> **本文是「架构实战·第二季」第十四篇**。前面我们讲的 RAG、Prompt、Agent 等都是"不动模型"的方案，本篇进入"动模型"——Fine-tuning。

---

## 引子：花了 8 周微调，效果还不如 prompt

去年我们做一个医疗问答项目，团队信心满满要"微调一个医疗 GPT"。

8 周后，效果不升反降：

- 通用医学问答：准确率从 75%（prompt）降到 68%（微调）；
- 边缘 case：模型回答越来越像"教科书"，失去了灵活性；
- 新出现的药品/指南：模型完全不知道。

**微调不是万能药**，选错了不仅没效果，还会"灾难性遗忘"。

---

## 一、什么时候应该 Fine-tuning

### 1.1 决策树

```
模型在当前任务上效果不达标
├── 是 → 原因是什么？
│       │
│       ├── 缺乏领域知识 → 先做 RAG
│       │
│       ├── 输出格式不稳定 → 改 Prompt + Few-shot
│       │
│       ├── 风格不符合 → 改 Prompt
│       │
│       ├── 模型无法理解任务 → 考虑微调
│       │
│       └── 通用能力 + 风格都不行 → 才考虑微调
```

### 1.2 微调 vs Prompt vs RAG

| 维度 | Prompt | RAG | Fine-tuning |
|------|--------|-----|-------------|
| 知识更新 | ✅ 即时 | ✅ 即时 | ❌ 需重训 |
| 风格定制 | ⚠️ 有限 | ⚠️ 有限 | ✅ 强 |
| 格式约束 | ⚠️ 有限 | ⚠️ 有限 | ✅ 强 |
| 推理速度 | 慢（长 prompt）| 慢 | ✅ 快 |
| 成本 | 低 | 中 | 高 |
| 数据需求 | 0 | 文档库 | 1000+ 条 |
| 适合 | 通用 + 小改 | 知识库丰富 | 风格/格式专精 |

**经验法则**：

- 90% 的场景，**Prompt + RAG 足够**；
- 8% 的场景，需要**Few-shot in-context learning**（选 50+ 示例塞 prompt）；
- 2% 的场景，才真正需要**微调**。

---

## 二、微调前的准备

### 2.1 数据是 80% 的工作

| 任务 | 最低数据量 | 推荐数据量 |
|------|----------|----------|
| 风格微调 | 500 条 | 5000+ 条 |
| 格式微调 | 200 条 | 1000+ 条 |
| 领域问答 | 1000 条 | 5000+ 条 |
| 推理能力 | 5000 条 | 50000+ 条 |

### 2.2 数据格式

主流格式：Alpaca / ShareGPT

**Alpaca 格式**（单轮）：

```json
{
  "instruction": "请解释什么是 DDD",
  "input": "",
  "output": "DDD（领域驱动设计）是一种..."
}
```

**ShareGPT 格式**（多轮）：

```json
{
  "conversations": [
    {"from": "human", "value": "DDD 是什么？"},
    {"from": "gpt", "value": "DDD（领域驱动设计）..."},
    {"from": "human", "value": "它和微服务是什么关系？"},
    {"from": "gpt", "value": "..."}
  ]
}
```

**OpenAI 格式**：

```jsonl
{"messages": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
{"messages": [...]}
```

### 2.3 数据准备 Pipeline

```python
class TrainingDataPipeline:
    def __init__(self):
        self.raw_data = []
        self.clean_data = []
    
    def ingest(self, sources):
        """从多源拉取"""
        for src in sources:
            if src["type"] == "csv":
                self.raw_data.extend(pd.read_csv(src["path"]).to_dict("records"))
            elif src["type"] == "jsonl":
                self.raw_data.extend(self.read_jsonl(src["path"]))
            elif src["type"] == "database":
                self.raw_data.extend(self.fetch_db(src["query"]))
    
    def clean(self):
        """清洗"""
        for d in self.raw_data:
            d = self.deduplicate(d)
            d = self.filter_too_short(d, min_len=20)
            d = self.filter_toxic(d)
            d = self.fix_pii(d)  # 去除 PII
            self.clean_data.append(d)
    
    def augment(self):
        """数据增强"""
        augmented = []
        for d in self.clean_data:
            # 同义改写
            for v in self.paraphrase(d["output"], n=2):
                new = d.copy()
                new["output"] = v
                augmented.append(new)
        self.clean_data.extend(augmented)
    
    def quality_check(self):
        """质量校验"""
        for d in self.clean_data:
            score = self.quality_scorer.score(d)
            if score < 0.7:
                logger.warning(f"低质量样本: {d}")
        return self.clean_data
```

