神经网络基础

• \(x\) : 表示一个 \(n_x\) 维数据，为输入数据，维度为 \((n_x, 1)\)
• \(y\) : 表示输出结果，取值为 \((0, 1)\)
• \((x^{(i)}, y^{(i)})\) : 表示第 \(i\) 组数据，可能是训练数据，也可能是测试数据，此处默认为训练数据
• \(\mathbf{X} = [x^{(1)}, x^{(2)}, \ldots, x^{(m)}]\) : 表示所有的训练数据集的输入值，放在一个 \(n_x \times m\) 的矩阵中，其中 \(m\) 表示样本数目
• \(\mathbf{Y} = [y^{(1)}, y^{(2)}, \dots, y^{(m)}]\) : 对应表示所有训练数据集的输出值，维度为 \(1 \times m\)

用一对 \((x, y)\) 来表示一个单独的样本，\(x\) 代表 \(n_x\) 维的特征向量， \(y\) 表示标签(输出结果)只能为0或1。 而训练集将由 \(m\) 个训练样本组成：

• 其中 \((x^{(1)}, y^{(1)})\) 表示第一个样本的输入和输出
• \((x^{(2)}, y^{(2)})\) 表示第二个样本的输入和输出
• 直到最后一个样本 \((x^{(m)}, y^{(m)})\)

所有的这些一起表示整个训练集：

• 有时候为了强调这是训练样本的个数，会写作 \(\mathbf{M}_{train}\)
• 当涉及到测试集的时候，会使用 \(\mathbf{M}_{test}\) 来表示测试集的样本数，所以这是测试集的样本数

最后为了能把训练集表示得更紧凑一点，会定义一个矩阵用大写 \(\mathbf{X}\) 的表示，它由输入向量 \(x^{(1)}\) , \(x^{(2)}\) 等组成，如下图放在矩阵的列中，所以现在 \(x^{(1)}\) 把作为第一列放在矩阵中， \(x^{(2)}\) 作为第二列，\(x^{(m)}\) 放到第 \(m\) 列，然后就得到了 训练集矩阵 。所以这个矩阵有 \(m\) 列，是训练集的 样本数量 ，然后这个矩阵的高度记为 \(n_{x}\) ，注意有时候可能因为其他某些原因，矩阵 \(\mathbf{X}\) 会由训练样本按照行堆叠起来而不是列，\(x^{(1)}\) 的转置直到 \(x^{(m)}\) 的转置，但是在实现神经网络的时候，使用左边的这种形式，会让整个实现的过程变得更加简单：

下图是 \(\mathbf{sigmoid}\) 函数的图像，如果把水平轴作为 \(z\) 轴，那么关于的sigmoid函数是平滑地从0走向1（纵轴），曲线与纵轴相交的截距是 0.5 ，这就是 \(z\) 关于的 \(\mathbf{sigmoid}\) 函数的图像。通常都使用 \(z\) 来表示 \(w^{T}x + b\) 的值

\(\mathbf{sigmoid}\) 函数的公式： \(\sigma(z) = \frac{1}{1 + e^{-z}}\) , \(z\) 在这里是一个实数

这里要说明一些值得注意的事情：

• 如果 \(z\) 非常大，那么 \(e^{-z}\) 将会接近于0，而 \(\mathbf{sigmoid}\) 函数将会非常接近 1
• 相反地，如果 \(z\) 非常小或者说是一个绝对值很大的负数，那么关于 \(e^{-z}\) 这项会变成一个很大的数，所以这个就接近于 0

因此当实现逻辑回归时，让机器学习参数应用这个函数使得成为对概率的一个很好的估计

损失函数 Loss function 又叫做 误差函数 ，用来衡量算法的运行情况: \(\mathbf{L}(\hat{y}, y)\) 。通过这个称为 \(\mathbf{L}\) 的损失函数，来衡量预测输出值和实际值有多接近

一般损失函数用预测值和实际值的平方差或者它们平方差的一半，但是通常在逻辑回归中不这么做

因为在学习逻辑回归参数的时候，会发现优化目标不是凸优化，只能找到多个局部最优值，梯度下降法很可能找不到全局最优值

虽然平方差是一个不错的损失函数，但是在逻辑回归模型中会定义另外一个损失函数

在逻辑回归中用到的损失函数是：\(\mathbf{L}(\hat{y}, y) = -y\log{\hat{y}} - (1 - y)\log{(1-\hat{y})}\) . 为了更好地理解这个损失函数怎么起作用，举两个例子：

