LoRA on 酒中仙

基于 peft 库的 LoRA 实战

Wed, 25 Mar 2026 22:40:25 -0800

基于 peft 库的 LoRA 实战

在前两个小节中，探讨了参数高效微调（PEFT）的理论背景和主流方法，特别是 LoRA 的核心原理。这些知识为我们提供了理论支撑，但要真正驾驭这些技术，还需要一个强大而易用的工具。本节将进入实战环节，学习使用当前社区常用的 PEFT 工具库——Hugging Face 的 peft ¹。 peft 库的设计理念与 Hugging Face 生态系统一脉相承，它希望将复杂的 PEFT 技术（如 LoRA, Prefix Tuning, Adapter 等）抽象成统一、简洁的接口，让开发者能够以最小的代码改动，将这些高效微调方法无缝地应用到 Hugging Face Hub 上的大模型上。如图 11-11，peft 库的官方文档将其内容划分为快速入门、方法指南、概念指南和参考手册，便于开发者上手。

图 11-11 Hugging Face PEFT 库官方文档首页

一、`peft` 库的设计理念

要理解 peft 库，首先要明白它并非要取代基础的模型库（例如 transformers），而是作为其插件或 增强模块 而存在。

我们可以类比游戏《黑神话：悟空》：

基础预训练模型：如同主角“天命人”（悟空），他本身已拥有强大的基础能力和标志性的金箍棒。但面对不同的 Boss（下游任务），只靠基础能力会很吃力。让他“重新修炼”以获得全新能力（即全量微调）显然不现实。
peft 库：则相当于悟空掌握的“七十二变”法术神通库。这个库里包含了各种强大的法术（如 LoRA）、变身能力（如 Prefix Tuning）和法宝（如 Prompt Tuning）。
PeftConfig：相当于一份为特定 Boss 战准备的“法术搭配方案”。这份方案详细规划了要启用哪一种核心神通（例如 peft_type='LORA'），以及该神通的具体参数（例如 LoRA 的 r、lora_alpha，可以理解为法术的威力和范围）。
get_peft_model 函数：扮演着“临阵变身”的角色。它接收基础的“悟空”（base_model）和选定的“法术搭配方案”（peft_config），然后依据方案，将对应的神通（例如 LoRA 的低秩矩阵）“加持”在悟空身上，从而打造出一个针对特定 Boss 特化的、能力更强的 PeftModel。

通过这种方式，无需改动庞大的基础模型本身（冻结其大部分权重），只需定义、训练和切换不同的轻量级插件（Adapter），就能让模型高效地适应各种下游任务。这不仅节省了大量的计算和存储资源，也使得模型的管理和部署变得更加灵活。

二、`peft` 库的核心组件

peft 库通过几个核心的类和函数，实现了对各种 PEFT 方法的统一封装，使其遵循一致的调用逻辑。接下来，简单介绍一下。

2.1 声明式配置 PeftConfig

PeftConfig 是所有 PEFT 方法配置的基类，它采用声明式的方式定义了微调的策略。其中最重要的两个通用参数是：

peft_type：一个枚举类型，用于 指定要使用的 PEFT 插件类型。例如，PeftType.LORA 明确表示使用 LoRA 方法。这是 peft 库能够自动检索和应用不同微调算法的关键。
task_type：同样是枚举类型，用于 指定模型的下游任务类型。例如，TaskType.CAUSAL_LM 用于自回归语言模型（如 GPT），TaskType.SEQ_2_SEQ_LM 用于序列到序列模型（如 T5）。这个参数能够帮助 peft 库为特定任务对模型的头部（Head）或其他结构进行正确的适配。

针对每一种具体的 PEFT 方法，peft 库都提供了一个继承自 PeftConfig 的子类，例如 LoraConfig、PromptTuningConfig 等。以 LoraConfig 为例，它包含了 LoRA 方法专属的超参数，这些参数直接源于 LoRA 论文中的定义：

r：LoRA 的秩（rank），决定了低秩矩阵 A 和 B 的中间维度 (d, r) 和 (r, k)。它是控制新增参数量和模型适应能力的核心超参数。
lora_alpha：LoRA 的缩放因子。在 LoRA 的计算中，低秩矩阵的输出 BAx 会乘以一个缩放系数 alpha/r。lora_alpha 就是这个公式中的 alpha，它用于调整低秩适应矩阵与原始权重矩阵合并时的尺度。
target_modules：一个字符串或正则表达式列表，用于 精确指定要将 LoRA 应用于基础模型中的哪些模块。如，["q_proj", "v_proj"] 表示仅在 Transformer 层的 query 和 value 投影矩阵上应用 LoRA。
lora_dropout：在 LoRA 层上应用的 Dropout 比例，用于防止过拟合。
bias：偏置参数的训练方式，可选值为 'none'（冻结所有 bias）、'all'（训练所有 bias）或 'lora_only'（仅训练 LoRA 模块自身的 bias）。

2.2 动态注入生成 PeftModel

get_peft_model 是 peft 库中的核心工厂函数。它接收一个原始的预训练模型和一个 PeftConfig 对象，然后执行以下操作：

解析 PeftConfig，确定要使用的 PEFT 方法和相关参数。
遍历基础模型的网络结构，根据 target_modules 找到需要注入 LoRA 模块的目标层。
将原始的目标层（如 nn.Linear）替换/封装为注入了 LoRA 的线性模块（如 LoraLinear 或其 k-bit 量化变体）。该模块内部保留冻结的原始权重，并引入可训练的低秩分支 A 和 B。
返回一个 PeftModel 实例。

返回的 peft_model 对象是一个高度封装的模型。它内部保留了对原始基础模型的引用，并通过动态修改其 forward 传递路径，实现了 LoRA 逻辑的注入。这个 peft_model 实例拥有与基础模型完全兼容的接口，可以直接用于 Trainer 或自定义的训练循环中。

peft_model 还提供了一个有用的调试方法是 print_trainable_parameters()，它可以计算并打印出模型中可训练参数的数量及其占总参数量的比例，能够直观地感受到 PEFT 在节约资源上的巨大优势。

三、LoRA 微调实战流程

结合 peft 库，可以形成一个标准的 LoRA 微调流程。下面以 EleutherAI/pythia-2.8b-deduped 模型为例，进行微调实战。

本节完整代码

3.1 加载依赖、基础模型与分词器

为了在消费级硬件上运行数十亿参数的大模型，需要采用量化技术。这里，我们使用 bitsandbytes 库，在加载模型时直接对其进行 8-bit 量化，并指定 dtype=torch.float16 以进一步优化显存。

