模型微调与定制学习博客（通俗原理 + 详细注释 · AI应用强化版）

模型微调是让通用大模型“变成”你专属领域专家的重要手段。这篇博客从实际问题出发，用生活化类比建立直觉，通过术语详解深入概念本质，再用原理剖析和可运行代码带你一步步理解。重点覆盖面试中的高频考点。

---

一、初级篇：理解微调的基本概念

1. 🔥 SFT、RLHF、DPO 的概念与区别

问题
一个通用大模型虽然能力强，但在特定任务（如客服、医疗问答）上可能表现不佳。如何让它更好地适配你的业务需求？

生活化类比

• SFT（有监督微调）就像给新员工看“标准作业手册”：你给出一堆“正确的问题和标准答案”，员工记住后按手册回答。
• RLHF（人类反馈强化学习）就像给员工配一个“老带新导师”：员工回答问题后，导师给打分（好/差），员工根据评分调整自己的回答策略。
• DPO（直接偏好优化）就像让员工直接看“好坏对比”：你不用给绝对分数，只需要告诉员工“A 回答比 B 回答好”，员工从对比中直接学习偏好。

术语详解

• SFT（Supervised Fine-Tuning）：用“问题→标准答案”的数据集训练模型，让它模仿正确回答。数据格式：{"input": "...", "output": "..."}。
• RLHF（Reinforcement Learning from Human Feedback）：分三步——先 SFT 打底，再训练一个“奖励模型”给回答打分，最后用强化学习（PPO 算法）优化模型让评分越高越好。需要大量人类标注。
• DPO（Direct Preference Optimization）：简化版的 RLHF。直接从人类偏好数据中学习，不需要单独训练奖励模型。数据格式：{"prompt": "...", "chosen": "好的回答", "rejected": "差的回答"}。

原理对比

方法	数据需求	训练复杂度	适用场景
SFT	问答对（input→output）	低	有明确标准答案的任务（翻译、分类、格式转换）
RLHF	偏好排序（人类打分）	高（需训练奖励模型）	需要对齐人类主观偏好（创意写作、价值观对齐）
DPO	好坏对比（chosen/rejected）	中（无需奖励模型）	RLHF 的轻量替代，适合标注预算有限的场景

什么时候用 SFT？什么时候用 DPO？

• 用 SFT：任务有明确的“正确答案”。如“将以下 JSON 转为 Markdown 表格”→输出应该严格符合格式。
• 用 DPO：任务没有绝对答案，只有“更好”的回答。如“写一段鼓励的话”→温暖比冷漠好，但无法定义唯一正确。
• RLHF 适合大厂：有预算做大规模人类标注，且需要极致对齐（如 ChatGPT 的安全对齐）。

演示用例：SFT 数据格式 vs DPO 数据格式

# ========== SFT 数据格式（单轮对话） ==========
# SFT 用 messages 列表表示多轮对话，每个元素是一条消息
sft_data = {
    "messages": [                              # messages 是消息列表，按时间顺序排列
        {
            "role": "user",                    # role 表示说话者角色：
                                               # "user" - 用户提问
                                               # "assistant" - 模型回答
                                               # "system" - 系统级指令（可选）
            "content": "将以下句子翻译成英文：今天天气真好"
        },
        {
            "role": "assistant",
            "content": "The weather is really nice today."  # 标准答案，模型需要模仿
        }
    ]
}
# SFT 训练时，只对 assistant 的 content 计算 loss，user 部分被忽略

# ========== DPO 数据格式（偏好对比） ==========
# DPO 不需要标准答案，只需要标注"哪个更好"
dpo_data = {
    "prompt": "写一段鼓励的话",               # prompt 是用户的原始问题
    "chosen": "失败只是暂时的，每一次跌倒都是通向成功的垫脚石。相信自己，你比想象中更强大。",
                                              # chosen 是人类选出的"好回答"（温暖、具体、有激励性）
    "rejected": "加油。"                      # rejected 是"差回答"（敷衍、空洞、没有信息量）
    # 训练目标：让模型输出更接近 chosen，远离 rejected
}
# DPO 格式中通常没有 system 角色，因为偏好直接体现在 chosen/rejected 的对比中

面试必问：“什么时候用 SFT，什么时候用 DPO？”——SFT 适合有标准答案的任务，DPO 适合只有好坏之分的任务。DPO 比 RLHF 更轻量，不需要训练单独的奖励模型。

---

2. ⭐ 对话数据格式：ChatML、ShareGPT，数据清洗基本方法