1. 当 \(y = 1\) 时损失函数 \(\mathbf{L} = -\log{\hat{y}}\) ，如果想要损失函数 \(\mathbf{L}\) 尽可能的小，那么 \(\hat{y}\) 就要尽可能大，因为 \(\mathbf{sigmoid}\) 函数取值是 \([0, 1]\) ，所以 \(\hat{y}\) 会无限接近于1
2. 当 \(y =0\) 时损失函数 \(\mathbf{L} = -\log{(1-\hat{y})}\) ，如果想要损失函数 \(\mathbf{L}\) 尽可能得小，那么 \(\hat{y}\) 就要尽可能小，因为 \(\mathbf{sigmoid}\) 函数取值是 \([0, 1]\) ，所以 \(\hat{y}\) 会无限接近于0

有很多的函数效果和现在这个类似，就是如果 \(y\) 等于1，就尽可能让 \(\hat{y}\) 变大，如果 \(y\) 等于0，就尽可能让 \(\hat{y}\) 变小

损失函数是在单个训练样本中定义的，它衡量的是算法在单个训练样本中表现如何，为了衡量算法在全部训练样本上的表现如何，需要定义一个算法的 代价函数 ，对 \(m\) 个样本的损失函数求和然后除以 \(m\) : \(\mathbf{J}(w, b) = \frac{1}{m} \cdot \sum_{i=1}^{m} \mathbf{L}\Big(\hat{y}^{(i)}, y^{(i)}\Big) = \frac{1}{m} \cdot \sum_{i=1}^{m} \Big(-y\log{\hat{y}} - (1 - y)\log{(1-\hat{y})}\Big)\)

损失函数只适用于像这样的单个训练样本，而代价函数是参数的总代价

所以在训练逻辑回归模型时候，需要找到合适的 w 和 b ，来让代价函数 J 的总代价降到最低

逻辑回归实际上可以看做是一个非常小的神经网络

在这个图中，横轴表示空间参数 \(w\) 和 \(b\)

在实践中，可以是更高的维度，但是为了更好地绘图，我们定义 w 和 b 都是单一实数

代价函数（成本函数）\(\mathbf{J}(w, b)\) 是在水平轴 \(w\) 和 \(b\) 上的曲面，因此曲面的高度就是在某一点的函数值。所做的就是找到使得代价函数（成本函数） \(\mathbf{J}(w, b)\) 函数值是最小值时所对应的参数 \(w\) 和 \(b\)

上图的代价函数（成本函数） \(\mathbf{J}(w, b)\) 是一个 凸函数 convex function ，像一个大碗一样

这与刚才的图有些相反，因为它是非凸的并且有很多不同的局部最小值

由于逻辑回归的代价函数（成本函数）特性，必须定义代价函数（成本函数）J(w, b) 为凸函数

上面看了一个例子使用流程计算图来计算函数J

现在清理一下流程图的描述，看看如何利用它计算出函数的导数

使用到的公式：

\(\frac{\mathrm{d} J}{\mathrm{d} u} = \frac{\mathrm{d} J}{\mathrm{d} v} \frac{\mathrm{d} v}{\mathrm{d} u}\) , \(\frac{\mathrm{d} J}{\mathrm{d} b} = \frac{\mathrm{d} J}{\mathrm{d} u} \frac{\mathrm{d} u}{\mathrm{d} b}\), \(\frac{\mathrm{d} J}{\mathrm{d} a} = \frac{\mathrm{d} J}{\mathrm{d} u} \frac{\mathrm{d} u}{\mathrm{d} a}\)

这是一个流程图：

假设要计算 \(\frac{\mathrm{d} J}{\mathrm{d} v}\) ，那要怎么算呢？比如说，把这个 \(v\) 值拿过来，改变一下，那么 \(J\) 的值会怎么变呢？定义上 \(J = 3v\) ，现在 \(v = 11\) ，如果让 \(v\) 增加一点点，比如到11.001，那么 \(J = 3v = 33.003\) ，最终结果是 \(J\) 上升到原来的3倍，所以 \(\frac{\mathrm{d} J}{\mathrm{d} v} = 3\) ，因为对于任何 \(v\) 的增量 \(J\) 都会有3倍增量

在反向传播算法中的术语：

如果想计算最后输出变量的导数，使用最关心的变量对的导数，那么就做完了一步反向传播

在这个流程图中是一个反向步骤