根据 transformers 库的最新实践，现已不再推荐使用已被弃用的 load_in_8bit=True 参数，而是通过定义一个 BitsAndBytesConfig 对象，并将其传递给 quantization_config 参数来精确地控制量化行为。同时，通过设置 device_map="auto"，可以让 accelerate 库自动地、智能地将模型层分配到可用的硬件上（例如，将所有层都放到唯一的 GPU 上）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

model_id = "EleutherAI/pythia-2.8b-deduped"

# --- 使用 BitsAndBytesConfig 定义 8-bit 量化配置 ---
bnb_config = BitsAndBytesConfig(
 load_in_8bit=True,
)

# 加载模型，并将量化配置传给 `quantization_config` 参数
model = AutoModelForCausalLM.from_pretrained(
 model_id,
 quantization_config=bnb_config,
 dtype=torch.float16,
 device_map="auto",
)

执行完这段代码后，如果打印 model 对象，你会看到模型架构的详细信息。其中，类似 (query_key_value): Linear8bitLt(in_features=2560, out_features=7680, bias=True) 的层表明，原始的 nn.Linear 已经被成功替换为 8-bit 量化版本 Linear8bitLt，说明模型加载和量化已成功完成。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


GPTNeoXForCausalLM(
 (gpt_neox): GPTNeoXModel(
 (embed_in): Embedding(50304, 2560)
 (emb_dropout): Dropout(p=0.0, inplace=False)
 (layers): ModuleList(
 (0-31): 32 x GPTNeoXLayer(
 (input_layernorm): LayerNorm((2560,), eps=1e-05, elementwise_affine=True)
 (post_attention_layernorm): LayerNorm((2560,), eps=1e-05, elementwise_affine=True)
 (post_attention_dropout): Dropout(p=0.0, inplace=False)
 (post_mlp_dropout): Dropout(p=0.0, inplace=False)
 (attention): GPTNeoXAttention(
 (query_key_value): Linear8bitLt(in_features=2560, out_features=7680, bias=True)
 (dense): Linear8bitLt(in_features=2560, out_features=2560, bias=True)
 )
 (mlp): GPTNeoXMLP(
 (dense_h_to_4h): Linear8bitLt(in_features=2560, out_features=10240, bias=True)
 (dense_4h_to_h): Linear8bitLt(in_features=10240, out_features=2560, bias=True)
 (act): GELUActivation()
 )
 )
 )
 (final_layer_norm): LayerNorm((2560,), eps=1e-05, elementwise_affine=True)
 (rotary_emb): GPTNeoXRotaryEmbedding()
 )
 (embed_out): Linear(in_features=2560, out_features=50304, bias=False)
)

模型加载完成后，加载其对应的分词器。对于 Pythia 这类模型，其分词器默认可能没有 pad_token。在进行批量训练时，数据整理器（Data Collator）要用 pad_token 将序列填充至相同长度，我们需要手动将其设置为 eos_token。

1
2
3


tokenizer = AutoTokenizer.from_pretrained(model_id)
# Pythia模型的tokenizer默认没有pad_token，我们将其设置为eos_token
tokenizer.pad_token = tokenizer.eos_token

3.2 模型预处理

在使用 peft 对 8-bit 量化模型进行微调之前，需要进行一些必要的预处理。peft 库提供了一个非常方便的函数 prepare_model_for_kbit_training 来完成这项工作。

在 PEFT 0.10.0 及更高版本中，原来的 prepare_model_for_int8_training 已被 prepare_model_for_kbit_training 替代，新函数同时支持 4-bit 和 8-bit 量化。

这个函数主要执行几个关键操作：

（1）类型转换：将模型中一些需要以更高精度（如 FP32）计算的层（例如 LayerNorm）进行类型转换，以保证训练的数值稳定性。

（2）启用梯度检查点：调用 model.gradient_checkpointing_enable()，这是一种用计算时间换取显存的技术。它在反向传播时会重新计算中间层的激活值，而不是将它们全部存储在显存中，从而显著降低了训练过程中的显存峰值。

（3）输出嵌入层预处理：对模型的输出嵌入层进行一些必要的处理，以使其与 LoRA 兼容。

（4）输入梯度处理：为需要的输入启用梯度，保证在冻结大部分权重且使用 k-bit 训练时的反向传播兼容性。

1
2
3
4


from peft import prepare_model_for_kbit_training

# 对量化后的模型进行预处理
model = prepare_model_for_kbit_training(model)

3.3 定义 LoRA 配置并创建 `PeftModel`

这是整个 PEFT 流程中最核心的一步。我们将应用刚才介绍的核心组件，实例化一个 LoraConfig 对象来声明 LoRA 微调的具体策略，然后使用 get_peft_model 函数将其应用到预处理过的基础模型上。

在 LoraConfig 中，会详细设置 LoRA 的各个超参数，这些参数的选择直接关系到微调的效果和效率，与在上节 LoRA 方法详解 中讨论的理论紧密相关：

r：LoRA 的秩。这是最关键的超参数之一。r 越大，意味着低秩矩阵的表达能力越强，可训练的参数也越多。但正如前文的实验所示，r 并非越大越好，过大的 r 可能会增加噪声，且会线性增加可训练参数量。通常建议从 8 或 16 开始尝试。
lora_alpha：LoRA 的缩放因子。在前文提到过，最终的权重更新量会以 alpha/r 的比例进行缩放。这意味着，lora_alpha 的值可以理解为对学习到的低秩矩阵的“增强系数”。一个常见的做法是将其设置为 r 的两倍。
target_modules：指定要将 LoRA 应用于模型中的哪些模块。这是一个非常关键的参数，因为不同模型的模块命名方式不同。

如何确定 target_modules？ 可以先打印出基础模型 model 的结构，并以其显示的层命名为准。对于大多数 Transformer 模型，注意力机制中的“查询（Query）”、“键（Key）”和“值（Value）”层（如 q_proj, k_proj, v_proj）是首选。而对于 Pythia 或 GPT-NeoX 系列模型，其注意力权重常被合并在一个 query_key_value 层中，前馈网络（FFN）中的线性层则常见 dense、dense_h_to_4h 和 dense_4h_to_h。将 LoRA 应用于这些层通常都能带来收益。
bias：偏置参数的训练方式。'none' 是最常用的设置，意味着不训练任何偏置参数，这与 LoRA 的原始思想保持一致，以最大化参数效率。在数据量充足的情况下，可以尝试 'lora_only'，仅训练 LoRA 模块自身的偏置。

LoraConfig 的其他参数（如 lora_dropout、task_type）也都提供了对微调过程的精细控制，具体代码如下。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


from peft import LoraConfig, get_peft_model

# 定义 LoRA 配置
config = LoraConfig(
 r=16,
 lora_alpha=32,
 target_modules=["query_key_value", "dense"],
 lora_dropout=0.05,
 bias="none",
 task_type="CAUSAL_LM",
)