### 2.4 评测集准备

```python
EVAL_SET = [
    {
        "input": "...",
        "expected_output": "...",
        "criteria": "accuracy"
    },
    # 至少 100-300 条
]

def evaluate_model(model, eval_set):
    scores = []
    for case in eval_set:
        pred = model.generate(case["input"])
        score = judge(pred, case["expected_output"], case["criteria"])
        scores.append(score)
    return {
        "mean": np.mean(scores),
        "by_criteria": group_by_criteria(scores)
    }
```

---

## 三、微调方法

### 3.1 三种方法对比

| 方法 | 显存需求 | 训练时间 | 效果 | 适用 |
|------|---------|---------|------|------|
| **Full Fine-tuning** | 极高（>= 80GB）| 长 | 最好 | 数据量大、追求极致 |
| **LoRA** | 中（24GB）| 中 | 好 | 数据中等、性价比高 |
| **QLoRA** | 低（8-16GB）| 中 | 好 | 单卡微调、显存有限 |

### 3.2 LoRA 原理

LoRA（Low-Rank Adaptation）冻结原模型权重，只训练一对低秩矩阵：

```
原始 W (d × d) 不变
新输出 = Wx + BAx
其中 B (d × r), A (r × d), r << d
```

训练时只更新 A 和 B（参数量从 d² 降到 2dr）。

### 3.3 QLoRA 原理

QLoRA = 量化（4-bit）+ LoRA，进一步降低显存：

```
模型量化到 4-bit（NT4 / FP4）
权重冻结
LoRA 适配器以 FP16 训练
```

可以在 24GB 显存上微调 70B 模型。

### 3.4 实战：QLoRA 微调 Qwen2.5-7B

```python
# 安装依赖
# pip install transformers peft trl bitsandbytes accelerate datasets

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer
from datasets import load_dataset
import torch

# 1. 配置 4-bit 量化
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

# 2. 加载模型
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")
tokenizer.pad_token = tokenizer.eos_token

# 3. 准备模型
model = prepare_model_for_kbit_training(model)

# 4. LoRA 配置
lora_config = LoraConfig(
    r=16,                # rank
    lora_alpha=32,       # alpha
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", 
                    "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 输出：trainable params: 16,777,216 || all params: 7,625,263,616 || trainable: 0.22%

# 5. 加载数据
dataset = load_dataset("json", data_files="train.jsonl", split="train")

def format_func(example):
    return f"<|im_start|>user\n{example['instruction']}\n<|im_end|>\n<|im_start|>assistant\n{example['output']}\n<|im_end|>"

dataset = dataset.map(lambda x: {"text": format_func(x)})

# 6. 训练
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args={
        "output_dir": "./qwen2.5-7b-finetuned",
        "num_train_epochs": 3,
        "per_device_train_batch_size": 4,
        "gradient_accumulation_steps": 4,
        "learning_rate": 2e-4,
        "warmup_steps": 100,
        "logging_steps": 10,
        "save_strategy": "epoch",
    },
)
trainer.train()
```

### 3.5 用 Unsloth 加速（可选）

```python
# pip install unsloth
from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="Qwen/Qwen2.5-7B-Instruct",
    max_seq_length=2048,
    load_in_4bit=True,
)
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=32,
    use_gradient_checkpointing="unsloth",
)
```

**Unsloth 优势**：比原生 LoRA 快 2-3 倍，显存少 40%。

---

## 四、训练监控与调优

### 4.1 关键指标

```python
# 训练损失
"loss"             # 总损失
"eval_loss"        # 验证损失
"learning_rate"    # 学习率
"grad_norm"        # 梯度范数
"epoch"            # 当前 epoch

# GPU 资源
"gpu_memory_used"  # 显存使用
"gpu_utilization"  # GPU 利用率
"throughput"       # tokens/s
```

