Coursera吴恩达《神经网络与深度学习》课程笔记（4）-- 浅层神经网络

个人总结一下：

1.首先由逻辑回归引申出浅层神经网络，即浅层神经网络只是比逻辑回归多了一层，相当于重复计算；从左到右，先计算输入到隐藏，在计算隐藏到输出；从右到左，先计算输出到隐藏，在计算隐藏到输入；

2.神经网络的表达，浅层神经网络，也叫做两层神经网络，因为有隐藏层和输出层；

3.计算神经网络输出，相当于重复计算z和a，对于每个节点都尽心；

4.向量化

5.没有

6.激活函数：前面介绍的是sigmod，但是不只有这一个。tanh会比sigmod好一些，因为自带归一化，但是都存在梯度消失的问题，因此引入relu，通常涉及分类问题，最后一层使用sigmod。

7.每一个节点一定得带着非线性激活，否则就是简单的逻辑回归，或者线性回归

8.计算梯度的问题

9。初始化，对于W不可以使用0进行初始化，因为对称性，什么也学不出来；一定要打破对称性。常见的是随机值 * 0.1，主要是让z落在0附近，这样就会有大的梯度，便于学习。当然b可以初始化为0，不影响学习。

 

 

hts://blog.csdn.net/red_stone1/article/details/78018269

上节课我们主要介绍了向量化、矩阵计算的方法和python编程的相关技巧。并以逻辑回归为例，将其算法流程包括梯度下降转换为向量化的形式，从而大大提高了程序运算速度。本节课我们将从浅层神经网络入手，开始真正的神经网络模型的学习。

1. Neural Networks Overview

首先，我们从整体结构上来大致看一下神经网络模型。

前面的课程中，我们已经使用计算图的方式介绍了逻辑回归梯度下降算法的正向传播和反向传播两个过程。如下图所示。神经网络的结构与逻辑回归类似，只是神经网络的层数比逻辑回归多一层，多出来的中间那层称为隐藏层或中间层。这样从计算上来说，神经网络的正向传播和反向传播过程只是比逻辑回归多了一次重复的计算。正向传播过程分成两层，第一层是输入层到隐藏层，用上标[1]来表示：

 

z[1]=W[1]x+b[1]z[1]=W[1]x+b[1]

 

 

a[1]=σ(z[1])a[1]=σ(z[1])

 

第二层是隐藏层到输出层，用上标[2]来表示：

 

z[2]=W[2]a[1]+b[2]z[2]=W[2]a[1]+b[2]

 

 

a[2]=σ(z[2])a[2]=σ(z[2])

 

在写法上值得注意的是，方括号上标[i]表示当前所处的层数；圆括号上标(i)表示第i个样本。

同样，反向传播过程也分成两层。第一层是输出层到隐藏层，第二层是隐藏层到输入层。其细节部分我们之后再来讨论。

2. Neural Network Representation

下面我们以图示的方式来介绍单隐藏层的神经网络结构。如下图所示，单隐藏层神经网络就是典型的浅层（shallow）神经网络。

结构上，从左到右，可以分成三层：输入层（Input layer），隐藏层（Hidden layer）和输出层（Output layer）。输入层和输出层，顾名思义，对应着训练样本的输入和输出，很好理解。隐藏层是抽象的非线性的中间层，这也是其被命名为隐藏层的原因。

在写法上，我们通常把输入矩阵X记为a[0]a[0]，把隐藏层输出记为a[1]a[1]，上标从0开始。用下标表示第几个神经元，注意下标从1开始。例如a[1]1a1[1]表示隐藏层第1个神经元，a[1]2a2[1]表示隐藏层第2个神经元,，等等。这样，隐藏层有4个神经元就可以将其输出a[1]a[1]写成矩阵的形式：

 

a[1]=⎡⎣⎢⎢⎢⎢⎢⎢a[1]1a[1]2a[1]3a[1]4⎤⎦⎥⎥⎥⎥⎥⎥a[1]=[a1[1]a2[1]a3[1]a4[1]]

 

最后，相应的输出层记为a[2]a[2]，即y^y^。这种单隐藏层神经网络也被称为两层神经网络（2 layer NN）。之所以叫两层神经网络是因为，通常我们只会计算隐藏层输出和输出层的输出，输入层是不用计算的。这也是我们把输入层层数上标记为0的原因（a[0]a[0]）。

