AI/ML 详解：预训练与微调

就像让一个新人把整个互联网"读一遍"——只做一个动作：看前文猜下一个词。猜对/猜错都不评价对错，只校准它对"世界文本规律"的直觉。

如果对每个任务（翻译、问答、写代码）都从零训一个模型，每次都要重新教模型"什么是英语、什么是句子、什么是事实"，成本和数据需求都不现实。预训练把"语言+常识"作为一个共享的底座一次性学好，下游任务只需要在这个底座上做小量的"专科训练"。这就是基础模型（Foundation Model）的核心思路。

核心任务非常朴素：给前 N 个 token，预测第 N+1 个 token。然后用预测和真实 token 的差距做梯度下降。重复亿万亿次。

# 伪代码：预训练的一个 step
text = sample_from_internet()              # 大杂烩：网页/书/代码/论文
tokens = tokenize(text)                    # 切成 token 序列
for i in range(len(tokens) - 1):
    pred = model(tokens[:i+1])             # 模型预测下一个 token 的概率分布
    loss = cross_entropy(pred, tokens[i+1])# 预测错了多少
    loss.backward(); optimizer.step()      # 调一点点参数

规模决定能力：数据量从 GB→TB，参数量从亿→千亿，"涌现"出来的能力（推理、写代码）就出现了。

# 用 Hugging Face 体会预训练目标：模型给每个位置算下一个 token 的概率
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tok = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

inputs = tok("The capital of France is", return_tensors="pt")
with torch.no_grad():
    logits = model(**inputs).logits        # [1, seq_len, vocab_size]
next_id = logits[0, -1].argmax()           # 选最可能的下一个 token
print(tok.decode(next_id))                  # " Paris"

• Karpathy："Let's build GPT" YouTube 视频（2 小时手撸一个迷你 GPT，最佳入门）
• Hugging Face："How does a language model work" 章节

经典：GPT-2/3、Llama 系列的"base 模型"就是只做了预训练。
贴近你：当你看到 llama-3-8b（无 instruct 后缀），那就是预训练裸模型；做投资研报续写、生成数据这种"补全式任务"反而比 chat 模型更直接。

就像给应届生发一本《标准回答示例集》，让他照着抄一千遍——目的是把"会续写"的模型，调教成"会按指令回答"的助手。

预训练完的模型只会续写，它不知道"请翻译这段话"该输出译文而不是一段评论。SFT 用人工写好的「指令-回答」对，把模型的输出风格切到"听话、有用、格式整齐"的轨道上。这一步把 base model 变成 instruct model（指令模型），是所有 ChatGPT/Claude 类产品落地的第一步。

训练目标和预训练完全一样（预测下一个 token），变的只是数据：从"互联网杂文"变成"高质量指令-回答对"。

# 数据样本长这样：
{
  "instruction": "用一句话解释什么是缓存",
  "response":   "缓存是把昂贵计算的结果暂存起来，下次直接复用。"
}
# 训练时拼成：
prompt = "<|user|>用一句话解释什么是缓存<|assistant|>"
target = prompt + response
# 关键：只在 response 部分计算 loss，prompt 部分不学
loss = cross_entropy(model(target), target, mask=is_response_token)

通常 1 万~100 万条精挑细选的样本就能让模型脱胎换骨。质量 >> 数量。

# 用 trl 库做一次最简单的 SFT，<= 20 行
from datasets import load_dataset
from trl import SFTTrainer, SFTConfig
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "meta-llama/Llama-3.2-1B"
tok   = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
ds    = load_dataset("HuggingFaceH4/ultrachat_200k", split="train_sft[:1000]")

trainer = SFTTrainer(
    model=model, tokenizer=tok, train_dataset=ds,
    args=SFTConfig(output_dir="sft-llama", num_train_epochs=1,
                   per_device_train_batch_size=2, learning_rate=2e-5),
)
trainer.train()                            # 跑完模型就会"听话"了

• Hugging Face TRL 文档：huggingface.co/docs/trl（SFT/DPO/PPO 全套高层 API）
• Sebastian Raschka 博客："Practical Tips for Fine-tuning LLMs"

经典：InstructGPT、Alpaca、Llama-3-Instruct。
贴近你：给"育儿助手"做 SFT——用 500 条「家长问题 → 你认可的回答风格」的样本，模型就会用你想要的语气和深度回答，而不是空话套话。

就像 App Store 评分系统：让人对模型的两个回答打"哪个更好"，训出一个"评分员模型"，然后让主模型反复刷分——逐渐学会输出人类更喜欢的回答。

SFT 教模型"模仿示范回答"，但很多东西没法用标准答案表达：什么叫"礼貌但不啰嗦"？什么叫"有用但不越界"？人类自己写示例既慢又不一致，但比较两个回答"哪个更好"很容易。RLHF 把"难写示例"的问题转成"易做选择"的问题，是 ChatGPT 第一次让大众感觉"AI 真懂事"的关键。

