前馈神经网络与反向传播

前馈神经网络与反向传播

Jackknifer
Jackknifer 博主

一个前馈神经网络由多层线性变换和非线性激活函数组成。训练时,网络先计算预测与损失,再利用链式法则将损失的梯度逐层传回各个参数。本文从神经元的计算开始,解释异或函数、常见激活函数、损失函数与反向传播,使用完整的数值例子推导矩阵公式,并说明参数初始化、Dropout、BatchNorm 和 PyTorch 中的训练过程。[1][2]

1 前馈神经网络如何计算

1.1 一个神经元

假设输入为 x1,x2x_1,x_2,神经元先进行加权求和:

z=w1x1+w2x2+b.z=w_1x_1+w_2x_2+b.

其中,w1,w2w_1,w_2 是权重,bb 是截距项。神经元随后通过激活函数 ff 计算输出:

a=f(z).a=f(z).

权重决定输入对计算结果的影响,截距项改变激活函数的作用位置。若将多个神经元组合为一层,使用列向量表示输入,便有:

z(l)=W(l)a(l−1)+b(l),a(l)=f(z(l)).\boldsymbol z^{(l)} =W^{(l)}\boldsymbol a^{(l-1)}+\boldsymbol b^{(l)}, \qquad \boldsymbol a^{(l)}=f(\boldsymbol z^{(l)}).

这里 a(0)=x\boldsymbol a^{(0)}=\boldsymbol x。若第 l−1l-1 层包含 nn 个输出,第 ll 层包含 mm 个神经元,则:

W(l)∈Rm×n,a(l−1)∈Rn×1,z(l),b(l)∈Rm×1.W^{(l)}\in\mathbb R^{m\times n},\quad \boldsymbol a^{(l-1)}\in\mathbb R^{n\times1},\quad \boldsymbol z^{(l)},\boldsymbol b^{(l)}\in\mathbb R^{m\times1}.

权重矩阵的每一行负责计算当前层的一个神经元。矩阵的每一列对应上一层的一个输入坐标。

1.2 为什么需要非线性

假设连续两层只进行线性变换:

h=W1x+b1,y=W2h+b2.\boldsymbol h=W_1\boldsymbol x+\boldsymbol b_1, \qquad \boldsymbol y=W_2\boldsymbol h+\boldsymbol b_2.

代入后得到:

y=(W2W1)x+(W2b1+b2).\boldsymbol y=(W_2W_1)\boldsymbol x+(W_2\boldsymbol b_1+\boldsymbol b_2).

这仍然是一层仿射变换。增加这样的线性层,无法形成新的非线性表达。激活函数让不同输入区域产生不同响应,从而使网络能够学习更复杂的关系。

1.3 用两个隐藏神经元表示 XOR

异或函数(XOR)在两个输入有且仅有一个等于 1 时输出 1。

x1x_1 x2x_2 XOR
0 0 0
0 1 1
1 0 1
1 1 0

一个具有两个 ReLU 隐藏神经元的网络可以实现它:

h1=ReLU⁡(x1+x2−1),h2=ReLU⁡(1−x1−x2),y=1−h1−h2.\begin{aligned} h_1&=\operatorname{ReLU}(x_1+x_2-1),\\ h_2&=\operatorname{ReLU}(1-x_1-x_2),\\ y&=1-h_1-h_2. \end{aligned}

当输入为 (0,0)(0,0) 时,h1=0,h2=1h_1=0,h_2=1,输出为 0。当输入为 (1,0)(1,0) 或 (0,1)(0,1) 时,两个隐藏神经元均输出 0,最终输出为 1。当输入为 (1,1)(1,1) 时,h1=1,h2=0h_1=1,h_2=0,输出回到 0。

这个例子说明,隐藏层可以把原始输入变成更适合判断的表示。对于更多布尔变量,可以用不同网络结构实现复杂逻辑函数。某个构造需要的神经元数量,仅说明该构造的规模;它不能直接证明所有网络都需要同样多的神经元。

1.4 多个布尔输入的奇偶函数

对于 nn 个布尔输入,奇偶函数在输入中有奇数个 1 时输出 1。它包含 2n−12^{n-1} 个输出为 1 的输入组合。

一种构造方法是分别识别这些输入组合,再将识别结果相加。若目标组合为 s∈{0,1}n\boldsymbol s\in\{0,1\}^n,定义:

gs(x)=ReLU⁡(1−∑i=1n∣xi−si∣).g_{\boldsymbol s}(\boldsymbol x)= \operatorname{ReLU}\left( 1-\sum_{i=1}^{n}|x_i-s_i| \right).

对于布尔输入,只有 x=s\boldsymbol x=\boldsymbol s 时,这个神经元输出 1。对所有奇数个 1 的组合求和:

Parity⁡(x)=∑s: ∑isi oddgs(x).\operatorname{Parity}(\boldsymbol x) =\sum_{\boldsymbol s:\,\sum_i s_i\ \mathrm{odd}} g_{\boldsymbol s}(\boldsymbol x).

这个构造使用 2n−12^{n-1} 个隐藏神经元。由于布尔变量满足 ∣xi−si∣=xi|x_i-s_i|=x_i(当 si=0s_i=0)或 1−xi1-x_i(当 si=1s_i=1),每个 gsg_{\boldsymbol s} 的激活前表达式都是输入的仿射函数。

还可以利用输入中 1 的总数来构造。记 t=∑i=1nxit=\sum_{i=1}^{n}x_i,则:

Parity⁡(x)=ReLU⁡(t)+2∑k=1n−1(−1)kReLU⁡(t−k).\operatorname{Parity}(\boldsymbol x) = \operatorname{ReLU}(t) +2\sum_{k=1}^{n-1}(-1)^k\operatorname{ReLU}(t-k).

在整数 t=0,1,…,nt=0,1,\ldots,n 上,该函数的输出依次为 0,1,0,1,…0,1,0,1,\ldots。这说明单隐藏层也存在使用 O(n)O(n) 个 ReLU 单元的表示。复杂度取决于选择的构造方法和网络约束。

若使用前面的两输入 XOR 模块,并按照平衡树组织成对计算,还可以在对数数量的模块层级中完成 nn 个输入的奇偶判断。这个例子说明,网络的层数、宽度与计算结构会共同影响表达能力。

2 激活函数与梯度

2.1 Sigmoid 和 Tanh

Sigmoid 将实数映射到 (0,1)(0,1):[1]

σ(z)=11+e−z.\sigma(z)=\frac{1}{1+e^{-z}}.

对它求导:

σ′(z)=e−z(1+e−z)2=σ(z)(1−σ(z)).\sigma'(z) =\frac{e^{-z}}{(1+e^{-z})^2} =\sigma(z)(1-\sigma(z)).

由于 0<σ(z)<10<\sigma(z)<1,导数最大为 1/41/4。输入的绝对值很大时,输出接近 0 或 1,导数接近 0。

Tanh 将实数映射到 (−1,1)(-1,1):

tanh⁡(z)=ez−e−zez+e−z,tanh⁡′(z)=1−tanh⁡2(z).\tanh(z)=\frac{e^z-e^{-z}}{e^z+e^{-z}}, \qquad \tanh'(z)=1-\tanh^2(z).

Tanh 在零附近的导数为 1,输出以 0 为中心。输入进入两端的饱和区域时,其导数也接近 0。

2.2 ReLU 及其变体

ReLU(修正线性单元)定义为:

ReLU⁡(z)=max⁡(0,z).\operatorname{ReLU}(z)=\max(0,z).

其导数在 z>0z>0 时等于 1,在 z<0z<0 时等于 0。z=0z=0 处的经典导数不存在;深度学习框架通常选择一个约定值,例如 0。

Leaky ReLU 在负半轴保留一定斜率:

f(z)={z,z>0,αz,z≤0,α>0.f(z)= \begin{cases} z,&z>0,\\ \alpha z,&z\leq0, \end{cases} \qquad \alpha>0.

PReLU 进一步让 α\alpha 参与训练。RReLU 在训练时从给定区间随机选取负半轴斜率,推断时一般使用区间的平均斜率。这些形式都用于改变负输入区域的响应。[3][4]

激活函数 主要形式 导数特征
Sigmoid 1/(1+e−z)1/(1+e^{-z}) 最大为 1/41/4,两端饱和
Tanh tanh⁡(z)\tanh(z) 零附近较大,两端饱和
ReLU max⁡(0,z)\max(0,z) 正半轴为 1,负半轴为 0
Leaky ReLU max⁡(z,αz)\max(z,\alpha z) 负半轴保留斜率 α\alpha
PReLU 与 Leaky ReLU 同形 α\alpha 可参与训练

单独打开激活函数与导数

2.3 梯度为什么会消失

反向传播会反复使用链式法则。对于标量计算,经过多层后的梯度常包含多个局部导数的乘积:

∂L∂x0=∂L∂xn∏l=0n−1∂xl+1∂xl.\frac{\partial L}{\partial x_0} =\frac{\partial L}{\partial x_n} \prod_{l=0}^{n-1}\frac{\partial x_{l+1}}{\partial x_l}.

如果十段传递中的局部导数都等于 0.10.1,对应乘积为:

0.110=10−10.0.1^{10}=10^{-10}.

传到前面层的梯度可能非常小,导致参数更新缓慢。Sigmoid 和 Tanh 的饱和区域容易出现这种情况。ReLU 在正半轴的导数为 1,但负半轴导数为 0,某些神经元可能长期无法从当前样本获得梯度。梯度还受权重矩阵、数据和损失函数影响,因此只考察激活函数的导数并不足以判断整个网络是否稳定。

3 损失函数与参数更新

3.1 损失衡量什么

神经网络的前向计算给出预测值 y^\hat y,损失函数衡量预测与目标 yy 之间的差异。[1]

对于回归问题,常用平方误差:

L=12(y^−y)2,∂L∂y^=y^−y.L=\frac12(\hat y-y)^2,\qquad \frac{\partial L}{\partial\hat y}=\hat y-y.

这里的 1/21/2 使求导结果更简洁。它不改变损失的最小值所在位置。

对于二分类问题,若模型输出正样本概率 pp,二元交叉熵(BCE)为:

L=−ylog⁡p−(1−y)log⁡(1−p),y∈{0,1}.L=-y\log p-(1-y)\log(1-p), \qquad y\in\{0,1\}.

当 y=1y=1 时,损失为 −log⁡p-\log p;当 y=0y=0 时,损失为 −log⁡(1−p)-\log(1-p)。模型给真实类别的概率越低,对应损失越高。

3.2 Sigmoid 与交叉熵的梯度

令 p=σ(z)p=\sigma(z),其中 zz 为模型输出的 logit。分别求导:

∂L∂p=−yp+1−y1−p=p−yp(1−p).\frac{\partial L}{\partial p} =-\frac yp+\frac{1-y}{1-p} =\frac{p-y}{p(1-p)}.

Sigmoid 的导数为:

∂p∂z=p(1−p).\frac{\partial p}{\partial z}=p(1-p).

应用链式法则:

∂L∂z=∂L∂p∂p∂z=p−y.\boxed{ \frac{\partial L}{\partial z} =\frac{\partial L}{\partial p} \frac{\partial p}{\partial z} =p-y. }

这个结果让二分类输出层的梯度计算非常简洁。实际实现时,直接把 logit 传入具有数值稳定处理的损失函数,通常更可靠。[5]

对于 KK 类分类问题,Softmax 定义为:

pk=ezk∑j=1Kezj.p_k=\frac{e^{z_k}}{\sum_{j=1}^{K}e^{z_j}}.

若采用独热标签 y\boldsymbol y 和多类别交叉熵,输出层的梯度同样化简为:

∂L∂zk=pk−yk.\frac{\partial L}{\partial z_k}=p_k-y_k.

3.3 梯度与学习率

设模型所有参数为 θ\boldsymbol\theta,损失为 L(θ)L(\boldsymbol\theta)。梯度的各个分量表示在当前参数附近,损失随该参数改变的局部变化率。

最简单的梯度下降更新为:

θnew=θold−η∇θL.\boxed{ \boldsymbol\theta_{\mathrm{new}} =\boldsymbol\theta_{\mathrm{old}} -\eta\nabla_{\boldsymbol\theta}L. }

其中 η>0\eta>0 是学习率。某个参数的梯度为正时,梯度下降减少该参数;梯度为负时,则增加该参数。梯度决定局部方向,学习率决定本次更新幅度。

4 从链式法则到反向传播

4.1 为什么需要反向计算

考虑一个隐藏神经元:

z1=w1x+b1,h=ReLU⁡(z1),z_1=w_1x+b_1,\qquad h=\operatorname{ReLU}(z_1), y^=w2h+b2,L=12(y^−y)2.\hat y=w_2h+b_2,\qquad L=\frac12(\hat y-y)^2.

计算预测时,数据依次经过 x→z1→h→y^→Lx\rightarrow z_1\rightarrow h\rightarrow\hat y\rightarrow L。计算 w1w_1 对损失的影响,需要沿这些关系应用链式法则:

∂L∂w1=∂L∂y^∂y^∂h∂h∂z1∂z1∂w1.\frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial\hat y} \frac{\partial\hat y}{\partial h} \frac{\partial h}{\partial z_1} \frac{\partial z_1}{\partial w_1}.

每个因子分别表示预测误差、输出层权重、激活函数和输入对权重的影响。反向传播(Backpropagation)从损失开始,逐层计算这些导数,并重复利用已经算出的中间梯度。[2][1]

4.2 手动计算四个参数的梯度

取下面的数值:

对象 数值
输入 xx 22
目标 yy 1010
w1,b1w_1,b_1 3,13,1
w2,b2w_2,b_2 2,02,0

前向传播:

z1=3×2+1=7,h=ReLU⁡(7)=7,z_1=3\times2+1=7,\qquad h=\operatorname{ReLU}(7)=7, y^=2×7+0=14,L=12(14−10)2=8.\hat y=2\times7+0=14,\qquad L=\frac12(14-10)^2=8.