来看另一个例子， \(\frac{\mathrm{d} J}{\mathrm{d} a}\) 是多少呢？换句话说，如果提高 \(a\) 的数值，对 \(J\) 的数值有什么影响？变量 \(a = 5\) ，让它增加到5.001，那么对v的影响就是 \(a + v\) ，之前 \(v = 11\) ，现在变成11.001，\(J\) 就变成33.003了，所以如果让 \(a\) 增加0.001，\(J\) 增加0.003。这意味传播到流程图的最右 \(J\) 的增量是3乘以 \(a\) 的增量，也就说导数是3

一种解释这个计算过程的方式是：如果你改变了 \(a\) ，那么也会改变 \(v\) ，通过改变 \(v\) ，也会改变 \(J\) 。当提升这个值 \(a\) 一点点（0.001） , \(J\) 变化量是0.003

首先 \(a\) 增加了， \(v\) 也会增加， \(v\) 增加多少呢？这取决于 \(\frac{\mathrm{d} v}{\mathrm{d} a}\) ，然后 \(v\) 的变化导致 \(J\) 也在增加。如果 \(a\) 影响到 \(v\) ，\(v\) 影响到 \(J\) ，那么让 \(a\) 变大时， \(J\) 的变化量就是当改变 \(a\) 时， \(v\) 的变化量乘以 改变 \(v\) 时 \(J\) 的变化量，在微积分里这叫 链式法则

从这个计算中看到，如果让 \(a\) 增加0.001， \(v\) 也会变化相同的大小，所以 \(\frac{\mathrm{d} v}{\mathrm{d} a} = 1\) 。事实上，如果代入进去之前算过 \(\frac{\mathrm{d} J}{\mathrm{d} v} = 3\) ，所以两者乘积 \(3 \times 1\) ，实际上就给出了正确答案 \(\frac{\mathrm{d} J}{\mathrm{d} a} = 3\)

这图表示了如何计算 \(\frac{\mathrm{d} J}{\mathrm{d} v}\) ，就是 \(J\) 对变量 \(v\) 的导数，它可以帮助计算 \(\frac{\mathrm{d} J}{\mathrm{d} a}\) ，这是另一步反向传播计算

当编程实现反向传播时，通常会有一个 最终输出值 是要关心的，最终的输出变量，真正想要关心或者说优化的。在这种情况下最终的输出变量是 \(J\) ，就是流程图里最后一个符号，所以有很多计算尝试计算输出变量的导数，所以输出变量对某个变量的导数，就用 \(d_{var}\) 命名，还有各种中间变量比如 \(a, b, c, u, v\) ，当在软件里实现的时候，导数的变量名叫什么？在 python 中，可以写一个很长的变量名，比如 \(d_{FinalOutputVarDvar}\) ，但这个变量名有点长，就用 \(dJ_{var}\) ，但因为是一直对 \(J\) 求导，在代码里，就使用变量名 \(dvar\) ，来表示那个 \(J\) 对 \(var\) 的导数

这是使用新符号后的计算图，其中 \(dv = 3\) , \(da = 3\)

目前为止，一直在往回传播，并计算出 \(dv = 3\) ， \(dv\) 是代码里的变量名，其真正的定义是 \(\frac{\mathrm{d} J}{\mathrm{d} v}\) 。同样的 \(da =3\) ，\(da\) 是代码里的变量名，其实代表 \(\frac{\mathrm{d} J}{\mathrm{d} a}\) 的值

现在看变量 \(u\) ，那么 \(\frac{\mathrm{d} J}{\mathrm{d} u}\) 是多少呢？通过和之前类似的计算，现在从 \(u = 6\) 出发，如果令 \(u\) 增加到6.001，之前 \(v\) 是11，现在变成11.001了， \(J\) 就从33变成33.003，所以 \(J\) 增量是3倍，所以 \(\frac{\mathrm{d} J}{\mathrm{d} u} =3\) 。对 \(u\) 的分析很类似对 \(a\) 的分析，实际上这计算起来就是 \(\frac{\mathrm{d} J}{\mathrm{d} v} \cdot \frac{\mathrm{d} v}{\mathrm{d} u}\) ，有了这个，可以算出， \(\frac{\mathrm{d} J}{\mathrm{d} v} = 3 , \frac{\mathrm{d} v}{\mathrm{d} u} = 1\) ，最终算出结果是 \(3 \times 1 = 3\)

