Bonus 专栏:LLM 训练全景手册(框架 / 训练模式 / 输入输出 / 最简测试)

不重复网上 "100 行 PyTorch 训练 GPT-2" 的入门文,只讲生产/工业级;跟 Day 8 vLLM 推理对照看(训练完模型 → vLLM 服务化)。

0. 训练全景 — 一张图理清

                     Foundation Model
                    ┌────────────────┐
       Pre-train ──→│  Base model    │   (Qwen2.5-3B-Base, Llama-3-8B, ...)
       (PT)         │  下一 token 预测 │
                    └───────┬────────┘
                            │
                            │ Continued Pre-training (CPT)
                            │ — 领域语料适配,仍是下一 token
                            ↓
                    ┌────────────────┐
       SFT       ──→│  Instruct model│   (Qwen2.5-3B-Instruct)
       Supervised   │  学指令格式    │
       FT           └───────┬────────┘
                            │
                ┌───────────┼───────────┐
                ↓           ↓           ↓
         ┌─────────┐ ┌─────────┐ ┌─────────┐
         │  DPO    │ │  KTO    │ │  PPO    │   ← 偏好对齐 / RLHF
         │  ORPO   │ │  GRPO   │ │ Reward  │
         └─────────┘ └─────────┘ │  Model  │
                                  └─────────┘
                            ↓
                    ┌────────────────┐
                    │ Aligned model  │   (生产可用)
                    └────────────────┘

并行能力 (任何阶段都可叠加):
  - LoRA / QLoRA / DoRA       (PEFT, 省显存)
  - Distillation              (小学大)
  - Quantization-aware Training (训练时就量化)

记住:Pre-train / SFT / 偏好对齐(DPO/PPO/GRPO/...)= 3 大阶段。后面要么全参微调,要么 PEFT。

1. 选型矩阵 — 我在什么场景用什么框架?

新人工具链:LLaMA-Factory 一站式 — UI + CLI 都有,90% 工业场景够用,内部封装了 DeepSpeed/FSDP/TRL/PEFT。

2. 主流框架横评

2.1 PyTorch 原生(DDP / FSDP)

原理:

• DDP (DistributedDataParallel) — 每张卡有模型完整副本,前向独立,反向 all-reduce 梯度。显存被模型 N 倍占用(N=卡数)。
• FSDP (Fully Sharded Data Parallel) — 模型分片到所有卡,前向/反向时按需 all-gather。显存 ≈ 模型大小 / N。

启动命令:

# DDP (单机多卡)
torchrun --nproc_per_node=8 train.py \
  --bf16 --output_dir ./out

# FSDP (单机多卡, accelerate 包装更简单)
accelerate launch --config_file fsdp_config.yaml train.py

重要参数:

• --sharding_strategy FULL_SHARD (ZeRO-3 等价) / SHARD_GRAD_OP (ZeRO-2)
• --mixed_precision bf16 (A100 / H100 必开)
• --gradient_checkpointing (省显存换计算 ~30%)
• --cpu_offload (FSDP 把权重 offload 到 CPU,跑 70B on 单卡)

何时不用: 业务模型小 + 团队不强,直接用 transformers.Trainer,它内部已经接 FSDP/DeepSpeed。

2.2 HuggingFace transformers.Trainer(最常用基线)

原理: 把 PyTorch 训练循环封装成 1 个 Trainer 对象,自动接 DDP/FSDP/DeepSpeed/Accelerate,自动处理日志/checkpoint/eval/早停。业界第一基线,出了问题先 reproduce 这个再说。

启动:

from transformers import Trainer, TrainingArguments

args = TrainingArguments(
    output_dir="./out",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,    # 等效 batch 16
    learning_rate=2e-5,
    bf16=True,
    deepspeed="ds_z3.json",            # 直接指 DeepSpeed 配置,自动接
    save_strategy="steps",
    save_steps=500,
    logging_steps=10,
    report_to="tensorboard",
)
Trainer(model=model, args=args, train_dataset=ds, tokenizer=tok).train()

重要参数(top 15):