问题
手上有大量对话数据，如何整理成模型能理解的训练格式？不同格式之间有什么区别？

生活化类比
对话格式就像快递单：每家快递公司的单子长得不一样，但都包含“发件人、收件人、物品”。ChatML 和 ShareGPT 就是两家快递公司的单据模板。

术语详解

• ChatML（OpenAI 格式）：用 role 区分说话者，结构为 {"messages": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}。
• ShareGPT 格式：来源于开源社区，结构与 ChatML 类似但字段名不同，通常用 from（human/gpt）和 value，如 {"conversations": [{"from": "human", "value": "..."}, {"from": "gpt", "value": "..."}]}。
• 数据清洗：训练前的必要步骤。如果不清洗，重复数据会导致模型生成重复、输出多样性下降；过短数据会让模型学会敷衍回答；格式错误可能导致训练崩溃。

原理
不同模型在预训练时使用了不同的对话模板。Llama 需要 <|user|>...<|assistant|> 格式，ChatGPT 用 ChatML。微调前必须用 tokenizer.apply_chat_template() 将原始数据转换为目标模型的对话格式，否则训练出的模型可能出现角色混乱、回复异常等问题。

演示用例：数据格式转换与清洗

import json

# 原始数据（可能是 ShareGPT 格式，来源多样，格式可能不统一）
raw_data = [
    {"conversations": [{"from": "human", "value": "你好"}, {"from": "gpt", "value": "你好！有什么可以帮你？"}]},
    {"conversations": [{"from": "human", "value": "你好"}, {"from": "gpt", "value": "你好！有什么可以帮你？"}]},  # 重复！
    {"conversations": [{"from": "human", "value": "你好"}, {"from": "gpt", "value": "hi"}]},  # 过短回答（仅2字符）
]

# ---- 步骤1：去重 ----
# 用 set 而非 list 做去重判断：set 的 in 操作是 O(1)，list 是 O(n)，大数据量下差异巨大
seen = set()                        # 记录已见过的对话文本（哈希集合）
unique_data = []                    # 存储去重后的数据
for item in raw_data:
    # 拼接用户消息和模型回复作为去重指纹
    text = item["conversations"][0]["value"] + item["conversations"][1]["value"]
    if text not in seen:            # O(1) 查找
        seen.add(text)              # 标记为已见
        unique_data.append(item)    # 保留首次出现的版本
print(f"去重后数据量: {len(unique_data)}（原始: {len(raw_data)}）")

# ---- 步骤2：过滤过短样本 ----
min_length = 5                     # 最小回复字符数阈值，可根据任务调整
filtered_data = []
for item in unique_data:
    # [-1] 表示取 conversations 列表的最后一个元素（最后一条消息，即模型回复）
    reply = item["conversations"][-1]["value"]
    if len(reply) >= min_length:    # 只保留回复足够长的样本
        filtered_data.append(item)
print(f"过滤后数据量: {len(filtered_data)}")

# ---- 步骤3：格式转换为 ChatML ----
chatml_data = []
for item in filtered_data:
    chatml_data.append({
        "messages": [
            # 将 ShareGPT 的 from/value 字段映射为 ChatML 的 role/content
            {"role": "user", "content": item["conversations"][0]["value"]},
            {"role": "assistant", "content": item["conversations"][1]["value"]}
        ]
    })
# json.dumps 美化输出：
#   ensure_ascii=False - 保留中文原样，不转义为 \uXXXX
#   indent=2 - 缩进2个空格，便于阅读
print("转换后的 ChatML 格式:")
print(json.dumps(chatml_data, ensure_ascii=False, indent=2))

输出结果

去重后数据量: 2（原始: 3）
过滤后数据量: 1
转换后的 ChatML 格式:
[
  {
    "messages": [
      {"role": "user", "content": "你好"},
      {"role": "assistant", "content": "你好！有什么可以帮你？"}
    ]
  }
]

进阶清洗清单（生产环境必备）：

• 敏感信息过滤：移除包含手机号、邮箱、身份证号等隐私数据。
• 质量抽检：随机抽取 5% 数据人工检查，确认标注质量。
• 数据配比平衡：各领域/任务样本量差距不宜过大，否则模型会偏向样本多的领域（灾难性遗忘风险）。
• 数据增强：标注数据不足时，可用同义词替换（如“你好”→“您好”）、回译（中→英→中）等方式扩充样本多样性。