### 4.2 学习率调整

```python
# 经验值
LEARNING_RATES = {
    "full_finetune": 1e-5,       # 全量微调，要小
    "lora": 2e-4,                # LoRA，可以大
    "qlora": 2e-4,               # QLoRA
    "continue_pretrain": 1e-5,   # 继续预训练
}

# 推荐：warmup + cosine
scheduler = get_cosine_schedule_with_warmup(
    optimizer,
    num_warmup_steps=100,
    num_training_steps=total_steps
)
```

### 4.3 早停与模型选择

```python
from transformers import EarlyStoppingCallback

trainer = SFTTrainer(
    model=model,
    args={...},
    callbacks=[
        EarlyStoppingCallback(early_stopping_patience=3)
    ]
)
```

### 4.4 Loss 异常处理

| 现象 | 原因 | 解决 |
|------|------|------|
| Loss 不下降 | 学习率太小 | 提高到 5e-4 |
| Loss 突然飙升 | 梯度爆炸 | 减小 LR + 梯度裁剪 |
| Loss 在 0.5 收敛 | 数据太简单 | 增加数据难度 |
| Loss 在 3.0 收敛 | 数据太难或质量差 | 清洗数据 |
| 训练集好但测试集差 | 过拟合 | 减少 epoch / 加 dropout |

---

## 五、模型评估

### 5.1 自动评估

```python
def auto_evaluate(model, eval_set):
    """用模型对评测集做推理，统计准确率"""
    results = {"total": 0, "correct": 0, "by_type": {}}
    
    for case in eval_set:
        pred = model.generate(case["input"])
        score = judge(pred, case["expected_output"])
        
        results["total"] += 1
        if score > 0.7:
            results["correct"] += 1
        
        # 按问题类型统计
        qtype = case.get("type", "default")
        results["by_type"].setdefault(qtype, {"total": 0, "correct": 0})
        results["by_type"][qtype]["total"] += 1
        if score > 0.7:
            results["by_type"][qtype]["correct"] += 1
    
    results["accuracy"] = results["correct"] / results["total"]
    for t, r in results["by_type"].items():
        r["accuracy"] = r["correct"] / r["total"]
    
    return results
```

### 5.2 LLM-as-a-Judge

```python
JUDGE_PROMPT = """你是评分员。请评估模型回答的质量。

【问题】
{question}

【标准答案】
{reference}

【模型回答】
{prediction}

请从以下维度评分（0-10）：
- 准确性
- 完整性
- 表达清晰度

输出 JSON：{"scores": {...}, "issues": [...], "overall": ...}"""

def llm_judge(question, reference, prediction):
    return json.loads(llm.complete(JUDGE_PROMPT.format(
        question=question, reference=reference, prediction=prediction
    )))
```

### 5.3 端到端业务评估

```python
def business_evaluate(model, business_cases):
    """端到端业务测试"""
    metrics = {
        "task_completion_rate": [],
        "user_satisfaction_proxy": [],
        "response_time": []
    }
    
    for case in business_cases:
        start = time.time()
        pred = model.generate(case["input"])
        elapsed = time.time() - start
        
        # 业务完成度（基于业务规则）
        completed = check_business_rule(pred, case["expected"])
        metrics["task_completion_rate"].append(1 if completed else 0)
        metrics["response_time"].append(elapsed)
    
    return {
        "completion_rate": np.mean(metrics["task_completion_rate"]),
        "avg_response_time": np.mean(metrics["response_time"]),
    }
```

---

## 六、模型合并与部署

### 6.1 LoRA 权重合并

```python
from peft import PeftModel

# 加载基础模型
base = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-7B-Instruct")
# 加载 LoRA
model = PeftModel.from_pretrained(base, "./qwen2.5-7b-finetuned")
# 合并
merged = model.merge_and_unload()
# 保存
merged.save_pretrained("./qwen2.5-7b-merged")
```

### 6.2 部署到 vLLM

```bash
# vLLM 启动微调后的模型
python -m vllm.entrypoints.openai.api_server \
  --model ./qwen2.5-7b-merged \
  --tensor-parallel-size 1 \
  --gpu-memory-utilization 0.9 \
  --port 8000
```