关于隐藏层对应的权重W[1]W[1]和常数项b[1]b[1]，W[1]W[1]的维度是（4,3）。这里的4对应着隐藏层神经元个数，3对应着输入层x特征向量包含元素个数。常数项b[1]b[1]的维度是（4,1），这里的4同样对应着隐藏层神经元个数。关于输出层对应的权重W[2]W[2]和常数项b[2]b[2]，W[2]W[2]的维度是（1,4），这里的1对应着输出层神经元个数，4对应着输出层神经元个数。常数项b[2]b[2]的维度是（1,1），因为输出只有一个神经元。总结一下，第i层的权重W[i]W[i]维度的行等于i层神经元的个数，列等于i-1层神经元的个数；第i层常数项b[i]b[i]维度的行等于i层神经元的个数，列始终为1。（？？？？？？？？？？？？？？？？？）

3. Computing a Neural Network’s Output

接下来我们开始详细推导神经网络的计算过程。回顾一下，我们前面讲过两层神经网络可以看成是逻辑回归再重复计算一次。如下图所示，逻辑回归的正向计算可以分解成计算z和a的两部分：

 

z=wTx+bz=wTx+b

 

 

a=σ(z)a=σ(z)

 

对于两层神经网络，从输入层到隐藏层对应一次逻辑回归运算；从隐藏层到输出层对应一次逻辑回归运算。每层计算时，要注意对应的上标和下标，一般我们记上标方括号表示layer，下标表示第几个神经元。例如a[l]iai[l]表示第l层的第i个神经元。注意，i从1开始，l从0开始。

下面，我们将从输入层到输出层的计算公式列出来：（此处W的维度为（1， x的维度））

 

z[1]1=w[1]T1x+b[1]1, a[1]1=σ(z[1]1)z1[1]=w1[1]Tx+b1[1], a1[1]=σ(z1[1])

 

 

z[1]2=w[1]T2x+b[1]2, a[1]2=σ(z[1]2)z2[1]=w2[1]Tx+b2[1], a2[1]=σ(z2[1])

 

 

z[1]3=w[1]T3x+b[1]3, a[1]3=σ(z[1]3)z3[1]=w3[1]Tx+b3[1], a3[1]=σ(z3[1])

 

 

z[1]4=w[1]T4x+b[1]4, a[1]4=σ(z[1]4)z4[1]=w4[1]Tx+b4[1], a4[1]=σ(z4[1])

 

然后，从隐藏层到输出层的计算公式为：

 

z[2]1=w[2]T1a[1]+b[2]1, a[2]1=σ(z[2]1)z1[2]=w1[2]Ta[1]+b1[2], a1[2]=σ(z1[2])

 

其中a[1]a[1]为：

 

a[1]=⎡⎣⎢⎢⎢⎢⎢⎢a[1]1a[1]2a[1]3a[1]4⎤⎦⎥⎥⎥⎥⎥⎥a[1]=[a1[1]a2[1]a3[1]a4[1]]

 

上述每个节点的计算都对应着一次逻辑运算的过程，分别由计算z和a两部分组成。

为了提高程序运算速度，我们引入向量化和矩阵运算的思想，将上述表达式转换成矩阵运算的形式：

 

z[1]=W[1]x+b[1]z[1]=W[1]x+b[1]

 

 

a[1]=σ(z[1])a[1]=σ(z[1])

 

 

z[2]=W[2]a[1]+b[2]z[2]=W[2]a[1]+b[2]

 

 

a[2]=σ(z[2])a[2]=σ(z[2])

 

之前也介绍过，这里顺便提一下，W[1]W[1]的维度是（4,3），b[1]b[1]的维度是（4,1），W[2]W[2]的维度是（1,4），b[2]b[2]的维度是（1,1）。这点需要特别注意。

4. Vectorizing across multiple examples

上一部分我们只是介绍了单个样本的神经网络正向传播矩阵运算过程。而对于m个训练样本，我们也可以使用矩阵相乘的形式来提高计算效率。而且它的形式与上一部分单个样本的矩阵运算十分相似，比较简单。

之前我们也介绍过，在书写标记上用上标(i)表示第i个样本，例如x(i)x(i)，z(i)z(i)，a[2](i)a[2](i)。对于每个样本i，可以使用for循环来求解其正向输出：

for i = 1 to m: 
    z[1](i)=W[1]x(i)+b[1]    z[1](i)=W[1]x(i)+b[1] 
    a[1](i)=σ(z[1](i))    a[1](i)=σ(z[1](i)) 
    z[2](i)=W[2]a[1](i)+b[2]    z[2](i)=W[2]a[1](i)+b[2] 
    a[2](i)=σ(z[2](i))    a[2](i)=σ(z[2](i))

