🛠️ 模型微调与量化

🤔 一、为什么需要微调？

预训练大语言模型（如 LLaMA、GPT、Qwen）经过海量文本训练，掌握了通用的语言理解和生成能力。但在实际应用中，我们通常需要模型在特定领域（如医疗、法律、金融）或特定任务（如代码生成、风格改写）上有更出色的表现。这就是微调的价值所在。

微调 vs Prompt Engineering vs RAG：选择指南

🏋️ 二、全量微调（Full Fine-tuning）

全量微调是最直接的微调方式：解冻预训练模型的所有参数，用任务特定的数据继续训练。模型的所有权重（可能达到数百亿个参数）都会被更新。

其中 θ 为模型参数，η 为学习率，L 为任务损失函数，D_task 为任务数据。

资源需求参考

适用场景：数据充足（≥ 10K 条）、算力充足、对效果上限有极致要求、且有完善评估体系防止过拟合和遗忘的情况。

⚡ 三、参数高效微调（PEFT）

全量微调的代价太高了。能不能只训练一小部分参数，同时达到接近全量微调的效果？PEFT（Parameter-Efficient Fine-Tuning）就是答案。

3.1 LoRA（Low-Rank Adaptation）

LoRA 是目前最流行的 PEFT 方法，由 Hu 等人于 2021 年提出^[1]。其核心洞察是：模型微调时的权重变化量 ΔW 具有低秩特性（intrinsic dimensionality 很低）。

来看一个使用 PEFT + Transformers 库实现 LoRA 的代码示例：

Python · LoRA 配置# pip install peft transformers datasets bitsandbytes

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model, TaskType

# 1. 加载基础模型（以 Qwen2.5-7B 为例）
model_name = "Qwen/Qwen2.5-7B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)

# 2. 配置 LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                    # 秩（rank），越大越灵活，但也越慢
    lora_alpha=32,           # 缩放因子，通常设为 2 × r
    lora_dropout=0.05,       # Dropout 防止过拟合
    target_modules=[            # 对哪些层加 LoRA
        "q_proj", "k_proj",     # Attention 的 Q/K 投影
        "v_proj", "o_proj",     # Attention 的 V/O 投影
        "gate_proj", "up_proj", # FFN 层
        "down_proj",
    ],
    bias="none",
)

# 3. 应用 LoRA 到模型
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 输出: trainable params: 4,194,304 || all params: 7,616,724,992
      trainable%: 0.0551%

3.2 QLoRA（Quantized LoRA）

QLoRA 由 Dettmers 等人于 2023 年提出^[2]，是 LoRA 的"升级版"——在4-bit 量化的模型上做 LoRA 微调。这使得在单张 48GB GPU（如 RTX 6000 Ada）上微调 65B 参数的模型成为可能。

Python · QLoRA 微调# pip install peft transformers datasets bitsandbytes accelerate

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# 1. 4-bit 量化配置
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",           # NormalFloat4
    bnb_4bit_compute_dtype="bfloat16",    # 计算精度
    bnb_4bit_use_double_quant=True,        # 双重量化
)

# 2. 以 4-bit 加载模型
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-7B-Instruct",
    quantization_config=bnb_config,
    device_map="auto"
)

# 3. 为 k-bit 训练做准备
model = prepare_model_for_kbit_training(model)

# 4. 配置 LoRA（与普通 LoRA 相同）
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)

# 5. 正常训练...

3.3 其他 PEFT 方法

📦 四、模型量化（Quantization）

大模型推理的瓶颈不仅在算力，更在内存带宽。一个 7B 模型在 FP32 下需要 ~28GB 内存，而量化到 INT4 后只需 ~3.5GB——这意味着可以在消费级硬件上运行更大的模型。

4.1 量化基础概念

量化就是降低数值的表示精度，让模型用更少的 bit 来存储权重和激活值。

4.2 训练后量化（Post-Training Quantization, PTQ）

PTQ 在模型训练完成后进行量化，不需要重新训练，是最常用的量化方式。主要方法有三种：

4.3 量化训练（Quantization-Aware Training, QAT）

QAT 在训练过程中就考虑量化的影响，通过在训练图中插入伪量化节点（fake quantization nodes），让模型学会适应低精度表示。

4.4 GGUF 格式

GGUF（GPT-Generated Unified Format）是 llama.cpp 项目定义的模型文件格式，也是 Ollama 等工具的底层格式。它将模型权重以多种量化级别打包成单个文件，方便在 CPU 和混合环境下高效推理。

4.5 量化方法效果对比

🚀 五、实战指南

5.1 用 LoRA 微调一个模型（完整代码）

下面展示一个完整的 LoRA 微调流程，包括数据准备、模型加载、训练、合并权重和测试。

Python · 数据准备from datasets import load_dataset

# 方式1: 从 HuggingFace Hub 加载
dataset = load_dataset("tatsu-lab/alpaca", split="train")

# 方式2: 从本地 JSON 文件加载
# dataset = load_dataset("json", data_files="my_data.json", split="train")

# 格式化为对话模板
def format_example(example):
    return {
        "text": f"""<|im_start|>system
你是一个有帮助的AI助手。<|im_end|>
<|im_start|>user
{example['instruction']}{example['input']}<|im_end|>
<|im_start|>assistant
{example['output']}<|im_end|>"""
    }

dataset = dataset.map(format_example)
# 选取子集用于快速实验
dataset = dataset.select(range(10000))

