损失函数与梯度推导：从MSE到交叉熵的完整指南

1. 为什么损失函数和梯度推导值得你花时间死磕

刚入门深度学习那会儿，我和大多数人一样，上来就model.compile()、model.fit()，跑通了就觉得自己会了。直到有一次自己动手写一个自定义层，反向传播怎么都对不上，梯度要么爆炸要么消失，调了整整两天才发现是损失函数求导时漏了一项。那次之后我才真正明白：损失函数和梯度推导不是学术派才关心的东西，它是你排查模型不收敛、训练震荡、梯度异常时唯一能依靠的底层逻辑。

这篇文章面向的是已经能跑通基础模型、但遇到训练问题只能靠“换学习率、换优化器、加batch size”三件套瞎试的人。我会从损失函数的设计动机讲起，把MSE、交叉熵、Hinge这几个常用损失函数的梯度一步步推给你看，然后落到代码上，让你能自己验证推导结果。整个过程不需要你有多深的数学底子，只要会链式法则和基本的矩阵运算就够了。

核心关键词就三个：损失函数、梯度推导、反向传播。这三个东西是一条线上的——损失函数定义了“什么是错”，梯度推导告诉你“怎么改”，反向传播则是把这件事高效地算出来。搞懂这条线，你再看任何论文里的loss设计，都能快速判断它到底在优化什么。

2. 损失函数到底在做什么：从直觉到数学形式

2.1 损失函数的本质是一个“打分器”

你可以把损失函数想象成一个裁判。模型每次预测完，裁判就根据预测值和真实值的差距给一个分数。分数越高说明错得越离谱，分数越低说明预测越准。训练的目标就是让这个分数越来越小。

但这里有个容易被忽略的点：损失函数不只是衡量对错，它还隐含地定义了“你更在意哪种错”。举个例子，在分类任务里，把一个猫预测成狗和预测成汽车，对交叉熵来说惩罚是不一样的——因为交叉熵看的是概率分布的距离，预测成汽车意味着猫的概率被压得极低，惩罚自然更大。而如果你用准确率作为指标，这两种错是一样的。所以选损失函数，本质上是在选你关心什么样的错误。

2.2 为什么不能直接用准确率当损失函数

很多人第一反应是：分类任务直接看准确率不就行了，分对了就是1，分错了就是0。问题在于，准确率对参数是不可导的。你稍微调一下权重，预测结果可能从“猫0.51、狗0.49”变成“猫0.52、狗0.48”，准确率纹丝不动，梯度全是零，根本没法更新。

所以损失函数必须是一个连续可导的函数，哪怕预测只变化一点点，损失也要跟着变一点点。这就是为什么我们用交叉熵而不是准确率，用MSE而不是绝对误差（虽然MAE也可导，但在零点不可导，且梯度恒定不利于收敛）。

2.3 常见损失函数一览与适用场景

这张表建议你记牢，尤其是最后一列。梯度形式决定了训练的动态行为，后面推导的时候你会看到，交叉熵配Softmax之所以好用，就是因为它的梯度干净到令人发指。

3. 均方误差的梯度推导：从标量到向量

3.1 标量情况下的推导

先从最简单的开始。假设只有一个样本，预测值$\hat{y}$，真实值$y$，损失是：

$$L = \frac{1}{2}(y - \hat{y})^2$$

这里加$\frac{1}{2}$是为了求导时把平方的2抵消掉，纯粹为了计算方便，不影响最优解位置。

对$\hat{y}$求导：

$$\frac{\partial L}{\partial \hat{y}} = -(y - \hat{y}) = \hat{y} - y$$

就这么简单。梯度的含义是：如果预测值比真实值大，梯度为正，参数往负方向更新就会让预测值变小；反之亦然。梯度永远指向损失增大的方向，所以我们要往反方向走。

3.2 推广到向量和批量

实际训练中$\hat{y}$是一个向量，损失是所有维度的平均：

$$L = \frac{1}{2n}\sum_{i=1}^{n}(y_i - \hat{y}_i)^2$$