不使用for循环，利用矩阵运算的思想，输入矩阵X的维度为（nxnx,m）。这样，我们可以把上面的for循环写成矩阵运算的形式：

 

Z[1]=W[1]X+b[1]Z[1]=W[1]X+b[1]

 

 

A[1]=σ(Z[1])A[1]=σ(Z[1])

 

 

Z[2]=W[2]A[1]+b[2]Z[2]=W[2]A[1]+b[2]

 

 

A[2]=σ(Z[2])A[2]=σ(Z[2])

 

其中，Z[1]Z[1]的维度是（4,m），4是隐藏层神经元的个数；A[1]A[1]的维度与Z[1]Z[1]相同；Z[2]Z[2]和A[2]A[2]的维度均为（1,m）。对上面这四个矩阵来说，均可以这样来理解：行表示神经元个数，列表示样本数目m。

5. Explanation for Vectorized Implementation

这部分Andrew用图示的方式解释了m个样本的神经网络矩阵运算过程。其实内容比较简单，只要记住上述四个矩阵的行表示神经元个数，列表示样本数目m就行了。

值得注意的是输入矩阵X也可以写成A[0]A[0]。

6. Activation functions

神经网络隐藏层和输出层都需要激活函数（activation function），在之前的课程中我们都默认使用Sigmoid函数σ(x)σ(x)作为激活函数。其实，还有其它激活函数可供使用，不同的激活函数有各自的优点。下面我们就来介绍几个不同的激活函数g(x)g(x)。

• sigmoid函数

• tanh函数

• ReLU函数

• Leaky ReLU函数

如上图所示，不同激活函数形状不同，a的取值范围也有差异。

如何选择合适的激活函数呢？首先我们来比较sigmoid函数和tanh函数。对于隐藏层的激活函数，一般来说，tanh函数要比sigmoid函数表现更好一些。因为tanh函数的取值范围在[-1,+1]之间，隐藏层的输出被限定在[-1,+1]之间，可以看成是在0值附近分布，均值为0。这样从隐藏层到输出层，数据起到了归一化（均值为0）的效果。因此，隐藏层的激活函数，tanh比sigmoid更好一些。而对于输出层的激活函数，因为二分类问题的输出取值为{0,+1}，所以一般会选择sigmoid作为激活函数。

观察sigmoid函数和tanh函数，我们发现有这样一个问题，就是当|z|很大的时候，激活函数的斜率（梯度）很小。因此，在这个区域内，梯度下降算法会运行得比较慢。在实际应用中，应尽量避免使z落在这个区域，使|z|尽可能限定在零值附近，从而提高梯度下降算法运算速度。

为了弥补sigmoid函数和tanh函数的这个缺陷，就出现了ReLU激活函数。ReLU激活函数在z大于零时梯度始终为1；在z小于零时梯度始终为0；z等于零时的梯度可以当成1也可以当成0，实际应用中并不影响。对于隐藏层，选择ReLU作为激活函数能够保证z大于零时梯度始终为1，从而提高神经网络梯度下降算法运算速度。但当z小于零时，存在梯度为0的缺点，实际应用中，这个缺点影响不是很大。为了弥补这个缺点，出现了Leaky ReLU激活函数，能够保证z小于零是梯度不为0。

最后总结一下，如果是分类问题，输出层的激活函数一般会选择sigmoid函数。但是隐藏层的激活函数通常不会选择sigmoid函数，tanh函数的表现会比sigmoid函数好一些。实际应用中，通常会会选择使用ReLU或者Leaky ReLU函数，保证梯度下降速度不会太小。其实，具体选择哪个函数作为激活函数没有一个固定的准确的答案，应该要根据具体实际问题进行验证（validation）。

7. Why do you need non-linear activation functions

我们知道上一部分讲的四种激活函数都是非线性（non-linear）的。那是否可以使用线性激活函数呢？答案是不行！下面我们就来进行简要的解释和说明。

假设所有的激活函数都是线性的，为了简化计算，我们直接令激活函数g(z)=zg(z)=z，即a=za=z。那么，浅层神经网络的各层输出为：

 

z[1]=W[1]x+b[1]z[1]=W[1]x+b[1]

 

 

a[1]=z[1]a[1]=z[1]

 

 

z[2]=W[2]a[1]+b[2]z[2]=W[2]a[1]+b[2]

 

 

a[2]=z[2]a[2]=z[2]

 

我们对上式中a[2]a[2]进行化简计算：

 