# 应用配置，获得 PEFT 模型
peft_model = get_peft_model(model, config)
peft_model.print_trainable_parameters()

输出如下：

1

trainable params: 7,864,320 || all params: 2,783,073,280 || trainable%: 0.2826

通过前面提到的 print_trainable_parameters() 可以看到，可训练参数仅占总参数量的 0.28%。

3.4 数据处理

现在模型已经准备就绪，需要为它准备“教材”——也就是训练数据。本次微调的目标是让模型学会生成名人名言。这里将使用 Abirate/english_quotes 这个数据集，它包含了大量的英文名言。

数据处理流程如下：

加载数据集：使用 datasets 库从 Hugging Face Hub 下载数据集。
数据预处理：定义一个 tokenize 函数，该函数会接收一批数据，提取出所关心的 quote 字段，然后使用之前加载的分词器 tokenizer 对其进行编码，将其转换为模型可以理解的 input_ids。
应用处理：使用 dataset.map() 方法，将 tokenize 函数批量应用到整个数据集上。这是 datasets 库一个非常高效的特性。

首先，加载数据集并查看一条样本。

1
2
3
4
5
6
7


from datasets import load_dataset

# 加载数据集
quotes_dataset = load_dataset("Abirate/english_quotes")

# 查看数据集示例
quotes_dataset['train'][0]

输出显示了数据集的结构，包含 quote、author 和 tags 字段。

1
2
3
4
5
6
7
8


{'quote': '“Be yourself; everyone else is already taken.”',
 'author': 'Oscar Wilde',
 'tags': ['be-yourself',
 'gilbert-perreira',
 'honesty',
 'inspirational',
 'misattributed-oscar-wilde',
 'quote-investigator']}

接下来，定义分词函数并将其应用到整个数据集上。

1
2
3
4
5
6
7
8
9


# 定义分词函数
def tokenize_quotes(batch):
 # 只对 "quote" 列进行分词
 return tokenizer(batch["quote"], truncation=True)

# 对整个数据集进行分词处理
tokenized_quotes = quotes_dataset.map(tokenize_quotes, batched=True)

tokenized_quotes['train'][0]

处理后的数据集新增了模型所需的 input_ids 和 attention_mask 列。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


{'quote': '“Be yourself; everyone else is already taken.”',
 'author': 'Oscar Wilde',
 'tags': ['be-yourself',
 'gilbert-perreira',
 'honesty',
 'inspirational',
 'misattributed-oscar-wilde',
 'quote-investigator'],
 'input_ids': [1628, 4678, 4834, 28, 4130, 2010, 310, 2168, 2668, 1425],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

3.5 定义 Trainer 并开始训练

Trainer 是 transformers 库提供的一个高度抽象化的训练器，它封装了标准的 PyTorch 训练循环。只需通过 TrainingArguments 定义训练的“策略”，而无需手动编写繁琐的训练代码（如梯度更新、学习率调度、日志记录等）。

在 TrainingArguments 中，会设置一些关键的训练参数：

per_device_train_batch_size & gradient_accumulation_steps：这两个参数共同决定了有效批量大小（effective batch size）。per_device_train_batch_size 是指每个 GPU 单次前向传播处理的样本数，而 gradient_accumulation_steps 则指定了梯度累积的步数。有效批量大小 = per_device_train_batch_size * gradient_accumulation_steps * num_gpus。通过梯度累积，可以在显存有限的情况下，模拟出更大的批量大小，这通常有助于稳定训练过程。
warmup_steps: 学习率预热的步数。在训练初期，学习率会从一个很小的值线性增加到设定的 learning_rate，这能让模型在开始阶段更好地适应数据。
max_steps: 训练的总步数。为了快速演示，这里只训练 200 步。
learning_rate: 学习率，控制模型参数更新的幅度。
fp16: 启用 16-bit 混合精度训练。可以在不牺牲太多性能的情况下，进一步减少显存占用并加速训练。

最关键的是，将之前创建的 PeftModel 实例直接传递给 Trainer。Trainer 会足够智能，自动识别出只有 LoRA 相关的参数是可训练的，并在训练时冻结所有其他参数。

除了上述基础参数外，还有两个关于训练策略的要点值得注意：

max_steps vs num_train_epochs：TrainingArguments 允许通过设置 max_steps（总训练步数）或 num_train_epochs（总训练轮数）来控制训练的总长度。在快速原型验证或演示时，使用 max_steps 可以精确控制训练量，便于快速看到结果。在正式的项目中，使用 num_train_epochs 更为常见，它能确保模型完整地学习过所有训练数据指定的轮数。
验证集的缺失：在专业的训练流程中，通常会从数据集中划分出一部分作为验证集，并在 TrainingArguments 中通过 evaluation_strategy 参数设置评估时机（例如，每 N 步或每个 epoch 结束后），以便监控模型是否过拟合，并据此进行早停等操作。为了简化演示流程，本教程省略了这一环节。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


from transformers import Trainer, TrainingArguments, DataCollatorForLanguageModeling

# 推荐操作：关闭缓存可提高训练效率
peft_model.config.use_cache = False

# 定义训练参数
train_args = TrainingArguments(
 per_device_train_batch_size=4,
 gradient_accumulation_steps=4,
 warmup_steps=100,
 max_steps=200,
 learning_rate=2e-4,
 fp16=True, # 启用混合精度训练
 logging_steps=1,
 output_dir="outputs",
)

# 数据整理器，用于处理批量数据
quote_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)

# 实例化 Trainer
trainer = Trainer(
 model=peft_model,
 train_dataset=tokenized_quotes["train"],
 args=train_args,
 data_collator=quote_collator,
)

# 开始训练
trainer.train()

执行 trainer.train() 后，控制台会实时打印训练日志。训练完成后，train 方法会返回一个包含所有训练指标的 TrainOutput 对象，方便进行分析和记录。

3.6 模型保存与推理

训练完成后，可以将学到的知识——也就是轻量的 LoRA 适配器保存下来，以备后续使用。

对 PeftModel（即 peft_model）调用 save_pretrained() 时，peft 会只保存增量的、可训练的适配器权重，而不是整个庞大的基础模型。通常，保存下来的文件（adapter_model.safetensors 和 adapter_config.json）只有几十 MB。

合并权重

