Skip to content

预训练目标函数:从 CLM、MLM 到 FIM 与 MTP

系统解析因果语言建模、掩码建模、代码 FIM 与多 Token 预测的数学原理与演进逻辑。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是预训练目标(CLM / MLM / FIM / MTP)?

预训练目标(Pre-training Objective) 就是给还没上过学的大模型出的“海量无监督练习题”:不需要人工标注答案,直接把互联网上的文本、代码挖空或截断,让模型自己猜缺失的部分,在猜错和纠错中自动学会语言规律、逻辑推理和世界知识。

现代大模型最核心的题型是 CLM(猜下一个词);在此基础上还衍生出专门练代码补全的 FIM(给头尾猜中间),以及 DeepSeek-V3 用于提效的 MTP(一眼同时猜后面多个词)。

01 问题从何而来:怎么给几百亿参数“出考题”? ​

刚初始化好的 Transformer 大模型就像一块还没通电的白板——它手里攥着几百亿个随机数字,既不懂中文语法,也不知道牛顿第二定律。更麻烦的是,互联网上几万亿字的网页、代码和书籍全都是没有人工标准答案的无标注文本。我们总不能雇人给几万亿字逐句打标签,那模型怎么自学成才?

答案就是自监督预训练目标函数:把文本本身拆开,遮住一部分,逼着模型用剩下的部分把遮住的内容猜出来。猜对了不扣分,猜错了就通过 反向传播 把误差送回去改权重。这道“考题”怎么出,直接决定了模型学到的是“擅长做阅读理解的做题家”,还是“能写诗写代码的通用生成大脑”。

类比 · 两种截然不同的自学考法

早期研究分成了两大门派。一派是 MLM(掩码语言建模),像 BERT (2019) ↗ 那样,把一篇文章随机挖掉 15% 的词换成 `<mask>`,让模型同时偷看左边和右边来做完形填空。另一派是 CLM(因果语言建模),像 GPT-2 (2019) ↗ 那样,拿一块黑纸盖住右边所有字,要求模型从左到右逐字做故事接龙:看到第 1 个字猜第 2 个,看到前 2 个字猜第 3 个,一路猜到句尾。

看起来“两边都能看”的完形填空更占便宜,可为什么今天几乎所有大模型都投奔了只看左边的故事接龙?因为 MLM 有两处硬伤:一是每次前向计算只对被挖空的 15% 位置算分,85% 的算力都在陪跑;二是现实里我们想让模型从零写文章时,根本不存在“右边写好的下文”。相反,CLM 一次前向能让句子里 100% 的位置同时当考题,而且练出来的技能和实际聊天生成严丝合缝。

核心设问

纯从左到右的“猜下一个词(NTP)”已经很强了,但它还有两个天然短板:写代码时鼠标后面明明已经有一段旧代码,模型却被蒙住眼睛看不见;而且每次只猜后面 1 个词,模型会不会太“短视”?我们能不能在保住 CLM 全部优势的前提下,顺手教会它看尾补中和走一步看几步?

02 核心直觉与生活类比:从接龙到“补漏”与“算步” ​

为了补齐纯 CLM 的两块短板,现代大模型演化出了两招极其精巧的升级:FIM(中间填充) 和 MTP(多 Token 预测)。

类比 · FIM:把三段录音重新剪辑,零改架构学会“看尾补中”

程序员写代码时最常见的场景,不是在文件最末尾续写,而是在函数中间补几行逻辑——这时候光标前面有前缀(Prefix),后面有后缀(Suffix)。如果去改模型结构加双向注意力,会破坏原本丝滑的因果推理。

OpenAI 在 FIM (2022) ↗ 里想出一个绝妙的“障眼法”:模型结构和损失函数一个字节都不用改,只在喂数据之前把文档切成“前、中、后”三段,然后把后段搬到中段前面,插上三个路标标记:

`<fim_prefix>` + 前缀 + `<fim_suffix>` + 后缀 + `<fim_middle>` + 中间答案 + `<eos>`