对第$j$个输出$\hat{y}_j$求偏导，只有第$j$项包含它：

$$\frac{\partial L}{\partial \hat{y}_j} = \frac{1}{n}(\hat{y}_j - y_j)$$

写成向量形式就是：

$$\frac{\partial L}{\partial \hat{\mathbf{y}}} = \frac{1}{n}(\hat{\mathbf{y}} - \mathbf{y})$$

3.3 再往前传一层：对权重的梯度

假设$\hat{\mathbf{y}} = \mathbf{W}\mathbf{x} + \mathbf{b}$，我们要对$\mathbf{W}$求导。根据链式法则：

$$\frac{\partial L}{\partial \mathbf{W}} = \frac{\partial L}{\partial \hat{\mathbf{y}}} \cdot \frac{\partial \hat{\mathbf{y}}}{\partial \mathbf{W}}$$

其中$\frac{\partial \hat{\mathbf{y}}}{\partial \mathbf{W}}$就是输入$\mathbf{x}$（因为$\hat{y}j = \sum_k W{jk}x_k + b_j$，对$W_{jk}$求导得$x_k$）。

所以：

$$\frac{\partial L}{\partial \mathbf{W}} = \frac{1}{n}(\hat{\mathbf{y}} - \mathbf{y})\mathbf{x}^T$$

这个结果很直观：权重的梯度等于输出误差乘以对应的输入。输入大的维度，梯度也大，更新幅度就大。这也是为什么输入不做归一化时训练容易不稳定——某些维度梯度天然就大。

实操心得：我在做回归任务时，如果发现某些权重更新特别剧烈，第一件事就是检查输入特征的尺度。MSE对输入尺度非常敏感，因为梯度直接和输入值相乘。

4. 交叉熵与Softmax：深度学习中最优雅的梯度

4.1 为什么分类任务用交叉熵而不是MSE

假设一个三分类问题，真实标签是[1,0,0]，模型预测[0.1,0.8,0.1]。用MSE算损失是$(0.9^2+0.8^2+0.1^2)/3 \approx 0.49$。用交叉熵算是$-\log(0.1) \approx 2.3$。

看起来MSE的损失更小，但关键在于梯度。MSE对Softmax输出的梯度里会带一个Softmax导数的因子$\hat{y}(1-\hat{y})$，当预测值接近0或1时这个因子趋近于0，梯度消失，学不动。而交叉熵配Softmax，梯度直接是$\hat{y}-y$，预测错得越离谱（比如真实类是猫但预测概率0.01），梯度越大，修正越猛。

4.2 Softmax函数及其导数

Softmax把一组实数变成概率分布：

$$\hat{y}_i = \frac{e^{z_i}}{\sum_j e^{z_j}}$$

其中$z_i$是第$i$类的logit（未归一化的得分）。

Softmax的导数分两种情况：

• 当$i = j$时：$\frac{\partial \hat{y}_i}{\partial z_i} = \hat{y}_i(1 - \hat{y}_i)$
• 当$i \neq j$时：$\frac{\partial \hat{y}_i}{\partial z_j} = -\hat{y}_i \hat{y}_j$

这个推导用商法则就能得到，不展开。记住结论就行。

4.3 交叉熵损失对logit的梯度推导

交叉熵损失（单个样本）：

$$L = -\sum_i y_i \log \hat{y}_i$$

其中$y$是one-hot向量，只有真实类为1。

对$z_k$求导，需要用到链式法则，因为$\hat{y}_i$都依赖$z_k$：

$$\frac{\partial L}{\partial z_k} = -\sum_i y_i \frac{1}{\hat{y}_i} \frac{\partial \hat{y}_i}{\partial z_k}$$

把Softmax导数代入，分$i=k$和$i \neq k$：

$$= -y_k \frac{1}{\hat{y}_k}\hat{y}_k(1-\hat{y}k) - \sum{i \neq k} y_i \frac{1}{\hat{y}_i}(-\hat{y}_i \hat{y}_k)$$

