Skip to content

监督微调(SFT):指令遵循、损失掩码与序列打包

通过高质量指令-回复对激活基座模型的对话与指令遵循能力,是从预训练迈向对齐的关键桥梁。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是监督微调(SFT)?

刚做完预训练的基座模型(Base Model)像一个读完图书馆所有书但没上过沟通课的学者——你问它“法国首都是哪?”,它可能会顺着续写出“英国首都是哪?德国首都是哪?”而不是直接回答你。

监督微调(SFT, Supervised Fine-Tuning) 就是拿几万到几十万条精心整理好的“人类提问 → 理想回答”对话范例给它做示范训练,并且只在模型回答的那部分算误差(Loss Masking),从而把预训练学到的满腹经纶激活成听懂指令、格式规范的对话助手。

01 问题从何而来:博学却“答非所问”的基座模型 ​

一个刚经历过万亿词元自回归预训练的基座模型(Base Model),肚子里其实已经装下了维基百科、GitHub 代码库和全人类的教科书。可如果你直接向它提问“请解释牛顿第二定律”,它很可能一本正经地接着往下写:“2. 请解释牛顿第三定律。3. 本大题共 20 分……”

它不是不懂物理,而是只会做“文档续写”——它把你的提问当成了一张试卷的开头,于是尽职尽责地帮你把后面的考题补全了。

类比 · 满腹经纶却不懂职场礼仪的图书管理员

预训练就像让一个天才在国家图书馆闭关读完所有藏书:他什么都知道,但从来没跟活人聊过天。当你问他一个问题时,他会条件反射地联想到书页里下一行该印什么字,而不是停下来认真回答你。监督微调(SFT) 不是重读一遍图书馆,而是给他安排一场短平快的“岗前问答规范培训”。

不仅如此,真实的对话助手还必须分清谁在说话(系统指令、用户提问还是助手自己),并且知道什么时候该闭嘴——在回答末尾精准吐出一个结束符(如 `<eos>` 或 `<|im_end|>`),而不是滔滔不绝地自己接着演下一轮用户提问。

2023 年 Meta 发表的 LIMA ↗ 给整个行业泼了一盆清醒剂:他们只用了 1,000 条人工精雕细琢的高质量问答对微调 65B 基座,效果就直逼用数万条数据微调的模型,由此提出了著名的表面对齐假说(Superficial Alignment Hypothesis)——知识早已在预训练阶段刻进权重,SFT 真正要教的,是如何把这些知识用人类喜欢的交互方式体面地表达出来。

核心设问

既然基座模型已经掌握了绝大部分世界知识,我们能不能只用几千到几万条“问题—优质回答”示范,不动它的知识根基,就把它从“自动续写机”切换成听得懂人话、守规矩的对话助手?

02 核心直觉与生活类比 ​

SFT 的核心机制其实由三个极其朴素、却决定成败的零件拼成:Chat Template(对话剧本)、Loss Masking(只给答卷打分) 和 Sequence Packing(带隔断的拼车)。

类比 · 剧本里的角色分割线:Chat Template

如果把两轮对话的纯文本直接粘在一起喂给模型,模型根本分不清哪句是用户问的、哪句是自己答的。Chat Template(比如 ChatML 或 Llama-3 模板)就像话剧剧本里的括号提示:在每段话开头插上特殊的控制词元(如 `<|im_start|>user`、`<|im_start|>assistant`),在结尾插上落幕标记 `<|im_end|>`。

这些特殊词元不是普通汉字,而是分词器里独占编号的“交通信号灯”——一旦看到 assistant 亮绿灯,模型立刻切换成答题模式;一旦答完核心内容,模型自己亮起 `<|im_end|>` 红灯,优雅停笔。

类比 · 老师批改作业:绝不给“抄题目”算分

想象你给学生发了一张印好题干的卷子,让学生在横线上作答。改卷子的时候,老师只看学生自己写的那几行答案对不对,绝不会把印刷在上面的题干也算进扣分项。

