【训练与微调篇04】LoRA与QLoRA原理实战：单卡微调大模型的全套方案

🪡 LoRA与QLoRA原理实战：单卡微调大模型的全套方案
2024 年，微调 70B 模型需要 16 张 A100，花费 $100,000+。2026 年，一张 RTX 5090 就能 QLoRA 微调 70B，一天搞定，成本不到 $50。这场革命的背后，是 LoRA、QLoRA、DoRA 等一系列 PEFT 技术的成熟。

📑 目录
从全量到高效：PEFT的进化

LoRA核心原理：低秩分解的数学之美

QLoRA：量化+LoRA的双重降维打击

DoRA：权重分解学习

2026年LoRA变体全家桶

LoRA地雷阵：常见误区与解决方案

实战：用LoRA微调7B模型（单卡）

实战：用QLoRA微调70B模型（单卡）

实战：多LoRA融合与切换

LoRA的数学框架与选择指南

总结

一、从全量到高效：PEFT的进化
1.1 为什么需要 PEFT？
全量微调的问题：

一卡装不下 → 分布式昂贵 → 成本高、迭代慢
​
7B 模型全量微调: 8×A100 (80GB) = ~$30,000/月
70B 模型全量微调: 32×A100 (80GB) = ~$120,000/月
PEFT 的核心思路：冻结 99%+ 的原始权重，只训练少量新增参数。

年份里程碑可训练参数对比全量
2021Adapter3-5%~20x 节省
2021Prefix Tuning0.1%~100x
2021LoRA (原始)0.1-1%100-1000x
2023QLoRA0.1-1%1000x+ (量化)
2024DoRA0.1-1%100-1000x (更好效果)
2025LoRA-XS, LoRA+, rsLoRA0.01-1%优化收敛
1.2 2026年各方法显存对比
方法7B模型14B模型70B模型单卡可行？
全量微调 FP16112GB210GB1TB+❌
LoRA (r=16)28GB52GB160GB⚠️ 70B需多卡
QLoRA (4-bit + LoRA)7GB14GB48GB✅ 全部单卡
DoRA (r=16)28GB52GB160GB⚠️ 同LoRA
QDoRA (4-bit)7GB14GB48GB✅
GaLore12GB22GB70GB✅
关键数据：2026 年，一张 RTX 5090（48GB）× QLoRA 就可以微调 70B 模型 [1]。这在两年前需要 16 张 A100。

二、LoRA核心原理：低秩分解的数学之美
2.1 核心洞察
LoRA（Low-Rank Adaptation）基于一个重要的发现 [2]：

预训练模型的本征维度（Intrinsic Dimension）很低。也就是说，模型虽然有几亿个参数，但真正有效的变化只需要一个低维子空间。

全量微调： W’ = W + ΔW ← ΔW 是一个满秩矩阵，参数量 ≈ d×k
LoRA： W’ = W + B·A ← B·A 是低秩分解，参数量 = d×r + r×k
​
其中：
W: d×k 原始权重（冻结）
B: d×r 低秩矩阵（可训练）
A: r×k 低秩矩阵（可训练）
r: 秩（通常 r=8~64, r << min(d,k)）
2.2 参数量节省

假设 Transformer 的 hidden_dim = 4096 (7B模型)：
​
全量微调 QKV 投影：W_q = 4096×4096 → 16.8M 参数 ← 全量更新
LoRA (r=16)：B=4096×16, A=16×4096 → 131K 参数 ← 仅 0.78%
​
总参数量对比（7B模型）：
全量微调： 6.7B 参数 ← 全部更新
LoRA: 6.7B (冻结) + 42M (可训练) = 0.15% 可训练
QLoRA: 6.7B (4-bit量化冻结) + 42M (可训练) = 0.15% 可训练，显存减半！
2.3 数学推导

“”“LoRA 的前向传播与梯度”“”
import torch
import torch.nn as nn
import math
​
class LoRALayer(nn.Module):
“”"
LoRA 低秩适配层
W’ = W + B·A