模型依然乖乖从左往右做故事接龙,可轮到它猜“中间答案”时,前缀和后缀早就在它的左边看完了!这就像把一道“已知开头和结尾补中间”的题,改写成“先读开头,再读结尾,最后写中间”,让单向模型免费解锁了双向补全技能。

类比 · MTP:象棋大师为什么不“走一步看一步”?

传统下一词预测(NTP)只关心眼前一步。如果句子里接下来是一个很顺口的虚词(比如“的”“了”),模型只需凭浅层惯性就能蒙对,根本懒得去思考整句话后面要表达什么主旨。

MTP(Multi-Token Prediction) 就像逼着棋手每走一步都把后面两三步的招法一起报出来(详见 Meta MTP (2024) ↗ 与 DeepSeek-V3 (2024) ↗)。DeepSeek-V3 更是把它做成了串联接力:主干网络猜出第 t+1 个词后,把主干脑子里的想法 ht0 和真实第 t+1 个词拼在一起,交给一个轻量副驾驶模块去猜第 t+2 个词。

这带来一石二鸟的红利:训练时,未来的误差会倒灌回主干网络,逼着模型提前打腹稿;推理时,这个训练好的副驾驶还能直接拿来做 投机解码——主干算一次、副驾驶顺手多猜一个词,命中率高达 85%–90%,白嫖近 1.8 倍的生成提速!

03 把关键公式读成人话 ​

CLM 的核心数学公式其实就一行——最小化全序列的平均负对数似然(即 信息论 里的交叉熵损失):

LCLM(θ)=−1T∑t=1Tlog⁡Pθ(xt∣x<t)

把公式读成直觉:- x<t 是“第 t 个词之前的所有上文”,竖线后面的条件表示模型绝不能偷看未来;

  • Pθ(xt∣x<t) 是模型给正确答案 xt 押上的概率赌注;
  • −log⁡(⋅) 是一把赏罚分明的尺子:如果模型对正确答案信心满满(概率 0.99),−log⁡(0.99)≈0.01,几乎不扣分;如果模型把正确答案押成 0.001,扣分就会飙升到 6.9,逼着参数立刻大改;
  • 1T∑t=1T 说明长度为 T 的文章一次前向就能同时批改 T 道题,算出平均失分。

到了 DeepSeek-V3 的链式 MTP,总考卷分值变成主考题加上 D 道“远见附加题”:

Ltotal=LCLM+λD∑k=1DLMTP(k)

**把 MTP 总损失读成直觉:**主考题 LCLM 依然是大头,保证当前一步猜得准;后面的 λD∑LMTP(k) 是附加分(DeepSeek-V3 前期权重 λ=0.3,后期退火降到 0.1)。因为主干表征既要对当前词负责,又要被未来第 2,3 个词的梯度拽着走,模型被迫把长远语义提前压缩进隐藏状态里。

04 它在模型里怎么工作 & 与上下游的关系 ​

预训练目标函数虽然只挂在网络最顶端,却像一根指挥棒牵动着整条大模型的上下游流水线:

  • 上游承接词表与数据编排:文本先经过 分词器 变成离散 ID,再由 预训练数据工程 做清洗、FIM 重排与多文档打包(Sequence Packing)。打包时必须配合 自注意力机制 里的文档级块对角掩码,防止把上一篇新闻的结尾误用来预测下一篇菜谱的开头。
  • 训练期驱动优化与缩放:目标函数算出的标量 Loss 经过 反向传播 变成梯度,交给 大模型优化器 更新权重。而随着语料与参数扩大,CLM 交叉熵的下降曲线严格遵循可预测的 缩放定律。
  • 下游无缝衔接微调与推理:进入后训练的 指令微调 (SFT) 阶段,目标函数依然是同一个 CLM 公式,只不过把“用户提问区”的损失权重置零,只对“模型回答区”算交叉熵;而如果预训练挂了 MTP 模块,部署时就能无缝对接 投机解码 提速推理。

05 演化对比与避坑备忘 ​

