吴恩达神经网络与深度学习章节笔记（二）——神经网络和激活函数

视频课程链接：
https://www.bilibili.com/video/BV1FT4y1E74V?
笔记参考链接：
https://blog.csdn.net/weixin_36815313/article/details/105728919
课程作业链接：
https://download.csdn.net/download/baoli8425/19821557?spm=1001.2014.3001.5503

1. 神经网络概览 (Neural Networks Overview)

神经网络模型与逻辑回归公式之间的关系如上图。
输入特征$x$，参数$w$和$b$ ，从而计算出$z$，最后输出预测值$\hat{y}$，同时计算损失函数$L(\hat{y},y)$。

我们会使用符号${}^{[m]}$表示第$m\text{m}m$层网络中节点相关的数，这些节点的集合被称为第$m\text{m}m$层网络。这样可以保证${}^{[m]}$不会和我们之前用来表示单个的训练样本的${}^{(i)}$(即我们使用表示第$i$个训练样本)混淆。

在这个神经网络对应的3个节点，首先计算第一层网络中的各个节点相关的数$z^{[1]}$，接着计算$a^{[1]}$。

使用另外一个线性方程对应的参数计算$z^{[2]}$，计算$a^{[2]}$，此时$a^{[2]}$就是整个神经网络最终的输出，用$\hat{y}$表示网络的输出。

2. 神经网络表示 (Neural Network Representation)

我们有输入特征$x_1、x_2、x_3$，它们被竖直地堆叠起来，这叫做神经网络的输入层(Input Layer)。它包含了神经网络的输入；这里还有另外一层我们称之为隐藏层(Hidden Layer)。在一个神经网络中，当你使用监督学习训练它的时候，训练集既包含了输入$x$，也包含了目标输出$y$，而这些中间结点的准确值我们是不知道的，你能看见输入的值，也能看见输出的值，但是隐藏层中的东西，在训练集中你是无法看到的；最后一层只由一个结点构成，而这个只有一个结点的层被称为输出层(Output Layer)，它负责产生预测值$\hat{y}$。
按照约定俗成的符号传统，在这个例子中，只能叫做一个两层的神经网络。输入层是不算入总层数内，我们将输入层称为第零层，因此在这个例子中隐藏层是第一层，输出层是第二层。
在前面的逻辑回归中，我们用向量$X$表示输入特征。在神经网络中$a^{[0]}$可以用来表示输入特征，a表示激活的意思，它意味着网络中不同层的值会传递到它们后面的层中，输入层将$X$传递给隐藏层，所以我们将输入层的激活值称为$a^{[0]}$；下一层即隐藏层也同样会产生一些激活值，那么我将其记作$a^{[1]}$，所以具体地，这里的第一个单元或结点我们将其表示为$a_1^{[1]}$，第二个结点的值我们记为$a_2^{[1]}$，以此类推。在本例中，我们有四个结点或者单元，或者称为四个隐藏层单元。写成如下的Python代码，那么它是一个规模为4x1的矩阵或一个大小为4的列向量。
$$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]}$。
隐藏层拥有两个参数$W$和$b$，给它们加上上标$(W^{[1]},b^{[1]})$，表示这些参数是和第一层这个隐藏层有关系的。在这个例子中$W$是一个4×3的矩阵，而$b$是一个4×1的向量。输出层也有一些与之关联的参数$W^{[2]}$以及$b^{[2]}$ 。从维数上来看，它们的规模分别是1×4以及1×1，1×4是因为隐藏层有四个隐藏层单元而输出层只有一个单元。

3. 计算神经网络的输出 (Computing a Neural Network’s Output)

3.1 神经网络的计算

用圆圈表示神经网络的计算单元，逻辑回归的计算有两个步骤，首先按步骤计算出$z$，然后第二步再以sigmoid函数为激活函数计算$z$，得出$a$，一个神经网络只是这样子做了好多次重复计算。

