灵魂拷问

预训练完成后，模型能续写文章、补全句子。但如果你输入 "请帮我写一首关于春天的诗"，它可能接着写 "请帮我写一首关于夏天的诗、秋天的诗……"——它在续写，而不是在回答。

当模型不会听话

预训练学会了语言的"形"，SFT 教会模型语言的"用"——什么场合说什么话。

Part 1: 为什么需要 SFT

先搞清楚动机——为什么不直接用预训练模型？SFT 到底改变了什么？

从图书馆到家教

比喻卸甲："图书馆"和"家教"只是为了建立直觉。技术上的区别是训练目标和数据格式——预训练用纯文本做"预测下一个 token"，SFT 用"指令-回答"对且只在回答部分计算 loss（Label Masking）。模型并没有真的"读书"或"被教"，它始终在做同一件事：根据上文预测下一个 token，只是 SFT 调整了它预测的内容偏好。

能力跃迁

核心差异一览

学习率为什么差50倍

定义：学习率控制每次参数更新的步长大小。

白话：预训练就像教一个不会说话的婴儿——大胆学、多犯错没关系。而 SFT 就像教一个已经会弹钢琴的人新的指法——只能微调，改太猛就把原来会的全忘了。

改太猛的后果有个专业名字：灾难性遗忘。模型把预训练学到的语言知识全丢了，SFT 也就白费了。

Part 2: 对话数据格式

先看一眼真实数据长什么样，再去理解代码就轻松多了。

JSONL 多轮对话

定义：SFT 数据使用 JSONL 格式（每行一个 JSON 对象），每条包含一段对话。

白话：就像微信聊天记录的导出——每条消息有发送者（角色）和内容。

比喻卸甲："聊天记录"只是帮助你建立直觉。实质上 JSONL 是一种逐行存储 JSON 对象的文本格式，每行是一个独立的训练样本，没有数据库、没有消息协议，就是纯文本文件。

{
  "conversations": [
    {"role": "user", "content": "请介绍一下中国的四大发明"},
    {"role": "assistant", "content": "中国四大发明分别是造纸术、印刷术、火药和指南针...",
     "reasoning_content": "用户问四大发明，我要简要介绍每一项"}
  ]
}

对话类型一览

角色有四种：system（系统指令）、user（用户）、assistant（助手）、tool（工具）。reasoning_content 字段记录助手的思考过程，可以为空。

多轮对话示例

{
  "conversations": [
    {"role": "system", "content": "你是一个数学老师"},
    {"role": "user", "content": "勾股定理是什么？"},
    {"role": "assistant", "content": "勾股定理：直角三角形两直角边平方和等于斜边平方。即 a² + b² = c²。", "reasoning_content": "用户问基础数学概念"},
    {"role": "user", "content": "举个数字例子？"},
    {"role": "assistant", "content": "比如 3² + 4² = 9 + 16 = 25 = 5²，所以 3、4、5 就是一组勾股数。", "reasoning_content": ""}
  ]
}

一条数据可以包含任意多轮对话。模型会从每一轮助手的回答中学习。

Part 3: Label Masking

这是 SFT 与预训练最本质的区别。搞懂这个机制，就搞懂了 SFT 的一半。

核心问题

设想一个场景：对话数据包含"用户：1+1等于多少？助手：1+1等于2。"

如果让模型学习整个序列，它会学着去预测"1+1等于多少？"——但这是用户说的，不是助手该说的。

我们只想让它学"1+1等于2"这部分。

什么是 Label Masking

定义：Label Masking 是一种训练技巧——把序列中不需要学习的位置的 label 设为 -100，其余位置设为真实 token ID。

白话：就像老师批改试卷时，只批改答案部分，题目部分直接跳过。-100 就是"跳过"的标记。

比喻卸甲："批改试卷"只是直觉。实际机制是 CrossEntropyLoss 的 ignore_index=-100——遇到 -100 的位置直接跳过损失计算，不产生梯度。模型并没有"判断对错"的能力，它只是在被告诉"这些位置不用学"。

可视化：谁学谁不学

多轮对话的 Masking

Part 4：数据变身记

一段对话 JSON 怎么变成模型能吃的 (input_ids, labels) 张量对？关键在于找到 assistant 说话的起止位置，只在那里计算 loss。

构造函数

构造函数完成三件事：加载数据、初始化 tokenizer、预计算定位标记。

