Lecture 3 · 浅层神经网络：隐藏层、激活函数与反向传播 · Shallow Neural Networks

对应 Maps to：Coursera Deep Learning Specialization C1M3 “Shallow Neural Networks”（Neural Networks Overview、Neural Network Representation、Computing a Neural Network’s Output、Vectorizing Across Multiple Examples、Explanation for Vectorized Implementation、Activation Functions、Why do you need Non-Linear Activation Functions?、Derivatives of Activation Functions、Gradient Descent for Neural Networks、Backpropagation Intuition、Random Initialization）；编程作业 Planar Data Classification with One Hidden Layer。在 Fall 2025 的课程表里，C1M3 和第 3 次课堂讲座（10/7，Full Cycle of a DL Project）在同一周，那次课堂讲座的内容放在本讲义第 11 讲。 依据说明：Coursera 的视频和编程作业只对注册学员开放，不能公开引用。本讲按 Andrew Ng 在 C1M3 里广为人知的内容来写：记号、公式和推导顺序，“花朵”数据的生成公式，以及作业里”隐藏单元数 1–50”的实验设计。作业的数据生成器照原公式用 numpy 重写，具体的点和原作业不同，所以数字也不同。激活函数的历史与性质依据原始论文（§13）。所有实验数字都来自配套代码。 配套代码 Code：code/lecture03/（numpy；5 个脚本 + 3 个工具模块。01、02 约 1 秒，04 约 27 秒，03、05 各约 45–50 秒） 预计阅读时间：3 小时（含运行代码）

0. 本讲导航 · How to read this lecture

0.1 学习目标 Learning goals

学完这一讲，你应该能够：

1. 用 Andrew Ng 的记号（上标 $[l]$ 表示层、上标 $(i)$ 表示样本、下标 $i$ 表示层内第几个单元）写出一个两层网络，说出每个量的形状，并解释为什么”一个隐藏层的网络”叫两层网络。
2. 从”一个样本、一个单元”的公式出发，推出向量化的前向传播 $Z^{[1]} = W^{[1]}X + b^{[1]}$……，并说清楚为什么把样本按列堆起来以后公式不变。
3. 画出 sigmoid、tanh、ReLU、Leaky ReLU 的形状，推导它们的导数，说出各自的优缺点，以及隐藏层和输出层分别该怎么选。
4. 证明并用实验验证：没有非线性激活，网络叠多少层都等于一层线性函数。线性激活的两层网络就是逻辑回归。
5. 独立推导两层网络反向传播的 6 个公式，做维度检查，并会用数值梯度检查自己的实现。
6. 解释为什么不能把权重初始化成 0（对称性），以及为什么初始权重要小（饱和）。
7. 看懂隐藏层大小怎样影响决策边界，认出过拟合（overfitting）的苗头。

0.2 先修与本讲范围 Prerequisites & scope

第 1 讲的 tiny_nn.py 是一个能处理任意层数的”黑盒”。本讲只看一个隐藏层的情形，把这个黑盒里的每一个公式摊开、推导、用实验验证。配套的 shallow_nn.py 从零实现了这个网络，函数划分和 Coursera 编程作业一样；代码 02 会验证它和 tiny_nn 算出的梯度完全一致。

0.3 本讲地图 Map

§1  为什么需要隐藏层：花朵数据上，逻辑回归 ≈ 抛硬币，4 个 tanh 单元 ≈ 94%      ← 代码 01 演示 1–2
§2  网络的表示：记号、形状、每个隐藏单元在做什么                                ← 代码 01 演示 3–4
§3  向量化：从一个样本到 m 个样本，为什么公式不变                                ← 代码 01 演示 3
§4  激活函数：sigmoid / tanh / ReLU / Leaky ReLU 的形状、导数与选择               ← 代码 03 演示 1、3
§5  为什么必须有非线性：线性激活的两层网络 = 逻辑回归                            ← 代码 03 演示 2
§6  梯度下降与反向传播：6 个公式的推导、维度检查、梯度检验                        ← 代码 02
§7  随机初始化：对称性，以及为什么要"小"                                        ← 代码 04
§8  隐藏层大小：决策边界、Bayes 上限、过拟合的苗头                               ← 代码 05
§9  拼起来：一个完整的训练流程（nn_model）                                       ← shallow_nn.py
§10–14  小结、常见误区、练习、延伸阅读、下一讲预告

0.4 记号 Notation（沿用第 1 讲 §0.4，本讲新增）

数层数：输入层记作第 0 层（$a^{[0]} = x$），不计入层数。所以”输入 → 一个隐藏层 → 输出层”是一个两层网络（2-layer neural network），$L = 2$。代码里写作 [n_x, n_h, 1]。

0.5 关于数字 · About the numbers

讲义里的实验数字都来自配套代码的实际输出（固定随机种子；每个演示用自己的随机数生成器；同一台机器上重复运行逐字相同，本讲没有计时类的数字）。数据是按 Coursera 作业的公式重新生成的，所以和原作业的数字不同。原作业报告的训练集准确率大约是：逻辑回归 47%，4 个隐藏单元 90%；我们这里是 51.0% 和 94.0%，趋势一致。代码 05 的准确率打印 4 位小数，其他脚本打印 3 位。有几处结果和我写代码前的预想不一样，讲义按实际结果来写，这些情况列在代码 README 的”关于实验结果”里。