正如上节中所讨论的，LoRA 的一个核心优势是它不会在推理时引入额外的延迟。这是因为它训练出的旁路矩阵 $A$ 和 $B$ 可以被 合并（merge） 回原始的权重矩阵中。训练完成后，可以调用 merged_model = peft_model.merge_and_unload() 方法，它会返回一个标准的 transformers 模型，其权重已经包含了 LoRA 的更新。这个 merged_model 的结构与原始模型完全一致，所以可以像任何普通模型一样进行部署，而没有任何额外的计算开销。若基础模型以 8/4-bit 量化加载，合并后返回的标准模型通常会转为 FP16/FP32；若需继续以 k-bit 部署，可在合并后按需重新量化。

为了验证微调的效果，可以进行一次推理测试，观察模型在续写名言开头的表现。为了获得最佳的推理效果并避免警告，需要注意以下几点：

传递 attention_mask：显式传递 attention_mask，确保模型能够正确识别有效的 token。
启用采样：设置 do_sample=True 以启用温度采样和核采样参数。
启用 use_cache：推理前将 use_cache=True 可提升生成效率；训练阶段通常配合梯度检查点将其关闭。

生成参数说明：

max_length: 生成文本的最大长度（包括输入）。
do_sample: 是否使用采样策略。设置为 True 时，temperature、top_p、top_k 才会生效。
temperature: 控制生成的随机性。较低的值（如 0.6）会使生成更具确定性，而较高的值则会增加多样性。
top_p: 核采样的概率阈值。只考虑累积概率达到 top_p 的最小 token 集合。
top_k: 每步只从概率最高的 k 个 token 中采样。
repetition_penalty: 重复惩罚因子，大于 1.0 会降低重复内容的概率。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


# 将模型设置为评估模式
peft_model.eval()

# 设置 pad_token_id 到模型配置中
peft_model.config.pad_token_id = tokenizer.pad_token_id

prompt = "Be yourself; everyone"

# 对输入进行分词，并获取 attention_mask
inputs = tokenizer(prompt, return_tensors="pt")
input_ids = inputs["input_ids"].to(peft_model.device)
attention_mask = inputs["attention_mask"].to(peft_model.device)

# 生成文本
with torch.no_grad():
 # 使用 autocast 提高混合精度推理的效率
 with torch.amp.autocast('cuda'):
 outputs = peft_model.generate(
 input_ids=input_ids,
 attention_mask=attention_mask,
 max_length=50,
 do_sample=True,
 temperature=0.6,
 top_p=0.95,
 top_k=40,
 repetition_penalty=1.2,
 pad_token_id=tokenizer.pad_token_id
 )

# 解码并打印结果
decoded_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
decoded_output

输出如下：

1

'Be yourself; everyone else is taken.” - Oscar Wilde"I have found that people will forget what you said, people will forget what you did, but people will never forget how you made them feel” Maya Angelou“The worst thing we'

从输出可以看到，模型成功地补全了这句来自奥斯卡·王尔德的名言，并且还继续生成了另一句风格相似的名言。这表明，仅仅通过200步的微调，模型就已经从数据集中大致学习到了名言的风格和内容，证明了 PEFT 方法的高效性。

模型输出的非确定性

大语言模型输出的非确定性主要来源于解码阶段的采样策略。当 do_sample=True 时，模型会根据计算出的词汇表概率分布进行随机抽样，而不是像确定性的贪心搜索那样总是选择概率最高的词。temperature、top_p 等参数正是用来调节这种抽样过程的随机程度的。

所以，这些采样参数是引入输出多样性的主要和意图性 的来源。除此之外，底层的CUDA算子、浮点数计算精度等因素也可能导致即使在固定随机种子的情况下，两次运行结果仍存在微小差异，但这并非主要原因。在本地运行时得到与文档不完全相同的结果，属于正常现象。

参考文献

Hugging Face PEFT Documentation. (2024). ↩︎

低秩近似（LoRA）方法详解

Wed, 25 Mar 2026 22:38:25 -0800

低秩近似（LoRA）方法详解

在上一节中，我们探讨了以 Adapter 和各类 Prompt Tuning 为代表的 PEFT 技术。它们通过在模型中插入新的模块或在输入端添加可学习的提示，巧妙地实现了高效微调。这些方法的核心，都是在尽量不“打扰”原始模型权重的前提下，通过影响模型的激活值来适应新任务。

本节，我们将介绍一种另辟蹊径，也是当前社区应用最广泛的 PEFT 方法——LoRA（Low-Rank Adaptation of Large Language Models）。它不再“绕道而行”，而是直击模型的权重矩阵，并提出一个观点。那就是大模型的参数更新，或许并不需要那么“兴师动众”。

一、低秩近似的核心思想

全量微调之所以成本高昂，是因为它需要为模型中每一个权重矩阵 $W$（维度可能高达数万）计算并存储一个同样大小的更新矩阵 $ΔW$。为了解决这个问题，研究者们提出了像 Adapter Tuning 和 Prompt Tuning 这样的参数高效微调方法。但是，它们也存在一些未解决的痛点。Adapter 虽好，却会引入额外的推理延迟；Prompt Tuning 则会占用输入序列长度，且优化难度较高。

有没有一种方法，既能大幅减少参数，又不引入推理延迟，还能直接作用于模型权重呢？这就是 LoRA 试图回答的问题。它的提出，源于一个假设 ¹：

大语言模型是过参数化的（Over-parametrized），它们在针对特定任务进行微调时，权重更新矩阵 $ΔW$ 具有一个很低的“内在秩”（Intrinsic Rank）。

这意味着，尽管 $ΔW$ 的维度很高，但它所包含的“有效信息”实际上可以被一个远小于其规模的低秩矩阵来表示。对此，LoRA 的核心思想就是用两个更小的“低秩”矩阵 $A$ 和 $B$ 的乘积，来模拟（近似）这个庞大的更新矩阵 $ΔW$。

$$ \Delta W = B \cdot A $$

其中， $W_0 \in \mathbb{R}^{d \times k}$，低秩分解后的 $B \in \mathbb{R}^{d \times r}$， $A \in \mathbb{R}^{r \times k}$，而秩 $r \ll \min(d, k)$。

LoRA 的工作方式可以理解为在原始的预训练权重 $W_0$ 旁边，增加了一个并行的“旁路”结构，如图 11-7 计算分为两条路径：

主路：输入 $x$ 经过原始的、被冻结的预训练权重 $W_0$。
旁路：输入 $x$ 依次通过两个低秩矩阵 $A$ 和 $B$。矩阵 $A$ 先将输入维度从 $k$ “压缩”到一个很小的秩 $r$，然后再由矩阵 $B$ “解压”回输出维度 $d$。

图 11-7 LoRA 结构示意图

最终的输出 $h$ 是这两条路径结果的加和：

$$ h = W_0 \cdot x + \Delta W \cdot x = W_0 \cdot x + (B \cdot A) \cdot x $$