class SFTDataset(Dataset):
    def __init__(self, jsonl_path, tokenizer, max_length=1024):
        super().__init__()
        self.tokenizer = tokenizer
        self.max_length = max_length
        features = Features({
            'conversations': [{
                'role': Value('string'),
                'content': Value('string'),
                'reasoning_content': Value('string'),
                'tools': Value('string'),
                'tool_calls': Value('string')
            }]
        })
        self.samples = load_dataset('json', data_files=jsonl_path,
                                     split='train', features=features)
        # 预计算 BOS 和 EOS 标记的 token 序列
        self.bos_id = tokenizer(f'{tokenizer.bos_token}assistant\n',
                                add_special_tokens=False).input_ids
        self.eos_id = tokenizer(f'{tokenizer.eos_token}\n',
                                add_special_tokens=False).input_ids

Features 定义了数据的字段类型，确保 reasoning_content、tools 等可选字段缺失时不会报错。

bos_id 与 eos_id

定义：bos_id 是 <|im_start|>assistant\n 的 token 序列，eos_id 是 <|im_end|>\n 的 token 序列。

白话：它们是"助手回答开始"和"助手回答结束"的定位标记——像书签一样，帮我们在长长的 token 序列中找到"助手到底说了什么"。

这个比喻只是为了帮你建立直观感受。在计算机内部，bos_id/eos_id 实际上是预先编码好的整数列表，在 generate_labels 中用来做子序列匹配，定位 assistant 回答的起止位置。

为什么要预计算

Chat Template

定义：create_chat_prompt 调用 tokenizer 内置的 chat_template，把结构化对话数据转为带特殊标记的文本。

白话：就是翻译官——把"角色+内容"的对话列表翻译成模型能读懂的一整段文字。

比喻卸甲："翻译官"只是直觉。实际是 chat_template 里一段 Jinja2 模板字符串，按固定规则把 role/content 拼接成带 <|im_start|> 等特殊标记的纯文本，没有任何"翻译"智能，纯粹是字符串拼接。

def create_chat_prompt(self, conversations):
    messages = []
    tools = None
    for message in conversations:
        message = dict(message)
        if message.get("role") == "system" and message.get("tools"):
            tools = json.loads(message["tools"])
        if message.get("tool_calls") and isinstance(message["tool_calls"], str):
            message["tool_calls"] = json.loads(message["tool_calls"])
        messages.append(message)
    return self.tokenizer.apply_chat_template(
        messages, tokenize=False,
        add_generation_prompt=False, tools=tools
    )

这个方法会解析 JSON 字符串格式的 tools 和 tool_calls，然后交给 apply_chat_template 统一渲染。

Template 渲染结果

经过 apply_chat_template 后，结构化对话变成了这样的文本：

<|im_start|>system
你是一个知识丰富的AI助手<|im_end|>
<|im_start|>user
什么是光合作用？<|im_end|>
<|im_start|>assistant
<think>
用户在问光合作用，我需要解释清楚
</think>

光合作用是植物利用阳光...<|im_end|>

generate_labels

SFT 最核心的函数——决定了模型学什么、不学什么

def generate_labels(self, input_ids):
    # 第一步：全部初始化为 -100（全部忽略）
    labels = [-100] * len(input_ids)
    i = 0
    while i < len(input_ids):
        # 第二步：找到 '<|im_start|>assistant\n' 的位置
        if input_ids[i:i + len(self.bos_id)] == self.bos_id:
            start = i + len(self.bos_id)  # 跳过 bos 标记本身
            end = start
            # 第三步：找到 '<|im_end|>\n' 的位置
            while end < len(input_ids):
                if input_ids[end:end + len(self.eos_id)] == self.eos_id:
                    break
                end += 1
            # 第四步：将 bos 到 eos 之间的标签设为实际 token
            for j in range(start, min(end + len(self.eos_id), self.max_length)):
                labels[j] = input_ids[j]
            i = end + len(self.eos_id) if end < len(input_ids) else len(input_ids)
        else:
            i += 1
    return labels

算法执行流程

四步拆解

__getitem__ 全流程

每次 DataLoader 取数据时，会调用 __getitem__，串联所有处理步骤：

def __getitem__(self, index):
    # 1. 获取原始数据
    sample = self.samples[index]
    conversations = pre_processing_chat(sample['conversations'])
    # 2. 格式化：将对话转为 chat template 文本
    prompt = self.create_chat_prompt(conversations)
    # 3. 后处理：可能移除空的思考标签
    prompt = post_processing_chat(prompt)
    # 4. 分词 + 截断 + 填充
    input_ids = self.tokenizer(prompt).input_ids[:self.max_length]
    input_ids += [self.tokenizer.pad_token_id] * (self.max_length - len(input_ids))
    # 5. 生成标签（核心步骤！）
    labels = self.generate_labels(input_ids)
    return torch.tensor(input_ids, dtype=torch.long), \
           torch.tensor(labels, dtype=torch.long)

处理流水线全景

注意填充（padding）在 generate_labels 之前执行。所以 pad 部分的 labels 也都是 -100——因为初始值就是 -100，不会被覆盖。