前向: y = x·W^T + (x·A^T)·B^T
"""
def __init__(self, in_features: int, out_features: int, rank: int = 8, alpha: int = 16):
super().__init__()

# 原始权重（冻结）
self.register_buffer('weight', torch.randn(out_features, in_features))

# LoRA 低秩矩阵（可训练）
self.lora_A = nn.Parameter(torch.randn(rank, in_features) * 0.01)
self.lora_B = nn.Parameter(torch.zeros(out_features, rank))

self.scaling = alpha / rank # 缩放因子
self.rank = rank

def forward(self, x: torch.Tensor) -> torch.Tensor:
"""
x: (batch, seq_len, in_features)
返回: (batch, seq_len, out_features)
"""
# 原始路径（冻结）
base_out = nn.functional.linear(x, self.weight)

# LoRA 路径（可训练 + 缩放）
# y = x·W^T + (x·A^T)·B^T · α/r
lora_out = (x @ self.lora_A.T) @ self.lora_B.T * self.scaling

return base_out + lora_out

​
class LoRALinear(nn.Module):
“”“替换 nn.Linear 的 LoRA 版本”“”
def init(self, original_linear: nn.Linear, rank: int = 8, alpha: int = 16):
super().init()

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

self.in_features = original_linear.in_features
self.out_features = original_linear.out_features

# LoRA A/B
self.lora_A = nn.Parameter(
torch.randn(rank, self.in_features) * 0.01
)
self.lora_B = nn.Parameter(
torch.zeros(self.out_features, rank)
)

self.scaling = alpha / rank

def forward(self, x: torch.Tensor) -> torch.Tensor:
result = nn.functional.linear(x, self.weight, self.bias)
result += (x @ self.lora_A.T) @ self.lora_B.T * self.scaling
return result

2.4 LoRA 的梯度行为
LoRA 的梯度有一个有趣的特点：

Loss 对 lora_B 的梯度: ∂L/∂B = (∂L/∂y) · (x·A^T)T
Loss 对 lora_A 的梯度: ∂L/∂A = B^T · (∂L/∂y) · x
​
关键：

• lora_A 接收从 lora_B 传回的梯度（受 B 影响）
• lora_B 直接从输出误差学习
• B 的初始化=0 → 初始时 LoRA 路径为 0 → 不影响原始输出
  ​
  为什么 B 初始化为 0？
  答：确保一开始 LoRA 不影响模型输出，训练过程是"平滑介入"的。
  如果 A、B 都随机初始化，第一轮训练就会偏离原始模型太远，loss 会飙升。
  2.5 秩 r 的选择

r 的选择对 LoRA 效果的影响：
​
r → 表达能力 ↑ 可训练参数 ↑ 过拟合风险 ↑
r → 表达能力 ↓ 可训练参数 ↓ 欠拟合风险 ↑
​
经验法则：
Q/K/V 层: r=8~16 (注意力头可以大一点)
O 投影: r=8 (IO 少一点)
FFN 层: r=16~32 (FFN 需要更多容量)

2026 最佳实践 [3]：
通用 SFT: r=16
领域适配: r=32~64
多任务: r=8（防止任务间干扰）
💡 面试加分点：秩 r 不等于"表达能力"。r=8 时 ΔW = B·A 的秩最多为 8，但 B·A 的"有效维度"比满秩矩阵小。这其实是 LoRA 的正则化效果——限制模型的变化空间，反而在数据量小时泛化更好。

三、QLoRA：量化+LoRA的双重降维打击
3.1 QLoRA 的架构
QLoRA = 4-bit NormalFloat (NF4) 量化 + LoRA + 双重量化 + 分页优化器 [4]

QLoRA 的组成（以微调 70B 为例）：
​

“”“NF4 量化：NormalFloat 的实现”“”
import torch
import numpy as np
​
class NF4Quantizer:
“”"
NormalFloat4 量化
针对 0-1 正态分布的统计最优量化
“”"

# 预计算的 NF4 量化级别（正态分布的分位数）
# 将 N(0,1) 的 CDF 等分为 16 个区间
NF4_LEVELS = torch.tensor([
-1.0, -0.6961928009986877, -0.5250730514526367,
-0.39491748809814453, -0.28444138169288635,
-0.18477343022823334, -0.09105003625154495,
0.0, 0.07958029955625534, 0.16093020141124725,
0.24621161818504333, 0.33791524171829224,
0.44067683815956116, 0.5626170039176941,
0.7229568362236023, 1.0
])

@staticmethod
def quantize(tensor: torch.Tensor) -> torch.Tensor:
"""
将 FP32/FP16 张量量化为 NF4
返回: int8 张量（每个元素存 2 个 NF4 值）
"""
# 1. 缩放到 [-1, 1]
absmax = tensor.abs().max()
scaled = tensor / absmax # 现在在 [-1, 1]

# 2. 找到最接近的 NF4 级别
# 展平 + 二分查找
flat = scaled.view(-1)
indices = torch.bucketize(flat, NF4Quantizer.NF4_LEVELS) – 1
indices = indices.clamp(0, 15).to(torch.uint8)

# 3. 打包两个 4-bit 到一个 byte
packed = indices[::2] | (indices[1::2] << 4)

return packed, absmax # 返回量化值和缩放因子

@staticmethod
def dequantize(packed: torch.Tensor, absmax: float, shape: tuple) -> torch.Tensor:
"""反量化"""
# 解包
low = packed & 0x0F
high = (packed >> 4) & 0x0F

indices = torch.stack([low, high], dim=-1).flatten()
indices = indices[:np.prod(shape)]

# 映射到实际的 NF4 级别
values = NF4Quantizer.NF4_LEVELS[indices.long()]

# 缩放回原始范围
return values.reshape(shape) * absmax

​
​

===== 使用 BitsAndBytes 加载 4-bit 模型 =====

from transformers import BitsAndBytesConfig
​
def load_4bit_model(model_name: str):
“”“加载 4-bit 量化模型”“”

quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.bfloat16, # 计算用 BF16
bnb_4bit_use_double_quant=True, # 双重量化
bnb_4bit_quant_type="nf4", # NF4 类型
)

model = AutoModelForCausalLM.from_pretrained(
model_name,
quantization_config=quantization_config,
device_map="auto", # 自动分配
trust_remote_code=True,
)

return model

3.3 QLoRA 的显存魔法

QLoRA vs LoRA vs Full Fine-tune 的显存对比（70B 模型）:
​
Full Fine-tune LoRA (FP16) QLoRA (NF4)
参数: 140 GB 140 GB 35 GB
LoRA 适配器: – 84 MB 84 MB
优化器状态: 280 GB (Adam) 84 MB 84 MB
梯度: 140 GB 84 MB 84 MB
激活: ~20 GB ~20 GB ~12 GB
─────────────────────────────────────────────────────
总计: ~580 GB ~160 GB ~48 GB
↑
一张 RTX 5090 就够了！
3.4 分页优化器
QLoRA 的另一个工程创新——分页优化器（Paged Optimizer）：

“”“分页优化器核心逻辑”“”
class PagedAdamW(torch.optim.Optimizer):
“”"
分页 AdamW：优化器状态可以在 CPU/GPU 间换入换出
当 GPU 显存不足时，自动将优化器状态换出到 CPU
“”"

def __init__(self, params, lr=1e-4, **kwargs):
super().__init__(params, {"lr": lr, **kwargs})
self.page_size = 1024 * 1024 # 1M 参数一页
self.cpu_pages = {} # CPU 上的页
self.gpu_pages = {} # GPU 上的页

@torch.no_grad()
def step(self, closure=None):
"""优化步：自动管理 GPU 内存"""
for group in self.param_groups:
for p in group["params"]:
if p.grad is None:
continue

state = self.state[p]

# 如果 GPU 显存不足，换出到 CPU
if torch.cuda.memory_allocated() > 0.9 * torch.cuda.get_device_properties(0).total_memory:
self._evict_to_cpu(state)

# Adam update
self._adam_update(p, state, group)

return None

def _evict_to_cpu(self, state):
"""将优化器状态换出到 CPU"""
for key in ["exp_avg", "exp_avg_sq"]:
if key in state and state[key].is_cuda:
state[key] = state[key].cpu()

def _adam_update(self, p, state, group):
"""Adam 更新（标准实现）"""
# … 标准 AdamW 更新逻辑
pass

四、DoRA：权重分解学习
4.1 DoRA 的洞察
DoRA（Weight-Decomposed Low-Rank Adaptation）[5] 发现：

全量微调的权重更新可以分解为方向（Direction）和幅度（Magnitude）两个部分。LoRA 默认同时更新两者，但方向更新更重要。

全量微调的权重变化：ΔW = ||W_new|| · (W_new / ||W_new||) – ||W|| · (W / ||W||)
​
DoRA：将学习分解为两个独立任务

“”“DoRA 的核心实现”“”
import torch
import torch.nn as nn
import torch.nn.functional as F
​
class DoRALayer(nn.Module):
“”"
DoRA: Weight-Decomposed Low-Rank Adaptation

W' = m · (W + ΔW) / ||W + ΔW||

其中：
– m: 可学习的幅度向量（magnitude）
– ΔW: LoRA 学习的更新（direction）
– ||·||: 列归一化
"""

