观文听傑

返回

上一篇把长序列注意力改写成一张稀疏可见性图,回答了“位置 tt 可以读取哪些历史”。但即使模型已经能读取正确的前缀,它仍然不知道应该输出什么。海量网页、书籍和代码没有人工逐 token 标注;训练信号究竟从哪里来?

答案看似简单:把原文向左错开一位,让每个 token 都成为下一个位置的标签。真正容易出错的是三个彼此独立的契约:标签移位决定预测什么,因果 mask 决定能看什么,loss mask 决定哪些预测计分。 本文围绕这三个契约推导因果语言建模(Causal Language Modeling, CLM)的 next-token loss,再解释 Teacher Forcing(教师强制)与困惑度(Perplexity, PPL)。

01 没有人工标签,训练目标从哪里来?#

设一段文本经分词后得到:

z0,z1,…,zT,zt∈{0,1,…,V−1}z_0,z_1,\ldots,z_T,\qquad z_t\in\{0,1,\ldots,V-1\}

其中 VV 是词表大小,ztz_t 是第 tt 个 token 的整数编号。概率链式法则(Chain Rule of Probability)把整段序列概率分解为:

pθ(z0,z1,…,zT)=pθ(z0)∏t=0T−1pθ(zt+1∣z≤t)p_\theta(z_0,z_1,\ldots,z_T) =p_\theta(z_0)\prod_{t=0}^{T-1} p_\theta(z_{t+1}\mid z_{\le t})

若用一个序列起始 token bos 提供初始条件,就可以把 p(z0)p(z_0) 也写成“给定 bos 预测第一个正文 token”。最大化整段文本概率,等价于最小化负对数似然(Negative Log-Likelihood, NLL):

LNLL=−∑t=0T−1log⁡pθ(zt+1∣z≤t)\mathcal L_{\text{NLL}} =-\sum_{t=0}^{T-1} \log p_\theta(z_{t+1}\mid z_{\le t})

一段长度为 T+1T+1 的文本因此自动产生 TT 个监督信号。标签仍来自数据本身,所以这通常称为自监督学习(Self-Supervised Learning),而不是“完全没有监督信号”。

02 错开一位后,每一行究竟预测谁?#

取序列:

完整序列: <bos>  我   爱   猫  <eos>
位置:        0    1    2    3     4

模型输入: <bos>  我   爱   猫
监督标签:   我   爱   猫  <eos>
text

位置 tt 的隐藏状态 hth_t 由 0..t 的输入产生;语言模型头(Language Model Head, LM Head)把它投影到 VV 个词表 logits:

ot=htWvocab+b,ht∈RD,Wvocab∈RD×V,ot∈RVo_t=h_tW_{\text{vocab}}+b,\qquad h_t\in\mathbb R^D,\quad W_{\text{vocab}}\in\mathbb R^{D\times V},\quad o_t\in\mathbb R^V

随后:

pθ(zt+1=c∣z≤t)=exp⁡(ot,c)∑j=0V−1exp⁡(ot,j)p_\theta(z_{t+1}=c\mid z_{\le t}) =\frac{\exp(o_{t,c})}{\sum_{j=0}^{V-1}\exp(o_{t,j})}

关键不是把输入 token ztz_t 在同一位置重建出来,而是让位置 tt 的 logits 对齐标签 zt+1z_{t+1}。最后一个输入位置预测 eos;若把 eos 丢掉,模型便少了一类“何时结束”的训练信号。

03 标签移位与 causal mask 为什么缺一不可?#

这两件事经常被混成一句“做 next-token prediction”,但职责完全不同:

真实 token: z0 ─ z1 ─ z2 ─ z3 ─ z4
                │    │    │    │
标签移位:      z1   z2   z3   z4       决定每个位置预测谁

位置 t 的可见输入:z0 ... zt             causal mask 决定答案能否被偷看
位置 t 的计分开关:m_t ∈ {0,1}           loss mask 决定这一题是否计分
text

若只移位而没有 causal mask,并行 Transformer 的 hth_t 仍可能读取输入位置 t+1t+1,也就是直接看到标签。训练损失会异常漂亮,生成却失败。

若只有 causal mask 却不移位,用 oto_t 预测输入位置 ztz_t,模型只需复制当前 token;这不是我们想要的条件概率。