Part 5: 预处理与后处理

数据在送入 tokenizer 之前和之后，还有两道"清洗工序"。它们让模型更鲁棒。

随机系统提示

定义：pre_processing_chat 以 20% 概率为没有 system 消息的对话随机添加系统提示。

白话：不是每条对话都自带系统提示。我们随机"塞"一个进去，让模型学会在有/无系统提示时都能正常回答。

def pre_processing_chat(conversations, add_system_ratio=0.2):
    # 有工具定义的对话不做处理
    if any(conv.get('tools') for conv in conversations):
        return conversations
    SYSTEM_PROMPTS = [
        "你是一个知识丰富的AI，尽力为用户提供准确的信息。",
        "你是minimind，一个小巧但有用的语言模型。",
        "You are a helpful AI assistant.",
        # ... 共 10 条中英文提示
    ]
    if conversations[0].get('role') != 'system':
        if random.random() < add_system_ratio:
            return [{'role': 'system', 'content': random.choice(SYSTEM_PROMPTS)}] + conversations
    return conversations

预处理决策流程

空思考标签处理

定义：post_processing_chat 以 80% 概率移除空思考标签 <think>\n\n</think>\n\n。

白话：当助手没有推理过程时（reasoning_content 为空），模板会生成空的思考标签。80% 的情况下删掉它（更干净），20% 保留（让模型学会"有时不思考就直接回答"）。

def post_processing_chat(prompt_content, empty_think_ratio=0.2):
    if '<think>\n\n</think>\n\n' in prompt_content and random.random() > empty_think_ratio:
        prompt_content = prompt_content.replace('<think>\n\n</think>\n\n', '')
    return prompt_content

Part 6: Thinking 模式

模型可以先"想"再"答"。这个能力来自 DeepSeek-R1 / OpenAI o1 的启发。

思考模式格式

定义：模型在回答之前先进行内部推理，推理过程包裹在 <think>...</think> 标签中。

白话：就像考试时先在草稿纸上算一遍，再往卷子上写答案。

这个比喻只是为了帮你建立直观感受。在计算机内部，Thinking 模式只是在最终回答前多生成了一段 <think> 包裹的文本。这些文本和回答一样，都在 assistant 回答区域内，都会参与训练。

<|im_start|>assistant
<think>
用户问的是勾股定理，我需要给出定义并举例子。
先说定义：a² + b² = c²。
再举个例子：3, 4, 5。
</think>

勾股定理：直角三角形中，两直角边的平方和等于斜边的平方。
例如：3² + 4² = 5²。
<|im_end|>

思考模式的训练

Part 7：训练如何运转

有了前面的知识储备，现在看训练流程就轻松多了。SFT 训练的核心和预训练几乎一样，只多了 Label Masking。

关键超参数

parser.add_argument("--learning_rate", type=float, default=1e-5)   # 比 Pretrain 小 50 倍
parser.add_argument("--epochs", type=int, default=2)               # SFT 通常 2 轮就够
parser.add_argument("--max_seq_len", default=768, type=int)        # 比 Pretrain 的 340 更长
parser.add_argument("--batch_size", type=int, default=16)
parser.add_argument("--accumulation_steps", type=int, default=1)   # 梯度累积
parser.add_argument("--grad_clip", type=float, default=1.0)        # 梯度裁剪
parser.add_argument("--dtype", type=str, default="bfloat16")       # 混合精度
parser.add_argument("--data_path", type=str,
                    default="../dataset/sft_t2t_mini.jsonl")
parser.add_argument("--from_weight", default='pretrain')           # 基于预训练权重！

为什么序列更长

SFT 的 max_seq_len 是 768，而预训练只有 340。为什么？

如果截断太短，助手回答可能被截掉，那 labels 里就没有有效训练信号了。768 是一个平衡值——既覆盖大多数对话，又不浪费太多显存。

训练循环核心

for step, (input_ids, labels) in enumerate(loader):
    input_ids = input_ids.to(args.device)
    labels = labels.to(args.device)

    with autocast_ctx:
        res = model(input_ids, labels=labels)
        loss = res.loss + res.aux_loss
        loss = loss / args.accumulation_steps

    scaler.scale(loss).backward()

    if step % args.accumulation_steps == 0:
        scaler.unscale_(optimizer)
        torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
        scaler.step(optimizer)
        scaler.update()
        optimizer.zero_grad(set_to_none=True)

与预训练的差异

这就是好的架构设计——训练逻辑不变，数据逻辑封装在 Dataset 里。

梯度累积与裁剪

学习率调度

lr = get_lr(epoch * iters + step, args.epochs * iters, args.learning_rate)
for param_group in optimizer.param_groups:
    param_group['lr'] = lr