def __init__(self, in_features: int, out_features: int, rank: int = 8, alpha: int = 16):
super().__init__()

# 原始权重（冻结）
self.register_buffer('weight', torch.randn(out_features, in_features))

# 幅度向量 m（可训练）
self.m = nn.Parameter(torch.ones(out_features)) # 初始化为1

# LoRA 方向更新（可训练）
self.lora_A = nn.Parameter(torch.randn(rank, in_features) * 0.01)
self.lora_B = nn.Parameter(torch.zeros(out_features, rank))

self.scaling = alpha / rank

def forward(self, x: torch.Tensor) -> torch.Tensor:
"""
DoRA 前向传播：
1. 计算权重更新方向: W_updated = W + B·A·α/r
2. 列归一化: W_normed = W_updated / ||W_updated||
3. 乘幅度: W_doRA = m · W_normed
"""
# 原始权重
W = self.weight

# 1. 计算方向更新
delta_W = (self.lora_B @ self.lora_A) * self.scaling

# 2. 合并权重
W_combined = W + delta_W

# 3. 列归一化（每列分开归一化）
W_norm = torch.norm(W_combined, p=2, dim=1, keepdim=True)
W_normalized = W_combined / W_norm

# 4. 幅度缩放
W_doRA = self.m.unsqueeze(1) * W_normalized

