reorganize configs into subdirs lm/vlm/vam, remove runs/, add interview docs for pretrain & full_sft

README.md

@@ -67,18 +67,15 @@ src/
 │   └── checkpoint.py  # checkpoint 读写辅助
 ├── serve/            # 实时语音会话（SileroVAD / RealtimeSession）
 configs/
-├── lm.yaml           # 纯文本训练配置
-├── lm_moe.yaml       # 纯文本 MoE 训练配置
+├── lm_full_sft.yaml       # 纯文本 SFT 训练配置
+├── lm_full_sft_moe.yaml   # 纯文本 MoE SFT 训练配置
+├── lm_pretrain.yaml       # 纯文本预训练配置
+├── lm_pretrain_moe.yaml   # 纯文本 MoE 预训练配置
 ├── vlm.yaml          # 视觉多模态训练配置
-├── vlm_moe.yaml      # 视觉多模态 MoE 训练配置
-├── vam.yaml          # 全模态训练配置
-├── vam_moe.yaml      # 全模态 MoE 训练配置
+├── lm/               # 纯文本 LM 配置
+├── vlm/              # 视觉多模态 VLM 配置
+├── vam/              # 全模态 VAM 配置
 └── tokenizer/        # tokenizer.json / tokenizer_config.json
-runs/                # 根目录可直接运行的训练启动脚本（默认加载对应 configs/*.yaml）
-├── train_lm.sh      # bash runs/train_lm.sh  -> configs/lm.yaml
-├── train_vlm.sh     # bash runs/train_vlm.sh -> configs/vlm.yaml
-├── train_vam.sh     # bash runs/train_vam.sh -> configs/vam.yaml
-└── train_tokenizer.sh  # bash runs/train_tokenizer.sh -> 训练 tokenizer，保存到 checkpoint/tokenizer/
 scripts/              # 推理 / 服务 / 转换脚本
 ├── eval_llm.py      # 命令行推理与对话
 ├── eval_vlm.py      # 视觉多模态推理
@@ -102,20 +99,79 @@ pip install -e ".[rl,serve,demo]"
 
 ### 训练（YAML 驱动）
 
-根目录 `runs/` 提供可直接运行的 `.sh` 启动脚本，默认加载 `configs/` 下对应的 YAML，
-也可通过 `--config` 指定其它配置，任意 CLI 参数都能覆盖 YAML 中的默认值：
+训练入口统一为 `python -m trainers.<包>.<脚本>`，通过 `--config` 指定 YAML 配置，
+任意 CLI 参数都能覆盖 YAML 中的默认值：
+
+#### 纯文本 LM
+
+```bash
+# 预训练（从头训练语言模型）
+python -m trainers.lm.pretrain --config configs/lm/lm_pretrain.yaml
+
+# 全量 SFT（以预训练权重初始化，指令微调）
+python -m trainers.lm.full_sft --config configs/lm/lm_full_sft.yaml
+
+# 训练 tokenizer（学习用，MiniMind 已自带）
+python -m trainers.lm.train_tokenizer --data_path dataset/sft_t2t_mini.jsonl \
+                                      --vocab_size 6400 \
+                                      --checkpoint_dir ./checkpoint \
+                                      --no_eval
+
+# LoRA 微调
+python -m trainers.lm.lora_sft --config configs/lm/lm_full_sft.yaml
+
+# DPO / PPO / GRPO 偏好对齐
+python -m trainers.lm.dpo   --config configs/lm/lm_full_sft.yaml
+python -m trainers.lm.ppo   --config configs/lm/lm_full_sft.yaml
+python -m trainers.lm.grpo  --config configs/lm/lm_full_sft.yaml
+
+# 知识蒸馏
+python -m trainers.lm.distill --teacher <teacher_path> --config configs/lm/lm_full_sft.yaml
+
+# MoE 变体
+python -m trainers.lm.full_sft --config configs/lm/lm_full_sft_moe.yaml
+python -m trainers.lm.pretrain --config configs/lm/lm_pretrain_moe.yaml
+
+# Mini 变体（快速验证用，h=128, L=4, ~14min pretrain）
+python -m trainers.lm.pretrain --config configs/lm/lm_pretrain_mini.yaml
+python -m trainers.lm.full_sft --config configs/lm/lm_full_sft_mini.yaml
+```
+
+#### 视觉多模态 VLM
+
+```bash
+# 预训练（视觉模态对齐）
+python -m trainers.vlm.pretrain --config configs/vlm/vlm.yaml
+
+# 全量 SFT
+python -m trainers.vlm.full_sft --config configs/vlm/vlm.yaml
+python -m trainers.vlm.full_sft --config configs/vlm/vlm_moe.yaml   # MoE 变体
+```
+
+#### 全模态 VAM（文本 + 视觉 + 语音）
+
+```bash
+# 全量 SFT
+python -m trainers.vam.full_sft --config configs/vam/vam.yaml
+python -m trainers.vam.full_sft --config configs/vam/vam_moe.yaml   # MoE 变体
+```
+
+#### 常用覆盖参数
 
 ```bash
-bash runs/train_tokenizer.sh --data_path dataset/sft_t2t_mini.jsonl \
-                             --vocab_size 6400 \
-                             --checkpoint_dir ./checkpoint \
-                             --no_eval
+# 覆盖任意 YAML 字段
+python -m trainers.lm.full_sft --config configs/lm/lm_full_sft.yaml \
+                               --epochs 3 --batch_size 8 --learning_rate 5e-6
 
-bash runs/train_lm.sh                                  # 使用 configs/lm.yaml
-bash runs/train_vlm.sh --config configs/vlm_moe.yaml
-bash runs/train_vam.sh --epochs 5                      # 在 vam.yaml 基础上覆盖单字段
+python -m trainers.vam.full_sft --config configs/vam/vam.yaml --epochs 5
 
+# 指定 checkpoint 目录
+python -m trainers.lm.full_sft --config configs/lm/lm_full_sft.yaml \
+                               --save_dir checkpoint/my_exp
 
+# 多卡 DDP 训练（torchrun）
+torchrun --nproc_per_node=4 -m trainers.lm.pretrain --config configs/lm/lm_pretrain.yaml
+torchrun --nproc_per_node=4 -m trainers.lm.full_sft --config configs/lm/lm_full_sft.yaml
 ```
 
 ### 推理 / 对话

configs/{lm.yaml → lm/lm_full_sft.yaml}

@@ -19,8 +19,9 @@ train:
   save_interval: 1000
   log_interval: 100
   from_weight: pretrain   # none / pretrain / full_sft
+  model_dir: checkpoint/lm_pretrain
   from_resume: 0
 
 paths:
   save_dir: checkpoint/lm
-  data_path: dataset/sft.jsonl
+  data_path: dataset/sft_t2t_mini.jsonl

configs/lm/lm_full_sft_mini.yaml

@@ -0,0 +1,27 @@
+# LM SFT 配置（小模型快速微调，使用 lm_pretrain_mini 的预训练权重）
+model:
+  hidden_size: 128
+  num_hidden_layers: 4
+  use_moe: 0
+  vocab_size: 6400
+  max_seq_len: 768
+  num_attention_heads: 8
+  num_key_value_heads: 4
+  dropout: 0.0
+
+train:
+  epochs: 1
+  batch_size: 32
+  learning_rate: 1.0e-5
+  accumulation_steps: 1
+  grad_clip: 1.0
+  dtype: bfloat16
+  save_interval: 500
+  log_interval: 50
+  from_weight: pretrain
+  model_dir: checkpoint/lm_pretrain_mini
+  from_resume: 0
+
+paths:
+  save_dir: checkpoint/lm_full_sft_mini
+  data_path: dataset/sft_t2t_mini.jsonl

configs/lm/lm_pretrain.yaml

@@ -0,0 +1,26 @@
+# LM 预训练配置（纯文本语言模型，从头训练）
+model:
+  hidden_size: 512
+  num_hidden_layers: 8
+  use_moe: 0            # 1 启用 MoE
+  vocab_size: 6400
+  max_seq_len: 340
+  num_attention_heads: 8
+  num_key_value_heads: 4
+  dropout: 0.0
+
+train:
+  epochs: 2
+  batch_size: 32
+  learning_rate: 5.0e-4
+  accumulation_steps: 8
+  grad_clip: 1.0
+  dtype: bfloat16
+  save_interval: 1000
+  log_interval: 100
+  from_weight: none      # 从头开始预训练
+  from_resume: 0
+
+paths:
+  save_dir: checkpoint/lm_pretrain
+  data_path: dataset/pretrain_t2t_mini.jsonl