接下来一个例子是 \(\frac{\mathrm{d} J}{\mathrm{d} b}\) ，使用微积分链式法则，这可以写成两者的乘积，就是 \(\frac{\mathrm{d} J}{\mathrm{d} u} \cdot \frac{\mathrm{d} u}{\mathrm{d} b}\) 。 \(u\) 的定义是 \(b \cdot c\) ，所以 \(b = 3\) 时这是6，现在就变成6.002了，因为在例子中 \(c = 2\) ，所以这表明 \(\frac{\mathrm{d} u}{\mathrm{d} b} = 2\) 当让 \(b\) 增加0.001时， \(u\) 就增加两倍。前面已经计算过： \(\frac{\mathrm{d} J}{\mathrm{d} u} = 3\) ，因此 \(\frac{\mathrm{d} J}{\mathrm{d} b} = \frac{\mathrm{d} J}{\mathrm{d} u} \cdot \frac{\mathrm{d} u}{\mathrm{d} b} = 3 \times 2 = 6\)

下图是计算 \(du = 6\) 的反向计算图：

同样可以计算出 \(\frac{\mathrm{d} J}{\mathrm{d} c} = \frac{\mathrm{d} J}{\mathrm{d} u} \cdot \frac{\mathrm{d} u}{\mathrm{d} c} = 3 \times 3 = 9\) , 可以推出 \(dc = 9\)

当计算所有这些导数时，最有效率的办法是从右到左计算，跟着这个红色箭头走。特别是当第一次计算对 \(v\) 的导数时，之后在计算对 \(a\) 导数就可以用到。然后对 \(u\) 的导数，可以帮助计算对 \(b\) 和 \(c\) 的导数：

总结：一个计算流程图，就是 正向 从左到右 的计算来计算 代价函数 \(\mathbf{J}\) ，然后 反向 从右到左 计算 导数

如果想计算向量 \(u = Av\) ，矩阵乘法的定义就是：\(u_i = \sum_jA_{ij}v_i\) 使用非向量化实现

1. 初始化 \(u = np.zeros(n, 1)\)
2. 通过两层循环 \(for(i) : for(j) :\) ，得到 \(u[i] = u[i] + A[i][j] * v[j]\)

现在就有了 i 和 j 的两层循环，这就是非向量化

向量化方式就可以用 \(u = np.dot(A, v)\) ，使得代码运行速度更快

事实上，numpy库有很多向量化函数，比如：

• \(u=np.log(v)\) : 计算对数函数(log)
• \(u = np.exp(v)\) : 计算指数操作
• \(np.abs()\) : 计算数据的绝对值
• \(np.maximum()\) : 计算元素中的最大值
  • 也可以 \(np.maximum(v,0)\)
• \(v ** 2\) 代表获得元素 每个值得平方
• \(\frac{1}{v}\) 获取每个元素的倒数
• …….

所以当想写循环时候，检查numpy是否存在类似的内置函数，从而避免使用循环(loop)方式

那么，将刚才所学到的内容，运用在逻辑回归的梯度下降上，看看是否能简化两个计算过程中的某一步

逻辑回归的求导代码，有两层循环：

1. 如果有超过两个特征时，需要循环 \(\mathrm{d} w_1\) , \(\mathrm{d} w_2\) , \(\mathrm{d} w_3\) 等。所以 \(j\) 的实际值是1, 2 和 \(n_x\) 。如果想要消除第二循环，首先不用初始化 \(\mathrm{d} w_1\) , \(\mathrm{d} w_2\) 都等于0，而是定义 \(\mathrm{d} w\) 为一个向量，设置 \(dw = np.zeros(nx, 1)\) ，定义了一个 \(n_x\) 行的一维向量，从而替代循环
2. 使用了一个向量操作 \(\mathrm{d} w = \mathrm{d} w + x^{(i)}\mathrm{d} z^{(i)}\)
3. 最后 \(\mathrm{d} w = \frac{\mathrm{d} w}{m}\)

虽然通过将两层循环转成一层循环，但仍然还有一个for循环来训练样本

接下来需要解决这个问题

前面讨论过向量化是如何显著加速代码，接下来将讨论如何实现逻辑回归的向量化计算

这样就能处理整个数据集，甚至不会用一个明确的for循环就能实现对于整个数据集梯度下降算法的优化

如果你有 \(m\) 个训练样本：

1. 对第一个样本进行预测：
   • 使用这个熟悉的公式 \(z^{(1)} = w^Tx^{(1)} + b\) 计算 \(z\)
   • 计算激活函数 \(a^{(1)} = \sigma(z^{(1)})\)
   • 计算第一个样本的预测值 \(y^{(1)}\)