目标范式考题形态单次前向有效考题占比能否直接写文章典型代表
MLM挖空 15% 做双向完形填空约 15%不能BERT, RoBERTa
Span Corruption挖掉连续片段,解码器补全约 15%–25%有条件支持T5 (arXiv ↗)
CLM (NTP)从左到右逐字故事接龙100%原生支持GPT-4, LLaMA-3, Qwen
CLM + FIM前后缀重排,单向模拟双向补全100%原生支持StarCoder, DeepSeek-Coder
CLM + 链式 MTP猜下一步 + 串联副驾驶猜未来多步(1+D)×100%原生支持 + 加速DeepSeek-V3 (arXiv ↗)

工程落地时,有三个最容易踩的坑值得提前记住:

  1. 巨型词表的 Logits 显存爆炸:现代模型词表常达 128K 以上,如果傻傻地把整个 [B, T, V] 的 FP32 预测分数完整算出来再送进交叉熵,光这一个张量就能吃掉几 GB 显存直接 OOM。工程上必须用 Fused Linear Cross-Entropy(分块边算矩阵乘边算 Softmax)把显存峰值削平。
  2. 超大词表配低精度时的 Z-Loss 稳压阀:在 混合精度训练(BF16/FP8)下,Softmax 分母 log⁡Z 容易莫名其妙越漂越大引发梯度爆炸。在交叉熵外加上极小的惩罚项 α(log⁡Z)2,相当于给 Logits 装上一根避雷针。
  3. 跨文档拼接忘了隔断注意力:把十篇短文章拼成一条 8192 序列提速训练时,如果只插 `<eos>` 而不加文档级注意力掩码,文章 B 的词会跨界去注意文章 A 的无关内容,悄悄污染模型的长文本注意力分布。

想查阅 CLM/MLM/FIM/MTP 的完整形式化推导、Mermaid 顺序链式数据流图与可运行的 CLMWithMTPLoss PyTorch 实现?按快捷键 M 或点击顶部 技术 Wiki 随时切换。

预训练目标函数(Pretraining Objective)是大语言模型从海量无标注语料中汲取世界知识与推理能力的“指挥棒”。通过构造自监督(Self-Supervised)预测任务,模型被迫将语法结构、事实知识与逻辑推演压缩进权重矩阵之中。从早期的双向掩码语言建模(MLM),到如今占主导地位的因果语言建模(CLM),再到面向代码补全的中间填充(FIM)与提升训练密度的多 Token 预测(MTP),预训练目标的演进始终围绕着训练信号密度、生成一致性与架构可扩展性三大核心权衡展开,其交叉熵理论根基来自 信息论基础,而最终拟合上限则与 缩放定律 紧密相连。

直观理解

把预训练想象成一场永无止境的“完形填空”或“故事接龙”考试。CLM(下一词预测) 是按从左到右的顺序逐字接龙,每个字都是一道考题;MLM是随机挖掉句子里 15% 的空,结合上下文来填词;FIM是给定代码开头和结尾,补全中间缺失的函数体;而 MTP 则是要求模型在每个位置“走一步看两步”,同时预测未来的多个词,从而逼迫模型提前规划全局语义。

问题动机与演进背景 ​

在 Transformer 诞生初期,研究者面临一个根本分歧:究竟应该利用双向全上下文来学习高质量的表征,还是严格受限于单向因果视野以换取自然语言生成能力?

  1. 判别式表征时期(MLM / Span Corruption):BERT 采用掩码语言建模,允许每个位置同时看到左侧与右侧上下文,在分类、抽取等理解任务上大幅领先单向模型。然而,MLM 存在显著缺陷:一是每次前向传播仅在约 15% 的掩码位置计算损失,样本利用效率低;二是预训练引入了特殊占位符 <mask>,导致预训练与下游微调/生成存在分布失配(Pretrain-Finetune Discrepancy);三是无法直接进行开放式自回归生成。
  2. 大一统生成范式(CLM / NTP):GPT 系列证明,只要将模型与语料规模扩大,简单的下一词预测(Next-Token Prediction, NTP)即可涌现出强大的上下文学习(In-Context Learning)与零样本泛化能力。CLM 在单次前向传播中对全部 T 个位置并行计算损失(训练信号利用率接近 100%),且预训练目标与推理时的自回归解码完全一致。
  3. 结构化补全与高阶规划需求(Prefix LM / FIM / MTP):
    • 在代码编辑器补全等场景中,光标后方往往已有代码,纯从左到右的 CLM 无法利用后缀信息,催生了 FIM(Fill-in-the-Middle)。
    • 传统 NTP 每次只看一步,容易陷入局部表面统计特征,且每步仅提供单 Token 的监督信号;MTP(Multi-Token Prediction) 要求隐藏状态同时预测未来 k 个 Token,既增加了单步训练的信息密度,又能将额外预测头直接复用于推理加速。

