损失函数（平方损失MSE、绝对值损失MAE、负对数似然损失NLL、交叉熵损失CEL和二元交叉熵损失BCE）原理、公式调库实现与手动实现

1. 损失函数概述

1.1 什么是损失函数

损失函数（亦称代价函数、错误函数）损失函数是用来评估模型的预测值$f(x)$与真实值$y$的不一致程度，损失函数很小，表明机器学习模型与数据真实分布很接近，则模型性能好。

1.2 损失函数通常使用的位置

在端到端模型训练中，损失函数位于前向传播的最后一步，接收模型输出与真实标签后计算标量损失；随后通过反向传播算法，基于该损失对模型参数求梯度并更新，以逐步降低预测误差。

前向传播：将输入x通过模型model计算得到输出y的过程。

反向传播：要将预测值和真实值的差值减小，需要反向传播更新模型中的参数。

损失函数就基于这两种传播之间，起到承上启下的作用。承上：接受模型的预测值；启下：计算预测值和真实值的差值，为后面的反向传播提供输入数据。

---

2. 平方损失函数（Mean Squared Error, MSE）

2.1 基本介绍与原理

平方损失函数（也称L2 Loss）将预测误差平方后求平均，强调较大误差对总体损失的贡献，使模型对离群点更敏感。

2.2 计算公式

$$\mathrm{MSE}=\frac{1}{n}\sum _{i=1}^n(y_i-{\hat{y}}_i{)}^2$$

其中，$y_i$为真实值，${\hat{y}}_i$为预测值，$n$为样本数。

上图的横坐标为$y_i-{\hat{y}}_i$，纵坐标为MSE。

MSE损失函数：即便学习率固定，也会收敛。当损失值趋向于0时会逐渐降低，从而让它在模型训练首尾时更加准确。

MSE：当真实值与预测值差大于1时，会增大其误差；小于1时，会减小其误差。即MSE会对误差较大（>1）的情况给予更大的惩罚，对误差较小（<1）的情况给予更小的惩罚。模型会偏向于惩罚较大的点，赋予其更大的权重。

（1）使用场景与作用

• 回归任务：常用于线性回归、神经网络回归等场景；
• 优化稳定：二阶可导，便于梯度计算与优化算法收敛。

（2）特点

• 对大误差具有二次惩罚，模型更关注异常值；
• 可导性好，但对离群点敏感。

2.3 使用方法

（1）调库实现

from sklearn.metrics import mean_squared_error
mse = mean_squared_error(y_true, y_pred)# 或在 PyTorch：
import torch.nn as nn
loss_fn = nn.MSELoss()
loss = loss_fn(outputs, targets) # outputs: 模型的输出, targets: 真实标签

（2）手动实现

import numpy as npdef mse(y_true, y_pred):y_true, y_pred = np.array(y_true), np.array(y_pred)return np.mean((y_true - y_pred) ** 2)

---

3. 绝对值损失函数（Mean Absolute Error, MAE）

3.1 基本介绍与原理

绝对值损失（L1 Loss）对误差取绝对值再求平均，避免了正负误差相互抵消，更具鲁棒性。

3.2 计算公式

$$\mathrm{MAE}=\frac{1}{n}\sum _{i=1}^n|y_i-{\hat{y}}_i|$$

上图的横坐标为$y_i-{\hat{y}}_i$，纵坐标为MAE。

MAE损失函数：梯度始终一样，即使很小的损失，梯度也很大，很难收敛到更高的精度。（可使用动态学习率解决）；且$y_i-{\hat{y}}_i=0$处不可导。

（1）使用场景与作用

• 回归任务：尤其当数据中存在异常值时，MAE比MSE更稳定；
• 目标分位回归：可用于中位数回归。

（2）特点

• 对离群点惩罚线性，较MSE更鲁棒；
• 不可导于误差为0处，需在实现时处理不连续点。

3.3 使用方法