2. 对第二个样本进行预测，需要计算 \(z^{(2)} = w^Tx^{(2)} + b\) , \(a^{(2)} = \sigma(z^{(2)})\) , \(y^{(2)}\)
3. 对第三个样本进行预测，需要计算 \(z^{(3)} = w^Tx^{(3)} + b\) , \(a^{(3)} = \sigma(z^{(3)})\) , \(y^{(3)}\)
4. 依次类推

如果有 m 个训练样本，可能需要这样做  m 次

有没有办法可以并且不需要任何一个明确的for循环完成向前传播？ 

首先，曾经定义了一个矩阵 \(\mathbf{X}\) 作为 训练输入 (如下图中蓝色) 像这样在不同的列中堆积在一起。这是一个 \(n_x\) 行 \(m\) 列的矩阵。如果把它写为 numpy 的形式 \((n_x, m)\) ，这表示 \(\mathbf{X}\) 是一个 \(n_{x}\) 乘以 \({m}\) 的矩阵 \(\mathbb{R}^{n_x \times m}\)

首先在一个步骤中计算 \(z_1, z_2, \ldots z_m\) ：

1. 先构建一个 \(1 \times m\) 的矩阵，实际上它是一个 行向量
2. 同时准备计算 \(z^{(1)}\), \(z^{(2)}\) 一直到 \(z^{(m)}\) ，所有值都是在同一时间内完成

实际上计算结果可以表达为 \(w\) 的转置乘以大写矩阵 \(\mathbf{X}\) 然后加上向量 \([b, b, \ldots, b]\) , 也就是说 \([z^{(1)}, z^{(2)}, \ldots, z^{(m)}] = w^T \cdot \mathbf{X} + [b, b, \ldots, b]\) , 其中 \([b, b, \ldots, b]\) 是一个 \(1\times m\) 的向量或者 \(1\times m\) 的矩阵或者是一个 \(m\) 维的行向量。如果熟悉矩阵乘法，会发现的 \(w\) 转置乘以 \(x^{(1)}\) , \(x^{(2)}\) 一直到 \(x^{(m)}\) 。然后加上 \([b, b, \ldots, b]\) ，实际上将 \(b\) 加到了每个元素上。最终得到了另一个 \(1 \times m\) 的向量：

\([z^{(1)}, z^{(2)}, \ldots, z^{(m)}] = w^T \cdot \mathbf{X} + [b, b, \ldots, b] = [w^Tx{(1)} + b, w^Tx{(2)} + b, \ldots , w^Tx{(m)} + b]\) , 而 \(w^Tx{(1)} + b\) 第一个元素， \(w^Tx{(2)} + b\) 是第二个元素， \(w^Tx{(m)} + b\) 是第 \(m\) 个元素

第一个元素恰好是 \(z^{(1)}\) 的定义，第二个元素恰好是 \(z_{(2)}\) 的定义 …. 另外 \(\mathbf{X}\) 是一次获得的，在得到的训练样本，一个一个横向堆积起来。类似地也将 \([z^{(1)}, z^{(2)}, \ldots, z^{(m)}]\) 定义为大写的 \(\mathbf{Z}\) 。为了计算 \(w^T \cdot \mathbf{X} + [b, b, \ldots, b]\) ， numpy 代码只需要 \(Z = np.dot(w.T, X) + b\)

这里在Python中有一个巧妙的地方，这里 b 是一个实数，或者你可以说是一个 1 X 1 矩阵，只是一个普通的实数

但是将这个向量加上这个实数时，Python自动把这个实数 b 扩展成一个 1 X m 的行向量，这被称作广播 (brosdcasting)

它只用一行代码，用这一行代码，你可以计算Z，包含所有小写 z1 到 zm 的 1 X m 的矩阵

接下下来要做的就是找到一个同时计算 \([a^{(1)}, a^{(2)}, \ldots, a^{(m)}]\) 的方法。就像横向堆积小写 \(z\) 得到大写 \(\mathbf{Z}\) 一样，堆积小写变量 \(a\) 将形成一个新的变量，将它定义为大写 \(\mathbf{A}\) 。剩余地只需要编写一个支持向量化计算的 \(\mathbf{sigmoid}\) 函数：

\(\mathbf{A} = [a^{(1)}, a^{(2)}, \ldots, a^{(m)}] = \sigma(\mathbf{Z})\)

概括一下：已经学习了如何利用向量化在同一时间内高效地计算所有的激活函数的所有 a 值

接下来，也可以利用向量化高效地计算反向传播并以此来计算梯度