QLoRA微调Qwen3实战：4卡A100训练领域模型的完整流程
·
前言
2025年，大语言模型（LLM）领域最炙手可热的事件之一，当属阿里巴巴通义千问团队开源的Qwen3系列模型。其中Qwen3-72B凭借其出色的推理能力、多语言支持和开源协议，成为众多企业和开发者进行领域适配的首选基座。然而，72B参数的全精度模型需要超过150GB的显存来加载，单卡A100 80G显然力不从心。
如何在有限的GPU资源下，高效微调百亿参数模型？QLoRA（Quantized Low-Rank Adaptation） 技术给出了答案——它将4-bit量化与LoRA结合，使得在4张A100 80G上微调72B模型成为现实。本文将手把手带你走完从环境准备到vLLM部署的完整流程，涵盖所有可运行的代码和常见踩坑指南。
前置要求：4×NVIDIA A100 80G，CUDA 12.x，Python 3.10+，熟悉PyTorch基础操作。
1. 背景与目标
1.1 为什么选择QLoRA？
在讨论具体方案前，先用数据说话。下表是三种主流微调方案的显存占用和参数量对比：
| 方案 | 可训练参数量 | 显存占用（Qwen3-72B） | 训练速度 | 效果 |
|---|---|---|---|---|
| 全量微调（FFT） | 72B | ~640GB（FP16，需多机） | 慢 | 最好，但几乎不可行 |
| LoRA | ~0.1%~1% | ~160GB（FP16） | 中 | 好，显存压力大 |
| QLoRA | ~0.1%~1% | ~40GB（4-bit） | 中快 | 接近LoRA，性价比最高 |
QLoRA的核心思想来自QLoRA论文（QLORA: Efficient Finetuning of Quantized LLMs，Dettmers等，2023），它使用：
- NF4（4-bit NormalFloat） 量化数据类型，减少模型权重的显存占用
- 双重量化（Double Quantization）：对量化常数也做量化
- 分页注意力（Paged Attention）：管理梯度检查点，避免峰值显存爆炸
1.2 本文目标
- 在4×A100 80G上，使用QLoRA微调Qwen3-72B
- 训练一个具备领域知识（如金融、医疗、法律）的垂直模型
- 完整掌握数据准备 → 模型加载 → 训练 → 合并权重 → vLLM部署的全流程
- 避免常见OOM、loss不降、过拟合等坑点
2. 环境准备
2.1 硬件与系统
# 硬件配置
GPU: 4 × NVIDIA A100 80GB
NVLink: 已启用（GPU间通信加速）
CUDA: 12.1 或更高
驱动: NVIDIA Driver >= 525.60.13
操作系统: Ubuntu 22.04 / CentOS 7
2.2 创建Python虚拟环境
conda create -n qlora-qwen3 python=3.10 -y
conda activate qlora-qwen3
# 安装PyTorch（CUDA 12.1版本）
pip install torch==2.3.0 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
2.3 安装核心依赖
# QLoRA核心三件套
pip install transformers==4.40.0
pip install peft==0.10.0
pip install bitsandbytes==0.43.1
# 加速必备
pip install flash-attn --no-build-isolation
pip install accelerate==0.30.0
# 训练辅助
pip install datasets==2.18.0
pip install trl==0.8.6 # SFTTrainer封装
pip install tensorboard==2.16.0
pip install scikit-learn==1.4.2
pip install rouge-score==0.1.2
# vLLM部署
pip install vllm==0.4.0
# 工具库
pip install pandas numpy tqdm loguru
2.4 验证CUDA环境
import torch
print(f"PyTorch版本: {torch.__version__}")
print(f"CUDA可用: {torch.cuda.is_available()}")
print(f"GPU数量: {torch.cuda.device_count()}")
for i in range(torch.cuda.device_count()):
print(f" GPU {i}: {torch.cuda.get_device_name(i)} | {torch.cuda.get_device_properties(i).total_mem / 1024**3:.1f} GB")
输出示例：
PyTorch版本: 2.3.0
CUDA可用: True
GPU数量: 4
GPU 0: NVIDIA A100-SXM4-80GB | 80.0 GB
GPU 1: NVIDIA A100-SXM4-80GB | 80.0 GB
GPU 2: NVIDIA A100-SXM4-80GB | 80.0 GB
GPU 3: NVIDIA A100-SXM4-80GB | 80.0 GB
3. Step 1: 数据准备与清洗
3.1 数据格式说明
QLoRA微调推荐使用ShareGPT / Conversation格式，每条数据包含多轮对话：
{
"messages": [
{"role": "system", "content": "你是一位专业的金融分析师。"},
{"role": "user", "content": "请分析一下茅台股票的近期走势。"},
{"role": "assistant", "content": "根据最近的财务数据和市场表现，贵州茅台..."}
]
}
3.2 数据清洗完整代码
"""
data_prepare.py
数据准备、清洗、质量筛选脚本
"""
import json
import re
import os
from datasets import load_dataset, Dataset
from sklearn.model_selection import train_test_split
from typing import List, Dict, Any
# ============ 1. 原始数据示例 ============
RAW_DATA_EXAMPLES = [
{
"id": 1,
"instruction": "请分析这只股票的投资价值。",
"input": "股票代码：600519（贵州茅台），现价：1680元，市盈率：28倍。",
"output": "从基本面来看，贵州茅台作为A股白酒龙头，具有以下投资亮点..."
},
{
"id": 2,
"instruction": "解释什么是市盈率。",
"input": "",
"output": "市盈率（P/E Ratio）是..."
},
{
"id": 3,
"instruction": "写一段代码。",
"input": "用Python写一个快速排序。",
"output": "```python\ndef quicksort(arr):\n if len(arr) <= 1:\n return arr\n pivot = arr[len(arr) // 2]\n left = [x for x in arr if x < pivot]\n middle = [x for x in arr if x == pivot]\n right = [x for x in arr if x > pivot]\n return quicksort(left) + middle + quicksort(right)\n\nprint(quicksort([3,6,8,10,1,2,1]))\n```"
}
]
# ============ 2. 格式转换：转换为ShareGPT格式 ============
def convert_to_sharegpt(raw_item: Dict[str, Any]) -> Dict[str, Any]:
"""将{instruction, input, output}格式转换为ShareGPT格式"""
messages = []
messages.append({
"role": "system",
"content": "你是一位专业、严谨的金融领域助手，擅长股票分析、财务解读和投资建议。"
})
if raw_item.get("input", "").strip():
user_content = raw_item["instruction"] + "\n" + raw_item["input"]
else:
user_content = raw_item["instruction"]
messages.append({"role": "user", "content": user_content})
messages.append({"role": "assistant", "content": raw_item["output"]})
return {"messages": messages}
# ============ 3. 数据清洗规则 ============
class DataCleaner:
"""数据清洗器：过滤低质量和无效数据"""
def __init__(self):
self.min_response_len = 20
self.max_response_len = 4096
self.min_instruction_len = 2
self.filter_patterns = [
r"^对不起，我无法",
r"^抱歉，我不能",
r"^As an AI",
r"^I\'m sorry, but I",
r"^Sorry, I can\'t",
]
def is_valid(self, item: Dict[str, Any]) -> bool:
"""判断单条数据是否有效"""
messages = item.get("messages", [])
if len(messages) < 2:
return False
if messages[-1]["role"] != "assistant":
return False
response = messages[-1]["content"]
if len(response) < self.min_response_len:
return False
if len(response) > self.max_response_len:
return False
response_lower = response.lower()
for pattern in self.filter_patterns:
if re.search(pattern, response_lower, re.IGNORECASE):
return False
if self._has_garbled(response):
return False
return True
def _has_garbled(self, text: str) -> bool:
"""检测乱码"""
if re.search(r"(.)\1{5,}", text):
return True
return False
def clean(self, dataset: List[Dict]) -> List[Dict]:
"""清洗整个数据集"""
valid_items = []
for item in dataset:
if self.is_valid(item):
valid_items.append(item)
return valid_items
# ============ 4. 质量评分（简单规则版） ============
def score_data_quality(item: Dict[str, Any]) -> float:
"""简单质量评分：0~1分"""
score = 1.0
messages = item.get("messages", [])
if len(messages) > 4:
score += 0.1
if "```" in messages[-1]["content"]:
score += 0.1
if any(c.isdigit() for c in messages[-1]["content"]):
score += 0.1
resp_len = len(messages[-1]["content"])
if resp_len < 100:
score -= 0.1
if resp_len > 3000:
score -= 0.1
return min(1.0, max(0.0, score))
# ============ 5. 主程序：构建训练数据集 ============
def build_dataset(raw_data: List[Dict],
output_path: str = "./data/finetune_data.jsonl",
train_ratio: float = 0.95) -> tuple:
"""
完整数据处理流程
返回: (train_dataset, eval_dataset)
"""
print(f"📥 加载原始数据: {len(raw_data)} 条")
# Step 1: 格式转换
sharegpt_data = [convert_to_sharegpt(item) for item in raw_data]
print(f"✅ 格式转换完成: {len(sharegpt_data)} 条")
# Step 2: 数据清洗
cleaner = DataCleaner()
cleaned_data = cleaner.clean(sharegpt_data)
print(f"🧹 清洗后数据: {len(cleaned_data)} 条（过滤了 {len(sharegpt_data)-len(cleaned_data)} 条）")
# Step 3: 质量评分并排序
scored_data = [(item, score_data_quality(item)) for item in cleaned_data]
scored_data.sort(key=lambda x: x[1], reverse=True)
high_quality_data = [item for item, score in scored_data if score >= 0.8]
print(f"⭐ 高质量数据（分数≥0.8）: {len(high_quality_data)} 条")
# Step 4: 划分训练集和验证集
train_data, eval_data = train_test_split(
high_quality_data,
test_size=1-train_ratio,
random_state=42
)
print(f"📊 训练集: {len(train_data)} 条，验证集: {len(eval_data)} 条")
# Step 5: 保存为JSONL格式
os.makedirs(os.path.dirname(output_path), exist_ok=True)
with open(output_path, "w", encoding="utf-8") as f:
for item in train_data:
f.write(json.dumps(item, ensure_ascii=False) + "\n")
eval_path = output_path.replace("_train.jsonl", "_eval.jsonl")
with open(eval_path, "w", encoding="utf-8") as f:
for item in eval_data:
f.write(json.dumps(item, ensure_ascii=False) + "\n")
print(f"💾 数据已保存:")
print(f" 训练集: {output_path}")
print(f" 验证集: {eval_path}")
return train_data, eval_data
if __name__ == "__main__":
train, eval_ds = build_dataset(RAW_DATA_EXAMPLES)
3.3 使用HuggingFace数据集
# 从HuggingFace加载公开数据集示例
from datasets import load_dataset
# 加载alpaca格式数据并转换
dataset = load_dataset("yahma/alpaca-cleaned", split="train")
print(f"数据集大小: {len(dataset)}")
# 转换为ShareGPT格式
def format_example(example):
messages = [
{"role": "system", "content": "你是一个有帮助的助手。"},
{"role": "user", "content": example["instruction"]},
{"role": "assistant", "content": example["output"]}
]
return {"messages": messages}
formatted_dataset = dataset.map(format_example)
formatted_dataset.to_json("./data/alpaca_formatted.jsonl")
4. Step 2: 4-bit量化加载Qwen3-72B
4.1 量化配置详解
QLoRA使用bitsandbytes库实现4-bit量化，核心参数：
from transformers import BitsAndBytesConfig
# NF4量化配置（推荐用于Qwen3）
bnb_config = BitsAndBytesConfig(
# 量化数据类型：NF4（NormalFloat4），最适合正态分布的权重
load_in_4bit=True,
bnb_4bit_quant_type="nf4", # nf4 或 fp4（推荐nf4）
bnb_4bit_compute_dtype=torch.bfloat16, # 计算时使用bf16
# 双重量化：对量化常数再量化，节省~0.4bit/参数
bnb_4bit_use_double_quant=True,
)
为什么用NF4？ NF4是针对神经网络权重正态分布优化过的4-bit数据类型，在相同bit数下比FP4有更高的表示精度。论文实验显示NF4相比FP4在困惑度指标上平均提升2个百分点。
4.2 加载基座模型
"""
model_loader.py
4-bit量化加载Qwen3-72B
"""
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import prepare_model_for_kbit_training
import os
MODEL_NAME = "Qwen/Qwen2.5-72B-Instruct" # 或 Qwen/Qwen2.5-72B
MODEL_CACHE_DIR = "/data/models/qwen3-72b"
AUTH_TOKEN = "your_huggingface_token" # 如果需要授权
def load_quantized_model(
model_name: str = MODEL_NAME,
cache_dir: str = MODEL_CACHE_DIR,
use_flash_attn: bool = True,
):
"""使用QLoRA方式加载量化模型"""
print("=" * 60)
print("📦 正在加载Qwen3-72B（4-bit NF4量化）...")
print("=" * 60)
# Step 1: 定义量化配置
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True,
)
# Step 2: 加载分词器
print("🔤 加载分词器...")
tokenizer = AutoTokenizer.from_pretrained(
model_name,
cache_dir=cache_dir,
trust_remote_code=True,
token=AUTH_TOKEN,
padding_side="right",
)
if tokenizer.pad_token is None:
tokenizer.pad_token = tokenizer.eos_token
tokenizer.pad_token_id = tokenizer.eos_token_id
# Step 3: 加载量化模型
print("🧠 加载量化模型（预计需要5~10分钟）...")
model = AutoModelForCausalLM.from_pretrained(
model_name,
quantization_config=bnb_config,
device_map="auto", # 自动将模型层分布到多卡
max_memory={
0: "60GiB", # 每张卡最多用60GB（留余量给梯度）
1: "60GiB",
2: "60GiB",
3: "60GiB",
},
torch_dtype=torch.bfloat16,
trust_remote_code=True,
token=AUTH_TOKEN,
attn_implementation="flash_attention_2" if use_flash_attn else "eager",
)
# Step 4: QLoRA专用配置 - 为k-bit训练做准备
model = prepare_model_for_kbit_training(model)
print(f"✅ 模型加载完成！")
print(f" 模型参数量: {sum(p.numel() for p in model.parameters()) / 1e9:.2f}B")
print(f" 量化后显存占用: ~40GB（4卡）")
for i in range(torch.cuda.device_count()):
allocated = torch.cuda.memory_allocated(i) / 1024**3
reserved = torch.cuda.memory_reserved(i) / 1024**3
print(f" GPU {i}: 已分配 {allocated:.2f}GB / 预留 {reserved:.2f}GB")
return model, tokenizer
# ============ 显存占用参考 ============
"""
4-bit NF4量化加载Qwen3-72B后的显存分布：
GPU 0: ~10.5 GB (embedding + transformer blocks 0-17)
GPU 1: ~10.5 GB (transformer blocks 18-35)
GPU 2: ~10.5 GB (transformer blocks 36-53)
GPU 3: ~10.5 GB (transformer blocks 54-71 + lm_head)
梯度优化器状态: ~2GB/卡（使用paged adamw）
梯度: ~1.5GB/卡
激活值: ~5GB/卡（batch_size=4时）
──────────────────────────────
总计: 约40~45GB（4卡总占用）
"""
if __name__ == "__main__":
model, tokenizer = load_quantized_model()
5. Step 3: QLoRA配置与训练
5.1 LoRA配置详解
LoRA的核心思想是在原始权重旁添加低秩分解矩阵，只训练这些低秩参数：
from peft import LoraConfig, get_peft_model, TaskType
# LoRA配置
lora_config = LoraConfig(
# 任务类型：CausalLM（因果语言模型）
task_type=TaskType.CAUSAL_LM,
# r（rank）：LoRA低秩矩阵的维度
# rank越高表达能力越强，但参数量和显存也越高
# 推荐：r=64（72B模型），r=32（7B模型）
r=64,
# alpha：LoRA scaling factor，最终权重 = base + alpha/r * lora_weights
# alpha通常设为rank的2倍
lora_alpha=128,
# Dropout：防止过拟合
lora_dropout=0.05,
# ⚠️ 关键参数：target_modules
# 指定哪些模块应用LoRA，不同模型架构模块名不同
# Qwen2/Qwen3推荐target所有线性层以获得最佳效果
target_modules=[
"q_proj", "k_proj", "v_proj", "o_proj", # Attention中的QKV和输出投影
"gate_proj", "up_proj", "down_proj", # FFN中的MLP层
],
# 偏差层：建议"none"（不训练bias），训练所有bias容易过拟合
bias="none",
# 梯度检查点：节省显存（用计算换显存）
use_gradient_checkpointing=True,
)
5.2 训练超参数配置
"""
trainer_config.py
完整的训练超参数配置
"""
from transformers import TrainingArguments
# ============ 核心超参数 ============
# 学习率：QLoRA通常用比全量微调更高的学习率
# 因为只有0.1%的参数在训练，需要更大的更新幅度
LEARNING_RATE = 2e-4 # 2e-4 ~ 5e-4 之间，3e-4是经验最优值
# Batch size相关
PER_DEVICE_BATCH_SIZE = 4 # 每张卡batch_size，不宜过大
GRADIENT_ACCUMULATION_STEPS = 8 # 梯度累积，总effective_batch=4*8*4=128
# Epochs：领域微调通常2~3个epoch足够
# 过多容易过拟合，尤其是数据量小于10万条时
NUM_EPOCHS = 3
# 序列长度：Qwen3最大支持128K，这里用4K作为平衡
MAX_SEQ_LENGTH = 4096
# Warmup：学习率预热，防止初期梯度爆炸
WARMUP_RATIO = 0.03 # 前3%的步数用于warmup
# 权重衰减：L2正则化
WEIGHT_DECAY = 0.01
# 混合精度：bf16比fp16更稳定，适合大模型训练
BF16 = True
# 梯度裁剪
GRADIENT_CLIP_NORM = 1.0
# 评估策略
EVAL_STRATEGY = "steps"
EVAL_STEPS = 100
SAVE_STRATEGY = "steps"
SAVE_STEPS = 500
SAVE_TOTAL_LIMIT = 3 # 最多保存3个checkpoint
# 日志
LOGGING_STEPS = 10
REPORT_TO = "tensorboard"
# 其他
RUN_NAME = "qwen3-72b-qlora-finetune"
OUTPUT_DIR = "./outputs/qwen3-72b-finetune"
5.3 完整训练脚本
"""
train_qlora.py
完整的QLoRA微调训练脚本
"""
import os
import sys
import torch
from loguru import logger
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
BitsAndBytesConfig,
TrainingArguments,
DataCollatorForSeq2Seq,
set_seed,
)
from peft import (
LoraConfig,
get_peft_model,
prepare_model_for_kbit_training,
TaskType,
)
from trl import SFTTrainer
# ============ 日志配置 ============
logger.remove()
logger.add(
sys.stdout,
format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level}</level> | {message}",
level="INFO",
)
set_seed(42)
# ============ 配置参数 ============
class CFG:
model_name = "Qwen/Qwen2.5-72B-Instruct"
model_cache_dir = "/data/models/qwen3-72b"
hf_token = "your_token_here"
# 数据
train_data_path = "./data/finetune_data_train.jsonl"
eval_data_path = "./data/finetune_data_eval.jsonl"
max_seq_length = 4096
# LoRA配置
lora_r = 64
lora_alpha = 128
lora_dropout = 0.05
lora_target_modules = [
"q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",
]
# 训练超参数
per_device_batch_size = 4
gradient_accumulation_steps = 8
num_epochs = 3
learning_rate = 2e-4
warmup_ratio = 0.03
weight_decay = 0.01
max_grad_norm = 1.0
# 输出
output_dir = "./outputs/qwen3-72b-finetune"
run_name = "qwen3-72b-finetune-v1"
# 系统
bf16 = True
use_flash_attn = True
# ============ 数据预处理 ============
def formatting_prompts_func(example):
"""将数据格式化为模型输入格式"""
output_texts = []
for item in example["messages"]:
texts = []
for msg in item:
if msg["role"] == "system":
texts.append(f"<|im_start|>system\n{msg['content']}<|im_end|>")
elif msg["role"] == "user":
texts.append(f"<|im_start|>user\n{msg['content']}<|im_end|>")
elif msg["role"] == "assistant":
texts.append(f"<|im_start|>assistant\n{msg['content']}<|im_end|>")
text = "\n".join(texts) + "<|im_end|>\n"
output_texts.append(text)
return output_texts
def prepare_dataset(data_path: str, tokenizer, max_length: int):
"""加载并预处理数据集"""
dataset = load_dataset("json", data_files=data_path, split="train")
logger.info(f"数据集大小: {len(dataset)}")
def tokenize(element):
texts = formatting_prompts_func(element["messages"])
model_inputs = tokenizer(
texts,
max_length=max_length,
truncation=True,
padding="max_length",
return_tensors=None,
)
model_inputs["labels"] = model_inputs["input_ids"].copy()
return model_inputs
tokenized_dataset = dataset.map(
tokenize,
batched=True,
remove_columns=dataset.column_names,
num_proc=8,
desc="Tokenizing dataset",
)
return tokenized_dataset
# ============ 模型加载 ============
def load_model_and_tokenizer(cfg: CFG):
"""加载量化模型和分词器"""
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True,
)
logger.info("🔤 加载分词器...")
tokenizer = AutoTokenizer.from_pretrained(
cfg.model_name,
cache_dir=cfg.model_cache_dir,
trust_remote_code=True,
token=cfg.hf_token,
padding_side="right",
)
if tokenizer.pad_token is None:
tokenizer.pad_token = tokenizer.eos_token
tokenizer.pad_token_id = tokenizer.eos_token_id
logger.info("🧠 加载量化模型（4-bit NF4）...")
model = AutoModelForCausalLM.from_pretrained(
cfg.model_name,
quantization_config=bnb_config,
device_map="auto",
max_memory={i: "60GiB" for i in range(torch.cuda.device_count())},
torch_dtype=torch.bfloat16,
trust_remote_code=True,
token=cfg.hf_token,
attn_implementation="flash_attention_2" if cfg.use_flash_attn else "eager",
)
model = prepare_model_for_kbit_training(model)
logger.info("✅ 模型加载完成")
return model, tokenizer
# ============ 训练主函数 ============
def main():
cfg = CFG()
logger.info("🚀 QLoRA微调Qwen3-72B 训练启动")
logger.info(f" 模型: {cfg.model_name}")
logger.info(f" LoRA rank: {cfg.lora_r}, alpha: {cfg.lora_alpha}")
eff_batch = cfg.per_device_batch_size * cfg.gradient_accumulation_steps * torch.cuda.device_count()
logger.info(f" Batch size: {cfg.per_device_batch_size} × {cfg.gradient_accumulation_steps} × {torch.cuda.device_count()}GPU = {eff_batch}")
# Step 1: 加载模型
model, tokenizer = load_model_and_tokenizer(cfg)
# Step 2: 配置LoRA
logger.info("⚙️ 配置LoRA适配器...")
lora_cfg = LoraConfig(
task_type=TaskType.CAUSAL_LM,
r=cfg.lora_r,
lora_alpha=cfg.lora_alpha,
lora_dropout=cfg.lora_dropout,
target_modules=cfg.lora_target_modules,
bias="none",
use_gradient_checkpointing=True,
)
model = get_peft_model(model, lora_cfg)
model.print_trainable_parameters()
# 输出示例:
# trainable params: 198, 180, 480 || all params: 76, 337, 559, 040 || trainable%: 0.2596
# Step 3: 加载数据集
logger.info("📚 加载训练数据...")
train_dataset = prepare_dataset(cfg.train_data_path, tokenizer, cfg.max_seq_length)
eval_dataset = None
if os.path.exists(cfg.eval_data_path):
logger.info("📚 加载验证数据...")
eval_dataset = prepare_dataset(cfg.eval_data_path, tokenizer, cfg.max_seq_length)
# Step 4: DataCollator
data_collator = DataCollatorForSeq2Seq(
tokenizer=tokenizer,
model=model,
padding=True,
max_length=cfg.max_seq_length,
)
# Step 5: 训练参数
training_args = TrainingArguments(
output_dir=cfg.output_dir,
run_name=cfg.run_name,
num_train_epochs=cfg.num_epochs,
per_device_train_batch_size=cfg.per_device_batch_size,
per_device_eval_batch_size=cfg.per_device_batch_size,
gradient_accumulation_steps=cfg.gradient_accumulation_steps,
gradient_checkpointing=True,
gradient_checkpointing_kwargs={"use_reentrant": False},
learning_rate=cfg.learning_rate,
warmup_ratio=cfg.warmup_ratio,
weight_decay=cfg.weight_decay,
max_grad_norm=cfg.max_grad_norm,
optim="paged_adamw_32bit",
eval_strategy="steps" if eval_dataset else "no",
eval_steps=100 if eval_dataset else None,
save_strategy="steps",
save_steps=500,
save_total_limit=3,
load_best_model_at_end=True if eval_dataset else False,
logging_steps=10,
logging_first_step=True,
report_to="tensorboard",
bf16=cfg.bf16,
fp16=not cfg.bf16,
dataloader_num_workers=4,
remove_unused_columns=False,
seed=42,
ddp_find_unused_parameters=False,
)
# Step 6: 创建SFTTrainer
trainer = SFTTrainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
data_collator=data_collator,
tokenizer=tokenizer,
max_seq_length=cfg.max_seq_length,
dataset_text_field="text",
)
# Step 7: 开始训练
logger.info("🔥 开始训练！")
logger.info("=" * 60)
train_result = trainer.train()
# Step 8: 保存最终模型
logger.info("💾 保存最终模型...")
trainer.save_model(os.path.join(cfg.output_dir, "final_model"))
trainer.save_state()
metrics = train_result.metrics
trainer.log_metrics("train", metrics)
trainer.save_metrics("train", metrics)
logger.info("🎉 训练完成！")
loss_val = metrics.get('train_loss', 'N/A')
logger.info(f" 最终训练loss: {loss_val}")
logger.info(f" 模型保存位置: {cfg.output_dir}/final_model")
if __name__ == "__main__":
main()
5.4 启动训练
# 单机多卡训练（推荐4卡）
torchrun --nproc_per_node=4 train_qlora.py
# 如果需要分布式多机训练
# torchrun --nproc_per_node=4 --nnodes=2 --node_rank=0 --master_addr=192.168.1.1 train_qlora.py
# 查看训练进度（另一个终端）
tensorboard --logdir ./outputs/qwen3-72b-finetune-v1/runs
6. Step 4: 训练监控与调优
6.1 关键监控指标
训练过程中，以下指标需要重点关注：
# 训练日志中的关键指标解读
# ✅ 正常情况
# Step 10 | loss: 2.345 | lr: 1.2e-5 | iter/s: 2.3
# loss应该稳定下降，前100步下降最快
# ⚠️ loss震荡（可能原因）
# - 学习率过高 → 降低lr到1e-4或5e-5
# - batch太小 → 增加gradient_accumulation_steps
# - 数据噪声大 → 提升数据清洗标准
# ⚠️ loss不下降（可能原因）
# - 模型已经收敛到预训练知识 → 尝试更大的r值
# - 数据与模型能力不匹配 → 检查数据质量
# - 学习率过低 → 提升到3e-4或5e-4
6.2 显存不够时的处理策略
"""
显存优化策略（按优先级排序）
"""
# 策略1: 减小batch_size（最简单）
per_device_batch_size = 2 # 从4降到2
# 策略2: 增加gradient_accumulation_steps（保持effective batch）
gradient_accumulation_steps = 16 # 从8提到16
# 策略3: 减小max_seq_length
max_seq_length = 2048 # 从4096降到2048
# 策略4: 使用梯度检查点（默认已启用）
# 在LoraConfig中：
use_gradient_checkpointing = True
# 策略5: 减小LoRA rank
lora_r = 32 # 从64降到32，显存约省一半
# 策略6: 关闭double quant
bnb_4bit_use_double_quant = False # 牺牲~0.4bit精度换显存
6.3 TensorBoard可视化
# 训练过程中生成的可视化数据位于:
# ./outputs/qwen3-72b-finetune-v1/runs/
# 查看关键指标:
# - train/loss: 训练loss曲线
# - train/learning_rate: 学习率曲线
# - eval/loss: 验证loss曲线（如有）
# - system/gpu_flops_utilization: GPU利用率
7. Step 5: 合并权重与导出
7.1 合并LoRA权重
训练完成后，LoRA权重需要合并回原模型才能被标准推理框架（如vLLM）使用：
"""
merge_and_export.py
合并LoRA权重并导出完整模型
"""
import torch
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import os
from loguru import logger
BASE_MODEL_PATH = "Qwen/Qwen2.5-72B-Instruct"
LORA_ADAPTER_PATH = "./outputs/qwen3-72b-finetune/final_model"
EXPORT_PATH = "./outputs/qwen3-72b-finetune/merged_model"
HF_TOKEN = "your_token_here"
def merge_lora_weights():
logger.info("🔄 开始合并LoRA权重...")
# Step 1: 加载基座模型（FP16精度，用于合并）
logger.info("📦 加载基座模型（FP16）...")
base_model = AutoModelForCausalLM.from_pretrained(
BASE_MODEL_PATH,
device_map="cpu", # 合并时放CPU，避免显存不够
torch_dtype=torch.float16,
trust_remote_code=True,
token=HF_TOKEN,
)
# Step 2: 加载LoRA权重
logger.info("📦 加载LoRA适配器...")
model = PeftModel.from_pretrained(
base_model,
LORA_ADAPTER_PATH,
device_map="cpu",
)
# Step 3: 合并权重
logger.info("⚙️ 执行权重合并（预计需要10~20分钟）...")
model = model.merge_and_unload()
# Step 4: 保存合并后的模型
logger.info(f"💾 保存合并模型到: {EXPORT_PATH}")
os.makedirs(EXPORT_PATH, exist_ok=True)
model.save_pretrained(EXPORT_PATH, safe_serialization=True)
# 保存分词器
tokenizer = AutoTokenizer.from_pretrained(
BASE_MODEL_PATH,
trust_remote_code=True,
token=HF_TOKEN,
)
tokenizer.save_pretrained(EXPORT_PATH)
logger.info("✅ 合并完成！")
files = os.listdir(EXPORT_PATH)
logger.info(f"📁 导出文件列表: {files}")
return model, tokenizer
if __name__ == "__main__":
merge_lora_weights()
7.2 导出为HuggingFace格式
# 方式1: 直接用transformers CLI
transformers-cli upload ./outputs/qwen3-72b-finetune/merged_model
# 方式2: 压缩后手动上传
cd ./outputs/qwen3-72b-finetune
tar -czvf merged_model.tar.gz merged_model/
# 方式3: Push到HuggingFace Hub
python -c "
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained('./outputs/qwen3-72b-finetune/merged_model')
tokenizer = AutoTokenizer.from_pretrained('./outputs/qwen3-72b-finetune/merged_model')
model.push_to_hub('your_username/qwen3-72b-finetuned-v1')
tokenizer.push_to_hub('your_username/qwen3-72b-finetuned-v1')
"
8. Step 6: vLLM部署微调模型
8.1 为什么选择vLLM
vLLM是目前最高效的LLM推理引擎之一，核心优势：
- PagedAttention：类似操作系统的虚拟内存分页管理KV Cache，显存利用率提升2~3倍
- Continuous Batching：动态批处理不同长度的请求，吞吐量提升5~10倍
- 支持FP16/BF16/INT8/INT4量化推理
- OpenAI兼容API：无需修改代码即可替换OpenAI接口
8.2 vLLM部署脚本
"""
deploy_vllm.py
使用vLLM部署微调后的Qwen3模型
"""
from vllm import LLM, SamplingParams
MODEL_PATH = "./outputs/qwen3-72b-finetune/merged_model"
GPU_MEMORY_UTILIZATION = 0.90
MAX_MODEL_LEN = 4096
def start_inference_server():
print("🚀 启动vLLM推理服务...")
llm = LLM(
model=MODEL_PATH,
tensor_parallel_size=4, # 使用的GPU数量
gpu_memory_utilization=GPU_MEMORY_UTILIZATION,
max_model_len=MAX_MODEL_LEN,
dtype="bfloat16",
trust_remote_code=True,
enable_prefix_caching=True,
)
print("✅ vLLM服务已启动！")
return llm
def generate_text(llm, prompt: str, max_tokens: int = 512, temperature: float = 0.7):
"""生成文本"""
sampling_params = SamplingParams(
temperature=temperature,
top_p=0.9,
top_k=20,
max_tokens=max_tokens,
stop=["<|im_end|>", "<|endoftext|>"],
)
outputs = llm.generate([prompt], sampling_params)
generated_text = outputs[0].outputs[0].text
return generated_text
def batch_generate(llm, prompts: list, max_tokens: int = 512):
"""批量生成（vLLM的优势场景）"""
sampling_params = SamplingParams(
temperature=0.7,
top_p=0.9,
max_tokens=max_tokens,
stop=["<|im_end|>"],
)
outputs = llm.generate(prompts, sampling_params)
results = [output.outputs[0].text for output in outputs]
return results
if __name__ == "__main__":
llm = start_inference_server()
# 单条测试
prompt = """<|im_start|>system
你是一位专业的金融分析师。<|im_end|>
<|im_start|>user
请分析一下贵州茅台的当前投资价值，重点关注其财务数据和估值水平。<|im_end|>
<|im_start|>assistant
"""
print("📝 输入:", prompt[:100], "...")
response = generate_text(llm, prompt, max_tokens=1024)
print("🤖 输出:", response)
# 批量测试（展示vLLM吞吐优势）
print("\n📊 批量推理测试...")
batch_prompts = [
"<|im_start|>system\n你是一个有用的助手。<|im_end|><|im_start|>user\n什么是市盈率？<|im_end|><|im_start|>assistant\n",
"<|im_start|>system\n你是一个有用的助手。<|im_end|><|im_start|>user\n解释一下什么是ETF。<|im_end|><|im_start|>assistant\n",
"<|im_start|>system\n你是一个有用的助手。<|im_end|><|im_start|>user\n如何分散投资风险？<|im_end|><|im_start|>assistant\n",
]
results = batch_generate(llm, batch_prompts, max_tokens=256)
for i, r in enumerate(results):
print(f" [{i+1}] {r[:80]}...")
8.3 启动API服务（OpenAI兼容）
# 启动HTTP API服务
python -m vllm.entrypoints.openai.api_server \
--model ./outputs/qwen3-72b-finetune/merged_model \
--served-model-name qwen3-72b-finetuned \
--tensor-parallel-size 4 \
--gpu-memory-utilization 0.90 \
--max-model-len 4096 \
--port 8000 \
--host 0.0.0.0
# 服务启动后，API调用示例：
# curl http://localhost:8000/v1/chat/completions \
# -H "Content-Type: application/json" \
# -d '{
# "model": "qwen3-72b-finetuned",
# "messages": [{"role": "user", "content": "你好"}]
# }'
9. 常见问题与踩坑
Q1: 训练时显存溢出（OOM）
问题描述：CUDA out of memory. Tried to allocate ...
原因分析：
- batch_size设置过大
- max_seq_length过长
- 梯度累积时中间激活值占用过多显存
解决方案：
# 立即止损操作（按优先级）：
# 1. 减小batch_size: 4 → 2
# 2. 减小max_seq_length: 4096 → 2048
# 3. 增加gradient_accumulation: 8 → 16
# 4. 开启梯度检查点
model.gradient_checkpointing_enable()
# 高级优化：使用Deepspeed ZeRO
# 在 TrainingArguments 中添加:
training_args = TrainingArguments(deepspeed="ds_config.json", ...)
Q2: Loss不下降
问题描述：训练loss一直在2.0左右震荡，不收敛
排查步骤：
# 1. 检查数据格式是否正确
# 确认每条数据的labels字段不为全-100
print(tokenized_dataset[0]["labels"][:20])
# 2. 检查学习率是否合适
# 如果模型是在chat数据上微调，尝试 lr=5e-5
# 如果是在领域知识注入，尝试 lr=1e-4 ~ 3e-4
# 3. 检查数据质量
# 确保数据没有大量重复、噪声或乱码
# 4. 尝试不同的LoRA rank
# r=16 → r=64 → r=128 逐一尝试
Q3: 过拟合严重
问题描述：训练loss很低，但验证loss很高
解决方案：
# 1. 增加数据集规模（最少1000条高质量数据）
# 2. 增大lora_dropout: 0.05 → 0.1
# 3. 减少训练epoch: 3 → 2
# 4. 提高权重衰减: weight_decay=0.01 → 0.1
# 5. 使用更大的r值增加模型容量
Q4: 数据格式错误
问题描述：KeyError: 'messages' 或 ValueError: ...is not a valid Special token
解决方案：
# 1. 确认system prompt的role为"system"而非"system prompt"
# ✅ 正确: {"role": "system", "content": "..."}
# ❌ 错误: {"role": "system prompt", "content": "..."}
# 2. 确认每条数据都以assistant回复结尾
assert messages[-1]["role"] == "assistant"
# 3. 检查特殊token是否在tokenizer中存在
assert "<|im_start|>" in tokenizer.get_vocab()
assert "<|im_end|>" in tokenizer.get_vocab()
# 4. 检查tokenizer添加了特殊token
tokenizer.add_special_tokens({"additional_special_tokens": ["<|im_start|>", "<|im_end|>"]})
Q5: 模型合并后效果变差
问题描述：合并后模型回答质量不如训练过程中观察到的效果
原因与解决：
# 1. 使用safe_serialization=True保存
model.save_pretrained(export_path, safe_serialization=True)
# 2. 合并时使用全精度
base_model = AutoModelForCausalLM.from_pretrained(
base_model_path,
torch_dtype=torch.float16, # 不要用float32，会OOM
)
# 3. 确认LoRA权重被正确加载
# 检查adapter_config.json是否存在
# 检查adapter_model.safetensors或adapter_model.bin文件大小
10. 完整训练脚本汇总
将上述所有代码整合为一个可一键运行的脚本：
# 运行完整训练流程（推荐）
bash run_full_pipeline.sh
# 或直接运行Python脚本
python train_qlora.py
完整脚本可参考GitHub仓库（链接略），包含：
requirements.txt- 依赖清单config.yaml- 所有超参数配置train_qlora.py- 主训练脚本merge_weights.py- 权重合并脚本deploy_vllm.py- vLLM部署脚本
11. 效果验证
11.1 困惑度（Perplexity）评估
"""
eval_perplexity.py
计算验证集的困惑度
"""
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset
import math
def calculate_perplexity(model_path: str, eval_data_path: str):
"""计算模型困惑度"""
model = AutoModelForCausalLM.from_pretrained(
model_path,
device_map="auto",
torch_dtype=torch.bfloat16,
trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(
model_path,
trust_remote_code=True,
)
dataset = load_dataset("json", data_files=eval_data_path, split="train")
total_loss = 0
total_tokens = 0
model.eval()
with torch.no_grad():
for item in dataset:
assistant_text = item["messages"][-1]["content"]
inputs = tokenizer(
assistant_text,
return_tensors="pt",
truncation=True,
max_length=2048,
).to("cuda")
outputs = model(**inputs, labels=inputs["input_ids"])
total_loss += outputs.loss.item() * inputs["input_ids"].size(1)
total_tokens += inputs["input_ids"].size(1)
perplexity = math.exp(total_loss / total_tokens)
print(f"📊 验证集困惑度: {perplexity:.2f}")
return perplexity
# 基座模型困惑度 vs 微调后模型困惑度对比
# 基座Qwen3-72B-Instruct: ~15~25（取决于领域）
# 微调后模型: 应明显下降（通常在5~15之间）
11.2 人工评估标准
| 维度 | 评估标准 | 评分（1-5） |
|---|---|---|
| 领域准确性 | 回答是否准确反映领域知识 | 1=明显错误，5=专业准确 |
| 指令遵循 | 是否按用户要求格式/长度输出 | 1=偏离，5=完美遵循 |
| 流畅性 | 语句是否通顺自然 | 1=明显不通顺，5=流畅自然 |
| 安全性 | 是否有有害内容 | 1=有害，5=完全安全 |
| 一致性 | 多轮对话上下文是否一致 | 1=前后矛盾，5=完全一致 |
11.3 对比测试示例
"""
compare_models.py
对比基座模型和微调模型的效果
"""
def compare_models(base_model_path, finetuned_model_path, test_prompts):
"""对比测试"""
base_model = load_model(base_model_path)
finetuned_model = load_model(finetuned_model_path)
results = []
for prompt in test_prompts:
base_resp = generate(base_model, prompt)
finetuned_resp = generate(finetuned_model, prompt)
results.append({
"prompt": prompt,
"base_response": base_resp,
"finetuned_response": finetuned_resp,
})
return results
# 测试样例
test_prompts = [
"请分析一下XX股票的技术面。",
"解释一下什么是市净率。",
"如果我有100万，应该如何配置资产？",
]
# 预期结果：
# 基座模型：回答通用，但缺乏领域深度
# 微调模型：回答专业，有具体数据和术语
总结
本文完整介绍了使用QLoRA技术在4×A100 80G上微调Qwen3-72B的全流程，核心要点回顾：
- 数据是关键：高质量、多样化、格式正确的训练数据是微调成功的第一步
- QLoRA性价比最高：4-bit量化将显存需求从640GB降至~40GB，效果接近全量微调
- LoRA rank=64是72B模型的经验最优值：太低欠拟合，太高浪费显存
- 学习率2e-4：比全量微调高一个数量级，确保LoRA参数有足够更新幅度
- vLLM部署：合并后的模型通过vLLM部署，可实现高吞吐、低延迟的推理服务
中国智能体开发者社区，聚焦智能体与大模型开发，提供前沿资讯、实用工具链、开源项目及行业案例。通过技术沙龙、开发者大赛等活动，促进经验交流与协作，助力开发者快速构建创新智能应用。
更多推荐
8
0- 0
已为社区贡献4条内容
所有评论(0)