核心原理与数学推导 ​

1. 因果语言建模(CLM / Next-Token Prediction) ​

给定长度为 T 的 Token 序列 x=(x1,x2,…,xT),利用概率链式法则将联合分布严格分解为条件概率之积:

Pθ(x)=∏t=1TPθ(xt∣x<t)

其中 x<t=(x1,…,xt−1)。CLM 通过最小化序列的平均负对数似然(即交叉熵损失)来优化参数 θ:

LCLM(θ)=−1T∑t=1Tlog⁡Pθ(xt∣x<t)=−1T∑t=1Tlog⁡exp⁡(zt,xt)∑v=1|V|exp⁡(zt,v)

其中 zt=Wlmht−1∈R|V| 是第 t−1 步隐藏状态经词表投影后的 Logits。为防止未来信息泄露,自注意力层必须施加下三角因果掩码(Causal Mask):当 j>i 时,注意力分数矩阵位置 (i,j) 被置为 −∞。

2. 掩码语言建模(MLM)与跨度破坏(Span Corruption) ​

在 BERT 的 MLM 中,随机采样掩码位置集合 M⊂{1,…,T}(通常 |M|≈0.15T),对 M 中的 Token 以 80% 概率替换为 <mask>、10% 替换为随机词、10% 保持不变,构造破坏序列 x~:

LMLM(θ)=−1|M|∑t∈Mlog⁡Pθ(xt∣x~)

Span Corruption(T5) 进一步将离散单 Token 掩码推广为连续文本跨度(Span):将长度服从泊松分布(如均值 3)的连续片段替换为单个哨兵符号(Sentinel Token,如 <extra_id_0>、<extra_id_1>),要求 Encoder-Decoder 架构的解码器按顺序自回归生成被挖空的内容:

LSpan(θ)=−∑k=1Klog⁡Pθ(sk∣x~,s<k)

这不仅迫使模型预测不定长片段,还大幅缩短了目标序列长度,降低了计算开销。

3. 前缀语言建模(Prefix LM) ​

Prefix LM(如 UniLM、PaLM-2 的混合目标、GLM)在单个 Decoder 架构中融合了双向编码与单向生成。将序列划分为前缀区 x1:p 与目标生成区 xp+1:T:前缀内部采用双向全连接注意力,目标区对前缀以及自身左侧采用因果注意力,且损失仅在目标区计算:

LPrefix(θ)=−1T−p∑t=p+1Tlog⁡Pθ(xt∣x1:p,xp+1:t−1)

4. 中间填充(FIM, Fill-in-the-Middle) ​

OpenAI(Bavarian et al., 2022)发现,无需改动模型架构与 CLM 损失函数,仅通过数据级变换即可赋予因果模型双向补全能力。将文档随机切分为三段:前缀(Prefix, P)、中间(Middle, M)与后缀(Suffix, S),利用特殊控制符重构为 PSM 或 SPM 排列:

  • PSM 格式:<fim_prefix> +P+ <fim_suffix> +S+ <fim_middle> +M+ <eos>
  • SPM 格式:<fim_prefix> + <fim_suffix> +S+ <fim_middle> +P+M+ <eos>

模型随后仍按标准 CLM 计算全序列交叉熵。研究表明,以 50%–90% 的 FIM 变换比例混合常规从左到右语料训练时,模型几乎不会损失标准的左至右生成困惑度(即所谓 FIM-for-free 性质)。