若前两者正确但 loss mask 错了,padding、提示词或跨文档边界仍会产生不应存在的梯度。

04 用三个概率手算一次 loss 与困惑度#

假设三个有效目标的正确 token 概率依次为:

q=[0.5,0.25,0.5]q=[0.5,0.25,0.5]

逐 token NLL 是:

ℓ=[−ln⁡0.5,−ln⁡0.25,−ln⁡0.5]≈[0.693,1.386,0.693]\ell=[-\ln0.5,-\ln0.25,-\ln0.5] \approx[0.693,1.386,0.693]

token 平均损失:

Lˉ=0.693+1.386+0.6933≈0.924\bar{\mathcal L} =\frac{0.693+1.386+0.693}{3} \approx0.924

困惑度定义为平均 NLL 的指数:

PPL⁡=exp⁡(Lˉ)=(10.5×0.25×0.5)1/3≈2.52\operatorname{PPL}=\exp(\bar{\mathcal L}) =\left(\frac{1}{0.5\times0.25\times0.5}\right)^{1/3} \approx2.52

直观上,它是正确 token 概率几何平均数的倒数。PPL 越低,模型平均给真实下一个 token 的概率越高。但“相当于每步在 2.52 个词中选择”只是粗略比喻;模型分布通常远非均匀。

05 从 token 到标量,所有张量怎样流动?#

设 batch size 为 NN,每条输入长度为 LL,隐藏宽度为 DD,词表大小为 VV:

原始 token ids [N,L+1]
   ├─ [:,:-1] ─► input_ids  [N,L]
   └─ [:, 1:] ─► target_ids [N,L]
                         │
input_ids ─► Embedding + Position ─► hidden [N,L,D]
                         │
                  causal Transformer
                         │
                         ▼
                    hidden [N,L,D]
                         │ @ W_vocab [D,V]
                         ▼
                    logits [N,L,V] ──┐
target_ids [N,L] ─► loss mask [N,L] ├─► token NLL [N,L]
                                    └─► sum / valid_count ─► scalar loss
text

交叉熵的类别轴是 VV。将其展平时,logits 必须变成 [N*L,V],标签必须用同样的 batch-major 顺序变成 [N*L]。target_ids 的 dtype 是 torch.long;logits 是未经 softmax 的浮点数。

06 用 PyTorch 把移位与归约写透明#

下面只实现本文的核心目标函数,不把标签移位藏进模型:

为什么函数输入仍是完整的 [N,L]?因为常见 Decoder-only 模型让位置 tt 的 logits 预测位置 t+1t+1,所以要丢掉最后一列 logits 和第一列标签。也可以在数据层提前构造 x=ids[:,:-1]、y=ids[:,1:];两种方式只能选一种。

当前 PyTorch 2.13 的 torch.nn.functional.cross_entropy ↗ 直接接收未归一化 logits。ignore_index=-100 的位置不贡献梯度;reduction='mean' 会对未忽略目标求平均。这里显式取 sum/count,是为了后面正确处理梯度累积、分布式归约和 PPL。

07 一个训练 step 究竟更新了什么?#

输入 attention_mask 让模型不要读取 padding;causal_lm_loss 再让 padding 目标不计分。训练时通常关闭 KV Cache,因为所有位置一次并行计算,保存逐步生成用的 cache 只会增加显存和复杂性。

伪代码可以压缩为:

for token_batch in corpus:
    valid_edges  = causal ∩ non_padding ∩ same_segment
    logits       = model(token_batch, valid_edges)
    labels       = token_batch shifted left by one
    scored       = valid_next_token ∩ allowed_objective_region
    loss         = sum(cross_entropy(logits, labels) over scored) / count(scored)
    backward(loss)
    optimizer.step()
text

08 Teacher Forcing 到底“强制”了什么?#

教师强制(Teacher Forcing)指训练第 tt 个预测时,条件前缀来自数据中的真实 token,而不是模型此前自己生成的 token:

训练:真实 z0 ─► 预测 z1
      真实 z1 ─► 预测 z2
      真实 z2 ─► 预测 z3      所有位置可借 causal mask 并行

推理:给定 z0 ─► 采样 ẑ1
          ẑ1 ─► 采样 ẑ2
          ẑ2 ─► 采样 ẑ3      每一步依赖模型自己的上一步
text

