每日基础课

← 返回日报
基础知识 第一则

交叉熵与负对数似然:今天真正弄懂

先记住

先记住:一句话定义 + 一句记忆口诀

通俗讲解

交叉熵和负对数似然,本质是在问一句话:模型给正确答案的概率有多高,越高损失越小,越低损失越大。

记忆口诀:

“先 softmax 成概率,再取真类的负 log。”

更短一点:

“真类概率越大,loss 越小。”

一、生活类比

假设你在做一道选择题。

题目是:这段音频是谁在说话?

正确答案是:说话人 B。

模型给出预测:

A:0.10 B:0.70 C:0.20

模型把 70% 的信心给了正确答案 B。 这还不错,所以损失不大。

如果模型给出:

A:0.80 B:0.01 C:0.19

它只给正确答案 B 1% 的信心。 这很糟糕,所以损失很大。

交叉熵就是这样打分:

不是只看“猜没猜对”。 而是看“你给正确答案的信心有多足”。

二、必要公式

分类任务里,交叉熵常写成:

\[ H(y, p) = - \sum_{i=1}^{C} y_i \log(p_i) \]

逐个解释:

  • \(C\):类别数。比如 3 个说话人,就是 \(C=3\)。
  • \(i\):第几个类别。
  • \(y_i\):真实标签的 one-hot 表示。
  • 如果正确类是 B,则 \(y=[0,1,0]\)。
  • \(p_i\):模型预测第 \(i\) 类的概率。
  • 例如 \(p=[0.1,0.7,0.2]\)。
  • \(\log\):对数,通常是自然对数。
  • 前面的负号 \(-\):因为概率小于 1 时,\(\log(p)\) 是负数,加负号后变成正的损失。

如果标签是 one-hot,上面的公式会简化。

例如正确类是第 \(k\) 类:

\[ H(y,p) = -\log(p_k) \]

这就是负对数似然:

\[ NLL = -\log(p_{\text{true}}) \]

逐个解释:

  • \(p_{\text{true}}\):模型分给真实类别的概率。
  • \(-\log(\cdot)\):把“概率越大越好”变成“损失越小越好”。

三、看几个数字

如果模型给正确类的概率是:

\[ p_{\text{true}}=0.9 \]

损失是:

\[ -\log(0.9) \approx 0.105 \]

很小。

如果:

\[ p_{\text{true}}=0.1 \]

损失是:

\[ -\log(0.1) \approx 2.303 \]

很大。

如果:

\[ p_{\text{true}}=0.001 \]

损失是:

\[ -\log(0.001) \approx 6.908 \]

非常大。

所以它很“讨厌”模型对正确答案过度不自信。

四、它解决什么问题

它解决的是分类模型的训练问题。

模型输出一堆分数。 训练时需要告诉模型:

“你这次预测有多差?”

这个“差”的量,就是 loss。

对于分类任务,交叉熵特别合适,因为它关心:

  • 正确类概率是否高。
  • 错误类概率是否被压低。
  • 模型有没有过度自信地选错。

没有它会怎样?

如果只用准确率:

  • 准确率不可导,不能直接拿来反向传播。
  • 它太粗糙。
  • 0.51 猜对和 0.99 猜对,都算对。
  • 0.49 猜错和 0.001 猜错,都算错。
  • 训练信号不细。

交叉熵更细:

  • 0.99 给正确类,奖励更大。
  • 0.51 给正确类,虽然对了,但还不够稳。
  • 0.001 给正确类,会被重罚。

这很适合神经网络学习。

五、主流用法

在 PyTorch 里,最常见的是:

loss_fn = torch.nn.CrossEntropyLoss()
loss = loss_fn(logits, labels)

注意:

输入不是 softmax 后的概率。 输入是 logits。

logits 是模型最后一层输出的原始分数。

例如:

logits = [2.0, 5.0, 1.0]

它还不是概率。 经过 softmax 后才是概率。

PyTorch 的 `CrossEntropyLoss` 内部大致做了两步:

CrossEntropyLoss = LogSoftmax + NLLLoss

也就是:

  • 先把 logits 变成 log 概率。
  • 再取真实类别对应位置的负 log 概率。

学习资料建议:

  • PyTorch CrossEntropyLoss 文档:适合重点看 logits、标签格式、reduction 参数。
  • Dive into Deep Learning 的信息论章节:适合理解熵、交叉熵为什么和“不确定性”有关。
先想再展开答案
交叉熵一句话是什么?
衡量模型给正确答案的概率有多高;正确类概率越高,损失越小。
CrossEntropyLoss 和 NLLLoss 的关系是什么?
CrossEntropyLoss 大致等于 LogSoftmax 加 NLLLoss。
为什么分类任务通常不用准确率直接训练?
准确率不可导且信号太粗,不能告诉模型“差多少”。
发展脉络 · 现状 · 未来

一、发展流程:之前怎么做

早期做分类,常见想法是:

  • 直接比较预测类别和真实类别。
  • 看准确率。
  • 或者用平方误差。

例如真实标签是 one-hot:

真实:[0, 1, 0]
预测:[0.2, 0.6, 0.2]

可以用均方误差:

\[ MSE = \sum_i (y_i - p_i)^2 \]

这也能用。 但对分类问题不够自然。