# 5. 线性变换
return F.linear(x, W_doRA)

4.3 DoRA vs LoRA 效果对比
指标LoRA (r=8)DoRA (r=8)对比
Commonsense QA74.3%76.5%+2.2%
MMLU63.8%64.7%+0.9%
GSM8K30.4%32.5%+2.1%
参数量42M42M+7K仅多 7K
推理速度1×0.97x几乎无影响
DoRA 的改进不需要额外的推理成本——部署时可以将 m·W_normalized 合并到权重中，推理时与原生模型速度完全一致。

五、2026年LoRA变体全家桶
5.1 变体对比
方法年份核心创新适用场景优缺点
LoRA2021低秩分解 ΔW = BA通用 SFT基准方法
QLoRA2023NF4量化 + LoRA显存受限✅ 单卡70B, ❌ 精度略降
DoRA2024幅度/方向分离通用 SFT✅ 效果更好, ⚠️ 略慢
LoRA+2024不同LR(B大A小)加速收敛✅ 收敛快2x, 无需改架构
rsLoRA2024秩缩放大 r 场景✅ r=256也稳定
PiSSA2025SVD初始化知识注入✅ 新知识更好
LoRA-XS2025共享A矩阵多任务✅ 极省显存, ⚠️ 表达力
VeRA2024共享B/A+可学习d超小显存✅ 最省参数
Delta-LoRA2024参数差值更新联邦学习✅ 隐私友好
AdaLoRA2023自适应秩分配自动化✅ 自动调r
5.2 rsLoRA：解决大 r 时的不稳定性

“”“rsLoRA：Rank-Stabilized LoRA”“”
class RsLoRALayer(nn.Module):
“”"
rsLoRA: 用 r/√r 替代 r 的缩放
标准 LoRA: scaling = α/r
rsLoRA: scaling = α/√r

为什么？
当 r 增大时，B·A 的期望范数按 √r 增长
标准 LoRA 的 α/r 缩放太强 → 大 r 时学习率变成无效
rsLoRA 的 α/√r 与 r 无关 → 大 r 也稳定
"""
def __init__(self, in_features, out_features, rank=8, alpha=16):
super().__init__()
self.lora_A = nn.Parameter(torch.randn(rank, in_features) * 0.01)
self.lora_B = nn.Parameter(torch.zeros(out_features, rank))

# 关键区别：用 1/√r 替代 1/r
self.scaling = alpha / math.sqrt(rank) # rsLoRA!

def forward(self, x):
delta = (x @ self.lora_A.T) @ self.lora_B.T * self.scaling
return F.linear(x, self.weight) + delta

5.3 PiSSA：用 SVD 初始化 LoRA

“”“PiSSA：Principal Singular values and Singular vectors Adaptation”“”
class PiSSALayer(nn.Module):
“”"
PiSSA: 用原始权重的 SVD 分解来初始化 LoRA

标准 LoRA: A 随机初始化(0.01), B 初始化(0)
PiSSA: A = U[:r] · √S[:r], B = √S[:r] · V[:r]^T

效果：PiSSA 保留了原始权重中最重要的方向，收敛更快，效果更好
"""

@staticmethod
def from_linear(linear: nn.Linear, rank: int = 8):
"""用 SVD 从原始权重初始化 PiSSA"""
W = linear.weight.data.float()

# SVD 分解
U, S, Vh = torch.linalg.svd(W, full_matrices=False)

# 取前 r 个奇异值
U_r = U[:, :rank] # (out, r)
S_r = S[:rank] # (r,)
Vh_r = Vh[:rank, :] # (r, in)

layer = PiSSALayer(
linear.in_features,
linear.out_features,
rank=rank
)

# 初始化为 SVD 分解
layer.lora_B.data = U_r * torch.sqrt(S_r).unsqueeze(0)
layer.lora_A.data = torch.sqrt(S_r).unsqueeze(1) * Vh_r

return layer

六、LoRA地雷阵：常见误区与解决方案
6.1 误区一：r 越大越好

❌ 误区: 秩 r 越大，表达能力越强，效果越好
✅ 真相: r 过大反而容易过拟合（尤其数据量少时）
​
经验:
数据量 < 1K: r=4~8
数据量 1K~10K: r=8~16
数据量 > 10K: r=16~64
6.2 误区二：所有层都用一样的 r

def apply_lora_with_varied_rank(
model: nn.Module,
default_rank: int = 8,
attention_rank: int = 16, # 注意力层更多容量
ffn_rank: int = 32, # FFN 层学习更复杂的映射
output_rank: int = 4, # 输出层少一点
):
“”“按层类型分配不同的秩”“”

lora_config = {
"q_proj": attention_rank,
"k_proj": attention_rank,
"v_proj": attention_rank,
"o_proj": default_rank,
"gate_proj": ffn_rank,
"up_proj": ffn_rank,
"down_proj": output_rank,
}