5. 多 Token 预测(MTP, Multi-Token Prediction) ​

Gloeckle et al. (2024) 提出在共享主干网络后挂载 D 个并行输出头同时预测 xt+1,…,xt+D。DeepSeek-V3 对此进行了关键改良:将并行预测改为顺序因果链式预测(Sequential MTP Modules),使每一步预测保持完整的自回归因果依赖。

设主干网络在第 t 步输出隐藏状态 ht0∈Rd。对于第 k∈{1,…,D} 个 MTP 模块(包含独立 RMSNorm、线性投影矩阵 Mk∈Rd×2d 与轻量 Transformer 块 TRMk),其融合上一深度表征 htk−1 与真实未来词嵌入 Emb(xt+k):

ht′k=Mk[RMSNorm(htk−1);RMSNorm(Emb(xt+k))]htk=TRMk(ht′k),Ptk+1=Softmax(Wlmhtk)

其中词嵌入矩阵 Emb 与输出头 Wlm 在主模型与所有 MTP 模块间共享权重。总训练目标为主 CLM 损失与各深度 MTP 损失的加权和:

Ltotal=LCLM+λD∑k=1DLMTP(k),LMTP(k)=−1T∑t=2+kT+1log⁡Pt−k−1k+1(xt)

通过反向传播,未来多步的梯度同时回传至主干状态 ht0,迫使主干网络预先规划跨步语义;推理阶段则可直接丢弃 MTP 模块零开销运行,或将其用作 投机解码 的草稿头(DeepSeek-V3 中单步 MTP 接受率达 85%–90%,实现约 1.8 倍解码加速)。而在预训练结束后,指令微调 (SFT) 仍沿用完全一致的 CLM 交叉熵形式,仅将损失掩码限定在回答区间。

算法架构与数据流图 ​

下图对比了标准 CLM 注意力流与 DeepSeek-V3 顺序链式 MTP(D=2)的前向数据流结构:

图表加载中...

复杂度与横向对比 ​

目标函数代表模型注意力掩码模式单次前向有效损失占比是否支持原生生成核心优势主要局限
CLM (NTP)GPT-4, LLaMA-3, Qwen下三角因果掩码100% (T 个位置)是训练与推理完全一致、缩放律最优单步视野受限、缺乏显式后缀感知
MLMBERT, RoBERTa全双向掩码约 15%否双向上下文表征极强掩码分布失配、训练信号稀疏
Span CorruptionT5, UL2Encoder 双向 + Decoder 因果约 15%–25%有条件支持兼顾双向理解与变长片段生成Encoder-Decoder 架构推理部署较复杂
Prefix LMUniLM, PaLM-2前缀双向 + 后缀因果取决于后缀比例是适合有固定输入前缀的任务需预设前缀切分点,KV Cache 复用受限
FIMCodex, StarCoder, DeepSeek-Coder下三角因果掩码100%是零架构改动赋予双向上下文代码补全过高的 FIM 比例会轻微削弱长文连贯性
MTPMeta MTP, DeepSeek-V3因果掩码 + 链式预测模块(1+D)×100%是稠密监督促成长期规划、自带投机解码头额外增加少量投影层与轻量块显存/算力

核心 PyTorch 参考实现 ​

以下代码实现了支持 FIM 数据变换 以及 DeepSeek-V3 风格顺序链式 MTP 的核心模块,并标注了张量维度变化:

python
import random
import torch
import torch.nn as nn
import torch.nn.functional as F


def apply_fim_transform(
    tokens: list[int],
    prefix_id: int,
    suffix_id: int,
    middle_id: int,
    fim_rate: float = 0.5,
    spm_rate: float = 0.5,
) -> list[int]:
    """对单条 token 序列按概率执行 PSM 或 SPM 格式的 FIM 重排。"""
    if len(tokens) < 4 or random.random() > fim_rate:
        return tokens
    # 随机采样两个切分点,保证三段均非空
    i, j = sorted(random.sample(range(1, len(tokens)), 2))
    prefix, middle, suffix = tokens[:i], tokens[i:j], tokens[j:]
    if random.random() < spm_rate:
        # SPM: <fim_prefix> <fim_suffix> suffix <fim_middle> prefix middle
        return [prefix_id, suffix_id] + suffix + [middle_id] + prefix + middle
    # PSM: <fim_prefix> prefix <fim_suffix> suffix <fim_middle> middle
    return [prefix_id] + prefix + [suffix_id] + suffix + [middle_id] + middle