SFT 里的 Loss Masking(损失掩码) 正是这个道理:把“系统提示 + 用户问题 + 助手回答”拼成一整条词元序列送进模型,但在算交叉熵损失时,把提示词和用户问题的标签全部盖住(设为 -100),只对助手回复的每一个字——包括末尾那句“我说完了”(`<|im_end|>`)——计算梯度。这样模型才不会浪费容量去背诵用户怎么提问,而是把全部精力花在“给定问题,如何写出好答案并按时收尾”上。

而面对真实指令数据“有的只有两句话、有的长达几千字”的长尾长度分布,如果把每条短对话后面强行补满空白填充符(Padding),GPU 超过一半的算力都会浪费在算空气上。

类比 · 带隔音玻璃的拼车:Sequence Packing

为了不让 GPU 跑空车,工业界会把好几条不相关的短对话首尾拼进同一条长序列里一起算,这叫 序列打包(Sequence Packing)(Krell et al., 2021 ↗)。但如果不加隔离,排在后面的对话 B 就会偷看到前面对话 A 的聊天记录,位置编号也会乱套。

解决办法是在注意力层立起几块“单向隔音玻璃”——块对角因果掩码,同时让每条新对话的位置编号(RoPE 刻度)从 0 重新起跳。这样既把 GPU 吞吐拉高 2–5 倍,又在数学上与逐条单独训练完全等价。

还有一个贯穿整个微调阶段的隐形敌人:灾难性遗忘(Catastrophic Forgetting)。如果在一小批风格极窄的数据上把全参数猛训十几轮,模型就像背模板背魔怔的考生,虽然把新套路记得滚瓜烂熟,却把预训练学来的代码、数学和常识全挤掉了。因此在 SFT 数据里混入 5%–15% 的高质量预训练回放语料、把学习率压到预训练峰值的 1/10 以下,或者引入向词嵌入加轻微噪声的 NEFTune ↗,都是守住通用底牌的关键招数。

03 把关键公式读成人话 ​

SFT 沿用了预训练的自回归交叉熵,但只给掩码 mt=1 的助手回复词元算账。在长短样本混排的批次 B 里,工业级实现一律采用词元级平均(Token-Level Mean):

Ltoken(θ)=−1∑i=1B∑t=1Timi,t∑i=1B∑t=1Timi,tlog⁡πθ(xi,t∣xi,<t)

把公式读成直觉:- xi,t 是第 i 条对话的第 t 个词元,xi,<t 是它前面所有的上下文(包含系统提示、历史多轮对话和已经吐出的半句回答)。

  • mi,t∈{0,1} 是“批改掩码开关”:落到用户提问上是 0(直接忽略),落到助手回答及结尾 `<|im_end|>` 上是 1(计入损失)。
  • 最前面的分母是对全批次所有有效回复词元总数求和,而不是先算每条样本的平均再求均值——这能防止一条只有 3 个字的短回答(比如“是的。”)在梯度里拥有和一篇 800 字长文一样的话语权。

打包多条样本时,防止跨样本偷看的块对角注意力掩码同样只有两行条件:

Mi,j={0,若 j≤i 且 di=dj−∞,其他情况

把公式读成直觉:di 表示第 i 个词元属于“哪一条原始对话”。只有当词元 j 排在 i 之前(j≤i,守因果律)并且俩人来自同一条对话(di=dj,不串台)时,注意力才放行(0);否则直接填 −∞,过完 Softmax 权重瞬间归零。

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

在完整的后训练流水线里,SFT 承上启下,扮演着把“毛坯基座”塑造成“可用助手”的第一道关键关卡:

  • 向上承接预训练与分词器:SFT 直接从预训练基座加载权重,保留全部通用知识(正如 Meta 的 LIMA, 2023 ↗ 所提出的表面对齐假说:哪怕只用 1,000 条极高质量样本,也能唤醒基座里沉睡的对话与推理能力);同时高度依赖预训练数据工程沉淀的去重清洗管线,以及分词器里专门注册的角色控制词元。
  • 训练期与底层内核协同:配合 FlashAttention 的变长接口 varlen 无需显式构造 O(L2) 掩码矩阵即可跑满隔离打包;配合更温和的学习率调度(通常是预训练峰值的 1/10∼1/20)防止灾难性遗忘。
  • 向下衔接高效微调与偏好对齐:当单机显存装不下全参数 SFT 时,业界普遍改用 LoRA / QLoRA 或其他 PEFT 方法 降低门槛;而训练好的 SFT 模型会直接作为下游奖励建模、RLHF-PPO 以及 DPO 偏好优化 的起点与参考基线(详见 InstructGPT ↗ 与 FLAN ↗)。

05 演化对比与避坑备忘 ​

不同批处理与微调策略的选择,直接决定了 SFT 的性价比与上限:

维度朴素方案工业推荐方案直观区别
长度对齐统一 Padding 补齐隔离 Sequence Packing算力利用率从 <40% 飙升至 ~98%,且零跨样本污染
损失均值样本级平均全局词元级平均避免短回复主导梯度,与梯度累积严格等价
数据策略堆百万爬虫脏数据万级精筛 + 5%~15% 预训练回放质量远胜数量,有效抑制灾难性遗忘
参数范围全参数更新(~16× 显存)大数据用全参 / 垂域小样本用 LoRA显存与通用能力保持之间的最佳平衡

最后记住三个最容易翻车的工程备忘:

  1. 切勿自己手拼字符串再分段分词:BPE 可能会把换行符和正文首字合并成一个新词元,导致 Loss Mask 整体错位 1 格;务必使用官方 apply_chat_template 并随机抽检解码 label != -100 的明文。
  2. 绝不能漏掉回复末尾的结束符:如果 `<|im_end|>` 被误标为 -100,模型就会彻底丧失“刹车意识”,上线后变成停不下来的复读机。
  3. SFT 训练 2–3 个 Epoch 就够了:盲目多跑几轮会让验证集困惑度先降后升,模型不仅会遗忘通用知识,还会学会对不懂的问题“一本正经地按模板编瞎话”。

需要查阅完整形式化定义、隔离打包与词元级损失的 PyTorch 实现及工程陷阱详情?按快捷键 M 或点击顶部 技术 Wiki 即可随时切换。

监督微调(Supervised Fine-Tuning, SFT),又称指令微调(Instruction Tuning),是将仅擅长文本续写的预训练基座模型(Base Model)转化为能够理解人类意图、遵循复杂指令并进行多轮对话的助手模型(Instruct/Chat Model)的核心阶段。与动辄消耗数万亿词元(Token)的预训练不同,SFT 通常只需数千至数十万条高质量对话样本,即可显著重塑模型的交互行为。

直观理解

如果把预训练比作“通读人类图书馆的全部藏书以习得广博知识”,那么 SFT 就像是“参加岗前职业礼仪与问答规范培训”。基座模型脑中早已储存了解决问题的知识,但缺乏“看到问题就按规范作答,而非继续续写相似问题”的行为模式;SFT 的核心任务就是用少量示范教会模型以人类期望的格式调取已有知识。

问题动机与演进背景 ​

在自回归预训练阶段,模型的核心目标是最大化海量无标注语料上的下一词元预测概率。这种训练方式赋予了基座模型强大的世界知识与上下文学习(In-Context Learning)能力,但也带来了两个显著缺陷:

  1. 目标错配(Objective Mismatch):当用户输入“请解释牛顿第二定律”时,未经微调的基座模型很可能出于文档续写惯性,接着输出“请解释牛顿第三定律”或“本题满分 10 分”,而不是直接给出答案。
  2. 格式与角色边界缺失:在多轮对话、代码生成、工具调用等场景中,模型需要借助分词器中的特殊控制词元清晰区分系统提示(System)、用户提问(User)与模型自身回答(Assistant),并在回答结束时准确生成终止符(如 `<|im_end|>` 或 `<eos>`)。

自 FLAN(Wei et al., 2022 ↗)、T0 与 InstructGPT(Ouyang et al., 2022 ↗)以来,学术界与工业界系统确立了指令微调范式。2023 年 Meta 提出的 LIMA(Less Is More for Alignment)(Zhou et al., 2023 ↗)更进一步提出了著名的表面对齐假说(Superficial Alignment Hypothesis):大语言模型的绝大部分知识与能力均在预训练阶段习得,对齐微调仅需极少量(例如 1,000 条)精心策展、风格统一、多样性高的示例,便足以教会模型在特定子分布下以合适格式与用户交互。

核心原理与数学推导 ​

1. 条件自回归损失与 Loss Masking ​

设一条多轮对话样本经由对话模板(Chat Template)拼接后,被分词器编码为长度为 T 的词元序列 x=(x1,x2,…,xT)。序列中既包含系统提示和用户输入(Prompt 区间),也包含待学习的目标回答及结束标记(Response 区间)。

在标准 SFT 中,我们仅对助手回复部分计算交叉熵损失,对提示词部分施加损失掩码(Loss Masking,在 PyTorch 中通常将对应位置的标签设为忽略索引 -100)。令指示函数 mt∈{0,1} 表示位置 t 是否属于助手回复词元(含该轮回复的终止符),则 SFT 损失函数定义为:

LSFT(θ)=−1∑t=1Tmt∑t=1Tmtlog⁡πθ(xt∣x<t)

其中 πθ 为参数化语言模型。设在训练批次 B 内共有 B 条样本,需注意两种梯度归一化方式的差异:

  • 样本级平均(Sample-level Mean):先对每条样本内部的有效词元求平均损失,再对批次求平均。短回复中的每个词元会获得更大的梯度权重。
  • 词元级平均(Token-level Mean):先将整个批次(乃至整个梯度累积周期)内所有有效词元的损失求和,再除以总有效词元数 Nvalid:
Ltoken(θ)=−1∑i=1B∑t=1Timi,t∑i=1B∑t=1Timi,tlog⁡πθ(xi,t∣xi,<t)

在长短回复混排的指令数据中,词元级平均能避免短样本过度主导梯度方向,同时保证跨 GPU 数据并行与梯度累积(Gradient Accumulation)时的严格数学等价性。

2. Chat Template 与多轮角色切分 ​

为了统一单轮、多轮、系统提示与工具调用等异构结构,现代框架引入了标准化的 Chat Template(如 ChatML、Llama-3 模板)。以 ChatML 风格为例,一条两轮对话被序列化为:

  • 系统段:`<|im_start|>system\n你是一位严谨的助手。<|im_end|>\n`(掩码 mt=0)
  • 用户第 1 轮:`<|im_start|>user\n什么是熵?<|im_end|>\n`(掩码 mt=0)
  • 助手第 1 轮:`<|im_start|>assistant\n熵衡量不确定性。<|im_end|>\n`(内容及 `<|im_end|>` 掩码 mt=1)
  • 用户第 2 轮:`<|im_start|>user\n请给出公式。<|im_end|>\n`(掩码 mt=0)
  • 助手第 2 轮:`<|im_start|>assistant\nH(X) = -sum p log p。<|im_end|>\n`(掩码 mt=1)

将每轮的 `<|im_end|>` 纳入损失计算至关重要:若忽略终止符,模型将无法学会在回答完毕后适时停止生成,推理时容易陷入冗长复读。

3. 序列打包(Sequence Packing)与交叉注意力隔离 ​

指令数据的长度分布极度长尾(多数样本仅数百词元,少数长上下文样本可达数万词元)。若直接采用右填充(Padding)对齐到最大长度 Lmax,大量算力会浪费在无效填充符上。

序列打包(Sequence Packing) 将多条独立短样本首尾拼接到同一条长度为 Lmax 的定长槽位中,将计算利用率提升 2 倍至 5 倍。然而,朴素拼接会带来严重的跨样本注意力污染(Cross-Sample Contamination):样本 B 的词元会错误地注意到前序样本 A 的键值状态,且位置编码(RoPE)也会从非零位置继续累加。

解决办法是构造块对角因果掩码(Block-Diagonal Causal Mask) 并配合位置索引重置(Position ID Reset)。设打包后序列中每个词元 i 所属的原始样本编号为 di,则注意力掩码矩阵 M∈{0,−∞}L×L 满足:

Mi,j={0,若 j≤i 且 di=dj−∞,其他情况

同时,每个新样本起始处的位置编码索引重置为 0,1,2,…。借助 FlashAttention 的变长接口(flash_attn_varlen_func)与累积序列长度数组 cu_seqlens,无需显式实例化 O(L2) 的二维掩码矩阵即可实现完全无泄漏的高效打包训练。

4. 灾难性遗忘(Catastrophic Forgetting)与缓解策略 ​

全参数 SFT 在小规模窄分布数据上迭代过多轮次时,权重会向指令分布剧烈漂移,导致模型丧失预训练阶段习得的通用知识、代码能力或推理广度,这一现象称为灾难性遗忘。其数学本质在于参数更新 Δθ 破坏了预训练损失曲面上的低曲率谷底。常见缓解手段包括:

  1. 数据回放与混合(Replay / Mixing):结合预训练数据工程沉淀的语料,在指令数据中混入 5%∼15% 高质量预训练语料或通用问答数据。
  2. 极小学习率与短周期:SFT 的学习率调度峰值通常仅为预训练的 1/10 至 1/20(如 5×10−6∼2×10−5),训练轮数(Epoch)控制在 2∼3 轮。
  3. 正则化与参数高效微调:引入 Weight Decay、NEFTune(Jain et al., 2024 ↗,向词嵌入注入均匀噪声以抑制死记硬背)或改用 LoRA 限制参数更新子空间的秩,再衔接下游 RLHF-PPO 或 DPO 做精细对齐。

算法架构与数据流图 ​

以下流程图展示了从原始多轮对话 JSON 数据到序列打包、Loss Masking 与块对角注意力前向传播的完整数据流:

图表加载中...

复杂度与横向对比表 ​

下表对比了 SFT 训练中常见的数据组织策略与微调范式在效率、显存与效果上的权衡:

策略维度实现方案有效词元吞吐跨样本泄漏风险显存开销典型适用场景
批处理组织朴素 Padding低(常低于 40%)无较高(含大量 Pad 激活)原型验证、长度极均匀数据
批处理组织动态分桶(Length Bucketing)中(65% - 80%)无中等中等规模训练、不支持 varlen 内核时
批处理组织朴素 Packing(无隔离)极高(约 98%)有(污染注意力与位置)低仅推荐用于继续预训练(CPT)
批处理组织隔离 Packing(varlen FlashAttn)极高(约 98%)无(数学严格等价)最低工业级全参数与 LoRA SFT 标准方案
参数更新范围全参数 SFT(Full SFT)基准—极高(约 16x 参数量字节)大规模多领域指令数据(100K+ 样本)
参数更新范围参数高效 SFT(如 LoRA)高(反向计算少)—低(节省优化器状态显存)小样本微调、单卡/少卡垂域适配

核心 PyTorch 参考实现 ​

下面给出包含多轮对话 Loss Masking、Sequence Packing 位置重置、块对角因果注意力掩码构造以及 Token-Level 掩码交叉熵计算的自包含 PyTorch 实现:

python
import torch
import torch.nn.functional as F
from typing import List, Dict, Tuple

IGNORE_INDEX = -100


def build_masked_conversation(
    turns: List[Tuple[List[int], List[int]]],
    bos_id: int,
    eos_id: int,
) -> Dict[str, List[int]]:
    """
    将多轮对话 (prompt_ids, response_ids) 拼接并构造仅监督回复部分的 labels。
    注意:response 末尾的 eos_id 必须参与损失计算,确保模型学会停止生成。
    """
    input_ids: List[int] = [bos_id]
    labels: List[int] = [IGNORE_INDEX]

    for prompt_ids, response_ids in turns:
        # Prompt 部分:labels 全部置为 IGNORE_INDEX
        input_ids.extend(prompt_ids)
        labels.extend([IGNORE_INDEX] * len(prompt_ids))

        # Assistant 回复部分 + EOS:保留真实 token id 作为监督目标
        resp_with_eos = response_ids + [eos_id]
        input_ids.extend(resp_with_eos)
        labels.extend(resp_with_eos)

    return {"input_ids": input_ids, "labels": labels}


def pack_sequences_with_isolation(
    samples: List[Dict[str, List[int]]],
    max_seq_len: int,
    pad_id: int = 0,
) -> Dict[str, torch.Tensor]:
    """
    将多条独立样本打包到定长序列 max_seq_len 中,并生成:
      - position_ids: 每条样本从 0 重新计数
      - doc_ids: 标记词元所属原始样本,用于构造块对角因果掩码
    输出张量形状均为 [max_seq_len] 或 [max_seq_len, max_seq_len]
    """
    packed_input_ids: List[int] = []
    packed_labels: List[int] = []
    packed_pos_ids: List[int] = []
    packed_doc_ids: List[int] = []

    for doc_idx, sample in enumerate(samples):
        seq_len = len(sample["input_ids"])
        if len(packed_input_ids) + seq_len > max_seq_len:
            break
        packed_input_ids.extend(sample["input_ids"])
        packed_labels.extend(sample["labels"])
        packed_pos_ids.extend(range(seq_len))       # 位置索引重置
        packed_doc_ids.extend([doc_idx] * seq_len)  # 记录样本归属

    # 尾部不足 max_seq_len 的部分补齐 Padding(doc_id 设为 -1 表示无效)
    pad_len = max_seq_len - len(packed_input_ids)
    packed_input_ids.extend([pad_id] * pad_len)
    packed_labels.extend([IGNORE_INDEX] * pad_len)
    packed_pos_ids.extend([0] * pad_len)
    packed_doc_ids.extend([-1] * pad_len)

    input_ids_t = torch.tensor(packed_input_ids, dtype=torch.long)     # [L]
    labels_t = torch.tensor(packed_labels, dtype=torch.long)           # [L]
    pos_ids_t = torch.tensor(packed_pos_ids, dtype=torch.long)         # [L]
    doc_ids_t = torch.tensor(packed_doc_ids, dtype=torch.long)         # [L]

    # 构造块对角因果掩码: True 表示允许 attend,形状 [L, L]
    L = max_seq_len
    causal_mask = torch.tril(torch.ones((L, L), dtype=torch.bool))     # j <= i
    same_doc = (doc_ids_t.unsqueeze(1) == doc_ids_t.unsqueeze(0))      # d_i == d_j
    valid_doc = doc_ids_t.unsqueeze(1) >= 0                            # 排除 pad
    attn_mask = causal_mask & same_doc & valid_doc                     # [L, L]

    return {
        "input_ids": input_ids_t,
        "labels": labels_t,
        "position_ids": pos_ids_t,
        "attention_mask": attn_mask,
    }


def compute_sft_token_level_loss(
    logits: torch.Tensor,
    labels: torch.Tensor,
) -> torch.Tensor:
    """
    计算严格移位后的 Token-Level 掩码自回归交叉熵损失。
    logits: [B, L, V]
    labels: [B, L]
    """
    # 自回归预测:位置 t 的 logits 预测位置 t+1 的词元
    shift_logits = logits[:, :-1, :].contiguous()   # [B, L-1, V]
    shift_labels = labels[:, 1:].contiguous()       # [B, L-1]

    # 扁平化后仅对非 IGNORE_INDEX 词元求和,再除以全局有效词元数
    loss_sum = F.cross_entropy(
        shift_logits.view(-1, shift_logits.size(-1)),
        shift_labels.view(-1),
        ignore_index=IGNORE_INDEX,
        reduction="sum",
    )
    valid_tokens = (shift_labels != IGNORE_INDEX).sum().clamp(min=1)
    return loss_sum / valid_tokens


if __name__ == "__main__":
    # 模拟两条不同长度的多轮样本并执行打包与损失计算
    s1 = build_masked_conversation([([10, 11], [20, 21, 22])], bos_id=1, eos_id=2)
    s2 = build_masked_conversation([([30], [40, 41]), ([31, 32], [42])], bos_id=1, eos_id=2)
    packed = pack_sequences_with_isolation([s1, s2], max_seq_len=20)

    B, L, V = 1, 20, 100
    dummy_logits = torch.randn(B, L, V, requires_grad=True)
    loss = compute_sft_token_level_loss(dummy_logits, packed["labels"].unsqueeze(0))
    print(f"Packed valid mask sum: {packed['attention_mask'].sum().item()}, SFT loss: {loss.item():.4f}")

工程实践与常见陷阱 ​

工程实践

  1. 质量远大于数量(Quality over Quantity):在 SFT 阶段,1 万条经过严格人工校对、格式统一、推理链条完整的样本,往往显著优于 100 万条夹杂噪声与错误答案的爬虫数据。使用基于嵌入的语义去重(SemDeDup)和指令难度/多样性分层采样(如 InsTag、DEITA)是提升性价比的标准手段。
  2. 多轮样本中的边界对齐:务必在预处理后随机抽检解码结果,直观打印 label != -100 对应的明文片段,确认所有 Prompt 均被掩蔽、所有回复首尾及 `<|im_end|>` 均被准确覆盖。
  3. 跨样本梯度累积与词元级 Loss:使用 PyTorch / Accelerate 进行梯度累积时,若直接对每个微批次(Micro-batch)求 mean 再除以累积步数,当各微批次有效回复词元数不均时会产生梯度偏差。最佳实践是在累积周期内先汇总分子(loss sum)与分母(有效词元总数),再统一求商。

常见陷阱

  1. BPE 词元边界粘连(Token Boundary Merging):在拼接 Chat Template 与正文时,如果分步分词再拼接与整段一起分词结果不一致(例如换行符 \n 与后续字符合并成一个 BPE 词元),会导致 Loss Mask 错位 1 个词元,严重破坏回复开头质量。应始终基于特殊词元标记进行显式切分或使用官方 apply_chat_template。
  2. 忘记在序列打包中屏蔽跨样本边界标签:在打包后的序列中,样本 A 的最后一个词元(位置 k)在 shift_labels 移位后会尝试预测样本 B 的第一个词元(位置 k+1)。只要样本 B 开头是 BOS 或 Prompt(其 label 为 -100),该跨界预测会被自动屏蔽;但若某样本首词元意外参与监督,则必须在样本拼接边界强制将 labels[start_of_next_doc] = -100。
  3. 过度训练导致模式坍塌与幻觉加剧:若模型在 SFT 集上训练超过 3∼5 个 Epoch,验证集困惑度(Perplexity)往往先降后升,且模型会倾向于对未知事实强行编造符合模板口吻的回答。应同时监控通用基准(如 MMLU、GSM8K)与指令遵循基准(如 IFEval)以防过拟合。

延伸阅读与参考论文 ​

  • Wei, J., Bosma, M., Zhao, V. Y., et al. (2022). Finetuned Language Models Are Zero-Shot Learners (FLAN). ICLR 2022. arXiv:2109.01652 ↗
  • Ouyang, L., Wu, J., Jiang, X., et al. (2022). Training language models to follow instructions with human feedback (InstructGPT). NeurIPS 2022. arXiv:2203.02155 ↗
  • Zhou, C., Liu, P., Xu, P., et al. (2023). LIMA: Less Is More for Alignment. NeurIPS 2023. arXiv:2305.11206 ↗
  • Jain, N., Chiang, P., Wen, Y., et al. (2024). NEFTune: Noisy Embeddings Improve Instruction Finetuning. ICLR 2024. arXiv:2310.05914 ↗
  • Krell, M. M., Kosec, M., Perez, S. P., & Fitzgibbon, A. (2021). Efficient Sequence Packing without Cross-contamination: Accelerating Large Language Models without Impacting Performance. arXiv:2107.02027 ↗