LLM 模型微调：PEFT 与 QLoRA 技术总结

为了避免这种情况，作者采用分位量化（Quantile Quantization），可以先将输入参数从小到大进行排序再等分为 16 份，每一份映射一个值。这种分位量化方法量化出的参数就能保证分布尽可能与原始分布相差不大。

但是上述分位量化会额外引入明显的计算开销，因为每次有参数输入进来都需要对齐进行排序并等分。作者发现预训练的参数基本上都服从均值为 0 的正态分布，可以将其缩放到 [-1, 1] 的范围中。同时可以将正态分 N(0,1) 划分为 2^k + 1 份，并缩放到 [-1, 1] 的范围中。这样就能直接将参数映射到对应的分位，不用每次都对参数进行排序。

为处理零点问题，做了以下改进：分别将负数和整数部分划分 2^(k-1)，参数 0 还是放在 0 原本的位置上。

3.2 实验结果分析

3.2.1 QLoRA vs. Standard Finetuning

在语言模型和零样本任务的评估中，4-bit NormalFloat 数据类型 (NF4) 表现出更好的性能，优于 4-bit 浮点数 (FP4)。研究采用了不同类型的量化 LLMs（OPT，BLOOM，Pythia，LLaMA）以及不同大小（125M 到 65B），比较 NF4、FP4 和 Int4 的性能，并发现 NF4 能够显著提升性能，双重量化可以减少内存占用同时不影响性能。

比较 RoBERTA 和 T5 模型在 GLUE 和 Super-NaturalInstructions 数据集上结果表明：无论是使用 16 位、8 位还是 4 位的适配器方法，都能够复制全 16 位微调的基准的性能。这说明，尽管量化过程中会存在性能损失，但通过适配器微调，完全可以恢复由于量化不准确而丢失这些性能。

测试 4 位 QLoRA 是否可以在 7B 到 65B 参数范围内匹配 16 位 LoRA。为此，在两个指令跟随数据集 Alpaca 和 FLAN v2 上对 LLaMA 7B 至 65B 进行了微调，并在 MMLU 基准测试上通过 5 点精度进行了评估。结果看到具有双重量化的 NF4 完全恢复了 16 位 LoRA 在 MMLU 性能。与 FP4 相比，QLoRA 性能落后于 16 位 BFloat16 LoRA 基准约 1 个百分点。这证实了 QLoRA 与 NF4 能够复制 16 位全微调和 16 位 LoRA 微调的性能，且 NF4 在量化精度方面优于 FP4。

3.2.2 Pushing the Chatbot State-of-the-art with QLoRA

使用 MMLU（Massively Multitask Language Understanding）基准来测量模型在一系列语言理解任务上的性能。报告 5-shot 测试准确率。还通过自动化和人工评估来测试生成语言能力。使用 nucleus 采样（p=0.9）和温度 0.7 进行所有测试。

基于 QLoRA 调优方法，作者对 OASST1 进行调优得到系列模型 Guanaco。基于自动化和人工评估，发现 QLoRA 优化的顶级模型 Guanaco 65B 是性能最好的开源聊天机器人模型，其性能与 ChatGPT 相比具有竞争力。与 GPT-4 相比，Guanaco 65B 和 33B 的预期获胜概率为 30%。在 Vicuna 基准相对于 ChatGPT 的结果显示，Guanaco 65B 是继 GPT-4 之后性能最好的型号，相对于 ChatGPT 实现了 99.3% 的性能。Guanaco 33B 比 Vicuna 13B 型号有更多的参数，但其权重仅使用 4 位精度，因此在 21 GB 和 26 GB 时的存储效率要高得多，比 Vicuna 13B 提高了三个百分点。此外，Guanaco 7B 以 5GB 的容量轻松安装在手机上，同时仍比 Alpaca 13B 高出近 20 个百分点。

4. QLoRA 细节解析与经验

4.1 LoRA 与 P-tuning 原理对比

• LoRA 原理：核心是在大型语言模型上对指定参数增加额外的低秩矩阵，也就是在原始 PLM 旁边增加一个旁路，做一个降维再升维的操作。并在模型训练过程中，固定 PLM 的参数，只训练降维矩阵 A 与升维矩阵 B。
• P-tuning 原理：核心是使用可微的 virtual token 替换了原来的 discrete tokens，且仅加入到输入层，并使用 prompt encoder（BiLSTM+MLP）对 virtual token 进行编码学习。