Python · 训练from transformers import (
    AutoModelForCausalLM, AutoTokenizer,
    TrainingArguments, BitsAndBytesConfig, DataCollatorForSeq2Seq
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer

# QLoRA 量化配置
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype="bfloat16",
    bnb_4bit_use_double_quant=True,
)

# 加载模型和分词器
model_name = "Qwen/Qwen2.5-7B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)
model = prepare_model_for_kbit_training(model)

# LoRA 配置
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    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",
)

# 训练参数
training_args = TrainingArguments(
    output_dir="./lora_output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,      # 等效 batch_size=16
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_ratio=0.03,
    fp16=True,
    logging_steps=10,
    save_strategy="epoch",
    gradient_checkpointing=True,         # 节省显存
    optim="paged_adamw_8bit",             # 8bit 优化器
    max_seq_length=2048,
)

# 开始训练
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    args=training_args,
    peft_config=lora_config,
    dataset_text_field="text",
    max_seq_length=2048,
)
trainer.train()
trainer.model.save_pretrained("./lora_adapter")  # 保存 LoRA 权重

Python · 合并权重from peft import PeftModel

# 加载基础模型 + LoRA 适配器
base_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto",
)
model = PeftModel.from_pretrained(base_model, "./lora_adapter")

# 合并权重并保存
merged_model = model.merge_and_unload()
merged_model.save_pretrained("./merged_model")
tokenizer.save_pretrained("./merged_model")
# 得到一个独立的模型，不再需要 PEFT 库即可加载

Python · 推理测试# 加载合并后的模型
model = AutoModelForCausalLM.from_pretrained(
    "./merged_model",
    torch_dtype="auto",
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("./merged_model")

prompt = "<|im_start|>user\n什么是机器学习？<|im_end|>\n<|im_start|>assistant\n"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=512,
    temperature=0.7,
    top_p=0.9,
    do_sample=True,
)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

5.2 用 Ollama 运行量化模型

Ollama 是最流行的本地 LLM 运行工具之一，底层使用 llama.cpp 和 GGUF 格式，让量化模型的部署变得极其简单。

Bash · 安装 Ollama# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh

# 安装后验证
ollama --version

Bash · 运行模型# 下载 Qwen2.5 7B 的 Q4_K_M 量化版
ollama pull qwen2.5:7b

# 交互式对话
ollama run qwen2.5:7b

# 单次提问
ollama run qwen2.5:7b "用 Python 写一个快速排序"

# 查看 GPU 使用情况
ollama ps

# 其他常用模型
ollama pull llama3.1:8b      # LLaMA 3.1 8B
ollama pull mistral:7b        # Mistral 7B
ollama pull deepseek-r1:14b   # DeepSeek R1 14B
ollama pull gemma2:9b         # Gemma 2 9B

Bash · API 调用# 兼容 OpenAI 格式的 API
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5:7b",
    "messages": [
      {"role": "user", "content": "你好，介绍一下自己"}
    ]
  }'

Python · OpenAI SDK 调用 Ollamafrom openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # Ollama 不需要真实 key
)

response = client.chat.completions.create(
    model="qwen2.5:7b",
    messages=[
        {"role": "user", "content": "什么是量化？"}
    ]
)
print(response.choices[0].message.content)

📋 六、微调数据准备

微调的效果，80% 取决于数据质量。好的数据准备是微调成功的关键。

6.1 数据格式要求

大多数微调框架要求将数据整理为指令-回复对（Instruction-Response pairs）格式：

JSON · 微调数据格式[
  {
    "instruction": "将以下句子翻译成英文",
    "input": "今天天气真好，适合出去散步。",
    "output": "The weather is great today, perfect for a walk."
  },
  {
    "instruction": "请总结以下文本",
    "input": "人工智能（AI）是计算机科学的一个分支...",
    "output": "AI 是计算机科学的研究方向，致力于创建能模拟人类智能的系统。"
  }
]

也可以使用多轮对话格式：

JSON · 多轮对话格式{
  "messages": [
    {"role": "system", "content": "你是一个专业的法律顾问。"},
    {"role": "user", "content": "劳动合同到期不续签有补偿吗？"},
    {"role": "assistant", "content": "根据《劳动合同法》第46条..."}
  ]
}

6.2 数据质量 > 数据数量

6.3 数据清洗

在训练前，务必对数据进行清洗。关键步骤包括：

6.4 合成数据（Synthetic Data）

当真实数据不足时，可以用更强的模型（如 GPT-4、Claude）生成合成训练数据。这是扩大数据集的有效手段。

Python · 用 LLM 生成合成数据from openai import OpenAI
import json

client = OpenAI()

# 定义种子问题（你已有的少量真实问题）
seed_topics = [
    "Python 的列表推导式用法",
    "SQL JOIN 的区别",
    "React 的 useEffect 钩子",
    "Git rebase vs merge",
    "Docker 容器化部署",
]

synthetic_data = []
for topic in seed_topics:
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "你是一个技术问答专家。请针对给定的主题，生成3个不同难度的问题和详细回答。输出JSON数组格式。"},
            {"role": "user", "content": topic}
        ]
    )
    synthetic_data.append(response.choices[0].message.content)

# 保存合成数据
with open("synthetic_data.json", "w") as f:
    json.dump(synthetic_data, f, ensure_ascii=False, indent=2)