configs/lm/lm_pretrain_mini.yaml

@@ -0,0 +1,26 @@
+# LM 预训练配置（小模型快速验证，~30分钟跑完）
+model:
+  hidden_size: 128
+  num_hidden_layers: 4
+  use_moe: 0
+  vocab_size: 6400
+  max_seq_len: 256
+  num_attention_heads: 8
+  num_key_value_heads: 4
+  dropout: 0.0
+
+train:
+  epochs: 1
+  batch_size: 96
+  learning_rate: 5.0e-4
+  accumulation_steps: 1
+  grad_clip: 1.0
+  dtype: bfloat16
+  save_interval: 500
+  log_interval: 50
+  from_weight: none
+  from_resume: 0
+
+paths:
+  save_dir: checkpoint/lm_pretrain_mini
+  data_path: dataset/pretrain_t2t_mini.jsonl

configs/lm/lm_pretrain_moe.yaml

@@ -0,0 +1,31 @@
+# LM-MoE 预训练配置（纯文本语言模型，启用 MoE，从头训练）
+model:
+  hidden_size: 512
+  num_hidden_layers: 8
+  use_moe: 1            # 1 启用 MoE
+  num_experts: 4
+  num_experts_per_tok: 1
+  moe_intermediate_size: 1408
+  norm_topk_prob: true
+  router_aux_loss_coef: 5.0e-4
+  vocab_size: 6400
+  max_seq_len: 340
+  num_attention_heads: 8
+  num_key_value_heads: 4
+  dropout: 0.0
+
+train:
+  epochs: 2
+  batch_size: 32
+  learning_rate: 5.0e-4
+  accumulation_steps: 8
+  grad_clip: 1.0
+  dtype: bfloat16
+  save_interval: 1000
+  log_interval: 100
+  from_weight: none      # 从头开始预训练
+  from_resume: 0
+
+paths:
+  save_dir: checkpoint/lm_pretrain_moe
+  data_path: dataset/pretrain_t2t_mini.jsonl

docs/architecture/overview.md

@@ -41,10 +41,9 @@ input_ids
 ## 4. 训练入口
 
 ```
-runs/
-├── lm.sh    → python -m trainers.lm.full_sft   --config configs/lm.yaml
-├── vlm.sh   → python -m trainers.vlm.full_sft  --config configs/vlm.yaml
-└── vam.sh   → python -m trainers.vam.full_sft  --config configs/vam.yaml
+python -m trainers.lm.full_sft   --config configs/lm/lm_full_sft.yaml
+python -m trainers.vlm.full_sft  --config configs/vlm/vlm.yaml
+python -m trainers.vam.full_sft  --config configs/vam/vam.yaml
 ```
 
 配置读取：`utils.training.apply_config(parser, default_config)` 把 YAML 的

docs/interview/full_sft.md

