LLM 训练流程

┌──────────────┐   ┌──────────────┐   ┌──────────────┐   ┌──────────────┐
│  预训练       │ → │  SFT         │ → │  RM + RLHF   │ → │  部署        │
│  Pre-training │   │  监督微调     │   │  奖励模型     │   │  Deployment  │
│  海量文本     │   │  高质量对答   │   │  人类偏好     │   │  上线服务     │
└──────────────┘   └──────────────┘   └──────────────┘   └──────────────┘
     成本：$$$$$        成本：$$$           成本：$$$           成本：$

问题：基座模型只会"续写文本"，不会"回答问题"

基座模型：给它一个问题，它可能续写成更多问题、写一首诗、或编造答案
它不懂什么是"好的回答"，什么是"有害的回答"

解决：通过多阶段训练逐步塑造模型行为

SFT：教会它"回答问题"的格式
RLHF/DPO：教会它"什么是好的回答"

┌─────────────────────────────────────────────────────────────┐
│                    预训练数据集                                │
│  互联网网页 │ 书籍 │ 代码 │ 维基百科 │ 论文 │ 新闻 ...      │
│  典型规模：数万亿 tokens（GPT-3: 300B tokens）               │
└──────────────────────────┬──────────────────────────────────┘
                           │ 自回归训练（Next-token Prediction）
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                    基座模型 (Base Model)                      │
│  能力：语言理解、知识存储、基础推理                             │
│  缺陷：不会按指令回答、可能编造、格式不可控                      │
└─────────────────────────────────────────────────────────────┘

# ============================================================
# 预训练核心目标：Next-token Prediction（带详细注释）
# 比喻：预训练就像一个人花十年读完整个图书馆——
#       积累了海量知识，语言表达流畅，什么话题都能聊几句
#       但从未学过"怎么当客服"——问它问题可能答非所问
#
# ASCII 流程图：
# ┌─────────────────────────────────────────────┐
# │  海量文本："The capital of France is ___"    │
# │  标签：    "Paris"                           │
# │  模型预测："London" (概率 30%)               │
# │           "Paris"  (概率 60%) ← 正确答案     │
# │           "Berlin" (概率 10%)                │
# │                                              │
# │  损失 = -log(0.6) = 0.51                     │
# │  → 反向传播 → 调整参数 → 让 "Paris" 概率更高  │
# └─────────────────────────────────────────────┘
# ============================================================

# 模拟预训练的简化流程（实际会用 PyTorch/TensorFlow）
import numpy as np

def pretrain_step(model, tokenizer, text, target_next_token):
    """
    预训练的单步训练过程

    参数：
        model: Transformer 模型
        tokenizer: 分词器
        text: 输入文本（如 "The capital of France is"）
        target_next_token: 正确的下一个 Token（如 "Paris"）

    返回：
        loss: 损失值（越小表示模型预测越准）

    关键细节：
        1. 损失函数是交叉熵——衡量模型预测分布与真实分布的差距
        2. 反向传播计算每个参数的梯度
        3. 优化器根据梯度更新参数，使预测更准
    """
    # 第 1 步：分词——把文本切成 Token 序列
    # "The capital of France is" → [464, 3139, 286, 4881, 318]
    input_ids = tokenizer.encode(text)

    # 第 2 步：前向传播——模型预测下一个 Token 的概率分布
    # 输出是词表中每个 Token 的分数（logits），词表通常有 50000+ 个 Token
    logits = model.forward(input_ids)  # shape: [seq_len, vocab_size]
    next_token_logits = logits[-1]     # 只看最后一个位置的预测

    # 第 3 步：Softmax——把分数转成概率分布
    probs = softmax(next_token_logits)  # 每个 Token 的概率，加起来 = 1

    # 第 4 步：计算交叉熵损失
    # 损失 = -log(P(正确答案))
    # 如果模型给 "Paris" 的概率是 60%，损失 = -log(0.6) ≈ 0.51
    # 如果模型给 "Paris" 的概率是 99%，损失 = -log(0.99) ≈ 0.01（很好！）
    target_id = tokenizer.encode(target_next_token)[0]
    loss = -np.log(probs[target_id] + 1e-10)  # 加 1e-10 防止 log(0)

    # 第 5 步：反向传播 + 参数更新
    # 计算每个参数对损失的梯度，然后调整参数使损失变小
    loss.backward()       # 计算梯度
    optimizer.step()      # 更新参数
    optimizer.zero_grad() # 清零梯度（为下一步准备）

    return loss