1. 为什么需要一个隐藏层 · Why a hidden layer?

1.1 从第 2 讲出发

第 2 讲推导了逻辑回归：一个样本 $x$ 进来，算 $z = w^\top x + b$，再算 $a = \sigma(z)$ 作为”是正类的概率”；损失用交叉熵；反向传播时有一个漂亮的结果 $dz = a - y$；$m$ 个样本一起算时是 $dZ = A - Y$、$dw = \frac{1}{m} X\,dZ^\top$、$db = \frac1m \sum_i dz^{(i)}$。第 2 讲还强调：逻辑回归就是一个没有隐藏层的神经网络，只有一个 sigmoid 单元。

逻辑回归的决策边界是 $w^\top x + b = 0$，在二维平面上是一条直线（高维时是一个超平面）。直线一侧判为 1，另一侧判为 0。那么问题来了：如果两类数据不能用一条直线分开呢？

1.2 花朵数据

Coursera 的编程作业用了一个专门为此设计的数据集，因为点排成一朵花的形状，大家叫它”花朵”数据（load_planar_dataset）。生成方法是这样的（planar_data.py）：每类 200 个点，对第 $j$ 类（$j = 0, 1$）：

其中 $\epsilon_1, \epsilon_2$ 是标准正态噪声。$t$ 是角度，$r$ 是半径。$\sin(4t)$ 让半径随角度起伏，形成”花瓣”。$r$ 可以是负数，负半径相当于把点翻到原点的另一侧。正因为这个翻转，两类的花瓣交替出现：第 0 类本来只占 $t \in [0, 3.12]$ 的”上半圈”，但有一半花瓣被翻到了另一半。两个 0.2 的噪声让花瓣有了宽度，也让两类在花心附近和花瓣边缘互相重叠。所以这个数据集没有 100% 正确的分类器（§8.2 会算出最好能做到多少）。

仔细算一下还会发现一个细节（代码 01 演示 4 用到它）：8 片花瓣每片占 45°，但有两处是相邻的两片同色，所以绕原点一圈，颜色只变 6 次，而不是 8 次。

我们用这个生成器生成 400 个训练样本（和原作业一样），再用另一个种子独立生成 2000 个测试样本。测试集取 2000 个是为了让测试准确率更稳：400 个样本时，准确率本身就有约 ±1.5 个百分点的随机误差。

1.3 逻辑回归 vs 4 个隐藏单元

代码 01 演示 1–2 在花朵数据上训练了两个模型，都用学习率 1.2、10000 步全批量梯度下降（作业的设定）：

终端字符画（plot_tools.py）画出了两个模型的决策边界。背景 ' ' 表示模型预测第 0 类，'.' 表示预测第 1 类；o、x 是两类训练样本，大写的 O、X 是分错的点：

逻辑回归：训练 51.0%                         4 个 tanh 隐藏单元：训练 94.0%
+----------------------------------------+   +----------------------------------------+
|                                        |   |                                        |
|           oooX          oo             |   |           oooX          oo           ..|
|           oooXXo      oooo             |   |..         oooXXo      oooo         ....|
|            o  oo    oo   oo            |   |....        o  oo    oo   oo      ......|
|                 oo  o    o             |   |.......          oo  o    o    .........|
|    X        o    o oX   o        XX    |   |....x....    o    o oX   o   .....xx....|
|  XXXX X XXX oo   Xoo   ooXX XX XXX XX  |   |..xxxx.x.xxx oo   Xoo   ooXx.xx.xxx.xx..|
|    X       X Xo   Xo   * X      XXX X  |   |....x.......x.Xo   Xo   *.x......xxx.x..|
|     X XX      Xoo X o*X      XXXX  ....|   |.....x.xx......xOo X o*x......xxxx......|
|          X   XXXoX*oXXXXx.x.x..........|   |..........x...xxxOx*Oxxxxx.x.x..........|
|         ooooooO.x.OxxOO.O.OOOO.........|   |         ooooooo X OxXoo o oooo         |
|    OOOO......OO*x......O.....O.OO......|   |    oooo      oo*x..... o     o oo      |
|...O.O.....O.OOx...O...x.OOO.......O....|   |   o o     o oOx...O...x.Ooo       o    |
|..OOOOOOO.OO..x...x.x...x..OOO.OOOOOO...|   |  ooooooo oo..x...x.x...x..Ooo oooooo   |
|....................x....xx.............|   |          ..........x....xx....         |
|............x....xO..x....x.............|   |        ....x....xO..x....x......       |
|............x....x....x....x............|   |     .......x....x....x....x........    |
|...........xxxxx.......x.xxx............|   |   ........xxxxx.......x.xxx..........  |
|...........xxxxx........xxxx............|   | ..........xxxxx........xxxx............|
|........................................|   |........................................|
+----------------------------------------+   +----------------------------------------+