• per_device_train_batch_size 单卡 batch
• gradient_accumulation_steps 累积梯度(增加等效 batch 而不撑显存)
• learning_rate 2e-5(SFT 经典)/ 5e-6(DPO)/ 1e-4(LoRA)
• warmup_ratio 0.03(LR 暖启)
• lr_scheduler_type cosine / linear / constant_with_warmup
• weight_decay 0.01
• max_grad_norm 1.0(梯度裁剪)
• bf16=True Ampere+ 必开,A100/A800/H100
• gradient_checkpointing=True 省 30%+ 显存
• dataloader_num_workers 数据 IO 并行,默认 0 太慢
• eval_strategy="steps" + eval_steps=500
• save_total_limit=3(只保留最近 3 个 checkpoint,省盘)
• report_to=["tensorboard", "wandb"]
• deepspeed="ds_z3.json"(集成 ZeRO)
• fsdp="full_shard auto_wrap"(也可)

2.3 DeepSpeed(ZeRO 1/2/3)

原理: 微软方案,ZeRO 把"显存爆炸"的 3 大件分片:

• ZeRO-1: 优化器状态分片(Adam 一阶/二阶矩,占 8× 模型 fp32)
• ZeRO-2: + 梯度分片
• ZeRO-3: + 模型权重分片(=FSDP)
• ZeRO-Infinity: + offload 到 NVMe/CPU

典型 ds_z3.json:

{
  "bf16": {"enabled": true},
  "zero_optimization": {
    "stage": 3,
    "offload_optimizer": {"device": "cpu"},
    "offload_param": {"device": "none"},
    "overlap_comm": true,
    "contiguous_gradients": true,
    "reduce_bucket_size": 5e8
  },
  "gradient_accumulation_steps": "auto",
  "train_micro_batch_size_per_gpu": "auto",
  "wall_clock_breakdown": false
}

启动:

deepspeed --num_gpus=8 train.py --deepspeed ds_z3.json
# 或通过 transformers Trainer 内部自动启

何时选 DeepSpeed vs FSDP:

• DeepSpeed: 生态最久 / CPU offload 成熟 / 微软优化 / 70B + 全参微调首选
• FSDP: PyTorch 原生 / 跟 HF 集成更新 / 配置更简单
• 都能用时, 新项目选 FSDP(社区方向)

2.4 Megatron-LM / Megatron-DeepSpeed

原理: NVIDIA 出的预训练专用框架。引入:

• Tensor Parallelism (TP): 矩阵切片到多卡(GEMM 横切 / 竖切)
• Pipeline Parallelism (PP): 模型按 layer 切到多机
• Sequence Parallelism (SP): 配合 TP 进一步切 LayerNorm/Dropout
• 3D 并行: DP × TP × PP,百亿 + 模型必需

何时用: 7B 以下用 DDP+FSDP 够,13B+ 全参训练考虑 Megatron。GPT-3、Llama-3 系列等大厂用它。

学习成本: ★★★★★(配置 + 命令复杂,要懂 3D 并行原理)

启动示意(70B Llama 8 机 64 卡):

torchrun --nproc_per_node=8 --nnodes=8 --node_rank=$RANK \
  --master_addr=$MASTER_IP --master_port=6000 \
  pretrain_gpt.py \
    --tensor-model-parallel-size 8 \
    --pipeline-model-parallel-size 8 \
    --sequence-parallel \
    --num-layers 80 --hidden-size 8192 --num-attention-heads 64 \
    --micro-batch-size 1 --global-batch-size 1024 \
    --lr 1e-4 --train-iters 100000 \
    --data-path /data/c4/llama_text_document \
    --tokenizer-type Llama2Tokenizer \
    --bf16 --use-flash-attn

2.5 LLaMA-Factory(2024-2025 工业最热)

原理: 一站式封装 — UI(llamafactory-cli webui)+ CLI,把 transformers/TRL/PEFT/DeepSpeed/FSDP 串成一个 yaml 配置即跑。

支持几乎所有:

• 模型: Qwen / Llama / Mistral / DeepSeek / Phi / Yi / Baichuan / ChatGLM / Gemma / 100+
• 模式: PT / SFT / RM / PPO / DPO / ORPO / KTO / SimPO / GRPO
• PEFT: LoRA / QLoRA / DoRA / GaLore / BAdam
• 多模态: Qwen2-VL / LLaVA / MiniCPM-V

启动(yaml 配置 → CLI):

# qwen_sft.yaml
model_name_or_path: Qwen/Qwen2.5-3B-Instruct
stage: sft                         # pt / sft / rm / ppo / dpo / kto / orpo
do_train: true
finetuning_type: lora              # full / lora / freeze
lora_target: all                   # 所有 linear 都加 LoRA
lora_rank: 16
lora_alpha: 32
lora_dropout: 0.05