# --- 训练后的效果 ---
# 模型学会了语言规律和世界知识：
#   "法国的首都" → "巴黎"（知识）
#   "function add(a, b) {" → "return a + b; }"（代码模式）
#   "React 是由" → "Meta（原 Facebook）开发的"（事实）
#
# 但模型不会按指令回答：
#   "请帮我写一个函数" → 可能续写更多问题，而不是写函数
#   这就是为什么需要 SFT 阶段

// 预训练的核心目标：Next-token Prediction
// 给定前文，预测下一个最可能的 token

// 训练过程（伪代码）
for (epoch of epochs) {
  for (batch of trainingData) {
    // 输入：一段文本的前 N 个 token
    const input = "The capital of France is";
    // 标签：第 N+1 个 token（正确答案）
    const target = " Paris";

    // 模型预测下一个 token 的概率分布
    const logits = model.forward(input);

    // 计算交叉熵损失
    const loss = crossEntropy(logits, target);

    // 反向传播更新参数
    loss.backward();
    optimizer.step();
  }
}
// 训练完成后，模型学会了：
// - "法国的首都" → "巴黎"
// - "function add(a, b) {" → "return a + b; }"
// - 但"请帮我写一个函数" → 可能续写更多问题而不是写函数

┌──────────────────────────────────────────┐
│          高质量 SFT 数据集                 │
│  {                                       │
│    "instruction": "解释什么是闭包",       │
│    "input": "",                          │
│    "output": "闭包是指函数能够访问..."    │
│  }                                       │
│  典型规模：1 万 - 10 万条                  │
└─────────────────────┬────────────────────┘
                      │ 监督学习
                      ▼
┌──────────────────────────────────────────┐
│          SFT 模型                        │
│  能力：按指令回答、格式可控、减少幻觉      │
│  仍然存在的问题：回答质量参差不齐           │
└──────────────────────────────────────────┘

# ============================================================
# SFT（监督微调）训练过程（带详细注释）
# 比喻：SFT 就像给新员工做岗前培训——
#       看几百份优秀的"报告范例"，学会按公司规范格式工作
#       关键不是数量（1 万份低质量不如 100 份高质量）
#
# ASCII 流程图：
# ┌─────────────────────────────────────────────┐
# │  基座模型（知识渊博但不会按格式回答）          │
# │       +                                      │
# │  高质量 SFT 数据（指令 → 标准回答）           │
# │       ↓                                      │
# │  监督学习：模型学习生成与标准回答一致的输出    │
# │       ↓                                      │
# │  SFT 模型（会按指令回答，格式可控）            │
# └─────────────────────────────────────────────┘
# ============================================================

# SFT 数据格式（典型的 instruction-following 格式）
sft_dataset = [
    {
        "instruction": "请用简洁的语言解释什么是 React 的虚拟 DOM",
        "input": "",  # 有些任务不需要额外输入
        "output": (
            "虚拟 DOM 是 React 在内存中维护的一棵轻量级 DOM 树副本。"
            "当状态变化时，React 先在虚拟 DOM 上计算差异（Diff），"
            "再将最小变更批量应用到真实 DOM，避免频繁的 DOM 操作带来的性能损耗。"
        ),
    },
    {
        "instruction": "以下代码有什么问题？",
        "input": "const [count, setCount] = useState(0);\nuseEffect(() => {\n  setCount(count + 1);\n});",
        "output": (
            "这段代码会导致无限循环。useEffect 没有依赖数组，每次渲染后都会执行，"
            "而 setCount 触发重新渲染，形成死循环。"
            "修复：添加空依赖数组 `[]` 或指定 `[count]` 作为依赖。"
        ),
    },
    # ... 数万条高质量示例
]