在训练时，只有旁路的矩阵 $A$ 和 $B$ 会被更新。通过这种方式，需要优化的参数量就从 $d \times k$ 下降到了 $d \times r + r \times k$。通常，秩 $r$ 会选择一个非常小的值（如 8, 16, 64），使得可训练参数量仅为全量微调的千分之一甚至万分之一。

初始化与缩放技巧

初始化：如图 11-7 所示，旁路矩阵有特殊的初始化方式。矩阵 A 通常使用高斯分布进行随机初始化（ $A = \mathcal{N}(0, \sigma^2)$ ），而矩阵 B 则初始化为全零（ $B=0$ ）。这样做可以确保在训练开始时，旁路输出为零，微调是从原始的预训练模型状态开始的，保证了训练初期的稳定性。

缩放：LoRA 的前向计算公式会包含一个缩放因子 $s$: $h = W_0 \cdot x + s \cdot (B \cdot A) \cdot x$。这个 $s$ 通常设为 $\alpha/r$，其中 $\alpha$ 是一个可调超参。这个缩放操作有助于在调整秩 $r$ 时，减少对学习率等其他超参数的重新调整需求，让训练过程更稳定。

二、LoRA 的优势与实践

相比于之前介绍的 PEFT 方法，LoRA 以其独特的结构带来了显著的优势，下面来具体看一下。

2.1 核心优势

LoRA 凭借其独特的并行结构和直接作用于权重的特性，展现出几大核心优势：

更高的参数与存储效率：对于每一个下游任务，不再需要存储一个完整的模型副本，而只需保存极小的矩阵 A 和 B。论文指出，这可以将模型 checkpoints 的体积缩小高达 10,000 倍（例如从 350GB 减小到 35MB）。在训练时，由于无需为冻结的参数计算梯度和存储优化器状态，可以节省高达 2/3 的 GPU 显存，并提升约 25% 的训练速度。
零额外推理延迟：这是 LoRA 相比 Adapter Tuning 最具吸引力的优点。Adapter 在模型中串行地引入了新的计算层，不可避免地会增加推理延迟。而 LoRA 的旁路结构在训练完成后，可以通过矩阵加法 $(W’ = W_0 + s \cdot B \cdot A)$ 直接“合并”回原始权重中。这样，模型的网络结构与原始模型完全一致，不会引入任何额外的计算步骤。

这种“合并”策略的代价是，如果你需要为 不同的任务（拥有不同的 LoRA 权重）同时提供服务，在单个 batch 中混合处理这些任务会变得不那么直接。
效果媲美全量微调，且不占用输入长度：与 Prompt-Tuning 等作用于输入激活值的方法不同，LoRA 直接修改权重矩阵，能更深入、更直接地影响模型的行为，效果也更接近于全量微调。同时，它不添加任何 virtual token，不会占用上下文长度，在处理长文本任务时更有优势。
良好的可组合性：LoRA 的设计是 正交的，它可以与 Prefix-Tuning 等其他 PEFT 方法结合使用，取长补短，进一步提升模型性能。

2.2 关键实践

LoRA 虽然强大，但也带来了新的超参数选择问题：应该对哪些权重矩阵应用 LoRA？秩 $r$ 又该如何选择？幸运的是，原始论文通过大量实验为我们提供了指导。

第一个问题是：应该对哪些权重矩阵应用 LoRA？

LoRA 的作者们为了简化问题和提高参数效率，将研究范围 限定在了自注意力模块（Self-Attention）的权重矩阵 上，并冻结了前馈网络等其他模块。在自注意力模块中，主要有四个权重矩阵：查询（Query）的 $W_q$、键（Key）的 $W_k$、值（Value）的 $W_v$ 和输出（Output）的 $W_o$。通过原文的实验数据（如表 11-1 所示）可以发现一个规律。在固定的可训练参数预算下，将 LoRA 应用于 多种类型的注意力权重（特别是 $W_q$ 和 $W_v$ 的组合）通常比把所有预算用于增大单一类型权重的秩（rank）效果更好。所以，原论文提出并验证了一个高效的策略：仅在注意力模块中应用 LoRA，并冻结模型的其余部分。

	# of Trainable Parameters = 18M
Weight Type	W_q	W_k	W_v	W_o	W_q, W_k	W_q, W_v	W_q, W_k, W_v, W_o
Rank r	8	8	8	8	4	4	2
WikiSQL (±0.5%)	70.4	70.0	73.0	73.2	71.4	73.7	73.7
MultiNLI (±0.1%)	91.0	90.8	91.0	91.3	91.3	91.3	91.7

表 11-1 不同注意力权重上的 LoRA 微调效果

第二个问题是：秩 r 的选择是不是越大越好？

通过表 11-2 的实验结果可以看到，一个非常小的秩 $r$（例如 4, 8 甚至 1）就已经足够强大。盲目增大 $r$ 不仅会增加参数量，有时甚至会导致性能下降。例如，对于 $W_q$ 和 $W_v$ 的组合，即使秩 $r$ 仅为 1 或 2，模型在各项任务上的表现也已具竞争力，甚至超过了 $r=64$ 的情况。这说明权重更新确实是低秩的。

	Weight Type	r=1	r=2	r=4	r=8	r=64
WikiSQL(±0.5%)	W_q	68.8	69.6	70.5	70.4	70.0
	W_q, W_v	73.4	73.3	73.7	73.8	73.5
	W_q, W_k, W_v, W_o	74.1	73.7	74.0	74.0	73.9
MultiNLI (±0.1%)	W_q	90.7	90.9	91.1	90.7	90.7
	W_q, W_v	91.3	91.4	91.3	91.6	91.4
	W_q, W_k, W_v, W_o	91.2	91.7	91.7	91.5	91.4

表 11-2 不同秩 r 对 LoRA 微调效果的影响

最后一个问题是，LoRA 究竟是如何生效的？ 论文通过分析发现，它学习到的更新矩阵 $\Delta W$ 并不是对原始权重 $W_0$ 中最重要特征的简单复制，恰恰相反，它学习到的是那些在预训练中学习到但未被充分强调、却对下游任务至关重要的“隐藏特征”，并对其进行大幅放大。它不是在重复模型已经很擅长的事情，而是在“查缺补漏”，精准地增强了模型在特定任务上所欠缺的能力。

三、AdaLoRA 自适应微调

尽管我们根据上述实验知道了应该优先微调注意力权重、并选择一个较小的秩 r，但 LoRA 这种固定的设置方式仍然引入了新的问题：

秩 $r$ 的选择： $r$ 应该设为多大？这是一个固定的超参数，无法在训练中自适应调整。
微调目标的选择：应该对哪些权重矩阵（ $W_q, W_k, W_v, W_o$ 还是前馈网络的矩阵）应用 LoRA？原始 LoRA 论文的实验主要集中在注意力模块，忽略了 FFN 模块，但后续研究发现 FFN 的微调同样重要。