@@ -0,0 +1,528 @@
+# 面试：全量微调（Full SFT）深度
+
+> 本仓库 `src/trainers/lm/full_sft.py`，对应 config：`configs/lm/lm_full_sft.yaml`
+
+## 0. 整体流程
+
+```
+数据集 (sft_t2t_mini.jsonl)
+    │  60,000 条多轮对话
+    ▼
+SFTDataset
+    ├── 解析 JSON 对话格式
+    ├── 拼接多轮对话（含 <s>system</s> <s>user</s> <s>assistant</s> 标记）
+    ├── input_ids：全部 token 的 id
+    ├── labels：prompt 段 → -100，assistant 段 → input_ids
+    └── 截断 / 填充到 max_seq_len
+    │
+    ▼
+DataLoader → model(input_ids, labels)
+    │
+    ├── 🔥 加载预训练权重（from_weight=pretrain）
+    │    └── model_dir 指定权重源目录
+    │
+    ├── 全量参数更新（所有参数参与训练）
+    │
+    └── Loss = CE(shift_logits, shift_labels)
+        只计算 labels != -100 的位置
+    │
+    ▼
+    AdamW + Cosine LR → 保存 checkpoint
+```
+
+---
+
+## Q1. SFTDataset 如何处理多轮对话？
+
+### 输入格式
+
+```json
+{
+  "conversations": [
+    {"from": "system", "value": "你是一个 AI 助手"},
+    {"from": "user",  "value": "你好"},
+    {"from": "assistant", "value": "你好！有什么可以帮你的？"},
+    {"from": "user",  "value": "什么是 LLM？"},
+    {"from": "assistant", "value": "LLM 是大型语言模型..."}
+  ]
+}
+```
+
+### 编码拼接（`src/dataset/sft.py`）
+
+```python
+def _build_conversation(self, conversation):
+    input_ids, labels = [], []
+    for turn in conversation:
+        speaker = turn['from']
+        text = turn['value']
+        # 用特殊标记包裹每条发言
+        tokens = self.tokenizer.encode(f'<s>{speaker}</s>\n{text}\n')
+        if speaker == 'assistant':
+            input_ids += tokens
+            labels   += tokens                     # 回复段参与损失
+        else:
+            input_ids += tokens
+            labels   += [-100] * len(tokens)       # prompt 段忽略损失
+    return input_ids[:self.max_length], labels[:self.max_length]
+```
+
+### 为什么 prompt 段 label 置 -100？
+
+- `nn.CrossEntropyLoss(ignore_index=-100)` 自动忽略这些位置的损失
+- **只学习回复内容**：模型只需要学会生成 assistant 的回答，不需要拟合用户的输入
+- **保持 prompt 长度灵活性**：不需要 mask attention，只是不算损失
+
+### 极端情况
+
+如果整条对话 `max_seq_len` 截断后只包含 prompt 段（user 说的话），那么所有的 labels 都是 -100，loss = 0。这种情况虽然罕见但需要注意——数据预处理时应该过滤掉这种样本。
+
+> 面试点：如果一条对话全部被截断为 prompt 端怎么办？→ loss=0，该样本对训练无贡献；需要在数据预处理时过滤或截断时尽量保留 assistant 段
+
+---
+
+## Q2. 加载预训练权重机制
+
+### 权重加载流程
+
+```
+1. from_weight=pretrain
+       │
+2. 确定权重路径：
+   model_dir / from_weight_hidden_size.pth
+   → checkpoint/lm_pretrain/pretrain_512.pth
+       │
+3. torch.load(..., map_location=device)
+       │
+4. model.load_state_dict(weights, strict=False)
+       │
+5. 选择不加载 lm_head.weight（可选）
+```
+
+### 代码实现
+
+```python
+# src/utils/training.py:145-168
+def init_model(config, save_dir, weight_type='pretrain', model_dir=None):
+    if weight_type != 'none':
+        weight_dir = model_dir or save_dir              # model_dir 优先
+        weight_path = f'{weight_dir}/{weight_type}_{config.hidden_size}.pth'
+        weights = torch.load(weight_path, map_location=device)
+        # 可选择跳过 lm_head（如新增词表时）
+        # weights = {k: v for k, v in weights.items() if 'lm_head' not in k}
+        model.load_state_dict(weights, strict=False)
+```
+
+### model_dir vs save_dir
+
+| 参数 | 作用 | 默认值 |
+|---|---|---|
+| `save_dir` | checkpoint 写入目录 | 配置中的 `paths.save_dir` |
+| `model_dir` | checkpoint 读取目录 | 未设置时 = save_dir |
+
+为什么要分开？
+- pretrain 权重存在 `checkpoint/lm_pretrain/`
+- SFT 权重存在 `checkpoint/lm/`
+- SFT 需要从 pretrain 目录**加载**，但**保存**到自己目录
+- 没有 `model_dir` 时会在 `checkpoint/lm/` 下找 `pretrain_512.pth`，找不到
+
+### 不同 from_weight 的语义
+
+| from_weight | 用途 | 加载的文件 |
+|---|---|---|
+| `none` | 从头训练 | 不加载（随机初始化） |
+| `pretrain` | pretrain → SFT 持续训练 | `pretrain_{h}.pth` |
+| `full_sft` | SFT 继续训练/增量 SFT | `full_sft_{h}.pth` |
+
+### strict=False 的注意事项
+
+- 允许权重文件和模型结构**不完全一致**
+- 常见的 mismatch 来源：
+  1. embedding 和 lm_head 的 weight tying（两个 key 映射到同一个参数字典）
+  2. 词表大小变化（新增 special token 后加载旧权重）
+  3. 模型架构微调（如增减层数）
+- `strict=False` 会静默忽略多出的键（缺少的键会随机初始化）
+
+> 面试点：strict=False 实际可能导致模型部分随机初始化而不报错，如何确保没有遗漏？→ 加载后比较 `model.state_dict().keys()` 和 `weights.keys()`，打印 missing_keys 和 unexpected_keys
+
+---
+
+## Q3. SFT 训练流程详解
+
+### 训练循环（`src/trainers/lm/full_sft.py`）
+
+```python
+def train_epoch(epoch, model, loader, optimizer, scheduler, scaler, args):
+    model.train()
+    total_loss = 0
+    for step, (input_ids, labels) in enumerate(loader):
+        input_ids = input_ids.cuda()
+        labels = labels.cuda()
+
+        with autocast_ctx:
+            logits = model(input_ids)
+            loss = cross_entropy(logits[..., :-1, :].contiguous(),
+                                 labels[..., 1:].contiguous(),
+                                 ignore_index=-100)
+            loss = loss / args.accumulation_steps
+
+        scaler.scale(loss).backward()
+
+        if (step + 1) % args.accumulation_steps == 0:
+            scaler.unscale_(optimizer)
+            clip_grad_norm_(model.parameters(), args.grad_clip)
+            scaler.step(optimizer)
+            scaler.update()
+            optimizer.zero_grad(set_to_none=True)
+            scheduler.step()
+
+        total_loss += loss.item()
+```
+
+### 与 Pretrain 训练循环的区别
+
+| | Pretrain | Full SFT |
+|---|---|---|
+| 是否加载预训练权重 | 否（from_weight=none） | 是（from_weight=pretrain） |
+| 学习率 | 5e-4（从零学习） | 1e-5（微调，小 lr） |
+| 训练轮数 | 2 | 2 |
+| 数据集 | 纯文本 1.27M 条 | 指令对话 60K 条 |
+| loss 计算 | 全 token | 仅 assistant 段 |
+| weight_decay | 有 | 有（默认 0.1） |
+
+### 为什么 SFT 学习率要小？
+
+- 预训练权重已经学到很好的语言表示
+- 大学习率会破坏/覆盖预训练知识（灾难性遗忘）
+- 目标是在已有知识基础上"微调"指令跟随能力
+- 一般 pretrain LR : SFT LR ≈ 10:1 ~ 50:1
+
+---
+
+## Q4. 灾难性遗忘（Catastrophic Forgetting）
+
+### 什么灾难性遗忘？
+
+模型在 SFT 阶段学会生成对话回复的同时，**丢失**了在预训练阶段学到的通用知识（如常识推理、知识问答能力）。
+
+### 为什么 SFT 会导致遗忘？
+
+```
+预训练：    语言 P(x₁...xₙ)  ← 通用分布
+SFT：       条件 P(回复|指令)  ← 狭窄分布
+     ──────────────────────→
+     训练分布偏移 → 覆盖预训练权重
+```
+
+### 缓解策略
+
+1. **小学习率**：1e-5 比 5e-4 小 50 倍，梯度更新量小
+2. **少轮数**：1-2 轮足够，更多轮次会导致过拟合和遗忘
+3. **保留预训练数据**：混合 SFT 数据 + 10-20% 预训练数据（本仓库未实现）
+4. **EWC / LwF**：正则化方法，限制重要参数的大幅更新（本仓库未实现）
+5. **LoRA**：增量微调，冻结原权重（本仓库另有 `src/trainers/lm/lora_sft.py`）
+
+> 面试点：什么情况下灾难性遗忘最严重？→ 大量 SFT 数据 + 高学习率 + 多轮训练 + 领域单一的数据集
+
+---
+
+## Q5. SFT 训练问题诊断
+
+### Loss 正常值范围
+
+| 阶段 | Loss | 说明 |
+|---|---|---|
+| 初始（第 1 步） | ~7.0-8.5 | 刚加载 pretrain 权重，但换数据集后分布不同 |
+| 收敛 | ~1.5-2.5 | 模型学会生成合理回复 |
+| 过拟合 | < 1.0 | 训练 loss 极低但生成质量差（记忆而不是泛化） |
+
+### Loss 异常分析
+
+```
+Loss 行为                 可能原因                          建议
+────────────────────────────────────────────────────────────────────
+初始 loss 极低 (<2.0)     pretrain 数据集和 SFT 高度重叠    check 数据分布
+loss 不下降 (<30 步)      学习率太小 / 模型冻结              check 梯度
+loss 突增                 学习率太大 / 梯度爆炸              减少 lr / 加强 grad_clip
+loss 震荡                  batch 太小 / lr 太高              调大 batch / 减小 lr
+loss 降到 0.0             所有 label 为 -100                 检查数据截断
+val loss 上升但 train     train loss 下降过拟合              early stopping / 正则化
+```
+
+---
+
+## Q6. 推理时生成差异
+
+### 训练 vs 推理行为对比
+
+```python
+# 训练时
+model.train()
+logits = model(input_ids)                          # 全部序列
+loss = cross_entropy(shift_logits, shift_labels)   # 不采样，计算损失
+
+# 推理时
+model.eval()
+generated = model.generate(input_ids, max_new_tokens=256, do_sample=True, temperature=0.7)
+```
+
+### 推理超参
+
+| 参数 | 作用 | SFT 推荐值 |
+|---|---|---|
+| `do_sample` | 是否采样（否则 greedy） | `True` |
+| `temperature` | 采样温度，越高越随机 | 0.7-0.9 |
+| `top_k` | 只从前 K 个 token 采样 | 40-50 |
+| `top_p` | 核采样（累积概率 p） | 0.9 |
+| `repetition_penalty` | 重复惩罚 | 1.05-1.15 |
+
+### 温度对比
+
+```
+Temperature=0.1: "今天天气真好，我们去散步吧。"
+Temperature=0.7: "今天天气真好，要不出去走走？"
+Temperature=1.5: "天气不错，散步散步散步吧...哦不对不对呵呵呵"
+```
+
+- 温度太低 → 输出机械、重复
+- 温度太高 → 输出发散、语无伦次
+- 0.7 是创造性 + 连贯性的良好平衡点
+
+---
+
+## Q7. YAML 配置详解
+
+### 结构说明
+
+```yaml
+model:
+  hidden_size: 512            # 模型容量：影响参数量和激活值大小
+  num_hidden_layers: 8        # Transformer 层数
+  use_moe: 0                  # MoE 开关
+  vocab_size: 6400            # 词表大小
+  max_seq_len: 768            # SFT 通常需要更长上下文
+  num_attention_heads: 8      # Q 头数
+  num_key_value_heads: 4     # K/V 头数（GQA，4:8=2x 压缩）
+  dropout: 0.0                # SFT 一般不加 dropout
+
+train:
+  epochs: 2
+  batch_size: 16              # 受显存限制
+  learning_rate: 1.0e-5       # 微调用小 lr
+  accumulation_steps: 1
+  grad_clip: 1.0
+  dtype: bfloat16
+  save_interval: 1000
+  log_interval: 100
+  from_weight: pretrain       # 加载预训练权重
+  model_dir: checkpoint/lm_pretrain  # 预训练权重来源目录
+  from_resume: 0
+
+paths:
+  save_dir: checkpoint/lm     # 训练产物存放目录
+  data_path: dataset/sft.jsonl
+```
+
+### max_seq_len 为什么比 pretrain 大？
+
+| | Pretrain | SFT |
+|---|---|---|
+| max_seq_len | 340 | 768 |
+| 原因 | 预训练数据多为短文本（如 BERT 风格片段） | 多轮对话需要更多空间 |
+
+对话拼接后 token 数≈ sum of turns，通常比单篇文本长。
+
+---
+
+## Q8. AdamW 优化器
+
+### 与 Adam 的区别
+
+```python
+# Adam:     w_{t+1} = w_t - lr * m_hat / (sqrt(v_hat) + eps)   # 无 weight decay
+# AdamW:    w_{t+1} = w_t - lr * (m_hat / (sqrt(v_hat) + eps) + λ*w_t)
+#                     └─────────────────────────────┬──────────────┘
+#                                                   └ weight decay 与梯度更新解耦
+```
+
+Adam 将 weight decay 和 L2 正则化混在一起（L2 = 在 loss 上加 λ/2 × ||w||²），而 AdamW 将 weight decay 从自适应学习率中解耦出来。
+
+### 为什么 AdamW 更好？
+
+| | Adam (L2) | AdamW |
+|---|---|---|
+| Decay 位置 | loss 函数中（对梯度贡献） | optimizer 更新时独立加 |
+| 自适应影响 | decay 也被 m_hat/v_hat 缩放 | decay 不受影响 |
+| 实际效果 | 大学习率下 decay 被自适应削弱 | 稳定的 decay 效果 |
+| 业界标准 | 旧方法 | GPT/LLaMA 等现代模型标配 |
+
+### 本仓库配置
+
+```python
+optimizer = AdamW(model.parameters(), lr=args.learning_rate, weight_decay=0.1)
+```
+
+- `weight_decay=0.1` 是常见推荐值
+- 一般不对 bias 和 norm 参数做 weight decay（但此项目未做区分)
+- PyTorch 的 AdamW 默认 `betas=(0.9, 0.999)`, `eps=1e-8`
+
+---
+
+## Q9. SFT 评估方法
+
+### 评估维度
+
+| 维度 | 评估方式 | 指标 |
+|---|---|---|
+| 指令跟随 | 人工/模型评估 | 是否按指令完成 |
+| 生成质量 | 人工评分 | 连贯性/有用性/安全性 |
+| 多样性 | 统计 | distinct-1/2, ngram 重复率 |
+| 知识正确性 | 基准测试 | MMLU, CEval, CMMLU |
+
+### 本仓库评估脚本（`scripts/eval_llm.py`）
+
+```python
+# 生成回复 + 即时交互评估
+python scripts/eval_llm.py --config configs/lm/lm_full_sft.yaml --checkpoint /path/to/full_sft_512.pth
+```
+
+```
+生成评估结果（示例）：
+────────────────────────────────────
+User: 讲个笑话
+Assistant: 为什么程序员总把万圣节和圣诞节搞混？
+因为 Oct 31 == Dec 25！
+────────────────────────────────────
+User: 用 Python 写一个快速排序
+Assistant: def quicksort(arr):
+    if len(arr) <= 1: return arr
+    pivot = arr[len(arr)//2]
+    left  = [x for x in arr if x < pivot]
+    mid   = [x for x in arr if x == pivot]
+    right = [x for x in arr if x > pivot]
+    return quicksort(left) + mid + quicksort(right)
+────────────────────────────────────
+```
+
+### 常见问题
+
+- **回复过短**：「是的」「好的」→ 数据集过于简单或数据量不够
+- **回复重复**：不断生成相同短语 → 温度太低或 repetition_penalty 太小
+- **偏离主题**：模型开始乱说 → 训练不足或 temperature 太高
+- **不能按格式输出**：要求 JSON 但输出自然语言 → 数据集中缺乏格式化示例
+
+---
+
+## Q10. SFT vs RLHF 的关系
+
+### SFT 的局限性
+
+1. **模仿而非优化**：SFT 只是让模型模仿人工回复分布，不是优化最终效果
+2. **暴露偏差**：训练时使用 teacher forcing（每步输入真实 token），推理时输入是自生成的 token，分布偏移
+3. **缺乏偏好对齐**：所有训练样本被视为同等正确，区分不出"好��答"和"更好回答"
+
+### RLHF 如何解决？
+
+```
+SFT 阶段：模仿示范数据
+    │
+    ▼
+Reward 模型训练：学习偏好排序
+    │
+    ▼
+PPO 阶段：以 reward 为信号优化策略
+    │
+    ▼
+结果：模型知道什么"更好"，不仅仅是"像什么"
+```
+
+### 本仓库的 RL 系列
+
+- `src/trainers/lm/dpo.py`：Direct Preference Optimization（PPO 的简化替代）
+- `src/trainers/lm/ppo.py`：Proximal Policy Optimization（标准 RLHF）
+- `src/trainers/lm/grpo.py`：Group Relative Policy Optimization（DeepSeek 方案）
+- `src/trainers/lm/distill.py`：知识蒸馏
+
+> 面试点：SFT 和 RLHF 的核心区别是什么？→ SFT 是监督学习（模仿示范），RLHF 是从偏好信号中学习优化（区分好与更好）
+
+---
+
+## Q11. Teacher Forcing 与 Exposure Bias
+
+### Teacher Forcing
+
+```python
+# 训练时：每次输入真实 token
+for t in range(seq_len):
+    logit = model(input_ids[:, :t+1])
+    loss  = CE(logit[:, t, :], labels[:, t])
+
+# 等价于一次性算全部
+logits = model(input_ids)
+loss   = CE(shift_logits, shift_labels)
+```
+
+### 问题：Exposure Bias
+
+```
+训练时：
+  input:  "中国的首都是"  → 模型预测 → "北京"
+  实际输入下一时间步: "北京" (真实 token)
+
+推理时：
+  input:  "中国的首都是"  → 模型预测 → "上海" (错误!)
+  实际输入下一时间步: "上海" (自己的预测, 错上加错)
+
+        训练分布 ≠ 推理分布 → 累积误差
+```
+
+### 缓解方法
+
+1. **Scheduled Sampling**：推理时以一定概率用模型自己的预测替换真实 token（本仓库未实现，但面试常考）
+2. **强化学习**（RLHF阶段）：直接在自生成序列上优化
+3. **Beam Search**：推理时维护候选路径，减少单步错误的累积影响
+
+---
+
+## Q12. 实际训练资源估算
+
+### 30M 模型 SFT 成本
+
+| 项目 | 估算 |
+|---|---|
+| 参数量 | ~30M（hidden_size=512, L=8） |
+| 总步数 | `ceil(60000/16) × 2 = 7500` |
+| 每步时间 | ~250ms (RTX 4060) |
+| 总时间 | `7500 × 0.25 ≈ 31 分钟` |
+| 峰值显存 | ~4-5 GB（bf16, bs=16, seq=768） |
+| 权重大小 | ~60 MB（fp16 保存） |
+
+### 大数据全量 SFT 估算（实际生产）
+
+| 数据量 | batch_size | 步数 | 每步时间 | 总时间 |
+|---|---|---|---|---|
+| 10K | 16 | 1250 | ~250ms | ~5 分钟 |
+| 60K | 16 | 7500 | ~250ms | ~31 分钟 |
+| 500K | 16 | 62500 | ~250ms | ~4.3 小时 |
+
+> 面试点：如何加速 SFT 训练？→ 增大 batch_size（需更大显存或多卡）→ 减少步数；使用梯度累积补偿显存不足；使用 DeepSpeed ZeRO 节省显存
+
+---
+
+## 面试高频题汇总
+
+### 基础
+
+1. **SFT 和 Pretrain 训练的核心区别？** → 数据格式（纯文本 vs 对话）、loss 计算（全 token vs assistant only）、学习率（5e-4 vs 1e-5）、权重初始化
+2. **为什么 label 要置 -100？** → `CrossEntropyLoss(ignore_index=-100)` 忽略该位置损失，只计算 assistant 段
+3. **Teacher Forcing 是什么？** → 训练时每步输入真实 token 而非模型预测
+4. **灾难性遗忘怎么避免？** → 小 lr、少轮数、混合预训练数据、LoRA 增量微调
+
+### 进阶
+
+5. **Exposure Bias 是什么？** → 训练（teacher forcing）和推理（自回归）的输入分布不一致导致的误差累积
+6. **SFT 后为什么需要 RLHF？** → SFT 只是模仿，RLHF 从偏好信号中学习"什么更好"
+7. **AdamW 比 Adam 好在哪？** → weight decay 与自适应学习率解耦，更有效的正则化
+8. **weight tying 在微调时有用吗？** → 有用，嵌入层和输出头共享权重能提升泛化和收敛
+9. **strict=False 的潜在风险？** → 部分参数随机初始化而不报错，需要手动验证加载结果
+10. **如何处理超长对话？** → 截断（丢失信息）、滑动窗口（窗口训练）、压缩（使用长上下文模型）