回到两层的神经网络，我们从隐藏层的第一个神经元开始计算（如上图）。这个神经元的计算与逻辑回归一样分为两步，小圆圈代表了计算的两个步骤。
第一步：计算$z_1^{[1]}=w_1^{[1]T}x+b_1^{[1]}$
第二步：通过激活函数计算$a_1^{[1]}=\sigma (z_1^{[1]})$
隐藏层的其余三个神经元的计算过程一样，只是注意符号表示不同，最终分别得到：
$$z_2^{[1]}=w_2^{[1]}Tx+b_2^{[1]},a_2^{[1]}=\sigma (z_2^{[1]})$$$$z_3^{[1]}=w_3^{[1]}Tx+b_3^{[1]},a_3^{[1]}=\sigma (z_3^{[1]})$$$$z_4^{[1]}=w_4^{[1]}Tx+b_4^{[1]},a_4^{[1]}=\sigma (z_4^{[1]})$$

3.2 向量化计算

向量化的过程是将神经网络中的一层神经元参数纵向堆积起来，例如隐藏层中的$W$纵向堆积起来变成一个4×3的矩阵，用符号$W^{[1]}$表示。其中这里的数字4是因为我们有四个结点或隐藏层单元，数字3是因为这里有三个输入特征。
对于神经网络的第一层，即隐藏层，给予一个输入$x$，通过如下两步计算得到$a^{[1]}$。
$$z^{[1]}=\left[\begin{array}{c}{z}_1^{[1]}\\ z_2^{[1]}\\ z_3^{[1]}\\ z_4^{[1]}\end{array}\right]=\left[\begin{array}{c}{W}_1^{[1]}{W}_1^{[1]}{W}_1^{[1]}\\ W_2^{[1]}{W}_2^{[1]}{W}_2^{[1]}\\ W_4^{[1]}{W}_3^{[1]}{W}_3^{[1]}\\ W_4^{[1]}{W}_4^{[1]}{W}_4^{[1]}\end{array}\right]\ast \left[\begin{array}{c}{x}_1\\ x_2\\ x_3\end{array}\right]+\left[\begin{array}{c}{b}_1^{[1]}\\ b_2^{[1]}\\ b_3^{[1]}\\ b_4^{[1]}\end{array}\right]$$$$a^{[1]}=\left[\begin{array}{c}{a}_1^{[1]}\\ a_2^{[1]}\\ a_3^{[1]}\\ a_4^{[1]}\end{array}\right]=\sigma (z^{[1]})$$下一层输出层的表示同样可以写成类似的形式，以$a^{[1]}$作为输入，通过如下两步计算得到$a^{[2]}$。
$$z^{[2]}=\left[\begin{array}{c}{z}_1^{[2]}\\ z_2^{[2]}\\ z_3^{[2]}\\ z_4^{[2]}\end{array}\right]=\left[\begin{array}{c}{W}_1^{[2]}{W}_1^{[2]}{W}_1^{[2]}{W}_1^{[2]}\end{array}\right]\ast \left[\begin{array}{c}{a}_1^{[1]}\\ a_2^{[1]}\\ a_3^{[1]}\\ a_4^{[1]}\end{array}\right]+\left[\begin{array}{c}{b}_1^{[2]}\end{array}\right]$$$$a^{[2]}=\sigma (z^{[2]})$$

4. 多个例子中的向量化 (Vectorizing across Multiple Examples)

上一节是针对单一的训练样本，在神经网络上计算出预测值$\hat{y}$。而在本节中，我们将会了解到如何向量化多个训练样本，并计算出结果。
首先引入一种新的符号定义，以$a^{[2](i)}$为例，其中$(i)$是指第$i$个训练样本，$[2]$是指第二层。
对于所有的训练样本，如果采用非向量化的方法实现，需要让$i$从1到$m$遍历这四个等式（此处$W\text{W}W$没有转置）。