因为分类的核心不是“数值离得多近”。 而是“给真实类别的概率有多大”。

二、为什么出现交叉熵

分类模型常把输出看成概率分布。

比如:

A: 0.1
B: 0.7
C: 0.2

真实答案也可以看成一个分布:

A: 0
B: 1
C: 0

训练目标就是:

让预测分布接近真实分布。

交叉熵正好衡量:

“如果真实分布是 y,但你用预测分布 p 来编码,会有多浪费。”

在深度学习里,可以简单理解成:

“模型给正确答案的概率越低,付出的代价越大。”

三、现在怎么用

现在它是分类任务的默认损失之一。

常见位置:

1. 图像分类 最后一层输出每个类别的 logits,然后接 CrossEntropyLoss。

2. 音频事件分类 输入一段声音,判断是咳嗽、笑声、音乐、噪声等。

3. 说话人识别 输入一段语音 embedding,分类到某个 speaker ID。

4. 视频动作分类 输入视频片段,输出动作类别,例如走路、坐下、挥手。

5. 语音识别或语言模型中的 token 预测 每个时间步预测下一个 token,通常也是交叉熵。

四、在音视频理解与说话人日志中的实际位置

  • 音频分类

流程通常是:

音频 waveform
→ 特征,如 log-mel spectrogram
→ encoder
→ 分类头
→ logits
→ CrossEntropyLoss

比如判断一段音频是不是:

speech / music / noise
  • 视频分类

流程通常是:

视频帧
→ video encoder
→ pooling
→ 分类头
→ logits
→ CrossEntropyLoss

比如判断:

说话 / 沉默 / 转场 / 手势
  • 说话人识别

流程:

语音片段
→ speaker encoder
→ speaker embedding
→ linear classifier
→ speaker logits
→ CrossEntropyLoss

训练时用 speaker ID 作为标签。 模型学会把同一个说话人的 embedding 拉到相似区域。

  • 说话人日志 diarization

说话人日志常问:

“什么时候谁在说话?”

它可能包含多个子任务:

  • 语音活动检测:这一帧有没有人说话。
  • 说话人变化检测:这里是不是换人了。
  • 说话人分类:这一段属于哪个已知说话人。
  • 多说话人活动预测:某个时间段哪些人同时说话。

其中,只要任务被建成分类问题,就可能用交叉熵。

例如:

每一帧:speech / non-speech

可以用二分类交叉熵。

如果是:

speaker A / speaker B / speaker C

可以用多分类交叉熵。

但注意:真实 diarization 往往有重叠语音、未知说话人、聚类步骤。 不是所有环节都只是一个简单 CrossEntropyLoss。

五、与相近概念的区别

  • 交叉熵 vs 负对数似然

在 one-hot 分类里,它们几乎是同一个东西。

交叉熵:

\[ -\sum_i y_i \log(p_i) \]

如果 \(y\) 是 one-hot,只剩真实类那一项:

\[ -\log(p_{\text{true}}) \]

这就是负对数似然。

简单说:

  • 交叉熵:从两个分布的角度看。
  • 负对数似然:从“真实答案的概率有多大”的角度看。
  • 在普通多分类训练里,二者常常等价。
  • CrossEntropyLoss vs NLLLoss

在 PyTorch 中:

  • `CrossEntropyLoss` 接收 logits。
  • `NLLLoss` 接收 log-probabilities。

也就是说:

CrossEntropyLoss(logits, labels)

大致等价于:

NLLLoss(LogSoftmax(logits), labels)

常见错误:

不要先 softmax 再传给 `CrossEntropyLoss`。 因为它内部已经会处理。

  • 交叉熵 vs softmax

softmax 不是 loss。 softmax 是把 logits 转成概率的函数。

交叉熵是 loss。 它拿预测概率和真实标签算损失。

关系:

logits → softmax → probabilities → cross entropy

但 PyTorch 的 `CrossEntropyLoss` 把 softmax/log-softmax 放在内部做了。

  • 交叉熵 vs KL 散度

KL 散度衡量两个分布差多少:

\[ KL(y||p) \]

交叉熵和 KL 有关系:

\[ H(y,p)=H(y)+KL(y||p) \]

如果真实分布 \(y\) 固定,最小化交叉熵等价于最小化 KL。

但初学时先记:

  • 交叉熵:训练分类器常用。
  • KL:比较两个概率分布差异常用。
  • 交叉熵 vs 均方误差

均方误差更适合回归。 例如预测年龄、温度、坐标。

交叉熵更适合分类。 例如预测类别、speaker ID、token ID。

六、当前局限

事实部分:

1. 它需要可靠标签。 标签错了,模型会被训练去相信错误答案。

2. 它容易鼓励过度自信。 模型可能给某类 0.999 的概率,但其实并不一定真的那么有把握。

3. 类别不平衡时会有问题。 如果“非语音”样本远多于“语音”样本,模型可能偏向多数类。

4. 对开放集不天然友好。 训练中只有 A、B、C 三个说话人,测试时来了未知说话人 D,普通交叉熵不会自动解决。

5. 对多标签任务要小心。 如果同一时间可能有多个说话人同时说话,普通多分类交叉熵不合适。 这时常用 binary cross entropy 处理每个说话人是否活跃。

