深入理解吴恩达深度学习（01神经网络和深度学习 第三周 单隐藏层神经网络）

1引言

    大家好，我是博主斌斌，一个27岁的java攻城狮，最近想转行人工智能，最近我发现了斯坦福大学吴恩达老师的深度学习微专业讲的特别好，不过可能还会有不少难以理解的地方。本人才疏学浅，想尽量将课程中的重要知识点用自己能够理解的方式记录下来，希望能够在帮助自己的同时也能够帮助别人。
    废话不多说了，这里给出免费的课程地址：

内容	链接
吴恩达深度学习	课程地址
深度学习上课内容	内容地址
深度学习课后作业	课后作业地址

第三周：浅层神经网络(Shallow neural networks)

3.1 神经网络概述（Neural Network Overview）

3.1.1 逻辑回归回顾

在描述神经网络之前，我们学习了逻辑回归，下面复习一下逻辑回归。
图3.1.1 :

公式3.1：
$$\begin{array}{l}x\\ w\\ b\end{array}\}⟹z=w^{T}x+b$$
如上所示，首先你需要输入特征$x$，参数$w$和$b$，通过这些你就可以计算出$z$，公式3.2：
$$\begin{gathered} \begin{array}{l}x\\ w\\ b\end{array}\}⟹z=w^{T}x+b⟹\alpha =\sigma (z) \\ ⟹L(a,y) \\ ⟹L\left(a,y\right)=-y\log (a)-(1-y)\log (1-a) \end{gathered}$$
接下来使用$z$就可以计算出$a$。我们将的符号换为表示输出$\hat{y}⟹a=\sigma (z)$,然后可以计算出loss function $L(a,y)$

3.1.2 神经网络介绍

神经网络看起来是如下这个样子（图3.1.2）。其中图中每一个节点（圆圈）表示上述的一个逻辑回归单元，如果我们的输出函数都使用sigmoid函数，那么可以看成神经网络就是多个sigmoid单元堆叠起来的网络。对于图3.1.1中的节点，它包含了之前讲的计算的两个步骤：首先通过公式3.1计算出值$z$，然后通过$\sigma (z)$计算值$a$。

符号说明：

1. $W^{[1]}$表示第一层神经网络的$W$系数矩阵数值。
2. $W_1^{[1]}$表示第一层神经网络的第一个逻辑回归单元的$W$系数矩阵数值。
3. 同理， $b^{[2]}$表示第二层神经网络的$b$系数矩阵数值。

那么我们从$X$输入矩阵计算出$\hat{y}$的过程（前向传播过程）可以描述如下：
1.先计算第一层的输出结果：
$$\begin{array}{r}x\\ W^{[1]}\\ b^{[1]}\end{array}\}⟹z^{[1]}=W^{[1]}x+b^{[1]}⟹a^{[1]}=\sigma (z^{[1]})公式3.4：$$
2.再使用第一层的输出结果$\sigma (z^{[1]})$作为第二层的输入,再计算第二层的输出结果：
$$\begin{array}{r}\text{a[1]=σ(z[1])}\\ \text{W[2]}\\ \text{b[2]}\end{array}\}⟹z^{[2]}=W^{[2]}{a}^{[1]}+b^{[2]}⟹a^{[2]}=\sigma (z^{[2]})$$
3.再使用第二层的输出结果$\sigma (z^{[2]})$计算出损失函数:
这里$\sigma (z^{[2]})=a^{[2]}$
$$⟹L\left(a^{[2]},y\right)$$
$$⟹L\left(a^{[2]},y\right)=-y\log (a^{[2]})-(1-y)\log (1-a^{[2]})$$

3.2 神经网络的表示（Neural Network Representation）

这是一张神经网络的图片，让我们给此图的不同部分取一些名字：
1.输入层：将特征转换为输入矩阵$X$。
    功能：将输入特征$x_1$、$x_2$、$x_3$，转换为列向量$[x_1，x_2，x_3{]}^T$，然后输入下一层进行计算。
2.隐藏层：图中第一层的神经网络单元组成。
    由于从输入端看进去看见输入层，从输出端看进去只能看见模型的输出层，因此第一层是不可见的，我们称之为隐藏层。
    功能：计算出第一层的输出给下一层作为输入。
$$\begin{array}{r}x\\ W^{[1]}\\ b^{[1]}\end{array}\}⟹z^{[1]}=W^{[1]}x+b^{[1]}⟹a^{[1]}=\sigma (z^{[1]})$$
    
3.输出层：再次进行逻辑回归运算，给出输出结果。
    功能：计算最终结果，过程如下：
$$\begin{array}{r}\text{a[1]=σ(z[1])}\\ \text{W[2]}\\ \text{b[2]}\end{array}\}⟹z^{[2]}=W^{[2]}{a}^{[1]}+b^{[2]}⟹a^{[2]}=\sigma (z^{[2]})$$
    

