Loss Functions：Logistic Loss、Cross Entropy 与 Hinge Loss

Loss Functions：Logistic Loss、Cross Entropy 与 Hinge Loss

在机器学习和深度学习中，损失函数（Loss Function） 用来衡量模型预测结果与真实答案之间的差距。

训练模型的过程，本质上就是不断调整模型参数，使损失函数尽可能小。

例如，在分类任务中：

输入 x
  ↓
模型
  ↓
预测值
  ↓
Loss Function
  ↓
与真实标签比较
  ↓
得到 Loss
  ↓
反向传播 + 参数更新

本篇重点介绍三个经典分类损失函数：

• Logistic Loss；
• Cross Entropy；
• Hinge Loss；
• 以及它们之间的关系和使用场景。

---

1. 什么是损失函数

假设模型参数为：

θ\thetaθ

训练数据为：

{(xi,yi)}i=1N\{(x_i,y_i)\}_{i=1}^{N}{(xi,yi)}i=1N

模型的预测结果可以写成：

y^i=f(xi;θ)\hat{y}_i=f(x_i;\theta)y^i=f(xi;θ)

损失函数用于衡量：

y^i\hat{y}_iy^i

与真实标签：

yiy_iyi

之间的差异。

整个训练集上的平均损失通常写为：

J(θ)=1N∑i=1NL(yi,y^i)J(\theta)=\frac{1}{N}\sum_{i=1}^{N}L(y_i,\hat{y}_i)J(θ)=N1i=1∑NL(yi,y^i)

训练模型的目标就是：

θ∗=arg⁡min⁡θJ(θ)\theta^*=\arg\min_{\theta}J(\theta)θ∗=argθminJ(θ)

因此可以把机器学习训练简单理解成：

寻找一组模型参数，让预测错误所对应的"代价"尽可能小。

---

2. 分类问题中的 score、probability 和 margin

在理解下面三个损失函数前，需要区分三个概念。

2.1 Score

很多分类模型首先输出的不是概率，而是一个任意实数：

z=wTx+bz=w^Tx+bz=wTx+b

这个值通常称为：

• score；
• logit；
• decision score。

例如：

z = 3.2
z = -1.7
z = 0.4

---

2.2 Probability

Logistic Regression 可以通过 Sigmoid 将 score 转换为概率：

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

此时：

0<p<10<p<10<p<1

因此可以把：

p=P(y=1∣x)p=P(y=1|x)p=P(y=1∣x)

理解为模型认为样本属于正类的概率。

---

2.3 Margin

在 Logistic Loss 和 Hinge Loss 中，经常使用：

yzyzyz

这里通常规定：

y∈{−1,+1}y\in\{-1,+1\}y∈{−1,+1}

于是：

m=yzm=yzm=yz

称为分类 margin。

如果：

yz>0yz>0yz>0

说明分类方向正确。

如果：

yz<0yz<0yz<0

说明分类错误。

而且：

yzyzyz

越大，说明模型不仅分类正确，而且越有信心。

---

3. Logistic Loss

Logistic Loss 是 Logistic Regression 中最经典的损失函数之一。

假设：

y∈{−1,+1}y\in\{-1,+1\}y∈{−1,+1}

模型输出：

z=wTx+bz=w^Tx+bz=wTx+b

那么 Logistic Loss 定义为：

Llogistic(y,z)=log⁡(1+e−yz)L_{\text{logistic}}(y,z)=\log(1+e^{-yz})Llogistic(y,z)=log(1+e−yz)

这是一个非常重要的公式。

---

3.1 观察公式

令：

m=yzm=yzm=yz

那么：

L(m)=log⁡(1+e−m)L(m)=\log(1+e^{-m})L(m)=log(1+e−m)

也就是说，Logistic Loss 实际上主要关注的是：

yzyzyz

也就是模型的分类 margin。

可以看到：

• 当 margin 很小时，loss 很大；
• 当 margin = 0 时，模型处于分类边界；
• 当 margin 越来越大时，loss 越来越接近 0。

---

3.2 一个例子

假设真实类别：

y=+1y=+1y=+1

模型输出：

z=3z=3z=3

那么：

yz=3yz=3yz=3

损失为：

L=log⁡(1+e−3)L=\log(1+e^{-3})L=log(1+e−3)

损失非常小，说明预测比较好。

如果模型输出：

z=−3z=-3z=−3

则：

yz=−3yz=-3yz=−3

此时：

L=log⁡(1+e3)L=\log(1+e^3)L=log(1+e3)