而采用向量化的方式则是将训练样本在横向上堆叠到矩阵的各列，形成一个$n_x\times m$维的矩阵。
将小写的$x$向量堆叠到矩阵的各列中，形成矩阵$X$（如下图）。
$$X=\left[\begin{array}{cccc}⋮& ⋮& ⋮& ⋮\\ x^{(1)}& x^{(2)}& \cdots & x^{(m)}\\ ⋮& ⋮& ⋮& ⋮\end{array}\right]$$将$z^{[1](1)}$、$z^{[1](2)}$、……、$z^{[1](m)}$等$m$个列向量堆叠到各列中，就得到了矩阵$Z^{[1]}$（如下图）。
$$Z^{[1]}=\left[\begin{array}{cccc}⋮& ⋮& ⋮& ⋮\\ z^{[1](1)}& z^{[1](2)}& \cdots & z^{[1](m)}\\ ⋮& ⋮& ⋮& ⋮\end{array}\right]$$将$a^{[1](1)}$、$a^{[1](2)}$、……、$a^{[1](m)}$组合到矩阵的各列中，就得到了矩阵$A^{[1]}$（如下图）。$$A^{[1]}=\left[\begin{array}{cccc}⋮& ⋮& ⋮& ⋮\\ a^{[1](1)}& a^{[1](2)}& \cdots & a^{[1](m)}\\ ⋮& ⋮& ⋮& ⋮\end{array}\right]$$同理可得第二层中对应的矩阵$Z^{[2]}$和$A^{[2]}$。
对于矩阵$A$来说，从水平方向上看，代表了$m$个不同的训练样本。从垂直方向上看，对应于同一层中不同的隐藏单元（神经元）。
而对于矩阵$Z$，$X$也是类似的。在水平方向上，对应于$m$个不同的训练样本；在竖直方向上，对应不同的输入特征，即神经网络输入层中的各个节点。
因此采用向量化的方式实际按照如下四个公式计算。$$Z^{[1]}=W^{[1]}X+b^{[1]}$$$$A^{[1]}=\sigma (Z^{[1]})$$$$Z^{[2]}=W^{[2]}{A}^{[1]}+b^{[2]}$$$$A^{[2]}=\sigma (Z^{[2]})$$

5. 激活函数 (Activation Function)

5.1 sigmoid函数

$$a=\sigma (z)=\frac{1}{1+e^{-z}}$$在神经网络的前向传播中，在$a^{[1]}=\sigma (z^{[1]})$和$a^{[2]}=\sigma (z^{[2]})$这两步中会使用到sigmoid函数。如果是二分类问题，即输出是0和1，要想让$\hat{y}$的数值介于0和1之间，则输出层选择sigmoid函数，然后其它的所有单元都选择tanh函数或者ReLu函数。

5.2 tanh函数​

$$a=g(z)=\frac{e^z+e^{-z}}{e^z-e^{-z}}$$tanh函数是sigmoid函数向下平移和伸缩后的结果。
如果在隐藏层上使用tanh函数，效果总是优于sigmoid函数。因为函数值域在-1和+1之间，其均值更接近于零。在训练一个算法模型时，如果使用tanh函数代替sigmoid函数中心化数据，使得数据的平均值更接近0而不是0.5，这会使下一层学习简单一点。
sigmoid函数和tanh函数两者共同的缺点是，在$z$特别大或者特别小的情况下，导数的梯度或者函数的斜率会变得特别小，最后就会接近于0，导致降低梯度下降的速度。

5.3 ReLu函数

$$a=max(0,z)$$当$z$是正值的时候，导数恒等于1，当$z$是负值的时候，导数恒等于0，而当$z=0$的时候，导数是没有意义的。但是在编程实现的时候，$z$刚好等于0的概率很低，因此在实践中不需要担心这个问题。当$z$等于0的时候，可以直接给导数赋值为0或1。

5.4 Leaky ReLu函数

$$a=max(0.1z,z)$$这个函数通常比ReLu激活函数效果要好，尽管在实际中Leaky ReLu使用的并不多。至于为什么常数是0.1？在实际应用中，你可以为学习算法选择不同的参数。

5.5 激活函数选择的经验总结