现在我们再引入几个符号，就像我们之前用向量$x$表示输入特征。这里有个可代替的记号$a^{[0]}$可以用来表示输入特征。$a$表示激活的意思，它意味着网络中不同层的值会传递到它们后面的层中，输入层将$x$传递给隐藏层，所以我们将输入层的激活值称为$a^{[0]}$；下一层即隐藏层也同样会产生一些激活值，那么我将其记作$a^{[1]}$，所以具体地，这里的第一个单元或结点我们将其表示为$a_1^{[1]}$，第二个结点的值我们记为$a_2^{[1]}$以此类推。所以这里的是一个四维的向量如果写成Python代码，那么它是一个规模为4x1的矩阵或一个大小为4的列向量，如下公式，它是四维的，因为在本例中，我们有四个结点或者单元，或者称为四个隐藏层单元；
公式3.7
$$a^{[1]}=\left[\begin{array}{c}{a}_1^{[1]}\\ a_2^{[1]}\\ a_3^{[1]}\\ a_4^{[1]}\end{array}\right]$$
最后输出层将产生某个数值$a$，它只是一个单独的实数，所以的$\hat{y}$值将取为$a^{[2]}$

3.3 计算一个神经网络的输出（Computing a Neural Network’s output）

图3.3.1

其中，$x$表示输入特征，$a$表示每个神经元的输出，$W$表示特征的权重，上标表示神经网络的层数（隐藏层为1），下标表示该层的第几个神经元。这是神经网络的符号惯例，下同。

神经网络的计算

关于神经网络是怎么计算的，从我们之前提及的逻辑回归开始，如下图所示。用圆圈表示神经网络的计算单元，逻辑回归的计算有两个步骤，首先你按步骤计算出$z$，然后在第二步中你以sigmoid函数为激活函数计算$z$（得出$a$），一个神经网络只是这样子做了好多次重复计算。

图3.3.2

回到两层的神经网络，我们从隐藏层的第一个神经元开始计算，如上图第一个最上面的箭头所指。从上图可以看出，输入与逻辑回归相似，这个神经元的计算与逻辑回归一样分为两步，小圆圈代表了计算的两个步骤。

第一步，计算$z_1^{[1]},z_1^{[1]}=w_1^{[1]T}x+b_1^{[1]}$。

第二步，通过激活函数计算$a_1^{[1]},a_1^{[1]}=\sigma (z_1^{[1]})$。

隐藏层的第二个以及后面两个神经元的计算过程一样，只是注意符号表示不同，最终分别得到$a_2^{[1]}、a_3^{[1]}、a_4^{[1]}$，详细结果见下:

$z_1^{[1]}=w_1^{[1]T}x+b_1^{[1]},a_1^{[1]}=\sigma (z_1^{[1]})$

$z_2^{[1]}=w_2^{[1]T}x+b_2^{[1]},a_2^{[1]}=\sigma (z_2^{[1]})$

$z_3^{[1]}=w_3^{[1]T}x+b_3^{[1]},a_3^{[1]}=\sigma (z_3^{[1]})$

$z_4^{[1]}=w_4^{[1]T}x+b_4^{[1]},a_4^{[1]}=\sigma (z_4^{[1]})$

3.3.1 向量化计算

如果你执行神经网络的程序，用for循环来做这些看起来真的很低效。所以接下来我们要做的就是把这四个等式向量化。向量化的过程是将神经网络中的一层神经元参数纵向堆积起来，例如隐藏层中的$w$纵向堆积起来变成一个$(4,3)$的矩阵，用符号$W^{[1]}$表示。另一个看待这个的方法是我们有四个逻辑回归单元，且每一个逻辑回归单元都有相对应的参数——向量$w$，把这四个向量堆积在一起，你会得出这4×3的矩阵。

注：为什么是4*3的矩阵：可以这么想，我们有3个特征，并且有4个神经元。我们的目标是将每个特征输入到各个神经元中进行计算，我们将W进行纵向堆叠，$W^{T}x+b$是不可分的，因此b也是纵向堆叠，因为一个逻辑回归中b是一个常量，维度为1，b堆叠之后就是一个[4,1]的列向量。因此$W^{T}X$输出的行数也应该是4（这样才能跟b进行求和呀）, 所以根据矩阵乘法法则，$WX$应该是$4\ast 3\ast 3\ast m$ 的 形式，这里m表示样本数量。

总结：隐藏层理解如下：
W 维度：[当前层的神经元个数,每个样本的特征个数]
X 维度 : [每个样本的特征个数,样本数量]
b 维度 : [当前层的神经元个数，1]

第n层维度理解如下：
W维度：[当前层的神经元个数，当前层输入特征个数]
X维度 ：[当前层输入特征个数，样本数量m]
b维度 : [当前层的神经元个数，1]

从上边公式不难得出
$W^{[1]}$维度：[当前层的神经元个数，当前层输入特征个数]=[4,3]
$X^{[1]}$维度 ：[当前层输入特征个数，样本数量] = [3,1]
$b^{[1]}$维度 ：[当前层的神经元个数，1] = [4,1]

$W^{[2]}$维度：[当前层的神经元个数，当前层输入特征个数]=[1,4]
$X^{[2]}$维度 ：[当前层输入特征个数，样本数量] = [4,1]
$b^{[2]}$维度 ：[当前层的神经元个数，1] = [1,1]

因此，
公式3.8：
$z^{[n]}=w^{[n]}x+b^{[n]}$