损失会明显增大。

因为：

真实：正类
模型：强烈认为是负类

所以应该受到较大的惩罚。

---

4. Logistic Loss 为什么好用

Logistic Loss 有几个重要特点。

4.1 连续且光滑

Logistic Loss 是一个平滑函数，可以方便地求导。

其对 margin 的导数为：

dLdm=−11+em\frac{dL}{dm}=-\frac{1}{1+e^m}dmdL=−1+em1

这意味着可以直接使用：

• Gradient Descent；
• SGD；
• Momentum；
• Adam；

等优化算法训练模型。

---

4.2 错得越离谱，惩罚越大

当：

yz≪0yz\ll0yz≪0

模型不仅预测错误，而且非常自信地预测错误。

Logistic Loss 会给予较大的损失。

---

4.3 分类正确后仍然继续优化

即使：

yz>0yz>0yz>0

Loss 也不会立刻变成 0。

模型仍然会继续推动：

yzyzyz

变大。

所以 Logistic Loss 更像是在告诉模型：

分类正确还不够，你还应该提高正确分类的置信程度。

---

5. Cross Entropy

Cross Entropy，中文通常称为：

交叉熵损失

它是深度学习分类任务中最常见的损失函数之一。

Cross Entropy 常见于：

• Logistic Regression；
• 神经网络二分类；
• 多分类神经网络；
• CNN 图像分类；
• Transformer 分类任务。

---

6. Binary Cross Entropy

对于二分类问题，假设：

y∈{0,1}y\in\{0,1\}y∈{0,1}

模型预测正类概率：

p=P(y=1∣x)p=P(y=1|x)p=P(y=1∣x)

Binary Cross Entropy 的公式为：

LBCE=−ylog⁡(p)+(1−y)log⁡(1−p)L_{\text{BCE}}=-y\\log(p)+(1-y)\\log(1-p)LBCE=−ylog(p)+(1−y)log(1−p)

这个公式非常重要，建议记住。

---

6.1 当 y = 1

如果真实标签：

y=1y=1y=1

那么：

L=−log⁡(p)L=-\log(p)L=−log(p)

此时模型希望：

p→1p\rightarrow1p→1

因为概率越接近 1，Loss 越小。

---

6.2 当 y = 0

如果真实标签：

y=0y=0y=0

那么：

L=−log⁡(1−p)L=-\log(1-p)L=−log(1−p)

此时模型希望：

p→0p\rightarrow0p→0

因为正类概率越小越好。

---

6.3 Cross Entropy 的直觉

例如真实类别是：

y=1y=1y=1

模型预测：

p=0.9p=0.9p=0.9

那么：

L=−log⁡(0.9)L=-\log(0.9)L=−log(0.9)

损失很小。

如果模型预测：

p=0.1p=0.1p=0.1

那么：

L=−log⁡(0.1)L=-\log(0.1)L=−log(0.1)

损失很大。

因此 Cross Entropy 会特别惩罚：

非常自信但预测错误的模型。

---

7. Logistic Loss 与 Binary Cross Entropy 的关系

这两个名字经常让初学者困惑。

实际上：

Logistic Loss 和 Binary Cross Entropy 本质上描述的是同一个二分类学习目标，只是标签表示和公式写法不同。

Logistic Loss 常使用：

y∈{−1,+1}y\in\{-1,+1\}y∈{−1,+1}

公式为：

L=log⁡(1+e−yz)L=\log(1+e^{-yz})L=log(1+e−yz)

Binary Cross Entropy 常使用：

y∈{0,1}y\in\{0,1\}y∈{0,1}

公式为：

L=−ylog⁡(p)+(1−y)log⁡(1−p)L=-y\\log(p)+(1-y)\\log(1-p)L=−ylog(p)+(1−y)log(1−p)

如果：

p=σ(z)p=\sigma(z)p=σ(z)

那么两者可以相互转换。

因此，在很多资料中你会看到：

Log Loss
Logistic Loss
Binary Cross Entropy
Binary Log Loss

它们在二分类场景中通常具有非常紧密的对应关系。

---

8. 多分类 Cross Entropy

对于多分类问题，假设一共有：

KKK

个类别。

真实标签使用 one-hot 表示：

y=(y1,y2,...,yK)y=(y_1,y_2,\dots,y_K)y=(y1,y2,...,yK)

模型预测概率为：

p=(p1,p2,...,pK)p=(p_1,p_2,\dots,p_K)p=(p1,p2,...,pK)

并且满足：

