1
通用大模型（如GPT-4）的痛点：
2

3
1. 风格不够"对味"
4
   - 输出太冗长，用户喜欢简洁
5
   - 语气太官方，需要更亲切
6
   - 格式不统一，每次都要纠正
7

8
2. 领域知识不深
9
   - 医疗：专业术语理解有偏差
10
   - 法律：判例引用不够精准
11
   - 金融：风控规则理解不透
12

13
3. 成本与性能矛盾
14
   - 大模型效果好但贵
15
   - 能用小模型但要"懂行"
16
   - RAG检索慢，延迟高

1
微调擅长：
2
- 特定输出风格（简洁/详细、正式/口语）
3
- 特定格式输出（JSON、报告模板）
4
- 领域术语理解（医疗、法律、金融）
5
- 降低延迟（小模型+微调 vs 大模型）
6
- 降低成本（本地部署 vs API调用）
7

8
微调不擅长：
9
- 让模型"更聪明"（推理能力由预训练决定）
10
- 让模型"记住"大量知识（用RAG更合适）
11
- 处理动态变化的信息（实时数据）

1
全量微调（Full Fine-tuning）：
2
- 更新模型所有参数
3
- 效果最好，但成本高
4
- 需要大量GPU显存
5
- 可能"灾难性遗忘"
6

7
参数高效微调（PEFT）：
8
- 只更新少量参数
9
- 效果接近全量微调
10
- 成本低很多
11
- 主流方案：LoRA、QLoRA

1
LoRA（Low-Rank Adaptation）核心思想：
2

3
原始权重矩阵 W（维度 d×k）
4
┌─────────────────────┐
5
│                     │
6
│         W           │  ← 冻结，不更新
7
│      (d × k)        │
8
│                     │
9
└─────────────────────┘
10

11
微调后的权重 = W + ΔW
12

13
LoRA将ΔW分解为两个小矩阵：
14
                        ┌─────┐
15
           ┌───────┐    │  A  │ r×k
16
   ΔW  =   │   B   │ ×  │     │
17
           │ d×r   │    └─────┘
18
           └───────┘
19
              ↑
20
         秩 r << min(d, k)
21

22
参数量对比：
23
┌─────────────────────────────────────────┐
24
│ 全量微调：d × k 个参数                    │
25
│ LoRA：d × r + r × k 个参数               │
26
│                                          │
27
│ 示例：d=4096, k=4096, r=8               │
28
│ 全量：16,777,216 参数                    │
29
│ LoRA：65,536 参数（减少99.6%）           │
30
└─────────────────────────────────────────┘
31

32
实际效果：
33
- 7B模型全量微调：需要28GB显存
34
- 7B模型LoRA微调：只需8GB显存
35
- 效果差距：<2%

1
QLoRA = 量化（Quantization）+ LoRA
2

3
步骤：
4
1. 将模型量化为4-bit（原始16-bit的1/4大小）
5
2. 用LoRA添加可训练的低秩矩阵
6
3. 只训练LoRA参数
7

8
显存需求对比：
9
┌─────────────────────────────────────────┐
10
│ 模型    │ 16-bit加载 │ 4-bit加载 │ QLoRA训练 │
11
│────────│───────────│──────────│──────────│
12
│ 7B     │ 14GB      │ 4GB      │ 8GB      │
13
│ 14B    │ 28GB      │ 8GB      │ 16GB     │
14
│ 70B    │ 140GB     │ 35GB     │ 48GB     │
15
└─────────────────────────────────────────┘
16

17
结论：RTX 4090（24GB）可以微调14B模型！

1
[
2
  {
3
    "instruction": "根据用户描述，判断风险等级",
4
    "input": "用户月收入5000元，申请贷款20万，期限36个月",
5
    "output": "风险等级：高\n原因：月还款额占收入比例超过50%，建议降低贷款金额或延长期限。"
6
  },
7
  {
8
    "instruction": "生成产品推荐话术",
9
    "input": "客户画像：30岁女性，有孩子，关注教育储蓄",
10
    "output": "为您推荐我们的「教育成长计划」，年化收益4.5%，专门为子女教育储备设计..."
11
  }
12
]