从损失出发:

∂L∂y^=y^−y=4.\frac{\partial L}{\partial\hat y} =\hat y-y=4.

输出层的权重和截距项梯度为:

∂L∂w2=∂L∂y^∂y^∂w2=4×h=28,\frac{\partial L}{\partial w_2} =\frac{\partial L}{\partial\hat y} \frac{\partial\hat y}{\partial w_2} =4\times h=28, ∂L∂b2=4.\frac{\partial L}{\partial b_2}=4.

接着将梯度传给隐藏神经元:

∂L∂h=∂L∂y^∂y^∂h=4×2=8.\frac{\partial L}{\partial h} =\frac{\partial L}{\partial\hat y} \frac{\partial\hat y}{\partial h} =4\times2=8.

由于 z1=7>0z_1=7>0,ReLU 的导数为 1,因此:

∂L∂z1=∂L∂hReLU⁡′(z1)=8×1=8.\frac{\partial L}{\partial z_1} =\frac{\partial L}{\partial h} \operatorname{ReLU}'(z_1) =8\times1=8.

于是:

∂L∂w1=∂L∂z1x=8×2=16,∂L∂b1=8.\frac{\partial L}{\partial w_1} =\frac{\partial L}{\partial z_1}x =8\times2=16, \qquad \frac{\partial L}{\partial b_1}=8.

四个参数的梯度为:

参数 当前值 梯度
w1w_1 33 1616
b1b_1 11 88
w2w_2 22 2828
b2b_2 00 44

4.3 完成一次梯度下降

选择学习率 η=0.01\eta=0.01,同时更新四个参数:

w1′=3−0.01×16=2.84,b1′=1−0.01×8=0.92,w2′=2−0.01×28=1.72,b2′=0−0.01×4=−0.04.\begin{aligned} w_1'&=3-0.01\times16=2.84,\\ b_1'&=1-0.01\times8=0.92,\\ w_2'&=2-0.01\times28=1.72,\\ b_2'&=0-0.01\times4=-0.04. \end{aligned}

使用新参数重新前向计算:

h′=ReLU⁡(2.84×2+0.92)=6.6,h'=\operatorname{ReLU}(2.84\times2+0.92)=6.6, y^′=1.72×6.6−0.04=11.312,\hat y'=1.72\times6.6-0.04=11.312, L′=12(11.312−10)2=0.860672.L'=\frac12(11.312-10)^2=0.860672.

这一次更新让损失由 88 降低到 0.8606720.860672。但梯度只反映当前位置的局部变化,学习率过大时,新损失可能上升。

单独打开一次反向传播与参数更新

5 多层网络如何反向传播

5.1 两个隐藏层的完整计算

考虑输入维度为 2、两个隐藏层各有 2 个神经元、输出维度为 1 的网络。列向量输入和权重为:

x=[12],W(1)=[1120],\boldsymbol x= \begin{bmatrix}1\\2\end{bmatrix}, \qquad W^{(1)}= \begin{bmatrix}1&1\\2&0\end{bmatrix}, W(2)=[121−1],W(3)=[21].W^{(2)}= \begin{bmatrix}1&2\\1&-1\end{bmatrix}, \qquad W^{(3)}= \begin{bmatrix}2&1\end{bmatrix}.

所有截距项设为零,两个隐藏层使用 ReLU,目标 y=14y=14。前向传播为:

z(1)=W(1)x=[32],a(1)=[32],\boldsymbol z^{(1)}=W^{(1)}\boldsymbol x =\begin{bmatrix}3\\2\end{bmatrix}, \quad \boldsymbol a^{(1)}=\begin{bmatrix}3\\2\end{bmatrix}, z(2)=W(2)a(1)=[71],a(2)=[71].\boldsymbol z^{(2)}=W^{(2)}\boldsymbol a^{(1)} =\begin{bmatrix}7\\1\end{bmatrix}, \quad \boldsymbol a^{(2)}=\begin{bmatrix}7\\1\end{bmatrix}.

输出和损失为:

y^=W(3)a(2)=2×7+1×1=15,L=12(15−14)2=0.5.\hat y=W^{(3)}\boldsymbol a^{(2)} =2\times7+1\times1=15, \qquad L=\frac12(15-14)^2=0.5.

5.2 定义每层的局部梯度

为简化表达,定义:

δ(l)=∂L∂z(l).\boldsymbol\delta^{(l)} =\frac{\partial L}{\partial\boldsymbol z^{(l)}}.

这里 δ(l)\boldsymbol\delta^{(l)} 表示损失对第 ll 层激活前数值的梯度。对于线性输出层:

δ(3)=y^−y=1.\delta^{(3)}=\hat y-y=1.