config = LoraConfig(
r=default_rank, # 默认秩
target_modules=list(lora_config.keys()),
lora_alpha=16,
lora_dropout=0.05,
modules_to_save=None,
# 注意：transformers 不支持每层不同 r
# 需要手动构建 LoRA 层
)
return config

6.3 误区三：LoRA 不需要 dropout

“”“LoRA Dropout 实验”“”
def lora_dropout_experiment():
“”"
LoRA 是否需要 dropout 取决于数据量：

数据量 | 最优 dropout | 说明
< 500 | 0.1-0.3 | 防过拟合，重要！
500-5K | 0.05-0.1 | 适中
> 5K | 0.0-0.05 | 数据够多不需要

QLoRA 场景：推荐 dropout=0.05（默认）
"""
lora_config = LoraConfig(
r=16,
lora_alpha=32,
lora_dropout=0.05, # 不要设为 0！
target_modules=["q_proj", "v_proj"],
)

6.4 误区四：LoRA 只能微调 attention

❌ 误区: LoRA 只对 attention 的 QKV 层有效
✅ 真相: FFN 层（gate/up/down）同样重要，且需要更高秩
​
2026 最佳实践：
模型大小 | 推荐配置
7B | q+v+o+gate+up+down, r=16
14B | 同上, r=8
70B | 同上, r=8
七、实战：用LoRA微调7B模型（单卡）
7.1 完整脚本

“”“Qwen3-7B + LoRA 微调完整脚本（单卡 RTX 5090）”“”
import os
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
TrainingArguments,
BitsAndBytesConfig,
)
from peft import (
LoraConfig,
get_peft_model,
prepare_model_for_kbit_training,
TaskType,
)
from trl import SFTTrainer
import wandb
​

===== 0. 配置 =====

MODEL_NAME = “Qwen/Qwen3-7B”
DATA_PATH = “sft_data.jsonl”
OUTPUT_DIR = “qwen3-7b-lora”
​

===== 1. 加载模型（BF16，不量化） =====

model = AutoModelForCausalLM.from_pretrained(
MODEL_NAME,
torch_dtype=torch.bfloat16,
trust_remote_code=True,
attn_implementation=“flash_attention_2”,
device_map=“auto”,
)
​
tokenizer = AutoTokenizer.from_pretrained(
MODEL_NAME,
trust_remote_code=True,
padding_side=“right”,
)
tokenizer.pad_token = tokenizer.eos_token
​

===== 2. 配置 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=TaskType.CAUSAL_LM,
)
​

应用 LoRA

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

输出: trainable params: 33,554,432 || all params: 6,734,123,520 ||

trainable%: 0.4984

​

===== 3. 准备数据 =====

dataset = load_dataset(“json”, data_files=DATA_PATH, split=“train”)
​
def format_chat(example):
text = tokenizer.apply_chat_template(
example[“messages”],
tokenize=False,
add_generation_prompt=False,
)
return {“text”: text}
​
dataset = dataset.map(format_chat)
​

===== 4. 训练参数 =====

training_args = TrainingArguments(
output_dir=OUTPUT_DIR,
per_device_train_batch_size=4, # 7B LoRA 能吃下 batch=4
gradient_accumulation_steps=4, # 等效 batch = 16
num_train_epochs=3,
learning_rate=2e-4, # LoRA 的 LR 通常比全量大 2-4x
warmup_ratio=0.03,
lr_scheduler_type=“cosine”,
bf16=True,
logging_steps=10,
save_strategy=“epoch”,
save_total_limit=3,
optim=“adamw_torch_fused”,
max_grad_norm=0.3, # LoRA 的梯度裁剪更严格
report_to=[“wandb”],
remove_unused_columns=False,
dataloader_num_workers=4,
)
​

===== 5. SFT Trainer =====

trainer = SFTTrainer(
model=model,
args=training_args,
train_dataset=dataset,
tokenizer=tokenizer,
max_seq_length=4096,
dataset_text_field=“text”,
packing=False,
)
​

===== 6. 训练 =====

trainer.train()
​

===== 7. 保存 =====

只保存 LoRA 适配器（约 84MB）

trainer.save_model()
​

也可以合并到原模型（可选）

merged_model = model.merge_and_unload()
merged_model.save_pretrained(os.path.join(OUTPUT_DIR, “merged”))
tokenizer.save_pretrained(os.path.join(OUTPUT_DIR, “merged”))
7.2 训练监控要点

LoRA 训练的正常信号:

• 初始 loss: 与原始模型相近（因为 LoRA 初始化为0）
• loss 下降: 比全量微调慢，但更稳定
• 梯度范数: 维持在 0.01-0.1 量级
  ​
  异常信号:
• loss 不降: 检查 lr（LoRA 需要更大的 lr: 1e-4 ~ 5e-4）
• loss 飙升: 检查缩放因子 α/r 是否过大
• 过拟合: loss 降但 eval loss 升 → 增加 dropout 或减少 r
  7.3 超参数速查
  模型量化batch_sizelrr显存单卡
  Qwen3-7BBF1642e-41624GBRTX 5090
  LLaMA 4-8BBF1642e-41628GBRTX 5090
  Qwen3-14BBF1621e-4840GBRTX 5090
  Qwen3-32BNF421e-4824GBRTX 5090
  Qwen3-72BNF411e-4840GBRTX 5090
  LLaMA 4-109BNF415e-5848GBRTX 5090 ✅
  八、实战：用QLoRA微调70B模型（单卡）
  8.1 QLoRA 完整脚本

“”“Qwen3-72B + QLoRA 微调（单卡 RTX 5090 48GB）”“”
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
TrainingArguments,
BitsAndBytesConfig,
)
from peft import LoraConfig, prepare_model_for_kbit_training
from trl import SFTTrainer
​

===== 1. 4-bit 量化加载 =====

bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True,
bnb_4bit_quant_type=“nf4”,
)
​
model = AutoModelForCausalLM.from_pretrained(
“Qwen/Qwen3-72B”,
quantization_config=bnb_config,
device_map=“auto”,
trust_remote_code=True,
attn_implementation=“flash_attention_2”,
)
​

===== 2. QLoRA 专有准备 =====

为 k-bit 量化训练做准备

model = prepare_model_for_kbit_training(
model,
use_gradient_checkpointing=True,
gradient_checkpointing_kwargs={“use_reentrant”: True},
)
​

===== 3. LoRA 配置（QLoRA 建议用更低秩） =====

lora_config = LoraConfig(
r=8, # 70B 模型用更小的 r
lora_alpha=16,
target_modules=[
“q_proj”, “k_proj”, “v_proj”, “o_proj”,
], # 只 QKV+O 就够
lora_dropout=0.05,
bias=“none”,
task_type=TaskType.CAUSAL_LM,
)
​
model = get_peft_model(model, lora_config)
​

===== 4. 训练参数（QLoRA 特有） =====

training_args = TrainingArguments(
output_dir=“qwen3-72b-qlora”,
per_device_train_batch_size=1, # 70B 只能 batch=1
gradient_accumulation_steps=8, # 等效 batch=8
num_train_epochs=3,
learning_rate=2e-4,
warmup_ratio=0.03,
bf16=True,
logging_steps=5,
save_strategy=“steps”,
save_steps=100,
save_total_limit=2,

# QLoRA 推荐配置
optim="paged_adamw_8bit", # 分页优化器！避免 OOM
max_grad_norm=0.3,
gradient_checkpointing=True,

# 节省显存
ddp_find_unused_parameters=False,
dataloader_num_workers=2,
group_by_length=True, # 按长度分组，减少padding浪费
length_column_batching=True,

)
​

===== 5. 训练 =====

trainer = SFTTrainer(
model=model,
args=training_args,
train_dataset=dataset,
tokenizer=tokenizer,
max_seq_length=2048, # QLoRA 用较短上下文
dataset_text_field=“text”,
packing=True, # packing 提高效率
)
​
trainer.train()
​

===== 6. 保存 =====

保存 LoRA 适配器（~21MB）

model.save_pretrained(“qwen3-72b-qlora-adapter”)
tokenizer.save_pretrained(“qwen3-72b-qlora-adapter”)
8.2 推理时合并/分离

“”“QLoRA 适配器的加载与合并”“”
from peft import PeftModel
​

方式一：动态加载 LoRA（不修改原模型）

base_model = AutoModelForCausalLM.from_pretrained(
“Qwen/Qwen3-72B”,
quantization_config=bnb_config,
device_map=“auto”,
)
​
lora_model = PeftModel.from_pretrained(
base_model,
“qwen3-72b-qlora-adapter”,
)
​

推理

inputs = tokenizer(“你好”, return_tensors=“pt”).to(“cuda”)
outputs = lora_model.generate(**inputs, max_new_tokens=100)
​

方式二：合并到原模型（推理更快，不依赖 peft）

merged_model = lora_model.merge_and_unload()
​

方式三：同时加载多个 LoRA（多任务切换）

base_model = AutoModelForCausalLM.from_pretrained(…)
​
lora_coding = PeftModel.from_pretrained(base_model, “coding-lora”)
lora_chat = PeftModel.from_pretrained(base_model, “chat-lora”)
lora_medical = PeftModel.from_pretrained(base_model, “medical-lora”)
​

使用时切换

def switch_lora(task: str):
if task == “coding”:
lora_coding.model.set_adapter(“coding”)
elif task == “chat”:
lora_coding.model.set_adapter(“chat”)
# … 注意：set_adapter 需要在同一个 PeftModel 上
九、实战：多LoRA融合与切换
9.1 LoRA 的算术操作
LoRA 的一个独特优势是可以做算术运算：

“”“LoRA 的加、减、合并操作”“”
import torch
​
class LoRAArithmetic:
“”“LoRA 权重算术操作”“”

@staticmethod
def add(lora_a: dict, lora_b: dict, alpha: float = 0.5) -> dict:
"""LoRA 权重融合: C = α·A + (1-α)·B
可用于融合两个领域的知识
"""
merged = {}
for key in lora_a:
merged[key] = alpha * lora_a[key] + (1 – alpha) * lora_b[key]
return merged

@staticmethod
def subtract(lora_a: dict, lora_b: dict) -> dict:
"""LoRA 减法: C = A – B
可用于去除某个能力
"""
return {
key: lora_a[key] – lora_b[key]
for key in lora_a
}

@staticmethod
def task_arithmetic(
base_lora: dict,
task_specific_loras: List[Tuple[str, dict, float]],
) -> dict:
"""任务算术：base + Σ(w_i · Δlora_i)"""
merged = dict(base_lora)
for name, lora_weights, weight in task_specific_loras:
for key in merged:
merged[key] += weight * lora_weights[key]
print(f" + {name} × {weight}")
return merged

​
​

===== 多 LoRA 管理系统 =====

class LoRAManager:
“”“多 LoRA 适配器管理器”“”

def __init__(self, base_model, base_path: str = "loras"):
self.base_model = base_model
self.base_path = Path(base_path)
self.active_adapter = None

def list_adapters(self) -> List[str]:
"""列出所有可用 LoRA"""
return [
d.name for d in self.base_path.iterdir()
if d.is_dir() and (d / "adapter_config.json").exists()
]

def load_adapter(self, adapter_name: str):
"""加载特定 LoRA"""
adapter_path = self.base_path / adapter_name

self.base_model.load_adapter(
str(adapter_path),
adapter_name=adapter_name,
)
print(f" ✅ 已加载: {adapter_name}")

def switch_to(self, adapter_name: str):
"""切换 LoRA"""
from peft import set_peft_model_state_dict

self.base_model.set_adapter(adapter_name)
self.active_adapter = adapter_name
print(f" → 激活: {adapter_name}")

def merge_adapters(
self,
adapter_names: List[str],
weights: List[float],
output_name: str = "merged"
):
"""融合多个 LoRA"""
merged_state = {}

for adapter_name, weight in zip(adapter_names, weights):
adapter_path = self.base_path / adapter_name
state = torch.load(
adapter_path / "adapter_model.bin",
map_location="cpu"
)
for key, val in state.items():
if key not in merged_state:
merged_state[key] = val * weight
else:
merged_state[key] += val * weight

# 保存融合结果
output_path = self.base_path / output_name
output_path.mkdir(exist_ok=True)
torch.save(
merged_state,
output_path / "adapter_model.bin"
)
print(f" ✅ 融合完成: {adapter_names} × {weights}")

def generate(self, prompt: str, **kwargs):
"""用当前 LoRA 生成"""
messages = [{"role": "user", "content": prompt}]
text = tokenizer.apply_chat_template(
messages, tokenize=False, add_generation_prompt=True
)
inputs = tokenizer(text, return_tensors="pt").to(self.base_model.device)

outputs = self.base_model.generate(
**inputs,
max_new_tokens=512,
temperature=0.7,
do_sample=True,
**kwargs
)

return tokenizer.decode(
outputs[0][inputs.input_ids.shape[1]:],
skip_special_tokens=True
)

​
​

===== 使用示例 =====

“”"
manager = LoRAManager(base_model)
​

独立 LoRA

manager.load_adapter(“coding-lora”) # 代码能力
manager.load_adapter(“medical-lora”) # 医疗知识
manager.load_adapter(“chat-lora”) # 对话风格
​

切换

manager.switch_to(“coding-lora”)
print(manager.generate(“写一个快速排序”))
​

融合（60% 代码 + 40% 聊天 = 一个代码教学助手）

manager.merge_adapters(
[“coding-lora”, “chat-lora”],
[0.6, 0.4],
“coding-tutor”
)
​
manager.switch_to(“coding-tutor”)
“”"
9.2 LoRA 融合的实际效果
融合方案代码聊天数学适用场景
pure coding92%30%65%代码助手
pure chat40%85%35%聊天机器人
0.7 coding + 0.3 chat85%65%58%代码教学
0.5 coding + 0.5 math75%40%82%数学竞赛
0.4 coding + 0.3 chat + 0.3 math80%55%75%全能助手 ⭐
十、LoRA的数学框架与选择指南
10.1 LoRA 的信息论视角

LoRA 的信息瓶颈：
min I(Z; X_base) – β·I(Z; Y_target)
↑ ↑
不偏离原始 •适应新任务
​
LoRA 的秩 r 控制了信息瓶颈的宽度：
r 小 → I(Z; X_base) 小 → 保留原始能力
r 大 → I(Z; Y_target) 大 → 适应更好 → 但也更容易遗忘
​
最佳 r = √(I(Y_target) / I(X_base)) … 理论上
实际: r=8~16 是最佳平衡
10.2 PEFT 选择决策树

我的需求：
├── 显存充足 + GPU ≥4 卡 → 用 LoRA (BF16)
│ ├── 效果好，速度快
│ └── 70B 需要 4×H200
│
├── 显存受限 + 单卡 → 用 QLoRA (NF4)
│ ├── 单卡 RTX 5090 可微调 70B
│ └── 精度损失 ~1%
│
├── 追求最高质量 → 用 DoRA
│ ├── 比 LoRA 好 1-3%，几乎不增加参数
│ └── 推理时无额外开销
│
├── 多任务切换 → LoRA + Adapter 管理
│ ├── 每个适配器 ~20MB
│ └── 可热切换
│
└── 极致显存节省 → QLoRA + LoRA-XS
├── 7B 只需 4GB
└── 适合边缘设备
10.3 2026 LoRA 最佳实践速查

LoRA 2026 最佳配置

​
通用 SFT (7B-14B):
r: 16
alpha: 32
target_modules: [q, k, v, o, gate, up, down]
dropout: 0.05
lr: 2e-4
batch: 16
​
领域适配 (医疗/法律/金融):
r: 32-64
alpha: 64
target_modules: [all linear]
dropout: 0.1
lr: 1e-4
replay_ratio: 0.1 # 10% 通用数据
​
多任务 (10+ tasks):
r: 8
alpha: 16
target_modules: [q, v]
dropout: 0.0
lr: 3e-4
​
QLoRA 70B+:
r: 8
alpha: 16
target_modules: [q, v, o]
dropout: 0.05
lr: 2e-4
batch: 8 (grad_accum)
max_seq_length: 2048
总结
核心要点
LoRA 的本质：ΔW = B·A 的低秩分解，冻结 99.85% 参数，只训练 0.15%

QLoRA = NF4 + LoRA + Dual Quant + Paged Optimizer：一张 RTX 5090 微调 70B

DoRA = Direction + Magnitude 分离：比 LoRA 好 1-3%，几乎 0 额外参数

r 不是越大越好：r=16 是通用最优，数据多可用 r=32-64

LoRA 可算术操作：加减融合，构建混合能力的 LoRA

2026 最佳实践：通用 SFT → LoRA(r=16, 2e-4), 显存受限 → QLoRA, 质量优先 → DoRA

各方法的显存/质量权衡

质量
↑
| Full Fine-tune
| DoRA
| LoRA (FP16)
| QLoRA (NF4)
| LoRA-XS
|
±——————————-→ 显存效率
面试高频问题
Q: LoRA 为什么把 B 初始化为 0，A 初始化为随机？
A: 初始化 B=0 保证 LoRA 路径 ΔW=0，不影响原始模型输出，loss 从原始水平开始平滑下降。A 随机初始化保证梯度可以正常流动。如果 B 和 A 都随机，ΔW 一开始就有随机值，loss 会飙升。

Q: LoRA 的秩 r 如何选择？
A: 取决于任务和数据量。通用 SFT: r=16; 领域适配: r=32-64; 多任务: r=8; 数据量 <1K: r=4-8. r 太小学不到，r 太大容易过拟合。Q/K/V 层的 r 可以比 FFN 层小。

Q: QLoRA 相比 LoRA 的精度损失有多大？
A: NF4 量化 + LoRA 的组合在绝大多数任务上精度损失 < 1-2%。如果使用 Double Quantization + BF16 compute dtype，损失几乎不可察觉。但对于数学推理等精度敏感任务，建议用 LoRA (BF16) 而非 QLoRA。

Q: 同一个 base model 可以用多个 LoRA 适配器切换吗？
A: 可以！这是 LoRA 的独特优势。每个 LoRA 适配器只有 ~20-80MB，可以在推理时热切换。甚至可以将多个 LoRA 通过线性组合融合出新能力（LoRA arithmetic）。

下一篇预告：训练与微调篇第 5 篇——Prefix Tuning 与 Prompt Tuning。

参考资料

[1] Hu et al. LoRA: Low-Rank Adaptation of Large Language Models. ICLR 2022
[2] Aghajanyan et al. Intrinsic Dimensionality Explains the Effectiveness of Language Model Fine-Tuning. 2021
[3] Dettmers et al. QLoRA: Efficient Finetuning of Quantized Language Models. NeurIPS 2023
[4] Liu et al. DoRA: Weight-Decomposed Low-Rank Adaptation. ICML 2024
[5] Kalajdzievski. rsLoRA: A Rank-Stabilized LoRA Scaling. 2024
[6] Meng et al. PiSSA: Principal Singular Values and Singular Vectors Adaptation. 2025
[7] Biderman et al. LoRA+: Efficient Low-Rank Adaptation with Different Learning Rates. 2024