左边满屏的大写字母：逻辑回归学到的边界是 $0.049\,x_1 - 0.267\,x_2 - 0.010 = 0$，一条几乎水平的直线。花瓣绕着中心交替排列，任何一条直线两侧都是两类各占一半，所以 51% 并不是梯度下降没收敛，而是模型本身只能画直线。这种”模型太简单、再多数据和训练也没用”的情况叫 high bias（偏差大），第 6 讲会系统地诊断它。

右边只多了 4 个隐藏单元（参数从 3 个变成 17 个），'.' 区域就被切成了几块扇形，大致贴合了花瓣，训练准确率 94.0%，测试准确率 90.6%。

训练过程（每 1000 步记录一次，节选）：

第 0 步的 cost 是 $0.6932 \approx \ln 2$：权重很小时网络对每个样本都输出约 0.5，“完全没把握”时的交叉熵就是 $\ln 2$。前 1000 步就学会了大部分东西，之后 cost 还在慢慢降，准确率基本不动。

一个隐藏层到底多做了什么？ 这是 §2 的问题。先给答案：每个隐藏单元本身就是一个”小逻辑回归”，各自画一条直线；输出层再把这几条直线的判断组合起来。4 条直线组合起来，就能围出直线画不出的形状。

2. 网络的表示 · Neural network representation

2.1 输入层、隐藏层、输出层

   输入层（第 0 层）        隐藏层（第 1 层）              输出层（第 2 层）

        x₁ ─────────┬──────→ ○  a₁[1] ─┐
              ╲   ╱ ├──────→ ○  a₂[1] ─┤
               ╲ ╱  │                   ├──────→ ○  a[2] = ŷ
               ╱ ╲  ├──────→ ○  a₃[1] ─┤
        x₂ ───╱───╲─┴──────→ ○  a₄[1] ─┘
                   （每个输入连到每个隐藏单元：全连接）

• 输入层就是 $x$ 本身，记作 $a^{[0]} = x$。它不做任何计算，所以不算一层。
• 隐藏层（hidden layer）：“隐藏”的意思是：训练集里有 $x$ 也有 $y$，但没有隐藏单元”应该输出什么”的标准答案。它们的值由网络自己在训练中决定（第 1 讲 §2.3 的”自动学出中间特征”）。
• 输出层输出 $\hat y = a^{[2]}$。二分类时它是一个 sigmoid 单元。

2.2 每个圆圈做两件事

Andrew Ng 讲”Computing a Neural Network’s Output”时，先只看一个圆圈。每个圆圈都做和逻辑回归一模一样的两件事：

隐藏层的 4 个单元各有自己的 $w$ 和 $b$，各自算一遍：

写 4 遍太啰嗦。把 4 个 $w^{[1]\top}_i$ 竖着叠成一个矩阵的 4 行，4 个 $b^{[1]}_i$ 叠成一个列向量：

于是一个样本的前向传播只要四行：

后两行就是”以 $a^{[1]}$ 为输入的逻辑回归”。所以一个两层网络 = 4 个并排的逻辑回归（隐藏层）+ 一个以它们的输出为输入的逻辑回归（输出层）。区别只在于：隐藏层的 4 个”逻辑回归”没有自己的标签，它们的参数由输出层的误差反向传回来决定（§6）。

代码 01 演示 3 的函数 forward_loop_units 就是照这个”每个圆圈做两件事”的方式，用两重 for 循环一个单元、一个样本地算，结果和矩阵写法一样（§3.4）。

2.3 形状

代码 01 演示 3 打印了花朵数据上（$n_x = 2$、$n_h = 4$、$m = 400$）每个量的形状：

规律只有一条：$W^{[l]}$ 的形状是（本层单元数, 上一层单元数）。参数个数是 $n_h n_x + n_h + n_h + 1$，$n_h = 4$ 时 $8 + 4 + 4 + 1 = 17$。

2.4 每个隐藏单元在做什么

隐藏单元算的是 $\tanh(w_1 x_1 + w_2 x_2 + b)$：在直线 $w_1x_1 + w_2x_2 + b = 0$ 的一侧接近 +1，另一侧接近 −1，越过直线时平滑地翻转。可以把它想成一个**“软开关”**。$\|w\|$ 越大，翻转得越陡，越接近一个硬开关。

代码 01 演示 4 把训练好的 4 个单元逐个拿出来看：

单元 #0：a > 0 处为 '.'  单元 #1：a > 0 处为 '.'  单元 #2：a > 0 处为 '.'  单元 #3：a > 0 处为 '.'
+--------------------+  +--------------------+  +--------------------+  +--------------------+
|                    |  |                    |  |....................|  |    ................|
|.                   |  |                 ...|  |....................|  |         ...........|
|....                |  |               .....|  |....................|  |              ......|
|......              |  |             .......|  |....................|  |                  ..|
|.........           |  |           .........|  |....................|  |                    |
|...........         |  |         ...........|  |                    |  |                    |
|..............      |  |      ..............|  |                    |  |                    |
|................    |  |    ................|  |                    |  |                    |
|................... |  |  ..................|  |                    |  |                    |
|....................|  |....................|  |                    |  |                    |
+--------------------+  +--------------------+  +--------------------+  +--------------------+