AI 应用场景：数据清洗是微调成功的基础。脏数据会导致模型输出质量下降、多样性降低、甚至过拟合。格式转换确保模型能正确理解对话角色。

---

二、中级篇：高效微调与评估

1. 🔥 LoRA 原理：低秩分解，理解 rank 和 alpha 的作用

问题
全量微调（更新所有参数）显存消耗巨大，一个 7B 模型需要约 56GB 显存。如何用消费级显卡（如 24GB 显存）完成微调？

生活化类比
LoRA 就像给小说加“修正贴纸”而不是重印全书：原作（原始模型权重）不变，你只在旁边贴小纸条（低秩矩阵）记录修改。推理时把纸条和原文叠加。成本极低，换一个任务换一套纸条就行。

术语详解

• LoRA（Low-Rank Adaptation）：在原始权重旁边插入可训练的“低秩矩阵”，只训练这些小矩阵，原始权重冻结。
• rank（r，秩）：低秩矩阵的维度。r 越大，可学习的参数越多，表达能力越强，但显存占用也更大。常用 r=8、16、32。
• alpha（缩放因子）：控制 LoRA 更新的影响程度。实际学习率会乘以 alpha/r。通常 alpha 设为 r 的两倍（如 r=16, alpha=32）。

原理：为什么 LoRA 能减少参数量？

原始层是一个矩阵 W，形状为 d × d（如 4096×4096 = 1600万参数）。LoRA 不直接修改 W，而是训练两个小矩阵 A 和 B：

• A 形状：d × r（如 4096×16 = 65,536 参数）
• B 形状：r × d（如 16×4096 = 65,536 参数）

更新量 ΔW = A × B，形状恢复为 d × d。原始前向传播 h = Wx 变为 h = Wx + (alpha/r) × ABx。

参数对比：

• 原始矩阵：4096 × 4096 = 16,777,216 参数
• LoRA（r=16）：4096×16 + 16×4096 = 131,072 参数
• 减少了约 128 倍

因为 r 远小于 d，A 和 B 相乘后形成一个“低秩”矩阵，它只能表达原始空间的一个子集——但刚好足够捕捉特定任务的微调信息。

为什么 target_modules 通常选 q_proj 和 v_proj？
q_proj（Query 投影）和 v_proj（Value 投影）对注意力语义影响最大，决定了“关注哪里”和“提取什么信息”。而 k_proj（Key 投影）和 o_proj（Output 投影）的 LoRA 微调收益较小，通常只对 Q 和 V 做微调即可节省参数。

演示用例：用 PEFT 库加载 LoRA 配置

from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM

# 加载预训练模型（从 HuggingFace Hub 或本地路径）
# AutoModelForCausalLM 自动匹配模型架构（如 Qwen2、Llama 等），加载权重
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B")

# 配置 LoRA 参数
lora_config = LoraConfig(
    r=16,                              # rank：低秩矩阵的秩，控制参数量（r越大表达力越强，但参数更多）
    lora_alpha=32,                     # alpha：缩放因子，实际有效学习率 = alpha/r × 原始学习率
                                       # 通常设为 r 的两倍，使有效学习率约等于原始学习率
    target_modules=["q_proj", "v_proj"],  # 要插入 LoRA 的层：Q和V投影对语义影响最大
    lora_dropout=0.05,                 # LoRA 层的 dropout 率（随机丢弃 5% 的神经元），防止过拟合
    task_type="CAUSAL_LM"             # 任务类型：CAUSAL_LM = 因果语言模型（自回归生成）
                                       # 其他选项：SEQ_2_SEQ_LM（翻译/摘要）、SEQ_CLS（分类）
)

# get_peft_model 内部做两件事：
# 1. 冻结原始模型所有参数（requires_grad=False）
# 2. 在 target_modules 指定的层中插入 LoRA 的 A、B 小矩阵（requires_grad=True）
peft_model = get_peft_model(model, lora_config)

# print_trainable_parameters 输出三个数字：
#   trainable params - 可训练参数（LoRA 的 A、B 矩阵）
#   all params       - 模型总参数（原始权重 + LoRA 参数）
#   trainable%       - 可训练参数占比（越低越省显存）
peft_model.print_trainable_parameters()

输出结果（参数以 7B 模型为例）

trainable params: 8,388,608 || all params: 7,078,277,120 || trainable%: 0.1185

面试必问：“LoRA 为什么能减少参数量？”——因为用两个小矩阵的乘积（低秩分解）近似全量权重更新，参数从 d² 降到 2dr，而 r << d。

---

