2024 年我们想给一个法律咨询 SaaS 加一个 中文合同审查 助手 我们以为很简单 拿一个开源 LLM 比如 Qwen 7B 全参数微调一下喂 5 万条合同审查样本就上线。我跑通第一版后陆续踩了一堆坑。第一种最让我傻眼 全参数微调 7B 模型一台 A100 80G 跑了 2 天 单 epoch loss 收敛得很慢 训完 evaluate 模型对法律术语的理解几乎没变 在合同关键条款上的 F1 只比 base 模型高 3% 老板很失望。第二种最难缠 我们换 LoRA 微调 同样 5 万样本 loss 下降很快 evaluate F1 飙到 85% 我兴冲冲上线 用户反馈模型在合同审查上确实强但日常问候 你好 怎么回事 模型也开始一本正经讲合同条款 灾难性遗忘 base 能力全丢。第三种最离谱 我们的训练数据是从 10 个律所标注收集的 不同律所对同一条款的标注口径不一样 模型学到的是矛盾的标签 evaluate 在某律所测试集飙 90% 在另一律所只有 60% 模型其实学到的是律所风格不是法律知识。第四种最致命 我们用 Adam optimizer 没设 weight decay 训练后期 LoRA 权重数值 explode 模型输出全是乱码 重训一次损失 1500 美元。第五种最莫名其妙 我们 fp16 训练在 V100 上 loss 跑着跑着突然 NaN 排查发现是 V100 不支持 bf16 fp16 数值范围不够 必须换 A100 或者用 mixed precision。我盯着这一连串问题想了很久才彻底想明白第一版错在一个根本的认知上我以为 LLM 微调就是 拿数据 跑训练循环 看 loss 下降 出模型 可这个认知是错的真正能用的 LLM 微调是一个 数据筛选与标注一致性 加 LoRA 与 QLoRA 参数选型 加 学习率与优化器调参 加 灾难性遗忘缓解 加 评估与回归测试 加 推理部署与量化 的整套工程方法论 任何一环没做都可能让你的模型训完不能用或者烧钱白训本文从头梳理 LLM 微调的工程化要点 LoRA 怎么选 rank QLoRA 怎么做 4bit 训练 学习率怎么定 灾难性遗忘怎么缓解 评估集怎么设计 量化推理怎么部署 以及一些把微调做扎实要避开的工程坑
问题背景:为什么 LLM 微调不是 trainer.train 就完事
很多人对 LLM 微调的认知是 拿数据 调 transformers Trainer fit 一下就出模型 但生产里你会发现 全参数训不动 LoRA 训完忘了 base 能力 数据标注不一致 学习率随手设导致 NaN 评估只看 loss 上线全是坑。问题的根源在于:
- 全参数微调成本太高:7B 模型全参数微调要 4 张 A100 80G 一周 LoRA 一张卡几小时 成本差 100 倍 必须 PEFT。
- LoRA 也会灾难性遗忘:rank 越高 lora_alpha 越大 模型偏离 base 越多 通用能力丢失 必须混合 base 能力数据。
- 标注一致性是数据命脉:不同标注人对同一样本的判断不同 模型学到的是矛盾标签 IAA inter-annotator agreement 必须 0.8+。
- 学习率与优化器决定能否收敛:LoRA 学习率比全参数大一个量级 1e-4 量级 用错优化器或 schedule 直接 NaN。
- 评估集必须严肃:训练集与评估集同分布会有 data leakage 必须独立采样 时间维度切分。
- 推理量化决定部署成本:4bit GPTQ 5bit AWQ 8bit bnb 都能让 7B 跑单张消费级卡 vLLM 上能跑 100 QPS。
一 数据筛选与标注一致性:微调命脉
LLM 微调的天花板不是模型 是数据。数据噪声大 标注不一致 模型学不到稳定知识。我们的经验 5 万样本 但筛选清洗去重后 1.5 万高质量样本 训出来的模型比 5 万脏样本好 30%。质量永远胜过数量。
import json
import pandas as pd
from collections import Counter
from sklearn.metrics import cohen_kappa_score
def load_annotations(files: list[str]) -> pd.DataFrame:
"""加载多个标注员的结果 检查一致性"""
dfs = []
for f in files:
with open(f, encoding='utf-8') as fp:
data = json.load(fp)
df = pd.DataFrame(data)
df['annotator'] = f.split('/')[-1].replace('.json', '')
dfs.append(df)
return pd.concat(dfs, ignore_index=True)
def compute_iaa(df: pd.DataFrame, label_col: str = 'label') -> dict:
"""计算标注一致性 IAA inter-annotator agreement"""
annotators = df['annotator'].unique()
sample_ids = df['sample_id'].unique()
iaas = {}
for i, a in enumerate(annotators):
for b in annotators[i+1:]:
common = set(df[df['annotator']==a]['sample_id']) & \
set(df[df['annotator']==b]['sample_id'])
if len(common) < 10:
continue
la = df[(df['annotator']==a) & (df['sample_id'].isin(common))] \
.sort_values('sample_id')[label_col].tolist()
lb = df[(df['annotator']==b) & (df['sample_id'].isin(common))] \
.sort_values('sample_id')[label_col].tolist()
kappa = cohen_kappa_score(la, lb)
iaas[f'{a}_vs_{b}'] = kappa
return iaas
def filter_consensus(df: pd.DataFrame, min_agreement: int = 2) -> pd.DataFrame:
"""每个样本至少要 min_agreement 个标注员一致才保留"""
grouped = df.groupby('sample_id')['label'].agg(list)
keep = []
for sid, labels in grouped.items():
c = Counter(labels)
majority, count = c.most_common(1)[0]
if count >= min_agreement:
keep.append({'sample_id': sid, 'label': majority,
'agreement': count / len(labels)})
return pd.DataFrame(keep)
有了 IAA 工具 工程流程就是 先抽 100 条让 3 个标注员独立标 计算 Cohen Kappa 一致性低于 0.6 必须重新对齐标注规范 再标 100 条 一直到 0.8+ 再开始大规模标注 这个前置投入能让你后续模型质量好 30%。
# 实战用法
df = load_annotations([
'lawyer_a.json', 'lawyer_b.json', 'lawyer_c.json',
])
iaas = compute_iaa(df)
print('Inter-annotator agreement:', iaas)
# {'lawyer_a_vs_lawyer_b': 0.82, 'lawyer_a_vs_lawyer_c': 0.65, ...}
# lawyer_c 与其他人一致性低 必须 calibration 重新对齐
# 筛选高一致性样本作为训练集
clean = filter_consensus(df, min_agreement=2)
print(f'原始 {len(df)} 清洗后 {len(clean)} 保留率 {len(clean)/len(df):.0%}')
# 数据格式化为 instruction tuning 格式
def to_alpaca(row):
return {
'instruction': '你是一位资深律师 请审查以下合同条款并指出潜在风险',
'input': row['clause_text'],
'output': row['risk_analysis'],
}
training_data = [to_alpaca(r) for _, r in clean.iterrows()]
with open('train.json', 'w', encoding='utf-8') as f:
json.dump(training_data, f, ensure_ascii=False, indent=2)
数据筛选的工程经验 IAA 是数据质量的硬指标 Cohen Kappa 0.8+ 才算高质量 0.6 以下数据基本不能用 必须重新校准标注规范 这是被新手严重低估的环节 直接决定模型能不能上线。我们公司的规范是 任何新标注任务 前 100 条必须做 IAA 测试 通过才铺开 否则训出来的模型只是学到了标注员的不一致性。
二 LoRA 与 QLoRA:参数高效微调
LoRA 是 LLM 微调的事实标准 把 attention 与 FFN 的 weight 分解成两个低秩矩阵 只训这两个小矩阵 base 模型权重 frozen 训练参数从 7B 降到 50M 显存与计算都省 100 倍。QLoRA 在 LoRA 基础上把 base 模型 4bit 量化 显存再省一半 单张 24G 4090 能微调 7B 模型。
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
# 1 QLoRA 4bit 量化加载 base 模型
bnb_config = 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-Instruct',
quantization_config=bnb_config,
device_map='auto',
trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained('Qwen/Qwen2.5-7B-Instruct')
# 2 准备 k-bit 训练 给量化层加可训练的 norm
model = prepare_model_for_kbit_training(model)
model.gradient_checkpointing_enable() # 显存换计算
# 3 LoRA 配置
lora_config = LoraConfig(
r=16, # rank 8-64 越大表达力越强但容易过拟合
lora_alpha=32, # 一般是 rank 的 2 倍 控制权重缩放
lora_dropout=0.05, # 正则化 防过拟合
bias='none',
task_type='CAUSAL_LM',
# 目标模块 Qwen 系列要带 attention 与 MLP 的所有 linear
target_modules=[
'q_proj', 'k_proj', 'v_proj', 'o_proj',
'gate_proj', 'up_proj', 'down_proj',
],
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 41,943,040 || all params: 7,656,873,984 || trainable%: 0.55
LoRA 配置完只是搭起了训练骨架 还要把 base 模型在 4bit 量化下的反向传播跑通 prepare_model_for_kbit_training 帮你做了量化层的 norm 浮点处理 与 input embedding 的梯度开启 否则反向会 NaN 这是 QLoRA 论文里的关键 trick 直接抄就行不要自己造轮子。
from transformers import TrainingArguments, Trainer
from datasets import load_dataset
dataset = load_dataset('json', data_files='train.json', split='train')
def format_example(ex):
prompt = f'指令 {ex["instruction"]}\n输入 {ex["input"]}\n输出 '
full = prompt + ex['output'] + tokenizer.eos_token
enc = tokenizer(full, truncation=True, max_length=2048, padding='max_length')
enc['labels'] = enc['input_ids'].copy()
# mask 掉 prompt 部分 只算 output 的 loss
prompt_len = len(tokenizer(prompt)['input_ids'])
enc['labels'][:prompt_len] = [-100] * prompt_len
return enc
dataset = dataset.map(format_example, remove_columns=dataset.column_names)
training_args = TrainingArguments(
output_dir='./qwen-law-lora',
num_train_epochs=3,
per_device_train_batch_size=2,
gradient_accumulation_steps=8, # 等效 batch 16
learning_rate=2e-4, # LoRA 比全参数大一个量级
warmup_ratio=0.03,
lr_scheduler_type='cosine',
bf16=True, # A100 必开 bf16 比 fp16 数值稳定
logging_steps=10,
save_steps=200,
optim='paged_adamw_8bit', # QLoRA 推荐的 8bit Adam 省显存
weight_decay=0.01, # 防 LoRA 权重 explode
max_grad_norm=1.0, # 梯度裁剪 防 NaN
)
trainer = Trainer(model=model, args=training_args, train_dataset=dataset)
trainer.train()
model.save_pretrained('./qwen-law-lora-final')
LoRA 与 QLoRA 的工程经验 rank=16 lora_alpha=32 是大多数场景的甜区 学习率 2e-4 配 cosine schedule paged_adamw_8bit 必开省显存 weight_decay 0.01 防权重 explode max_grad_norm 1.0 防梯度爆炸 这些参数照抄就行不要瞎调。target_modules 必须覆盖 attention 的 q k v o 与 MLP 的 gate up down 7 个 linear 只调 q k v 模型几乎学不到任务知识。
三 灾难性遗忘:base 能力的保护
LoRA 微调最大的陷阱是灾难性遗忘 训完法律审查模型 用户问 你好 怎么样 模型也开始讲合同条款 base 的对话能力丢了。缓解方法是混合 base 能力数据 加 LoRA rank 控制 加 KL 散度约束。
# 1 数据混合 30% base 能力数据
import random
law_data = json.load(open('train_law.json')) # 法律数据 1.5 万
general_data = json.load(open('alpaca_chinese.json')) # 通用 Alpaca 5 万
# 比例 7:3 法律:通用 防止只学法律忘了通用对话
mixed = law_data + random.sample(general_data, int(len(law_data) * 0.43))
random.shuffle(mixed)
print(f'混合后 {len(mixed)} 法律占 {len(law_data)/len(mixed):.0%}')
# 2 LoRA rank 不要太高 控制偏离 base 的幅度
# rank=8 偏离小 通用能力保留好 但任务学得不深
# rank=64 偏离大 任务学得深 但通用能力丢失明显
# 一般法律 医疗这种垂域 rank=16 是甜区
数据混合与 rank 控制是被动的防遗忘 主动防遗忘还要在 loss 里加一项 KL 散度 让 LoRA 微调后的输出分布别离 base 太远 这种做法在法律 医疗这种对回答风格有严格要求的垂域非常有效 代价是训练慢一倍因为每步要 forward base 一次。
# 3 训练时加 KL 散度正则 让 LoRA 输出别偏离 base 太远
class KLRegularizedTrainer(Trainer):
def __init__(self, base_model, kl_weight=0.1, *args, **kwargs):
super().__init__(*args, **kwargs)
self.base_model = base_model # 冻结的 base
self.kl_weight = kl_weight
def compute_loss(self, model, inputs, return_outputs=False):
outputs = model(**inputs)
loss = outputs.loss
# KL 散度让 LoRA 别偏离 base 太远
with torch.no_grad():
base_logits = self.base_model(**inputs).logits
kl = torch.nn.functional.kl_div(
torch.log_softmax(outputs.logits, dim=-1),
torch.softmax(base_logits, dim=-1),
reduction='batchmean',
)
total = loss + self.kl_weight * kl
return (total, outputs) if return_outputs else total
灾难性遗忘缓解的工程经验 数据混合 7:3 任务:通用 是最简单有效的方法 LoRA rank 控制在 8-32 区间 KL 散度正则适合极度严格的场景 比如医疗法律 这三招组合 base 能力保留度能到 90%+ 任务能力也 85%+。我们公司法律助手用 rank=16 加 7:3 混合 base 对话能力测试 85% 法律审查测试 88% 双赢。
四 学习率与优化器:调参玄学
LoRA 训练的学习率 优化器 schedule 是初学者最容易翻车的地方。学习率设错 NaN 或者不收敛 优化器选错显存爆 schedule 设错收敛慢。生产参数有一套相对成熟的最佳实践 抄就行。
# LoRA 训练参数选型对照表 不要瞎调
# 1 学习率 lr
# 全参数微调 lr=1e-5 到 5e-5
# LoRA 微调 lr=1e-4 到 5e-4 大一个量级
# QLoRA lr=1e-4 到 2e-4 4bit 量化对 lr 敏感不能太大
# 起步用 2e-4 看 loss 曲线再调
# 2 batch size 与 gradient accumulation
# 显存够大 直接 per_device_train_batch_size=8
# 显存不够 per_device_train_batch_size=2 gradient_accumulation_steps=4
# 等效 batch=8 显存只占 1/4
# 3 epoch 数
# 数据 1 万以下 epoch=3-5
# 数据 1 万到 10 万 epoch=2-3
# 数据 10 万以上 epoch=1-2 防止过拟合
# 4 warmup
# warmup_ratio=0.03 训练前 3% 步数 lr 从 0 线性升到目标 lr
# 防止训练初期梯度爆炸
# 5 scheduler
# lr_scheduler_type='cosine' 余弦衰减 是 LLM 微调的事实标准
# 'linear' 也行但收敛略差
# 不要用 'constant' 会在末期震荡
# 6 优化器
# 标准 'adamw_torch'
# 显存紧 'paged_adamw_8bit' 8bit Adam 省一半显存
# QLoRA 推荐 'paged_adamw_8bit'
# 7 精度
# A100 用 bf16=True
# V100 用 fp16=True 但要开 fp16_full_eval=False 避免 eval 时 NaN
# T4 也只能 fp16 性能差
# 8 防 NaN 必开
# max_grad_norm=1.0 梯度裁剪
# weight_decay=0.01 L2 正则
# 实战 LoRA 训练参数模板
TrainingArguments(
learning_rate=2e-4,
num_train_epochs=3,
per_device_train_batch_size=2,
gradient_accumulation_steps=8,
warmup_ratio=0.03,
lr_scheduler_type='cosine',
optim='paged_adamw_8bit',
weight_decay=0.01,
max_grad_norm=1.0,
bf16=True,
logging_steps=10,
save_steps=200,
save_total_limit=3, # 只保留最近 3 个 ckpt 省磁盘
evaluation_strategy='steps',
eval_steps=200,
load_best_model_at_end=True,
metric_for_best_model='eval_loss',
)
学习率与优化器的工程经验 LoRA 默认 2e-4 cosine warmup 0.03 paged_adamw_8bit weight_decay 0.01 这套组合是 99% 场景的最佳实践 不要自己瞎调 翻车的概率比调到更好的概率大 10 倍 调参之前先看几篇高质量论文的实验设置。loss 跑着跑着 NaN 90% 是 max_grad_norm 没开或者 fp16 数值溢出 换 bf16 加梯度裁剪基本解决。
[mermaid]flowchart TD
A[原始标注数据] --> B[IAA 一致性检查]
B --> C{Kappa 大于 0.8}
C -->|否| D[标注规范对齐 重标]
C -->|是| E[筛选高一致性样本]
D --> B
E --> F[混合 base 能力数据]
F --> G[QLoRA 4bit 加载 base]
G --> H[LoRA rank 16 训练]
H --> I[evaluation 集 评估]
I --> J{指标合格}
J -->|否| K[调参 增数据]
J -->|是| L[merge LoRA 到 base]
K --> H
L --> M[GPTQ AWQ 量化]
M --> N[vLLM 部署推理]
五 评估与回归测试:loss 不等于效果
训练 loss 下降不代表模型能用 必须设计严肃的 evaluation 套件 覆盖任务能力 base 能力 边界 case 回归。我们公司法律助手有一套 200 条人工标的 evaluation 集 每次模型更新都跑一遍 任何指标下降 5%+ 拒绝上线。
from transformers import pipeline
import json
class EvaluationSuite:
"""LLM 微调评估套件 多维度评估"""
def __init__(self, model, tokenizer):
self.pipe = pipeline('text-generation', model=model, tokenizer=tokenizer)
def eval_task_accuracy(self, test_set: list) -> float:
"""任务能力 法律审查 F1"""
correct = 0
for ex in test_set:
pred = self.pipe(ex['prompt'], max_new_tokens=512,
do_sample=False)[0]['generated_text']
if self._match_keywords(pred, ex['expected_keywords']):
correct += 1
return correct / len(test_set)
def eval_base_capability(self, general_set: list) -> float:
"""通用能力 日常对话 数学 逻辑"""
correct = 0
for ex in general_set:
pred = self.pipe(ex['prompt'], max_new_tokens=256,
do_sample=False)[0]['generated_text']
if self._is_reasonable_response(pred, ex):
correct += 1
return correct / len(general_set)
def eval_safety(self, safety_set: list) -> float:
"""安全性 prompt injection 越狱 敏感话题"""
safe = 0
for ex in safety_set:
pred = self.pipe(ex['prompt'], max_new_tokens=256,
do_sample=False)[0]['generated_text']
if not self._contains_harmful(pred):
safe += 1
return safe / len(safety_set)
def eval_regression(self, prev_results: dict, current: dict) -> dict:
"""回归测试 与上一版对比 任何指标下降都报警"""
regressions = {}
for metric, value in current.items():
prev = prev_results.get(metric, 0)
if value < prev - 0.05: # 下降超 5%
regressions[metric] = {'prev': prev, 'current': value}
return regressions
def _match_keywords(self, text, keywords):
return all(k in text for k in keywords)
def _is_reasonable_response(self, text, ex):
return len(text) > 20 and not text.strip().startswith('合同')
def _contains_harmful(self, text):
harmful = ['攻击', '炸弹', '毒品'] # 实战要专业 safety classifier
return any(h in text for h in harmful)
评估套件的工程价值 一是回归测试 任何新版本必须跑全套 与上版对比 二是多维度覆盖 不能只看任务指标 通用能力 安全性同样重要 三是人工 evaluation 不能省 自动 metric 比如 BLEU ROUGE 与人感观差距很大 必须人工抽检 50-100 条。我们公司每次模型上线前 3 个律师独立打分 平均分低于 4.0 拒绝上线 这是兜底的人工质量门。
六 LLM 微调的工程坑:那些论文里学不到的
讲完原理来说几个真实生产里踩过的坑。第一个坑是 tokenizer chat template 不匹配 你训练时用一种 prompt 格式 推理时用另一种 模型输出完全乱套 必须严格用 tokenizer.apply_chat_template 训练推理一致。第二个坑是 LoRA save 与 load 路径 PEFT 保存的只是 LoRA adapter 几十 MB 用的时候必须先加载 base 再 merge_and_unload 或者 PeftModel.from_pretrained 别忘记 base 模型路径。第三个坑是 数据集长度截断 max_length 设 2048 但 30% 样本超 2048 直接截断后 output 部分丢失 模型学到的是不完整的 output 必须先统计长度分布再设。第四个坑是 推理时温度 top_p 与训练时不一致 训练时 teacher forcing 推理时 do_sample=True 温度高会产生训练时没见过的分布漂移 推荐推理时 temperature 0.7 top_p 0.9 do_sample=True。第五个坑是 多卡训练 deepspeed 与 peft 兼容性差 deepspeed zero3 + peft 经常 OOM 或者 grad 不更新 我们的经验是 7B 单卡 QLoRA 13B 用 deepspeed zero2 + LoRA 不要用 zero3。
关键概念速查
| 概念 | 含义 | 工程价值 |
|---|---|---|
| LoRA | 低秩矩阵微调 | 参数省 100 倍 |
| QLoRA | 4bit + LoRA | 单卡 24G 微调 7B |
| rank | LoRA 秩 | 8-32 甜区 |
| lora_alpha | 缩放系数 | 一般是 rank 的 2 倍 |
| IAA | 标注一致性 | Kappa 0.8+ 才能用 |
| 灾难性遗忘 | 忘了 base 能力 | 数据混合 7:3 缓解 |
| paged_adamw_8bit | 8bit Adam | 显存省一半 |
| bf16 | brain float 16 | 数值稳定 防 NaN |
| cosine schedule | 余弦衰减 | LoRA 事实标准 |
| chat_template | 对话格式 | 训推一致 |
避坑清单
- 数据先做 IAA Kappa 低于 0.8 必须重新对齐标注规范 不要赶进度铺标注 数据脏一切白搭。
- QLoRA 4bit 加载必须 prepare_model_for_kbit_training 否则反向 NaN 这是 QLoRA 论文的关键 trick。
- LoRA target_modules 必须覆盖 q k v o gate up down 7 个 linear 只调 attention 模型学不深。
- 学习率 LoRA 2e-4 QLoRA 1e-4 不要瞎调 默认值就是大多数场景最优。
- 必开 bf16 paged_adamw_8bit weight_decay 0.01 max_grad_norm 1.0 这是防 NaN 防权重 explode 的标配。
- 灾难性遗忘必须缓解 数据混合 7:3 任务:通用 LoRA rank 控制 16-32 KL 正则可选。
- 评估集独立采样 不要从训练集切 必须时间维度切分或独立标注 防 data leakage。
- tokenizer chat_template 训推一致 用 apply_chat_template 不要自己拼 prompt 格式漂移完蛋。
- 多卡训练 7B 单卡 QLoRA 13B+ 用 deepspeed zero2 不要 zero3 兼容性差容易 OOM。
- 每次模型上线前跑评估套件 任务 base 安全 回归四个维度都要 任何下降 5% 拒绝上线。
总结
LLM 微调这事 很多人的直觉是 拿数据 调 Trainer fit 一下 loss 下降就完事 这其实是把 我会写 trainer.train 和 我能在生产微调出可用的领域 LLM 混为一谈。前者是会调 API 后者是懂微调工程。中间隔着的是 数据筛选 IAA LoRA 选型 学习率优化器 灾难性遗忘 评估套件 推理部署 整整一套工程方法论。
从原型到生产 你需要做的事远不止 跑通训练循环。你要懂 数据质量比数量重要 IAA 是命脉 LoRA rank target_modules 怎么定 学习率调度怎么搭 灾难性遗忘怎么防 评估套件怎么设计 推理量化部署怎么做。每一项单独看都不复杂 但它们组合在一起 才是一个能上线的领域 LLM。少任何一项 都可能让你的模型训完不能用 烧钱白训。
我经常用一个比喻来理解 LLM 微调 它有点像让一个通才大学生转行做专科医生。base 模型是大学生 已经懂常识懂语言懂基本逻辑 微调是住院医培训 把他训成专科医生。数据是病例 IAA 是不同主任医师对同一病例的诊断要一致 否则学员学到的是矛盾 LoRA 是只更新住院医生新学的专科知识 不动他过去的通识 rank 是新学知识的深度 学习率是学习节奏 灾难性遗忘是怕他学了专科忘了内科 评估是上级医师考核 量化部署是让他真正进医院执业。你不能因为塞他几本书就觉得他能看病 还要管病例质量 学习节奏 通识保留 考核把关 才是一整套医师培养。
这套架构最难的地方在于 它的复杂度在 demo 阶段几乎完全暴露不了。你拿 100 条数据 LoRA 微调一下 demo 看起来效果还不错 觉得 LLM 微调真简单。但真正上生产 几万样本 标注一致性差 多维度评估 灾难性遗忘 推理量化 你才发现 99% 的复杂度都在 那 1% 的工程细节里 数据脏了 rank 错了 学习率高了 evaluation 没跑 灾难性遗忘了。建议任何想做严肃 LLM 微调的团队 上线前一定要做 多维度评估 + 人工抽检 任务指标 base 能力 安全性 回归测试都必须达标 千万别只看 loss 曲线 那只是训练的内部指标 跟用户感受相差十万八千里。
—— 别看了 · 2026