∑k=1Kpk=1\sum_{k=1}^{K}p_k=1k=1∑Kpk=1

多分类 Cross Entropy 为：

L=−∑k=1Kyklog⁡(pk)L=-\sum_{k=1}^{K}y_k\log(p_k)L=−k=1∑Kyklog(pk)

由于 one-hot 标签只有正确类别对应位置为 1，所以公式实际上可以简化为：

L=−log⁡(py)L=-\log(p_y)L=−log(py)

这里：

pyp_ypy

表示模型分配给真实类别的概率。

---

9. Softmax + Cross Entropy

多分类神经网络通常先输出 logits：

z1,z2,...,zKz_1,z_2,\dots,z_Kz1,z2,...,zK

再经过 Softmax：

pk=ezk∑j=1Kezjp_k=\frac{e^{z_k}}{\sum_{j=1}^{K}e^{z_j}}pk=∑j=1Kezjezk

然后使用 Cross Entropy：

L=−log⁡(py)L=-\log(p_y)L=−log(py)

整个过程可以写成：

Neural Network
      ↓
    logits
      ↓
   Softmax
      ↓
 probabilities
      ↓
Cross Entropy
      ↓
     Loss

---

10. 一个三分类例子

假设有三个类别：

Cat
Dog
Bird

真实类别为：

Dog

对应 one-hot：

y=0,1,0y=0,1,0y=0,1,0

模型预测：

p=0.1,0.8,0.1p=0.1,0.8,0.1p=0.1,0.8,0.1

Cross Entropy：

L=−0log⁡(0.1)+1log⁡(0.8)+0log⁡(0.1)L=-0\\log(0.1)+1\\log(0.8)+0\\log(0.1)L=−0log(0.1)+1log(0.8)+0log(0.1)

因此：

L=−log⁡(0.8)L=-\log(0.8)L=−log(0.8)

如果模型预测变成：

p=0.8,0.1,0.1p=0.8,0.1,0.1p=0.8,0.1,0.1

那么：

L=−log⁡(0.1)L=-\log(0.1)L=−log(0.1)

Loss 会明显增大。

---

11. Hinge Loss

Hinge Loss 最经典的应用是：

Support Vector Machine，SVM

假设：

y∈{−1,+1}y\in\{-1,+1\}y∈{−1,+1}

模型输出：

z=wTx+bz=w^Tx+bz=wTx+b

Hinge Loss 定义为：

Lhinge(y,z)=max⁡(0,1−yz)L_{\text{hinge}}(y,z)=\max(0,1-yz)Lhinge(y,z)=max(0,1−yz)

这是 SVM 中最重要的损失函数之一。

---

12. Hinge Loss 的核心思想

同样令：

m=yzm=yzm=yz

则：

L=max⁡(0,1−m)L=\max(0,1-m)L=max(0,1−m)

于是存在三种情况。

情况 1：分类错误

如果：

yz<0yz<0yz<0

说明分类错误。

此时：

L>1L>1L>1

模型受到较大惩罚。

---

情况 2：分类正确，但 margin 不够

如果：

0<yz<10<yz<10<yz<1

虽然分类已经正确，但是距离分类边界太近。

此时：

L>0L>0L>0

所以模型仍然会被惩罚。

---

情况 3：分类正确，而且 margin 足够大

如果：

yz≥1yz\ge1yz≥1

则：

L=0L=0L=0

也就是说模型认为：

已经分得足够好了，不需要继续奖励这个样本。

---

13. Logistic Loss 与 Hinge Loss 对比

两者都可以用于二分类，但思想稍有不同。

Logistic Loss：

L=log⁡(1+e−yz)L=\log(1+e^{-yz})L=log(1+e−yz)

Hinge Loss：

L=max⁡(0,1−yz)L=\max(0,1-yz)L=max(0,1−yz)

最大的差别在于：

当：

yz≥1yz\ge1yz≥1

Hinge Loss 直接变成：

000

而 Logistic Loss 仍然大于：

000

只是越来越接近 0。

因此：

Hinge Loss:
分得足够好 → 不再管这个样本

Logistic Loss:
分得越好 → Loss 越小，但仍继续优化

---

14. Hinge Loss 与 SVM 的关系

线性 SVM 并不只是最小化 Hinge Loss，还需要考虑参数正则化。

一个典型形式为：

J(w)=12∥w∥2+C∑i=1Nmax⁡(0,1−yi(wTxi+b))J(w)=\frac{1}{2}\|w\|^2+C\sum_{i=1}^{N}\max(0,1-y_i(w^Tx_i+b))J(w)=21∥w∥2+Ci=1∑Nmax(0,1−yi(wTxi+b))