$$= -y_k(1-\hat{y}k) + \sum{i \neq k} y_i \hat{y}_k$$

$$= -y_k + y_k \hat{y}_k + \hat{y}k \sum{i \neq k} y_i$$

因为$\sum_i y_i = 1$，所以$\sum_{i \neq k} y_i = 1 - y_k$：

$$= -y_k + y_k \hat{y}_k + \hat{y}_k(1 - y_k) = \hat{y}_k - y_k$$

最终结果：$\frac{\partial L}{\partial \mathbf{z}} = \hat{\mathbf{y}} - \mathbf{y}$

这个结果太漂亮了。梯度就是预测概率减去真实标签。如果真实类是第2类，预测概率是[0.1, 0.6, 0.3]，那么梯度就是[0.1, -0.4, 0.3]。第2类的logit会被增大（梯度为负，往反方向更新），其他类被压低。

4.4 代码验证

推导对不对，跑一遍就知道：

import numpy as np def softmax(z): e = np.exp(z - np.max(z)) return e / e.sum() # 前向 z = np.array([1.0, 2.0, 3.0]) y = np.array([0, 0, 1]) # 真实类是第3类 y_hat = softmax(z) loss = -np.sum(y * np.log(y_hat)) print(f"loss: {loss:.4f}") # 手动梯度 grad_manual = y_hat - y print(f"manual grad: {grad_manual}") # 数值梯度验证 eps = 1e-5 grad_numeric = np.zeros_like(z) for i in range(len(z)): z_plus = z.copy(); z_plus[i] += eps z_minus = z.copy(); z_minus[i] -= eps loss_plus = -np.sum(y * np.log(softmax(z_plus))) loss_minus = -np.sum(y * np.log(softmax(z_minus))) grad_numeric[i] = (loss_plus - loss_minus) / (2 * eps) print(f"numeric grad: {grad_numeric}")

跑出来两个梯度几乎一模一样，说明推导没问题。数值梯度验证是我强烈建议养成的习惯，每次自己推完梯度，花两分钟写个验证脚本，能省掉后面几小时的debug。

5. 反向传播：把梯度从最后一层传到第一层

5.1 计算图视角下的反向传播

反向传播本质上就是链式法则的系统化应用。把前向过程画成计算图，每个节点是一个运算，反向传播就是从损失节点出发，沿着图的反方向，每经过一个节点就乘以该节点的局部梯度。

假设一个两层网络：

$$\mathbf{h} = \sigma(\mathbf{W}_1\mathbf{x} + \mathbf{b}_1)$$ $$\mathbf{z} = \mathbf{W}_2\mathbf{h} + \mathbf{b}_2$$ $$\hat{\mathbf{y}} = \text{softmax}(\mathbf{z})$$ $$L = \text{CrossEntropy}(\hat{\mathbf{y}}, \mathbf{y})$$

反向传播的顺序是：

1. $\frac{\partial L}{\partial \mathbf{z}} = \hat{\mathbf{y}} - \mathbf{y}$（已经推过）
2. $\frac{\partial L}{\partial \mathbf{W}_2} = \frac{\partial L}{\partial \mathbf{z}} \mathbf{h}^T$
3. $\frac{\partial L}{\partial \mathbf{h}} = \mathbf{W}_2^T \frac{\partial L}{\partial \mathbf{z}}$
4. $\frac{\partial L}{\partial \mathbf{a}_1} = \frac{\partial L}{\partial \mathbf{h}} \odot \sigma'(\mathbf{a}_1)$，其中$\mathbf{a}_1 = \mathbf{W}_1\mathbf{x} + \mathbf{b}_1$，$\odot$是逐元素乘
5. $\frac{\partial L}{\partial \mathbf{W}_1} = \frac{\partial L}{\partial \mathbf{a}_1} \mathbf{x}^T$

5.2 激活函数导数的坑

第4步里的$\sigma'$是激活函数的导数。这里是最容易出问题的地方：

