课程名称：深层神经网络中的前向传播
学习时间：2019年7月31日
课程要点：

• 向量化的前向传播计算方法

首先我们来看看单一样本的情况：

当然，我们都希望能有一个向量化的版本，能够一次性计算所有样本值，那么下面就来一起看看吧

大家不要被深度神经网络的“深度”给吓到了，对于今天的课程笔记：深度神经网络的前向传播，它真的和浅层神经网络非常类似，只不过是重复几遍罢了

深度神经网络

符号

l：层数
l = 4
n^[l]:每一次的单元数
n^[1] = 5 n^[2] = 5 n^[3] = 3 n^[4] = 1
a^[l]:每一次的激活函数
a^[l] = g^[l](z^[l])
w^[l]:每一次的权值
b^[l]:每一次的偏置

前向传播

x
z^[1] = w^[1]x + b^[1]
a^[1] = g^[1](z^[1])
z^[2] = w^[2]a^[1] + b^[2]
a^[2] = g^[2](z^[2])
z^[3] = w^[3]a^[2] + b^[3]
a^[3] = g^[3](z^[3])
z^[4] = w^[4]a^[3] + b^[4]
a^[4] = g^[4](z^[4])

for l =1 to 4
    z^[l] = w^[l]a^[l-1] + b^[l]
    a^[l] = g^[l](z^[l])

#m个样本向量化
Z^[1] = W^[1]A^[0] + b^[1]      #  X=A^[0]
A^[1] = g^[1](Z^[1])
Z^[2] = W^[2]A^[1]+ b^[2]
A^[2] = g^[2](z^[2])
Z^[3] = W^[3]A^[2] + b^[3]
A^[3] = g^[3](Z^[3])
Z^[4] = W^[4]A^[3] + b^[4]
A^[4] = g^[4](Z^[4])

for l = 1 to 4
	    Z^[l] = w^[l]A^[l-1] + b^[l]
	    A^[l] = g^[l](Z^[l])

矩阵维度

n^[0] = 2
n^[1] = 3
n^[2] = 5
n^[3] = 4
n^[4] = 2
n^[4] = 1
z^[1]        =      w^[1]               x            +        b^[1]
(3,1)               (3,2)             (2,1)                   (3,1)
(n^[1],1)        (n^[1],n^[0])       (n^[0],1)              (n^[1],1)
a^[1] = g^[1](z^[1])
(3,1)         (3,1)
(n^[1],1)   (n^[1],1)
z^[2]        =      w^[2]             a^[1]             +     b^[1]
(5,1)               (5,3)             (3,1)                   (5,1)
(n^[2],1)        (n^[2],n^[1])       (n^[1],1)              (n^[2],1)
a^[2] = g^[2](z^[2])
(5,1)         (5,1) 
(n^[2],1)   (n^[2],1)  
z^[3]        =      w^[3]             a^[2]             +     b^[3]
(4,1)               (4,5)             (5,1)                   (4,1)
(n^[3],1)        (n^[3],n^[2])       (n^[2],1)              (n^[3],1)
a^[3] = g^[3](z^[3])
(4,1)         (4,1)  
(n^[3],1)   (n^[3],1)  
z^[4]        =      w^[4]             a^[3]             +     b^[4]
(2,1)               (2,4)             (4,1)                   (2,1)
(n^[4],1)        (n^[4],n^[3])       (n^[3],1)              (n^[4],1)
a^[4] = g^[4](z^[4])
(2,1)         (2,1)        
(n^[4],1)    (n^[4],1)    
z^[5]        =      w^[5]             a^[4]             +     b^[5]
(1,1)               (1,2)             (2,1)                   (1,1)
(n^[5],1)        (n^[5],n^[4])       (n^[4],1)              (n^[5],1)
a^[5] = g^[5](z^[5])
(1,1)         (1,1)        
(n^[5],1)    (n^[5],1)    

for l = 1 to 5
	    z^[l]     =   w^[l]            a^[l-1]         +       b^[l]
	    (n^[l],1)    (n^[l],n^[l-1])  (n^[l-1],1)            (n^[l],1)
	    a^[l] = g^[l](z^[l])
	    (n^[l],1)    (n^[l],1) 

m个样本