1
高质量数据四要素：
2

3
1. 准确（Accuracy）
4
   - 答案正确无误
5
   - 不包含错误信息
6

7
2. 一致（Consistency）
8
   - 格式统一
9
   - 风格统一
10
   - 标注规范统一
11

12
3. 多样（Diversity）
13
   - 覆盖各种场景
14
   - 包含边界情况
15
   - 难度分布合理
16

17
4. 清晰（Clarity）
18
   - 指令描述明确
19
   - 无歧义
20
   - 上下文完整

1
┌─────────────────────────────────────────┐
2
│ 数据量    │ 效果预期        │ 风险      │
3
│──────────│────────────────│───────────│
4
│ 100-500  │ 可能有效        │ 容易过拟合 │
5
│ 500-1000 │ 基本有效        │ 需仔细评估 │
6
│ 1000-5K  │ 较好效果        │ 推荐       │
7
│ 5K-10K   │ 良好效果        │ 理想      │
8
│ 10K+     │ 优秀效果        │ 最佳      │
9
└─────────────────────────────────────────┘
10

11
注意：数据质量 > 数据数量
12
      100条精心标注 > 1000条粗制滥造

1
# 配置示例
2
model_name_or_path: Qwen/Qwen2.5-7B
3
stage: sft
4
do_train: true
5
finetuning_type: lora
6
lora_target: all
7

8
# 数据配置
9
dataset: my_dataset
10
template: qwen
11
cutoff_len: 1024
12

13
# 训练参数
14
num_train_epochs: 3
15
per_device_train_batch_size: 4
16
gradient_accumulation_steps: 4
17
learning_rate: 5e-5
18
warmup_ratio: 0.1
19

20
# LoRA参数
21
lora_rank: 8
22
lora_alpha: 16
23
lora_dropout: 0.05
24

25
# 量化配置（QLoRA）
26
quantization_bit: 4

1
┌─────────────────────────────────────────────────────┐
2
│ 模型   │ QLoRA显存 │ 推荐显卡        │ 云服务成本/小时 │
3
│───────│──────────│────────────────│───────────────│
4
│ 7B    │ 8GB      │ RTX 4090       │ $0.5-1        │
5
│ 14B   │ 16GB     │ A100-40G       │ $1.5-2        │
6
│ 32B   │ 24GB     │ A100-80G       │ $2-3          │
7
│ 70B   │ 48GB     │ 2×A100-80G     │ $4-6          │
8
└─────────────────────────────────────────────────────┘
9

10
训练时间参考（7B模型，1000条数据）：
11
- 单卡A100：约30分钟
12
- RTX 4090：约1小时

1
1. 功能测试
2
   - 准备测试集（不在训练集中）
3
   - 检查输出格式是否正确
4
   - 检查内容是否准确
5

6
2. 对比测试
7
   - 微调前 vs 微调后
8
   - 与目标效果对比
9
   - A/B测试
10

11
3. 边界测试
12
   - 异常输入处理
13
   - 对抗性输入
14
   - 超出训练范围的问题
15

16
4. 性能测试
17
   - 推理延迟
18
   - 吞吐量
19
   - 资源占用

1
import json
2
from openai import OpenAI
3

4
client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
5

6
test_data = json.load(open("test_data.json"))
7

8
correct = 0
9
for item in test_data:
10
    response = client.chat.completions.create(
11
        model="fine-tuned-model",
12
        messages=[
13
            {"role": "user", "content": item["input"]}
14
        ]
15
    )
16
    answer = response.choices[0].message.content
17
    # 评估答案是否正确
18
    if evaluate(answer, item["output"]):
19
        correct += 1
20

21
print(f"准确率: {correct/len(test_data)*100:.2f}%")

1
错误认知：
2
   "微调后模型推理能力变强了"
3

4
正确认知：
5
   微调改变的是"输出分布"，不是"推理能力"
6
   模型的基础能力由预训练决定
7

8
类比：
9
   微调 = 培训员工熟悉公司业务