def sft_train_step(model, example):
    """
    SFT 的单步训练过程

    参数：
        model: 基座模型（已预训练，但不会按指令回答）
        example: 一条 SFT 数据 {"instruction": ..., "input": ..., "output": ...}

    返回：
        loss: 损失值

    关键细节：
        1. SFT 只做"格式对齐"，不注入新知识——数据量太少（1-10 万条）
        2. 数据质量远比数量重要——1 万条精心标注 > 100 万条低质量
        3. 损失函数和预训练一样（交叉熵），但只在 output 部分计算
    """
    # 第 1 步：拼接 Prompt
    # 把指令和输入拼成模型能理解的格式
    prompt = (
        f"### 指令：{example['instruction']}\n"
        f"### 输入：{example['input']}\n"
        f"### 回答："
    )

    # 第 2 步：把 prompt + output 拼接成完整的训练序列
    full_text = prompt + example["output"]

    # 第 3 步：分词
    input_ids = tokenizer.encode(full_text)
    prompt_ids = tokenizer.encode(prompt)

    # 第 4 步：前向传播
    logits = model.forward(input_ids)  # [seq_len, vocab_size]

    # 第 5 步：计算损失（只在 output 部分计算，prompt 部分不计算）
    # 这是 SFT 和预训练的关键区别——预训练在整个序列上计算损失
    # SFT 只在"回答"部分计算损失，让模型学习"怎么回答"
    output_logits = logits[len(prompt_ids) - 1 : -1]  # output 部分的预测
    target_ids = input_ids[len(prompt_ids) :]           # output 部分的真实 Token
    loss = cross_entropy(output_logits, target_ids)

    # 第 6 步：反向传播 + 更新参数
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

    return loss

# --- SFT 训练后的效果 ---
# 基座模型（训练前）：
#   输入："什么是闭包？"
#   输出："什么是全局变量？什么是作用域？什么是..."  ← 续写更多问题
#
# SFT 模型（训练后）：
#   输入："什么是闭包？"
#   输出："闭包是指函数能够访问其词法作用域中的变量..."  ← 按格式回答

// SFT 数据格式（典型的 instruction-following 格式）
const sftDataset = [
  {
    instruction: "请用简洁的语言解释什么是 React 的虚拟 DOM",
    input: "",
    output:
      "虚拟 DOM 是 React 在内存中维护的一棵轻量级 DOM 树副本。当状态变化时，React 先在虚拟 DOM 上计算差异（Diff），再将最小变更批量应用到真实 DOM，避免频繁的 DOM 操作带来的性能损耗。",
  },
  {
    instruction: "以下代码有什么问题？",
    input:
      "const [count, setCount] = useState(0);\nuseEffect(() => {\n  setCount(count + 1);\n});",
    output:
      "这段代码会导致无限循环。useEffect 没有依赖数组，每次渲染后都会执行，而 setCount 触发重新渲染，形成死循环。修复：添加空依赖数组 `[]` 或指定 `[count]` 作为依赖。",
  },
  // ... 数万条高质量示例
];

// SFT 训练过程
for (const example of sftDataset) {
  // 拼接 instruction 和 input 作为 prompt
  const prompt = `### 指令：${example.instruction}\n### 输入：${example.input}\n### 回答：`;

  // 模型学习生成与 output 一致的回答
  const loss = computeLoss(model(prompt), example.output);
  loss.backward();
  optimizer.step();
}

┌─────────────────────────────────────────────────────┐
│  步骤 1：收集人类偏好数据                              │
│  人类标注员对模型的多个回答进行排序                      │
│  回答 A > 回答 B > 回答 C（从好到差）                  │
└──────────────────────────┬──────────────────────────┘
                           ▼