docs/interview/pretrain.md

@@ -0,0 +1,520 @@
+# 面试：预训练（Pretrain）深度
+
+> 本仓库 `src/trainers/lm/pretrain.py`，对应 config：`configs/lm/lm_pretrain.yaml`
+
+## 0. 整体流程
+
+```
+数据集 (pretrain_t2t_mini.jsonl)
+    │  1,270,238 条纯文本
+    ▼
+PretrainDataset
+    ├── 读取 jsonl，每条取 text 字段
+    ├── tokenizer.encode() → input_ids
+    ├── labels = input_ids 克隆（完整序列监督）
+    └── 截断 / 填充到 max_seq_len
+    │
+    ▼
+SkipBatchSampler → DataLoader
+    │  batch_size 个样本 / 组
+    │  SkipBatchSampler 支持断点续训跳过前 N 步
+    ▼
+Forward: model(input_ids, labels)
+    ├── TokenEmbed → N×Block → RMSNorm → lm_head
+    └── CE Loss(input=logits[..., :-1, :], target=labels[..., 1:])
+    │
+    ▼
+Backward → 梯度累积 → 梯度裁剪 → Optimizer.step()
+    │
+    ▼
+  Cosine LR 调度 → 定期保存 checkpoint
+```
+
+---
+
+## Q1. PretrainDataset 怎么处理数据？
+
+### 代码（`src/dataset/pretrain.py`）
+
+```python
+class PretrainDataset(Dataset):
+    def __init__(self, data_path, tokenizer, max_length=340):
+        self.data = self.load_data(data_path)
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+
+    def load_data(self, data_path):
+        with open(data_path, 'r') as f:
+            return [json.loads(line)['text'] for line in f]
+
+    def __getitem__(self, index):
+        text = self.data[index]
+        input_ids = self.tokenizer.encode(text, max_length=self.max_length,
+                                          truncation=True, padding='max_length',
+                                          return_tensors='pt')[0]
+        labels = input_ids.clone()
+        return input_ids, labels
+```
+
+### 与 SFT 数据集的关键区别
+
+| | PretrainDataset | SFTDataset |
+|---|---|---|
+| 数据格式 | 纯文本 | 多轮对话 JSON |
+| label 构造 | `labels = input_ids.clone()`（全监督） | prompt 段置 `-100`，只标 assistant |
+| 损失计算 | 所有 token 都参与 | 只有 assistant 回复参与 |
+| 训练目标 | 下一个 token 预测 | 指令跟随回复生成 |
+
+> 面试点：预训练时所有 token 都计算损失 vs SFT 只算 assistant 段，为什么？→ 预训练目标是学习语言分布，所有 token 都提供统计信息；SFT 是学习指令跟随能力，只需要拟合回复
+
+---
+
+## Q2. 损失函数具体怎么算？
+
+### Next-Token Prediction + 标签平移
+
+```python
+# src/models/lm/model.py:63-70
+def forward(self, input_ids, labels=None):
+    hidden_states = self.model(input_ids)
+    logits = self.lm_head(hidden_states)          # [B, S, V]
+
+    if labels is not None:
+        shift_logits = logits[..., :-1, :].contiguous()       # [B, S-1, V]
+        shift_labels = labels[..., 1:].contiguous()           # [B, S-1]
+        loss = F.cross_entropy(
+            shift_logits.view(-1, shift_logits.size(-1)),
+            shift_labels.view(-1)
+        )
+```
+
+### 为什么平移？
+
+- `logits[t]` 预测的是 `labels[t+1]`（第 t 个位置的输出预测第 t+1 个位置的 token）
+- 不平移的话，模型学到的是恒等映射：`logits[t] ≈ labels[t]`
+- 训练时看似 loss 很低，但生成时完全无法产生新内容
+
+> 面试点：平移的本质是什么？→ 将语言模型建模为条件概率 P(xₜ|x₁,...,xₜ₋₁)，第 t 个位置的输出对应第 t+1 个 token 的概率分布
+
+### 辅助损失：MoE aux_loss
+
+```python
+loss = res.loss + res.aux_loss
+```
+
+当 `use_moe=1` 时，MoE 层还会产生一个 auxiliary load-balancing loss，鼓励专家负载均衡。非 MoE 模式下 `aux_loss = 0`。
+
+---
+
+## Q3. 训练超参如何影响模型？
+
+### 核心参数详解
+
+| 参数 | 默认值 | 作用 | 调大影响 | 调小影响 |
+|---|---|---|---|---|
+| `hidden_size` | 512 | 每 token 的表示维度 | 容量↑，速度↓ | 容量↓，速度↑ |
+| `num_hidden_layers` | 8 | Transformer 层数 | 深度↑，梯度传播难 | 深度↓，表达弱 |
+| `batch_size` | 32 | 每步样本数 | 梯度稳，显存↑ | 梯度噪，显存↓ |
+| `accumulation_steps` | 8 | 梯度累积步数 | 等效 batch↑，速度不变 | 等效 batch↓ |
+| `max_seq_len` | 340 | 最大序列长度 | 上下文↑，显存↑ | 上下文↓ |
+| `learning_rate` | 5e-4 | 初始学习率 | 收敛快，可能不稳 | 收敛慢，更稳 |
+| `dtype` | bfloat16 | 混合精度类型 | 精度高，速度中 | 精度低，速度快 |
+
+### 等效 Batch Size
+
+```
+等效 batch = batch_size × accumulation_steps
+```
+
+本仓库 pretrain 默认 `batch_size=32, accumulation_steps=8` → 等效 batch = 256。
+
+### 梯度累积实现
+
+```python
+# src/trainers/lm/pretrain.py:36-47
+loss = loss / args.accumulation_steps     # 归一化
+scaler.scale(loss).backward()             # 累积梯度
+
+if step % args.accumulation_steps == 0:   # 累积够 N 步后
+    scaler.unscale_(optimizer)
+    clip_grad_norm_(model.parameters(), grad_clip)
+    scaler.step(optimizer)                # 更新参数
+    scaler.update()
+    optimizer.zero_grad(set_to_none=True) # 清空梯度
+```
+
+> 面试点：为什么 loss 要除以 accumulation_steps？→ 因为梯度是链式累积的，不归一化的话等效学习率会放大 accumulation_steps 倍。除以步数后，每步梯度相当于独立 batch 梯度的平均，保持学习率语义不变
+
+---
+
+## Q4. 学习率调度策略？
+
+### Cosine Decay
+
+```python
+# src/utils/training.py:82-83
+def get_lr(current_step, total_steps, lr):
+    return lr * (0.1 + 0.45 * (1 + math.cos(math.pi * current_step / total_steps)))
+```
+
+### 调度曲线
+
+```
+lr
+↑
+│    lr * 0.55 ─────────── 余弦下降 ──→ lr * 0.1
+│    (初始)                          (最终)
+└─────────────────────────────────────→ step
+```
+
+- 初始 LR = `lr * 0.55`（cos 从 0 开始，`1 + cos(0) = 2` → `0.1 + 0.45*2 = 1.0`... 不对）
+  仔细看：`current_step=0` 时 `cos(0)=1` → `0.1 + 0.45*2 = 1.0` → `lr * 1.0 = lr`
+  所以在 step 0 时 LR 正好等于设置的 learning_rate。
+- 最终 LR = `lr * 0.1`（cos(π) = -1 → `0.1 + 0.45*0 = 0.1`）
+- 即 LR 从 `lr` 余弦衰减到 `0.1 * lr`
+
+这种"不下到 0"的调度比标准 cosine 更好，保持模型在训练后期仍有适度更新能力。
+
+---
+
+## Q5. 混合精度训练怎么做？
+
+### AMP (Automatic Mixed Precision)
+
+```python
+# src/trainers/lm/pretrain.py:121-123
+dtype = torch.bfloat16 if args.dtype == "bfloat16" else torch.float16
+autocast_ctx = torch.cuda.amp.autocast(dtype=dtype)
+```
+
+### bf16 vs fp16
+
+| | bf16 | fp16 |
+|---|---|---|
+| 指数位 | 8 位（同 fp32） | 5 位 |
+| 尾数位 | 7 位 | 10 位 |
+| 数值范围 | 同 fp32（~3.4e38） | 有限（~6.5e4） |
+| 是否需要 GradScaler | ❌ 不需要 | ✅ 需要 |
+| 精度 | 低精度（7bit 尾数） | 高精度（10bit 尾数） |
+| 硬件要求 | Ampere+（3090/A100 等） | 几乎所有 GPU |
+
+### 为什么 bf16 不需要 GradScaler？
+
+bf16 的指数范围和 fp32 一样，不会发生梯度下溢。fp16 的指数范围只有 5 位，小梯度会直接变 0，需要用 GradScaler 放大梯度再缩小。
+
+### 精度保留技巧
+
+```python
+# src/core/norm.py:7-8
+x = x.float()                              # RMSNorm 内部转 fp32
+x = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+return (self.weight * x).type_as(self.weight)  # 转回 bf16/fp16
+```
+
+即使训练是 bf16，归一化层内部转 fp32 计算再转回，避免归一化精度损失。
+
+---
+
+## Q6. 训练时显存都花在哪了？
+
+### 显存分布（以 30M 参数模型为例）
+
+```
+模型参数 (fp32):      120 MB
+梯度 (fp32):          120 MB
+Adam 状态 (fp32×2):   240 MB
+─────────────────────────────
+模型状态总计:          480 MB
+
+激活值 (bf16, 8层):   ~3-5 GB  ← 大头
+输入数据:              <10 MB
+CUDA 上下文:           ~200 MB
+─────────────────────────────
+总计:                  ~4-6 GB（取决于 batch_size 和 seq_len）
+```
+
+### 为什么激活值占这么多？
+
+- 反向传播需要存储每层的中间激活值
+- 每层存储 Q/K/V、注意力输出、MLP 中间结果等
+- 数量级：`O(batch_size × seq_len × hidden_size × num_layers × k)`，k ≈ 15-34
+
+### 没有激活检查点
+
+本仓库**没有**使用 `torch.utils.checkpoint`（梯度检查点）。代价是激活值全存，好处是不需要重计算，训练速度更快。
+
+> 面试点：激活检查点 trade-off 是什么？→ 节省显存（存部分激活，反向时重算），增加约 15-20% 计算时间
+
+---
+
+## Q7. 分布式训练是怎么做的？
+
+### DDP (DistributedDataParallel)
+
+```python
+# src/utils/distributed.py
+def init_distributed_mode():
+    if int(os.environ.get("RANK", -1)) == -1:
+        return 0                              # 单卡模式
+    dist.init_process_group(backend="nccl")   # 多卡模式
+    local_rank = int(os.environ["LOCAL_RANK"])
+    torch.cuda.set_device(local_rank)
+    return local_rank
+```
+
+### 启动方式
+
+```bash
+# 单卡
+python -m trainers.lm.pretrain --config configs/lm/lm_pretrain.yaml
+
+# 多卡（torchrun）
+torchrun --nproc_per_node=4 -m trainers.lm.pretrain --config configs/lm/lm_pretrain.yaml
+```
+
+### DDP 原理
+
+- 每个 GPU 一张完整的模型副本
+- 前向/反向独立计算
+- 反向传播后通过 `allreduce` 同步梯度
+- 每个 GPU 独立执行 optimizer.step()
+
+### 本仓库没有使用
+
+- ❌ ZeRO（DeepSpeed）
+- ❌ FSDP
+- ❌ 张量/序列并行
+- ❌ torch.compile（默认关闭，`use_compile: 0`）
+
+> 面试点：为什么小模型不用 ZeRO/FSDP？→ 模型仅 30M 参数，单卡就能装下，DDP 的梯度同步开销也很小。ZeRO/FSDP 的通信量更大，对小模型反而可能更慢
+
+---
+
+## Q8. Checkpoint 如何保存和恢复？
+
+### 保存（`train_epoch` 内）
+
+```python
+# src/trainers/lm/pretrain.py:59-67
+if (step % args.save_interval == 0 or step == iters) and is_main_process():
+    ckp = f'{args.save_dir}/{args.save_weight}_{hidden_size}.pth'
+    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, ...)
+```
+
+### 保存两个文件
+
+| 文件 | 内容 | 用途 |
+|---|---|---|
+| `pretrain_512.pth` | 模型权重 (fp16) | 推理/下游微调 |
+| `pretrain_512_resume.pth` | 权重 + 优化器 + epoch + step | 断点续训 |
+
+### 恢复训练 `from_resume=1`
+
+```python
+ckp_data = lm_checkpoint(lm_config, weight=args.save_weight, save_dir='../checkpoints')
+if ckp_data:
+    model.load_state_dict(ckp_data['model'])
+    optimizer.load_state_dict(ckp_data['optimizer'])
+    start_epoch = ckp_data['epoch']
+    start_step = ckp_data.get('step', 0)
+```
+
+### 权重初始化 `from_weight`
+
+```yaml
+from_weight: none      # 从头训练（随机初始化）
+from_weight: pretrain  # 加载 pretrain_512.pth 继续训练
+from_weight: full_sft  # 加载 full_sft_512.pth 继续训练
+```
+
+`init_model` 会根据 `from_weight` 在 `save_dir` 下查找对应文件：
+
+```python
+weight_path = f'{save_dir}/{from_weight}_{hidden_size}.pth'
+weights = torch.load(weight_path, map_location=device)
+model.load_state_dict(weights, strict=False)
+```
+
+> 面试点：`strict=False` 意味着什么？→ 允许加载的权重和模型结构部分不匹配（如只加载 encoder 不加载 lm_head），LoRA 等场景常用
+
+---
+
+## Q9. SkipBatchSampler 如何实现断点续训？
+
+```python
+# src/utils/training.py:177-200
+class SkipBatchSampler(Sampler):
+    def __init__(self, sampler, batch_size, skip_batches=0):
+        self.sampler = sampler                  # 原始索引（或 DistributedSampler）
+        self.batch_size = batch_size
+        self.skip_batches = skip_batches        # 跳过的步数
+
+    def __iter__(self):
+        batch = []
+        skipped = 0
+        for idx in self.sampler:
+            batch.append(idx)
+            if len(batch) == self.batch_size:
+                if skipped < self.skip_batches:  # 跳过前 N 个 batch
+                    skipped += 1
+                    batch = []
+                    continue
+                yield batch
+                batch = []
+```
+
+### 为什么需要跳过？
+
+- 断点续训时已经从 checkpoint 恢复了优化器状态
+- 但 DataLoader 从头开始迭代的话，会重复处理之前的数据
+- `SkipBatchSampler` 通过 `skip_batches` 跳过已处理的 batch
+
+### 使用场景
+
+```python
+skip = start_step if (epoch == start_epoch and start_step > 0) else 0
+batch_sampler = SkipBatchSampler(train_sampler or indices, args.batch_size, skip)
+```
+
+---
+
+## Q10. 随机种子和数据打乱
+
+```python
+# src/trainers/lm/pretrain.py:160
+setup_seed(42 + epoch)
+indices = torch.randperm(len(train_ds)).tolist()
+```
+
+### 每 epoch 重新打乱
+
+- 每个 epoch 用不同的 `indices` 顺序
+- 种子 = `42 + epoch`，保证可复现
+- `DistributedSampler` 模式下，每个 GPU 拿到不同但确定性的分片
+
+### 为什么 seed 要 + epoch？
+
+- 每个 epoch 的数据顺序不同
+- 同一 epoch 在不同运行间可复现
+- 分布式下每个 rank 拿到不同的子集
+
+---
+
+## Q11. YAML 配置是如何生效的？
+
+### 配置优先级
+
+```
+CLI 参数 > YAML 默认值 > Python argparse 默认值
+```
+
+### 实现机制
+
+```python
+# src/utils/training.py:25-38
+def apply_config(parser, default_config=None):
+    pre, _ = parser.parse_known_args()
+    config_path = getattr(pre, 'config', None) or default_config
+    if config_path and os.path.exists(config_path):
+        defaults = _load_yaml_config(config_path)
+        parser.set_defaults(**defaults)     # YAML 值设置为 argparse 默认值
+    return parser.parse_args()              # CLI 显式传参仍可覆盖
+```
+
+### YAML 映射
+
+```yaml
+model:
+  hidden_size: 512    → args.hidden_size
+train:
+  batch_size: 32      → args.batch_size
+paths:
+  save_dir: ...       → args.save_dir
+```
+
+YAML 的三个 section（model/train/paths）被扁平化为 argparse 参数后注入，之后任何 CLI 传参都可以覆盖。
+
+---
+
+## Q12. 为什么选 SwiGLU 作为激活函数？
+
+### 公式对比
+
+| 激活函数 | 公式 | 参数量 |
+|---|---|---|
+| ReLU FFN | `ReLU(xW₁)W₂` | 2×d×d_ff |
+| SwiGLU | `SiLU(xW_g) * (xW_u) * W_d` | 3×d×d_ff |
+
+SwiGLU 用三个投影（gate/up/down）替代两个，参数量增加 50%，但同等参数下效果更好。
+
+### 仓库实现
+
+```python
+# src/core/mlp.py:16-17
+def forward(self, x):
+    return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+```
+
+### intermediate_size 的奇怪计算
+
+```python
+# src/models/lm/config.py:22
+self.intermediate_size = math.ceil(hidden_size * math.pi / 64) * 64
+```
+
+为���么用 π？这是一个取整技巧：`hidden_size × π / 64` 取整再 ×64，保证 intermediate_size 是 64 的倍数，有利于 GPU 内存对齐和 Tensor Core 加速。
+
+对于 `hidden_size=512`：`intermediate_size = ceil(512 × π / 64) × 64 = ceil(25.13) × 64 = 1664`
+
+---
+
+## Q13. 训练过程中 loss 的变化规律
+
+典型 pretrain loss 曲线：
+
+```
+loss
+↑
+8.0 │  █
+7.0 │    ██
+6.0 │      ███
+5.0 │        ████
+4.0 │          █████
+3.0 │            ██████
+    └────────────────────→ step
+```
+
+### 特征
+
+1. **快速下降期**（前 5-10% 步数）：loss 从 ~8.5 降到 ~5.0，模型学到基础词法/语法模式
+2. **平稳下降期**：loss 稳步下降，学习更复杂的语义/知识
+3. **接近收敛**：loss 下降变缓，接近理论下界
+
+### 预估最终 loss
+
+对于 vocab_size=6400 的随机初始化模型：
+- 初始 loss ≈ log(6400) ≈ 8.76（均匀分布的交叉熵）
+- 训练后 loss ≈ 2.5-3.5（取决于模型大小和数据量）
+- 理论下限 ≈ 0（完美拟合数据分布，但实际上达不到）
+
+---
+
+## 面试高频题汇总
+
+### 基础
+
+1. **预训练和 SFT 的区别？** → 预训练从零学习语言分布（全 token 监督），SFT 学习指令跟随（只监督回复）
+2. **为什么用 bf16 而不是 fp16？** → bf16 指数范围同 fp32，无需 GradScaler，训练更稳定
+3. **梯度累积的作用？** → 显存不足时用计算换显存，等效增大 batch_size
+4. **Cosine 学习率调度的优缺点？** → 平滑衰减，早期快速学习后期精细调优，但可能过早衰减
+
+### 进阶
+
+5. **如何估计训练时间？** → `总步数 = ceil(样本数 / batch_size) × epochs`，`总时间 = 总步数 × 每步时间`
+6. **为什么 loss 除以 accumulation_steps？** → 保持梯度期望不变，等效于 "平均 N 个 mini-batch 的梯度"
+7. **DDP 和 DP 的区别？** → DDP 每个 GPU 独立前反向 + allreduce 梯度，DP 是单进程多线程（GIL 限制性能）
+8. **weight tying 的作用？** → 共享 embedding 和 lm_head 的权重矩阵，减少参数量（本项目默认开启）
+9. **GQA 和 MHA 的区别？** → GQA 减少 KV head 数量，降低 KV cache 大小，推理时更省显存
+10. **Flash Attention 为什么省显存？** → tiling 计算注意力矩阵，不显式存储 O(n²) 的 score 矩阵