这张表比准确率更能说明网络学到了什么：

1. 3 个单元（#0、#1、#2）是几乎穿过原点的直线，权重很大，90% 以上的样本上”开关拨到了底”。花朵的花瓣从中心辐射出去，有用的分界线自然也从中心出发。
2. 3 条过原点的直线把平面切成 6 个扇形，正好对应 §1.2 说的”绕一圈颜色变 6 次”。
3. 单元 #3 几乎没被用上：权重小得多、从不饱和，在整个数据范围内输出只在 −0.84 到 0.22 之间平缓变化，是一个”斜坡”而不是”开关”。4 个单元里有 1 个是多余的。这预告了 §8 的结果：$n_h = 3$ 就够了。
4. 输出层在”投票”：$\hat y = \sigma(7.70\,a_0 + 5.59\,a_1 + 11.88\,a_2 - 3.33\,a_3 - 1.22)$。每跨过一条直线，就有一个开关从 −1 翻到 +1（或反过来），投票结果随之改变，于是拼出了扇形相间的边界。

没有人告诉网络”要用过原点的直线”或者”要切成 6 个扇形”。这是梯度下降为了降低 cost 自己找到的中间特征，和第 1 讲 §2.3 里网络自己学出 walkability 是同一件事，只不过这里能直接画出来看。

3. 向量化：从一个样本到 m 个样本 · Vectorizing across examples

3.1 对样本循环

§2.2 的四行公式只处理一个样本。$m$ 个样本最直接的写法是循环：

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

第 1 讲 §4.4 和第 2 讲都讲过，Python 循环比矩阵运算慢几百到几千倍。我们想要一次算完所有样本。

3.2 把样本横着堆起来

把 $m$ 个样本的列向量横着排成矩阵（第 1 讲的约定），中间结果也一样横着排：

于是四行公式变成：

和单个样本的公式一模一样，只是小写换成了大写。在矩阵 $Z^{[1]}$、$A^{[1]}$ 里：

• 横着走（换列）= 换样本：第 $j$ 列是第 $j$ 个样本在所有隐藏单元上的值；
• 竖着走（换行）= 换隐藏单元：第 $i$ 行是第 $i$ 个隐藏单元对所有样本的输出。

代码 01 演示 3 打印了一个例子：$A^{[1]}$ 的第 7 列是 $[-1, -1, 1, 0.1309]$，即第 7 个样本在 4 个隐藏单元上的输出（竖着读）；第 0 行的前 5 个是 $[-1, -1, -1, 1, -1]$，即第 0 个单元对前 5 个样本的输出（横着读）。

3.3 为什么公式不变？

这是 Ng 的视频 “Explanation for Vectorized Implementation” 要回答的问题。为了简单，先假设 $b^{[1]} = 0$。矩阵乘法可以按列拆开看：

$W^{[1]}X$ 的第 $j$ 列只和 $X$ 的第 $j$ 列有关，恰好就是第 $j$ 个样本的 $z^{[1]{}(j)}$。再加上 $b^{[1]}$：它的形状是 $(n_h, 1)$，加到 $(n_h, m)$ 的矩阵上时，numpy 把它复制到每一列（广播），等于给每个样本都加上同一个 $b^{[1]}$。激活函数是逐元素的，不在乎有几列。第二层同理。

所以向量化不是近似，它和逐个样本算是同一个计算，只是把循环交给了 numpy 底层的线性代数库。

3.4 代码验证

代码 01 演示 3 用三种写法算同一个 $A^{[2]}$：

4.4e−16 是浮点数的舍入误差（加法的顺序不同，最后一位可能不同），数学上三者完全相等。

4. 激活函数 · Activation functions

到目前为止隐藏层用的都是 tanh。为什么不用 sigmoid？为什么现代网络大多用 ReLU？输出层又该用什么？

4.1 四个候选

（这张图由 03_activation_functions.py 生成；没装 matplotlib 时脚本只打印下面的表。）

代码 03 演示 1 在一排 $z$ 上算出了取值和导数（节选）：

4.2 导数的推导 · Derivatives of activation functions

反向传播要用到 $g'(z)$（§6），所以先把四个导数推出来。

sigmoid。$\sigma(z) = (1 + e^{-z})^{-1}$，用链式法则：

最后一步用了 $\frac{e^{-z}}{1 + e^{-z}} = 1 - \frac{1}{1 + e^{-z}}$。记 $a = \sigma(z)$，则 $\sigma'(z) = a(1 - a)$。$a(1-a)$ 在 $a = 1/2$（即 $z = 0$）时最大，等于 1/4。

tanh。用商的求导法则，记 $u = e^z - e^{-z}$、$v = e^z + e^{-z}$，注意 $u' = v$、$v' = u$：

记 $a = \tanh(z)$，则 $\tanh'(z) = 1 - a^2$，在 $z = 0$ 处最大，等于 1。

ReLU：$z > 0$ 时导数是 1，$z < 0$ 时是 0。Leaky ReLU：$z > 0$ 时是 1，$z < 0$ 时是 0.01。

两个实现细节：