每一步都会根据当前进度重新计算学习率。通常使用余弦退火（cosine annealing）策略——开始时学习率最大，逐步衰减到接近 0。

这样模型在训练初期学得多、后期学得少，符合"先抓大方向、再打磨细节"的直觉。

Part 8: 续训机制

训练中断了怎么办？MiniMind 内置了断点续训功能。

自动续训

# 命令行参数
parser.add_argument('--from_resume', default=0, type=int,
                    choices=[0, 1], help="是否自动检测并续训")

# 脚本中的续训逻辑
ckp_data = lm_checkpoint(lm_config, weight=args.save_weight,
                          save_dir='../checkpoints') if args.from_resume == 1 else None

start_epoch, start_step = 0, 0
if ckp_data:
    model.load_state_dict(ckp_data['model'])
    optimizer.load_state_dict(ckp_data['optimizer'])
    scaler.load_state_dict(ckp_data['scaler'])
    start_epoch = ckp_data['epoch']
    start_step = ckp_data.get('step', 0)

续训恢复内容

保存检查点

脚本每隔 save_interval 步（默认 1000）保存一次检查点：

if (step % args.save_interval == 0 or step == iters) and is_main_process():
    model.eval()
    # 保存模型权重（FP16 节省空间）
    state_dict = raw_model.state_dict()
    torch.save({k: v.half().cpu() for k, v in state_dict.items()}, ckp)
    # 保存完整检查点（含优化器状态，用于续训）
    lm_checkpoint(lm_config, weight=args.save_weight, model=model,
                  optimizer=optimizer, epoch=epoch, step=step,
                  wandb=wandb, save_dir='../checkpoints', scaler=scaler)
    model.train()

Part 9: 端到端全景

让我们把所有碎片拼起来，看一条数据从原始 JSON 到梯度更新的完整旅程。

训练架构全景

端到端数据追踪

{"conversations": [
  {"role": "user", "content": "1+1等于多少？"},
  {"role": "assistant", "content": "1+1等于2。", "reasoning_content": ""}
]}

完整数据流

Part 10: 动手实践

理论学完了，动手跑一跑才能真正理解。

启动训练

$ cd trainer
$ python train_full_sft.py

默认参数：数据 sft_t2t_mini.jsonl，基于预训练权重，学习率 1e-5，序列长度 768，训练 2 轮。

预期输出：

Epoch:[1/2](1/xxx), loss: 8.xxxx, logits_loss: 8.xxxx, aux_loss: 0.xxxx, lr: 0.00000xxx, epoch_time: xx.xmin

自定义参数

$ python train_full_sft.py \
    --data_path ../dataset/my_sft_data.jsonl \
    --learning_rate 5e-6 \
    --max_seq_len 1024 \
    --epochs 3 \
    --batch_size 8 \
    --accumulation_steps 4 \
    --from_weight pretrain \
    --save_dir ../my_sft_output

准备自己的数据

{"conversations": [{"role": "user", "content": "你好"}, {"role": "assistant", "content": "你好！有什么可以帮助你的吗？", "reasoning_content": ""}]}
{"conversations": [{"role": "system", "content": "你是数学老师"}, {"role": "user", "content": "2×3=？"}, {"role": "assistant", "content": "2×3=6。", "reasoning_content": "简单的乘法"}]}

每行一个 JSON 对象，必须包含 conversations 字段。reasoning_content 可以为空字符串。

练习：手工标注

假设以下是一条经过 chat_template 格式化后的 token 序列（简化表示）：

[<|im_start|>, system, \n, 你是AI助手, <|im_end|>, \n,
 <|im_start|>, user, \n, 什么是光合作用？, <|im_end|>, \n,
 <|im_start|>, assistant, \n, 光合作用是植物利用阳光..., <|im_end|>, \n,
 <pad>, <pad>, <pad>]

[-100, -100, -100, -100, -100, -100,
 -100, -100, -100, -100, -100, -100,
 -100, -100, -100, 光合作用是植物利用阳光..., <|im_end|>, \n,
 -100, -100, -100]

练习：算法跟踪

给定以下 input_ids（简化，每个元素代表一个 token）：

input_ids = [10, 20, 30, 1, 2, 3, 40, 50, 4, 5, 60]
# bos_id = [1, 2, 3]  (代表 <|im_start|>assistant\n)
# eos_id = [4, 5]      (代表 <|im_end|>\n)

[-100, -100, -100, -100, -100, -100, 40, 50, 4, 5, -100]

练习：调参决策

错误诊断：loss 不降

错误诊断：loss 飙升

错误诊断：模型复读

错误诊断：其他问题

常见问题 FAQ

SFT 核心回顾

你学到了什么