4.2 LoRA 与全参数训练的资源对比

1. 计算量上：LoRA 训练时，在主干模型的（部分）全连接层增加了 LoRA 旁路，前向和后向的计算量都在主干模型的基础上，增加了旁路部分的计算，因此相比全参数训练，略有增加。
2. 显存上：训练时，显存主要有①模型参数②梯度③中间激活值④优化器参数四个部分。模型参数/梯度/激活值相比全参数训练也略微增加；而优化器则不需要再存储原模型参数的部分，只需要存储 LoRA 旁路部分，这部分节省较多显存。
3. 效率提升原因：
   • 优化器部分的显存减少了，可以增大 batch。
   • 优化器参数减少了，分布式训练中多卡之间的通信量减少了。
   • 主干模型由于不用更新，可以进一步量化到 int8/int4 等。

4.3 常见问题解答

• FP4 量化有硬件要求吗？ FP4 量化方法仅与 GPU 兼容，目前尚无法在 CPU 上对模型进行 4 比特量化。在 GPU 中，此方法没有任何硬件要求，只要安装了 CUDA>=11.2，任何 GPU 都可以用于运行 4 比特量化。另请记住，计算不是以 4 比特完成的，仅仅是权重和激活被压缩为该格式，而计算仍在指定的或者原始数据类型上进行。
• 可以训练 4 比特 / 8 比特模型吗？ 对这些模型进行全模型 4 比特训练是不可能的。但是，可以利用参数高效微调 (PEFT) 来训练这些模型，即在基础模型之上训练新增部分如适配器。QLoRA 论文就是这么做的，Hugging Face 的 PEFT 库也正式支持了该方法。

4.4 QLoRA 量化调用流程

PreTrainedModel.from_pretrained 调用了 bitsandbytes.py 的 replace_with_bnb_linear，将 nn.Linear 层替换成量化层。 随后需要加载模型权重，调用函数 _load_pretrained_model -> _load_state_dict_into_meta_model -> set_module_quantized_tensor_to_device。 set_module_quantized_tensor_to_device 在 bitsandbytes.py 中，用于将权重转化为 int4 量化权重，并更新量化层信息。 转化过程在 Params4bit.cuda 中实现，它调用了 bnb.functional.quantize_4bit 函数，这个函数再调用 lib 的一个函数 lib.cquantize_blockwise_fp16_nf4，所以核心计算过程都在 cuda 上完成。 最终，每个参数的量化交给 dQuantizeNF4 这个函数完成，而这个函数就是依照输入数值的区间赋值的。

4.5 LoRA 与其他微调大模型对比优点

• Adapter Tuning：增加了模型层数，Adapter 引入了额外的推理延迟（只能串行）。
• Prefix-Tuning：难于训练，且预留给 Prompt 的序列挤占了下游任务的输入序列空间，影响模型性能。
• P-tuning v2：很容易导致旧知识遗忘，微调之后的模型，在之前的问题上表现明显变差。要占用 context length，变相的降低模型能力。

5. LoRA 微调大模型的实践经验总结

• LoRA 的一致性：尽管训练模型通常具有随机性，但是多次进行 LoRA 微调的实验结果在测试集上的效果十分稳定。
• QLoRA 的计算与内存权衡：QLoRA 是一种在微调时进一步降低内存使用的技术，通过将预训练的权重量化为 4 位精度，并使用分页优化器来处理内存峰值。QLoRA 可以节省 33% 的 GPU 内存，但增加了 39% 的训练时间。
  • 默认的 16 位浮点 LoRA：训练时间 1.85 小时，内存使用 21.33GB。
  • 这里的 4 位浮点 QLoRA：训练时间 2.79 小时，内存使用 14.18GB。
