每日基础课

一句话定义： 梯度是让损失函数上升最快的方向向量，而链式法则就是把复合函数从外到内一层层拆开求导、再把各层变化率乘起来的数学规则。

生活类比： 想象一家面包厂做出的面包太咸了（产生损失 Loss）。 厂长（最终输出）质问车间主管（隐藏层），主管质问配料师傅（输入层）。 配料师傅的责任 = “主管对总口味的连带责任” × “师傅对主管指令的执行偏差”。 链式法则就是这样自后向前、把总责任逐级拆解并连乘的过程。

必要公式与符号解释： 若函数嵌套为 $y = f(u)$ 且 $u = g(x)$，对输入 $x$ 求导的链式法则为： $$\frac{\partial y}{\partial x} = \frac{\partial y}{\partial u} \cdot \frac{\partial u}{\partial x}$$ 当输入是多维参数（如权重向量 $\mathbf{w} = [w_1, w_2, \dots, w_n]^T$）时，损失 $L$ 对所有参数的偏导数打包成一个向量，就叫梯度： $$\nabla_{\mathbf{w}} L = \left[ \frac{\partial L}{\partial w_1}, \frac{\partial L}{\partial w_2}, \dots, \frac{\partial L}{\partial w_n} \right]^T$$ - $L$：标量损失值（模型预测与真实标签的差距）。 - $\mathbf{w}$：模型中需要更新的权重参数。 - $\frac{\partial L}{\partial w_i}$：第 $i$ 个权重微调时，对总损失造成的影响速率。 - $\nabla$（Nabla 算子）：表示把所有偏导数打包成梯度向量。

它解决什么问题？没有它会怎样？ 深度模型通常包含几十上百层（如提取声学特征的卷积层与 Transformer 层）。 如果没有链式法则，我们想更新第一层卷积的参数，就只能对每一个参数做微调扰动去重新测一遍损失（数值差分），一个亿级参数的模型做一次更新就需要跑一亿次前向传播，计算量直接爆炸。 有了链式法则，只需一次前向计算保存中间状态，再做一次反向传递，就能同时算出所有层参数的梯度。

在音视频与说话人日志中的实际用法： 在说话人日志（Speaker Diarization）中，前端网络（如 ECAPA-TDNN 或 Conformer）负责将连续语音切片编码为说话人表征向量（Speaker Embedding，如 x-vector）。 后端计算损失（如 AAM-Softmax 损失或对比学习损失）。 系统通过链式法则把损失从分类头逆向传回投影层、注意力层、最后传到卷积前端，告诉特征提取网络：“如何调整滤波器，才能把张三和李四的声音分得更开”。

实现思路： 1. 设定一个简单的两层全连接复合函数：$z = X W_1 + b_1 \to a = \text{ReLU}(z) \to \hat{y} = a W_2 \to L = \frac{1}{2} (\hat{y} - y_{true})^2$。 2. 按照链式法则手工推导出 $\frac{\partial L}{\partial W_2}, \frac{\partial L}{\partial W_1}, \frac{\partial L}{\partial X}$ 的数学公式并在 NumPy/纯 Python 中实现反向传递。 3. 用 PyTorch 构建相同计算图并执行 `.backward()`。 4. 使用 `np.allclose` 验收手算梯度与 PyTorch 梯度是否完全一致。

完整可运行代码：

import torch
import numpy as np

# 1. 固定随机种子，确保可复现
torch.manual_seed(42)
np.random.seed(42)

# 2. 构造模拟数据（例如：1个样本，输入特征维度为 2，隐藏层维度为 3，输出维度为 1）
# 模拟：输入 X 为某语音帧的简单特征，y_true 为说话人标签对应的标量目标
X_np = np.array([[1.5, -0.5]], dtype=np.float32)       # 形状: (1, 2)
W1_np = np.random.randn(2, 3).astype(np.float32)       # 形状: (2, 3)
b1_np = np.random.randn(1, 3).astype(np.float32)       # 形状: (1, 3)
W2_np = np.random.randn(3, 1).astype(np.float32)       # 形状: (3, 1)
y_true_np = np.array([[1.0]], dtype=np.float32)        # 形状: (1, 1)

# ----------------- 手写链式法则（前向 + 反向） -----------------
# 前向过程
z_np = np.dot(X_np, W1_np) + b1_np                     # (1, 3)
a_np = np.maximum(0, z_np)                             # ReLU 激活: (1, 3)
y_pred_np = np.dot(a_np, W2_np)                        # (1, 1)
loss_np = 0.5 * np.sum((y_pred_np - y_true_np) ** 2)   # 标量

# 反向链式求导过程
dL_dypred = y_pred_np - y_true_np                      # (1, 1)
dL_dW2 = np.dot(a_np.T, dL_dypred)                     # (3, 1)
dL_da = np.dot(dL_dypred, W2_np.T)                     # (1, 3)
dL_dz = dL_da * (z_np > 0).astype(np.float32)          # ReLU 导数: (1, 3)
dL_dW1 = np.dot(X_np.T, dL_dz)                         # (2, 3)
dL_db1 = np.sum(dL_dz, axis=0, keepdims=True)          # (1, 3)
dL_dX = np.dot(dL_dz, W1_np.T)                         # (1, 2)

# ----------------- PyTorch 自动微分对比 -----------------
X_pt = torch.tensor(X_np, requires_grad=True)
W1_pt = torch.tensor(W1_np, requires_grad=True)
b1_pt = torch.tensor(b1_np, requires_grad=True)
W2_pt = torch.tensor(W2_np, requires_grad=True)
y_true_pt = torch.tensor(y_true_np)

# PyTorch 前向
z_pt = torch.matmul(X_pt, W1_pt) + b1_pt
a_pt = torch.relu(z_pt)
y_pred_pt = torch.matmul(a_pt, W2_pt)
loss_pt = 0.5 * torch.sum((y_pred_pt - y_true_pt) ** 2)

# PyTorch 反向自动求导
loss_pt.backward()

# ----------------- 验收比对 -----------------
assert np.allclose(dL_dW2, W2_pt.grad.numpy(), atol=1e-6), "W2 梯度不一致！"
assert np.allclose(dL_dW1, W1_pt.grad.numpy(), atol=1e-6), "W1 梯度不一致！"
assert np.allclose(dL_db1, b1_pt.grad.numpy(), atol=1e-6), "b1 梯度不一致！"
assert np.allclose(dL_dX, X_pt.grad.numpy(), atol=1e-6),   "X 梯度不一致！"

print("✅ 验收通过！手写链式法则梯度与 PyTorch autograd 结果完全一致！")
print(f"W1 手算梯度形状: {dL_dW1.shape}, 范数: {np.linalg.norm(dL_dW1):.4f}")
print(f"W2 手算梯度形状: {dL_dW2.shape}, 范数: {np.linalg.norm(dL_dW2):.4f}")