• sigmoid 和 tanh 的导数都能用前向时已经算好的 $a$ 表示。反向传播时不用再算一次指数，直接用缓存里的 $A^{[1]}$：dZ1 = dA1 * (1 - A1**2)。这也是它们好用的原因之一。
• ReLU 在 $z = 0$ 处严格来说不可导（左导数 0、右导数 1）。实践中随便约定一边就行（代码里归到 0），因为浮点数恰好等于 0 的概率几乎为零，对训练没有影响。数学上这叫取一个”次梯度”（subgradient）。

代码 03 演示 1 用数值导数 $[g(z+h) - g(z-h)]/(2h)$ 在 $[-6, 6]$ 上核对了这四个公式，最大误差分别是 8.5e−11、7.4e−11、1.4e−10、1.4e−10（跳过了 $z = 0$）。

4.3 为什么隐藏层里 tanh 通常比 sigmoid 好

Ng 在视频里说得很直接：隐藏层几乎总是用 tanh 比 sigmoid 好，sigmoid 只留给二分类的输出层。理由有两个，第三点是一个常被忽略的事实。

① 导数大 4 倍。 $\sigma'$ 最大 0.25，$\tanh'$ 最大 1。反向传播时梯度要乘上 $g'(z)$（§6.2），用 sigmoid 时每穿过一层至少打 4 折。第 1 讲代码 04 已经看到，在 5 层 sigmoid 网络里这会让第 1 层的梯度只剩输出层的约 1/2000。

② 以 0 为中心（zero-centered）。 当 $z$ 来自标准正态分布时，代码 03 演示 1 算出的平均输出是：tanh 0.000，sigmoid 0.500，ReLU 0.400，Leaky ReLU 0.396。为什么”平均值在 0 附近”重要？看下一层的权重梯度。单个样本对 $W^{[2]}$ 的梯度是

$dz^{[2]{}(i)}$ 是一个数，$a^{[1]{}(i)}$ 是一个向量。如果 $a^{[1]}$ 的分量全是正的（sigmoid 的输出在 (0, 1)），那么这个样本给 $W^{[2]}$ 的每个分量的梯度符号都一样：要么全部往上推，要么全部往下推。想让一个权重变大、另一个变小，就只能靠不同样本之间互相抵消，走”之”字形的路线。这个论证最早出自 LeCun 等人的 Efficient BackProp（1998）。代码 03 演示 1 在花朵数据上直接数了一下：

（Leaky ReLU 的负输出 $0.01z$ 虽然小，符号却是负的，所以”全部同号”的比例也低。但它的平均值是 0.396，离零中心还远。这个统计只看符号，不看大小。）

③ 两者能表示的函数完全一样。 有一个恒等式：

所以任何 sigmoid 隐藏层的网络，都可以精确地改写成 tanh 隐藏层的网络：把 $W^{[1]}, b^{[1]}, W^{[2]}$ 减半，$b^{[2]}$ 加上 $\sum_j W^{[2]}_j / 2$（练习 3）。代码 03 演示 3 末尾验证了，改写前后的输出最大差别是 2.2e−16。这说明 sigmoid 和 tanh 的差别不在”能表示什么”，而在”梯度下降走得顺不顺”。代码 03 演示 3 的实验（§4.6）也是这样：两者最终准确率几乎一样，tanh 只是快得多。

4.4 为什么 ReLU 成了默认选择

sigmoid 和 tanh 有一个共同的毛病：饱和（saturation）。代码 03 演示 1：$|z| > 4.59$ 时 $\sigma'(z) < 0.01$，$|z| > 3.00$ 时 $\tanh'(z) < 0.01$。$z$ 一旦跑到这些区域，“推一下几乎没反应”，梯度传不回去，学习就停滞了。

ReLU 在 $z > 0$ 时导数恒等于 1，不会饱和。它的好处：

1. 梯度不衰减：正半轴上梯度原样通过，深层网络里不会一层层被打折（第 1 讲代码 04：ReLU 深网在很宽的学习率范围内 100–200 步就学会了，sigmoid 深网只在很窄的范围内能训练）；
2. 计算便宜：一个比较和一次取最大值，没有指数运算；
3. 稀疏：负半轴的输出恰好是 0，一部分单元对某个样本”完全不激活”。

它也有缺点：

• dead ReLU：如果某个单元对所有训练样本都有 $z < 0$，它的梯度永远是 0，再也学不动了（第 1 讲练习 1(d) 已经见过这个现象）。学习率太大或者初始化不好时容易出现。Leaky ReLU 在负半轴保留 0.01 的斜率，就是为了让这些单元还能”活过来”。它由 Maas、Hannun 和 Ng（2013）在语音识别网络里提出。
• 不是零中心的：§4.3 的”全部同号”问题它也有（100%），但它照样是最常用的激活函数。可见零中心是一个加分项，不是决定性的。

历史上，ReLU 在 2010–2012 年间流行起来：Nair & Hinton（2010）、Glorot、Bordes & Bengio（2011）展示了它在深层网络里好训练；AlexNet（2012）报告用 ReLU 的卷积网络在 CIFAR-10 上达到 25% 训练误差的速度是 tanh 的约 6 倍。今天的 Transformer 大多用 ReLU 的平滑变体，比如 GELU（BERT、GPT 系列）或 SwiGLU（LLaMA 等）。