### 6.3 灰度上线

```
微调模型 vs 原模型 A/B 测试
1. 5% 流量给新模型
2. 监控：质量、延迟、错误率
3. 数据上看新模型确实更好
4. 逐步放量到 100%
```

---

## 七、踩坑提示

### 坑 1：数据量过小

**症状**：100 条数据微调，效果反而变差。

**解决**：< 1000 条建议用 Few-shot，而不是微调。

### 坑 2：数据分布不均

**症状**：训练集全是"标准问题"，测试集有"刁钻问题"。

**解决**：数据多样化，覆盖 5+ 场景。

### 坑 3：灾难性遗忘

**症状**：微调后模型忘了通用能力，问"1+1=?"答错。

**解决**：
- 加通用数据到训练集（10-20% 比例）；
- 用较低的 learning rate；
- 限制训练 epoch。

### 坑 4：训练数据是 prompt 注入

**症状**：训练数据里带"忽略以上"，模型学会被注入。

**解决**：清洗数据，拒绝带注入的样本。

### 坑 5：评测集泄漏

**症状**：评测集答案在训练集里出现，准确率虚高。

**解决**：严格分离 train/eval，定期去重。

### 坑 6：推理 OOM

**症状**：合并后模型加载 OOM。

**解决**：合并后用 4-bit 量化加载，或用 vLLM 部署。

### 坑 7：训练损失接近 0，但实际效果差

**症状**：loss 已经 < 0.1，但业务测试很差。

**解决**：loss 不是真理，业务指标才是。多准备业务评测集。

---

## 八、本篇要点回顾

| 模块 | 关键点 |
|------|--------|
| 决策 | 90% 用 Prompt + RAG，只有 2% 真正需要微调 |
| 数据 | 1000+ 条，质量 > 数量 |
| 方法 | QLoRA 是单卡首选 |
| 训练 | 学习率 2e-4，warmup + cosine |
| 评测 | 自动 + LLM-as-judge + 业务测试 |
| 部署 | LoRA 合并后用 vLLM 部署 |

**Fine-tuning 落地的三个核心原则**：

1. **先试 Prompt，再试 RAG，最后才微调**——不要一上来就微调；
2. **数据是 80%**——没有 1000+ 高质量数据别微调；
3. **业务指标 > Loss**——Loss 看着漂亮不代表业务能用。

---

## 九、下一篇预告

下一篇 【架构实战】**LLM推理优化：vLLM、TGI与TensorRT-LLM部署**，我们进入 LLM 工程化的"重头戏"——推理优化：

- LLM 推理的核心瓶颈（显存、计算、内存带宽）；
- vLLM / TGI / TensorRT-LLM 三大推理框架对比；
- PagedAttention、Continuous Batching、量化等关键优化技术；
- 实战：从零部署一个高吞吐 LLM 推理服务。

LLM 推理是"省钱的关键"——同样的 GPU，vLLM 能比原生 Transformers 快 10 倍。

---

> **作者**：架构实战 第二季  
> **版本**：v1.0  
> **最后更新**：2026-10  
> **全文约 5000 字**

本文是「架构实战·第二季」第十四篇。前面我们讲的 RAG、Prompt、Agent 等都是"不动模型"的方案，本篇进入"动模型"——Fine-tuning。

【架构实战】LLM Fine-tuning：领域模型微调与小样本训练

研发部经理

人工智能

本文解析大模型微调（Fine-tuning）实战，对比Prompt与RAG，强调90%场景无需微调。提供QLoRA微调Qwen2.5-7B完整代码，涵盖数据准备、训练监控、评估部署及避坑指南，揭示业务指标优于Loss的核心原则。

4核4G3M云服务器 新用户低至38元/年！

2026上云采购 | AI焕新·智启新局

lexiang

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

【架构实战】LLM Fine-tuning：领域模型微调与小样本训练-腾讯云开发者社区-腾讯云

【架构实战】LLM Fine-tuning：领域模型微调与小样本训练

【架构实战】LLM Fine-tuning：领域模型微调与小样本训练

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