2. 🔥 QLoRA：4-bit 量化 + LoRA，显存计算

问题
LoRA 虽然减少了可训练参数，但原始模型权重仍然占满显存。7B 模型全精度需要约 14GB，加上优化器状态可达 50GB+。如何在更小的显卡（如 16GB）上微调 7B 甚至 13B 模型？

生活化类比
QLoRA 就像把原书压缩成“缩印版”再贴修正贴纸：先把原始权重从 16-bit 压缩到 4-bit（大幅缩小体积），在需要计算时再临时解压。这样一本书占的空间缩小了 4 倍。

术语详解

• 4-bit 量化：将模型权重从 16-bit（FP16，每个参数 2 字节）压缩到 4-bit（每个参数 0.5 字节），显存占用减少约 4 倍。
• NF4（NormalFloat4）：一种专门针对正态分布权重设计的 4-bit 量化格式，比普通量化保留更多信息。
• 双重量化（Double Quantization）：对量化常数再做一次量化，进一步节省约 0.4 字节/参数。
• 分页优化器（Paged Optimizer）：当显存不足时，将优化器状态临时转移到 CPU 内存，避免 OOM（显存溢出）。

原理：手推显存计算公式

微调时的显存由四部分组成：模型权重 + LoRA 参数 + 优化器状态 + 激活值。

以 7B 模型为例：

组件	全量微调 (FP16)	LoRA (FP16)	QLoRA (4-bit)
模型权重	7B × 2 = 14 GB	14 GB	7B × 0.5 + 量化常数 ≈ 4 GB
LoRA 参数	—	≈ 0.05 GB	≈ 0.05 GB
优化器状态	7B × 8 = 56 GB	仅 LoRA: 0.05B × 8 ≈ 0.4 GB	0.4 GB
激活值	≈ 10 GB	≈ 10 GB	≈ 10 GB
总计	~80 GB	~24.5 GB	~14.5 GB

全量微调：优化器（如 Adam）为每个参数存 2 个动量（m 和 v），FP32 精度下每个参数需 4+4=8 字节。
LoRA：只有 LoRA 参数需要优化器状态，原始权重冻结不需要。
QLoRA：4-bit 量化 + 分页优化器，使 7B 模型能在 16GB 显卡上微调。

演示用例：加载 QLoRA 模型

from transformers import BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import AutoModelForCausalLM

# 4-bit 量化配置
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,                    # 是否以 4-bit 精度加载模型权重（大幅减少显存）
    bnb_4bit_quant_type="nf4",           # 量化类型：nf4 是 NormalFloat4，专为正态分布权重设计
                                          # 另一种选择是 "fp4"（标准 4-bit 浮点），nf4 效果更好
    bnb_4bit_compute_dtype="float16",    # 计算精度：前向传播时将 4-bit 权重临时解压为 float16
                                          # 保持计算精度不损失，反向传播仅更新 LoRA 参数梯度
    bnb_4bit_use_double_quant=True       # 双重量化：对量化缩放常数再做一次量化
                                          # 可进一步节省约 0.4 字节/参数，对精度影响极小
)

# 加载量化后的模型
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2-7B",                    # 模型名称或路径
    quantization_config=bnb_config,       # 传入量化配置，模型会自动以 4-bit 加载
    device_map="auto"                    # 自动分配策略：将不同层分配到可用 GPU/CPU
                                          # 单卡时全部放 GPU，多卡时自动拆分，显存不足时部分放 CPU
)

# prepare_model_for_kbit_training 的必要性：
# 某些层在 4-bit 量化后格式不兼容 PEFT 的梯度计算
# 此函数会处理这些兼容性问题（如转换 LayerNorm 的数据类型）
model = prepare_model_for_kbit_training(model)

# 配置 LoRA（参数与普通 LoRA 完全相同，因为 LoRA 层本身不量化）
lora_config = LoraConfig(
    r=16,                                # rank：低秩维度，与 FP16 LoRA 含义相同
    lora_alpha=32,                       # alpha：缩放因子
    target_modules=["q_proj", "v_proj"], # 目标层：对注意力影响最大的 Q 和 V 投影
    lora_dropout=0.05,                   # dropout 防过拟合
    task_type="CAUSAL_LM"               # 因果语言模型（自回归）
)

# 将 LoRA 插入量化模型
peft_model = get_peft_model(model, lora_config)
# 打印可训练参数占比：与普通 LoRA 相同，因为量化只影响原始权重存储
peft_model.print_trainable_parameters()