公式3.9：

$a^{[n]}=\sigma (z^{[n]})$

详细过程见下:
公式3.10：
$$a^{[1]}=\left[\begin{array}{c}{a}_1^{[1]}\\ a_2^{[1]}\\ a_3^{[1]}\\ a_4^{[1]}\end{array}\right]=\sigma (z^{[1]})$$
公式3.11：
$$\left[\begin{array}{c}{z}_1^{[1]}\\ z_2^{[1]}\\ z_3^{[1]}\\ z_4^{[1]}\end{array}\right]=\stackrel{W^{[1]}}{\left[\begin{array}{c}...W_1^{[1]T}...\\ ...W_2^{[1]T}...\\ ...W_3^{[1]T}...\\ ...W_4^{[1]T}...\end{array}\right]}\ast \stackrel{input}{\left[\begin{array}{c}{x}_1\\ x_2\\ x_3\end{array}\right]}+\stackrel{b^{[1]}}{\left[\begin{array}{c}{b}_1^{[1]}\\ b_2^{[1]}\\ b_3^{[1]}\\ b_4^{[1]}\end{array}\right]}$$
对于神经网络的第一层，给予一个输入$x$，得到$a^{[1]}$，$x$可以表示为$a^{[0]}$。通过相似的衍生你会发现，后一层的表示同样可以写成类似的形式，得到$a^{[2]}$，$\hat{y}=a^{[2]}$，具体过程见公式3.8、3.9。

如上图左半部分所示为神经网络，把网络左边部分盖住先忽略，那么最后的输出单元就相当于一个逻辑回归的计算单元。当你有一个包含一层隐藏层的神经网络，你需要去实现以计算得到输出的是右边的四个等式，并且可以看成是一个向量化的计算过程，计算出隐藏层的四个逻辑回归单元和整个隐藏层的输出结果，如果编程实现需要的也只是这四行代码。

3.4 多样本向量化（Vectorizing across multiple examples）

从3.3中我们总结了如下维度规律：
第n层维度理解如下：
W维度：[当前层的神经元个数，当前层输入特征个数]
X维度 ：[当前层输入特征个数，样本数量]
b维度 : [当前层的神经元个数，1]

逻辑回归是将各个训练样本组合成矩阵，对矩阵的各列进行计算。神经网络是通过对逻辑回归中的等式简单的变形，让神经网络计算出输出值。这种计算是所有的训练样本同时进行的，以下是实现它具体的步骤：

图3.4.1

如果有一个非向量化形式的实现，而且要计算出它的预测值，对于所有训练样本，需要让$i$从1到$m$实现这四个等式：

$z^{[1](i)}=W^{[1](i)}{x}^{(i)}+b^{[1](i)}$

$a^{[1](i)}=\sigma (z^{[1](i)})$

$z^{[2](i)}=W^{[2](i)}{a}^{[1](i)}+b^{[2](i)}$

$a^{[2](i)}=\sigma (z^{[2](i)})$

对于上面的这个方程中的${}^{(i)}$，是所有依赖于训练样本的变量，即将$(i)$添加到$x$，$z$和$a$。如果想计算$m$个训练样本上的所有输出，就应该向量化整个计算，以简化这列。

接下来讲讲如何向量化这些数值：

1. 对于m个样本的输入集X:
   注：这里就是说输入层的作用，将输入特征$x_1$、$x_2$、$x_3$，转换为列向量$[x_1，x_2，x_3{]}^T$，然后输入下一层进行计算。只不过这里是将m个列向量$[x^{(1)},x^{(2)},\dots \dots x^{(m)}]$进行列堆叠。因此得到：
   公式3.12：
   $$x=\left[\begin{array}{cccc}⋮& ⋮& ⋮& ⋮\\ x^{(1)}& x^{(2)}& \cdots & x^{(m)}\\ ⋮& ⋮& ⋮& ⋮\end{array}\right]$$
   所以输入集X的维度是：[特征数量k，样本数量m]

2. 对于第一层的输出:
   注: 由矩阵的乘法 $Z^{[1]}=W^{[1]}X+b^{[1]}，z^{[1](1)}==W^{[1](1)}{x}^{(1)}+b^{[1](1)}$
   公式3.13：
   $$Z^{[1]}=\left[\begin{array}{cccc}⋮& ⋮& ⋮& ⋮\\ z^{[1](1)}& c& \cdots & z^{[1](m)}\\ ⋮& ⋮& ⋮& ⋮\end{array}\right]$$
   对于矩阵$Z$从水平方向上看，对应于不同的训练样本；竖直方向上，对应不同的输入特征，而这就是神经网络输入层中各个节点。
   所以输入集W的维度是：[当前层的神经元个数，当前层输入样本的个数]
   公式3.14：
   $$A^{[1]}=\left[\begin{array}{cccc}⋮& ⋮& ⋮& ⋮\\ {\alpha }^{[1](1)}& {\alpha }^{[1](2)}& \cdots & {\alpha }^{[1](m)}\\ ⋮& ⋮& ⋮& ⋮\end{array}\right]$$
   从水平上看，矩阵$A$代表了各个训练样本的输出。从竖直上看，矩阵$A$的不同的索引对应于不同的隐藏单元。

