模型合并、量化与推理加速

LoRA 权重合并

from peft import AutoPeftModelForCausalLM
from transformers import AutoTokenizer

# 加载带 LoRA 的模型
model = AutoPeftModelForCausalLM.from_pretrained(
    "./lora-output",
    torch_dtype="bfloat16"
)
tokenizer = AutoTokenizer.from_pretrained("./lora-output")

# 将 LoRA 权重合并进基座模型
merged_model = model.merge_and_unload()

# 保存合并后的完整模型
merged_model.save_pretrained("./merged-model", safe_serialization=True)
tokenizer.save_pretrained("./merged-model")

LoRA 权重合并

from peft import AutoPeftModelForCausalLM
from transformers import AutoTokenizer

# 加载带 LoRA 的模型
model = AutoPeftModelForCausalLM.from_pretrained(
    "./lora-output",
    torch_dtype="bfloat16"
)
tokenizer = AutoTokenizer.from_pretrained("./lora-output")

# 将 LoRA 权重合并进基座模型
merged_model = model.merge_and_unload()

# 保存合并后的完整模型
merged_model.save_pretrained("./merged-model", safe_serialization=True)
tokenizer.save_pretrained("./merged-model")

模型合并的数学原理

模型合并（Model Merging）是将多个微调后的模型权重组合成一个新模型的技术。这不是简单的平均，而是基于线性代数的权重空间操作。

线性插值合并（Linear Interpolation）

最简单的合并方法，适用于同一基座模型的不同微调版本：

W_merged = α × W_A + (1 - α) × W_B

其中：
- W_A, W_B 是两个微调模型的权重
- α ∈ [0, 1] 是插值系数
- α = 0.5 表示等权重平均

使用 mergekit 进行模型合并

# 安装 mergekit
pip install mergekit

# 创建合并配置文件 merge_config.yaml
cat > merge_config.yaml << 'EOF'
merge_method: slerp
slices:
  - sources:
      - model: meta-llama/Llama-3.1-8B-Instruct
        layer_range: [0, 32]
      - model: ./my-finetuned-model
        layer_range: [0, 32]
parameters:
  t: 0.5  # SLERP 插值系数
dtype: float16
EOF

# 执行合并
mergekit-yaml merge_config.yaml ./merged-model --cuda

量化技术深度解析

量化的数学基础

量化是将高精度浮点数（FP16/FP32）映射到低精度整数（INT8/INT4）的过程：

对称量化（Symmetric Quantization）：
Q(x) = round(x / scale) × scale
scale = max(|x|) / (2^(bits-1) - 1)

非对称量化（Asymmetric Quantization）：
Q(x) = round((x - zero_point) / scale)
scale = (max(x) - min(x)) / (2^bits - 1)
zero_point = round(-min(x) / scale)

GPTQ 量化实战

from transformers import AutoModelForCausalLM, AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

# 1. 加载原始模型
model_id = "meta-llama/Llama-3.1-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)

# 2. 准备校准数据（128 条样本）
from datasets import load_dataset
calibration_data = load_dataset("wikitext", "wikitext-2-raw-v1", split="train")
calibration_samples = [
    tokenizer(text, return_tensors="pt", truncation=True, max_length=2048)
    for text in calibration_data["text"][:128]
]

# 3. 配置量化参数
quantize_config = BaseQuantizeConfig(
    bits=4,                    # 4-bit 量化
    group_size=128,           # 每 128 个权重共享一个 scale
    damp_percent=0.01,        # Hessian 阻尼系数
    desc_act=False,            # 是否量化激活值（通常 False）
    sym=True,                  # 对称量化
    true_sequential=True      # 逐层量化（更慢但更准确）
)

# 4. 执行量化（需要 GPU，约 10-30 分钟）
model = AutoGPTQForCausalLM.from_pretrained(
    model_id,
    quantize_config=quantize_config
)
model.quantize(calibration_samples)

# 5. 保存量化模型
model.save_quantized("./llama-3.1-8b-gptq")
tokenizer.save_pretrained("./llama-3.1-8b-gptq")

量化格式对比

转换为 GGUF（Ollama 本地部署）

# 安装 llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && pip install -r requirements.txt

# 转换为 GGUF 格式
python convert_hf_to_gguf.py \
  --outfile my-model-q4.gguf \
  --outtype q4_k_m \
  ./merged-model

# 用 Ollama 运行
cat > Modelfile <<EOF
FROM ./my-model-q4.gguf
SYSTEM "你是专业的代码助手..."
EOF
ollama create my-finetune -f Modelfile
ollama run my-finetune

AWQ 量化（GPU 高性能部署）

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model = AutoAWQForCausalLM.from_pretrained("./merged-model")
tokenizer = AutoTokenizer.from_pretrained("./merged-model")

# 量化（需要 128 条校准数据）
quant_config = {"zero_point": True, "q_group_size": 128, "w_bit": 4, "version": "GEMM"}
model.quantize(tokenizer, quant_config=quant_config)
model.save_quantized("./my-model-awq")

# 用 vLLM 部署 AWQ 模型
# vllm serve ./my-model-awq --quantization awq --max-model-len 4096

vLLM 高性能服务部署

# 安装 vLLM
pip install vllm

# 启动 OpenAI 兼容服务
vllm serve ./merged-model \
  --served-model-name my-finetune \
  --max-model-len 4096 \
  --gpu-memory-utilization 0.9 \
  --tensor-parallel-size 1 \
  --port 8000

# 调用（兼容 OpenAI 格式）
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "my-finetune", "messages": [{"role": "user", "content": "你好"}]}'

量化的工作原理

推理性能基准测试

import time
import requests

def benchmark_vllm(n_requests: int = 100, prompt: str = "介绍一下机器学习："):
    """测量 vLLM 服务的吞吐量（tokens/second）"""
    url = "http://localhost:8000/v1/chat/completions"

    start = time.time()
    total_tokens = 0

    for _ in range(n_requests):
        resp = requests.post(url, json={
            "model": "my-finetune",
            "messages": [{"role": "user", "content": prompt}],
            "max_tokens": 200
        })
        result = resp.json()
        total_tokens += result["usage"]["completion_tokens"]

    elapsed = time.time() - start
    tps = total_tokens / elapsed

    print(f"总耗时: {elapsed:.1f}s")
    print(f"总生成 tokens: {total_tokens}")
    print(f"吞吐量: {tps:.1f} tokens/s")
    print(f"平均延迟: {elapsed/n_requests*1000:.0f}ms/request")

本章小结