第二个隐藏层的梯度为:

δ(2)=(W(3))⊤δ(3)⊙ReLU⁡′(z(2))=[21].\boldsymbol\delta^{(2)} =(W^{(3)})^\top\delta^{(3)} \odot\operatorname{ReLU}'(\boldsymbol z^{(2)}) =\begin{bmatrix}2\\1\end{bmatrix}.

⊙\odot 表示对应元素相乘。由于这一层两个激活前数值均大于 0,ReLU 导数向量为 [1,1]⊤[1,1]^\top。

5.3 为什么需要相加与矩阵转置

第一个隐藏层的第一个输出同时进入第二层两个神经元:

z1(2)=a1(1)+2a2(1),z2(2)=a1(1)−a2(1).z_1^{(2)}=a_1^{(1)}+2a_2^{(1)}, \qquad z_2^{(2)}=a_1^{(1)}-a_2^{(1)}.

因此,第一个隐藏神经元接收到的梯度需要把两条连接的贡献相加:

∂L∂a1(1)=1×δ1(2)+1×δ2(2)=1×2+1×1=3.\frac{\partial L}{\partial a_1^{(1)}} =1\times\delta_1^{(2)} +1\times\delta_2^{(2)} =1\times2+1\times1=3.

第二个隐藏神经元的梯度为:

∂L∂a2(1)=2×2+(−1)×1=3.\frac{\partial L}{\partial a_2^{(1)}} =2\times2+(-1)\times1=3.

把两个计算合并:

(W(2))⊤δ(2)=[112−1][21]=[33].(W^{(2)})^\top\boldsymbol\delta^{(2)} = \begin{bmatrix}1&1\\2&-1\end{bmatrix} \begin{bmatrix}2\\1\end{bmatrix} = \begin{bmatrix}3\\3\end{bmatrix}.

再次乘以第一层 ReLU 的导数,得到:

δ(1)=[33].\boxed{\boldsymbol\delta^{(1)}= \begin{bmatrix}3\\3\end{bmatrix}.}

矩阵转置将下一层的连接关系整理成适合当前层求和的方向。它使每个当前神经元都能累加自己通向下一层各个神经元的影响。

单独打开矩阵反向传播

5.4 如何得到全部权重梯度

对于线性变换 z=Wa+b\boldsymbol z=W\boldsymbol a+\boldsymbol b,某个权重的梯度为:

∂L∂Wij=∂L∂zi∂zi∂Wij=δiaj.\frac{\partial L}{\partial W_{ij}} =\frac{\partial L}{\partial z_i} \frac{\partial z_i}{\partial W_{ij}} =\delta_i a_j.

因此,整层权重梯度是一个外积:

∂L∂W(l)=δ(l)(a(l−1))⊤,∂L∂b(l)=δ(l).\boxed{ \frac{\partial L}{\partial W^{(l)}} =\boldsymbol\delta^{(l)} (\boldsymbol a^{(l-1)})^\top, \qquad \frac{\partial L}{\partial\boldsymbol b^{(l)}}=\boldsymbol\delta^{(l)}. }

代入本例:

∂L∂W(3)=1[71]=[71],\frac{\partial L}{\partial W^{(3)}} =1\begin{bmatrix}7&1\end{bmatrix} =\begin{bmatrix}7&1\end{bmatrix}, ∂L∂W(2)=[21][32]=[6432],\frac{\partial L}{\partial W^{(2)}} =\begin{bmatrix}2\\1\end{bmatrix} \begin{bmatrix}3&2\end{bmatrix} =\begin{bmatrix}6&4\\3&2\end{bmatrix}, ∂L∂W(1)=[33][12]=[3636].\frac{\partial L}{\partial W^{(1)}} =\begin{bmatrix}3\\3\end{bmatrix} \begin{bmatrix}1&2\end{bmatrix} =\begin{bmatrix}3&6\\3&6\end{bmatrix}.

各层截距项梯度依次为:

∂L∂b(1)=[33],∂L∂b(2)=[21],∂L∂b(3)=1.\frac{\partial L}{\partial\boldsymbol b^{(1)}}= \begin{bmatrix}3\\3\end{bmatrix},\quad \frac{\partial L}{\partial\boldsymbol b^{(2)}}= \begin{bmatrix}2\\1\end{bmatrix},\quad \frac{\partial L}{\partial b^{(3)}}=1.

这些结果来自同一次前向计算。每个神经元的局部梯度只需要计算一次,便可以用于其所有输入权重的求导。

6 一般矩阵公式与批量训练

对于第 ll 层,设下一层具有 mm 个神经元,当前层具有 nn 个神经元:[1]