(1) 在$z$的区间变动很大的情况下，激活函数的导数或者激活函数的斜率都会远大于0，在程序实现就是一个if-else语句，而sigmoid函数需要进行浮点四则运算。在实践中，使用ReLu激活函数的神经网络通常会比使用sigmoid或者tanh激活函数学习的更快。
(2) sigmoid和tanh函数的导数在正负饱和区的梯度都会接近于0，这会造成梯度弥散，而ReLu和Leaky ReLu函数大于0部分都为常数，不会产生梯度弥散现象。同时应该注意到的是，ReLu进入负半区的时候，梯度为0，神经元此时不会训练，产生所谓的稀疏性，而Leaky ReLu不会有这问题。
(3) 如果在隐藏层上不确定使用哪个激活函数，那么通常会使用Relu激活函数，有时也会使用tanh激活函数，但ReLu的一个优点是，当$z$是负值的时候，导数等于0。
在编写神经网络的时候，会有很多的选择，例如隐藏层单元的个数、激活函数的选择、初始化权值等，但是自己的神经网络的应用以及其特殊性，是很难提前知道选择哪些效果更好，所以通常的建议是如果不确定哪一个激活函数效果更好，可以把它们都试试，然后在验证集或者发展集上进行评价，看哪一种表现的更好，就去使用它。

6. 为什么需要非线性激活函数？ (Why do you need non-linear activation function?)

如下是神经网络正向传播的方程。

假设$g(z)=z$，这被称为线性激励函数或恒等激励函数，即把输入值直接输出。$$a^{[1]}=z^{[1]}=W^{[1]}x+b^{[1]}\text{\hspace{1em}(1)}$$ $$a^{[2]}=z^{[2]}=W^{[2]}{a}^{[1]}+b^{[2]}\text{\hspace{1em}(2)}$$将公式(1)代入到公式(2)中得$$z^{[2]}=W^{[2]}(W^{[1]}x+b^{[1]})+b^{[2]}=W^{[2]}{W}^{[1]}x+W^{[2]}{b}^{[1]}+b^{[2]}\text{\hspace{1em}(3)}$$简化多项式得$$a^{[2]}=z^{[2]}=W^{{}^{\prime }}x+b^{{}^{\prime }}$$因此如果用线性激活函数或者恒等激励函数，那么神经网络只是把输入线性组合再输出。如果你使用线性激活函数或者没有使用一个激活函数，那么无论你的神经网络有多少层，一直在做的只是计算线性函数，所以不如直接去掉全部隐藏层。
总而言之，可以在隐藏层使用ReLU函数、tanh函数、Leaky ReLU函数或者其他的非线性激活函数，但不能使用线性激活函数，唯一可以用线性激活函数的通常就是输出层。

7. 激活函数的导数 (Derivatives of Activation Functions)

7.1 sigmoid函数的导数

已知sigmoid函数的表达式为$$g(z)=\frac{1}{1+e^{-z}}$$对sigmoid函数求导可得$$\begin{array}{rl}{g}^{\prime }(z)& =\frac{d}{dz}g(z)\\ & =\frac{1}{1+e^{-z}}(1+\frac{1}{1-e^{-z}})\\ & =g(z)\cdot (1-g(z))\end{array}$$当$z$较大时，假设$z=10$，$g(z)\approx 1$，那么sigmoid函数的导数$g^{\prime }(z)\approx 1\cdot (1-1)\approx 0$；当$z$较小时，假设$z=-10$，$g(z)\approx 0$，那么sigmoid函数的导数$g^{\prime }(z)\approx 0\cdot (1-0)\approx 0$。

7.2 tanh函数的导数

已知tanh函数的表达式为$$g(z)=\frac{e^z+e^{-z}}{e^z-e^{-z}}$$对tanh函数求导可得$$\begin{array}{rl}{g}^{\prime }(z)& =\frac{d}{dz}g(z)\\ & =1-(tanh(z){)}^2\\ & =1-g(z{)}^2\end{array}$$当$z$较大时，假设$z=10$，$g(z)\approx 1$，那么tanh函数的导数$g^{\prime }(z)\approx 0$；当$z$较小时，假设$z=-10$，$g(z)\approx 0$，那么tanh函数的导数$g^{\prime }(z)\approx 0\cdot (1-0)\approx 0$。

