微调与LoRA

全参数微调 70B 模型需要 280GB GPU 内存。LoRA 只训练 0.1% 的参数——不到 1GB——就能达到 95% 以上的全参数微调效果。这就是参数高效微调（PEFT）的力量。

类型： 构建 语言： Python 前置条件： Phase 10 Lesson 06（指令微调 SFT） 预计时间： ~60 分钟

学习目标

• 理解 LoRA 的数学原理：低秩分解
• 掌握 LoRA 的关键超参数：rank、alpha、目标模块
• 理解 QLoRA 和 NF4 量化
• 实现完整的 LoRA 微调流程

LoRA 原理

LoRA（Low-Rank Adaptation）将权重更新分解为低秩矩阵：

$W' = W + \Delta W = W + BA$

其中 $B \in \mathbb{R}^{d \times r}$，$A \in \mathbb{R}^{r \times k}$，$r \ll \min(d, k)$。

原始权重 $W$ 冻结不更新，只训练 $A$ 和 $B$。

import torch
import torch.nn as nn


class LoRALayer(nn.Module):
    """LoRA 适配层"""

    def __init__(self, original_layer, rank=8, alpha=16):
        super().__init__()
        self.original_layer = original_layer
        self.rank = rank
        self.alpha = alpha
        self.scaling = alpha / rank

        # 获取原始层的维度
        if isinstance(original_layer, nn.Linear):
            d_out, d_in = original_layer.weight.shape
        else:
            raise ValueError("LoRA only supports Linear layers")

        # 低秩矩阵
        self.lora_A = nn.Parameter(torch.randn(d_in, rank) * 0.01)
        self.lora_B = nn.Parameter(torch.zeros(rank, d_out))

        # 冻结原始权重
        original_layer.weight.requires_grad = False
        if original_layer.bias is not None:
            original_layer.bias.requires_grad = False

    def forward(self, x):
        # 原始变换
        original_output = self.original_layer(x)

        # LoRA 增量
        lora_output = (x @ self.lora_A @ self.lora_B) * self.scaling

        return original_output + lora_output

参数量对比

使用 PEFT 库

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


def setup_lora(model_name="meta-llama/Llama-2-7b-hf", rank=8, alpha=16):
    """配置 LoRA 微调"""
    # 加载基座模型
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.bfloat16,
        device_map="auto",
    )

    # LoRA 配置
    lora_config = LoraConfig(
        task_type=TaskType.CAUSAL_LM,
        r=rank,
        lora_alpha=alpha,
        lora_dropout=0.05,
        target_modules=["q_proj", "v_proj", "k_proj", "o_proj",
                        "gate_proj", "up_proj", "down_proj"],
        bias="none",
    )

    # 应用 LoRA
    model = get_peft_model(model, lora_config)
    model.print_trainable_parameters()
    # 输出: trainable params: 13,107,200 || all params: 6,738,415,616 || trainable%: 0.1945

    return model

QLoRA

QLoRA 在 LoRA 基础上加入 4-bit 量化，进一步降低内存：

from transformers import BitsAndBytesConfig


def setup_qlora(model_name="meta-llama/Llama-2-7b-hf", rank=64, alpha=16):
    """配置 QLoRA 微调"""
    # 4-bit 量化配置
    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.bfloat16,
        bnb_4bit_use_double_quant=True,
    )

    # 加载量化模型
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        quantization_config=bnb_config,
        device_map="auto",
    )

    # LoRA 配置（QLoRA 通常用更高的 rank）
    lora_config = LoraConfig(
        task_type=TaskType.CAUSAL_LM,
        r=rank,
        lora_alpha=alpha,
        target_modules=["q_proj", "v_proj", "k_proj", "o_proj",
                        "gate_proj", "up_proj", "down_proj"],
    )

    model = get_peft_model(model, lora_config)
    return model

Rank 选择指南

合并 LoRA 适配器

def merge_lora(model):
    """将 LoRA 权重合并到基座模型"""
    model = model.merge_and_unload()
    return model

# 保存合并后的模型
model = merge_lora(model)
model.save_pretrained("merged_model")

关键术语

延伸阅读

• Hu et al., 2021 — “LoRA: Low-Rank Adaptation of Large Language Models” — LoRA 原始论文
• Dettmers et al., 2023 — “QLoRA: Efficient Finetuning of Quantized Language Models” — QLoRA 论文
• PEFT 文档 — Hugging Face PEFT 库