W(l+1)∈Rm×n,δ(l+1)∈Rm×1.W^{(l+1)}\in\mathbb R^{m\times n},\qquad \boldsymbol\delta^{(l+1)}\in\mathbb R^{m\times1}.

则:

(W(l+1))⊤δ(l+1)∈Rn×1.(W^{(l+1)})^\top\boldsymbol\delta^{(l+1)} \in\mathbb R^{n\times1}.

再与当前层的 nn 维激活函数导数逐元素相乘:

δ(l)=((W(l+1))⊤δ(l+1))⊙f′(z(l)).\boxed{ \boldsymbol\delta^{(l)} = \left((W^{(l+1)})^\top \boldsymbol\delta^{(l+1)}\right) \odot f'(\boldsymbol z^{(l)}). }

矩阵乘法计算各条连接带来的梯度总和,激活函数导数调整这些梯度。得到 δ(l)\boldsymbol\delta^{(l)} 后,再计算当前层的参数梯度:

∇W(l)L=δ(l)(a(l−1))⊤.\boxed{ \nabla_{W^{(l)}}L =\boldsymbol\delta^{(l)} (\boldsymbol a^{(l-1)})^\top. }

若第 l−1l-1 层有 rr 个神经元,第 ll 层有 nn 个神经元,则 δ(l)∈Rn×1\boldsymbol\delta^{(l)}\in\mathbb R^{n\times1},(a(l−1))⊤∈R1×r(\boldsymbol a^{(l-1)})^\top\in\mathbb R^{1\times r}。外积形状为 n×rn\times r,恰好与 W(l)W^{(l)} 的形状一致。

上面的推导针对单条样本。训练时常使用一个批次中的 BB 条样本。若总损失是各样本损失的平均值:

Lbatch=1B∑s=1BLs,L_{\mathrm{batch}}=\frac1B\sum_{s=1}^B L_s,

则权重梯度也是这些样本梯度的平均值:

∇WLbatch=1B∑s=1B∇WLs.\nabla_W L_{\mathrm{batch}} =\frac1B\sum_{s=1}^B\nabla_W L_s.

神经网络的训练循环由三个不同的计算组成:前向传播产生预测和损失;反向传播计算梯度;优化器使用梯度更新参数。PyTorch 中,调用 loss.backward() 会执行自动求导;更新参数还需要优化器的 step()。[6][7]

当一个中间结果被多条路径共同使用时,反向计算会将这些路径传回的梯度求和。残差连接、共享参数以及多任务网络也遵循这一规则。

7 参数初始化与训练稳定性

7.1 为什么不能把同一隐藏层的权重全部设为零

考虑同一隐藏层中的两个神经元。若两者具有相同的初始权重和截距项,在相同输入下就会产生相同输出。若后续连接也具有对称结构,它们会收到相同的梯度,随后继续保持相同参数。

因此,隐藏层通常采用随机初始化来区分神经元。Xavier 初始化常用于具有较对称导数行为的激活函数,其权重方差的一个常见选择为:

Var⁡(Wij)=2nin+nout.\operatorname{Var}(W_{ij}) =\frac{2}{n_{\mathrm{in}}+n_{\mathrm{out}}}.

对 ReLU 网络,He 初始化常采用:

Var⁡(Wij)=2nin.\operatorname{Var}(W_{ij}) =\frac{2}{n_{\mathrm{in}}}.

这些公式基于一定的输入分布和独立性近似,旨在控制信号经过多层时的数值尺度。不同初始化方式的效果还取决于网络结构。[8][3]

7.2 Dropout 怎样工作

Dropout 在训练过程中随机将部分神经元输出置为零。设保留概率为 qq,掩码满足:[9]

mi∼Bernoulli⁡(q).m_i\sim\operatorname{Bernoulli}(q).

使用倒置 Dropout 时,训练阶段的输出为:

a~i=miqai.\tilde a_i=\frac{m_i}{q}a_i.

由于 E[mi]=q\mathbb E[m_i]=q,在给定 aia_i 时:

E[a~i]=E[mi]qai=ai.\mathbb E[\tilde a_i] =\frac{\mathbb E[m_i]}q a_i =a_i.

这样,训练时随机失活的输出在期望上与输入一致。通常在模型推断时关闭 Dropout,无需额外乘以保留概率。这里的 qq 是保留概率;在 PyTorch 的 nn.Dropout(p) 中,参数 pp 表示失活概率,二者关系为 q=1−pq=1-p。[10]

7.3 BatchNorm 如何计算

Batch Normalization(批量归一化,简称 BatchNorm)使用同一批次中的数值计算均值和方差:[11]

μB=1B∑i=1Bxi,σB2=1B∑i=1B(xi−μB)2.\mu_B=\frac1B\sum_{i=1}^B x_i, \qquad \sigma_B^2=\frac1B\sum_{i=1}^B(x_i-\mu_B)^2.

归一化后再进行可训练的缩放和平移:

x^i=xi−μBσB2+ε,yi=γx^i+β.\hat x_i=\frac{x_i-\mu_B}{\sqrt{\sigma_B^2+\varepsilon}}, \qquad y_i=\gamma\hat x_i+\beta.

其中,ε>0\varepsilon>0 避免分母过小,γ\gamma 是缩放参数,β\beta 是平移参数。γ\gamma 本身不代表方差。

例如,输入为 [1,2,3][1,2,3],总体均值为 22、方差为 2/32/3。忽略极小的 ε\varepsilon,可得:

x^≈[−1.224745, 0, 1.224745].\hat{\boldsymbol x}\approx [-1.224745,\,0,\,1.224745].

若 γ=2,β=1\gamma=2,\beta=1:

y≈[−1.449490, 1, 3.449490].\boldsymbol y\approx [-1.449490,\,1,\,3.449490].

对于全连接层,BatchNorm 通常按特征坐标在批次维度上计算统计量。对于卷积层,常按通道汇总批次及空间位置上的统计量。推断时,标准 BatchNorm 使用训练期间累计的统计量。[12]

单独打开BatchNorm 与 Dropout

7.4 梯度消失、梯度爆炸与数值稳定性

深层网络的梯度包含一系列矩阵和激活函数导数。局部变换连续缩小梯度,可能形成梯度消失;连续放大梯度,则可能形成梯度爆炸。

实际训练通常结合合适的初始化、激活函数、学习率、归一化与残差连接。残差模块具有 y=x+F(x)y=x+F(x) 的形式,其 Jacobian 为 I+JFI+J_F,为梯度提供一条直接路径,但无法保证梯度始终处于理想范围。[13]

8 使用 PyTorch 验证计算

8.1 核对单个隐藏神经元的梯度

下面的代码重现第四节的手动求导。运行后应依次得到 16,8,28,416,8,28,4:[6]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import torch

x = torch.tensor(2.0)
target = torch.tensor(10.0)

w1 = torch.tensor(3.0, requires_grad=True)
b1 = torch.tensor(1.0, requires_grad=True)
w2 = torch.tensor(2.0, requires_grad=True)
b2 = torch.tensor(0.0, requires_grad=True)

hidden = torch.relu(w1 * x + b1)
prediction = w2 * hidden + b2
loss = 0.5 * (prediction - target).square()

loss.backward()

assert torch.allclose(w1.grad, torch.tensor(16.0))
assert torch.allclose(b1.grad, torch.tensor(8.0))
assert torch.allclose(w2.grad, torch.tensor(28.0))
assert torch.allclose(b2.grad, torch.tensor(4.0))
print(prediction.item(), loss.item())

对每个参数设置 requires_grad=True,表示需要计算其梯度。执行 loss.backward() 后,结果保存在各参数的 grad 属性中。

8.2 核对两层隐藏网络的矩阵梯度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import torch

x = torch.tensor([1.0, 2.0])
target = torch.tensor(14.0)
w1 = torch.tensor([[1.0, 1.0], [2.0, 0.0]], requires_grad=True)
w2 = torch.tensor([[1.0, 2.0], [1.0, -1.0]], requires_grad=True)
w3 = torch.tensor([[2.0, 1.0]], requires_grad=True)

a1 = torch.relu(w1 @ x)
a2 = torch.relu(w2 @ a1)
prediction = (w3 @ a2).squeeze()
loss = 0.5 * (prediction - target).square()
loss.backward()

assert torch.allclose(w1.grad, torch.tensor([[3.0, 6.0], [3.0, 6.0]]))
assert torch.allclose(w2.grad, torch.tensor([[6.0, 4.0], [3.0, 2.0]]))
assert torch.allclose(w3.grad, torch.tensor([[7.0, 1.0]]))
assert prediction.item() == 15.0

这里,@ 表示矩阵乘法,Autograd(自动求导)会完成矩阵转置、梯度求和与逐元素求导。

8.3 训练一个 XOR 分类网络

下面的示例包含线性层、BatchNorm、ReLU、Dropout 和优化器。训练时使用带 logit 的二元交叉熵:[5][14]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import torch
from torch import nn

torch.manual_seed(42)

inputs = torch.tensor([
[0.0, 0.0],
[0.0, 1.0],
[1.0, 0.0],
[1.0, 1.0],
])
targets = torch.tensor([[0.0], [1.0], [1.0], [0.0]])

model = nn.Sequential(
nn.Linear(2, 16),
nn.BatchNorm1d(16),
nn.ReLU(),
nn.Dropout(p=0.1),
nn.Linear(16, 1),
)
optimizer = torch.optim.AdamW(
model.parameters(), lr=0.03, weight_decay=0.001
)
criterion = nn.BCEWithLogitsLoss()

model.train()
for epoch in range(800):
optimizer.zero_grad()
logits = model(inputs)
loss = criterion(logits, targets)
loss.backward()
optimizer.step()

model.eval()
with torch.no_grad():
probabilities = torch.sigmoid(model(inputs))
predictions = (probabilities >= 0.5).float()

print(probabilities.flatten().tolist())
assert torch.equal(predictions, targets)

训练阶段调用 model.train(),使 BatchNorm 和 Dropout 使用训练行为;预测阶段调用 model.eval(),采用相应的推断行为。这个实验只使用四个布尔输入,用于核对计算流程,并不用于判断模型在其他数据上的表现。

9 自己重新推导反向传播

理解公式后,可以通过独立计算检验是否掌握。建议先完成单个神经元的计算,再进入整层矩阵。

9.1 单个神经元

某个神经元与下一层两个神经元的连接权重为 22 和 −1-1;下一层传回的梯度为 33 和 44。若当前激活函数导数为 1,求当前神经元的梯度。

δ=(2×3+(−1)×4)×1=2.\delta=(2\times3+(-1)\times4)\times1=2.

9.2 权重梯度

若某个连接的输入为 55,其终点神经元的局部梯度为 22,则:

∂L∂w=5×2=10.\frac{\partial L}{\partial w}=5\times2=10.

9.3 ReLU 的作用

若 x=−2,w=2,b=1x=-2,w=2,b=1,则 z=wx+b=−3z=wx+b=-3。由于 ReLU 在负半轴的导数为零,经过该激活函数传回的局部梯度为零,对应输入权重和截距项从当前样本得到的梯度也为零。

9.4 两个公式如何记忆

反向传播中,两个动作不断重复:

  1. 传递神经元梯度:每条后续连接的权重乘以下一层梯度,把结果相加,再乘以当前激活函数导数。
  2. 计算参数梯度:当前神经元的局部梯度乘以连接输入。

对应的矩阵公式是:

δ(l)=((W(l+1))⊤δ(l+1))⊙f′(z(l)),\boldsymbol\delta^{(l)} =\left((W^{(l+1)})^\top\boldsymbol\delta^{(l+1)}\right) \odot f'(\boldsymbol z^{(l)}), ∇W(l)L=δ(l)(a(l−1))⊤.\nabla_{W^{(l)}}L =\boldsymbol\delta^{(l)} (\boldsymbol a^{(l-1)})^\top.

能够独立说明乘权重、求和、乘导数以及乘输入的原因,便能从单个神经元扩展到任意层数的前馈神经网络。

参考文献

[1] GOODFELLOW I, BENGIO Y, COURVILLE A. Deep Learning[M]. MIT Press, 2016.

[2] RUMELHART D E, HINTON G E, WILLIAMS R J. Learning representations by back-propagating errors[J]. Nature, 1986, 323(6088): 533–536. DOI: 10.1038/323533a0.

[3] HE K, ZHANG X, REN S, et al. Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification[C]//Proceedings of the IEEE International Conference on Computer Vision. 2015.

[4] PyTorch Contributors. RReLU[EB/OL]. PyTorch 2.10.

[5] PyTorch Contributors. BCEWithLogitsLoss[EB/OL]. PyTorch 2.10.

[6] PyTorch Contributors. Autograd mechanics[EB/OL]. PyTorch 2.10.

[7] PyTorch Contributors. torch.optim[EB/OL]. PyTorch 2.10.

[8] GLOROT X, BENGIO Y. Understanding the difficulty of training deep feedforward neural networks[C]//Proceedings of the International Conference on Artificial Intelligence and Statistics. 2010, 9: 249–256.

[9] SRIVASTAVA N, HINTON G, KRIZHEVSKY A, et al. Dropout: A Simple Way to Prevent Neural Networks from Overfitting[J]. Journal of Machine Learning Research, 2014, 15(56): 1929–1958.

[10] PyTorch Contributors. Dropout[EB/OL]. PyTorch 2.10.

[11] IOFFE S, SZEGEDY C. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift[C]//Proceedings of the International Conference on Machine Learning. 2015, 37: 448–456.

[12] PyTorch Contributors. BatchNorm1d[EB/OL]. PyTorch 2.10.

[13] HE K, ZHANG X, REN S, et al. Identity Mappings in Deep Residual Networks[C]//Computer Vision – ECCV. 2016.

[14] LOSHCHILOV I, HUTTER F. Decoupled Weight Decay Regularization[C]//International Conference on Learning Representations. 2019.

评论

评论由 GitHub Giscus 提供。若当前网络无法加载,可 前往 GitHub Discussions 查看或参与讨论。