class SequentialMTPModule(nn.Module):
    """DeepSeek-V3 风格的单个顺序链式 MTP 模块。"""

    def __init__(self, d_model: int, n_heads: int):
        super().__init__()
        self.norm_h = nn.RMSNorm(d_model)
        self.norm_e = nn.RMSNorm(d_model)
        self.proj = nn.Linear(2 * d_model, d_model, bias=False)
        # 使用轻量单层因果 Transformer Block(示例采用标准 EncoderLayer + 因果掩码)
        self.block = nn.TransformerEncoderLayer(
            d_model=d_model,
            nhead=n_heads,
            dim_feedforward=4 * d_model,
            activation="gelu",
            batch_first=True,
            norm_first=True,
        )

    def forward(self, prev_h: torch.Tensor, future_emb: torch.Tensor) -> torch.Tensor:
        # prev_h:     [B, L, D]  来自上一深度的隐藏状态
        # future_emb: [B, L, D]  对应位置偏移后的真实 token 嵌入
        fused = torch.cat([self.norm_h(prev_h), self.norm_e(future_emb)], dim=-1)  # [B, L, 2D]
        x = self.proj(fused)  # [B, L, D]
        seq_len = x.size(1)
        causal_mask = nn.Transformer.generate_square_subsequent_mask(seq_len, device=x.device)
        return self.block(x, src_mask=causal_mask, is_causal=True)  # [B, L, D]


class CLMWithMTPLoss(nn.Module):
    """整合标准 CLM 损失与 D 步顺序 MTP 损失的训练头。"""

    def __init__(self, vocab_size: int, d_model: int, n_heads: int, mtp_depth: int = 2, mtp_weight: float = 0.3):
        super().__init__()
        self.mtp_depth = mtp_depth
        self.mtp_weight = mtp_weight
        self.embed = nn.Embedding(vocab_size, d_model)
        self.lm_head = nn.Linear(d_model, vocab_size, bias=False)
        self.mtp_modules = nn.ModuleList([SequentialMTPModule(d_model, n_heads) for _ in range(mtp_depth)])

    def compute_loss(self, hidden_states: torch.Tensor, input_ids: torch.Tensor) -> tuple[torch.Tensor, dict]:
        # hidden_states: [B, T, D]  主干网络输出 h^0
        # input_ids:     [B, T]     完整输入序列 x_1 .. x_T
        B, T, _ = hidden_states.shape

        # 1. 标准 CLM (NTP) 损失:用 h_t^0 预测 x_{t+1}
        logits_main = self.lm_head(hidden_states[:, :-1, :])  # [B, T-1, V]
        targets_main = input_ids[:, 1:]                       # [B, T-1]
        loss_clm = F.cross_entropy(logits_main.reshape(-1, logits_main.size(-1)), targets_main.reshape(-1))

        # 2. 顺序链式 MTP 损失:深度 k 预测 x_{t+1+k}
        h_curr = hidden_states
        mtp_losses = []
        for k, mtp_mod in enumerate(self.mtp_modules, start=1):
            valid_len = T - 1 - k
            if valid_len <= 0:
                break
            prev_h = h_curr[:, :valid_len, :]                      # [B, T-1-k, D]
            future_emb = self.embed(input_ids[:, k : k + valid_len])  # [B, T-1-k, D]
            h_next = mtp_mod(prev_h, future_emb)                   # [B, T-1-k, D]
            logits_k = self.lm_head(h_next)                        # [B, T-1-k, V]
            targets_k = input_ids[:, k + 1 : k + 1 + valid_len]    # [B, T-1-k]
            loss_k = F.cross_entropy(logits_k.reshape(-1, logits_k.size(-1)), targets_k.reshape(-1))
            mtp_losses.append(loss_k)
            h_curr = h_next

        loss_mtp = torch.stack(mtp_losses).mean() if mtp_losses else torch.tensor(0.0, device=hidden_states.device)
        total_loss = loss_clm + self.mtp_weight * loss_mtp
        return total_loss, {"clm": loss_clm.item(), "mtp": loss_mtp.item()}