dataset: alpaca_zh_demo            # 内置 demo 或自定义
template: qwen
cutoff_len: 2048
overwrite_cache: true
preprocessing_num_workers: 16

output_dir: saves/qwen2.5-3b/lora/sft
logging_steps: 5
save_steps: 200
plot_loss: true
overwrite_output_dir: true

per_device_train_batch_size: 1
gradient_accumulation_steps: 8
learning_rate: 1.0e-4
num_train_epochs: 3.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
bf16: true

ddp_timeout: 180000000

llamafactory-cli train qwen_sft.yaml
# 或 webui:
llamafactory-cli webui   # 浏览器 7860,点选配置导出 yaml

面试点: LLaMA-Factory 不是底层框架,是个集成器 — 但因为它包装了主流所有训练模式,生产 SFT/DPO 默认用它节省 80% 时间。

2.6 TRL — Transformers Reinforcement Learning

原理: HuggingFace 官方 RL/对齐库。提供 6 个核心 Trainer:

• SFTTrainer — 监督微调(其实跟 transformers Trainer 区别小)
• RewardTrainer — 训练 Reward Model
• PPOTrainer — RLHF 经典
• DPOTrainer — Direct Preference Optimization
• KTOTrainer — Kahneman-Tversky Optimization
• GRPOTrainer — Group Relative Policy Optimization(DeepSeek-R1 用)
• ORPOTrainer — Odds Ratio Preference Optimization

最简 DPO:

from trl import DPOTrainer, DPOConfig

config = DPOConfig(
    output_dir="./dpo_out",
    beta=0.1,                          # 偏好强度
    learning_rate=5e-7,                # 远小于 SFT (5e-7 ~ 5e-6)
    num_train_epochs=1,
    per_device_train_batch_size=2,
    bf16=True,
)
DPOTrainer(
    model=model,
    ref_model=ref_model,               # frozen 参考模型 (可 None,内部 copy)
    args=config,
    train_dataset=ds,                  # 含 prompt/chosen/rejected
    tokenizer=tok,
).train()

2.7 PEFT — LoRA / QLoRA / DoRA

原理:

• LoRA: 冻结原 weight,加 A·B 两个低秩矩阵 (rank=r),只训这俩。显存 = 原 1/100, 效果 95%。
• QLoRA: LoRA + 原 weight 4bit 量化加载。24GB 卡跑 65B 模型。
• DoRA: LoRA 进阶,把 weight 分解为 magnitude + direction,direction 用 LoRA,精度↑ 速度 ≈。

典型 QLoRA 配置:

from peft import LoraConfig, get_peft_model
from transformers import BitsAndBytesConfig

bnb = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-7B", quantization_config=bnb, device_map="auto"
)
lora = LoraConfig(
    r=16, lora_alpha=32, lora_dropout=0.05,
    target_modules=["q_proj","k_proj","v_proj","o_proj",
                    "gate_proj","up_proj","down_proj"],   # 所有 attention + MLP
    task_type="CAUSAL_LM",
    use_dora=False,                                       # True 改 DoRA
)
model = get_peft_model(model, lora)
model.print_trainable_parameters()
# 典型输出: trainable params: 40M / 7.6B (0.5%)

LoRA rank 选取:

• r=4 ~ 8: 风格微调 / 简单 instruction
• r=16: 通用 SFT(默认)
• r=64 ~ 128: 接近全参效果,但已经很贵
• 一般 alpha = 2 × r

2.8 Unsloth — 单卡 GPU 最快微调

原理: 重写 PyTorch attention/MLP kernel,单 GPU 比标准 transformers 快 2-5×, 显存省 30-70%。但只支持单卡(2024-Q4 才出多卡)。

何时用: 1 张消费卡(4090 / A100-40G)做 LoRA/QLoRA。

启动:

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    "unsloth/Qwen2.5-7B-Instruct-bnb-4bit",
    max_seq_length=4096, dtype=None, load_in_4bit=True,
)
model = FastLanguageModel.get_peft_model(
    model, r=16, lora_alpha=32,
    target_modules=["q_proj","k_proj","v_proj","o_proj",
                    "gate_proj","up_proj","down_proj"],
)
# 后续用普通 SFTTrainer