10
   不会 = 培训员工变聪明
11

12
如果需要更强的推理能力：
13
   → 选择更强的基座模型
14
   → 使用推理增强模型（o1、R1）

1
错误认知：
2
   "训练数据越多，效果越好"
3

4
正确认知：
5
   数据质量 > 数据数量
6
   低质量数据会污染模型
7

8
最佳实践：
9
   1. 先用100-500条高质量数据验证
10
   2. 效果好再逐步增加
11
   3. 始终保持数据质量控制

1
错误认知：
2
   "微调完成，不用管了"
3

4
正确认知：
5
   微调模型需要持续评估和迭代
6

7
维护要点：
8
   - 定期评估效果
9
   - 收集badcase补充训练
10
   - 关注基座模型更新
11
   - 保持训练代码可复现

1
┌─────────────────────────────────────────────────────┐
2
│ 方案     │ 风格适配 │ 知识内化 │ 响应速度 │ 灵活性 │
3
│─────────│─────────│─────────│─────────│───────│
4
│ 提示工程 │ 中       │ 低       │ 快       │ 高    │
5
│ RAG     │ 中       │ 中       │ 慢       │ 高    │
6
│ 微调    │ 高       │ 高       │ 快       │ 低    │
7
└─────────────────────────────────────────────────────┘
8

9
结论：根据需求选择，没有银弹

1
┌─────────────────────────────────────────────────────────────┐
2
│                    微调决策矩阵                               │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  高 │         RAG+微调              │        微调          │
6
│  需 │     （知识+风格）              │    （纯风格）         │
7
│  要 ├───────────────────────────────┼──────────────────────│
8
│  内 │                               │                      │
9
│  化 │         RAG                   │      提示工程        │
10
│  低 │    （纯知识）                  │    （都不需要）       │
11
│     │                               │                      │
12
│     └───────────────────────────────┴──────────────────────│
13
│              低                      高                     │
14
│                   需要特定风格/格式                           │
15
└─────────────────────────────────────────────────────────────┘

1
┌─────────────────────────────────────────────────────────────┐
2
│                      LoRA 微调原理                            │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│   输入 x                                                    │
6
│     │                                                       │
7
│     ▼                                                       │
8
│   ┌─────────────────────────────────────────┐              │
9
│   │              原始权重 W                   │              │
10
│   │         ┌───────────────┐               │              │
11
│   │         │  W (冻结)      │               │              │
12
│   │         │   d × k       │               │              │
13
│   │         └───────┬───────┘               │              │
14
│   │                 │                       │              │
15
│   │                 ▼                       │              │
16
│   │         ┌───────────────┐               │              │
17
│   │         │  W × x        │               │              │
18
│   │         └───────┬───────┘               │              │
19
│   │                 │                       │              │
20
│   └─────────────────┼───────────────────────┘              │
21
│                     │                                       │
22
│                     │  +                                    │
23
│                     │                                       │
24
│   ┌─────────────────┼───────────────────────┐              │
25
│   │                 │                       │              │
26
│   │     ┌───────────┴───────────┐           │              │
27
│   │     │                       │           │              │
28
│   │  ┌──┴──┐                 ┌──┴──┐       │              │
29
│   │  │  B  │      ×          │  A  │       │              │
30
│   │  │d×r  │                 │r×k  │       │              │
31
│   │  └──┬──┘                 └──┬──┘       │              │
32
│   │     │        LoRA           │          │              │
33
│   │     │      (可训练)          │          │              │
34
│   │     └───────────┬───────────┘           │              │
35
│   │                 │                       │              │
36
│   │                 ▼                       │              │
37
│   │         ┌───────────────┐               │              │
38
│   │         │ B × A × x     │               │              │
39
│   │         └───────┬───────┘               │              │
40
│   │                 │                       │              │
41
│   └─────────────────┼───────────────────────┘              │
42
│                     │                                       │
43
│                     ▼                                       │
44
│               输出 = Wx + BAx                               │
45
│                                                             │
46
└─────────────────────────────────────────────────────────────┘