4.5 输出层用什么

输出层的激活函数由输出 $y$ 是什么决定，和隐藏层的选择是两回事：

这几乎是唯一应该用线性激活的地方。隐藏层用线性激活会怎样？那是 §5 的主题。

4.6 实验：同一个任务上，谁学得快？

代码 03 演示 3 用五种隐藏层激活，在三个数据集（花朵；§8 会用到的同心圆、两个月牙）上各训练一个 [2, 20, 1] 网络。学习率 1.2，10000 步，每种组合 3 个初始化种子（2、3、4）。“达到门槛”指训练准确率第一次达到：花朵 85%、同心圆 75%、月牙 95%（明显好于逻辑回归、接近该数据集能达到的水平）。

(a) 作业的设定：$W = 0.01 \times$ 随机数

(b) 只换初始化：$W$ 的标准差改成 1（对 2 个输入的 ReLU 层，这正好是第 7 讲 He 初始化给出的 $\sqrt{2/n_x}$）

读这两张表时，我原本预想的是”ReLU 最快、准确率不输 tanh”。实际结果更复杂：

1. linear 永远达不到门槛，三个数据集上都等于逻辑回归（§5）。非线性是必需品。
2. sigmoid vs tanh：最终准确率几乎一样（花朵 0.908 vs 0.902），这和 §4.3 的第 ③ 点吻合：两者能表示的函数相同。差别在速度：同样的学习率下，tanh 达到门槛的步数少得多（花朵中位数 100 vs 400，同心圆 1000 vs 4500）。sigmoid 在月牙上还有 2 个种子停在了 0.88 左右的差解上。
3. ReLU / Leaky ReLU 的表现取决于数据集和初始化：同心圆上它们最快（200 步）。但在作业的 0.01 初始化下，花朵和月牙上它们停在明显更差的解（测试 0.820、0.882，tanh 是 0.902、0.963）。换成更大的初始化（表 b）后，月牙上 ReLU 追平了 tanh（0.963 vs 0.964），花朵上仍然落后（0.835 vs 0.895）。我在写代码的原型阶段还试过学习率 0.1 和 0.3、训练 30000 步，花朵上 ReLU 也一直落后。

为什么花朵上 tanh 更好？一个可能的解释（我没有专门做实验验证）：§2.4 看到，花朵需要的是几条过原点的”开关”，每个开关的输出和点离原点多远无关。tanh 单元饱和以后正好是这样的有界开关；ReLU 单元却是一个随距离线性增长的”斜坡”，离中心越远输出越大，要拼出”扇形”就别扭得多。初始化太小对 ReLU 尤其不利，这一点第 7 讲会从”信号的方差”角度解释。

所以”隐藏层默认用 ReLU”是针对深层网络的经验法则：它的主要优势是梯度穿过很多层时不衰减、计算便宜，这些在只有一个隐藏层、输入只有 2 维的小问题上都不重要。Ng 自己的建议也不是”永远用 ReLU”，而是：拿不准的时候，几种都试一试，在验证集上比较（第 6 讲讲怎样建立验证集）。

4.7 选择建议

5. 为什么必须有非线性 · Why non-linear activations?

5.1 线性的叠加还是线性

第 1 讲 §2.4 用一行公式说明过：两层没有激活函数的线性变换合起来还是一个线性变换。现在把它说完整。设隐藏层用线性激活 $g^{[1]}(z) = z$：

$W'$ 的形状是 $(1, n_h)(n_h, n_x) = (1, n_x)$，和逻辑回归的 $w^\top$ 一样。所以

这就是一个逻辑回归。不管 $n_h$ 是 4 还是 4000，不管叠多少个线性层（用归纳法：每多一层，就多乘一个矩阵、多加一个向量，结果仍是”矩阵 × x + 向量”），整个网络能表示的函数都和一个线性层（再加一个输出激活）完全相同。隐藏层的意义就在于它的非线性。

5.2 实验：线性激活的两层网络 = 逻辑回归

代码 03 演示 2 把隐藏层激活换成 $g(z) = z$，用和 §1.3 一样的设定训练：

再把训练好的 [2, 4, 1] “压扁”：

• 网络：$W' = W^{[2]}W^{[1]} = [0.049, -0.267]$，$b' = W^{[2]}b^{[1]} + b^{[2]} = -0.010$；
• 单独训练的逻辑回归：$w^\top = [0.049, -0.267]$，$b = -0.010$；
• 网络输出 $A^{[2]}$ 和 $\sigma(W'x + b')$ 在测试集上的最大差别：1.1e−16。

线性激活的网络不只是”准确率和逻辑回归差不多”：它的决策边界就是逻辑回归那条直线（代码里的字符画两张图都是 §1.3 左边那张），参数压扁以后和逻辑回归在 3 位小数上相同。[2, 50, 1] 多出来的 198 个参数一个都没用上，只是把同一个线性函数用更啰嗦的方式写了一遍。