┌─────────────────────────────────────────────────────┐
│  步骤 2：训练奖励模型 (Reward Model)                   │
│  输入：(问题, 回答) → 输出：标量分数（奖励值）           │
│  奖励模型学会了判断"什么是好回答"                       │
└──────────────────────────┬──────────────────────────┘
                           ▼
┌─────────────────────────────────────────────────────┐
│  步骤 3：PPO 算法优化策略模型                          │
│  SFT 模型生成回答 → 奖励模型打分 → PPO 更新参数         │
│  目标：最大化奖励分数，同时不偏离 SFT 模型太远           │
└─────────────────────────────────────────────────────┘

// RLHF 的三步流程（伪代码）

// 步骤 1：收集偏好数据
const preferenceData = [
  {
    prompt: "解释什么是闭包",
    chosen: "闭包是指函数能够访问其词法作用域中的变量...",
    rejected: "闭包就是函数里面套函数，外面的变量在里面能用...",
  },
  // ... 数万条偏好对
];

// 步骤 2：训练奖励模型
for (const { prompt, chosen, rejected } of preferenceData) {
  const rewardChosen = rewardModel(prompt, chosen); // 好回答的分数
  const rewardRejected = rewardModel(prompt, rejected); // 差回答的分数

  // 损失函数：好回答的分数应该高于差回答
  const loss = -log(sigmoid(rewardChosen - rewardRejected));
  loss.backward();
  optimizer.step();
}

// 步骤 3：PPO 优化
for (const prompt of prompts) {
  const response = sftModel.generate(prompt); // SFT 模型生成回答
  const reward = rewardModel(prompt, response); // 奖励模型打分
  const klPenalty = klDivergence(sftModel, refModel); // KL 散度惩罚

  // 总奖励 = 奖励模型分数 - KL 惩罚
  // KL 惩罚防止模型偏离 SFT 模型太远（避免 reward hacking）
  const totalReward = reward - beta * klPenalty;

  // PPO 更新策略模型
  ppoUpdate(sftModel, totalReward);
}

RLHF 流程（复杂）：
偏好数据 → 训练奖励模型 → PPO 优化策略模型
   ↑ 需要同时维护 3 个模型，训练不稳定

DPO 流程（简洁）：
偏好数据 → 直接优化策略模型
   ↑ 策略模型 + 冻结的参考模型共 2 个，不需要奖励模型和 PPO 的 critic

// RLHF vs DPO 的核心区别

// ===== RLHF：需要训练奖励模型 =====
// 步骤 1：训练奖励模型
const rewardModel = new RewardModel();
for (const { prompt, chosen, rejected } of preferenceData) {
  const loss = -log(
    sigmoid(rewardModel(prompt, chosen) - rewardModel(prompt, rejected)),
  );
  loss.backward(); // 需要单独训练奖励模型
}

// 步骤 2：PPO 优化
for (const prompt of prompts) {
  const response = policyModel.generate(prompt);
  const reward = rewardModel(prompt, response);
  const klPenalty = klDivergence(policyModel, refModel);
  ppoUpdate(policyModel, reward - beta * klPenalty);
}

// ===== DPO：直接从偏好数据优化 =====
// 不需要奖励模型，直接用偏好数据训练
for (const { prompt, chosen, rejected } of preferenceData) {
  // DPO 损失函数：让 chosen 的概率高于 rejected
  const logProbChosen = policyModel.logProb(prompt, chosen);
  const logProbRejected = policyModel.logProb(prompt, rejected);
  const logProbRefChosen = refModel.logProb(prompt, chosen);
  const logProbRefRejected = refModel.logProb(prompt, rejected);

  // DPO 损失：隐式地最大化 chosen 和 rejected 的概率差
  const loss = -log(
    sigmoid(
      beta *
        (logProbChosen -
          logProbRefChosen -
          (logProbRejected - logProbRefRejected)),
    ),
  );
  loss.backward();
  optimizer.step();
}