• Sigmoid：$\sigma'(x) = \sigma(x)(1-\sigma(x))$，最大值只有0.25。多层叠加后梯度指数衰减，这就是经典的梯度消失。
• Tanh：导数最大为1，比Sigmoid好一点，但饱和区仍然趋近0。
• ReLU：$x>0$时导数为1，$x<0$时为0。正区间不衰减，但负区间直接死掉，导致“神经元死亡”。

注意：用ReLU时如果学习率设太大，一批神经元的输入全落到负区间，梯度永远是0，这些神经元就再也活不过来了。我一般的做法是先用较小的学习率（1e-3或更小），观察几轮再决定要不要调大。

5.3 批量版本的梯度

实际训练都是mini-batch，假设batch size为$B$，交叉熵损失是平均：

$$L = \frac{1}{B}\sum_{b=1}^{B} L_b$$

梯度也要除以$B$：

$$\frac{\partial L}{\partial \mathbf{z}^{(b)}} = \frac{1}{B}(\hat{\mathbf{y}}^{(b)} - \mathbf{y}^{(b)})$$

写成矩阵形式，如果$\mathbf{Z}$是$B \times C$的矩阵（$C$是类别数），$\hat{\mathbf{Y}}$和$\mathbf{Y}$同形：

$$\frac{\partial L}{\partial \mathbf{Z}} = \frac{1}{B}(\hat{\mathbf{Y}} - \mathbf{Y})$$

然后$\frac{\partial L}{\partial \mathbf{W}_2} = \frac{\partial L}{\partial \mathbf{Z}}^T \mathbf{H}$，其中$\mathbf{H}$是$B \times H$的隐藏层输出。

5.4 完整的手写反向传播代码

下面是一个两层网络的完整实现，不依赖任何框架的自动求导：

import numpy as np class TwoLayerNet: def __init__(self, input_dim, hidden_dim, output_dim): self.W1 = np.random.randn(input_dim, hidden_dim) * 0.01 self.b1 = np.zeros(hidden_dim) self.W2 = np.random.randn(hidden_dim, output_dim) * 0.01 self.b2 = np.zeros(output_dim) def forward(self, X): self.X = X self.a1 = X @ self.W1 + self.b1 self.h = np.maximum(0, self.a1) # ReLU self.z = self.h @ self.W2 + self.b2 # softmax e = np.exp(self.z - np.max(self.z, axis=1, keepdims=True)) self.y_hat = e / e.sum(axis=1, keepdims=True) return self.y_hat def backward(self, y_true): B = self.X.shape[0] # 交叉熵 + softmax 的梯度 dz = (self.y_hat - y_true) / B # 第二层权重和偏置 dW2 = self.h.T @ dz db2 = dz.sum(axis=0) # 传到隐藏层 dh = dz @ self.W2.T # ReLU 导数 da1 = dh * (self.a1 > 0) # 第一层权重和偏置 dW1 = self.X.T @ da1 db1 = da1.sum(axis=0) return dW1, db1, dW2, db2 def update(self, grads, lr=0.1): dW1, db1, dW2, db2 = grads self.W1 -= lr * dW1 self.b1 -= lr * db1 self.W2 -= lr * dW2 self.b2 -= lr * db2

这段代码里每一行梯度都能对应到前面的推导。dz = (y_hat - y_true) / B就是交叉熵配Softmax的梯度，dW2 = h.T @ dz就是$\frac{\partial L}{\partial \mathbf{W}_2} = \mathbf{H}^T \frac{\partial L}{\partial \mathbf{Z}}$，da1 = dh * (a1 > 0)就是ReLU的逐元素导数。

6. 梯度检查与常见训练问题排查

6.1 梯度检查的标准做法

自己写的反向传播，上线前一定要做梯度检查。核心思想是用数值梯度逼近解析梯度：

$$\frac{\partial L}{\partial \theta_i} \approx \frac{L(\theta_i + \epsilon) - L(\theta_i - \epsilon)}{2\epsilon}$$