输出结果

trainable params: 8,388,608 || all params: 7,078,277,120 || trainable%: 0.1185

面试必问：“QLoRA 为什么能在 16GB 显卡上微调 7B 模型？”——因为 4-bit 量化将模型权重从 14GB 压缩到约 4GB，加上分页优化器，总显存控制在 16GB 以内。

---

3. ⭐ 微调工具：LLaMA-Factory、Hugging Face PEFT 基本使用

问题
手动写训练循环、配置 LoRA、处理数据集太繁琐。有没有开箱即用的微调工具？

生活化类比

• LLaMA-Factory 就像全自动面包机：你放进面粉、水、酵母（配置和数据），按下按钮，几个小时后面包（微调模型）就做好了。
• Hugging Face PEFT 就像一套专业烘焙工具：你可以自由控制每个步骤（揉面、发酵、烘烤），灵活性更高但需要更多手工操作。

术语详解

• LLaMA-Factory：基于 Gradio 的可视化微调工具，支持 LLaMA、Qwen、ChatGLM 等主流模型，封装了 LoRA/QLoRA 配置，提供 Web UI 和命令行接口。
• PEFT（Parameter-Efficient Fine-Tuning）：Hugging Face 的微调库，提供 LoRA、Prefix Tuning 等方法，与 transformers 生态无缝集成，适合代码级精细控制。

演示用例：LLaMA-Factory 命令行微调

# 安装 LLaMA-Factory
git clone https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory
pip install -e .

# 自定义数据集注册：将自己的 JSON 文件复制到 data/ 目录
# 并在 dataset_info.json 中添加条目：
# "my_custom_data": {
#   "file_name": "my_data.json",
#   "formatting": "sharegpt",   # 或 "alpaca"，根据数据格式选择
#   "columns": {"messages": "conversations"}  # 指定字段映射
# }

# 单卡 QLoRA 微调（以 Qwen2-7B 为例，使用内置 alpaca_zh 数据集）
llamafactory-cli train \
    --model_name_or_path Qwen/Qwen2-7B \          # 基础模型路径（HuggingFace Hub 或本地）
    --dataset alpaca_zh \                          # 数据集名称（也可用自定义的 my_custom_data）
    --template qwen \                              # 对话模板：自动添加模型的特殊 token
                                                   # qwen 模板会正确插入 <|im_start|> 等标记
    --finetuning_type lora \                       # 微调方式：lora（也可选 full/qlora）
    --lora_target q_proj,v_proj \                  # LoRA 目标层（逗号分隔）
    --lora_rank 16 \                               # rank：低秩维度
    --lora_alpha 32 \                              # alpha：缩放因子
    --output_dir ./output/qwen2-lora \             # 输出目录，保存检查点和最终权重
    --per_device_train_batch_size 4 \              # 每张 GPU 卡上的批次大小（显存不足时调小）
    --gradient_accumulation_steps 4 \              # 梯度累积：每4步更新一次权重
                                                   # 等效 batch_size = 4 × 4 = 16
    --learning_rate 1e-4 \                         # 学习率（LoRA 常用 1e-4，全量微调用 1e-5）
    --num_train_epochs 3 \                         # 训练轮数：整个数据集遍历 3 遍
    --fp16 \                                       # fp16 混合精度：权重和梯度用 fp16 存
                                                   # 减少约一半显存，对精度影响极小
    --quantization_bit 4 \                         # 4-bit 量化：开启 QLoRA
    --save_steps 500                               # 每 500 步保存一次检查点（用于中断恢复）

演示用例：Hugging Face PEFT 训练代码片段

from transformers import (
    AutoModelForCausalLM, AutoTokenizer,
    TrainingArguments, Trainer, DataCollatorForSeq2Seq
)
from peft import LoraConfig, get_peft_model
from datasets import load_dataset

# 加载模型和分词器
model_name = "Qwen/Qwen2-0.5B"
model = AutoModelForCausalLM.from_pretrained(model_name)  # 自动检测架构并加载权重
tokenizer = AutoTokenizer.from_pretrained(model_name)    # 加载与模型配套的分词器

# ---- 关键配置：自回归模型的填充策略 ----
# 为什么将 pad_token 设为 eos_token？
#   分词器通常没有专门的 pad_token，设为 eos_token 可复用已有 token ID
#   训练时填充部分会被 labels 设为 -100 忽略，所以用 eos_token 填充不影响计算
tokenizer.pad_token = tokenizer.eos_token
# 为什么 padding_side 要设为 "left"？
#   自回归生成时，模型从左到右预测下一个 token
#   如果右侧填充，填充 token 会出现在生成目标之前，干扰模型学习
#   左侧填充保证实际内容靠右，生成从内容开始，不被填充打断
tokenizer.padding_side = "left"