docs/training/config-and-cli.md

@@ -53,10 +53,11 @@ trainer 用 `LMConfig(**vars(args))`（或 `VLMConfig` / `VAMConfig`）构造模
 ## 启动
 
 ```bash
-bash runs/train_lm.sh                                   # 默认 configs/lm.yaml
-bash runs/train_vlm.sh --config configs/vlm_moe.yaml
-bash runs/train_vam.sh --epochs 10                       # 覆盖单字段
-bash runs/train_tokenizer.sh                      # 训练 tokenizer（学习用），保存到 checkpoint/tokenizer/
+python -m trainers.lm.full_sft --config configs/lm/lm_full_sft.yaml
+python -m trainers.vlm.full_sft --config configs/vlm/vlm_moe.yaml
+python -m trainers.vam.full_sft --config configs/vam/vam.yaml --epochs 10
+python -m trainers.lm.train_tokenizer --data_path dataset/sft_t2t_mini.jsonl \
+                                      --vocab_size 6400 --no_eval
 ```
 
 ## Tokenizer 训练
@@ -70,10 +71,10 @@ bash runs/train_tokenizer.sh                      # 训练 tokenizer（学习用
 常用参数：
 
 ```bash
-bash runs/train_tokenizer.sh --data_path dataset/sft_t2t_mini.jsonl \
-                             --vocab_size 6400 \
-                             --checkpoint_dir ../checkpoint \
-                             --no_eval
+python -m trainers.lm.train_tokenizer --data_path dataset/sft_t2t_mini.jsonl \
+                                      --vocab_size 6400 \
+                                      --checkpoint_dir ../checkpoint \
+                                      --no_eval
 ```
 
 ## 要点（面试）