7.3 ReLu函数的导数

已知ReLu函数的表达式为$$g(z)=max(0,z)$$对ReLu函数求导可得$$g^{\prime }(z)=\{\begin{array}{ll}0& z<0\\ 1& z>0\\ undefined& z=0\end{array}$$在实际编程中，$z=0$的时候可以自定义为0或1，因为通常$z=0$的情况很少遇到。

7.4 Leaky ReLu函数的导数

已知Leaky ReLu函数的表达式为$$g(z)=max(0.01z,z)$$对Leaky ReLu函数求导可得$$g^{\prime }(z)=\{\begin{array}{ll}0.01& z<0\\ 1& z>0\\ undefined& z=0\end{array}$$在实际编程中，$z=0$的时候可以自定义为0.01或1，因为通常$z=0$的情况很少遇到。

8. 神经网络的梯度下降法 (Gradient Descent for Neural Networks)

8.1 参数定义

在单隐层神经网络中有$W^{[1]}$，$b^{[1]}$表示隐藏层参数，$W^{[2]}$，$b^{[2]}$表示输出层参数，$n_x$或$n^{[0]}$表示输入特征的个数，$n^{[1]}$表示隐藏层的单元个数，$n^{[2]}$表示输出层的单元个数。因此$W^{[1]}$是维度$(n^{[1]},n^{[0]})$的矩阵，$b^{[1]}$是$n^{[1]}$维向量，$W^{[1]}$是维度$(n^{[2]},n^{[1]})$的矩阵，$b^{[1]}$是$n^{[2]}$维向量。
在二元分类问题中，成本函数为$J(W^{[1]},b^{[1]},W^{[2]},b^{[2]})=\frac{1}{m}{\sum }_{i=1}^{m}L(\hat{y},y)$，其中损失函数$L(\hat{y},y)$可能与逻辑回归中的损失函数完全一样，$\hat{y}$即为输出值$a^{[2]}$。

8.2 参数训练

参数训练需要算法做梯度下降，在训练神经网络的时候，随机初始化参数很重要，而不是初始化成全零。当初始化参数后，每次梯度下降都会循环计算预测值${\hat{y}}^{(i)}(i=1,2,...,m)$。$$d{W}^{[1]}=\frac{dJ}{d{W}^{[1]}},d{b}^{[1]}=\frac{dJ}{d{b}^{[1]}}$$$$d{W}^{[2]}=\frac{dJ}{d{W}^{[2]}},d{b}^{[2]}=\frac{dJ}{d{b}^{[2]}}$$$$W^{[1]}:=W^{[1]}-\alpha d{W}^{[1]},b^{[1]}:=b^{[1]}-\alpha d{b}^{[1]}$$$$W^{[2]}:=W^{[2]}-\alpha d{W}^{[2]},b^{[2]}:=b^{[2]}-\alpha d{b}^{[2]}$$

8.3 计算步骤

神经网络正向传播（forward propagation）的步骤如下：
(1) $Z^{[1]}=W^{[1]}X+b^{[1]}$
(2) $A^{[1]}=g^{[1]}(Z^{[1]})$
(3) $Z^{[2]}=W^{[2]}{A}^{[1]}+b^{[2]}$
(4) $A^{[2]}=\sigma (Z^{[2]})$
神经网络反向传播（backward propagation）的步骤如下:
(1) $d{Z}^{[2]}=A^{[2]}-Y$，其中$Y=[y^{[1]}{y}^{[2]}\cdots y^{[m]}]$
(2) $d{W}^{[2]}=\frac{1}{m}d{Z}^{[2]}{A}^{[1]T}$
(3) $d{b}^{[2]}=\frac{1}{m}np.sum(d{Z}^{[2]})$
(4) $d{Z}^{[1]}=\frac{dL}{d{A}^{[2]}}\cdot \frac{d{A}^{[2]}}{d{Z}^{[2]}}\cdot \frac{d{Z}^{[2]}}{d{A}^{[1]}}\cdot \frac{d{A}^{[1]}}{d{Z}^{[1]}}=(\frac{-Y}{A^{[2]}}+\frac{1-Y}{1-A^{[2]}})\cdot (A^{[2]}\cdot (1-A^{[2]}))\cdot W^{[2]}\cdot g^{[1]\prime }(Z^{[1]})=W^{[2]T}d{Z}^{[2]}\ast g^{[1]\prime }(Z^{[1]})$
(5) $d{W}^{[1]}=\frac{1}{m}d{Z}^{[1]}{x}^T$
(6) $d{b}^{[1]}=\frac{1}{m}np.sum(d{Z}^{[1]})$
以上矩阵的维度如下：
(1) $W^{[2]}$的维度是$(n^{[2]},n^{[1]})$
(2) $Z^{[2]}$，$d{Z}^{[2]}$的维度都是$(n^{[2]},1)$。如果是二元分类，那么维度就是$(1,1)$。
(3) $Z^{[1]}$，$d{Z}^{[1]}$的维度都是$(n^{[1]},1)$。
实现反向传播的技巧就是要保证矩阵的维度相互匹配。

9. 随机初始化 (Radom Initialization)

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

以上图为例，该神经网络有两个输入特征，因此$n^{[0]}$=2，而隐藏层有两个隐藏单元，因此$n^{[1]}$=2。假设将$W^{[1]}$初始化为零，即$W^{[1]}=\left[\begin{array}{cc}0& 0\\ 0& 0\end{array}\right]$。$b^{[1]}$也初始化为零，即$b^{[1]}=[0,0{]}^T$。
如果按照这样子初始化的话，给网络输入任何样本，$a^{[1]}=g^{[1]}(w_1^{[1]}x+b^{[1]})$两个隐藏单元$a_1^{[1]}$和$a_2^{[1]}$都计算同样的函数，则两个值相等。做反向传播计算的时候，由于对称性，这会导致$d{z}_1^{[1]}$和$d{z}_2^{[1]}$也相等，并且最终经过多次训练迭代，这两个隐藏单元仍然计算着同一个函数。因为大部分情况下$dW=\left[\begin{array}{cc}u& v\\ u& v\end{array}\right]$会是这样的矩阵形式，每一行的数值都一样，因此我们执行权重更新$W^{[1]}:=W^{[1]}-\alpha dW$，每次迭代后$W^{[1]}$的第一行都等于第二行。
以此类推，根据归纳法可以得到结论，无论多少次迭代，不管训练网络多长时间，隐藏单元仍然计算的是同样的函数，所有的隐藏单元就会对输出单元有同样的影响，这样是没有意义的。解决这个问题的方法就是随机初始化所有参数。
随机初始化的Python代码如下：

W1 = np.random.randn(2,2)∗0.01
b1 = np.zeros((2,1))
W2 = np.random.randn(2,2)∗0.01
b2 = 0

把$w$设为np.random.randn(2,2)，从而生成参数为(2,2)的高斯分布随机变量，然后再乘上一个很小的系数，比如0.01，这样把它初始化为很小的随机数。$b$不存在这个对称性的问题，因此可以把$b$初始化为0。
至于这里的系数0.01，我们通常倾向于初始化为很小的随机数，因为如果使用tanh或者sigmoid激活函数，或者只在输出层有一个sigmoid激活函数，当你在计算激活函数的值时，若$w$较大，则$z$也会较大或者较小，这种情况下你很可能停在tanh或sigmoid函数较为平缓的地方，这意味着梯度下降会很慢，因此学习速度也就很慢。

事实上有时有比0.01更好的常数，当你训练一个单隐层神经网络（这是相对浅的神经网络，没有太多的隐藏层）时，设为0.01也是可以，但当你要训练一个非常深的神经网络，你可能要试试0.01以外的常数。