a[2]=z[2]=W[2]a[1]+b[2]=W[2](W[1]x+b[1])+b[2]=(W[2]W[1])x+(W[2]b[1]+b[2])=W′x+b′a[2]=z[2]=W[2]a[1]+b[2]=W[2](W[1]x+b[1])+b[2]=(W[2]W[1])x+(W[2]b[1]+b[2])=W′x+b′

 

经过推导我们发现a[2]a[2]仍是输入变量x的线性组合。这表明，使用神经网络与直接使用线性模型的效果并没有什么两样。即便是包含多层隐藏层的神经网络，如果使用线性函数作为激活函数，最终的输出仍然是输入x的线性模型。这样的话神经网络就没有任何作用了。因此，隐藏层的激活函数必须要是非线性的。

另外，如果所有的隐藏层全部使用线性激活函数，只有输出层使用非线性激活函数，那么整个神经网络的结构就类似于一个简单的逻辑回归模型，而失去了神经网络模型本身的优势和价值。

值得一提的是，如果是预测问题而不是分类问题，输出y是连续的情况下，输出层的激活函数可以使用线性函数。如果输出y恒为正值，则也可以使用ReLU激活函数，具体情况，具体分析。

8. Derivatives of activation functions

在梯度下降反向计算过程中少不了计算激活函数的导数即梯度。

我们先来看一下sigmoid函数的导数：

 

g(z)=11+e(−z)g(z)=11+e(−z)

 

 

g′(z)=ddzg(z)=g(z)(1−g(z))=a(1−a)g′(z)=ddzg(z)=g(z)(1−g(z))=a(1−a)

 

对于tanh函数的导数：

 

g(z)=e(z)−e(−z)e(z)+e(−z)g(z)=e(z)−e(−z)e(z)+e(−z)

 

 

g′(z)=ddzg(z)=1−(g(z))2=1−a2g′(z)=ddzg(z)=1−(g(z))2=1−a2

 

对于ReLU函数的导数：

 

g(z)=max(0,z)g(z)=max(0,z)

 

 