docs/training/index.md

@@ -24,7 +24,7 @@
 
 ## 训练脚本（Trainers）
 
-按模态组织的训练入口，每个脚本暴露 `main(default_config=None)`（可由 `python -m trainers.<mod>` 或 `runs/*.sh` 调用）。
+按模态组织的训练入口，每个脚本暴露 `main(default_config=None)`（通过 `python -m trainers.<mod>` 调用）。
 
 - `trainers/lm/`：pretrain / full_sft / lora / dpo / distillation / ppo / grpo / agent / rollout_engine / train_tokenizer
 - `trainers/vlm/`：pretrain / full_sft

docs/training/trainers.md

@@ -1,6 +1,6 @@
 # trainers/trainers.md · 训练脚本
 
-`trainers/` 按模态分子包，每个脚本暴露 `main(default_config=None)`（可由 `python -m trainers.<mod>` 或 `runs/*.sh` 调用）。
+`trainers/` 按模态分子包，每个脚本暴露 `main(default_config=None)`（通过 `python -m trainers.<mod>` 调用）。
 
 ## 文本（lm/）
 

runs/train_lm.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# LM (纯文本) 训练启动脚本
-set -e
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT"
-exec uv run python -m trainers.lm.full_sft --config "$ROOT/configs/lm.yaml" "$@"