• 学习率调度器：文章讨论了余弦退火学习率调度器如何调整学习率，模仿余弦曲线逐渐减少学习率以优化收敛并避免过度拟合。实验中引入这种调度器显著改善了 SGD 性能，但对 Adam 和 AdamW 优化器影响较小。
• Adam 与 SGD 的比较：在 7B 参数的 Llama 2 模型训练中，使用 AdamW 和 LoRA 的默认设置（r=8）需要 14.18GB 的 GPU 内存，而使用 SGD 需要 14.15GB 的内存，节省非常有限。
• 多次训练 epoch：对于 50k 样本的 Alpaca 指令微调数据集，增加训练迭代次数后，模型性能出现下降，这表明多轮训练可能不适用于指令微调，因为可能会导致过拟合。
• 为更多层启用 LoRA：实验显示，如果为更多层启用 LoRA，虽然内存需求从 14.18GB 增加到 16.62GB，但模型性能有显著提升。
• 平衡 LoRA 超参数 R 和 Alpha：文章讨论了 LoRA 权重的缩放系数，发现虽然一般来说是较好的选择，但在某些情况下，不同的组合可能会产生更好的性能。
• 在单 GPU 上训练 7B 参数模型：LoRA 技术使得在单个 GPU 上微调 7B 参数的模型成为可能。使用 QLoRA 最优设置（r=256 和 alpha=512）时，训练一个 7B 参数模型在 A100 GPU 上需要大约 3 小时。

6. QLoRA 代码详解

6.1 BitsAndBytesConfig 参数详解

from transformers import BitsAndBytesConfig

# 使用 bnb 加载 nf4 量化的模型
nf4_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
    bnb_4bit_compute_dtype=torch.bfloat16
)
model_nf4 = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=nf4_config
)

• load_in_4bit=True：指定在加载模型时使用 4 位量化。这意味着模型的权重将被量化为 4 位，以减少内存使用和提高计算效率。
• bnb_4bit_quant_type="nf4"：指定量化的类型为 "nf4"。NF4 是一个特定的量化方法，指代某种压缩和优化的策略。
• bnb_4bit_use_double_quant=True：指定是否使用双重量化。双重量化是一种在量化过程中进一步优化的技术，可以提供更高的模型精度或更低的计算开销。
• bnb_4bit_compute_dtype=torch.bfloat16：指定计算的数据类型为 bfloat16。bfloat16 是一种半精度浮点格式，可以在保持计算精度的同时减少内存使用。

6.2 消费级 GPU 上微调大型语言模型

!pip install -q -U bitsandbytes
!pip install -q -U git+https://github.com/huggingface/transformers.git
!pip install -q -U git+https://github.com/huggingface/peft.git
!pip install -q -U git+https://github.com/huggingface/accelerate.git
!pip install -q -U datasets

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

model_id = "EleutherAI/gpt-neox-20b"
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)
tokenizer = AutoTokenizer.from_pretrained(model_id)

# 加载 model 使用 qlora
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map={"": 0}
)

from peft import prepare_model_for_kbit_training
model.gradient_checkpointing_enable()
model = prepare_model_for_kbit_training(model)

def print_trainable_parameters(model):
    """
    Prints the number of trainable parameters in the model.
    """
    trainable_params = 0
    all_param = 0
    for _, param in model.named_parameters():
        all_param += param.numel()
        if param.requires_grad:
            trainable_params += param.numel()
    print(
        f"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}"
    )