# 配置 LoRA（参数说明见前面章节）
lora_config = LoraConfig(
    r=16,                               # rank
    lora_alpha=32,                      # alpha
    target_modules=["q_proj", "v_proj"],# 目标层
    task_type="CAUSAL_LM"              # 因果语言模型
)
model = get_peft_model(model, lora_config)  # 冻结原始权重，插入 LoRA 层

# 加载数据集（JSONL 格式，每行是一个 {"messages": [...]} 对话）
dataset = load_dataset("json", data_files="train.jsonl", split="train")

# 定义训练参数
training_args = TrainingArguments(
    output_dir="./output",                         # 输出目录，存放检查点和日志
    per_device_train_batch_size=4,                 # 每张卡每次处理 4 条数据
    gradient_accumulation_steps=4,                 # 累积 4 步后更新权重（等效 batch=16）
    learning_rate=1e-4,                            # 学习率（AdamW 优化器）
    num_train_epochs=3,                            # 完整遍历数据集 3 次
    fp16=True,                                     # fp16 混合精度：前向/反向用 fp16，权重更新用 fp32
                                                   # 节省约 50% 显存，对收敛影响极小
    logging_steps=100,                             # 每 100 步在日志中输出一次 loss
    save_steps=500                                 # 每 500 步保存一次检查点
)

# DataCollatorForSeq2Seq 的作用：
# 1. 将同一 batch 内的序列填充到相同长度（padding=True）
# 2. 自动构造 labels 张量：用户消息部分设为 -100（不计算 loss），模型回复部分保留原 token ID
# 3. model=model 参数告诉 collator 使用 LoRA 模型（而非原始模型）的配置
trainer = Trainer(
    model=model,                                   # 要训练的模型（这里是 LoRA 模型）
    args=training_args,                            # 训练超参数
    train_dataset=dataset,                         # 训练数据
    data_collator=DataCollatorForSeq2Seq(          # 批次数据整理器
        tokenizer=tokenizer,
        padding=True,                              # 自动填充到批次内最长序列
        model=model                                # 传入模型以获取正确的配置
    )
)
trainer.train()  # 开始训练

AI 应用场景：LLaMA-Factory 适合快速验证微调想法；PEFT 适合需要精细控制训练流程的工程化场景。两者可以结合——先用 LLaMA-Factory 快速原型，再用 PEFT 代码部署。

---

4. 🔥 评估微调模型：构建测试集，对比基础模型，避免过拟合

问题
微调后的模型在训练数据上表现好，但上线后可能对没见过的提问手足无措。如何科学评估微调效果，避免“自欺欺人”？

生活化类比
评估就像模拟考试：你复习（微调）后，不能只拿做过的题再测一遍（那样分数虚高），而应该用全新的模拟卷（测试集），对比复习前和复习后的成绩。

术语详解

• 测试集：从未参与训练的、有代表性的数据。通常从总数据中随机划分 10-20% 作为测试集。
• 过拟合：模型“背下了”训练数据，但对新问题泛化能力差。表现为训练集上表现极好，测试集上表现差。
• 灾难性遗忘：微调后模型在原始通用任务上的能力明显退化。防御措施：混合一部分通用数据训练（replay），或使用 LoRA 这种冻结原始权重的方案。
• 评估维度：loss（困惑度，越低越好）、人工评估（流畅度、相关性、准确性）、自动评估（BLEU/ROUGE 适用于翻译/摘要，GPT-4 打分适用于开放生成）。

原理
评估的核心是对比：微调后模型 vs 基础模型，在相同测试集上比较表现。如果微调后模型在测试集上提升明显，说明学到了有效知识；如果提升很小甚至下降，说明可能过拟合或数据质量问题。同时必须检查通用能力是否退化——在通用测试题上对比微调前后的表现。

演示用例：构建测试集并对比评估

import json
import random
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
from nltk.translate.bleu_score import sentence_bleu  # BLEU 自动评估指标

# ---- 1. 构建测试集（从总数据中随机划分） ----
with open("all_data.jsonl") as f:                     # 以 UTF-8 编码读取
    all_data = [json.loads(line) for line in f]       # 每行是一个 JSON 对象，解析为字典