其中第一部分：

12∥w∥2\frac{1}{2}\|w\|^221∥w∥2

用于控制模型复杂度。

第二部分：

C∑i=1Nmax⁡(0,1−yi(wTxi+b))C\sum_{i=1}^{N}\max(0,1-y_i(w^Tx_i+b))Ci=1∑Nmax(0,1−yi(wTxi+b))

用于惩罚分类错误以及 margin 不足的样本。

SVM 的目标可以简单理解为：

在正确分类样本的同时，让分类边界与两类样本之间的间隔尽可能大。

---

15. 三个损失函数放在一起理解

可以建立这样一个整体认识。

Loss	常见任务	标签形式	模型输出	核心思想
Logistic Loss	二分类	-1 / +1	score / logit	根据分类 margin 平滑惩罚
Binary Cross Entropy	二分类	0 / 1	probability 或 logit	最大化真实类别概率
Cross Entropy	多分类	class / one-hot	logits	提高真实类别概率
Hinge Loss	SVM 二分类	-1 / +1	decision score	正确且超过 margin 后不再惩罚

需要特别注意：

Logistic Loss 与 Binary Cross Entropy 在 Logistic Regression 中实际上是同一目标的不同表达形式。

---

16. NumPy 实现

16.1 Logistic Loss

import numpy as np

def logistic_loss(y, z):
    return np.logaddexp(0, -y * z)

例如：

y = 1
z = 2.5

loss = logistic_loss(y, z)

print(loss)

这里使用：

np.logaddexp

而不是直接写：

np.log(1 + np.exp(-y * z))

主要是为了提高数值稳定性。

---

17. Binary Cross Entropy 的 NumPy 实现

import numpy as np

def binary_cross_entropy(y, p):
    eps = 1e-12
    p = np.clip(p, eps, 1 - eps)

    return -(y * np.log(p) + (1 - y) * np.log(1 - p))

例如：

y = 1
p = 0.9

loss = binary_cross_entropy(y, p)

print(loss)

这里需要：

np.clip()

是因为：

log⁡(0)\log(0)log(0)

没有有限值。

因此实际计算中应该避免预测概率刚好等于 0 或 1。

---

18. Multi-class Cross Entropy 的 NumPy 实现

import numpy as np

def cross_entropy(y_true, probabilities):
    eps = 1e-12
    probabilities = np.clip(probabilities, eps, 1.0)

    return -np.log(probabilities[y_true])

例如：

probabilities = np.array([0.1, 0.8, 0.1])

y_true = 1

loss = cross_entropy(y_true, probabilities)

print(loss)

---

19. Hinge Loss 的 NumPy 实现

import numpy as np

def hinge_loss(y, z):
    return np.maximum(0, 1 - y * z)

例如：

y = 1
z = 0.6

loss = hinge_loss(y, z)

print(loss)

因为：

yz=0.6yz=0.6yz=0.6

所以：

L=max⁡(0,1−0.6)L=\max(0,1-0.6)L=max(0,1−0.6)

即：

L=0.4L=0.4L=0.4

说明分类方向虽然正确，但 margin 仍然不够大。

---

20. PyTorch 中的 CrossEntropyLoss

在 PyTorch 中，多分类最常使用：

torch.nn.CrossEntropyLoss

例如：

import torch
import torch.nn as nn

criterion = nn.CrossEntropyLoss()

logits = torch.tensor([
    [2.0, 4.0, 1.0],
    [3.0, 1.0, 0.5]
])

targets = torch.tensor([1, 0])

loss = criterion(logits, targets)

print(loss)

这里有一个非常重要的注意点：

CrossEntropyLoss 接收的是 raw logits，不需要自己先调用 Softmax。

不要写成：

probabilities = torch.softmax(logits, dim=1)
loss = criterion(probabilities, targets)

而应该直接：

loss = criterion(logits, targets)

PyTorch 会在内部完成对应的稳定计算。

---

21. PyTorch 中的 BCEWithLogitsLoss

对于二分类问题，更推荐：

torch.nn.BCEWithLogitsLoss

例如：

import torch
import torch.nn as nn

criterion = nn.BCEWithLogitsLoss()

logits = torch.tensor([2.0, -1.0, 0.5])

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

loss = criterion(logits, targets)

print(loss)

同样需要注意：

BCEWithLogitsLoss 已经包含 Sigmoid，所以输入 raw logits 即可。

通常不要先执行：