runs/train_tokenizer.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-# Tokenizer 训练启动脚本（仅供学习和参考，不建议重复训练 tokenizer）
-# 用法: bash runs/train_tokenizer.sh [额外参数...]
-set -e
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT"
-export PYTHONPATH="$ROOT/src:${PYTHONPATH}"
-exec uv run python -m trainers.lm.train_tokenizer "$@"

runs/train_vam.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# VAM (文本 + 视觉 + 语音 全模态) 训练启动脚本
-set -e
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT"
-exec uv run python -m trainers.vam.full_sft --config "$ROOT/configs/vam.yaml" "$@"

runs/train_vlm.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# VLM (文本 + 视觉) 训练启动脚本
-set -e
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$ROOT"
-exec uv run python -m trainers.vlm.full_sft --config "$ROOT/configs/vlm.yaml" "$@"

src/trainers/lm/full_sft.py

@@ -13,72 +13,12 @@ from torch.nn.parallel import DistributedDataParallel
 from torch.utils.data import DataLoader, DistributedSampler
 from models import LMConfig
 from dataset import SFTDataset
-from utils.training import get_lr, Logger, is_main_process, lm_checkpoint, init_distributed_mode, setup_seed, init_model, SkipBatchSampler
+from utils.training import get_lr, Logger, is_main_process, lm_checkpoint, init_distributed_mode, setup_seed, init_model, SkipBatchSampler, init_logger
 from utils.training import apply_config  # noqa: F401
 
 warnings.filterwarnings('ignore')
 
 