g′(z)={0,1,z<0z≥0g′(z)={0,z<01,z≥0

 

对于Leaky ReLU函数：

 

g(z)=max(0.01z,z)g(z)=max(0.01z,z)

 

 

g′(z)={0.01,1,z<0z≥0g′(z)={0.01,z<01,z≥0

 

9. Gradient descent for neural networks

接下来看一下在神经网络中如何进行梯度计算。

仍然是浅层神经网络，包含的参数为W[1]W[1]，b[1]b[1]，W[2]W[2]，b[2]b[2]。令输入层的特征向量个数nx=n[0]nx=n[0]，隐藏层神经元个数为n[1]n[1]，输出层神经元个数为n[2]=1n[2]=1。则W[1]W[1]的维度为（n[1]n[1],n[0]n[0]），b[1]b[1]的维度为（n[1]n[1],1），W[2]W[2]的维度为（n[2]n[2],n[1]n[1]），b[2]b[2]的维度为（n[2]n[2],1）。

该神经网络正向传播过程为：

 

Z[1]=W[1]X+b[1]Z[1]=W[1]X+b[1]

 

 

A[1]=g(Z[1])A[1]=g(Z[1])

 

 

Z[2]=W[2]A[1]+b[2]Z[2]=W[2]A[1]+b[2]

 

 

A[2]=g(Z[2])A[2]=g(Z[2])

 

其中，g(⋅)g(⋅)表示激活函数。

反向传播是计算导数（梯度）的过程，这里先列出来Cost function对各个参数的梯度：

 

dZ[2]=A[2]−YdZ[2]=A[2]−Y

 

 

dW[2]=1mdZ[2]A[1]TdW[2]=1mdZ[2]A[1]T

 

 

db[2]=1mnp.sum(dZ[2],axis=1,keepdim=True)db[2]=1mnp.sum(dZ[2],axis=1,keepdim=True)

 

 

dZ[1]=W[2]TdZ[2]∗g′(Z[1])dZ[1]=W[2]TdZ[2]∗g′(Z[1])

 

 

dW[1]=1mdZ[1]XTdW[1]=1mdZ[1]XT

 

 

db[1]=1mnp.sum(dZ[1],axis=1,keepdim=True)db[1]=1mnp.sum(dZ[1],axis=1,keepdim=True)

 

反向传播的具体推导过程我们下一部分再进行详细说明。

10. Backpropagation intuition(optional)

我们仍然使用计算图的方式来推导神经网络反向传播过程。记得之前介绍逻辑回归时，我们就引入了计算图来推导正向传播和反向传播，其过程如下图所示：

由于多了一个隐藏层，神经网络的计算图要比逻辑回归的复杂一些，如下图所示。对于单个训练样本，正向过程很容易，反向过程可以根据梯度计算方法逐一推导。

 

dz[2]=a[2]−ydz[2]=a[2]−y

 

 

dW[2]=dz[2]⋅∂z[2]∂W[2]=dz[2]a[1]TdW[2]=dz[2]⋅∂z[2]∂W[2]=dz[2]a[1]T

 

 

db[2]=dz[2]⋅∂z[2]∂b[2]=dz[2]⋅1=dz[2]db[2]=dz[2]⋅∂z[2]∂b[2]=dz[2]⋅1=dz[2]

 

 

dz[1]=dz[2]⋅∂z[2]∂a[1]⋅∂a[1]∂z[1]=W[2]Tdz[2]∗g[1]′(z[1])dz[1]=dz[2]⋅∂z[2]∂a[1]⋅∂a[1]∂z[1]=W[2]Tdz[2]∗g[1]′(z[1])

 

 

dW[1]=dz[1]⋅∂z[1]∂W[1]=dz[1]xTdW[1]=dz[1]⋅∂z[1]∂W[1]=dz[1]xT

 

 

db[1]=dz[1]⋅∂z[1]∂b[1]=dz[1]⋅1=dz[1]db[1]=dz[1]⋅∂z[1]∂b[1]=dz[1]⋅1=dz[1]

 

总结一下，浅层神经网络（包含一个隐藏层），m个训练样本的正向传播过程和反向传播过程分别包含了6个表达式，其向量化矩阵形式如下图所示：

11. Random Initialization

神经网络模型中的参数权重W是不能全部初始化为零的，接下来我们分析一下原因。

举个简单的例子，一个浅层神经网络包含两个输入，隐藏层包含两个神经元。如果权重W[1]W[1]和W[2]W[2]都初始化为零，即：

 

W[1]=[0000]W[1]=[0000]

 

 

W[2]=[00]W[2]=[00]

 

这样使得隐藏层第一个神经元的输出等于第二个神经元的输出，即a[1]1=a[1]2a1[1]=a2[1]。经过推导得到dz[1]1=dz[1]2dz1[1]=dz2[1]，以及dW[1]1=dW[1]2dW1[1]=dW2[1]。因此，这样的结果是隐藏层两个神经元对应的权重行向量W[1]1W1[1]和W[1]2W2[1]每次迭代更新都会得到完全相同的结果，W[1]1W1[1]始终等于W[1]2W2[1]，完全对称。这样隐藏层设置多个神经元就没有任何意义了。值得一提的是，参数b可以全部初始化为零，并不会影响神经网络训练效果。

我们把这种权重W全部初始化为零带来的问题称为symmetry breaking problem。解决方法也很简单，就是将W进行随机初始化（b可初始化为零）。python里可以使用如下语句进行W和b的初始化：

W_1 = np.random.randn((2,2))*0.01
b_1 = np.zero((2,1))
W_2 = np.random.randn((1,2))*0.01
b_2 = 0

• 1
• 2
• 3
• 4

这里我们将W[1]1W1[1]和W[1]2W2[1]乘以0.01的目的是尽量使得权重W初始化比较小的值。之所以让W比较小，是因为如果使用sigmoid函数或者tanh函数作为激活函数的话，W比较小，得到的|z|也比较小（靠近零点），而零点区域的梯度比较大，这样能大大提高梯度下降算法的更新速度，尽快找到全局最优解。如果W较大，得到的|z|也比较大，附近曲线平缓，梯度较小，训练过程会慢很多。

当然，如果激活函数是ReLU或者Leaky ReLU函数，则不需要考虑这个问题。但是，如果输出层是sigmoid函数，则对应的权重W最好初始化到比较小的值。

12. Summary

本节课主要介绍了浅层神经网络。首先，我们简单概述了神经网络的结构：包括输入层，隐藏层和输出层。然后，我们以计算图的方式推导了神经网络的正向输出，并以向量化的形式归纳出来。接着，介绍了不同的激活函数并做了比较，实际应用中根据不同需要选择合适的激活函数。激活函数必须是非线性的，不然神经网络模型起不了任何作用。然后，我们重点介绍了神经网络的反向传播过程以及各个参数的导数推导，并以矩阵形式表示出来。最后，介绍了权重随机初始化的重要性，必须对权重W进行随机初始化操作。

更多AI资源请关注公众号：红色石头的机器学习之路（ID：redstonewill）