torch.sigmoid(logits)

再传入 BCEWithLogitsLoss。

---

22. 为什么推荐直接输入 logits

从数学上看，我们可以先：

z→σ(z)→BCEz\rightarrow\sigma(z)\rightarrow BCEz→σ(z)→BCE

或者：

z→Softmax(z)→CrossEntropyz\rightarrow Softmax(z)\rightarrow CrossEntropyz→Softmax(z)→CrossEntropy

但计算机中直接组合计算通常更加稳定。

例如非常大的正数或负数可能导致：

exp(x)
log(x)

出现：

• overflow；
• underflow；
• log(0)。

因此深度学习框架通常提供：

BCEWithLogitsLoss
CrossEntropyLoss

让概率转换和损失计算组合在一起完成。

---

23. 三者的决策逻辑

可以通过一个二分类样本快速理解 Logistic Loss 与 Hinge Loss。

假设：

y=+1y=+1y=+1

模型输出 z = -2

此时：

yz=−2yz=-2yz=−2

模型分类错误。

Logistic Loss 较大，Hinge Loss 也较大。

---

模型输出 z = 0.5

此时：

yz=0.5yz=0.5yz=0.5

模型分类方向正确，但置信度有限。

两个损失仍然都会惩罚模型。

---

模型输出 z = 2

此时：

yz=2yz=2yz=2

Hinge Loss：

L=0L=0L=0

而 Logistic Loss：

L>0L>0L>0

但已经非常小。

这正是二者最重要的思想差异。

---

24. 应该什么时候使用哪个 Loss

二分类神经网络

通常优先使用：

nn.BCEWithLogitsLoss()

---

多分类神经网络

通常使用：

nn.CrossEntropyLoss()

---

Logistic Regression

可以从理论上理解为：

Sigmoid
+
Binary Cross Entropy

也可以使用 Logistic Loss 的 margin 形式进行推导。

---

SVM

经典选择：

Hinge Loss
+
Regularization

---

25. 最容易混淆的几个问题

25.1 Logistic Loss 和 Cross Entropy 是不是完全不同

不是。

在二分类 Logistic Regression 中，它们实际上高度对应。

不同主要来自：

• 标签编码方式不同；
• 一个使用 margin 形式；
• 一个使用概率形式。

---

25.2 Cross Entropy 前是否必须手动 Softmax

数学推导时：

logits
→ Softmax
→ Cross Entropy

但是 PyTorch：

nn.CrossEntropyLoss()

通常应该直接输入 logits。

---

25.3 BCEWithLogitsLoss 前是否要 Sigmoid

不需要。

因为：

BCEWithLogitsLoss
=
Sigmoid
+
Binary Cross Entropy

并且采用了更加稳定的内部计算方式。

---

25.4 Hinge Loss 为什么出现 1

因为 SVM 不仅要求：

yz>0yz>0yz>0

还希望正确样本至少具有一定 margin：

yz≥1yz\ge1yz≥1

只有达到这个要求，单个样本的 Hinge Loss 才变成 0。

---

26. 最后总结

三个损失函数可以用下面三句话记住。

Logistic Loss

L=log⁡(1+e−yz)L=\log(1+e^{-yz})L=log(1+e−yz)

关键词：

margin + 平滑惩罚

---

Cross Entropy

二分类：

L=−ylog⁡(p)+(1−y)log⁡(1−p)L=-y\\log(p)+(1-y)\\log(1-p)L=−ylog(p)+(1−y)log(1−p)

多分类：

L=−∑k=1Kyklog⁡(pk)L=-\sum_{k=1}^{K}y_k\log(p_k)L=−k=1∑Kyklog(pk)

关键词：

让真实类别获得更高概率

---

Hinge Loss

L=max⁡(0,1−yz)L=\max(0,1-yz)L=max(0,1−yz)

关键词：

不仅要分对，还要离分类边界足够远

---

如果从模型角度记忆，可以总结成：

Logistic Regression
        ↓
Logistic Loss / Binary Cross Entropy

Neural Network Classification
        ↓
Binary Cross Entropy / Cross Entropy

Support Vector Machine
        ↓
Hinge Loss

真正需要记住的核心不是三个名字，而是它们对"错误"的不同定义：

Cross Entropy:
真实类别的概率够不够高？

Logistic Loss:
分类 margin 是否足够好？

Hinge Loss:
分类是否正确，而且是否已经超过安全 margin？

理解这一点后，再学习 Softmax、Maximum Likelihood、SVM 和神经网络分类都会容易很多。