实验表明，为所有矩阵和所有层级设置一个统一的、固定的秩 $r$，远非最优解。不同任务、不同模型层、不同权重矩阵，其“可塑性”和对任务的重要性是不同的，它们理应被区别对待。手动为每个矩阵和层级寻找最优秩的组合，其超参数空间巨大，几乎不可能完成。不过，如图 11-8 所示的实验，已经揭示了这种重要性的差异：

图左侧显示，在固定的参数预算下，微调前馈网络（FFN）模块的权重（$W_{f1}, W_{f2}$）带来的性能收益，显著高于微调注意力模块的权重（$W_q, W_k, W_v, W_o$）。
图右侧则表明，微调模型更高层级（如 10-12 层）的权重，也比微调底层（如 1-3 层）能带来更大的性能提升。

图 11-8 不同模块与层级的微调性能对比

为了解决固定秩分配的次优性与手动调参的困难，AdaLoRA (Adaptive LoRA) ² 提出了一种更智能的、自适应的 LoRA 方案——根据权重的重要性，动态地、有选择地为不同模块分配参数预算。AdaLoRA 不再使用固定的秩 $r$，而是让模型在训练过程中自己“决定”哪些部分更需要被微调，以及需要多大的“力度”（秩）去微调。这一过程主要包含三个关键创新。

3.1 基于 SVD 的参数化

AdaLoRA 的第一步，是对 LoRA 的低秩分解形式进行了改进。它不再是使用两个简单的矩阵 $B \cdot A$，而是引入了经典的奇异值分解 (SVD) 思想来参数化更新矩阵 $\Delta W$：

$$ \Delta W = P \Lambda Q $$

在机器学习和信号处理中，SVD 是一种强大的矩阵分解技术，能将任意矩阵分解为三个矩阵的乘积：一个左奇异向量矩阵 $P$、一个对角矩阵 $\Lambda$ 和一个右奇异向量矩阵 $Q$。其中，对角线上的奇异值代表了数据中最重要的主成分。AdaLoRA 正是借鉴了这一思想。

这种参数化方式有两大好处：

避免了高昂的计算成本：它只是在形式上模拟了 SVD，在训练时 $P, \Lambda, Q$ 都是可训练的参数，并不需要对 $\Delta W$ 进行真正的、计算开销极大的 SVD 分解。
结构化的重要性：这种分解将 $\Delta W$ 的更新信息解耦为三个部分： $P$ 和 $Q$ 决定了更新的“方向”，而 $\Lambda$ 中的奇异值 $\lambda_i$ 则决定了在对应方向上的更新“幅度”。这使得我们可以通过调整奇异值的大小来直接控制每个“更新分量”的重要性，也即调整矩阵的秩。

为确保 $P$ 和 $Q$ 在训练中保持正交性（这是奇异向量的性质），AdaLoRA 还在训练损失中加入了一个正交正则化项，以保证分解的稳定性和有效性。

3.2 重要性评分与动态预算分配

有了 SVD 这种分解结构，AdaLoRA 接下来要解决的问题就是如何衡量每个“更新分量”的重要性？

它将每个奇异值和其对应的左右奇异向量组合成一个“三元组” $\mathcal{G}{k,i} = {P{k,\ast i}, \lambda_{k,i}, Q_{k,i \ast}}$。在训练过程中，AdaLoRA 会为每个三元组计算一个重要性分数 $S_{k,i}$。这个分数是基于对三元组中每个参数 $w$ 的重要性 $s(w)$ 进行聚合得到的。

参数 $w$ 的重要性 $s(w)$ 由两部分相乘得到，分别是平滑后的参数敏感度 (Sensitivity) $\bar{I}(w)$ 和不确定性 (Uncertainty) $\bar{U}(w)$。

参数敏感度 I：它被定义为参数自身大小与其梯度的乘积的绝对值，即 $I(w) = |w \cdot \nabla_w \mathcal{L}|$。其直观含义是：如果将这个参数 $w$ 置零，模型损失会发生多大的变化。敏感度越高，说明该参数对当前任务的性能影响越大。
平滑与不确定性 U：由于训练是分批次（mini-batch）进行的，单个批次计算出的梯度具有随机性，导致敏感度 I 的值会剧烈波动。为了得到更稳定的评估，AdaLoRA 引入了指数移动平均 (EMA) 来对敏感度和不确定性进行平滑处理：
$$ \bar{I}^{(t)}(w) = \beta_1 \bar{I}^{(t-1)}(w) + (1-\beta_1)I^{(t)}(w) $$$$ \bar{U}^{(t)}(w) = \beta_2 \bar{U}^{(t-1)}(w) + (1-\beta_2)|I^{(t)}(w) - \bar{I}^{(t)}(w)| $$
其中， $\bar{I}^{(t)}$ 是平滑后的敏感度，而 $\bar{U}^{(t)}$ 则量化了瞬时敏感度与平滑后值的偏差，即“不确定性”。一个参数如果不仅敏感度高，而且这种敏感性在训练中持续稳定出现（即不确定性低），那么它就更重要。

最终，单个三元组的重要性分数 $S_{k,i}$ 由其内部所有参数的重要性聚合而成：

$$ S_{k,i} = s(\lambda_{k,i}) + \frac{1}{d_1}\sum_{j=1}^{d_1}s(P_{k,ji}) + \frac{1}{d_2}\sum_{j=1}^{d_2}s(Q_{k,ij}) $$

其中 $d_1 = d,\ d_2 = k$（对应 $\Delta W\in\mathbb{R}^{d\times k}$）。

在计算出所有三元组的重要性分数后，AdaLoRA 会进行排序，并根据一个预设的参数预算（总秩），裁剪掉那些得分最低的三元组（即将它们对应的奇异值 $\lambda_i$ 置为 0），从而实现了参数的动态分配。

3.3 全局预算调度器与目标函数

为了让训练过程更加稳定和高效，AdaLoRA 的整体目标函数 L 包含了原始的损失函数 C 和我们前面提到的正交正则项 R：

$$ \mathcal{L}(\mathcal{P},\mathcal{E},\mathcal{Q}) = \mathcal{C}(\mathcal{P},\mathcal{E},\mathcal{Q}) + \gamma \sum_{k=1}^n R(P_k,Q_k) $$

同时，它还引入了全局预算调度器 (Global Budget Scheduler) 的策略。这里的“预算” $b(t)$，指的就是在训练的第 $t$ 步，模型总共保留的奇异值的数量。它由一个分段函数精确控制：