我原本以为，换成"$W^{[2]}W^{[1]}$"这种乘积形式的参数化以后（它对参数不再是凸的），梯度下降可能停在别的地方。实际上它找到的正是逻辑回归的那个最优解。

5.3 线性激活什么时候可以用

• 回归任务的输出层（§4.5）：输出本来就是一个实数，不需要再压缩。
• 隐藏层几乎从不用线性激活。偶尔会看到不带激活函数的线性层，比如把向量投影到另一个维度（第 17 讲 Transformer 里的 $Q, K, V$ 投影），但它们前后总有别的非线性（比如 softmax 注意力），整体仍是非线性的。

6. 梯度下降与反向传播 · Gradient descent & backpropagation

这是本讲的核心：两层网络的梯度到底怎么算。

6.1 要算什么

参数：$W^{[1]}\ (n_h, n_x)$，$b^{[1]}\ (n_h, 1)$，$W^{[2]}\ (1, n_h)$，$b^{[2]}\ (1, 1)$。Cost：

梯度下降（Ng 的 “Gradient Descent for Neural Networks”）：

随机初始化参数（§7）
重复：
    前向传播：算出所有样本的预测 A[2]
    反向传播：算出 dW[1], db[1], dW[2], db[2]
    更新：W[1] ← W[1] − α dW[1]，b[1] ← b[1] − α db[1]，W[2]、b[2] 同理

前向传播 §3 已经有了。下面推导反向传播：先推一个样本的，再向量化。

6.2 一个样本的推导

计算图（第 2 讲的工具）：

x ──┐
W[1]─┼─→ z[1] = W[1]x + b[1] ─→ a[1] = g(z[1]) ──┐
b[1]─┘                                          W[2]─┼─→ z[2] = W[2]a[1] + b[2] ─→ a[2] = σ(z[2]) ─→ L(a[2], y)
                                                b[2]─┘
     ←─────────── 反向传播：从右往左，每一步乘上"局部导数" ───────────

从最右边往左走，每一步只用链式法则：

第 ① 步：$dz^{[2]}$。 第 2 讲推导过 sigmoid + 交叉熵的组合：$\frac{\partial \mathcal L}{\partial a} = -\frac{y}{a} + \frac{1-y}{1-a}$，乘上 $\sigma'(z) = a(1-a)$，化简后

第 ② 步：$dW^{[2]}$、$db^{[2]}$。 $z^{[2]} = \sum_j W^{[2]}_{j}\, a^{[1]}_j + b^{[2]}$（$W^{[2]}$ 只有一行，$W^{[2]}_j$ 是它的第 $j$ 个元素）。$z^{[2]}$ 对 $W^{[2]}_j$ 的偏导是 $a^{[1]}_j$，所以

和逻辑回归的 $dw = x\,dz$ 完全一样，只是”输入”换成了 $a^{[1]}$。（$W^{[2]}$ 是行向量，所以写成 $dz\,a^\top$ 而不是 $a\,dz$。）

第 ③ 步：把误差传回隐藏层，$da^{[1]}$。 $z^{[2]}$ 对 $a^{[1]}_j$ 的偏导是 $W^{[2]}_j$，所以

这一步是反向传播和逻辑回归真正不同的地方：输出的误差按输出权重分配给每个隐藏单元。输出权重大的单元，对 $z^{[2]}$ 的影响大，分到的”责任”也大；输出权重是负的单元，被要求往反方向变。

第 ④ 步：穿过激活函数，$dz^{[1]}$。 $a^{[1]}_j = g(z^{[1]}_j)$，每个单元只依赖自己的 $z$，所以是逐元素相乘：

$g'$ 在这里起”阀门”的作用：tanh 单元饱和时 $g' \approx 0$，不管输出层传回多大的误差，这个单元都几乎收不到梯度。§4.4 的”饱和”、§7.4 的”初始化太大”，问题都出在这里。

第 ⑤ 步：$dW^{[1]}$、$db^{[1]}$。 和第 ② 步一样，只是输入换成 $x$：

这一步是一个外积：$dW^{[1]}_{jk} = dz^{[1]}_j \cdot x_k$，即”第 $j$ 个单元该改多少” × “第 $k$ 个输入有多大”。

6.3 向量化：m 个样本的 6 个公式

把样本按列堆起来，对 $J$（$m$ 个损失的平均）求导：

shallow_nn.py 的 backward_propagation 就是这 6 行，旁边标着”公式 (1)–(6)“。几个值得想清楚的地方：

• $1/m$ 放在哪里？ Ng 的约定是：$dZ$ 存的是”每个样本自己的”$\partial\mathcal{L}^{(i)}/\partial z^{(i)}$，不带 $1/m$；$1/m$ 只在算 $dW$、$db$ 时出现，因为 $J$ 是 $m$ 个样本的平均。
• 矩阵乘法自动完成了对样本的求和。 $dW^{[1]}$ 本该是 $\frac1m\sum_i dz^{[1]{}(i)} x^{(i)\top}$。按”列 × 行”展开矩阵乘法，$dZ^{[1]}X^\top = \sum_i dZ^{[1]}_{:,i}\, X_{:,i}^\top$，正好就是这个求和。$db$ 没有可以乘的输入，所以显式地 np.sum(..., axis=1)。
• keepdims=True 让 $db$ 保持 $(n, 1)$ 的二维形状。忘了它会怎样，见 §6.4。
• 公式 (4) 里的 $*$ 是逐元素乘法：$W^{[2]\top}dZ^{[2]}$ 是 $(n_h, 1)(1, m) = (n_h, m)$，$g'(Z^{[1]})$ 也是 $(n_h, m)$，两者对应位置相乘。tanh 时 $g'(Z^{[1]}) = 1 - A^{[1]2}$，用缓存里的 $A^{[1]}$ 直接算。