七、未来可能作用

事实部分:

交叉熵现在仍是深度学习中最基础、最常用的训练目标之一。 在分类、token 预测、说话人识别、音频事件识别中仍然大量使用。

推测部分:

未来它可能继续作为基础损失存在。 但会更多和其他方法组合:

  • 类别不平衡时,配合 class weight、focal loss 等。
  • 标签不确定时,配合 label smoothing。
  • 开放集说话人任务中,配合 metric learning 或聚类方法。
  • 多模态模型中,配合对比学习、匹配损失等。

但这些是扩展。 基础还是那句话:

“让模型把概率放到正确答案上。”

自测
  • 1. 如果正确类别概率从 0.8 降到 0.2,交叉熵损失会变大还是变小?为什么?
  • 2. PyTorch 的 CrossEntropyLoss 输入应该是 logits 还是 softmax 后的概率?标签应该是什么形状?
  • 3. 在说话人日志中,什么时候适合用多分类交叉熵,什么时候更适合用 binary cross entropy?
类比
交叉熵像考试评分:不只看你最后选没选对,还看你把多少信心押在正确选项上;押得越准,扣分越少。
动手练习 第二则

交叉熵与负对数似然:动手实现

练习目标

10-20分钟小练习目标、输入输出和验收标准

参考实现

练习目标:

用 PyTorch 手动算一遍交叉熵。 再和 `torch.nn.CrossEntropyLoss` 对齐。 最后训练一个极小的分类器,理解它在真实模型中的位置。

输入:

  • 4 个样本。
  • 每个样本有 2 维特征。
  • 3 个类别。
  • 标签是类别编号,不是 one-hot。

输出:

  • 手动计算的交叉熵。
  • PyTorch 计算的交叉熵。
  • 一个小模型训练后的 loss 和准确率。

验收标准:

  • 手动 loss 和 PyTorch loss 几乎相同。
  • 训练后 loss 下降。
  • 训练后准确率明显高于随机猜测。

思路:

  • 准备一批 logits,形状是 `[batch_size, num_classes]`。
  • 准备标签 labels,形状是 `[batch_size]`。
  • 手动做 `log_softmax`。
  • 取每个样本真实类别对应的 log 概率。
  • 加负号,得到 NLL。
  • 对 batch 求平均,得到 mean cross entropy。
  • 用 `nn.CrossEntropyLoss` 验证。
  • 训练一个小线性分类器。

完整可运行代码:

import torch
import torch.nn as nn
import torch.optim as optim

# 为了结果可复现
torch.manual_seed(42)

print("Part 1: 手动计算交叉熵,并和 PyTorch 对齐")
print("-" * 60)

# ------------------------------------------------------------
# 1. 准备一批 logits 和标签
# ------------------------------------------------------------
# 4 个样本,3 个类别
# logits 是模型原始输出分数,不是概率
logits = torch.tensor([
    [2.0, 1.0, 0.1],   # 样本 0
    [0.5, 2.5, 0.3],   # 样本 1
    [0.2, 0.1, 3.0],   # 样本 2
    [1.0, 2.0, 0.5],   # 样本 3
])

# 标签是类别编号
# 形状是 [batch_size]
# 不是 one-hot
labels = torch.tensor([0, 1, 2, 1])

print("logits shape:", logits.shape)
print("labels shape:", labels.shape)
print("logits:\n", logits)
print("labels:", labels)

# ------------------------------------------------------------
# 2. 手动计算 log_softmax
# ------------------------------------------------------------
# softmax: exp(logit_i) / sum_j exp(logit_j)
# log_softmax: log(softmax)
log_probs = torch.log_softmax(logits, dim=1)

print("\nlog_probs shape:", log_probs.shape)
print("log_probs:\n", log_probs)

# ------------------------------------------------------------
# 3. 取出每个样本真实类别对应的 log probability
# ------------------------------------------------------------
batch_indices = torch.arange(logits.shape[0])
true_class_log_probs = log_probs[batch_indices, labels]

print("\n每个样本真实类别的 log probability:")
print(true_class_log_probs)

# ------------------------------------------------------------
# 4. 负对数似然 NLL
# ------------------------------------------------------------
nll_per_sample = -true_class_log_probs
manual_loss = nll_per_sample.mean()

print("\n每个样本的 NLL:")
print(nll_per_sample)
print("手动 mean cross entropy:", manual_loss.item())

# ------------------------------------------------------------
# 5. 用 PyTorch CrossEntropyLoss 对齐
# ------------------------------------------------------------
loss_fn = nn.CrossEntropyLoss(reduction="mean")
torch_loss = loss_fn(logits, labels)

print("PyTorch CrossEntropyLoss:", torch_loss.item())
print("二者是否接近:", torch.allclose(manual_loss, torch_loss))


print("\n\nPart 2: 训练一个极小分类器")
print("-" * 60)

# ------------------------------------------------------------
# 6. 构造一个很小的三分类数据集
# ------------------------------------------------------------
# 每个点有 2 个特征
# 三类点大致分布在三个区域
X = torch.tensor([
    [2.0, 2.0],
    [2.2, 1.8],
    [1.8, 2.1],
    [2.1, 2.2],

    [-2.0, -1.8],
    [-2.2, -2.1],
    [-1.8, -2.0],
    [-2.1, -1.9],

    [2.0, -2.0],
    [2.2, -1.7],
    [1.7, -2.1],
    [2.1, -2.2],
], dtype=torch.float32)