全量微调：更新模型所有参数
┌──────────────────────────────┐
│  原始权重 W (冻结)             │
│  ΔW = 所有参数都在更新         │  ← 需要巨大显存
└──────────────────────────────┘

LoRA：只更新低秩适配器
┌──────────────────────────────┐
│  原始权重 W (冻结)             │
│  ΔW = B × A (低秩矩阵)       │  ← 只需少量显存
│  A ∈ R^(r×k), B ∈ R^(d×r)   │
│  r << min(d, k)  通常 r=8    │
└──────────────────────────────┘

// LoRA 的核心原理（伪代码）

// 原始模型的前向传播
// output = W × input  （W 是预训练权重，d×k 矩阵）

// LoRA 修改后的前向传播
// output = W × input + (B × A) × input
// 其中：
//   W 冻结不动（不参与训练）
//   A ∈ R^(r×k)  降维矩阵（随机初始化）
//   B ∈ R^(d×r)  升维矩阵（零初始化）
//   r << min(d, k)  典型值 r = 8

// 具体数字（7B 参数模型为例）
// 原始权重矩阵：4096 × 4096 = 16,777,216 参数
// LoRA (r=8)：8 × (4096 + 4096) = 65,536 参数
// 参数减少：99.6%！

// QLoRA：在 LoRA 基础上加 4-bit 量化
// 原始权重用 4-bit 存储（而非 16-bit/32-bit）
// 显存需求从 ~14GB 降到 ~5GB（7B 模型）
// 可以在单张 RTX 3090/4090 上微调 7B 模型

// 微调数据格式（以代码审查为例）
const fineTuneData = [
  {
    // 任务：代码审查
    instruction: "审查以下 React 组件的性能问题",
    input: `function UserList({ users }) {
  return (
    <div>
      {users.map(user => (
        <div key={user.id}>
          <img src={user.avatar} />
          <span>{user.name}</span>
          <span>{user.email}</span>
        </div>
      ))}
    </div>
  );
}`,
    output: `发现以下性能问题：

1. **缺少 memo 化**：UserList 组件在父组件重渲染时会无条件重渲染。
   建议：用 React.memo 包裹组件。

2. **列表项缺少 memo 化**：每个 UserItem 在父组件更新时都会重渲染。
   建议：将列表项抽为独立组件并用 React.memo 包裹。

3. **img 缺少 loading 属性**：大量头像同时加载可能阻塞首屏。
   建议：添加 loading="lazy"。

修复后的代码：
\`\`\`jsx
const UserItem = React.memo(function UserItem({ user }) {
  return (
    <div>
      <img src={user.avatar} loading="lazy" />
      <span>{user.name}</span>
      <span>{user.email}</span>
    </div>
  );
});

const UserList = React.memo(function UserList({ users }) {
  return (
    <div>
      {users.map(user => (
        <UserItem key={user.id} user={user} />
      ))}
    </div>
  );
});
\`\`\``,
  },
  // ... 更多高质量示例
];

// LoRA 在 Attention 层的实现（简化伪代码）
class LoRALinear {
  constructor(originalWeight, rank = 8, alpha = 16) {
    this.originalWeight = originalWeight; // 冻结的原始权重
    this.originalWeight.requiresGrad = false;

    // 低秩矩阵
    const d = originalWeight.shape[0]; // 输出维度
    const k = originalWeight.shape[1]; // 输入维度

    this.A = randomNormal(rank, k) * 0.01; // 降维矩阵（随机初始化）
    this.B = zeros(d, rank); // 升维矩阵（零初始化）
    this.scaling = alpha / rank; // 缩放因子
  }

  forward(x) {
    // 原始输出 + LoRA 输出
    const originalOutput = matmul(this.originalWeight, x);
    const loraOutput = matmul(this.B, matmul(this.A, x)) * this.scaling;
    return originalOutput + loraOutput;
  }

  merge() {
    // 训练完成后合并权重，推理时无额外开销
    return this.originalWeight + matmul(this.B, this.A) * this.scaling;
  }
}