2.9 大规模 RLHF — OpenRLHF / verl

为什么需要专用框架: TRL 的 PPO/GRPO 只到 single-node。多机分布式 RLHF 需要协调:

• Actor model (训练中)
• Reference model (frozen,提供 KL)
• Reward model (frozen)
• Critic model (Actor + value head)
• 4 个 model 切分 + Rollout 数据流转 — 复杂

OpenRLHF(字节系出品): 基于 Ray + DeepSpeed,70B 全参 PPO 在 32×A100 跑得动。

verl(火山引擎): 跟 OpenRLHF 类似,HybridFlow 论文落地,RLHF 抽象更优雅。

何时用: 模型 > 13B + 全参 RLHF。学术/工业前沿。

2.10 Axolotl

跟 LLaMA-Factory 同类(yaml 配置 → 跑训练),社区驱动,对新模型支持更快(Llama-3 / Mistral 之类新发布的 24h 内适配)。

跟 LLaMA-Factory 二选一,中文场景 LLaMA-Factory 更熟,英文 Axolotl 社区更活。

2.11 实验跟踪:WandB / TensorBoard / SwanLab

生产建议: 训练 yaml 加 report_to: ["tensorboard", "wandb"] 双写,即使 WandB 出问题也有 TB 备份。

3. 训练模式深度(每个含原理 + 数据 + 命令 + 产物 + 最简测试)

3.1 Pre-training(PT)

原理: 在大量无标注语料上做下一 token 预测(causal LM loss),从零或继续训。

数据:

• 输入: 长文本 (一行一篇 / 多行 chunked)
• 格式: 纯文本 / JSONL {"text": "..."} / Parquet
• 量级: B 量级 token (10B+ 才有意义)

LLaMA-Factory 命令:

stage: pt
finetuning_type: full              # PT 一般全参
dataset: c4_demo                   # 你自己的预训语料
template: empty                    # PT 不用 chat template
cutoff_len: 4096

产物:

• pytorch_model.bin 或 model.safetensors(全参 ckpt)
• config.json / tokenizer.json / generation_config.json
• trainer_state.json(训练历史 loss)

最简测试(单卡跑通):

# 用 130M 极小模型 + 100 个 sample 跑 3 step 看 loss 下降
model_name_or_path: HuggingFaceTB/SmolLM2-135M
stage: pt
dataset: wikitext_demo_100rows
max_steps: 10
per_device_train_batch_size: 1
gradient_accumulation_steps: 1
output_dir: /tmp/pt-smoke
logging_steps: 1

预期: loss 从 ~3.5 降到 ~3.0(2 分钟内,单卡 CPU 也可跑)

3.2 SFT — Supervised Fine-Tuning(最常用)

原理: 在 instruction-output pairs 上训,只对 output 算 loss,prompt 部分 mask 掉。

数据格式(Alpaca):

{"instruction": "翻译成英文", "input": "你好", "output": "Hello"}

ShareGPT 多轮:

{"conversations": [
  {"from": "human", "value": "你是谁?"},
  {"from": "gpt", "value": "我是 Qwen。"},
  {"from": "human", "value": "几岁?"},
  {"from": "gpt", "value": "我是模型,没年龄。"}
]}

LLaMA-Factory 命令:

stage: sft
finetuning_type: lora              # 或 full / freeze
template: qwen                     # 关键!chat template 决定 input 格式
dataset: alpaca_zh_demo
cutoff_len: 2048
mask_history: true                 # 多轮时只对最后一轮 assistant 算 loss

产物(LoRA 模式):

• adapter_model.safetensors (LoRA 权重,几十 MB)
• adapter_config.json (rank/alpha/target_modules)
• chat_template.jinja

全参模式产物: 同 PT(完整模型 + tokenizer + config)

最简测试:

model_name_or_path: Qwen/Qwen2.5-0.5B-Instruct
stage: sft
finetuning_type: lora
dataset: alpaca_zh_demo            # 内置 50 sample demo
template: qwen
max_steps: 20
output_dir: /tmp/sft-smoke

预期: 20 step loss 从 ~2.0 降到 ~1.5,15 分钟内(1 张 24G GPU)

3.3 DPO — Direct Preference Optimization

原理: SFT 后的对齐技术,绕过 Reward Model + PPO,直接用偏好对优化。比 PPO 简单 100×,效果接近。