y = torch.tensor([
    0, 0, 0, 0,
    1, 1, 1, 1,
    2, 2, 2, 2
], dtype=torch.long)

print("X shape:", X.shape)   # [12, 2]
print("y shape:", y.shape)   # [12]

# ------------------------------------------------------------
# 7. 定义一个线性分类器
# ------------------------------------------------------------
# 输入维度 2,输出维度 3
# 输出的是 logits
model = nn.Linear(in_features=2, out_features=3)

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# ------------------------------------------------------------
# 8. 训练前看一下效果
# ------------------------------------------------------------
with torch.no_grad():
    logits_before = model(X)
    loss_before = criterion(logits_before, y)

    pred_before = logits_before.argmax(dim=1)
    acc_before = (pred_before == y).float().mean()

print("\n训练前 loss:", loss_before.item())
print("训练前 acc:", acc_before.item())
print("训练前预测:", pred_before.tolist())

# ------------------------------------------------------------
# 9. 开始训练
# ------------------------------------------------------------
for epoch in range(100):
    # 前向传播
    logits_train = model(X)

    # 计算交叉熵
    loss = criterion(logits_train, y)

    # 清空旧梯度
    optimizer.zero_grad()

    # 反向传播
    loss.backward()

    # 更新参数
    optimizer.step()

    if (epoch + 1) % 20 == 0:
        with torch.no_grad():
            pred = logits_train.argmax(dim=1)
            acc = (pred == y).float().mean()
        print(f"epoch {epoch+1:3d} | loss = {loss.item():.4f} | acc = {acc.item():.4f}")

# ------------------------------------------------------------
# 10. 训练后看效果
# ------------------------------------------------------------
with torch.no_grad():
    logits_after = model(X)
    loss_after = criterion(logits_after, y)

    probs_after = torch.softmax(logits_after, dim=1)
    pred_after = logits_after.argmax(dim=1)
    acc_after = (pred_after == y).float().mean()

print("\n训练后 loss:", loss_after.item())
print("训练后 acc:", acc_after.item())
print("训练后预测:", pred_after.tolist())
print("\n训练后每个样本的预测概率:")
print(probs_after)

print("\n结论:")
print("CrossEntropyLoss 接收 logits 和类别编号 labels。")
print("它内部相当于 LogSoftmax + NLLLoss。")
print("训练时,它推动模型提高真实类别的概率。")
代码拆解与真实用法

逐段解释代码:

一、logits 的形状

logits.shape == [4, 3]

意思是:

  • 4 个样本。
  • 3 个类别。
  • 每一行是一个样本。
  • 每一列是一个类别的原始分数。

例如:

[2.0, 1.0, 0.1]

表示模型觉得:

  • 类别 0 分数最高。
  • 类别 1 次之。
  • 类别 2 最低。

但这些不是概率。 它们不会自动加和为 1。

二、labels 的形状

labels.shape == [4]

内容是:

[0, 1, 2, 1]

意思是:

  • 样本 0 的真实类是 0。
  • 样本 1 的真实类是 1。
  • 样本 2 的真实类是 2。
  • 样本 3 的真实类是 1。

PyTorch `CrossEntropyLoss` 默认要这种类别编号。 不是:

[[1,0,0], [0,1,0], [0,0,1], [0,1,0]]

三、手动计算部分

log_probs = torch.log_softmax(logits, dim=1)

`dim=1` 表示在类别维度上做 softmax。 因为每一行是一个样本,每一列是一个类别。

然后:

true_class_log_probs = log_probs[batch_indices, labels]

这句是在取:

第 0 个样本,第 labels[0] 类
第 1 个样本,第 labels[1] 类
第 2 个样本,第 labels[2] 类
第 3 个样本,第 labels[3] 类

也就是每个样本真实类别对应的 log 概率。

再做:

nll_per_sample = -true_class_log_probs

这就是负对数似然。

最后:

manual_loss = nll_per_sample.mean()

对 batch 求平均。 这对应 `reduction="mean"`。

四、PyTorch 对齐

loss_fn = nn.CrossEntropyLoss(reduction="mean")
torch_loss = loss_fn(logits, labels)

这里 PyTorch 内部已经完成:

logits → log_softmax → 取真实类 log 概率 → 加负号 → 求平均

所以它应该和手动计算结果一致。

五、小模型训练部分

model = nn.Linear(in_features=2, out_features=3)

它表示:

  • 输入是 2 维特征。
  • 输出是 3 维 logits。
  • 对应 3 个类别。

真实模型里,这个 `nn.Linear` 就是分类头。

在音视频模型中,前面通常不是 2 维点,而是:

音频 / 视频
→ encoder
→ embedding
→ linear classifier
→ logits
→ CrossEntropyLoss

六、训练循环