它并不是把标签 token 喂到同一位置。位置 tt 的真实 token 已经属于允许的前缀;答案 zt+1z_{t+1} 仍被 causal mask 挡在未来。

Teacher Forcing 的优势是监督密集、梯度稳定且训练位置可并行。代价是训练只见过真实前缀,推理却可能遇到自己制造的低概率前缀;一次错误会改变后续条件分布,这常称为暴露偏差(Exposure Bias)。

但不能据此简单关闭 causal mask 或用模型采样替代全部真实前缀。这样会改变训练分布、失去并行性并引入离散采样的梯度问题。是否采用 scheduled sampling、多 token 预测或序列级目标,必须通过生成质量与稳定性实验判断。

09 为什么训练能并行,生成仍要逐 token?#

训练时整条真实序列已知。causal mask 保证第 tt 行只读取 0..t,因此所有行可在一次矩阵运算中计算:

已知真实输入: z0 z1 z2 z3
并行输出:      o0 o1 o2 o3
对应标签:      z1 z2 z3 z4
text

开放式生成时,z2z_2 的输入取决于刚刚选出的 z^1\hat z_1,无法预先知道:

generated = prompt_ids
for _ in range(max_new_tokens):
    logits = model(generated, use_cache=True).logits
    next_logits = logits[:, -1, :]       # [N,V]
    next_id = sample(next_logits)         # [N,1]
    generated = torch.cat([generated, next_id], dim=1)
python

生产实现会复用上一篇讨论过的 KV Cache,避免每步重算全部历史,但仍必须先得到 z^t\hat z_t 才能构造下一步输入。训练并行来自“答案序列已经存在”,不是 causal 依赖消失了。

10 padding 为什么需要两种屏蔽?#

一个 batch 内的序列长度不同,常补齐为:

样本 A:<bos> 我 爱 猫 <eos>
样本 B:<bos> 好 <eos> <pad> <pad>
valid :   1   1    1     0     0
text

至少有两份规则:

  1. attention padding mask:真实 Query 不能读取 <pad> 对应的 Key;
  2. loss mask:目标是 <pad> 的位置不参与 NLL。

最安全的损失哨兵是 -100,而不是直接把 pad_id 传给 ignore_index。许多 Decoder-only tokenizer 会令 pad_token_id == eos_token_id;若写 ignore_index=eos_id,真实的 <eos> 标签也会全部被忽略,模型失去结束监督。

labels = input_ids.clone()
labels[attention_mask == 0] = -100
python

labels 只用于监督,改成 -100 不会改变 input_ids。反过来,labels=-100 也不会自动阻止注意力读取 padding Key。

11 packing 怎样制造“看不见的跨文档标签”?#

为了减少 padding,工程上会把多篇短文档打包(Sequence Packing)到同一长度:

位置:      0   1    2      3   4   5
token:     A1  A2  <eos>  B1  B2  <eos>
segment:   0   0     0     1   1     1

普通移位标签:A2 <eos>  B1   B2 <eos>
                        ▲
             A 的末尾被要求预测 B 的开头
text

这里必须先选择语义契约:

  • 连续 token 流:允许 <eos> 后预测下一篇开头,也允许模型看到更早文档;实现简单,但跨文档上下文属于训练分布的一部分。
  • 独立 segment:attention 只能连接同一文档;跨 segment 的 next-token 目标也必须忽略。若每段以 bos 开始,则 bos 位置仍可预测该段第一个正文 token。

独立 segment 的 loss mask 可以这样构造:

def packed_causal_lm_loss(logits, input_ids, valid, segment_ids):
    shift_logits = logits[:, :-1, :].contiguous()   # [N,L-1,V]
    shift_labels = input_ids[:, 1:].clone()          # [N,L-1]

    same_segment = segment_ids[:, :-1].eq(segment_ids[:, 1:])
    score = valid[:, :-1] & valid[:, 1:] & same_segment
    shift_labels.masked_fill_(~score, -100)

    token_loss = F.cross_entropy(
        shift_logits.transpose(1, 2),
        shift_labels,
        ignore_index=-100,
        reduction='none',
    )
    return token_loss.sum() / score.sum().clamp_min(1)
python

same_segment 同样要进入 attention 可见性规则;只屏蔽 loss 仍可能让 B 的隐藏状态读取 A。反过来,只隔离 attention 却保留 A→B 的边界标签,会要求模型在没有 B 上下文时猜文档开头。

