一个前馈神经网络由多层线性变换和非线性激活函数组成。训练时,网络先计算预测与损失,再利用链式法则将损失的梯度逐层传回各个参数。本文从神经元的计算开始,解释异或函数、常见激活函数、损失函数与反向传播,使用完整的数值例子推导矩阵公式,并说明参数初始化、Dropout、BatchNorm 和 PyTorch 中的训练过程。[1][2]
1 前馈神经网络如何计算
1.1 一个神经元
假设输入为 x1,x2,神经元先进行加权求和:
z=w1x1+w2x2+b.
其中,w1,w2 是权重,b 是截距项。神经元随后通过激活函数 f 计算输出:
a=f(z).
权重决定输入对计算结果的影响,截距项改变激活函数的作用位置。若将多个神经元组合为一层,使用列向量表示输入,便有:
z(l)=W(l)a(l−1)+b(l),a(l)=f(z(l)).
这里 a(0)=x。若第 l−1 层包含 n 个输出,第 l 层包含 m 个神经元,则:
W(l)∈Rm×n,a(l−1)∈Rn×1,z(l),b(l)∈Rm×1.
权重矩阵的每一行负责计算当前层的一个神经元。矩阵的每一列对应上一层的一个输入坐标。
1.2 为什么需要非线性
假设连续两层只进行线性变换:
h=W1x+b1,y=W2h+b2.
代入后得到:
y=(W2W1)x+(W2b1+b2).
这仍然是一层仿射变换。增加这样的线性层,无法形成新的非线性表达。激活函数让不同输入区域产生不同响应,从而使网络能够学习更复杂的关系。
1.3 用两个隐藏神经元表示 XOR
异或函数(XOR)在两个输入有且仅有一个等于 1 时输出 1。
| x1 |
x2 |
XOR |
| 0 |
0 |
0 |
| 0 |
1 |
1 |
| 1 |
0 |
1 |
| 1 |
1 |
0 |
一个具有两个 ReLU 隐藏神经元的网络可以实现它:
h1h2y=ReLU(x1+x2−1),=ReLU(1−x1−x2),=1−h1−h2.
当输入为 (0,0) 时,h1=0,h2=1,输出为 0。当输入为 (1,0) 或 (0,1) 时,两个隐藏神经元均输出 0,最终输出为 1。当输入为 (1,1) 时,h1=1,h2=0,输出回到 0。
这个例子说明,隐藏层可以把原始输入变成更适合判断的表示。对于更多布尔变量,可以用不同网络结构实现复杂逻辑函数。某个构造需要的神经元数量,仅说明该构造的规模;它不能直接证明所有网络都需要同样多的神经元。
1.4 多个布尔输入的奇偶函数
对于 n 个布尔输入,奇偶函数在输入中有奇数个 1 时输出 1。它包含 2n−1 个输出为 1 的输入组合。
一种构造方法是分别识别这些输入组合,再将识别结果相加。若目标组合为 s∈{0,1}n,定义:
gs(x)=ReLU(1−i=1∑n∣xi−si∣).
对于布尔输入,只有 x=s 时,这个神经元输出 1。对所有奇数个 1 的组合求和:
Parity(x)=s:∑isi odd∑gs(x).
这个构造使用 2n−1 个隐藏神经元。由于布尔变量满足 ∣xi−si∣=xi(当 si=0)或 1−xi(当 si=1),每个 gs 的激活前表达式都是输入的仿射函数。
还可以利用输入中 1 的总数来构造。记 t=∑i=1nxi,则:
Parity(x)=ReLU(t)+2k=1∑n−1(−1)kReLU(t−k).
在整数 t=0,1,…,n 上,该函数的输出依次为 0,1,0,1,…。这说明单隐藏层也存在使用 O(n) 个 ReLU 单元的表示。复杂度取决于选择的构造方法和网络约束。
若使用前面的两输入 XOR 模块,并按照平衡树组织成对计算,还可以在对数数量的模块层级中完成 n 个输入的奇偶判断。这个例子说明,网络的层数、宽度与计算结构会共同影响表达能力。
2 激活函数与梯度
2.1 Sigmoid 和 Tanh
Sigmoid 将实数映射到 (0,1):[1]
σ(z)=1+e−z1.
对它求导:
σ′(z)=(1+e−z)2e−z=σ(z)(1−σ(z)).
由于 0<σ(z)<1,导数最大为 1/4。输入的绝对值很大时,输出接近 0 或 1,导数接近 0。
Tanh 将实数映射到 (−1,1):
tanh(z)=ez+e−zez−e−z,tanh′(z)=1−tanh2(z).
Tanh 在零附近的导数为 1,输出以 0 为中心。输入进入两端的饱和区域时,其导数也接近 0。
2.2 ReLU 及其变体
ReLU(修正线性单元)定义为:
ReLU(z)=max(0,z).
其导数在 z>0 时等于 1,在 z<0 时等于 0。z=0 处的经典导数不存在;深度学习框架通常选择一个约定值,例如 0。
Leaky ReLU 在负半轴保留一定斜率:
f(z)={z,αz,z>0,z≤0,α>0.
PReLU 进一步让 α 参与训练。RReLU 在训练时从给定区间随机选取负半轴斜率,推断时一般使用区间的平均斜率。这些形式都用于改变负输入区域的响应。[3][4]
| 激活函数 |
主要形式 |
导数特征 |
| Sigmoid |
1/(1+e−z) |
最大为 1/4,两端饱和 |
| Tanh |
tanh(z) |
零附近较大,两端饱和 |
| ReLU |
max(0,z) |
正半轴为 1,负半轴为 0 |
| Leaky ReLU |
max(z,αz) |
负半轴保留斜率 α |
| PReLU |
与 Leaky ReLU 同形 |
α 可参与训练 |
2.3 梯度为什么会消失
反向传播会反复使用链式法则。对于标量计算,经过多层后的梯度常包含多个局部导数的乘积:
∂x0∂L=∂xn∂Ll=0∏n−1∂xl∂xl+1.
如果十段传递中的局部导数都等于 0.1,对应乘积为:
0.110=10−10.
传到前面层的梯度可能非常小,导致参数更新缓慢。Sigmoid 和 Tanh 的饱和区域容易出现这种情况。ReLU 在正半轴的导数为 1,但负半轴导数为 0,某些神经元可能长期无法从当前样本获得梯度。梯度还受权重矩阵、数据和损失函数影响,因此只考察激活函数的导数并不足以判断整个网络是否稳定。
3 损失函数与参数更新
3.1 损失衡量什么
神经网络的前向计算给出预测值 y^,损失函数衡量预测与目标 y 之间的差异。[1]
对于回归问题,常用平方误差:
L=21(y^−y)2,∂y^∂L=y^−y.
这里的 1/2 使求导结果更简洁。它不改变损失的最小值所在位置。
对于二分类问题,若模型输出正样本概率 p,二元交叉熵(BCE)为:
L=−ylogp−(1−y)log(1−p),y∈{0,1}.
当 y=1 时,损失为 −logp;当 y=0 时,损失为 −log(1−p)。模型给真实类别的概率越低,对应损失越高。
3.2 Sigmoid 与交叉熵的梯度
令 p=σ(z),其中 z 为模型输出的 logit。分别求导:
∂p∂L=−py+1−p1−y=p(1−p)p−y.
Sigmoid 的导数为:
∂z∂p=p(1−p).
应用链式法则:
∂z∂L=∂p∂L∂z∂p=p−y.
这个结果让二分类输出层的梯度计算非常简洁。实际实现时,直接把 logit 传入具有数值稳定处理的损失函数,通常更可靠。[5]
对于 K 类分类问题,Softmax 定义为:
pk=∑j=1Kezjezk.
若采用独热标签 y 和多类别交叉熵,输出层的梯度同样化简为:
∂zk∂L=pk−yk.
3.3 梯度与学习率
设模型所有参数为 θ,损失为 L(θ)。梯度的各个分量表示在当前参数附近,损失随该参数改变的局部变化率。
最简单的梯度下降更新为:
θnew=θold−η∇θL.
其中 η>0 是学习率。某个参数的梯度为正时,梯度下降减少该参数;梯度为负时,则增加该参数。梯度决定局部方向,学习率决定本次更新幅度。
4 从链式法则到反向传播
4.1 为什么需要反向计算
考虑一个隐藏神经元:
z1=w1x+b1,h=ReLU(z1),
y^=w2h+b2,L=21(y^−y)2.
计算预测时,数据依次经过 x→z1→h→y^→L。计算 w1 对损失的影响,需要沿这些关系应用链式法则:
∂w1∂L=∂y^∂L∂h∂y^∂z1∂h∂w1∂z1.
每个因子分别表示预测误差、输出层权重、激活函数和输入对权重的影响。反向传播(Backpropagation)从损失开始,逐层计算这些导数,并重复利用已经算出的中间梯度。[2][1]
4.2 手动计算四个参数的梯度
取下面的数值:
| 对象 |
数值 |
| 输入 x |
2 |
| 目标 y |
10 |
| w1,b1 |
3,1 |
| w2,b2 |
2,0 |
前向传播:
z1=3×2+1=7,h=ReLU(7)=7,
y^=2×7+0=14,L=21(14−10)2=8.
从损失出发:
∂y^∂L=y^−y=4.
输出层的权重和截距项梯度为:
∂w2∂L=∂y^∂L∂w2∂y^=4×h=28,
∂b2∂L=4.
接着将梯度传给隐藏神经元:
∂h∂L=∂y^∂L∂h∂y^=4×2=8.
由于 z1=7>0,ReLU 的导数为 1,因此:
∂z1∂L=∂h∂LReLU′(z1)=8×1=8.
于是:
∂w1∂L=∂z1∂Lx=8×2=16,∂b1∂L=8.
四个参数的梯度为:
| 参数 |
当前值 |
梯度 |
| w1 |
3 |
16 |
| b1 |
1 |
8 |
| w2 |
2 |
28 |
| b2 |
0 |
4 |
4.3 完成一次梯度下降
选择学习率 η=0.01,同时更新四个参数:
w1′b1′w2′b2′=3−0.01×16=2.84,=1−0.01×8=0.92,=2−0.01×28=1.72,=0−0.01×4=−0.04.
使用新参数重新前向计算:
h′=ReLU(2.84×2+0.92)=6.6,
y^′=1.72×6.6−0.04=11.312,
L′=21(11.312−10)2=0.860672.
这一次更新让损失由 8 降低到 0.860672。但梯度只反映当前位置的局部变化,学习率过大时,新损失可能上升。
5 多层网络如何反向传播
5.1 两个隐藏层的完整计算
考虑输入维度为 2、两个隐藏层各有 2 个神经元、输出维度为 1 的网络。列向量输入和权重为:
x=[12],W(1)=[1210],
W(2)=[112−1],W(3)=[21].
所有截距项设为零,两个隐藏层使用 ReLU,目标 y=14。前向传播为:
z(1)=W(1)x=[32],a(1)=[32],
z(2)=W(2)a(1)=[71],a(2)=[71].
输出和损失为:
y^=W(3)a(2)=2×7+1×1=15,L=21(15−14)2=0.5.
5.2 定义每层的局部梯度
为简化表达,定义:
δ(l)=∂z(l)∂L.
这里 δ(l) 表示损失对第 l 层激活前数值的梯度。对于线性输出层:
δ(3)=y^−y=1.
第二个隐藏层的梯度为:
δ(2)=(W(3))⊤δ(3)⊙ReLU′(z(2))=[21].
⊙ 表示对应元素相乘。由于这一层两个激活前数值均大于 0,ReLU 导数向量为 [1,1]⊤。
5.3 为什么需要相加与矩阵转置
第一个隐藏层的第一个输出同时进入第二层两个神经元:
z1(2)=a1(1)+2a2(1),z2(2)=a1(1)−a2(1).
因此,第一个隐藏神经元接收到的梯度需要把两条连接的贡献相加:
∂a1(1)∂L=1×δ1(2)+1×δ2(2)=1×2+1×1=3.
第二个隐藏神经元的梯度为:
∂a2(1)∂L=2×2+(−1)×1=3.
把两个计算合并:
(W(2))⊤δ(2)=[121−1][21]=[33].
再次乘以第一层 ReLU 的导数,得到:
δ(1)=[33].
矩阵转置将下一层的连接关系整理成适合当前层求和的方向。它使每个当前神经元都能累加自己通向下一层各个神经元的影响。
5.4 如何得到全部权重梯度
对于线性变换 z=Wa+b,某个权重的梯度为:
∂Wij∂L=∂zi∂L∂Wij∂zi=δiaj.
因此,整层权重梯度是一个外积:
∂W(l)∂L=δ(l)(a(l−1))⊤,∂b(l)∂L=δ(l).
代入本例:
∂W(3)∂L=1[71]=[71],
∂W(2)∂L=[21][32]=[6342],
∂W(1)∂L=[33][12]=[3366].
各层截距项梯度依次为:
∂b(1)∂L=[33],∂b(2)∂L=[21],∂b(3)∂L=1.
这些结果来自同一次前向计算。每个神经元的局部梯度只需要计算一次,便可以用于其所有输入权重的求导。
6 一般矩阵公式与批量训练
对于第 l 层,设下一层具有 m 个神经元,当前层具有 n 个神经元:[1]
W(l+1)∈Rm×n,δ(l+1)∈Rm×1.
则:
(W(l+1))⊤δ(l+1)∈Rn×1.
再与当前层的 n 维激活函数导数逐元素相乘:
δ(l)=((W(l+1))⊤δ(l+1))⊙f′(z(l)).
矩阵乘法计算各条连接带来的梯度总和,激活函数导数调整这些梯度。得到 δ(l) 后,再计算当前层的参数梯度:
∇W(l)L=δ(l)(a(l−1))⊤.
若第 l−1 层有 r 个神经元,第 l 层有 n 个神经元,则 δ(l)∈Rn×1,(a(l−1))⊤∈R1×r。外积形状为 n×r,恰好与 W(l) 的形状一致。
上面的推导针对单条样本。训练时常使用一个批次中的 B 条样本。若总损失是各样本损失的平均值:
Lbatch=B1s=1∑BLs,
则权重梯度也是这些样本梯度的平均值:
∇WLbatch=B1s=1∑B∇WLs.
神经网络的训练循环由三个不同的计算组成:前向传播产生预测和损失;反向传播计算梯度;优化器使用梯度更新参数。PyTorch 中,调用 loss.backward() 会执行自动求导;更新参数还需要优化器的 step()。[6][7]
当一个中间结果被多条路径共同使用时,反向计算会将这些路径传回的梯度求和。残差连接、共享参数以及多任务网络也遵循这一规则。
7 参数初始化与训练稳定性
7.1 为什么不能把同一隐藏层的权重全部设为零
考虑同一隐藏层中的两个神经元。若两者具有相同的初始权重和截距项,在相同输入下就会产生相同输出。若后续连接也具有对称结构,它们会收到相同的梯度,随后继续保持相同参数。
因此,隐藏层通常采用随机初始化来区分神经元。Xavier 初始化常用于具有较对称导数行为的激活函数,其权重方差的一个常见选择为:
Var(Wij)=nin+nout2.
对 ReLU 网络,He 初始化常采用:
Var(Wij)=nin2.
这些公式基于一定的输入分布和独立性近似,旨在控制信号经过多层时的数值尺度。不同初始化方式的效果还取决于网络结构。[8][3]
7.2 Dropout 怎样工作
Dropout 在训练过程中随机将部分神经元输出置为零。设保留概率为 q,掩码满足:[9]
mi∼Bernoulli(q).
使用倒置 Dropout 时,训练阶段的输出为:
a~i=qmiai.
由于 E[mi]=q,在给定 ai 时:
E[a~i]=qE[mi]ai=ai.
这样,训练时随机失活的输出在期望上与输入一致。通常在模型推断时关闭 Dropout,无需额外乘以保留概率。这里的 q 是保留概率;在 PyTorch 的 nn.Dropout(p) 中,参数 p 表示失活概率,二者关系为 q=1−p。[10]
7.3 BatchNorm 如何计算
Batch Normalization(批量归一化,简称 BatchNorm)使用同一批次中的数值计算均值和方差:[11]
μB=B1i=1∑Bxi,σB2=B1i=1∑B(xi−μB)2.
归一化后再进行可训练的缩放和平移:
x^i=σB2+εxi−μB,yi=γx^i+β.
其中,ε>0 避免分母过小,γ 是缩放参数,β 是平移参数。γ 本身不代表方差。
例如,输入为 [1,2,3],总体均值为 2、方差为 2/3。忽略极小的 ε,可得:
x^≈[−1.224745,0,1.224745].
若 γ=2,β=1:
y≈[−1.449490,1,3.449490].
对于全连接层,BatchNorm 通常按特征坐标在批次维度上计算统计量。对于卷积层,常按通道汇总批次及空间位置上的统计量。推断时,标准 BatchNorm 使用训练期间累计的统计量。[12]
7.4 梯度消失、梯度爆炸与数值稳定性
深层网络的梯度包含一系列矩阵和激活函数导数。局部变换连续缩小梯度,可能形成梯度消失;连续放大梯度,则可能形成梯度爆炸。
实际训练通常结合合适的初始化、激活函数、学习率、归一化与残差连接。残差模块具有 y=x+F(x) 的形式,其 Jacobian 为 I+JF,为梯度提供一条直接路径,但无法保证梯度始终处于理想范围。[13]
8 使用 PyTorch 验证计算
8.1 核对单个隐藏神经元的梯度
下面的代码重现第四节的手动求导。运行后应依次得到 16,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 单个神经元
某个神经元与下一层两个神经元的连接权重为 2 和 −1;下一层传回的梯度为 3 和 4。若当前激活函数导数为 1,求当前神经元的梯度。
δ=(2×3+(−1)×4)×1=2.
9.2 权重梯度
若某个连接的输入为 5,其终点神经元的局部梯度为 2,则:
∂w∂L=5×2=10.
9.3 ReLU 的作用
若 x=−2,w=2,b=1,则 z=wx+b=−3。由于 ReLU 在负半轴的导数为零,经过该激活函数传回的局部梯度为零,对应输入权重和截距项从当前样本得到的梯度也为零。
9.4 两个公式如何记忆
反向传播中,两个动作不断重复:
- 传递神经元梯度:每条后续连接的权重乘以下一层梯度,把结果相加,再乘以当前激活函数导数。
- 计算参数梯度:当前神经元的局部梯度乘以连接输入。
对应的矩阵公式是:
δ(l)=((W(l+1))⊤δ(l+1))⊙f′(z(l)),
∇W(l)L=δ(l)(a(l−1))⊤.
能够独立说明乘权重、求和、乘导数以及乘输入的原因,便能从单个神经元扩展到任意层数的前馈神经网络。
参考文献
[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 查看或参与讨论。