（1）调库实现

from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(y_true, y_pred)# 或在 PyTorch：
import torch
criterion = torch.nn.L1Loss() # 创建损失函数对象
output = criterion(y_pre, y_true) # 计算损失值

（1）手动实现

import numpy as npdef mae(y_true, y_pred):y_true, y_pred = np.array(y_true), np.array(y_pred)return np.mean(np.abs(y_true - y_pred))

---

4. 负对数似然损失函数（Negative Log-Likelihood, NLL）

4.1 基本介绍与原理

负对数似然将模型对真实标签的预测概率的对数取负，衡量模型预测分布与真实分布的差异。对数使得连乘概率变为累加损失，更易数值计算。

对数损失函数用于分类问题，而不是回归问题，它的输入与前面几个损失函数不同。首先真实值是一个类别，模型输出则是一个概率。

4.2 计算公式

对于单样本类别标签 $y$：
$$\mathrm{NLL}(\mathrm{y},\mathrm{P}(y/x))=-\log P(y/x)$$
对 $n$ 个样本取平均或求和即可。

（1）使用场景与作用

• 多分类任务：常与 softmax 输出结合，用于分类神经网络；
• 构建最大似然估计框架。

（2）特点

• 与交叉熵等价（当输出为 softmax 概率时）；
• 对概率接近0的预测惩罚巨大。

4.3 使用方法

（1）示例

假设我们有一个简单的图像分类任务，要将图像分为猫、狗、兔子三类。我们训练了一个神经网络模型，它会输出一个长度为 3 的向量，表示输入图像属于猫、狗、兔子的概率。

图像编号	预测为猫的概率	预测为狗的概率上	预测为兔子的概率	真实值标签
1	0.7	0.2	0.1	0（猫）
2	0.1	0.8	0.1	1（狗）
3	0.6	0.3	0.1	0（猫）
4	0.1	0.2	0.7	2（兔子）
5	0.2	0.7	0.1	1（狗）

• 对于第 1 张图像，真实标签是猫，模型预测为猫的概率是 0.7，所以该样本的损失为 −log(0.7)≈0.3567。
• 对于第 2 张图像，真实标签是狗，模型预测为狗的概率是 0.8，该样本的损失为 −log(0.8)≈0.2231。
• •对于第 3 张图像，真实标签是猫，模型预测为猫的概率是 0.6，损失为 −log(0.6)≈0.5108。
• •对于第 4 张图像，真实标签是兔子，模型预测为兔子的概率是 0.7，损失为 −log(0.7)≈0.3567。
• •对于第 5 张图像，真实标签是狗，模型预测为狗的概率是 0.7，损失为 −log(0.7)≈0.3567。

那么这 5 个样本的负对数似然损失函数值为：(0.3567+0.2231+0.5108+0.3567+0.3567)÷5=0.3604

从这个例子可以看出，模型对每个样本预测的概率越接近真实标签对应的概率，负对数似然损失函数值就越小，说明模型的性能越好。如果模型预测完全准确，即对于真实标签为猫的图像，预测为猫的概率为 1，那么该样本的损失为 −log(1)=0。

（2）调库实现（PyTorch）

import torch.nn as nn
loss_fn = nn.NLLLoss()
# 前提：模型最后输出需为 log-softmax
loss = loss_fn(log_probs, targets)import torch
import torch.nn as nn
# 示例数据
y_true = torch.tensor([0, 1, 0, 2, 1])
y_pred = torch.tensor([[0.7, 0.2, 0.1], [0.1, 0.8, 0.1], [0.6, 0.3, 0.1],[0.1, 0.2, 0.7],[0.2, 0.7, 0.1]], dtype=torch.float32)loss = nn.NLLLoss() # 创建负对数似然损失函数对象
output = torch.log(y_pred) # 对预测值取对数
result = loss(output, y_true) # 计算损失值
print(result)

（3）手动实现

