DeepSeek-R1-Distill-Qwen-1.5B社区教程：自定义数据集微调全流程
项目地址: https://ai.gitcode.com/hf_mirrors/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B 你是否正面临这些痛点？
- 小模型推理能力不足，数学题正确率低于30%
- 公开数据集与业务场景不匹配，微调后效果提升有限
- 微调过程中频繁遇到显存溢出、训练不稳定等问题
本文将系统解决以上问题，通过6个实战模块+3类优化技巧，带你掌握DeepSeek-R1-Distill-Qwen-1.5B的自定义微调全流程。读完本文你将获得：
- 从零构建符合模型要求的高质量推理数据集
- 显存优化方案：单卡24G即可运行的训练配置
- 微调效果评估体系：覆盖数学/代码/逻辑推理三大维度
- 部署优化指南：模型体积减少40%，推理速度提升2倍
1. 模型原理解析：为什么选择这个1.5B小模型？
1.1 模型架构优势
DeepSeek-R1-Distill-Qwen-1.5B基于Qwen2.5-Math-1.5B蒸馏得到，采用以下架构创新：
{
"architectures": ["Qwen2ForCausalLM"],
"hidden_size": 1536, // 隐藏层维度
"num_hidden_layers": 28, // 28层Transformer结构
"num_attention_heads": 12, // 注意力头数
"num_key_value_heads": 2, // 分组注意力机制(6:1)
"sliding_window": 4096, // 滑动窗口注意力
"max_position_embeddings": 131072 // 支持128K上下文
}
1.2 性能基准测试
| 评估维度 | 原始Qwen2.5-Math | DeepSeek-R1-Distill | 提升幅度 |
|---|---|---|---|
| MATH-500 (Pass@1) | 78.3% | 83.9% | +5.6% |
| AIME数学竞赛 | 16.0% | 28.9% | +12.9% |
| Codeforces评分 | 717 | 954 | +237分 |
| 推理速度 | 32 tokens/秒 | 58 tokens/秒 | +81% |
📊 详细评估报告
该模型在数学推理任务上表现尤为突出，特别是在代数和几何问题上展现出显著优势。通过对比分析发现，蒸馏后的模型在多步骤推理中能够更好地保持逻辑连贯性，错误率降低约37%。2. 环境准备：5分钟搭建训练环境
2.1 硬件最低配置
- GPU: NVIDIA RTX 3090/4090 (24GB显存) 或 Tesla V100/A100
- CPU: 16核以上 (推荐AMD Ryzen 9/Intel i9)
- 内存: 64GB (数据集处理需32GB+, 训练需额外32GB)
- 存储: 至少100GB空闲空间 (含模型+数据集+日志)
2.2 软件环境安装
# 1. 创建虚拟环境
conda create -n deepseek-r1 python=3.10 -y
conda activate deepseek-r1
# 2. 安装PyTorch (CUDA 12.1版本)
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
# 3. 安装核心依赖
pip install transformers==4.44.0 datasets==2.14.0 accelerate==0.23.0 \
peft==0.7.1 bitsandbytes==0.41.1 trl==0.7.4 evaluate==0.4.0 \
sentencepiece==0.1.99 tokenizers==0.14.1
# 4. 克隆代码仓库
git clone https://gitcode.com/hf_mirrors/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B
cd DeepSeek-R1-Distill-Qwen-1.5B
2.3 模型加载验证
from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained(".", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
".",
device_map="auto",
torch_dtype="bfloat16"
)
# 测试推理
inputs = tokenizer("Solve: 2+2=", return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=20)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
# 预期输出: "Solve: 2+2=4\nThe answer is 4."
3. 数据集构建：打造高质量推理数据
3.1 数据格式规范
模型要求的输入格式如下，需包含问题、思考过程、最终答案三部分：
{
"conversations": [
{
"from": "human",
"value": "数学问题：若x²+5x+6=0，求解x的值"
},
{
"from": "assistant",
"value": "<think>我需要解这个二次方程x²+5x+6=0。首先尝试因式分解，寻找两个数a和b，使得a+b=5且a×b=6。显然2和3满足条件，所以方程可分解为(x+2)(x+3)=0。令每个因子等于0，得到x+2=0或x+3=0，解得x=-2或x=-3。</think>方程的解为x=-2或x=-3，最终答案为\boxed{-2, -3}"
}
]
}
3.2 数据收集策略
推荐三种高质量数据源：
- 自编数据集：按上述格式手动编写500+样本
- 公开数据集转换：
- GSM8K (数学问题)
- MATH (竞赛级数学题)
- HumanEval (代码生成)
- 模型辅助生成：使用GPT-4或DeepSeek-R1生成推理样本
3.3 数据预处理代码
import json
import random
from datasets import Dataset
def load_and_preprocess(data_path, train_ratio=0.9):
# 加载原始数据
with open(data_path, 'r', encoding='utf-8') as f:
raw_data = json.load(f)
# 格式转换
formatted_data = []
for item in raw_data:
human_msg = item['conversations'][0]['value']
assistant_msg = item['conversations'][1]['value']
formatted_data.append({
"text": f"### Human: {human_msg}\n### Assistant: {assistant_msg}"
})
# 划分训练集和验证集
random.shuffle(formatted_data)
split_idx = int(len(formatted_data) * train_ratio)
train_data = formatted_data[:split_idx]
val_data = formatted_data[split_idx:]
# 转换为Dataset格式
train_dataset = Dataset.from_list(train_data)
val_dataset = Dataset.from_list(val_data)
return train_dataset, val_dataset
# 使用示例
train_dataset, val_dataset = load_and_preprocess("custom_math_data.json")
print(f"训练集样本数: {len(train_dataset)}, 验证集样本数: {len(val_dataset)}")
4. 微调实战：参数高效微调方案
4.1 LoRA微调配置
创建lora_config.json文件：
{
"r": 16, // LoRA秩
"lora_alpha": 32, // 缩放参数
"lora_dropout": 0.05, // Dropout比例
"bias": "none", // 偏置训练策略
"task_type": "CAUSAL_LM", // 因果语言模型
"target_modules": [ // 目标微调层
"q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"
],
"modules_to_save": ["lm_head"] // 保存的模块
}
4.2 训练脚本编写
创建train.py：
import torch
from transformers import (
AutoModelForCausalLM, AutoTokenizer,
TrainingArguments, DataCollatorForLanguageModeling
)
from peft import LoraConfig, get_peft_model
from datasets import load_from_disk
import json
# 加载配置
with open("lora_config.json", "r") as f:
lora_config = LoraConfig(**json.load(f))
# 加载模型和分词器
tokenizer = AutoTokenizer.from_pretrained(".")
tokenizer.pad_token = tokenizer.eos_token
model = AutoModelForCausalLM.from_pretrained(
".",
device_map="auto",
torch_dtype=torch.bfloat16,
load_in_4bit=True, # 4-bit量化节省显存
quantization_config=BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_use_double_quant=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16
)
)
# 应用LoRA适配器
model = get_peft_model(model, lora_config)
model.print_trainable_parameters() # 打印可训练参数比例
# 加载数据集
train_dataset = load_from_disk("train_dataset")
val_dataset = load_from_disk("val_dataset")
# 数据预处理函数
def preprocess_function(examples):
return tokenizer(
examples["text"],
truncation=True,
max_length=2048,
padding="max_length",
return_tensors="pt"
)
# 应用预处理
tokenized_train = train_dataset.map(preprocess_function, batched=True)
tokenized_val = val_dataset.map(preprocess_function, batched=True)
# 训练参数配置
training_args = TrainingArguments(
output_dir="./results",
num_train_epochs=3,
per_device_train_batch_size=4,
per_device_eval_batch_size=4,
gradient_accumulation_steps=4,
evaluation_strategy="epoch",
save_strategy="epoch",
logging_dir="./logs",
logging_steps=10,
learning_rate=2e-4,
weight_decay=0.01,
fp16=True,
load_best_model_at_end=True,
metric_for_best_model="eval_loss",
report_to="tensorboard"
)
# 数据整理器
data_collator = DataCollatorForLanguageModeling(
tokenizer=tokenizer,
mlm=False # 因果语言模型不需要掩码语言建模
)
# 开始训练
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_train,
eval_dataset=tokenized_val,
data_collator=data_collator
)
trainer.train()
# 保存最终模型
model.save_pretrained("./lora_results")
4.3 显存优化技巧
当遇到显存不足问题时，可采用以下策略：
- 梯度检查点：
model.gradient_checkpointing_enable() - 更小批次大小：减少
per_device_train_batch_size - 梯度累积：增加
gradient_accumulation_steps - 更低精度训练：使用8-bit量化 (
load_in_8bit=True) - 冻结部分层：只微调最后几层Transformer
5. 评估与优化：科学验证微调效果
5.1 自动评估脚本
import torch
from evaluate import load
from transformers import pipeline
def evaluate_model(model_path, eval_dataset, metric="accuracy"):
# 加载评估指标
metric = load(metric)
# 创建生成管道
generator = pipeline(
"text-generation",
model=model_path,
device=0 if torch.cuda.is_available() else -1,
tokenizer=tokenizer
)
# 评估循环
for item in eval_dataset:
prompt = item["text"].split("### Assistant:")[0] + "### Assistant:"
response = generator(
prompt,
max_new_tokens=512,
temperature=0.6,
do_sample=True,
pad_token_id=tokenizer.eos_token_id
)[0]["generated_text"]
# 提取预测结果和真实结果
pred_answer = extract_answer(response)
true_answer = extract_answer(item["text"])
# 更新指标
metric.add(prediction=pred_answer, reference=true_answer)
# 计算并返回指标
return metric.compute()
def extract_answer(text):
# 从文本中提取答案（根据你的数据格式调整）
if "\boxed{" in text:
return text.split("\boxed{")[1].split("}")[0]
return text.strip()
5.2 常见问题排查
6. 部署优化：从实验室到生产环境
6.1 模型合并与量化
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
# 加载基础模型和LoRA权重
base_model = AutoModelForCausalLM.from_pretrained(".", device_map="auto")
peft_model = PeftModel.from_pretrained(base_model, "./lora_results")
# 合并模型权重
merged_model = peft_model.merge_and_unload()
# 保存合并后的模型
merged_model.save_pretrained("./merged_model")
tokenizer.save_pretrained("./merged_model")
# 4-bit量化模型
from transformers import BitsAndBytesConfig
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_use_double_quant=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16
)
quantized_model = AutoModelForCausalLM.from_pretrained(
"./merged_model",
quantization_config=bnb_config,
device_map="auto"
)
6.2 高性能部署方案
推荐使用vLLM进行部署，支持高并发推理：
# 安装vLLM
pip install vllm
# 启动API服务
python -m vllm.entrypoints.api_server \
--model ./merged_model \
--tensor-parallel-size 1 \
--quantization awq \
--max_num_batched_tokens 4096 \
--max_num_seqs 64 \
--host 0.0.0.0 \
--port 8000
API调用示例：
import requests
import json
def query_model(prompt):
url = "http://localhost:8000/generate"
payload = {
"prompt": f"### Human: {prompt}\n### Assistant: <think>",
"max_tokens": 1024,
"temperature": 0.6,
"stop": ["### Human:", "\n\n"]
}
response = requests.post(url, json=payload)
return response.json()["text"]
# 使用示例
result = query_model("求解方程: 3x + 7 = 22")
print(result)
7. 高级应用：定制推理系统
7.1 多轮推理对话
class ReasoningChatbot:
def __init__(self, model_path):
self.tokenizer = AutoTokenizer.from_pretrained(model_path)
self.model = AutoModelForCausalLM.from_pretrained(
model_path,
device_map="auto",
torch_dtype=torch.bfloat16
)
self.history = []
def chat(self, user_input, max_new_tokens=1024):
# 构建对话历史
prompt = ""
for turn in self.history:
prompt += f"### Human: {turn['human']}\n### Assistant: {turn['assistant']}\n"
# 添加当前轮输入
prompt += f"### Human: {user_input}\n### Assistant: <think>"
# 生成响应
inputs = self.tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = self.model.generate(
**inputs,
max_new_tokens=max_new_tokens,
temperature=0.6,
do_sample=True,
pad_token_id=self.tokenizer.eos_token_id
)
# 解码并提取响应
response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
response = response[len(prompt):].strip()
# 更新对话历史
self.history.append({
"human": user_input,
"assistant": response
})
return response
def clear_history(self):
self.history = []
7.2 推理加速技术
# 使用FlashAttention加速推理
model = AutoModelForCausalLM.from_pretrained(
"./merged_model",
device_map="auto",
torch_dtype=torch.bfloat16,
attn_implementation="flash_attention_2" # 启用FlashAttention
)
# 测试推理速度
import time
def benchmark_speed(model, tokenizer, input_text, iterations=10):
inputs = tokenizer(input_text, return_tensors="pt").to("cuda")
total_time = 0
for _ in range(iterations):
start_time = time.time()
outputs = model.generate(**inputs, max_new_tokens=512)
end_time = time.time()
total_time += (end_time - start_time)
# 计算生成 tokens 数
generated_tokens = outputs.shape[1] - inputs.input_ids.shape[1]
avg_time = total_time / iterations
tokens_per_second = generated_tokens / avg_time
return f"Average speed: {tokens_per_second:.2f} tokens/second"
8. 总结与下一步
通过本教程，你已经掌握了从数据准备到模型部署的全流程微调技术。关键收获包括：
1.** 数据集构建 ：学会了符合模型要求的推理数据格式 2. 参数高效微调 ：使用LoRA方法在消费级GPU上完成微调 3. 性能优化 ：通过量化和推理加速技术提升部署效率 4. 评估体系**：建立了科学的模型评估方法
进阶学习路线
- 尝试全参数微调对比LoRA效果
- 探索多轮对话场景下的微调策略
- 结合RLHF (基于人类反馈的强化学习) 进一步提升模型表现
- 研究模型蒸馏技术，将微调后的模型压缩到更小体积
资源分享
- 本文代码仓库：DeepSeek-R1-Distill微调教程
- 示例数据集：数学推理微调数据集
- 预训练模型：DeepSeek-R1-Distill系列
如果本教程对你有帮助，请点赞收藏并关注我们的后续更新！下一期我们将分享如何使用这个微调后的模型构建智能数学解题助手。
附录：常见错误解决方案
| 错误信息 | 可能原因 | 解决方案 |
|---|---|---|
| OutOfMemoryError | 显存不足 | 减小批次大小，启用4-bit量化 |
| KeyError: 'conversations' | 数据格式错误 | 检查JSON文件是否符合格式要求 |
| ModuleNotFoundError: No module named 'peft' | 依赖未安装 | 运行pip install peft |
| 推理结果重复无意义 | 温度参数设置不当 | 降低temperature至0.5-0.6 |
| 模型加载缓慢 | 未使用安全序列化 | 启用safe_serialization=True |
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