12 当前 Transformers API 把移位放在哪里?#

Hugging Face 当前 GPT2LMHeadModel ↗ 文档明确说明:可以令 labels=input_ids,模型内部会完成 next-token 移位;标签为 -100 的位置被忽略。当前 DataCollatorForLanguageModeling ↗ 在 mlm=False 时也会复制输入作为标签,并把 padding 标签设为 -100。

若使用这种模型接口,就不要先手动把 labels 左移;否则内部再移一次,会变成位置 tt 预测 t+2t+2。若自己拿 outputs.logits 调 F.cross_entropy,则必须像第 06 节那样显式移位。接口边界一定要通过打印一个极小 batch 验证,不能凭类名猜测。

13 困惑度怎样汇总才不会被 batch 大小骗?#

验证集 PPL 应先累计所有有效 token 的 NLL,再做一次指数:

PPL⁡=exp⁡(∑bNLLSum⁡b∑bValidTokens⁡b)\operatorname{PPL} =\exp\left( \frac{\sum_b \operatorname{NLLSum}_b} {\sum_b \operatorname{ValidTokens}_b} \right)

不要平均每个 batch 的 mean loss:最后一个小 batch、不同长度与不同 padding 比例会获得不合理的同等权重。分布式验证还要先对 total_nll 和 total_tokens 分别做 all_reduce(SUM),再相除。

PPL 只有在 tokenizer、大小写/空白预处理、上下文长度、stride、是否计入 eos 以及 loss mask 一致时才可直接比较。不同 tokenizer 会把同一文本切成不同数量的 token;token 级 PPL 不能跨词表裸比。

14 用四个测试抓住“损失很低但目标错了”#

测试一:打印真实对齐对#

tokens = ['<bos>', '我', '爱', '猫', '<eos>']
for left, right in zip(tokens[:-1], tokens[1:]):
    print(f'看到 {left!r} 后预测 {right!r}')
python

在真实 batch 上解码 input_ids[0,:8] 与对应监督 token;这是发现双重移位、遗漏 eos 和 tokenizer 特殊 token 的最快方法。

测试二:未来替换不改变过去 logits#

ids_a = torch.tensor([[1, 7, 8, 9, 2]])
ids_b = torch.tensor([[1, 7, 8, 4, 5]])  # 只改位置 3 以后

with torch.inference_mode():
    a = model(ids_a).logits
    b = model(ids_b).logits

torch.testing.assert_close(a[:, :3], b[:, :3])
python

若位置 0–2 的 logits 变化,causal attention 存在未来泄漏。注意这项测试检查“看什么”,不能证明标签对齐正确。

测试三:pad 与 eos 分别计数#

构造 pad_id == eos_id 的 batch,断言真实 eos 标签被计入,而 padding 标签被改成 -100。同时检查有效 token 数是否等于人工计数。

测试四:过拟合一条极短序列#

固定随机种子,在一条 5-token 序列上训练数百步;正确 token loss 应显著下降。随后逐位置检查 argmax。若 loss 降而预测整体错一位,优先检查 labels 是否被数据层和模型内部各 shift 了一次。

15 最常见的 next-token 训练错误#

  • 没有 causal mask。 模型在训练时直接读取未来答案,验证 NLL 虚低。
  • 完全不移位。 每个位置学习复制当前 token,而不是预测下一个 token。
  • 手工 shift 后交给内部还会 shift 的模型。 目标跨了两格。
  • 同时先 softmax 又调用 cross entropy。 API 需要 logits;重复归一化会损失数值稳定性并改变梯度。
  • 把类别轴放错。 [N,L,V] 不能直接当作类别在第 1 维;应转成 [N,V,L] 或展平为 [N*L,V]。
  • 用 pad_id 作为 ignore index。 当 pad_id==eos_id 时会连真实结束 token 一起忽略。
  • 只有 attention mask,没有 loss mask。 padding 目标仍污染梯度。
  • 只有 loss mask,没有 key mask。 真实位置仍可能读取 padding 表示。
  • packing 只拼 token,不处理 segment。 文档边界产生伪标签或跨文档可见边。
  • 按 batch 平均再平均。 长短 batch 获得同权,验证 PPL 被 padding 比例改变。
  • 对 mean loss 做分布式平均。 每张卡有效 token 数不同,必须先汇总 NLL 总和与 token 数。
  • 把训练低 PPL 当成生成质量。 重复、事实错误与采样退化需要独立生成评估。