Z^[1]        =      W^[1]               X            +        b^[1]
(3,m)               (3,2)             (2,m)                   (3,1)
(n^[1],m)        (n^[1],n^[0])       (n^[0],m)              (n^[1],1)
A^[1] = g^[1](Z^[1])
(3,m)         (3,m)
(n^[1],m)   (n^[1],m)
Z^[2]        =      W^[2]             A^[1]             +     b^[1]
(5,m)               (5,3)             (3,m)                   (5,1)
(n^[2],m)        (n^[2],n^[1])       (n^[1],m)              (n^[2],1)
A^[2] = g^[2](Z^[2])
(5,m)         (5,m) 
(n^[2],m)   (n^[2],m)  
Z^[3]        =      W^[3]             A^[2]             +     b^[3]
(4,m)               (4,5)             (5,m)                   (4,1)
(n^[3],m)        (n^[3],n^[2])       (n^[2],m)              (n^[3],1)
A^[3] = g^[3](Z^[3])
(4,m)         (4,m)  
(n^[3],m)   (n^[3],m)  
Z^[4]        =      W^[4]             A^[3]             +     b^[4]
(2,m)               (2,4)             (4,m)                   (2,1)
(n^[4],m)        (n^[4],n^[3])       (n^[3],m)              (n^[4],1)
A^[4] = g^[4](Z^[4])
(2,m)         (2,m)        
(n^[4],m)    (n^[4],m)    
Z^[5]        =      W^[5]             A^[4]             +     b^[5]
(1,m)               (1,2)             (2,m)                   (1,1)
(n^[5],m)        (n^[5],n^[4])       (n^[4],m)              (n^[5],1)
A^[5] = g^[5](Z^[5])
(1,m)         (1,m)        
(n^[5],m)    (n^[5],m)    

for l = 1 to 4
	    Z^[l]    =    w^[l]              A^[l-1]   +     b^[l]
	    (n^[l],m)    (n^[l],n^[l-1])   (n^[l-1],m)     (n^[l],1)
	    A^[l] = g^[l](Z^[l])
      (n^[l],m)     (n^[l],m)

为什么使用深层表示

深度神经网络有很多的隐层，较早的前几层能学习一些低层次的简单特征，后几层就能将简单的特征结合起来去探测更加复杂的东西

搭建深层神经网络块

第l层参数： w^[l],b^[l]
前向传播： 输入 a^[l-1] 输出 a^[l]  存储 z^[l]
					z^[l] = w^[l]a^[l-1] + b^[l]
					a^[l] = g^[l](z^[l])
反向传播： 输入 da^[l]   输出da^[l-1]  dw^[l] db^[l]
					前向传播存储的z^[l] 					
					

正向传播和反向传播

从a^[0]开始，也就是x，经过一系列正向传播计算得到yhat,之后再用输出值计算实现反向传播，得到所有的导数项，w，b也在每一层更新

编程细节:将z^[l],w^[l],b^[l]存储

前向和反向传播

前向传播

前向传播： 输入 a^[l-1] 输出 a^[l]  存储 z^[l]
					z^[l] = w^[l]a^[l-1] + b^[l]
					a^[l] = g^[l](z^[l])
		向量化：
					Z^[l] = W^[l]A^[l-1] + b^[l]
					A^[l] = g^[l](Z^[l])

反向传播

反向传播： 输入 da^[l]   输出da^[l-1]  dw^[l] db^[l]
					dz^[l] = da^[l]*g'^[l](z^[l])
					dw^[l] = dz^[l]a^[l-1]
					db^[l] = dz^[l]
					da^[l-1] = w^[l]Tdz^[l]
					dz^[l] = w^[l+1]Tdz^[l+1]*g'^[l](z^[l])
		向量化：
					dZ^[l] = dA^[l]*g'^[l](Z^[l])
					dW^[l] =(1/m)dZ^[l]A^[l-1]T
					db^[l] = (1/m)np.sum(dZ^[l],axis = 1,keepdims = True)
					dA^[l-1] = W^[l]TdZ^[l]
					dZ^[l] = W^[l+1]TdZ^[l+1]*g'^[l](Z^[l])

参数和超参数

参数： w^[1],b^[1],w^[2],b^[2]...
超参数：
			学习率：alpha
			循环下降法的迭代次数：iteration
			隐藏层数：l
			隐藏单元数：n^[1],n^[2]...
			激活函数：sigmoid ,relu, tanh
			

和大脑的关系

解决高方差high variance的方法有两种：

• 正则化
• 准备更多数据

其中常用的正则化分为：

• L2正则化
• dropout正则化

L2正则化

L2正则化的原理

对于正则化的解释可以看一下这个博客【通俗易懂】机器学习中 L1 和 L2 正则化的直观解释

机器学习中，如果参数过多，模型过于复杂，容易造成过拟合（overfit）。即模型在训练样本数据上表现的很好，但在实际测试样本上表现的较差，不具备良好的泛化能力。为了避免过拟合，最常用的一种方法是使用使用正则化。

正则化的作用会让参数不会过大，避免发生过拟合的风险。具体每个参数的值还是通过梯度下降优化得到。

正则化一般选用L2正则化，L2正则化有时候也被叫为“权重衰减weight decay”
L2正则化公式：


λ是一个需要调整的超参数。
正则项说明，不管w^[l]是什么，我们都试图让它变得更小。实际上相当于我们给矩阵W乘上了(1-αλ/m)倍的权重。
而该系数小于1，因此L2正则化也被成为“权重衰减”

L2正则化对不同权重的衰减是不同的，它取决于倍增的激活函数的大小（？？？）。

L2正则化避免过拟合overfitting（高方差high variance）

当λ很大的时候，w^[l]会约等于0，相当于一些隐藏单元不再起作用。这样一个复杂的神经网络就会得到化简（如下图所示）。