logits_train = model(X)
loss = criterion(logits_train, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()

这就是最典型训练流程:

  • 模型输出 logits。
  • CrossEntropyLoss 算损失。
  • backward 算梯度。
  • optimizer 更新参数。

七、常见错误

错误 1:先 softmax 再传给 CrossEntropyLoss。

不要这样:

probs = torch.softmax(logits, dim=1)
loss = criterion(probs, labels)

应该这样:

loss = criterion(logits, labels)

错误 2:标签用了 float。

不要这样:

labels = torch.tensor([0, 1, 2], dtype=torch.float32)

应该这样:

labels = torch.tensor([0, 1, 2], dtype=torch.long)

错误 3:标签形状不对。

普通多分类中,不要传:

labels.shape == [batch_size, num_classes]

通常应该是:

labels.shape == [batch_size]

错误 4:类别维度 softmax 搞错。

对于 logits:

[batch_size, num_classes]

要用:

dim=1

不是 `dim=0`。

八、真实模型中的对应位置

在说话人识别中:

一段语音
→ speaker encoder
→ speaker embedding
→ linear layer
→ speaker logits
→ CrossEntropyLoss

在音频事件分类中:

log-mel 特征
→ audio encoder
→ pooling
→ event logits
→ CrossEntropyLoss

在视频分类中:

视频帧序列
→ video encoder
→ temporal pooling
→ action logits
→ CrossEntropyLoss

在说话人日志中,如果是每帧二分类:

frame embedding
→ classifier
→ speech/non-speech logits
→ CrossEntropyLoss

如果同一帧可能多个说话人同时说话,就不再是单一类别。 这时常改用多标签的 binary cross entropy。

再练一步
  • 把 `reduction="mean"` 改成 `"none"`,打印每个样本自己的 loss,看看哪个样本最难。
  • 把学习率 `lr=0.1` 改成 `lr=1.0` 或 `lr=0.001`,观察训练速度和稳定性。
类比
`loss = CE(logits, label)` 就是在代码里问:正确类别那一格,你给了多少信心?

往期记录 165 条记录

2026年08月14日Softmax 与温度系数:今天真正弄懂foundationsoftmaxtemperaturelogits
2026年08月14日Softmax 与温度系数:动手实现practicePythonPyTorchSoftmax 与温度系数
2026年08月13日残差连接:今天真正弄懂foundationresidual connectiongradient flowResNet
2026年08月13日残差连接:动手实现practicePythonPyTorch残差连接
2026年08月12日LayerNorm 与 Pre-Norm:今天真正弄懂foundationLayerNormPre-Normresidual
2026年08月12日LayerNorm 与 Pre-Norm:动手实现practicePythonPyTorchLayerNorm 与 Pre-Norm
2026年08月11日信息粒缓存编排interviewPrefixDAGMinCostFlowSemanticHash
2026年08月11日表示一个折线图的最少线段数codeGeometryArrayMath
2026年08月11日RMSNorm:今天真正弄懂foundationRMSNormnormalizationLLaMA
2026年08月11日RMSNorm:动手实现practicePythonPyTorchRMSNorm
2026年08月10日长上下文块复用interviewPrefixCachingDynamicProgrammingIntervalScheduling
2026年08月10日到达终点数字codeMathParityGreedy
2026年08月10日多教师蒸馏调度interviewMinCostFlowDynamicProgrammingParetoFrontier
2026年08月10日定长子串中元音的最大数目codeStringSliding WindowTwo Pointers
2026年08月06日长窗注意力稳健化interviewNumericalStabilitySoftmaxPositionBias
2026年08月06日执行操作使数据元素之和大于等于 KcodeGreedyMathEnumeration
2026年08月05日必须拿起的最小连续卡牌数codehashmaparrayslidingwindow
2026年08月04日绝对差不超过限制的最长连续子数组codesliding windowmonotonic queuedeque
2026年08月03日证据路由与采样优化interviewRoutingSubmodularLatency
2026年08月01日查询引导长视频采样interviewSubmodularKnapsackTemporalCoverage
2026年08月01日边界元素是最大值的子数组数目codeStackArrayMonotonicStack
2026年07月30日受限内存推理调度interviewLLM-servingKV-cacheScheduling
2026年07月29日技能感知词元压缩interviewTokenCompressionMultimodalKnapsack
2026年07月27日递归验证预算分配interviewAStarBanditSubmodular
2026年07月26日推理早停预算分配interviewOptimalStoppingSequentialTestCalibration
2026年07月26日二叉树中所有距离为 K 的结点codeTreeBFSDFS
2026年07月25日流式同传轨迹调度interviewStreamingMonotonicAlignmentLatencyControl
2026年07月25日分割回文串codepalindromebacktrackingdynamicprogramming
2026年07月24日最大节点价值之和codeGreedyBitManipulationTree
2026年07月23日长音视频工具调度interviewTool RoutingDAG SchedulingSubmodular Maximization
2026年07月20日流式多模态记忆检索interviewStreaming MemoryMultimodal RetrievalTemporal Indexing
2026年07月20日T 秒后青蛙的位置codeTreeDFSProbability
2026年07月20日约束预算模型路由interviewModel RoutingConstrained OptimizationContextual Bandit
2026年07月20日匹配模式数组的子数组数目 IIcodeArrayKMPStringMatching
2026年07月20日受限显存解码调度interviewLLMCompilerKVCacheScheduling
2026年07月20日填充每个节点的下一个右侧节点指针 IIcodeTreeBFSLinkedList
2026年07月02日变分信息瓶颈Information BottleneckVariational BoundRate-Distortion
2026年07月01日CTC序列对齐算法CTCForward-Backward AlgorithmBlank Token
2026年07月01日故障流行病学Core DumpStatistical DebuggingFault Localization
2026年06月30日哈希嵌入压缩Hash EmbeddingFeature HashingEmbedding Compression
2026年06月29日一致性蒸馏Consistency ModelsProgressive DistillationODE Trajectory
2026年06月29日原生推理引擎Native RuntimeggmlInference Engine
2026年06月28日无分类器引导Classifier-Free GuidanceGuidance ScaleScore Interpolation
2026年06月25日MVDR波束成形MVDR BeamformingSpatial FilteringCovariance Estimation
2026年06月24日神经缩放定律Scaling LawsCompute-Optimal TrainingPower Law
2026年06月23日最小贝叶斯风险解码Minimum Bayes RiskDecision TheoryHypothesis Selection
2026年06月23日PID控制与生成调控PID ControllerFeedback ControlClosed-loop Generation
2026年06月22日生成模型评估度量Frechet Inception DistanceGenerative EvaluationFeature Statistics
2026年06月21日浮点量化收缩偏差FP4 TrainingShrinkage BiasLow-Precision Arithmetic
2026年06月21日模型上线仿真Deployment SimulationShadow TestingOffline Evaluation
2026年06月20日现代联想记忆Hopfield NetworkAssociative MemoryEnergy-Based Model
2026年06月19日离散扩散语言模型Discrete DiffusionAbsorbing StateConcrete Score
2026年06月18日循环变换器架构Looped TransformerWeight TyingAdaptive Computation
2026年06月17日韵律建模演进Prosody PredictionF0 ModelingDuration Prediction
2026年06月16日说话人日志Speaker DiarizationSpeaker EmbeddingEEND
2026年06月15日偏好对齐优化Preference OptimizationDPOReward Modeling
2026年06月14日多令牌并行预测Multi-Token PredictionSpeculative DecodingParallel Decoding
2026年06月13日流匹配生成模型Flow MatchingRectified FlowOptimal Transport Path
2026年06月13日实时管线延迟预算Latency BudgetPipeline OrchestrationTime-to-First-Token
2026年06月12日MoE路由机制Mixture of ExpertsSparse GatingRouter Design
2026年06月11日连续自回归生成Continuous AutoregressiveLatent PredictionAudioVAE
2026年06月10日KV缓存压缩KV Cache CompressionToken EvictionAttention Sparsity
2026年06月09日浏览器端模型推理WebGPUBrowser InferenceClient-side ML
2026年06月02日残差向量量化Residual Vector QuantizationAudio TokenizationNeural Codec
2026年05月31日彩色噪声扩散采样Colored NoiseSpectral BiasSDE Solver
2026年05月31日算子融合编译原理Kernel FusionOperator Fusiontorch.compile
2026年05月20日AI生成内容溯源 (7 chars) ✓Content ProvenanceC2PASynthID
2026年05月19日推理委托设计模式 (8 chars) ✓ Let me now write the full content for both topics. Actually, I realize I should double-check: is "Runtime Abstraction" or "Delegate Pattern" too close to any covered keyword? Looking at the list: Cluster Scheduling, Co-design, Collective Communication, Computational Expressiveness, CUTLASS... No, none of these overlap. OK, let me finalize and write everything out. Let me reconsider the engineering topic one more time. The title "推理委托设计模式" is good but maybe I should make it even more specific and interesting. What about focusing on the "graph partitioning" aspect - how ML runtimes decide which operations to delegate to which backend? This is a more specific and technically interesting angle. No, I think the broader "delegate pattern" is better because it covers the full picture and is more useful to the reader. Let me write it all out now. For the engineering topic, let me think about the history: - Early days: frameworks were monolithic (Caffe, early TensorFlow) - TensorRT (2017): NVIDIA's specialized inference engine, initially standalone - ONNX Runtime (2019): Microsoft introduced "Execution Providers" - the first major delegate-like abstraction - TFLite delegates (2018-2019): TensorFlow Lite introduced delegate API for GPU, NNAPI, etc. - ExecuTorch (2023-2024): PyTorch's answer to edge inference with a clean delegate API - 2025-2026: MLX delegate, Qualcomm AI Engine Direct delegate, etc. This is a rich history. Let me write it up. Actually, I want to make sure I have the dates right: - TensorRT was first released around 2016-2017 - ONNX was announced in 2017 - ONNX Runtime was open-sourced in 2018-2019 - TFLite was released in 2017, delegates came later - ExecuTorch was announced at PyTorch Conference 2023 OK, let me write everything now. I'll be thorough. One more thought: for the MATH section of the engineering topic, I could discuss the graph partitioning problem formally, or I could discuss the cost model for deciding whether to delegate. Let me think... The graph partitioning for delegation can be formalized as: - Given a computation graph $G = (V, E)$ where $V$ is the set of operations and $E$ is data dependencies - And a set of delegates $D = \{d_1, ..., d_m\}$ where each delegate supports a subset of operations $S_i \subseteq V$ - Find a partition $P = \{P_0, P_1, ..., P_m\}$ (where $P_0$ is the fallback/CPU partition) that minimizes total execution time - Subject to: each $
2026年05月17日连续批处理异步化
2026年05月10日连续潜在扩散语言模型Continuous Latent DiffusionNon-autoregressive LMDiffusion Language Model
2026年05月10日零样本跨语言语音克隆Zero-shot Voice CloningCross-lingual TTSIPA Phoneme Representation
2026年05月09日最优传输音频距离Optimal TransportFréchet Audio DistanceRiemannian Metric
2026年05月09日推荐系统推理核内广播优化Intra-kernel BroadcastEmbedding TableRecommendation Inference
2026年05月08日扩散Transformer异常值令牌Outlier TokensDiffusion TransformerAttention Sink
2026年05月08日WebRTC低延迟语音工程WebRTCReal-time AudioJitter Buffer
2026年05月07日音素级深度伪造检测原理Phoneme-level Deepfake DetectionSelf-supervised Speech EmbeddingEmotional Speech Synthesis
2026年05月07日AI训练网络协议工程哲学Multi-path Reliable ConnectionRDMA over EthernetCollective Communication
2026年05月05日对抗解纠缠说话人验证Speaker DisentanglementAdversarial TrainingCross-lingual Verification
2026年05月05日LLM推理为何用语言Chain-of-ThoughtLatent ReasoningToken Space
2026年05月01日跨架构知识蒸馏原理Cross-Architecture DistillationDiffusion LMAutoregressive Teacher
2026年05月01日AI评估计算瓶颈工程LLM Evaluation InfrastructureBenchmark SaturationEval Compute Bottleneck
2026年04月29日平衡传输语音增强Schrödinger BridgeStochastic Differential EquationSpeech Enhancement
2026年04月29日深度学习理论形成Deep Learning TheoryLoss LandscapeNeural Tangent Kernel
2026年04月28日语义进度函数原理Semantic Progress FunctionDiffusion TrajectoryNonlinear Denoising
2026年04月28日大模型OCR选型认知OCR BenchmarkModel Selection BiasCost-Performance Tradeoff
2026年04月27日说话人验证核心原理Speaker Verificationd-vectorECAPA-TDNN
2026年04月27日GPU核函数语言选型GPU Kernel EngineeringCuTe DSLCUTLASS
2026年04月26日时长控制TTS原理Duration ModelingProsody ControlAutoregressive TTS
2026年04月26日AI研究价值评估困境Research EvaluationPublication BiasPeer Review
2026年04月25日全双工对话建模原理Full-Duplex DialogueTurn-TakingVoice Activity Detection
2026年04月25日流式TTS文本规范化Text NormalizationStreaming TTSInverse Text Normalization
2026年04月24日离散扩散语言模型原理Discrete DiffusionMasked Diffusion Language ModelAbsorbing Diffusion
2026年04月24日跟进ML研究的认知工程Information OverloadResearch TriageSpaced Repetition
2026年04月23日一致性正则化ASR原理Consistency RegularizationUnified ASRTransducer
2026年04月23日流式TTS文本规范化工程Text NormalizationStreaming TTSInverse Text Normalization
2026年04月22日神经编码器伪影检测Neural Audio CodecArtifact DetectionForensic Residual
2026年04月22日AI研究复现危机工程Reproducibility CrisisML EngineeringExperimental Rigor
2026年04月21日扩散SNR偏差校正原理Signal-to-Noise RatioDiffusion Timestep BiasScore Matching
2026年04月21日论文复现危机根治工程Reproducibility CrisisAblation StudyExperimental Rigor
2026年04月20日音频时序定位原理Temporal GroundingAudio Event DetectionCross-modal Alignment
2026年04月20日论文复现危机根因Reproducibility CrisisBenchmark OverfittingEvaluation Validity
2026年04月19日流匹配对齐原理Flow Matching AlignmentReward Gradient BackpropagationTrajectory Optimization
2026年04月19日分布式训练任务编排Distributed Training OrchestrationCluster SchedulingFault Tolerance
2026年04月18日最优传输信号融合Optimal TransportWasserstein BarycenterTime-Frequency Resolution
2026年04月18日分布式训练任务调度Distributed Training OrchestrationJob SchedulingCluster Resource Management
2026年04月17日扩散语音识别原理Masked Diffusion Language ModelDiscrete DiffusionASR Decoding
2026年04月17日Mel尺度跨文化偏差Mel ScalePsychoacousticsCultural Bias
2026年04月16日音频水印对抗原理Audio WatermarkingSemi-FragilePsychoacoustic Masking
2026年04月16日推测解码草稿树工程Speculative DecodingDraft TreeBlock Diffusion
2026年04月15日对抗流模型原理Continuous Normalizing FlowAdversarial TrainingFlow Matching
2026年04月15日代理状态可观测性工程Agent ObservabilityDistributed TracingState Machine Debugging
2026年04月14日过程奖励模型原理Process Reward ModelStep-level SupervisionReasoning Chain
2026年04月13日离散令牌音源分离Discrete Token ModelingSource SeparationConditional Generation
2026年04月13日超算API工程哲学Distributed Training OrchestrationSupercomputer API DesignFault Tolerance
2026年04月12日信息瓶颈原理演进Information BottleneckVariational IBDisentanglement
2026年04月12日Safetensors格式工程哲学SafetensorsModel SerializationMemory-Mapped IO
2026年04月11日归一化层演进原理Layer NormalizationRMS NormalizationBatch Normalization
2026年04月11日GEMM自调优后端工程GEMM AutotuningTorchInductorCuteDSL
2026年04月10日多令牌预测原理Multi-Token PredictionSpeculative DecodingMedusa Heads
2026年04月10日ML从业者认知校准Calibration BiasCapability IllusionBenchmark Overfitting
2026年04月09日编码器-解码器LM原理Encoder-Decoder LMCross-Attention ConditioningSequence-to-Sequence
2026年04月09日torch.compile归一化优化torch.compileLayerNormRMSNorm
2026年04月08日KV缓存压缩原理KV Cache CompressionRoPE Position EncodingAttention Score Estimation
2026年04月08日音效基础模型工程Sound Effect GenerationFoundation ModelFoley Synthesis
2026年04月07日可验证奖励强化学习Verifiable RewardRLVRProcess Reward Model
2026年04月07日LLM技能退化认知机制Cognitive OffloadingSkill AtrophyDesirable Difficulty
2026年04月06日音素可解释说话人验证Phoneme-aware Speaker VerificationInterpretable BiometricsLocal Acoustic Evidence
2026年04月06日音频幻觉攻击评估Hallucination AttackAudio Language Model ReliabilityAdversarial Probing
2026年04月05日潜在空间推理原理Latent Space ReasoningContinuous RepresentationToken-Free Inference
2026年04月05日mRNA模型极低成本训练Biology Foundation ModelCross-Species TransferLow-Budget Training
2026年04月04日编码器-解码器TTS原理Encoder-Decoder TTSText ConditioningPositional Capacity
2026年04月04日大模型训练的MXFP8工程MXFP8MicroscalingMixed Precision Training
2026年04月03日在线知识蒸馏原理Online DistillationKnowledge TransferStudent-Teacher
2026年04月03日MoE专家并行调度工程Expert ParallelismMixture of ExpertsAll-to-All Communication
2026年04月02日波形潜空间扩散TTSwaveform latent diffusionnon-autoregressive TTSlatent space acoustic modeling
2026年04月02日波形隐空间扩散原理waveform latent spacediffusion TTSVAE audio codec
2026年04月02日LLM量化权重工程weight quantizationLLM compression4-bit quantization
2026年04月02日扩散语言模型离散生成Discrete DiffusionMasked Diffusion Language ModelNon-autoregressive TTS
2026年04月02日LLM后训练库工程演进RLHF engineeringPPO training stabilityreward hacking
2026年04月02日声学证据瓶颈原理Audio Evidence BottleneckAcoustic GroundingAudio Language Model
2026年04月02日状态空间模型音频建模State Space ModelMambaSelective Scan
2026年04月02日实时语音增强工程选型Real-time Speech EnhancementNoise SuppressionStreaming Inference
2026年04月02日对话上下文压缩原理Context CompressionAbstractive SummarizationCross-Attention Fusion
2026年04月02日说话人匿名化工程Speaker AnonymizationVoice ConversionStreaming Inference
2026年04月02日视听语音识别融合Audio-Visual Speech RecognitionLip ReadingViseme
2026年04月02日GPU训练吞吐加速工程MXFP8MoE TrainingExpert Parallelism
2026年04月01日熵驱动多样性生成diversity samplingtypicality biasrepulsion in latent space
2026年04月01日说话人分割工程选型speaker diarizationbenchmark methodologystreaming ASR pipeline
2026年03月31日转向检测联合建模turn-taking detectionvoice activity detectionjoint acoustic-linguistic modeling
2026年03月31日基准测试的系统性失效benchmark contaminationevaluation validityLLM judge reliability
2026年03月31日扩散模型声学生成diffusion modelscore matchingstochastic differential equation
2026年03月31日TTS开源生态竞争open-weight TTStime-to-first-audiomultilingual speech synthesis
2026年03月30日注意力机制变体演进Multi-Head AttentionGrouped Query AttentionMulti-head Latent Attention
2026年03月30日设备端语音推理架构on-device inferenceExecuTorchvoice agent pipeline
2026年03月29日混合自回归流匹配TTSautoregressive semantic tokensflow matching acoustic decoderhybrid TTS architecture
2026年03月29日NCCL超时诊断方法论NCCL watchdog timeoutdistributed training debuggingcollective communication
2026年03月29日混合架构音频表示Mambastate space modelaudio representation learning
2026年03月29日DeepSeek预训练加速工程MXFP8 trainingexpert parallelismMoE pretraining
2026年03月27日说话人验证度量学习speaker verificationmetric learningcurriculum learning
2026年03月27日MX浮点格式加速训练MXFP8microscalingmixed precision training
2026年03月26日TTS模型极限压缩model compressionknowledge distillationTTS on-device
2026年03月26日小模型极限压缩哲学model compressionknowledge distillationquantization
2026年03月25日流匹配生成原理flow matchingrectified flowODE
2026年03月25日神经音频编解码器neural audio codecresidual vector quantizationEnCodec
2026年03月25日推测解码加速推理speculative decodingdraft modeltoken verification