$$ b^{(t)} = \begin{cases} b^{(0)} & 0 \le t < t_i \\ b^{(T)} + (b^{(0)} - b^{(T)})\left(1 - \frac{t - t_i}{T - t_i - t_f}\right)^3 & t_i \le t < T-t_f \\ b^{(T)} & \text{otherwise} \end{cases} $$

这个调度策略包含三个阶段：

热身阶段 ($0 \le t < t_i$)：从一个比目标预算 $b^{(T)}$ 略高的初始预算 $b^{(0)}$ 开始训练，让模型有更充分的机会去“探索”所有参数的潜在重要性。
裁剪阶段 ($t_i \le t < T-t_f$)：按照一个三次方的调度曲线，逐步地裁剪掉重要性分数较低的奇异值，将预算平滑地降低到最终的目标值。
微调阶段：在预算分配基本稳定后，固定预算为 $b^{(T)}$（即锁定了最重要的参数），继续对模型进行微调直至收敛。

这种“先探索、后收敛”的策略，让模型有更充分的机会去发现哪些权重真正重要，从而做出更优的预算分配决策。最终，AdaLoRA 实现了在训练过程中对秩的动态调整和在不同模块间的智能分配。

在图 11-9 中可以看到，模型自动为 FFN 模块（ $W_{f1}, W_{f2}$ ）以及模型的高层（层级 6-12）分配了更高的秩（颜色更深），这与图 11-8 的实验观察完全吻合，证明了其自适应机制的有效性。

图 11-9 AdaLoRA 最终秩分配结果示意图

与 Adapter、SVD 主题模型的联系

与 Adapter Tuning：两者都采用了“高维 → 低维 → 高维”的瓶颈结构。但 Adapter 是作用于 激活值 的串行模块（增加推理延迟），而 LoRA/AdaLoRA 是作用于权重的并行支路（可合并，无额外延迟）。AdaLoRA 在结构上更高效。

与 SVD 主题模型：在第二章第三节的中学习中，我们提到过 SVD 在主题模型中被用于分解“词-文档”矩阵，以发现最重要的“语义主题”（数据层面的低秩近似）。而 AdaLoRA 则创造性地将 SVD 的思想用于分解“权重更新矩阵”，以找到最关键的“参数变化方向”（模型层面的低秩近似）。

论文的实验结果也表明，AdaLoRA 的自适应机制是有效的。它能自动发现前馈网络和模型顶层的权重矩阵更为重要，并为其分配更高的秩。此外，消融实验证明，即使不使用动态预算分配，仅仅将参数化形式从 $B \cdot A$ 替换为 $P \Lambda Q$，就已经能带来性能提升，说明 SVD 结构本身的优越性。这种自适应的机制，让 AdaLoRA 在相同的参数预算下，往往能达到比原始 LoRA 更好的性能，进一步提升了参数高效微调的水平。

四、QLoRA 参数压缩

LoRA 和 AdaLoRA 分别从“低秩近似”和“自适应秩分配”两个角度优化了微调过程，但它们都还有一个共同的前提，原始的、被冻结的大模型权重仍然是以较高的精度（如 FP16 或 BF16）加载到显存中的。对于动辄几百上千亿参数的模型来说，这部分权重本身就是一笔巨大的显存开销。

华盛顿大学的研究者们提出了 QLoRA (Quantized LoRA)，一种更高阶的参数高效微调方法 ³。它通过一系列压缩技术，实现了很不错的效果。在保持与 16-bit 全量微调相当性能的同时，成功将一个 65B（650 亿）参数模型的微调任务，压缩到了一块 48GB 显存的 GPU 上。如图 11-10 所示，与冻结 16-bit 模型的标准 LoRA 相比，QLoRA 更进一步，将基座模型量化为 4-bit。训练时，梯度会穿过被冻结的 4-bit 模型，反向传播到 16-bit 的适配器中，并只更新适配器参数。此外，它还引入了 分页优化器，在显存不足时，可以将优化器状态临时卸载到 CPU 内存，从而有效管理内存峰值。

图 11-10 全量微调、LoRA 与 QLoRA 的机制对比

基于这些创新，QLoRA 训练出的 Guanaco 模型系列，在 Vicuna 基准测试中甚至达到了 ChatGPT 99.3% 的性能水平，而这仅仅需要单张 GPU 训练 24 小时。QLoRA 的成功，主要归功于三方面的创新：4-bit NormalFloat (NF4)、双量化 (Double Quantization) 和分页优化器 (Paged Optimizers)。

4.1 4-bit NormalFloat 数据类型

量化是模型压缩领域的常用技术，通过用更少的信息位数（bit）来表示数值，从而减小模型体积和显存占用。然而，传统的量化方法（如均匀量化）在面对神经网络权重时会遇到一个难题：权重值的分布通常是零中心的正态分布，其中大部分值集中在 0 附近，而少量“离群值”的绝对值又非常大。均匀的量化策略无法很好地适应这种非均匀分布，导致较大的精度损失。

以一个典型的 8-bit 均匀量化为例，其量化过程由以下公式定义：

$$ \mathbf{X}^{\text{Int8}} = \text{round}\left(\frac{127}{\text{absmax}(\mathbf{X}^{\text{FP32}})} \mathbf{X}^{\text{FP32}}\right) = \text{round}(c^{\text{FP32}} \cdot \mathbf{X}^{\text{FP32}}) $$

这个过程依赖于 absmax 缩放，即找到张量中的绝对值最大值来计算缩放系数，也就是 量化常数 $c^{\text{FP32}}$。这种方法对离群值非常敏感，也是它的主要局限性。反量化则是其逆过程：

$$ \text{dequant}(c^{\text{FP32}}, \mathbf{X}^{\text{Int8}}) = \frac{\mathbf{X}^{\text{Int8}}}{c^{\text{FP32}}} \approx \mathbf{X}^{\text{FP32}} $$

理解这个基础过程，特别是“量化常数”的概念，对于我们后续理解 QLoRA 的双量化会有所帮助。

那么，为了解决传统量化方法的问题，QLoRA 提出了一种专门为正态分布权重设计的 4-bit 数据类型——NormalFloat (NF4)。它被证明是一种 信息论上最优 的数据类型，其设计哲学基于“分位数量化（Quantile Quantization）”。

分位数量化旨在让每个量化“桶”中，都包含相同数量的来自目标分布的值。这意味着，在数据密集的区域（如正态分布的中心），量化点会更密集；在数据稀疏的区域（如分布的两尾），量化点会更稀疏。NF4 的具体构建步骤如下：