3. 同理，进行第二层向量化，我们得出第一，第二层的输出公式如下:
   公式3.15：
   $$\begin{array}{r}\text{z[1](i)=W[1](i)x(i)+b[1]}\\ \text{α[1](i)=σ(z[1](i))}\\ \text{z[2](i)=W[2](i)α[1](i)+b[2]}\\ \text{α[2](i)=σ(z[2](i))}\end{array}\}⟹\{\begin{array}{l}\text{A[1]=σ(z[1])}\\ \text{z[2]=W[2]A[1]+b[2]}\\ \text{A[2]=σ(z[2])}\end{array}$$

3.6 激活函数（Activation functions）

3.6.1 sigmoid函数

$$\sigma (z)=\frac{1}{{1+e}^{-z}}$$

激活函数	公式	导数
sigmoid	$\sigma (z)=\frac{1}{{1+e}^{-z}}$	$\sigma (z{)}^{{}^{\prime }}=\sigma (z)(1-\sigma (z))$

1. 优点： 中值为0.5适合做[0,1]范围内概率判断的函数，此时阈值为0.5。
2. 缺点： 当z特别大或者特别小时候，导数趋向0使得梯度下降缓慢导数趋向0使得梯度下降缓慢。

3.6.2 tanh函数

$$tanh(z)=\frac{e^z-e^{-z}}{e^z+e^{-z}}$$

激活函数	公式	导数
tanh	$tanh(z)=\frac{e^z-e^{-z}}{e^z+e^{-z}}$	$\tanh (z{)}^{{}^{\prime }}=1-tanh(z{)}^2$

1. 优点： 中值为0适合做[-1,1]值域范围内概率判断的函数,因此比较适合在隐藏层中使用。
2. 缺点： 当z特别大或者特别小时候，导数趋向0使得梯度下降缓慢导数趋向0使得梯度下降缓慢。
3. 求导过程：
   $$tanh(z)=\frac{e^z-e^{-z}}{e^z+e^{-z}}$$
   $$tanh(z{)}^{{}^{\prime }}=\frac{(e^z-e^{-z}{)}^{{}^{\prime }}(e^z+e^{-z})-(e^z-e^{-z})(e^z+e^{-z}{)}^{{}^{\prime }}}{(e^z+e^{-z}{)}^2}$$
   $$tanh(z{)}^{{}^{\prime }}=\frac{(e^z+e^{-z}{)}^2-(e^z-e^{-z})(e^z-e^{-z})}{(e^z+e^{-z}{)}^2}$$
   $$tanh(z{)}^{{}^{\prime }}=1-[\frac{(e^z-e^{-z})}{(e^z+e^{-z})}{]}^2$$
   $$tanh(z{)}^{{}^{\prime }}=1-tanh(z{)}^2$$

3.6.3 Relu函数(修正线性单元函数)

$$Relu(z)=max(0,z)$$

激活函数	公式	导数
Relu	$Relu(z)=max(0,z)$	$Relu(z{)}^{{}^{\prime }}=\{\begin{array}{l}1,z>0\\ 0,z<0\\ undefined,z=0\end{array}$

1. 优点： 具有线性的导数，求导简单，梯度下降法收敛速度快，因此比较适合在隐藏层和输出层中使用。
2. 缺点： 1.函数在x=0处时候不连续，无法求导，但是这里的0是严格的0实际上遇到这种情况可以使用特殊处理来解决。
               2.当x<0的时候，函数值直接为0，因此不适合在z的值域范围为[-inf，+inf]的输入值中使用。

3.6.5 Leaky Relu函数(弱修正线性单元函数)

$$LeakyRelu(z)=\{\begin{array}{l}0.01z,z>=0\\ z,z<0\end{array}$$

激活函数	公式	导数
Relu	$LeakyRelu(z)=max(0,z)$	$LeakyRelu(z{)}^{{}^{\prime }}=\{\begin{array}{l}1,z>0\\ 0.01,z<0\\ undefined,z=0\end{array}$

1. 优点： 具有线性的导数，求导简单，梯度下降法收敛速度快，因此比较适合在隐藏层中使用。
2. 缺点： 1.函数在x=0处时候不连续，无法求导，但是这里的0是严格的0实际上遇到这种情况可以使用特殊处理来解决。
               

所以通常的建议是：如果不确定哪一个激活函数效果更好，可以把它们都试试，然后在验证集或者发展集上进行评价。然后看哪一种表现的更好，就去使用它。

3.7 为什么需要非线性激活函数？（why need a nonlinear activation function?）

为什么神经网络需要非线性激活函数？事实证明：要让你的神经网络能够计算出有趣的函数，你必须使用非线性激活函数，证明如下：

这是神经网络正向传播的方程，现在我们去掉函数$g$，然后令$a^{[1]}=z^{[1]}$，或者我们也可以令$g(z)=z$，这个有时被叫做线性激活函数（更学术点的名字是恒等激励函数，因为它们就是把输入值输出）。为了说明问题我们把$a^{[2]}=z^{[2]}$，那么这个模型的输出$y$或仅仅只是输入特征$x$的线性组合。

如果我们改变前面的式子，令：
(1) $ a^{[1]} = z^{[1]} = W^{[1]}x + b^{[1]}$

(2) $a^{[2]}=z^{[2]}=W^{[2]}{a}^{[1]}+b^{[2]}$
将式子(1)代入式子(2)中，则：
$a^{[2]}=z^{[2]}=W^{[2]}(W^{[1]}x+b^{[1]})+b^{[2]}$

(3) $a^{[2]}=z^{[2]}=W^{[2]}{W}^{[1]}x+W^{[2]}{b}^{[1]}+b^{[2]}$
简化多项式得
$a^{[2]}=z^{[2]}=W^{{}^{\prime }}x+b^{{}^{\prime }}$
如果你是用线性激活函数或者叫恒等激励函数，那么神经网络只是把输入线性组合再输出。也就是说加入多少层的

我们稍后会谈到深度网络，有很多层的神经网络，很多隐藏层。事实证明，如果你使用线性激活函数或者没有使用一个激活函数，那么无论你的神经网络有多少层一直在做的只是计算线性函数，所以不如直接去掉全部隐藏层。在我们的简明案例中，事实证明如果你在隐藏层用线性激活函数，在输出层用sigmoid函数，那么这个模型的复杂度和没有任何隐藏层的标准Logistic回归是一样的，如果你愿意的话，可以证明一下。

在这里线性隐层一点用也没有，因为这两个线性函数的组合本身就是线性函数，所以除非你引入非线性，否则你无法计算更有趣的函数，即使你的网络层数再多也不行；只有一个地方可以使用线性激活函数------$g(z)=z$，就是你在做机器学习中的回归问题。$y$ 是一个实数，举个例子，比如你想预测房地产价格，$y$ 就不是二分类任务0或1，而是一个实数，从0到正无穷。如果$y$ 是个实数，那么在输出层用线性激活函数也许可行，你的输出也是一个实数，从负无穷到正无穷。

总而言之，不能在隐藏层用线性激活函数，可以用ReLU或者tanh或者leaky ReLU或者其他的非线性激活函数，唯一可以用线性激活函数的通常就是输出层；除了这种情况，会在隐层用线性函数的，除了一些特殊情况，比如与压缩有关的，那方面在这里将不深入讨论。在这之外，在隐层使用线性激活函数非常少见。因为房价都是非负数，所以我们也可以在输出层使用ReLU函数这样你的$\hat{y}$都大于等于0。

3.8 神经网络的梯度下降（Gradient descent for neural networks）

在这个视频中，我会给你实现反向传播或者说梯度下降算法的方程组，在下一个视频我们会介绍为什么这几个特定的方程是针对你的神经网络实现梯度下降的正确方程。

你的单隐层神经网络会有$W^{[1]}$，$b^{[1]}$，$W^{[2]}$，$b^{[2]}$这些参数，还有个$n_x$表示输入特征的个数，$n^{[1]}$表示隐藏单元个数，$n^{[2]}$表示输出单元个数。

在我们的例子中，我们只介绍过的这种情况，那么参数:

矩阵$W^{[1]}$的维度就是($n^{[1]},n^{[0]}$)，$b^{[1]}$就是$n^{[1]}$维向量，可以写成$(n^{[1]},1)$，就是一个的列向量。
矩阵$W^{[2]}$的维度就是($n^{[2]},n^{[1]}$)，$b^{[2]}$的维度就是$(n^{[2]},1)$维度。

你还有一个神经网络的成本函数，假设你在做二分类任务，那么你的成本函数等于：

Cost function:
公式：
$J(W^{[1]},b^{[1]},W^{[2]},b^{[2]})=\frac{1}{m}{\sum }_{i=1}^{m}L(\hat{y},y)$
loss function和之前做logistic回归完全一样。

训练参数需要做梯度下降，在训练神经网络的时候，随机初始化参数很重要，而不是初始化成全零。当你参数初始化成某些值后，每次梯度下降都会循环计算以下预测值：

${\hat{y}}^{(i)},(i=1,2,\dots ,m)$
公式3.28：
$d{W}^{[1]}=\frac{dJ}{d{W}^{[1]}},d{b}^{[1]}=\frac{dJ}{d{b}^{[1]}}$
公式3.29：
$d{W}^{[2]}=\frac{dJ}{d{W}^{[2]}},d{b}^{[2]}=\frac{dJ}{d{b}^{[2]}}$

其中

公式3.30：
$W^{[1]}⟹W^{[1]}-ad{W}^{[1]},b^{[1]}⟹b^{[1]}-ad{b}^{[1]}$

公式3.31：
$W^{[2]}⟹W^{[2]}-\alpha \mathrm{d}{W}^{[2]},b^{[2]}⟹b^{[2]}-\alpha \mathrm{d}{b}^{[2]}$
正向传播方程如下（之前讲过）：
forward propagation：
(1)
$z^{[1]}=W^{[1]}x+b^{[1]}$
(2)
$a^{[1]}=\sigma (z^{[1]})$
(3)
$z^{[2]}=W^{[2]}{a}^{[1]}+b^{[2]}$
(4)
$a^{[2]}=g^{[2]}(z^{[z]})=\sigma (z^{[2]})$

反向传播方程如下:

back propagation：
公式3.32：
$d{z}^{[2]}=A^{[2]}-Y,Y=\left[\begin{array}{cccc}{y}^{[1]}& y^{[2]}& \cdots & y^{[m]}\end{array}\right]$
公式3.33：
$dW^{[2]} = {\frac{1}{m}}dz^{[2]}A{[1]T} $
公式3.34：
$ {\rm d}b^{[2]} = {\frac{1}{m}}np.sum({d}z^{[2]},axis=1,keepdims=True)$
公式3.35：
$d{z}^{[1]}=\underset{(n^{[1]},m)}{W^{[2]T}\mathrm{d}{z}^{[2]}}\ast \underset{activationfunctionofhiddenlayer}{{g^{[1]}}^{{}^{\prime }}}\ast \underset{(n^{[1]},m)}{(z^{[1]})}$
公式3.36：
$d{W}^{[1]}=\frac{1}{m}d{z}^{[1]}{x}^T$
公式3.37：
$\underset{(n^{[1]},1)}{d{b}^{[1]}}=\frac{1}{m}np.sum(d{z}^{[1]},axis=1,keepdims=True)$

上述是反向传播的步骤，注：这些都是针对所有样本进行过向量化，$Y$是$1\times m$的矩阵；这里np.sum是python的numpy命令，axis=1表示水平相加求和，keepdims是防止python输出那些古怪的秩数$(n,)$，加上这个确保阵矩阵$d{b}^{[2]}$这个向量输出的维度为$(n,1)$这样标准的形式。

目前为止，我们计算的都和Logistic回归十分相似，但当你开始计算反向传播时，你需要计算，是隐藏层函数的导数，输出在使用sigmoid函数进行二元分类。这里是进行逐个元素乘积，因为$W^{[2]T}d{z}^{[2]}$和$(z^{[1]})$这两个都为$(n^{[1]},m)$矩阵；

还有一种防止python输出奇怪的秩数，需要显式地调用reshape把np.sum输出结果写成矩阵形式。

以上就是正向传播的4个方程和反向传播的6个方程，这里我是直接给出的，在下个视频中，我会讲如何导出反向传播的这6个式子的。如果你要实现这些算法，你必须正确执行正向和反向传播运算，你必须能计算所有需要的导数，用梯度下降来学习神经网络的参数；你也可以许多成功的深度学习从业者一样直接实现这个算法，不去了解其中的知识。

3.10（选修）直观理解反向传播（Backpropagation intuition）

这个视频主要是推导反向传播。

下图是逻辑回归的推导：

回想一下逻辑回归的公式(参考公式3.2、公式3.5、公式3.6、公式3.15)
公式3.38：
$$\begin{array}{l}x\\ w\\ b\end{array}\}⟹z=w^{T}x+b⟹\alpha =\sigma (z)⟹L\left(a,y\right)$$
所以回想当时我们讨论逻辑回归的时候，我们有这个正向传播步骤，其中我们计算$z$，然后$a$，然后损失函数$L$。

公式3.39：
$$\underset{dw=dz\cdot x,db=dz}{\begin{array}{l}x\\ w\\ b\end{array}\}}⟸\underset{dz=da\cdot g^{{}^{\prime }}(z),g(z)=\sigma (z),\frac{dL}{dz}=\frac{dL}{da}\cdot \frac{da}{dz},\frac{d}{dz}g(z)=g^{{}^{\prime }}(z)}{z=w^{T}x+b}⟸\underset{da=\frac{d}{da}L\left(a,y\right)=(-y\log \alpha -(1-y)\log (1-a){)}^{{}^{\prime }}=-\frac{y}{a}+\frac{1-y}{1-a}}{a=\sigma (z)⟸L(a,y)}$$
神经网络的计算中，与逻辑回归十分类似，但中间会有多层的计算。下图是一个双层神经网络，有一个输入层，一个隐藏层和一个输出层。

前向传播：

计算$z^{[1]}$，$a^{[1]}$，再计算$z^{[2]}$，$a^{[2]}$，最后得到loss function。

反向传播：

向后推算出$d{a}^{[2]}$，然后推算出$d{z}^{[2]}$，接着推算出$d{a}^{[1]}$，然后推算出$d{z}^{[1]}$。我们不需要对$x$求导，因为$x$是固定的，我们也不是想优化$x$。向后推算出$d{a}^{[2]}$，然后推算出$d{z}^{[2]}$的步骤可以合为一步：
公式3.40：
反向传播第二层的偏导数推导如下：
$$z^{[2]}=W^{[2]}{a}^{[1]}+b^{[2]}$$
$$a^{[2]}=\sigma (z^{[2]})=\sigma (W^{[2]}{a}^{[1]}+b^{[2]})$$
$$\frac{\partial L}{\partial b^{[2]}}=\frac{\partial L\left(z,y\right)}{\partial z}\ast \frac{\partial z}{\partial b^{[2]}}=(\sigma (z^{[2]})-y)\frac{\partial (W^{[2]}{a}^{[1]}+b^{[2]})}{\partial b^{[2]}}=a^{[2]}-y$$
$$\frac{\partial L}{\partial W^{[2]}}=\frac{\partial L\left(z,y\right)}{\partial z}\ast \frac{\partial z}{\partial W^{[2]}}=(\sigma (z^{[2]})-y)\frac{\partial (W^{[2]}{a}^{[1]}+b^{[2]})}{\partial W^{[2]}}=(a^{[2]}-y)\ast a^{[1]}$$
$$\frac{\partial L}{\partial W^{[2]}}=(a^{[2]}-y){a^{[1]}}^T$$
(注意：逻辑回归中；为什么$a^{[1]T}$多了个转置：$dw$中的$W$(视频里是$W_i^{[2]}$)是一个列向量，而$W^{[2]}$是个行向量，故需要加个转置);

反向传播第二层的偏导数推导总结如下：
$$\frac{\partial L\left(z,y\right)}{\partial z}=a^{[2]}-y,\frac{\partial L}{\partial b^{[2]}}=a^{[2]}-y，\frac{\partial L}{\partial W^{[2]}}=(a^{[2]}-y){a^{[1]}}^T$$

现在我们来计算反向传播的第一层的偏导数:
由于有第二层前向传播公式：
$$a^{[2]}=\sigma (z^{[2]})=\sigma (W^{[2]}{a}^{[1]}+b^{[2]})，z^{[2]}=W^{[2]}{a}^{[1]}+b^{[2]}$$
由于有第一层前向传播公式：
$$a^{[1]}=\sigma (z^{[1]})=\sigma (W^{[1]}X+b^{[1]})，z^{[1]}=W^{[1]}{a}^{[0]}+b^{[1]}=W^{[1]}X+b^{[1]}$$
从链式求导法则可以知道：
$$\frac{\partial L}{\partial b^{[1]}}=\frac{\partial L\left(z^{[1]},y\right)}{\partial z^{[2]}}\ast \frac{\partial z^{[2]}}{\partial a^{[1]}}\ast \frac{\partial a^{[1]}}{\partial z^{[1]}}\ast \frac{\partial z^{[1]}}{\partial b^{[1]}}=(\sigma (z^{[2]})-y)\ast W^{[2]}T\ast \sigma (z^{[1]})\ast (1-\sigma (z^{[1]})$$

$$\frac{\partial L}{\partial W^{[1]}}=\frac{\partial L\left(z^{[1]},y\right)}{\partial z^{[2]}}\ast \frac{\partial z^{[2]}}{\partial a^{[1]}}\ast \frac{\partial a^{[1]}}{\partial z^{[1]}}\ast \frac{\partial z^{[1]}}{\partial W^{[1]}}=(\sigma (z^{[2]})-y)\ast W^{[2]}T\ast \sigma (z^{[1]})\ast (1-\sigma (z^{[1]})\ast X$$

其实这就是吴恩达老师所说的最难的损失函数求导公式了，但是我们拆解一下，就能够很清晰的得到链式求导的真谛：

其实上述过程拆解可以成为这样子：

1. 计算 $\frac{\partial L\left(z^{[2]},y\right)}{\partial z[2]}$
2. 从 $Z^{[2]}=W^{[2]}{A}^{[1]}+b^{[2]}，将A^{[1]}$ 看做常数求$W^{[2]}，b^{[2]}$的偏导数。
3. 计算 $\frac{\partial L\left(z^{[1]},y\right)}{\partial z[1]}$，从第1步的结果我们已经求出了 $\frac{\partial L\left(z^{[2]},y\right)}{\partial z[2]}$,因为神经网络中$z[2]=W^{[2]}{A}^{[1]}+b^{[1]}$，因此 $\frac{\partial L\left(z^{[1]},y\right)}{\partial z[1]}=\frac{\partial L\left(z^{[2]},y\right)}{\partial z[2]}\ast W^{[2]}\ast$$g(z1{)}^{{}^{\prime }}$，其中$g(z1{)}^{{}^{\prime }}$指的是第一层激活函数对Z1的导数。
4. 从此我们可以推出来，对于L层神经网络应该有:
   $$\frac{\partial L\left(z^{[1]},y\right)}{\partial z^{[1]}}=\frac{\partial L\left(z^{[L]},y\right)}{\partial z^{[L]}}\ast \frac{\partial z^{[L]}}{\partial z^{[L-1]}}\ast \dots \dots \frac{\partial z^2}{[z^1]}$$
   $$=\frac{\partial L\left(z^{[L]},y\right)}{\partial z^{[L]}}\ast W^{[L]}\ast g(z^{[L-1]}{)}^{{}^{\prime }}\ast W^{[L-1]}\ast g(z^{[L-2]}{)}^{{}^{\prime }}\dots \dots W^{[2]}\ast g(z^{[1]}{)}^{{}^{\prime }}$$

接下来求代价函数就是求和之后求个平均值就好了，这里就不在赘述了。

$$J(W^{[1]},b^{[1]},W^{[2]},b^{[2]})=\frac{1}{m}\sum _{i=1}^{m}L(\hat{y},y)$$
吴恩达老师认为反向传播的推导是机器学习领域最难的数学推导之一，矩阵的导数要用链式法则来求，如果这章内容掌握不了也没大的关系，只要有这种直觉就可以了。还有一点，就是初始化你的神经网络的权重，不要都是0，而是随机初始化，下一章将详细介绍原因。

3.11 随机初始化（Random+Initialization）

当你训练神经网络时，权重随机初始化是很重要的。对于逻辑回归，把权重初始化为0当然也是可以的。但是对于一个神经网络，如果你把权重或者参数都初始化为0，那么梯度下降将不会起作用。

让我们看看这是为什么。有两个输入特征，$n^{[0]}=2$，2个隐藏层单元$n^{[1]}$就等于2。
因此与一个隐藏层相关的矩阵，或者说$W^{[1]}$是2*2的矩阵，假设把它初始化为0的2*2矩阵，$b^{[1]}$也等于 $[00{]}^T$，把偏置项$b$初始化为0是合理的，但是把$w$初始化为0就有问题了。
那这个问题如果按照这样初始化的话，你总是会发现$a_1^{[1]}$ 和 $a_2^{[1]}$相等，这个激活单元和这个激活单元就会一样。因为两个隐含单元计算同样的函数，当你做反向传播计算时，这会导致${\text{dz}}_1^{[1]}$ 和 ${\text{dz}}_2^{[1]}$也会一样，对称这些隐含单元会初始化得一样，这样输出的权值也会一模一样，由此$W^{[2]}$等于$[00]$；

图3.11.1
但是如果你这样初始化这个神经网络，那么这两个隐含单元就会完全一样，因此他们完全对称，也就意味着计算同样的函数，并且肯定的是最终经过每次训练的迭代，这两个隐含单元仍然是同一个函数，令人困惑。$dW$会是一个这样的矩阵，每一行有同样的值因此我们做权重更新把权重$W^{[1]}⟹W^{[1]}-adW$每次迭代后的$W^{[1]}$，第一行等于第二行。

由此可以推导，如果你把权重都初始化为0，那么由于隐含单元开始计算同一个函数，所有的隐含单元就会对输出单元有同样的影响。一次迭代后同样的表达式结果仍然是相同的，即隐含单元仍是对称的。通过推导，两次、三次、无论多少次迭代，不管你训练网络多长时间，隐含单元仍然计算的是同样的函数。因此这种情况下超过1个隐含单元也没什么意义，因为他们计算同样的东西。当然更大的网络，比如你有3个特征，还有相当多的隐含单元。

如果你要初始化成0，由于所有的隐含单元都是对称的，无论你运行梯度下降多久，他们一直计算同样的函数。这没有任何帮助，因为你想要两个不同的隐含单元计算不同的函数，这个问题的解决方法就是随机初始化参数。你应该这么做：把$W^{[1]}$设为np.random.randn(2,2)(生成高斯分布)，通常再乘上一个小的数，比如0.01，这样把它初始化为很小的随机数。然后$b$没有这个对称的问题（叫做symmetry breaking problem），所以可以把 $b$ 初始化为0，因为只要随机初始化$W$你就有不同的隐含单元计算不同的东西，因此不会有symmetry breaking问题了。相似的，对于$W^{[2]}$你可以随机初始化，$b^{[2]}$可以初始化为0。

$W^{[1]}=np.random.randn(2,2)\ast 0.01,b^{[1]}=np.zeros((2,1))$
$W^{[2]}=np.random.randn(2,2)\ast 0.01,b^{[2]}=0$

你也许会疑惑，这个常数从哪里来，为什么是0.01，而不是100或者1000。我们通常倾向于初始化为很小的随机数。因为如果你用tanh或者sigmoid激活函数，或者说只在输出层有一个Sigmoid，如果（数值）波动太大，当你计算激活值时$z^{[1]}=W^{[1]}x+b^{[1]},a^{[1]}=\sigma (z^{[1]})=g^{[1]}(z^{[1]})$如果$W$很大，$z$就会很大或者很小，因此这种情况下你很可能停在tanh/sigmoid函数的平坦的地方(见图3.8.2)，这些地方梯度很小也就意味着梯度下降会很慢，因此学习也就很慢。

回顾一下：如果$w$很大，那么你很可能最终停在（甚至在训练刚刚开始的时候）$z$很大的值，这会造成tanh/Sigmoid激活函数饱和在龟速的学习上，如果你没有sigmoid/tanh激活函数在你整个的神经网络里，就不成问题。但如果你做二分类并且你的输出单元是Sigmoid函数，那么你不会想让初始参数太大，因此这就是为什么乘上0.01或者其他一些小数是合理的尝试。对于$w^{[2]}$一样，就是np.random.randn((1,2))，我猜会是乘以0.01。

事实上有时有比0.01更好的常数，当你训练一个只有一层隐藏层的网络时（这是相对浅的神经网络，没有太多的隐藏层），设为0.01可能也可以。但当你训练一个非常非常深的神经网络，你可能要试试0.01以外的常数。下一节课我们会讨论怎么并且何时去选择一个不同于0.01的常数，但是无论如何它通常都会是个相对小的数。

好了，这就是这周的视频。你现在已经知道如何建立一个一层的神经网络了，初始化参数，用前向传播预测，还有计算导数，结合反向传播用在梯度下降中。