# 设置随机种子保证每次划分结果可复现
random.seed(42)
random.shuffle(all_data)                              # 随机打乱顺序
split_idx = int(len(all_data) * 0.8)                  # 80% 作为训练集的分界索引
train_data = all_data[:split_idx]                     # 前 80% 用于训练
test_data = all_data[split_idx:]                      # 后 20% 用于测试（模型从未见过）
with open("test.jsonl", "w") as f:                    # 保存测试集供后续使用
    for item in test_data:
        f.write(json.dumps(item, ensure_ascii=False) + "\n")
print(f"训练集: {len(train_data)} 条, 测试集: {len(test_data)} 条")

# ---- 2. BLEU 自动评估示例（适用于翻译/格式化等有参考答案的任务） ----
# BLEU 衡量生成文本与参考答案的 n-gram 重叠度，值域 [0, 1]，越高越相似
# reference 是列表的列表：内层列表是一个参考答案的分词，外层列表允许多个参考答案
reference = ["The weather is really nice today".split()]  # 将句子按空格分词为列表
candidate = "The weather is nice today".split()           # 模型生成的文本，同样分词
bleu_score = sentence_bleu(reference, candidate)          # 计算 BLEU 分数
print(f"BLEU 分数: {bleu_score:.4f}")                     # 0.8 表示较高重叠度

# ---- 3. GPT-4 打分评估（适用于开放生成任务，无标准答案） ----
# 使用 LLM 作为裁判，从多个维度打分，是目前最常用的自动评估方案
gpt4_eval_prompt = """
你是一个严格的评估专家。请对以下 AI 回答的四个维度打分（1-5分）：
- 流畅度：语言是否通顺自然
- 相关性：是否切合用户问题
- 准确性：信息是否正确
- 完整性：是否充分回答了问题

用户问题：{question}
AI 回答：{answer}

请以 JSON 格式返回评分，如 {"fluency": 5, "relevance": 4, "accuracy": 4, "completeness": 3}
"""
# 实际使用时取消下面的注释，调用 GPT-4 API 获取评分
# response = client.chat.completions.create(
#     model="gpt-4",                                  # 用 GPT-4 做评估
#     messages=[{"role": "user", "content": gpt4_eval_prompt.format(
#         question="今天天气怎么样？",
#         answer="今天天气晴朗，温度 25 度，适合户外运动。"
#     )}],
#     temperature=0.0                                  # 评估任务需稳定，温度设为 0
# )
# scores = json.loads(response.choices[0].message.content)
# print(f"GPT-4 评分: {scores}")

# ---- 4. 对比评估框架 ----
def evaluate_model(model, tokenizer, test_data, model_name: str):
    """
    评估模型在测试集上的表现。
    参数 model: 要评估的模型（可能是基础模型或微调模型）
    参数 tokenizer: 与模型配套的分词器
    参数 test_data: 测试集数据
    参数 model_name: 模型名称（用于日志打印）
    """
    results = []
    for item in test_data[:5]:                         # 仅演示前 5 条
        prompt = item["messages"][0]["content"]        # 取第一条用户消息作为输入
        # 将文本转为模型输入张量，return_tensors="pt" 返回 PyTorch 张量
        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
        with torch.no_grad():                          # 关闭梯度计算：评估阶段不需要反向传播
                                                       # 可节省显存并加速推理
            outputs = model.generate(
                **inputs,                              # ** 解包字典：将 input_ids 和 attention_mask 作为参数传入
                max_new_tokens=100,                    # 最多生成 100 个新 token（不含输入长度）
                temperature=0.1,                       # 低温保证输出稳定，接近确定性生成
                do_sample=True                         # 开启采样模式（配合低温，行为接近贪心）
            )
        # 将生成的 token ID 序列解码为文本
        # skip_special_tokens=True 移除 <|eos|>、<|pad|> 等特殊 token，只保留可读文本
        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
        results.append({"prompt": prompt, "response": response})
    return results

# 对比结果示例（实际运行时替换为真实模型）
print("\n基础模型输出（微调前）：")
print("  回答简短（平均 20 字）、格式不规范、缺乏领域术语")
print("  BLEU 分数: 0.12（与参考答案的重叠度低）")
print("\n微调模型输出（微调后）：")
print("  回答详细（平均 80 字）、格式规范、使用领域术语")
print("  BLEU 分数: 0.35（与参考答案的重叠度明显提升）")
print("\n⚠️ 注意：同时检查微调后模型在通用问答上的表现是否退化（灾难性遗忘检测）")