这样就会从左图所示的high variance(overfitting)向右图所示的high bias(underfitting)的方向发展（越来越接近逻辑回归 logistic regression），即减小variance。
但是λ会存在一个中间值，于是会有一个接近just right的中间状态。

最后我们借用tanh来直观感受下为什么正则化可以预防过拟合

当|z|较小时可以近似将激活函数tanh看作线性，当|z|较大时tanh为非线性。当λ较大时，w会较小，相应的使得z较小（z^[l] = w^[l] * A^[l-1] + b^[l]），从而对应到tanh的线性部分。这样每一层都可以近似视为线性。
而如果每层都是线性的，那么整个网络就是一个线性网络。这样的网络即使深度很大，由于其具有线性激活函数的特征，最终也只能计算线性函数。

dropout正则化（随机失活）

dropout的原理

dropout会遍历网络的每一层，并设置消除神经网络中节点的概率。
对于如下的神经网络，假设以0.5的概率dropout，则会有这样的结果：


即得到一个节点更少，规模更小的网络（实现对网络的精简）。

再往深里将，对于单个的神经元，can’t rely on any one feature, so have to spread out weights（我觉得这句话总结的十分到位）

这样dropout将产生收缩权重的平方范数效果。和前面的L2正则化类似，dropout的结果是它会压缩权重（shrinks the weight），并完成一些预防过拟合的外层正则化。

事实证明，dropout可以被正式地作为一种正则化的替代形式。

dropout的实现

反向随机失活（invert dropout）
（我觉得直接调用PyTorch的dropout()函数即可

不同层的保存概率keep prob也可以不同，对于可能出现过拟合（含有诸多参数）的层可以低一点，对于不太可能出现过拟合的层可以高一点。

另外切记，dropout是用来解决过拟合问题的。也就是说当不会出现过拟合的问题时，我们便不会使用dropout。

对dropout的使用主要再计算机视觉领域，因为我们通常没有组构的数据，所以一直存在过拟合。

dropout的一大缺点就是代价函数J不再被明确定义，因为过程是随机的，所以很难完全复现。

吴恩达老师说：“我通常会关闭dropout函数，将keep prob的值设为1，运行代码，确保函数J单调递减。然后再打开dropout函数，再dropout的过程中代码并未引入bug。”

其他正则化方法

假训练数据

吴恩达老师介绍了一种成本几乎为0的数据扩充方法。

对原有图片进行反转裁剪旋转等操作。但是需要注意的是，这样得到的训练集有冗余，并不如我们收集一组新图片效果好。
以这种方式扩增算法数据，进而正则化数据集来减少过拟合比较廉价。
像这种人工合成数据的话，我们要通过算法验证图片中的猫经过水平翻转后依旧是猫。

early stopping

同时绘制训练集和验证集的损失函数

在开始训练的时候W很小（初始化为一个很小的随机量），在迭代和训练过程中W的值会变得却来越大。
所以early stopping要做的就是在中间点停止迭代，从而得到一个W值中等大小的弗罗贝尼乌斯范数（？？？）

吴恩达老师也讲到了early stopping的一个缺点：
他认为机器学习包括几个步骤：

• 选择一个算法来说优化代价函数J
  • 梯度下降
  • Momentum
  • RMSprop
  • Adam
  • ……
• 避免过拟合
  • 正则化
  • 扩增数据
  • ……

在机器学习中，超级参数激增，选出可行的算法也变得越来越复杂。
吴恩达老师发现，如果我们用一组工具优化代价函数J，机器学习就会变得更简单。在重点优化代价函数J时，只需要留意w和b，J(w, b)的值越小越好，你只需要想办法减小这个值，其他的不用关注。
然后，预防过拟合还有其他任务，换句话说就是减小方差，这一步我们用另外一套工具来实现。
这个原理有时被成为“正交化”，思路就是在一个时间做一个任务。

对吴恩达老师来说，early stopping的主要缺点是：你不能独立地处理这两个问题。
因为提早停止梯度下降，也就是停止了优化代价函数J（因为现在你不再尝试降低代价函数J），同时你又不希望出现过拟合，你没有采用两个不同的方式来解决这两个问题，而是用一种方法同时解决两个问题（我的理解是：你仅仅使用early stopping这一个方式来解决“优化代价函数J”和“预防过拟合”这两个问题）。
这样做的结果是，我要考虑的事情变得很复杂。如果不用early stopping，另一种方法就是L2正则化，then you can just train the neural networks as long as possible。我发现，这导致超参数搜索空间更容易分解，也更容易搜索（the search space of hyper parameters easier to decompose, and easier to search over）。但缺点在于，你必须尝试很多正则化参数λ的值，这也导致搜索大量的λ值的计算代价太高。
early stopping的优点是只运行一次梯度下降，你可以找出W的较小值、中间值和较大值，而无需尝试L2正则化超参数λ的很多值。
虽然L2正则化有缺点，但还是有很多人愿意用它。我（吴恩达老师）个人更倾向于使用L2正则化，尝试许多不同的λ值（这基于你可以负担大量计算的代价）。而使用early stopping也能得到相似结果，还不用尝试这么λ值。