from peft import LoraConfig, get_peft_model
config = LoraConfig(
    r=8,
    lora_alpha=32,
    target_modules=["query_key_value"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, config)
print_trainable_parameters(model)

from datasets import load_dataset
data = load_dataset("Abirate/english_quotes")
data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
import transformers
# needed for gpt-neo-x tokenizer
tokenizer.pad_token = tokenizer.eos_token
trainer = transformers.Trainer(
    model=model,
    train_dataset=data["train"],
    args=transformers.TrainingArguments(
        per_device_train_batch_size=1,
        gradient_accumulation_steps=4,
        warmup_steps=2,
        max_steps=10,
        learning_rate=2e-4,
        fp16=True,
        logging_steps=1,
        output_dir="outputs",
        optim="paged_adamw_8bit"
    ),
    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
)
model.config.use_cache = False  # silence the warnings. Please re-enable for inference!
trainer.train()

6.3 基于 QLoRa+Transformer 的推理

text = "Ask not what your country"
device = "cuda:0"
inputs = tokenizer(text, return_tensors="pt").to(device)
outputs = model.generate(**inputs, max_new_tokens=20)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

6.4 权重合并推理

模型权重合并脚本：export_hf_checkpoint.py，将 lora 权重合并回原始权重。

import os
import torch
import transformers
from peft import PeftModel
from transformers import LlamaForCausalLM, LlamaTokenizer

BASE_MODEL = os.environ.get("BASE_MODEL", None)
LORA_MODEL = os.environ.get("LORA_MODEL", "tloen/alpaca-lora-7b")
HF_CHECKPOINT = os.environ.get("HF_CHECKPOINT", "./hf_ckpt")
assert (
    BASE_MODEL
), "Please specify a value for BASE_MODEL environment variable, e.g. `export BASE_MODEL=decapoda-research/llama-7b-hf`"

tokenizer = LlamaTokenizer.from_pretrained(BASE_MODEL)

base_model = LlamaForCausalLM.from_pretrained(
    BASE_MODEL,
    torch_dtype=torch.bfloat16,
    device_map={"": "cpu"},
)
first_weight = base_model.model.layers[0].self_attn.q_proj.weight
first_weight_old = first_weight.clone()

lora_model = PeftModel.from_pretrained(
    base_model,
    LORA_MODEL,
)
lora_weight = lora_model.base_model.model.model.layers[0].self_attn.q_proj.weight
assert torch.allclose(first_weight_old, first_weight)

# merge weights
for layer in lora_model.base_model.model.model.layers:
    layer.self_attn.q_proj.merge_weights = True
    layer.self_attn.v_proj.merge_weights = True
lora_model.train(False)

lora_model_sd = lora_model.state_dict()
deloreanized_sd = {
    k.replace("base_model.model.", ""): v
    for k, v in lora_model_sd.items()
    if "lora" not in k
}

LlamaForCausalLM.save_pretrained(
    base_model, HF_CHECKPOINT, state_dict=deloreanized_sd, max_shard_size="400MB"
)

推理脚本：inference.py

from transformers import AutoModelForCausalLM, LlamaTokenizer
import torch

model_id = "/data/nfs/guodong.li/pretrain/hf-llama-model/llama-7b"
merge_model_id = "/home/guodong.li/output/llama-7b-merge"

model = AutoModelForCausalLM.from_pretrained(
    merge_model_id,
    load_in_4bit=True,
    device_map="auto"
)
tokenizer = LlamaTokenizer.from_pretrained(model_id)
device = torch.device("cuda:0")

text = "Hello, my name is "
inputs = tokenizer(text, return_tensors="pt").to(device)
outputs = model.generate(**inputs, max_new_tokens=20, do_sample=True, top_k=30, top_p=0.85)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
print("\n------------------------------------------------\nInput: ")
line = input()
while line:
    inputs = tokenizer(line, return_tensors="pt").to(device)
    outputs = model.generate(**inputs, max_new_tokens=20, do_sample=True, top_k=30, top_p=0.85)
    print("Output: ", tokenizer.decode(outputs[0], skip_special_tokens=True))
    print("\n------------------------------------------------\nInput: ")
    line = input()

6.5 量化分位数如何计算

核心代码片段摘抄自 bitsandbytes 源码。

from scipy.stats import norm
import torch

def create_normal_map(offset=0.9677083, use_extra_value=True):
    if use_extra_value:
        # one more positive value, this is an asymmetric type
        v1 = norm.ppf(torch.linspace(offset, 0.5, 9)[:-1]).tolist() # 正数部分
        v2 = [0]*(256-15) ## we have 15 non-zero values in this data type
        v3 = (-norm.ppf(torch.linspace(offset, 0.5, 8)[:-1])).tolist() #负数部分
        v = v1 + v2 + v3
    else:
        v1 = norm.ppf(torch.linspace(offset, 0.5, 8)[:-1]).tolist()
        v2 = [0]*(256-14) ## we have 14 non-zero values in this data type
        v3 = (-norm.ppf(torch.linspace(offset, 0.5, 8)[:-1])).tolist()
        v = v1 + v2 + v3

    values = torch.Tensor(v)
    values = values.sort().values
    values /= values.max()
    assert values.numel() == 256
    return values

Q = create_normal_map()

函数 create_normal_map 有两个入参：offset 和 use_extra_value。其中 offset 的作用是确定分位数的始末值。use_extra_value 用来控制是使用对称量化还是非对称量化。 函数体内部有两个核心功能，其中 if…else…部分是用来计算分位数。其中 v1 计算正数部分，v3 计算负数部分。v2 直接将 0 映射到 0，并且根据要量化的单位计算 0 的个数。 源码是使用 NF4 来表示 8 比特的量化，如果是使用 4 比特的量化，我们将计算 v2 的 256 改成 16 就行。接下来最后几行用来将量化值归一化到 [-1,1] 。