把这 6 行和 §1.1 回顾的逻辑回归对比：公式 (1)–(3) 就是”输入为 $A^{[1]}$ 的逻辑回归”；公式 (5)–(6) 就是”误差为 $dZ^{[1]}$ 的逻辑回归”；新东西只有公式 (4)，它把误差从输出层传回了隐藏层。第 4 讲会看到，$L$ 层网络无非是把公式 (4)–(6) 重复 $L-1$ 次。

6.4 维度检查 · Getting the dimensions right

Ng 在 “Backpropagation Intuition” 里说，实现反向传播时最容易出错的就是维度。规则只有两条：

$dW$ 和 $W$ 同形状，$dZ$ 和 $Z$ 同形状（$db$ 和 $b$ 同形状）。

代码 02 演示 2 在花朵数据上逐个检查：

形状还能告诉你转置放在哪里：$dW^{[2]}$ 必须是 $(1, n_h)$，手里有 $dZ^{[2]}\ (1, m)$ 和 $A^{[1]}\ (n_h, m)$，唯一能凑出 $(1, n_h)$ 的乘法就是 $dZ^{[2]}A^{[1]\top}$。

演示 2 还故意制造了两个形状 bug：

1. 把公式 (4) 的 $*$ 写成矩阵乘法 @：$(4, 400)$ @ $(4, 400)$ 维度对不上，numpy 立刻报错。这是”幸运”的 bug。
2. 求 $db^{[1]}$ 时忘了 keepdims=True：$db^{[1]}$ 变成形状 $(4,)$ 的一维数组，$b^{[1]} - \alpha\,db^{[1]}$ 被悄悄广播成 $(4, 4)$，更新这一步不报错。错误要到下一次前向传播 $Z^{[1]} = W^{[1]}X + b^{[1]}$ 才暴露，而报错信息指向的是前向传播函数，离真正写错的那一行很远。更糟的是 $b^{[2]}$ 碰巧没事（$(1,1) - (1,) = (1,1)$），这种”有时对、有时错”的 bug 最难查。这是第 1 讲 §3.5 的 rank-1 数组陷阱在反向传播里的样子。

6.5 手算一遍

公式推完了，用一个能手算的例子把每个数都过一遍。代码 02 演示 1：2 个输入、2 个 tanh 隐藏单元、1 个样本。$x = (1, 0.5)^\top$，$y = 1$，$W^{[1]} = \begin{bmatrix} 1 & -1 \\ 0.5 & 0.5 \end{bmatrix}$，$b^{[1]} = 0$，$W^{[2]} = [1, -2]$，$b^{[2]} = 0$。（$m = 1$，所以没有 $1/m$。）

逐行读一下，这就是 “Backpropagation Intuition” 想传达的东西：

• 网络预测 0.3083，真实答案是 1，预测偏低。$dz^{[2]} = -0.6917 < 0$ 表示”$z^{[2]}$ 应该变大”（梯度下降沿负梯度方向走）。
• $da^{[1]}$ 把误差按输出权重分回去：单元 0 的输出权重是 +1，它被要求”变大”（$-0.6917$）；单元 1 的输出权重是 −2，它反而被要求”变小”（$+1.3834$），而且责任是单元 0 的两倍。
• 再乘上 $g'$：单元 1 的 $z$ 更大、更接近饱和，斜率只有 0.5966（单元 0 是 0.7864），所以它分到的梯度被打了更大的折扣。
• 数值导数逐项核对，四个参数的相对误差都不超过 4.4e−10。用学习率 0.5 走一步，$\hat y$ 从 0.3083 升到 0.8311，损失从 1.1768 降到 0.1850，方向是对的。

6.6 梯度检验：点到为止 · Gradient checking (preview)

推导和代码都可能出错，而反向传播的 bug 往往不报错：网络照样训练，只是学得慢或者学得差。最可靠的检查办法是数值梯度：把某个参数推一下，看 $J$ 变多少。

用双边差分是因为它的误差是 $O(\varepsilon^2)$，单边差分 $[J(\theta+\varepsilon) - J(\theta)]/\varepsilon$ 的误差是 $O(\varepsilon)$。Ng 的经验标准：相对误差约 1e−7 很好；约 1e−5 大概没问题，但要再看看；约 1e−3 很可能有 bug。（第 7 讲会系统地讲梯度检验的用法和注意事项，比如不要和 dropout 一起用。）

代码 02 演示 3 用 gradient_check 检查了正确的实现和三个故意写错的版本：