• Loss: -log σ(β × (log π(chosen) - log π_ref(chosen) - log π(rejected) + log π_ref(rejected)))

数据格式:

{
  "prompt": "如何减肥?",
  "chosen": "通过控制饮食 + 规律运动,逐步减少热量摄入...",
  "rejected": "吃减肥药,几天瘦 10 斤。"
}

LLaMA-Factory:

stage: dpo
finetuning_type: lora
dataset: dpo_zh_demo
template: qwen
pref_beta: 0.1                     # 偏好强度,经典 0.1
learning_rate: 5.0e-6              # ⚠️ 远小于 SFT (大于会破坏 SFT 后的能力)

产物: LoRA adapter 或全参 ckpt

最简测试:

model_name_or_path: Qwen/Qwen2.5-0.5B-Instruct   # 先 SFT 过的!
stage: dpo
dataset: dpo_en_demo
max_steps: 30

3.4 ORPO — Odds Ratio Preference Optimization

原理: DPO 进化版 — 不需要 SFT 阶段, SFT + DPO 一步到位,公式融合。适合从 base 直接对齐。

数据格式: 同 DPO(prompt/chosen/rejected)

stage: orpo
finetuning_type: lora
pref_beta: 0.1
learning_rate: 8.0e-6

3.5 KTO — Kahneman-Tversky Optimization

原理: 不需要 pair(chosen/rejected),只要"这个 response 好还是不好" 单值标签。数据更易收集。

数据格式:

{"prompt": "...", "completion": "...", "label": true}    // true = 好
{"prompt": "...", "completion": "...", "label": false}   // false = 不好

stage: kto
pref_beta: 0.1

3.6 PPO — Proximal Policy Optimization (经典 RLHF)

原理: 3 个模型同时跑:

• Actor (policy, 训练中)
• Critic (value head, 估优势)
• Reward Model (frozen, 给打分)
• 加 KL 约束防止偏离 SFT 太远

优点: 上限高(GPT-4 / Claude 用) 缺点: 训练不稳 / 显存 4× / 调参难

前置: 需要先训 Reward Model

stage: ppo
reward_model: ./saves/rm_qwen      # 训好的 RM
finetuning_type: lora
ppo_buffer_size: 1
ppo_score_norm: true
top_k: 0
top_p: 0.9

当 DPO 够用时不要碰 PPO — 工业 80% 项目已转 DPO/ORPO。

3.7 GRPO — Group Relative Policy Optimization

原理: DeepSeek-R1 / DeepSeek-Math 用的算法。无 Critic 网络(省 1 个模型),group sampling 算相对优势。

为啥火: 训推理能力(数学 / 代码)效果好,而且比 PPO 省显存 25%。

stage: grpo
reward_funcs:                      # 可写 reward 函数 (代码可执行 / math 答案匹配)
  - format_reward
  - accuracy_reward
num_generations: 8                 # 每 prompt 采 8 个 response 作 group

3.8 Reward Model (RM) 训练

原理: 训练一个 base model 输出 single scalar score。loss 是 pair-wise:-log σ(r_chosen - r_rejected)。

数据: 跟 DPO 同(prompt/chosen/rejected)

stage: rm
finetuning_type: lora
dataset: rm_zh_demo

产物: model with value head(v_head.bin)+ 主模型

3.9 Continued Pre-training (CPT)

原理: SFT 之前 / 之后,继续用领域语料做 next-token 预测。适合"通用 model + 法律/医疗/代码"场景。

关键:

• learning rate 小(2e-5,跟 PT 一样小)
• 一般加上 5-20% 原 pretrain 语料防遗忘(rehearsal)

stage: pt
finetuning_type: lora              # CPT + LoRA 是常见组合,省显存
dataset: legal_corpus_10b_token

3.10 Knowledge Distillation

原理: 大模型(teacher)给小模型(student)当监督信号。

• Hard distill: teacher 生成 SFT 数据,student 直接 SFT
• Soft distill: KL(student_logits, teacher_logits)
• On-policy: student 生成 → teacher 改正 → student 学

工业最常见: Hard distill — 用 GPT-4 / Claude 生成 100K 高质量 SFT 数据训自己的 7B。

3.11 多模态训练(VLM)

结构: Vision Encoder (CLIP/SigLIP/InternViT) + Projector + LLM

