手把手教你微调 DeepSeek 模型：从数据准备到模型部署完整指南#

1
[
2
  {
3
    "instruction": "用 Python 实现一个二分查找算法",
4
    "input": "",
5
    "output": "```python\ndef binary_search(arr, target):\n    left, right = 0, len(arr) - 1\n    \n    while left <= right:\n        mid = (left + right) // 2\n        if arr[mid] == target:\n            return mid\n        elif arr[mid] < target:\n            left = mid + 1\n        else:\n            right = mid - 1\n    \n    return -1\n```\n\n**算法说明**：\n- 时间复杂度：O(log n)\n- 空间复杂度：O(1)\n- 前提条件：数组必须是有序的"
6
  },
7
  {
8
    "instruction": "解释什么是 RESTful API",
9
    "input": "",
10
    "output": "RESTful API（Representational State Transfer）是一种 API 设计规范...（省略 200 字）..."
11
  }
12
]

1
import json
2
import random
3
from typing import List, Dict
4

5
class DataAugmenter:
6
    """数据增强器：一条数据变成 N 条"""
7

8
    def __init__(self, seed_data: List[Dict]):
9
        self.data = seed_data
10

11
    def paraphrase_instruction(self, text: str) -> str:
12
        """改写指令（用 LLM 做同义改写）"""
13
        templates = [
14
            f"请解释一下：{text}",
15
            f"跟我说说 {text} 是怎么回事",
16
            f"给我详细讲讲 {text}",
17
            f"你能介绍一下 {text} 吗？",
18
            f"关于 {text}，你知道些什么？"
19
        ]
20
        return random.choice(templates)
21

22
    def split_long_output(self, output: str) -> List[str]:
23
        """拆分长输出为多个知识点"""
24
        sections = output.split("\n\n")
25
        return [s.strip() for s in sections if len(s.strip()) > 50]
26

27
    def augment(self, multiplier: int = 3) -> List[Dict]:
28
        """增强数据集"""
29
        augmented = []
30
        for item in self.data:
31
            augmented.append(item)  # 保留原始
32
            for _ in range(multiplier - 1):
33
                new_item = {
34
                    "instruction": self.paraphrase_instruction(item["instruction"]),
35
                    "input": item["input"],
36
                    "output": item["output"]
37
                }
38
                augmented.append(new_item)
39
        return augmented
40

41
# 使用
42
augmenter = DataAugmenter(raw_data)
43
final_data = augmenter.augment(multiplier=5)
44
print(f"数据量：{len(raw_data)} → {len(final_data)}")

1
import torch
2
from transformers import (
3
    AutoModelForCausalLM,
4
    AutoTokenizer,
5
    BitsAndBytesConfig
6
)
7
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
8

9
# 4-bit 量化配置（省显存的关键）
10
bnb_config = BitsAndBytesConfig(
11
    load_in_4bit=True,
12
    bnb_4bit_quant_type="nf4",
13
    bnb_4bit_compute_dtype=torch.bfloat16,
14
    bnb_4bit_use_double_quant=True,
15
)
16

17
# 加载模型
18
model = AutoModelForCausalLM.from_pretrained(
19
    "deepseek-ai/deepseek-llm-7b-chat",
20
    quantization_config=bnb_config,
21
    device_map="auto",
22
    trust_remote_code=True,
23
)
24

25
# 加载分词器
26
tokenizer = AutoTokenizer.from_pretrained(
27
    "deepseek-ai/deepseek-llm-7b-chat",
28
    trust_remote_code=True,
29
)
30
tokenizer.pad_token = tokenizer.eos_token

1
# LoRA 配置——只训练一小部分参数
2
lora_config = LoraConfig(
3
    r=16,              # LoRA 秩，越大效果越好但也越耗显存
4
    lora_alpha=32,     # 缩放参数
5
    target_modules=[   # 要微调的目标模块
6
        "q_proj",
7
        "k_proj",
8
        "v_proj",
9
        "o_proj",
10
        "gate_proj",
11
        "up_proj",
12
        "down_proj",
13
    ],
14
    lora_dropout=0.05, # Dropout 防止过拟合
15
    bias="none",
16
    task_type="CAUSAL_LM",
17
)
18

19
# 应用 LoRA
20
model = prepare_model_for_kbit_training(model)
21
model = get_peft_model(model, lora_config)
22

23
# 看看有多少参数被训练
24
model.print_trainable_parameters()
25
# 输出: trainable params: 8,388,608 || all params: 6,743,363,584 || trainable%: 0.12%

1
from transformers import TrainingArguments, Trainer
2

3
training_args = TrainingArguments(
4
    output_dir="./deepseek-finetuned",
5
    num_train_epochs=3,
6
    per_device_train_batch_size=4,
7
    gradient_accumulation_steps=4,
8
    warmup_steps=100,
9
    learning_rate=2e-4,
10
    fp16=True,
11
    logging_steps=10,
12
    save_strategy="epoch",
13
    report_to="none",  # 不想看 wandb 可以关掉
14
)
15

16
trainer = Trainer(
17
    model=model,
18
    args=training_args,
19
    train_dataset=tokenized_dataset,
20
    data_collator=default_data_collator,
21
)
22

23
# 开跑！（去泡杯咖啡，半小时后回来）
24
trainer.train()

1
# 保存 LoRA 权重（只有几十 MB）
2
model.save_pretrained("./my-deepseek-lora")
3
tokenizer.save_pretrained("./my-deepseek-lora")
4

5
# 如果想把 LoRA 合并到原模型（会变大）
6
from peft import PeftModel
7

8
merged_model = PeftModel.from_pretrained(model, "./my-deepseek-lora")
9
merged_model = merged_model.merge_and_unload()
10
merged_model.save_pretrained("./my-deepseek-merged")

1
# hermes config.yaml
2
custom_providers:
3
  my-finetuned-deepseek:
4
    api_base: http://localhost:8000/v1
5
    model: my-deepseek-merged
6
    api_key: "not-needed"

1
outputs = model.generate(
2
    **inputs,
3
    repetition_penalty=1.1,  # 默认 1.0，适当提高
4
)