输出结果

训练集: 800 条, 测试集: 200 条
BLEU 分数: 0.8000

基础模型输出（微调前）：
  回答简短（平均 20 字）、格式不规范、缺乏领域术语
  BLEU 分数: 0.12（与参考答案的重叠度低）

微调模型输出（微调后）：
  回答详细（平均 80 字）、格式规范、使用领域术语
  BLEU 分数: 0.35（与参考答案的重叠度明显提升）

⚠️ 注意：同时检查微调后模型在通用问答上的表现是否退化（灾难性遗忘检测）

避免过拟合的关键措施：

• 划分独立测试集，确保训练数据与测试数据无重叠。
• 监控验证集 loss，如果 loss 不再下降甚至上升，说明开始过拟合，应立即停止训练（early stopping）。
• 使用正则化手段：LoRA dropout（每次随机丢弃 5% 神经元）、权重衰减（weight_decay，在 loss 中加惩罚项抑制参数过大）。
• 数据增强：对训练数据做同义词替换、句式变换等，增加多样性。
• 灾难性遗忘防御：训练数据中混合 10-20% 的通用数据（replay），确保模型不丢失基础能力。LoRA 冻结原始权重也能天然减轻遗忘。

面试必问：“如何评估微调模型？怎么判断过拟合？”——构建独立测试集，对比微调前后模型在测试集上的表现。验证 loss 上升 + 训练 loss 持续下降 = 过拟合。同时检查通用能力是否退化（灾难性遗忘检测）。

---

AI 应用场景速查表

知识点	核心用途	典型场景
SFT	让模型学会特定任务	翻译、分类、格式转换
DPO	对齐人类偏好	创意写作、价值观对齐
数据清洗	保证训练数据质量	所有微调任务的前置步骤
ChatML/ShareGPT	统一对话格式	多模型对话数据适配
LoRA	高效微调，降低显存	消费级显卡微调大模型
QLoRA	极致压缩显存	16GB 显卡微调 7B 模型
LLaMA-Factory	快速可视化微调	原型验证
PEFT	代码级精细控制	生产部署
测试集评估	量化微调效果	判断是否过拟合/灾难性遗忘

---

面试模拟题

1. 原理型：SFT、RLHF、DPO 有什么区别？什么时候用 SFT，什么时候用 DPO？

答案要点：SFT 用问答对训练，适合有标准答案的任务。RLHF 需要训练奖励模型，适合需要人类主观偏好对齐的场景。DPO 直接从偏好对比中学习，是 RLHF 的轻量替代。SFT 适合翻译、分类等确定性任务；DPO 适合创意写作、价值观对齐等主观任务。

---

2. 原理型：LoRA 为什么能减少可训练参数量？rank 和 alpha 分别起什么作用？

答案要点：LoRA 用两个小矩阵的乘积（低秩分解）近似全量权重更新，参数从 d² 降到 2dr（r << d）。rank 控制低秩矩阵的维度，越大表达能力越强但参数越多。alpha 是缩放因子，实际有效学习率 = alpha/r × 原始学习率，通常设为 rank 的两倍。

---

3. 计算型：QLoRA 为什么能在 16GB 显卡上微调 7B 模型？显存是怎么省下来的？

答案要点：4-bit 量化将模型权重从 14GB（FP16）压缩到约 4GB；LoRA 只有少量可训练参数（~0.05GB），优化器状态只针对 LoRA 参数（_{0.4GB）而非全量（}56GB）；分页优化器在显存不足时将优化器状态暂存 CPU。总显存约 14.5GB，可在 16GB 显卡上运行。

---

4. 实验型：微调后模型在训练集上表现很好，但上线后用户反馈不好。可能是什么原因？怎么办？

答案要点：可能是过拟合——模型背下了训练数据但泛化能力差。排查：构建独立测试集评估，检查训练/测试 loss 差距；监控训练过程，loss 不再下降时提前停止；增加数据多样性，使用正则化手段。同时检查是否存在灾难性遗忘——微调后模型在通用任务上的表现是否退化，必要时混合通用数据训练。

---

总结

从 SFT/DPO 的选型决策，到 LoRA 的低秩分解和 QLoRA 的显存优化，再到微调后的科学评估，你已掌握模型定制化的核心技术栈。面试中的高频考点——SFT vs DPO 的适用场景、LoRA 的参数量计算、QLoRA 的显存推导——都已覆盖。现在你可以用消费级显卡，把通用大模型打造成专属领域的专家了。