三步走，每一步都是独立的训练：

# Step 1: SFT 模型已就绪（上一张卡片）

# Step 2: 训练奖励模型（Reward Model, RM）
for (prompt, response_A, response_B, human_pref) in pref_data:
    score_A = reward_model(prompt, response_A)
    score_B = reward_model(prompt, response_B)
    # 让"人类偏好那个"的分数更高
    loss = -log(sigmoid(score_chosen - score_rejected))

# Step 3: 用 PPO 算法让主模型刷高 RM 的分
for prompt in prompts:
    response = sft_model.generate(prompt)
    reward   = reward_model(prompt, response)        # 评分员打分
    # PPO：朝着高分方向更新，但不能偏离 SFT 太远（KL 惩罚）
    sft_model.ppo_step(reward, kl_penalty=0.1)

那个 KL 惩罚很重要——没它的话模型会学会"奖励黑客"：输出一堆奇怪但 RM 喜欢的话术。

# trl 的 PPOTrainer 把三步骤封装好了（这里只展示第 3 步骨架）
from trl import PPOTrainer, PPOConfig
from transformers import pipeline

reward = pipeline("text-classification", model="my-reward-model")
ppo = PPOTrainer(config=PPOConfig(batch_size=8),
                 model=sft_model, tokenizer=tok)

for batch in dataloader:
    responses = ppo.generate(batch["prompt"])
    # RM 打分，分数越高代表越符合人类偏好
    scores = [reward(p + r)[0]["score"] for p, r in zip(batch["prompt"], responses)]
    ppo.step(batch["prompt"], responses, scores)

• Hugging Face 博客："Illustrating RLHF"（图最清楚的入门）
• Chip Huyen："RLHF: Reinforcement Learning from Human Feedback"

经典：ChatGPT、Claude、Gemini 都用了 RLHF（或其变体）。
贴近你：你给团队 AI 助手做内部"点赞/点踩"按钮，积累足够数据后训一个 RM，再去 PPO 优化主模型——这就是把内部协作偏好沉淀进模型的标准做法。

就像把 RLHF 的"训评分员 + PPO 刷分"两步合并成一个 SQL：直接用偏好数据一步调参，省掉奖励模型、省掉强化学习、训练像 SFT 一样稳定。

RLHF 的痛点有三个：(1) 要训两个模型（RM + policy），机器和工程量翻倍；(2) PPO 调参玄学，不稳定，容易崩；(3) 中间多了 RM 这层近似，可能引入偏差。DPO（2023 年 Stanford 提出）从数学上证明：在某些假设下，"最大化奖励"等价于一个非常简单的分类损失，可以跳过 RM 和 RL 直接用偏好对训练。结果：训练成本砍半，稳定性大幅提升。

核心想法：对每条偏好数据，让"赢家"在新模型下的概率比在旧模型下涨，让"输家"反之。

# 训练数据：(prompt, chosen, rejected) 三元组
for (prompt, chosen, rejected) in data:
    # 新模型给 chosen 的对数概率 - 参考模型(SFT)给 chosen 的对数概率
    log_ratio_chosen   = log P_new(chosen|prompt)   - log P_ref(chosen|prompt)
    log_ratio_rejected = log P_new(rejected|prompt) - log P_ref(rejected|prompt)
    # 让 chosen 的提升量 > rejected 的提升量
    loss = -log(sigmoid(beta * (log_ratio_chosen - log_ratio_rejected)))

一句话翻译：新模型相比 SFT 模型，应当更喜欢 chosen、更不喜欢 rejected。就这么直接，没有 RM、没有 PPO、没有采样、没有奖励黑客的烦恼。

# trl 的 DPOTrainer，接口和 SFTTrainer 一样简单
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset

# 偏好数据：每条有 prompt / chosen / rejected 三个字段
ds = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = DPOTrainer(
    model=sft_model,                       # 上一步 SFT 完的模型
    ref_model=sft_model,                   # 参考模型（冻结）
    train_dataset=ds, tokenizer=tok,
    args=DPOConfig(beta=0.1, num_train_epochs=1,
                   learning_rate=5e-7, output_dir="dpo-llama"),
)
trainer.train()                            # 跑完，效果约等于 RLHF，工程量小很多

• 原论文友好讲解：HF Blog "Preference Tuning LLMs"
• Sebastian Raschka："LLM Training: RLHF and Its Alternatives"

经典：Llama-3-Instruct、Zephyr、Tulu 系列都用 DPO。
贴近你：你想给"投研分析助手"做对齐——攒 2000 条「同一个问题的两份回答 + 你选哪个更专业」，用 DPO 微调，单卡几小时跑完，效果常常打平 RLHF。