import numpy as npdef nll(logits, targets):# logits: (n_samples, n_classes), raw scores# 转为概率并取对数exps = np.exp(logits - np.max(logits, axis=1, keepdims=True))probs = exps / np.sum(exps, axis=1, keepdims=True)log_probs = np.log(probs)# 选择真实类别nll = -log_probs[np.arange(len(targets)), targets]return np.mean(nll)# 上述示例代码实现：
import torch# 示例数据
y_true = torch.tensor([0, 1, 0, 2, 1])
y_pred = torch.tensor([[0.7, 0.2, 0.1], [0.1, 0.8, 0.1], [0.6, 0.3, 0.1],[0.1, 0.2, 0.7],[0.2, 0.7, 0.1]], dtype=torch.float32)# 公式计算对数损失函数
N = len(y_true) # 获取样本数量
loss = 0 # 初始化损失值
for i in range(N): #遍历样本# 获取真实标签true_label = y_true[i] # 获取真实标签对应的预测值y_p = y_pred[i, true_label]one = -torch.log(y_p)loss += one # 累加损失值
print(loss / N) # 计算平均损失值

---

5. 交叉熵损失函数（Cross-Entropy Loss）

5.1 基本介绍与原理

交叉熵损失函数（Cross - Entropy Loss Function）是机器学习和深度学习中用于衡量模型预测结果与真实标签之间差异的一种常用损失函数，在分类任务中应用广泛。交叉熵源自信息论，用于度量两个概率分布之间的距离。在分类中，计算真实分布与预测分布的交叉熵，值越小表示分布越接近。

5.2 计算公式

对于多分类（one-hot 编码 y i , k ∈ { 0 , 1 } y_{i,k}\in\{0,1\} yi,k​∈{0,1}、预测概率 ${\hat{p}}_{i,k}$：
$$\mathrm{CE}=-\frac{1}{n}\sum _{i=1}^n\sum _{k=1}^K{y}_{i,k}\log {\hat{p}}_{i,k}$$
其中

• $y_i$是第$i$个样本的真实标记
• ${\hat{p}}_i$是第$i$个样本的模型预测概率
• $K$代表第$K$个类别

例如：

$m$个样本、$n$种类别的交叉熵误差：
KaTeX parse error: Can't use function '$' in math mode at position 82: …log p_{k}^{(i)}$̲
该样本被标记为第$k$个类别：
$${\mathbf{y}}^{(i)}={\left[\begin{array}{c}0\\ 1\\ 0\\ ⋮\\ 0\end{array}\right]}_{n\times 1}$$
其中的1代表的是第$k$个$y_k^{(i)}$，其余均是0。

多分类问题的交叉熵损失，只与真实类别对应的模型预测概率有关，因为只有真实类别对应的那一项会被计算在内，其他类别的项在求和过程中均为0。

所以模型对其他类别饿预测概率不准确，但只要对真实类别的预测概率较高，损失函数的值仍然较低。

示例：

假设有以下 3 张水果图像的真实标签和模型预测的概率分布：

图像编号	真实标签$y$	预测概率分布$\hat{y}$
1	[1,0,0]	[0.8,0.1,0.1]
2	[0,1,0]	[0.1,0.7,0.2]
3	[0,0,1]	[0.2,0.3,0.5]

计算过程

• 图像 1：L1=−(1×log(0.8)+0×log(0.1)+0×log(0.1))=−log(0.8)≈0.223
• 图像 2：L2=−(0×log(0.1)+1×log(0.7)+0×log(0.2))=−log(0.7)≈0.357
• •图像 3：L3=−(0×log(0.2)+0×log(0.3)+1×log(0.5))=−log(0.5)≈0.693

平均损失为：$L_{avg}=\frac{L_1+L_2+L_3}{3}=\frac{0.223+0.357+0.693}{3}\approx 0.424$

（1）使用场景与作用