模式:

• Stage 1: 冻 ViT + LLM,只训 Projector(图文 align)
• Stage 2: 冻 ViT,训 Projector + LLM(指令跟随)
• Stage 3: 全参微调(RLHF/DPO)

# LLaMA-Factory Qwen2-VL 微调
model_name_or_path: Qwen/Qwen2-VL-7B-Instruct
stage: sft
visual_inputs: true                 # 关键
template: qwen2_vl
dataset: llava_mix_demo
freeze_vision_tower: true           # Stage 1/2 都冻

4. 输入/输出文件详解

4.1 训练数据格式

4.2 输出文件结构(全参 + LoRA 对比)

saves/qwen2.5-3b/full/sft/             ← 全参微调
├── config.json                        # 模型架构配置
├── generation_config.json             # 默认 sampling 参数
├── model.safetensors.index.json       # 分片索引
├── model-00001-of-00002.safetensors   # 模型权重(全)
├── model-00002-of-00002.safetensors
├── special_tokens_map.json            # 特殊 token
├── tokenizer.json                     # 主 tokenizer
├── tokenizer_config.json              # tokenizer 设置 (chat_template 在这)
├── trainer_state.json                 # 训练历史 (loss/lr 曲线)
├── training_args.bin                  # 训练参数 (用于 resume)
├── all_results.json                   # 最终 metrics
├── train_results.json
├── eval_results.json
└── checkpoint-1000/                   # 中间 checkpoint
    └── ... (同上结构 + optimizer.pt + rng_state.pth)


saves/qwen2.5-3b/lora/sft/             ← LoRA 模式
├── adapter_config.json                # rank/alpha/target_modules
├── adapter_model.safetensors          # 仅 LoRA 权重 (~40MB)
├── chat_template.jinja
├── special_tokens_map.json
├── tokenizer.json
├── tokenizer_config.json
├── trainer_state.json
└── README.md                          # LoRA 模型描述

关键文件解读:

4.3 转格式(推理优化)

# safetensors → GGUF (llama.cpp / Ollama 用)
python llama.cpp/convert_hf_to_gguf.py /path/to/model --outfile model.gguf

# safetensors → AWQ INT4 (vLLM 友好)
python -m awq.entry --model_path /path/to/model \
  --w_bit 4 --q_group_size 128 --version GEMM \
  --save_path /path/to/model-awq

# safetensors → GPTQ
python -m auto_gptq --model_path /path/to/model --bits 4 \
  --group_size 128 --save_path ...

# LoRA adapter merge 回 base (生成完整 model 可被 vLLM 加载)
python -m peft.merge_lora --base_model Qwen/Qwen2.5-7B \
  --adapter ./adapter --output ./merged

5. 最简完整测试 — 从零跑通端到端

场景: Qwen2.5-0.5B + LoRA SFT 在 50 行 alpaca 数据上跑 20 step

环境准备 (单 GPU 24G 即可,A800 切 1g.5gb MIG 也行):

# 1. 装依赖
pip install -U llamafactory[torch,metrics] bitsandbytes

# 2. clone LLaMA-Factory 内置 demo 数据
git clone https://github.com/hiyouga/LLaMA-Factory
cd LLaMA-Factory

# 3. 写 yaml
cat > smoke_sft.yaml <<EOF
model_name_or_path: Qwen/Qwen2.5-0.5B-Instruct

stage: sft
do_train: true
finetuning_type: lora
lora_target: all
lora_rank: 8
lora_alpha: 16

template: qwen
dataset: alpaca_zh_demo      # 内置 50 sample
cutoff_len: 1024
max_samples: 50

output_dir: /tmp/smoke_sft
overwrite_output_dir: true
logging_steps: 1
save_steps: 50
plot_loss: true

per_device_train_batch_size: 1
gradient_accumulation_steps: 4
learning_rate: 1.0e-4
max_steps: 20
lr_scheduler_type: cosine
warmup_ratio: 0.1
bf16: true
EOF

# 4. 跑
llamafactory-cli train smoke_sft.yaml

预期输出 (15 分钟内):