确定理论分布：首先，构建一个理论上的标准正态分布 $N(0, 1)$。
计算分位数：为这个标准正态分布精确计算出 $2^4 = 16$ 个值，这些值能将该分布的累积密度函数（CDF）划分为 16 个等概率的区间。这些计算出的分位数点，就构成了 NF4 数据类型能够表示的所有数值。
归一化与量化：在对实际的模型权重（通常以 block 为单位处理）进行量化时，首先通过“绝对值最大缩放”（absmax rescaling）进行归一化。具体来说，就是找到当前权重块中的绝对值最大值，并计算出其缩放因子，这个因子就是该块的 量化常数，它通常是一个 32-bit 浮点数。将块内所有权重都乘以这个缩放因子，就可以将它们的数值范围归一化到 $[-1, 1]$ 区间。最后，将每一个归一化后的权重值，映射到离它最近的 NF4 分位数点上。

更精确地说，一个 k-bit 的 NormalFloat 数据类型（NFk）包含 $2^k$ 个量化点（$q_i$），其数值是通过以下公式估算的：

$$ q_i = \frac{1}{2} \left( Q_X\left(\frac{i}{2^k+1}\right) + Q_X\left(\frac{i+1}{2^k+1}\right) \right) $$

这里的 $Q_X(\cdot)$ 是标准正态分布 $N(0, 1)$ 的分位数函数（Quantile Function）。该函数的作用是，给定一个概率值 $p$（在 0 到 1 之间），它能返回在该概率点上的具体数值。公式中的 $\frac{i}{2^k+1}$ 和 $\frac{i+1}{2^k+1}$ 就是将累积概率分布划分为 $2^k+1$ 个等份的点。整个公式的含义是，第 $i$ 个量化点 $q_i$ 的值，被定义为标准正态分布中第 $i$ 个和第 $i+1$ 个等概率区间隔断点的中点。

通过这种方式，NF4 用极其有限的 4 个 bit，实现了对正态分布数据的高精度近似，最大程度地保留了原始权重中的信息，远优于传统的 4-bit 整数或浮点数量化。

4.2 双量化与分页优化器

除了开创性的 NF4 数据类型，QLoRA 还引入了另外两项技术来进一步压缩显存。

双量化 (Double Quantization, DQ)：上述量化过程需要为每一组（block）权重存储一个对应的“量化常数”（通常是 32-bit 的浮点数）。对于一个巨大的模型，这些量化常数累加起来也会占用相当大的显存。例如，对于一个 block size 为 64 的权重块，这些常数平均会给每个参数带来 $32 / 64 = 0.5$ bit 的额外开销。双量化的思想是，对这些量化常数本身，再进行一次量化。通过用 8-bit 浮点数对第一级量化常数进行第二级量化，可以将这部分额外开销从每参数 0.5 bit 大幅降低到约 0.127 bit。
分页优化器 (Paged Optimizers)：在微调过程中，梯度和优化器状态（如 Adam 算法中的动量和方差）会产生瞬时的显存峰值，尤其是在处理长序列时，很容易导致显存溢出（Out-of-Memory, OOM）。分页优化器借鉴了操作系统中“虚拟内存”的思想，它利用 NVIDIA 统一内存（Unified Memory） 的特性，在 GPU 显存不足时，能自动地、按需地将一部分优化器状态“分页”暂存到 CPU 内存中，待需要时再加载回 GPU。这极大地提高了训练过程的稳定性，避免了因偶然的显存峰值而导致的训练失败。

4.3 QLoRA 的工作流程

结合上述技术，QLoRA 的完整微调流程可以概括为一种“存算分离”的巧妙设计：它使用一种低精度的数据类型进行存储，但在计算时又恢复为高精度。整个流程可以分为以下几个步骤：

加载与量化 (存)：加载 16-bit 的预训练模型，然后将其权重量化为 4-bit 的 NF4 格式，并应用 双量化 进一步压缩量化常数。此时，巨大的基座模型以极低的显存占用被冻结在 GPU 中。
前向传播 (算)：在模型中插入 LoRA 适配器，其权重保持为 16-bit 精度（BF16）。当进行前向计算时，需要使用的基座模型权重会被 动态地反量化回 16-bit 的 BF16 格式。计算完成后，这些临时的 16-bit 权重立即被丢弃，显存得以释放。
反向传播与更新：在反向传播过程中，梯度只会通过冻结的 4-bit 模型反向传播到 16-bit 的 LoRA 适配器中，并只更新适配器的权重。如果出现显存峰值，分页优化器 会介入，防止 OOM 发生。

这个“存算分离”的前向传播过程，可以用以下公式进行精确地数学描述：

$$ \mathbf{Y}^{\text{BF16}} = \mathbf{X}^{\text{BF16}}\text{doubleDequant}(c_1^{\text{FP32}}, c_2^{\text{k-bit}}, \mathbf{W}^{\text{NF4}}) + \mathbf{X}^{\text{BF16}}\mathbf{L}_1^{\text{BF16}}\mathbf{L}_2^{\text{BF16}} $$

第一部分（主路）：doubleDequant 函数对应了步骤 2 中的核心操作，它将 4-bit 的权重 $\mathbf{W}^{\text{NF4}}$ 动态恢复为 16-bit，再与 16-bit 的输入 $\mathbf{X}^{\text{BF16}}$ 相乘。
第二部分（旁路）： $\mathbf{X}^{\text{BF16}}\mathbf{L}_1^{\text{BF16}}\mathbf{L}_2^{\text{BF16}}$ 则是标准的 LoRA 模块，其计算全程保持 16-bit 精度。

LoRA on 酒中仙

基于 peft 库的 LoRA 实战

基于 peft 库的 LoRA 实战

一、peft 库的设计理念

二、peft 库的核心组件

2.1 声明式配置 PeftConfig

2.2 动态注入生成 PeftModel

三、LoRA 微调实战流程

3.1 加载依赖、基础模型与分词器

3.2 模型预处理

3.3 定义 LoRA 配置并创建 PeftModel

3.4 数据处理

3.5 定义 Trainer 并开始训练

3.6 模型保存与推理

参考文献

低秩近似（LoRA） 方法详解

低秩近似（LoRA） 方法详解

一、低秩近似的核心思想

二、LoRA 的优势与实践

2.1 核心优势

2.2 关键实践

三、AdaLoRA 自适应微调

3.1 基于 SVD 的参数化

3.2 重要性评分与动态预算分配

3.3 全局预算调度器与目标函数

四、QLoRA 参数压缩

4.1 4-bit NormalFloat 数据类型

4.2 双量化与分页优化器

4.3 QLoRA 的工作流程

参考文献

一、`peft` 库的设计理念

二、`peft` 库的核心组件

3.3 定义 LoRA 配置并创建 `PeftModel`

低秩近似（LoRA）方法详解

低秩近似（LoRA）方法详解