然后用相对误差判断：

$$\text{relative error} = \frac{|\text{grad}{analytic} - \text{grad}{numeric}|}{\max(|\text{grad}{analytic}|, |\text{grad}{numeric}|) + 1e-8}$$

相对误差小于$10^{-7}$说明没问题，$10^{-5}$到$10^{-7}$之间要警惕，大于$10^{-3}$基本可以确定推导或实现有bug。

实操心得：梯度检查时一定要把dropout、batch norm这些训练态和推理态行为不同的层关掉，否则数值梯度会不稳定。另外用双精度浮点数，单精度下$\epsilon$取太小会被舍入误差淹没。

6.2 常见问题速查表

6.3 梯度消失与爆炸的定量判断

怎么知道梯度是消失了还是爆炸了？最直接的办法是在反向传播过程中记录每层梯度的范数：

def print_grad_norms(self, grads): dW1, db1, dW2, db2 = grads print(f"W1 grad norm: {np.linalg.norm(dW1):.6f}") print(f"W2 grad norm: {np.linalg.norm(dW2):.6f}")

如果W1的梯度范数比W2小好几个数量级，说明梯度在传播过程中衰减了。这时候可以考虑：换激活函数（ReLU换Sigmoid）、加残差连接、用BatchNorm。如果反过来W1远大于W2，可能是梯度爆炸，需要加梯度裁剪：

def clip_gradients(grads, max_norm=5.0): total_norm = np.sqrt(sum(np.sum(g**2) for g in grads)) if total_norm > max_norm: scale = max_norm / (total_norm + 1e-8) grads = [g * scale for g in grads] return grads

6.4 损失函数选择的几个实战建议

回归任务别无脑用MSE。如果数据里有很多离群点，MSE会被离群点主导，因为误差是平方的。这时候用Huber损失（小误差时是MSE，大误差时是MAE）更稳。

分类任务里，如果类别极度不平衡（比如正样本只占1%），普通交叉熵会被多数类主导。可以用带权重的交叉熵，给少数类更大的权重：

$$L = -\sum_i w_i y_i \log \hat{y}_i$$

其中$w_i$可以设为$\frac{N}{N_i}$，$N$是总样本数，$N_i$是第$i$类样本数。

多标签分类（一个样本可以属于多个类）不能用Softmax，要用Sigmoid加二元交叉熵，每个类别独立判断。

7. 从推导到直觉：几个让我豁然开朗的瞬间

7.1 交叉熵梯度为什么这么简洁

第一次推完交叉熵配Softmax的梯度是$\hat{y}-y$时，我以为是巧合。后来才明白，这是指数族分布加最大似然估计的必然结果。Softmax属于指数族，交叉熵就是它的负对数似然，指数族分布的对数似然导数天然就是“期望减去观测”。这不是巧合，是数学结构决定的。

理解这一点之后，你看任何用最大似然训练的模型，都能预判它的梯度形式大概是“预测值减真实值”的某种变体。

7.2 梯度到底在告诉模型什么

梯度$\hat{y}-y$的物理意义很清晰：对于真实类，$y=1$，梯度是$\hat{y}-1$，是个负数，参数更新后会让这个类的logit增大；对于非真实类，$y=0$，梯度是$\hat{y}$，是个正数，参数更新后会让这些类的logit减小。梯度在做的就是把真实类的概率往上推，把其他类的概率往下压，而且推的力度和当前预测的偏差成正比。

7.3 为什么需要自己推一遍

用PyTorch或TensorFlow时，loss.backward()一行就搞定了，为什么还要手推？因为当训练出问题时，自动求导不会告诉你哪里出了问题。你只能看到损失不降，但不知道是梯度消失了、爆炸了、还是损失函数本身设计有问题。手推过一遍，你才能在打印出梯度范数时，一眼看出“这个值不对，正常应该是这个量级”。