[INFO] trainable params: 1,081,344 || all params: 495M (0.22%)
Step 1/20 | loss: 2.13 | lr: 1e-5 | grad_norm: 0.51
Step 5/20 | loss: 1.87 | lr: 5e-5
Step 10/20 | loss: 1.62 | lr: 1e-4
Step 15/20 | loss: 1.51 | lr: 8e-5
Step 20/20 | loss: 1.44 | lr: 5e-5
[INFO] Training completed. Loss curve saved to training_loss.png

产物:

ls /tmp/smoke_sft/
# adapter_config.json adapter_model.safetensors  
# chat_template.jinja training_args.bin trainer_state.json
# training_loss.png    tokenizer*  README.md

验证推理:

# 用 LoRA + base model 直接推理
llamafactory-cli chat \
  --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
  --adapter_name_or_path /tmp/smoke_sft \
  --template qwen \
  --finetuning_type lora
# 进入对话:
> 你好
< 你好!很高兴为您服务,请问有什么可以帮助您的吗?

Merge 后用 vLLM 服务化 (跟 Day 8 联动):

llamafactory-cli export \
  --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
  --adapter_name_or_path /tmp/smoke_sft \
  --template qwen \
  --finetuning_type lora \
  --export_dir /tmp/smoke_merged \
  --export_size 5

# 起 vLLM
python -m vllm.entrypoints.openai.api_server \
  --model /tmp/smoke_merged \
  --served-model-name my-qwen-sft \
  --port 8000

# 调用
curl localhost:8000/v1/chat/completions \
  -d '{"model":"my-qwen-sft","messages":[{"role":"user","content":"你好"}]}'

6. K8s 上跑训练 — TrainingJob CRD 草案

跟 Day 13.A LLM Operator 同理,可写 TrainingJob CRD:

apiVersion: training.bootcamp.local/v1
kind: TrainingJob
metadata: {name: qwen-sft-job-001}
spec:
  baseModel: Qwen/Qwen2.5-7B-Instruct
  stage: sft                       # pt / sft / dpo / orpo / kto / ppo / grpo
  finetuningType: lora             # full / lora / qlora
  loraConfig:
    rank: 16
    alpha: 32
    targetModules: [q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj]
  dataset:
    source: s3://bucket/alpaca-zh.jsonl
    template: qwen
    cutoffLen: 4096
  hyperparams:
    epochs: 3
    perDeviceBatchSize: 1
    gradientAccumulation: 8
    learningRate: 1.0e-4
  resources:
    gpuCount: 4
    gpuType: A800
    distributedFramework: deepspeed_z3   # ddp / fsdp / deepspeed_z3
  output:
    target: s3://bucket/saves/qwen-sft-job-001/
    pushToRegistry: harbor.local/models/qwen-sft:v1   # 训完自动 push
  monitoring:
    wandb: true
    tensorboard: true

Reconciler 工作:

1. 解析 spec → 生成 LLaMA-Factory yaml
2. 创建 Job(NVIDIA Device Plugin GPU 申请 + Longhorn PVC 存 checkpoint)
3. 训练完成 → push merged model 到 Harbor
4. 触发 LLMService CR(Day 13.A)自动起 vLLM 服务化

这就是工业级 AI Platform 的样子 — TrainingJob CRD → LLMService CRD 一气呵成。

7. 学习路径推荐

Week 1: 基本概念 + transformers.Trainer + LoRA
  ├─ HuggingFace course (https://huggingface.co/learn)
  └─ 跟着 Qwen 官方 fine-tuning notebook 跑一遍

Week 2: LLaMA-Factory + 一个真实 SFT 数据
  └─ 在内部数据上 SFT Qwen2.5-7B,看 loss 曲线 + 评测

Week 3: DPO/ORPO + Reward Model
  └─ TRL 跑通 DPO,理解 β 调参

Week 4: 分布式 (DeepSpeed Z3 / FSDP)
  └─ 多卡 / 多机训练大模型

Week 5+: 进阶
  - GRPO + 自定义 reward function
  - Megatron-LM (要训 70B+)
  - 多模态 VLM

99. 跟 Day 1-14 的联动

面试金句: "我能在 K8s 平台上跑端到端的训练→评测→部署→服务化流水线,包括 SFT/DPO/GRPO 主流训练模式,使用 LLaMA-Factory + DeepSpeed + Megatron 不同规模的分布式策略,产物从训完即通过 ArgoCD 自动同步到 vLLM 推理服务"。

文档: ~/Downloads/k8s-2week-bootcamp/Bonus-LLM-Training-Manual.md