if __name__ == "__main__":
    torch.manual_seed(42)
    B, T, D, V = 2, 16, 128, 1000
    head = CLMWithMTPLoss(vocab_size=V, d_model=D, n_heads=4, mtp_depth=2, mtp_weight=0.3)
    dummy_h = torch.randn(B, T, D, requires_grad=True)
    dummy_ids = torch.randint(0, V, (B, T))
    loss, metrics = head.compute_loss(dummy_h, dummy_ids)
    loss.backward()
    print(f"Total Loss: {loss.item():.4f}, Metrics: {metrics}, Grad norm: {dummy_h.grad.norm():.4f}")

工程实践与常见陷阱 ​

工程实践

  1. 文档打包(Sequence Packing)与跨文档注意力隔离:预训练数据工程 通常将多篇短文档用 <eos> 拼接填满固定上下文窗口(如 4096 或 8192)以消除 Padding 浪费。现代框架(如 FlashAttention varlen 接口)会构造块对角因果掩码(Document-level Attention Mask),阻止文档 B 的 Token 注意到文档 A 的内容,同时避免将文档 A 的最后一个 Token 用于预测文档 B 的开头。
  2. Z-Loss 稳定大模型交叉熵:当词表庞大且采用 混合精度训练(BF16/FP8)时,Softmax 分母 log⁡Z=log⁡∑vezv 容易漂移导致梯度爆炸。PaLM 与 Chameleon 均在交叉熵外附加 α⋅(log⁡Z)2(典型 α=10−4)以约束 Logits 幅度。
  3. MTP 权重退火策略:DeepSeek-V3 在训练前 10T Tokens 时将 MTP 损失权重 λ 设为 0.3,在最后 4.8T Tokens 阶段下调至 0.1,使模型后期更聚焦于主干单步分布的精确拟合。

常见陷阱

  1. 交叉熵的词表显存峰值(Logits Memory Spike):当词表 |V|≥128k、序列长 T=8192 时,仅 FP32 的 Logits 张量 [B, T, V] 就可能占据数 GB 显存。生产级训练必须采用 Fused Linear Cross-Entropy(如 Liger Kernel / Cut Cross-Entropy),在分块计算矩阵乘的同时在线计算 Softmax 归一化常数,避免实例化完整的巨型 Logits 矩阵。
  2. FIM 切分破坏字节/子词边界:若在字符级随机切分后再分别分词,容易产生训练时从未见过的“切碎的子词前缀”(Tokenization Artifacts)。应先在字符级按行或语法树边界切分,或直接在 Token 级执行 FIM 并混合两种粒度以提升真实 IDE 补全体验。
  3. 并行 MTP 忽略步间条件依赖:若直接从同一 ht0 并行预测 xt+1 与 xt+2 而非顺序链式注入 xt+1,模型在存在多种合法续写时只能学到边缘分布的模糊平均,无法保持联合分布一致性。

延伸阅读与参考论文 ​

  • Radford, A., et al. (2019). Language Models are Unsupervised Multitask Learners (GPT-2). OpenAI. (Paper PDF ↗)
  • Devlin, J., et al. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. NAACL. (arXiv:1810.04805 ↗)
  • Raffel, C., et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer (T5). JMLR. (arXiv:1910.10683 ↗)
  • Bavarian, M., et al. (2022). Efficient Training of Language Models to Fill in the Middle (FIM). (arXiv:2207.14255 ↗)
  • Gloeckle, F., et al. (2024). Better & Faster Large Language Models via Multi-token Prediction. ICML 2024. (arXiv:2404.19737 ↗)
  • DeepSeek-AI (2024). DeepSeek-V3 Technical Report. (arXiv:2412.19437 ↗)