LoRA/PEFT 微调

🎨 交互演示 (Interactive)

调整维度和秩，观察 LoRA 如何大幅减少可训练参数量。

🔧 LoRA 可视化

输入维度 d: 512

输出维度 k: 512

LoRA 秩 r: 8

原始权重 W

512 × 512

冻结 ❄️

W₀

不更新

LoRA ΔW = B × A

512×8

8×512

全量微调

0.26M

512 × 512 = 262,144 参数

LoRA (r=8)

0.0082M

8×512 + 512×8 = 8,192 参数

参数减少

96.9%

压缩比

32.0x

秩 / 维度

1.6%

📖 LoRA 原理

W' = W₀ + B × A

W₀: 预训练权重 (冻结，不更新)
A: 下投影矩阵，将 k 维映射到 r 维
B: 上投影矩阵，将 r 维映射回 d 维
r: 秩 (rank)，通常 4-64，控制表达能力

💡 典型应用:

7B 模型全量微调需 ~28GB 显存，LoRA 只需 ~8GB
可以为不同任务训练多个 LoRA 适配器，快速切换
常用于 Query/Key/Value 投影层和 FFN 层
QLoRA: LoRA + 4-bit 量化，进一步减少显存

💡 推荐: r=8~32, α=2r (缩放因子)

📌 核心定义 (What)

一句话定义：LoRA (Low-Rank Adaptation) 是一种参数高效微调技术，通过训练低秩矩阵来适配大模型，只需更新 0.1%-1% 的参数即可达到全量微调的效果。

PEFT: Parameter-Efficient Fine-Tuning，参数高效微调的统称
LoRA: 最流行的 PEFT 方法，冻结原模型，只训练低秩适配器
QLoRA: LoRA + 4bit 量化，进一步降低显存需求

🏠 生活类比 (Analogy)

🎸 “给吉他加变调夹”

全量微调	LoRA 微调
重新制作一把新吉他	在原吉他上加个变调夹
改变整个吉他的音色	只调整需要的音高
成本高，耗时长	便宜、快速、可拆卸
每首歌一把吉他	一把吉他 + 多个变调夹

LoRA 就是给大模型加”变调夹”，轻量级地改变它的行为。

🎯 为什么需要 LoRA？ (Why)

全量微调的问题

模型	参数量	全量微调显存	LoRA 微调显存
7B	70亿	56 GB (FP16)	8 GB
13B	130亿	104 GB	12 GB
70B	700亿	560 GB	48 GB

LoRA 的优势

优势	说明
显存	降低 80%+
存储	原模型 14GB + LoRA 几十 MB
多任务	一个基座模型 + 多个 LoRA 适配器
效果	接近全量微调

📊 技术原理 (Math)

核心思想：低秩分解

预训练权重 $W_0$ 固定，添加可训练的低秩矩阵：

LoRA 权重更新

W = W_0 + \Delta W = W_0 + BA

$W_0 \in \mathbb{R}^{d \times k}$ : 冻结的预训练权重
$B \in \mathbb{R}^{d \times r}$ : 可训练，初始化为 0
$A \in \mathbb{R}^{r \times k}$ : 可训练，随机初始化
$r \ll \min(d, k)$ : 秩，通常 8-64

参数量对比

层	原始参数	LoRA 参数 (r=8)	压缩比
4096 × 4096	16.7M	65K	256x
4096 × 11008	45M	120K	375x

前向传播

LoRA 前向传播

h = W_0 x + \frac{\alpha}{r} BAx

$x$ : 输入
$\alpha$ : 缩放因子（控制 LoRA 影响强度）
$r$ : 秩
推理时可合并: $W = W_0 + \frac{\alpha}{r}BA$

应用位置

通常应用于 Transformer 的 Attention 层：