-def train_epoch(epoch, loader, iters, start_step=0, wandb=None):
-    start_time = time.time()
-    last_step = start_step
-    for step, (input_ids, labels) in enumerate(loader, start=start_step + 1):
-        input_ids = input_ids.to(args.device)
-        labels = labels.to(args.device)
-        last_step = step
-        lr = get_lr(epoch * iters + step, args.epochs * iters, args.learning_rate)
-        for param_group in optimizer.param_groups:
-            param_group['lr'] = lr
-
-        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)
-
-        if step % args.log_interval == 0 or step == iters:
-            spend_time = time.time() - start_time
-            current_loss = loss.item() * args.accumulation_steps
-            current_aux_loss = res.aux_loss.item() if res.aux_loss is not None else 0.0
-            current_logits_loss = current_loss - current_aux_loss
-            current_lr = optimizer.param_groups[-1]['lr']
-            eta_min = spend_time / max(step - start_step, 1) * (iters - step) // 60
-            Logger(f'Epoch:[{epoch + 1}/{args.epochs}]({step}/{iters}), loss: {current_loss:.4f}, logits_loss: {current_logits_loss:.4f}, aux_loss: {current_aux_loss:.4f}, lr: {current_lr:.8f}, epoch_time: {eta_min:.1f}min')
-            if wandb: wandb.log({"loss": current_loss, "logits_loss": current_logits_loss, "aux_loss": current_aux_loss, "learning_rate": current_lr, "epoch_time": eta_min})
-
-        if (step % args.save_interval == 0 or step == iters) and is_main_process():
-            model.eval()
-            moe_suffix = '_moe' if lm_config.use_moe else ''
-            ckp = f'{args.save_dir}/{args.save_weight}_{lm_config.hidden_size}{moe_suffix}.pth'
-            raw_model = model.module if isinstance(model, DistributedDataParallel) else model
-            raw_model = getattr(raw_model, '_orig_mod', raw_model)
-            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()
-            del state_dict
-
-        del input_ids, labels, res, loss
-
-    if last_step > start_step and last_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)
-
-
 def main(default_config=None):
     parser = argparse.ArgumentParser(description="MiniMind Full SFT")
     parser.add_argument('--config', type=str, default=None, help='YAML 配置路径，其字段作为 argparse 默认值，CLI 显式传参可覆盖')
@@ -100,6 +40,7 @@ def main(default_config=None):
     parser.add_argument('--max_seq_len', default=768, type=int, help="训练的最大截断长度（中文1token≈1.5~1.7字符）")
     parser.add_argument('--use_moe', default=0, type=int, choices=[0, 1], help="是否使用MoE架构（0=否，1=是）")
     parser.add_argument("--data_path", type=str, default="../dataset/sft_t2t_mini.jsonl", help="训练数据路径")
+    parser.add_argument('--model_dir', default=None, type=str, help="预训练权重所在目录（默认同save_dir）")
     parser.add_argument('--from_weight', default='pretrain', type=str, help="基于哪个权重训练，为none则不基于任何权重训练")
     parser.add_argument('--from_resume', default=0, type=int, choices=[0, 1], help="是否自动检测&续训（0=否，1=是）")
     parser.add_argument("--use_wandb", action="store_true", help="是否使用wandb")
@@ -133,7 +74,7 @@ def main(default_config=None):
         wandb.init(project=args.wandb_project, name=wandb_run_name, id=wandb_id, resume=resume)
     
     # ========== 5. 定义模型、数据、优化器 ==========
-    model, tokenizer = init_model(lm_config, args.from_weight, save_dir=args.save_dir, tokenizer_dir=args.tokenizer_dir, device=args.device)
+    model, tokenizer = init_model(lm_config, args.from_weight, save_dir=args.save_dir, tokenizer_dir=args.tokenizer_dir, device=args.device, model_dir=args.model_dir)
     train_ds = SFTDataset(args.data_path, tokenizer, max_length=args.max_seq_len)
     train_sampler = DistributedSampler(train_ds) if dist.is_initialized() else None
     scaler = torch.cuda.amp.GradScaler(enabled=(args.dtype == 'float16'))
@@ -155,7 +96,67 @@ def main(default_config=None):
     if dist.is_initialized():
         model = DistributedDataParallel(model, device_ids=[local_rank])
     
-    # ========== 8. 开始训练 ==========
+    # ========== 8. 训练函数 ==========
+    def train_epoch(epoch, loader, iters, start_step=0, wandb=None):
+        start_time = time.time()
+        last_step = start_step
+        for step, (input_ids, labels) in enumerate(loader, start=start_step + 1):
+            input_ids = input_ids.to(args.device)
+            labels = labels.to(args.device)
+            last_step = step
+            lr = get_lr(epoch * iters + step, args.epochs * iters, args.learning_rate)
+            for param_group in optimizer.param_groups:
+                param_group['lr'] = lr
+
+            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)
+
+            if step % args.log_interval == 0 or step == iters:
+                spend_time = time.time() - start_time
+                current_loss = loss.item() * args.accumulation_steps
+                current_aux_loss = res.aux_loss.item() if res.aux_loss is not None else 0.0
+                current_logits_loss = current_loss - current_aux_loss
+                current_lr = optimizer.param_groups[-1]['lr']
+                eta_min = spend_time / max(step - start_step, 1) * (iters - step) // 60
+                Logger(f'Epoch:[{epoch + 1}/{args.epochs}]({step}/{iters}), loss: {current_loss:.4f}, logits_loss: {current_logits_loss:.4f}, aux_loss: {current_aux_loss:.4f}, lr: {current_lr:.8f}, epoch_time: {eta_min:.1f}min')
+                if wandb: wandb.log({"loss": current_loss, "logits_loss": current_logits_loss, "aux_loss": current_aux_loss, "learning_rate": current_lr, "epoch_time": eta_min})
+
+            if (step % args.save_interval == 0 or step == iters) and is_main_process():
+                model.eval()
+                moe_suffix = '_moe' if lm_config.use_moe else ''
+                ckp = f'{args.save_dir}/{args.save_weight}_{lm_config.hidden_size}{moe_suffix}.pth'
+                raw_model = model.module if isinstance(model, DistributedDataParallel) else model
+                raw_model = getattr(raw_model, '_orig_mod', raw_model)
+                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()
+                del state_dict
+
+            del input_ids, labels, res, loss
+
+        if last_step > start_step and last_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)
+
+    # ========== 9. 开始训练 ==========
     for epoch in range(start_epoch, args.epochs):
         train_sampler and train_sampler.set_epoch(epoch)
         setup_seed(42 + epoch); indices = torch.randperm(len(train_ds)).tolist()
@@ -168,7 +169,7 @@ def main(default_config=None):
         else:
             train_epoch(epoch, loader, len(loader), 0, wandb)
     
-    # ========== 9. 清理分布进程 ==========
+    # ========== 10. 清理分布进程 ==========
     if dist.is_initialized():
         dist.barrier()
         dist.destroy_process_group()

src/trainers/lm/pretrain.py

@@ -13,7 +13,7 @@ from torch.nn.parallel import DistributedDataParallel
 from torch.utils.data import DataLoader, DistributedSampler
 from models import LMConfig
 from dataset import PretrainDataset
-from utils.training import get_lr, Logger, is_main_process, lm_checkpoint, init_distributed_mode, setup_seed, init_model, SkipBatchSampler
+from utils.training import get_lr, Logger, is_main_process, lm_checkpoint, init_distributed_mode, setup_seed, init_model, SkipBatchSampler, init_logger
 from utils.training import apply_config  # noqa: F401
 
 warnings.filterwarnings('ignore')

src/utils/training.py

@@ -158,14 +158,15 @@ def lm_checkpoint(lm_config, weight='full_sft', model=None, optimizer=None, epoc
         return None
 
 
-def init_model(lm_config, from_weight='pretrain', save_dir='../checkpoint', tokenizer_dir=None, device='cuda'):
+def init_model(lm_config, from_weight='pretrain', save_dir='../checkpoint', tokenizer_dir=None, device='cuda', model_dir=None):
     tokenizer_dir = tokenizer_dir or os.path.join(save_dir, 'tokenizer')
     tokenizer = AutoTokenizer.from_pretrained(tokenizer_dir)
     model = LMForCausalLM(lm_config)
 
     if from_weight != 'none':
         moe_suffix = '_moe' if lm_config.use_moe else ''
-        weight_path = f'{save_dir}/{from_weight}_{lm_config.hidden_size}{moe_suffix}.pth'
+        weight_dir = model_dir or save_dir
+        weight_path = f'{weight_dir}/{from_weight}_{lm_config.hidden_size}{moe_suffix}.pth'
         weights = torch.load(weight_path, map_location=device)
         model.load_state_dict(weights, strict=False)