• 多分类神经网络：最后一层softmax + 交叉熵；
• 多标签分类：常配合 sigmoid 输出。

（1）特点

• 对不确定预测（概率接近0）有高惩罚；
• 与 NLLLoss 在 softmax 情况下等价。

5.3 使用方法

（1）调库实现

import torch.nn as nn
criterion = nn.CrossEntropyLoss()
loss = criterion(y_pred, y_true)
print(loss)

（2）手动实现

import numpy as npdef cross_entropy(y_true, y_pred, eps=1e-12):# y_true: one-hot, y_pred: probabilitiesy_pred = np.clip(y_pred, eps, 1. - eps)return -np.mean(np.sum(y_true * np.log(y_pred), axis=1))# 示例：
import torchy_true = torch.tensor([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=torch.float32)
y_pred = torch.tensor([[0.8, 0.1, 0.1], [0.1, 0.7, 0.2], [0.2, 0.3, 0.5]], dtype=torch.float32)# 手动实现交叉熵损失函数
N = len(y_true)
loss = 0
for i in range(N):one = torch.sum(y_true[i] * torch.log(y_pred[i]))loss += -one
print(loss / N)

---

6. 二元交叉熵损失函数（Binary Cross-Entropy, BCE）

6.1 基本介绍与原理

二元交叉熵是交叉熵在二分类问题上的特例，标签 y ∈ { 0 , 1 } y\in\{0,1\} y∈{0,1}，预测概率 $\hat{p}\in (0,1)$，衡量两类分布差异。

6.2 计算公式

$$\mathrm{BCE}=-\frac{1}{n}\sum _{i=1}^n[y_i\log {\hat{p}}_i+(1-y_i)\log (1-{\hat{p}}_i)]$$

其中

• $y_i$是第$i$个样本的真实标记
• ${\hat{p}}_i$是第$i$个样本的模型预测概率

（1）使用场景与作用

• 二分类神经网络：最后一层 sigmoid + BCE；
• 多标签分类：对每个标签独立计算BCE后求平均。

（1）特点

• 对罕见类别（小概率）预测误差惩罚高；
• 易梯度消失，通常配合从 logits 输入的 from_logits=True 实现更稳定。

6.3 使用方法

（1）调库实现（TensorFlow）

import tensorflow as tf
loss_fn = tf.keras.losses.BinaryCrossentropy(from_logits=False)
loss = loss_fn(y_true, y_pred)# 示例
import torch
y_true = torch.tensor([1, 0, 1, 0], dtype=torch.float32)
y_pred = torch.tensor([0.9, 0.1, 0.2, 0.8], dtype=torch.float32)# 使用torch.nn.BCELoss()计算二元交叉熵损失函数
criterion = torch.nn.BCELoss()
loss = criterion(y_pred, y_true)
print(loss)

（2）手动实现

import numpy as npdef binary_cross_entropy(y_true, y_pred, eps=1e-12):y_pred = np.clip(y_pred, eps, 1. - eps)return -np.mean(y_true * np.log(y_pred) + (1-y_true) * np.log(1-y_pred))# 示例
import torch
y_true = torch.tensor([1, 0, 1, 0], dtype=torch.float32)
y_pred = torch.tensor([0.9, 0.1, 0.2, 0.8], dtype=torch.float32)# 手动实现二元交叉熵损失函数
N = len(y_true)
loss = 0
for i in range(N):true_label = y_true[i]pred_label = y_pred[i]one = true_label * torch.log(pred_label) + (1 - true_label) * torch.log(1 - pred_label)loss += -one
print(loss/N)

---

小Tips：交叉熵损失函数与对数损失函数：从本质上来说，在分类问题中，交叉熵损失函数和对数损失函数是等价的。对数损失函数是交叉熵损失函数在分类问题中的具体应用形式，二者都旨在最小化模型预测与真实标签之间的差异，促使模型学习到更准确的分类模式。