┌─────────────────────────────────────────┐
│              Attention Layer            │
├─────────────────────────────────────────┤
│  Q = W_q · x + B_q · A_q · x   ← LoRA  │
│  K = W_k · x + B_k · A_k · x   ← LoRA  │
│  V = W_v · x + B_v · A_v · x   ← LoRA  │
│  O = W_o · attn + B_o · A_o    ← LoRA  │
└─────────────────────────────────────────┘

💻 代码实现 (Code)

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

# 1. 加载基座模型
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    torch_dtype=torch.float16,
    device_map="auto"
)

# 2. 配置 LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=8,                      # 秩
    lora_alpha=32,            # 缩放因子
    lora_dropout=0.1,         # Dropout
    target_modules=[          # 应用 LoRA 的层
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
)

# 3. 创建 PEFT 模型
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 4,194,304 || all params: 6,742,609,920
# trainable%: 0.0622%

# 4. 正常训练
from transformers import Trainer, TrainingArguments

trainer = Trainer(
    model=model,
    args=TrainingArguments(
        output_dir="./lora-llama2",
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        num_train_epochs=3,
        learning_rate=2e-4,
        fp16=True,
    ),
    train_dataset=dataset,
)
trainer.train()

# 5. 保存 LoRA 权重 (仅几十 MB)
model.save_pretrained("./lora-llama2")

# 6. 加载使用
from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
model = PeftModel.from_pretrained(base_model, "./lora-llama2")

# 7. 合并权重 (可选，用于部署)
merged_model = model.merge_and_unload()

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

# 1. 4bit 量化配置
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

# 2. 加载量化模型
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    quantization_config=bnb_config,
    device_map="auto",
)

# 3. 准备模型用于 k-bit 训练
model = prepare_model_for_kbit_training(model)

# 4. LoRA 配置
lora_config = LoraConfig(
    r=64,                     # QLoRA 推荐更高的秩
    lora_alpha=16,
    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",
)

# 5. 创建 QLoRA 模型
model = get_peft_model(model, lora_config)

# 现在只需 ~6GB 显存即可微调 7B 模型！

import torch
import torch.nn as nn

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

    def __init__(
        self,
        in_features: int,
        out_features: int,
        rank: int = 8,
        alpha: float = 16,
        dropout: float = 0.1
    ):
        super().__init__()
        self.rank = rank
        self.alpha = alpha
        self.scaling = alpha / rank

        # 原始权重 (冻结)
        self.weight = nn.Parameter(
            torch.randn(out_features, in_features),
            requires_grad=False
        )

        # LoRA 矩阵
        self.lora_A = nn.Parameter(torch.randn(rank, in_features))
        self.lora_B = nn.Parameter(torch.zeros(out_features, rank))
        self.dropout = nn.Dropout(dropout)

        # 初始化
        nn.init.kaiming_uniform_(self.lora_A, a=math.sqrt(5))
        nn.init.zeros_(self.lora_B)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # 原始前向
        result = x @ self.weight.T

        # LoRA 增量
        lora_out = self.dropout(x) @ self.lora_A.T @ self.lora_B.T
        result += lora_out * self.scaling

        return result

    def merge_weights(self):
        """合并 LoRA 到原始权重"""
        self.weight.data += (self.lora_B @ self.lora_A) * self.scaling

🔧 LoRA 变体

方法	特点	适用场景
LoRA	基础版，添加低秩矩阵	通用微调
QLoRA	LoRA + 4bit 量化	显存受限
DoRA	分解权重为方向和大小	更接近全量微调
AdaLoRA	自适应调整秩	自动化调参
LoRA+	不同学习率 for A 和 B	更快收敛

⚠️ 常见误区 (Pitfalls)

🔗 相关概念

Transformer - 基础架构
量化 - QLoRA 的基础
RLHF - 可与 LoRA 结合

📚 延伸资源

LoRA 论文

Low-Rank Adaptation of LLMs

阅读

QLoRA 论文

Efficient Finetuning of Quantized LLMs

阅读

PEFT 库

Hugging Face 官方实现

GitHub