我自己的经验是，每次设计一个新的损失函数，先手推梯度，再用数值梯度验证，最后才接到网络里训练。这个流程看起来慢，但比训练跑完发现不收敛再回头查要快得多。

8. 进阶方向：自定义损失函数的设计思路

8.1 设计自定义损失函数的基本框架

当你需要设计一个新损失函数时，按这个顺序思考：

1. 明确优化目标：你希望模型在什么情况下损失大，什么情况下损失小？
2. 保证可导：损失函数对模型输出必须几乎处处可导，否则梯度传不回去。
3. 推导梯度：手动推导$\frac{\partial L}{\partial \hat{y}}$，尽量化简。
4. 数值验证：写脚本对比解析梯度和数值梯度。
5. 量级检查：损失值和梯度的量级要和常用损失函数可比，否则学习率要重新调。

8.2 一个例子：Focal Loss的梯度

Focal Loss是为了解决类别不平衡提出的：

$$L = -\alpha (1-\hat{y})^\gamma \log \hat{y}$$

其中$\gamma > 0$是聚焦参数，$\alpha$是类别权重。当$\gamma=0$时退化为普通交叉熵。

对$\hat{y}$求导：

$$\frac{\partial L}{\partial \hat{y}} = -\alpha \left[ -\gamma(1-\hat{y})^{\gamma-1}\log \hat{y} + (1-\hat{y})^\gamma \frac{1}{\hat{y}} \right]$$

$$= \alpha \gamma (1-\hat{y})^{\gamma-1}\log \hat{y} - \alpha \frac{(1-\hat{y})^\gamma}{\hat{y}}$$

这个梯度里，$(1-\hat{y})^\gamma$这一项让容易分类的样本（$\hat{y}$接近1）梯度被压低，难分类样本（$\hat{y}$接近0）梯度保持较大。这就是Focal Loss的核心机制。

8.3 梯度裁剪与损失缩放

混合精度训练时，损失值可能超出float16的表示范围，需要对损失做缩放（loss scaling）。缩放后的损失梯度也等比缩放，更新前要除回来。这个过程中如果梯度溢出，需要跳过这一步并调整缩放因子。理解梯度推导能帮你判断缩放因子是否合理——如果梯度范数在缩放后接近float16上限（65504），说明缩放因子太大了。

9. 我踩过的几个典型坑

第一个坑是交叉熵里log(0)。早期写代码没加epsilon，模型某次预测出概率0，log(0)直接-inf，损失变NaN。后来养成习惯，所有log操作都加一个极小值：

loss = -np.sum(y * np.log(y_hat + 1e-8))

第二个坑是Softmax数值溢出。直接算np.exp(z)，如果z里有大值（比如100），exp(100)直接溢出。正确做法是先减去最大值：

e = np.exp(z - np.max(z))

这个操作不改变Softmax结果，因为分子分母同乘了$e^{-\max(z)}$。

第三个坑是梯度检查时忘了除以batch size。我的损失是batch平均，但数值梯度是按单个样本算的，导致相对误差一直很大。后来统一在损失里除以B，梯度检查就通过了。

第四个坑是ReLU死亡。有一次学习率设了0.1，训练两轮后一半神经元输出恒为0，损失卡住不动。换成LeakyReLU（负区间给0.01的斜率）后恢复正常。现在我的默认配置是学习率1e-3起步，观察几轮再调。

10. 把推导变成肌肉记忆

损失函数和梯度推导这件事，看一遍和推一遍是两码事，推一遍和写代码验证一遍又是两码事。我的建议是：拿一张纸，把MSE、交叉熵、Hinge这三个损失的梯度从头推一遍，然后用numpy写个数值梯度验证脚本，跑通。整个过程不超过两小时，但这两小时建立的直觉，能让你后面调模型时少走很多弯路。

后续如果想深入，可以看看信息论里KL散度和交叉熵的关系，以及变分推断里ELBO的梯度推导。那些看起来复杂的东西，底层还是链式法则加期望的线性性质。把基础打牢，上层的东西都是自然延伸。