16 这个目标会在哪些场景暴露局限?#

  1. 局部高概率不保证全局好序列。 每一步都看似合理,长文本仍可能重复、跑题或自相矛盾。
  2. Teacher Forcing 与自由生成条件不同。 模型训练时很少见到自己制造的错误前缀,推理误差可能累积。
  3. 稀有但关键 token 权重很小。 平均 token NLL 会被大量常见标点和语法 token 主导;事实、代码边界或安全规则未必得到足够权重。
  4. 数据似然会学习数据缺陷。 重复、偏见、隐私信息和错误事实同样能降低 next-token loss。
  5. 有限上下文改变条件概率。 切块后窗口开头缺少更早历史;不同 stride 与缓存策略会改变训练和评估值。
  6. PPL 不等于任务能力。 更低验证 PPL 通常有用,却不能单独证明推理、校准、可控性或事实性更好。

因此训练应同时监控数据质量、按域/长度/稀有度分桶的 NLL、生成样本、下游任务与安全指标。单个全局平均值只能回答一部分问题。

17 与相近训练目标的边界#

目标条件信息监督位置适合什么主要边界
因果语言建模 CLM只看左侧前缀通常每个 next token开放式自回归生成推理串行、误差会改变后续前缀
掩码语言建模 MLM同时看左右文被遮盖位置双向表征学习预训练中的 [MASK] 与生成不一致
Encoder–Decoder LM看完整源文和目标左前缀目标 next token翻译、摘要、条件生成需要明确源—目标配对
Sequence-level objective取决于模型整段奖励/偏好对齐任务级质量奖励稀疏、优化和归因更难
多 token 预测左侧前缀一次预测多个未来位置增密监督或加速探索目标相关性和推理契约更复杂

这些方法不是简单的“谁更先进”。选择取决于推理时可用的条件、需要的输出方式,以及训练目标与部署过程是否一致。

18 今天真正需要记住什么?#

  1. 因果语言模型用概率链式法则把原文变成密集监督:位置 tt 根据真实前缀 z≤tz_{\le t} 预测 zt+1z_{t+1}。
  2. 标签移位、causal attention mask 与 loss mask 分别控制“预测谁、能看谁、哪些位置计分”,任何一个都不能替代另外两个。
  3. Teacher Forcing 让训练使用真实前缀并并行计算所有位置;自回归推理却使用模型自己的输出,因此训练损失与生成行为必须分别验证。
  4. PyTorch 手写 loss 时显式 shift;Transformers CausalLM 常在模型内部 shift。两边都做会产生隐蔽的双重移位。
  5. PPL 应由全验证集 NLL 总和除以有效 token 总数后取指数;只有 tokenizer、切块与 mask 契约一致时才可比较。

19 思考题与小练习#

  1. 给定序列 [bos, A, B, eos, pad, pad],写出显式移位后的 logits 位置、标签和 -100 loss mask。若 pad_id==eos_id,解释为什么不能用 token id 本身判断哪些 eos 应忽略。
  2. 两个验证 batch 分别有 100 个有效 token、平均 NLL 1.0,以及 10 个有效 token、平均 NLL 2.0。计算正确的全局 PPL,并与“先平均两个 batch loss 再取指数”比较。
  3. 将两个 segment [bos,A,eos] 与 [bos,B,eos] 打包。画出 [6,6] 的 causal + same-segment 可见矩阵,再列出哪些 next-token 边界标签应设为 -100。

相关工作#

20 下一篇预告#

next-token loss 教会模型给每个候选 token 分配概率,却没有规定推理时怎样从分布中选出一个 token。下一篇将进入自回归解码:从贪心与 Beam Search 的确定性偏差出发,手算温度、top-k 与 top-p 如何重塑分布,并用重复率、事实性与多样性解释为什么“最高概率”不总等于“最好文本”。

标签就是原文,模型为何不能偷看答案?Next-token loss、Teacher Forcing 与困惑度
https://zwjcode.cn/blog/causal-language-model-next-token-loss-teacher-forcing-perplexity
作者 傑
发布于 2026年9月10日
版权协议 CC BY-NC-SA 4.0
评论加载似乎遇到了问题,请尝试刷新页面。