필사 모드: LoRA: 大规模语言模型的高效微调论文解析

• 1. 引言
• 2. Full Fine-tuning 的问题
  • 2.1 参数数量与 GPU 内存
  • 2.2 存储与部署成本
  • 2.3 Inference Latency 问题
• 3. LoRA 核心思想：权重变化量的 Low-Rank 分解
  • 3.1 核心假设
  • 3.2 数学公式化
  • 3.3 初始化策略
  • 3.4 Scaling Factor：alpha/r
  • 3.5 推理时的合并（Merge）
• 4. 数学背景：Intrinsic Dimensionality
  • 4.1 什么是 Intrinsic Dimensionality？
  • 4.2 与 LoRA 的联系
• 5. Rank 选择策略与应用层
  • 5.1 应该对哪些层应用 LoRA？
  • 5.2 Rank 选择指南
• 6. QLoRA：4-bit 量化 + LoRA
  • 6.1 QLoRA 概述
  • 6.2 4-bit NormalFloat（NF4）
  • 6.3 Double Quantization
  • 6.4 Paged Optimizers
  • 6.5 QLoRA 的性能
  • 6.6 LoRA vs QLoRA 对比
• 7. HuggingFace PEFT 库实践
  • 7.1 安装
  • 7.2 基本 LoRA 配置与训练
  • 7.3 使用 SFTTrainer 进行 Instruction Tuning
  • 7.4 QLoRA 应用示例
  • 7.5 加载训练好的 Adapter 并推理
• 8. LoRA vs Full Fine-tuning 性能对比
  • 8.1 原论文的结果（GPT-3 175B）
  • 8.2 推理性能与训练效率
  • 8.3 LoRA 的局限性
• 9. 实战技巧：Learning Rate、Rank、Alpha 调整
  • 9.1 Learning Rate
  • 9.2 Rank（r）设置
  • 9.3 Alpha 设置
  • 9.4 Dropout
  • 9.5 优化器选择
  • 9.6 数据集相关技巧
  • 9.7 实战配置模板
• 10. LoRA 生态系统与变体技术
• 11. 结语
• 参考资料

1. 引言

GPT-3（175B）、LLaMA（65B）、Falcon（180B）等大规模语言模型（LLM）在各种 NLP 任务中展现出了惊人的性能。但要把这些模型适配到特定领域或任务的 Fine-tuning 过程，仍然需要庞大的计算资源。2021 年 Microsoft Research 发表的 LoRA（Low-Rank Adaptation of Large Language Models） 论文，为这一问题提出了优雅的解法，如今已成为 LLM Fine-tuning 事实上的标准（de facto standard）。

本文将对 LoRA 论文（Hu et al., 2021）的核心原理进行数学分析，并系统整理后续研究 QLoRA，以及基于 HuggingFace PEFT 库的实战应用方法。

2. Full Fine-tuning 的问题

2.1 参数数量与 GPU 内存

Full Fine-tuning 会更新预训练模型的全部参数。以 GPT-3 175B 模型为例来看，其代价便一目了然。

在 Full Fine-tuning 中使用 Adam optimizer 时，需要为每个参数额外保存 momentum 和 variance 两种状态值。因此即便按 16-bit 精度计算，模型权重（2 bytes）+ gradient（2 bytes）+ optimizer states（8 bytes）= 每个参数大约需要 12 bytes。对 175B 模型而言，这意味着需要约 2.1TB 的内存。

2.2 存储与部署成本

执行 Full Fine-tuning 时，每个任务都要保存整个模型的副本。若对 GPT-3 进行 10 个不同任务的 Fine-tuning，就需要 350GB x 10 = 3.5TB 的存储空间。相比之下，LoRA 每个任务只需保存约 35MB 的 adapter 权重，同样的场景下 350MB 就足够了。这相当于节省了约 10,000 倍的存储空间。

2.3 Inference Latency 问题

以往基于 Adapter 的方法（Houlsby et al., 2019）由于要在模型结构中插入额外的层，存在推理（inference）时 latency 增加的问题。尤其是在 batch size 较小的在线服务环境中，这种 overhead 会达到不可忽视的程度。LoRA 从根本上解决了这一问题。

3. LoRA 核心思想：权重变化量的 Low-Rank 分解

3.1 核心假设

LoRA 的核心假设如下：

在将预训练模型的权重适配到特定任务时，权重的变化量（delta W）具有较低的内在维度（low intrinsic rank）。

这一假设受到 Aghajanyan et al.（2020）研究的启发，其直觉在于：由于预训练模型已经学到了足够好的表征，任务适配所需的变化量只集中在整个参数空间的极小一部分中。

3.2 数学公式化

设预训练的权重矩阵为 $W_0 \in \mathbb{R}^{d \times k}$。在 Full Fine-tuning 中，将其更新为 $W_0 + \Delta W$，其中 $\Delta W \in \mathbb{R}^{d \times k}$ 与整个参数空间具有相同的维度。

LoRA 将这个 $\Delta W$ 分解为两个低秩（low-rank）矩阵的乘积：

$\Delta W = BA$

其中：

• $B \in \mathbb{R}^{d \times r}$（down-projection）
• $A \in \mathbb{R}^{r \times k}$（up-projection）
• $r \ll \min(d, k)$（rank，通常为 1～64）

因此 Forward pass 修改如下：

$h = W_0 x + \Delta W x = W_0 x + BAx$

可训练参数数量从 $d \times k$ 大幅减少到 $r \times (d + k)$。例如，若 $d = k = 12288$（GPT-3 的 hidden dimension）、$r = 8$，则：

• Full Fine-tuning：$12288 \times 12288 = 150,994,944$ 个参数
• LoRA：$8 \times (12288 + 12288) = 196,608$ 个参数（约减少 768 倍）

3.3 初始化策略

LoRA 的初始化被设计为，在训练开始时刻使 $\Delta W = 0$：

• 矩阵 A：Random Gaussian 初始化
• 矩阵 B：Zero 初始化

这样一来，训练开始时 $BA = 0$，因此即便加入了 LoRA adapter，模型也会生成与原始预训练模型相同的输出。这是保证训练稳定性的重要设计决策。

3.4 Scaling Factor：alpha/r

在实际的 Forward pass 中，LoRA 的输出会乘以 scaling factor $\frac{\alpha}{r}$：

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

这里 $\alpha$ 是一个常数（hyperparameter）。原论文中提到，将 $\alpha$ 设为最初尝试的 $r$ 值，此后不再更改。这个 scaling factor 的作用，是减少在改变 rank $r$ 时重新调整 learning rate 的必要性。

最近有人提出了 Rank-Stabilized LoRA（rsLoRA），将 scaling factor 设为 $\frac{\alpha}{\sqrt{r}}$，改善了高 rank 下的训练稳定性。在 HuggingFace PEFT 中，可以通过 use_rslora=True 选项启用该功能。

3.5 推理时的合并（Merge）

LoRA 最大的优点之一，是推理时没有额外的 latency。训练完成后，可以将 adapter 权重合并进原始模型：

$W = W_0 + \frac{\alpha}{r} BA$

合并之后，模型结构与原模型完全相同，因此推理速度不会有任何下降。反之，如果想切换到另一个任务的 adapter，只需减去 $BA$，再加上另一组 $B'A'$ 即可。正是这种灵活性，使得在一个 base model 上高效管理多个任务专属 adapter 成为可能。

4. 数学背景：Intrinsic Dimensionality

4.1 什么是 Intrinsic Dimensionality？

Aghajanyan et al.（2020）在论文 "Intrinsic Dimensionality Explains the Effectiveness of Language Model Fine-Tuning" 中，通过实验证明了预训练语言模型的 Fine-tuning 过程具有出乎意料的低内在维度（intrinsic dimension）。

其核心思想是：即便把整个参数空间 $\mathbb{R}^D$（D 为总参数数）中的优化问题，重新参数化（reparameterize）为一个小得多的子空间 $\mathbb{R}^d$（$d \ll D$）中的优化问题，也能达到与 Full Fine-tuning 相近的性能。

4.2 与 LoRA 的联系

LoRA 直接利用了这一观察结果。如果权重更新 $\Delta W$ 具有较低的 intrinsic rank，那么用低秩矩阵乘积 $BA$ 来近似它就是合理的。

实际上，LoRA 论文的实验结果有力地支持了这一假设。在 GPT-3 175B 模型上对 $W_q$、$W_v$ 应用 LoRA 时，仅凭 rank r=1 就取得了相当有竞争力的性能：

$r=1$ 与 $r=64$ 之间几乎没有性能差异，这一点从实验上印证了权重变化量的 intrinsic rank 非常低的假设，也带来了「rank 越大并不总是越好」这一实用启示。

5. Rank 选择策略与应用层

5.1 应该对哪些层应用 LoRA？

Transformer 的 Self-Attention 模块中有 4 个权重矩阵：$W_q$（Query）、$W_k$（Key）、$W_v$（Value）、$W_o$（Output projection）。LoRA 论文在 GPT-3 175B 模型上，于相同的参数预算（18M）下对多种组合进行了实验。

结果显示，同时对 $W_q$ 和 $W_v$ 应用取得了最佳性能。只对单一矩阵应用（例如只用 $W_q$ 或只用 $W_v$）会导致性能下降，而对所有矩阵都应用，则会因为每个矩阵分配到的 rank 减少，反而使性能变差。

但后续的研究与实务经验表明，对所有 Linear 层应用 LoRA 往往能带来更好的结果。根据 Sebastian Raschka 的实验，在 LLaMA-2 7B 模型上，对 Attention 的 Q、K、V、O 以及 MLP 的 gate、up、down projection 等全部层都应用 LoRA 时：

• 可训练参数：4,194,304 -> 20,277,248（约增加 5 倍）
• GPU 内存：14.18 GB -> 16.62 GB（约增加 17%）
• 性能：显著提升

虽然参数数量与内存会有所增加，但性能收益相对于成本而言相当划算，因此实务中越来越推荐使用 target_modules="all-linear" 设置。

5.2 Rank 选择指南

Rank 的选择没有绝对的规则，但可以参考以下指南：

在 Sebastian Raschka 的实验中，r=256 的表现优于 r=8、32、64、128，但在 r=512 时反而观察到性能下降的趋势。这说明过高的 rank 可能引发 overfitting。

6. QLoRA：4-bit 量化 + LoRA

6.1 QLoRA 概述

2023 年 Tim Dettmers et al. 发表的 QLoRA（Quantized LoRA），将 LoRA 的内存效率又向前推进了一步。其核心思想是，把 base model 的权重量化为 4-bit 存储，只用 16-bit（或 BFloat16）来训练 LoRA adapter。

QLoRA 的三项技术创新：

6.2 4-bit NormalFloat（NF4）

NF4 是 QLoRA 提出的一种新数据类型，对于服从正态分布的权重而言，是信息论意义上最优的量化方式。

预训练神经网络的权重一般服从 zero-centered normal distribution。NF4 使用 quantile quantization，使每个量化区间（bin）在目标正态分布中表示相同期望数量的值。由此，它能比传统的 INT4 或 FP4 更精确地保留原始的权重分布。

6.3 Double Quantization

Double Quantization 是对量化常数（quantization constants）本身再次进行量化的技巧。在 Block-wise quantization 中，每个 block 都需要一个 scaling factor，通过再次量化这个 scaling factor 本身，可以平均每个参数额外节省约 0.37 bits。以 65B 模型为基准，可额外节省约 3GB 内存。

6.4 Paged Optimizers

Paged Optimizers 利用 NVIDIA Unified Memory，在 GPU 内存趋于饱和时，自动将 optimizer states 转移（page out）到 CPU 内存。这能有效应对处理长序列时出现的 gradient checkpointing memory spike。它基于 CUDA Toolkit 6.0 引入的 Unified Memory 模型，利用了 CPU 与 GPU 都能直接访问的统一内存空间。

6.5 QLoRA 的性能

借助 QLoRA，如今可以在单张 48GB GPU 上对 65B 参数模型进行 Fine-tuning，同时保持与 16-bit Full Fine-tuning 相当的任务性能。用 QLoRA 训练出的 Guanaco 系列模型，在 Vicuna 基准测试中超越了此前所有公开模型，达到了 ChatGPT 性能的 99.3%。而这一结果，仅用单张 GPU 训练 24 小时便已达成。

6.6 LoRA vs QLoRA 对比

QLoRA 以量化/反量化过程带来的约 39% 训练时间增加为代价，节省了约 33% 的内存。在内存受限的环境中 QLoRA 更合适，而在训练速度更重要的环境中 LoRA 更合适。

7. HuggingFace PEFT 库实践

7.1 安装

pip install peft transformers trl datasets bitsandbytes accelerate

7.2 基本 LoRA 配置与训练

下面是使用 HuggingFace PEFT 对 Causal Language Model 应用 LoRA 的基本示例。

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

# 1. 加载模型与分词器
model_id = "meta-llama/Llama-2-7b-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# 2. LoRA 配置
lora_config = LoraConfig(
    r=16,                          # rank
    lora_alpha=32,                 # scaling factor (alpha)
    target_modules="all-linear",   # 应用于所有 Linear 层
    lora_dropout=0.05,             # dropout 比例
    bias="none",                   # 禁用 bias 训练
    task_type=TaskType.CAUSAL_LM,  # 任务类型
)

# 3. 创建 PEFT 模型
model = get_peft_model(model, lora_config)

# 4. 检查可训练参数
model.print_trainable_parameters()
# 输出示例: trainable params: 20,277,248 || all params: 6,758,404,096 || trainable%: 0.30

7.3 使用 SFTTrainer 进行 Instruction Tuning

将 TRL 库的 SFTTrainer 与 PEFT 结合，可以更简洁地完成 Fine-tuning。

from trl import SFTTrainer, SFTConfig
from peft import LoraConfig
from datasets import load_dataset

# 加载数据集
dataset = load_dataset("tatsu-lab/alpaca", split="train")

# LoRA 配置
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
)

# 配置 SFTTrainer 并训练
trainer = SFTTrainer(
    model=model_id,
    args=SFTConfig(
        output_dir="./lora-output",
        num_train_epochs=1,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        bf16=True,
        logging_steps=10,
        save_strategy="epoch",
        max_seq_length=2048,
    ),
    train_dataset=dataset,
    peft_config=peft_config,
)

trainer.train()

# 保存训练好的 adapter
trainer.save_model("./lora-adapter")

7.4 QLoRA 应用示例

要应用 QLoRA，需要借助 bitsandbytes 添加 4-bit 量化配置。

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

# 4-bit 量化配置
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,                     # 启用 4-bit 量化
    bnb_4bit_quant_type="nf4",             # 使用 NormalFloat4 类型
    bnb_4bit_compute_dtype=torch.bfloat16, # 计算时使用 BFloat16
    bnb_4bit_use_double_quant=True,        # 启用 Double Quantization
)

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

# 为 k-bit 训练准备模型
model = prepare_model_for_kbit_training(model)

# LoRA 配置（QLoRA 中同样适用）
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules="all-linear",
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

# 创建 PEFT 模型
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

7.5 加载训练好的 Adapter 并推理

from peft import PeftModel, PeftConfig
from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载 Base 模型
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")

# 加载 LoRA adapter
model = PeftModel.from_pretrained(base_model, "./lora-adapter")

# （可选）将 adapter 合并进 base model 以优化 inference 速度
model = model.merge_and_unload()

# Inference
inputs = tokenizer("AI 的未来是", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

8. LoRA vs Full Fine-tuning 性能对比

8.1 原论文的结果（GPT-3 175B）

LoRA 原论文中报告的 GPT-3 175B 结果如下：

值得注意的是，LoRA 在 MNLI 和 SAMSum 上超过了 Full Fine-tuning。尽管只训练了 4.7M 参数（占全部的 0.003%），却取得了比训练全部 175B 参数更好的结果。这被解释为 LoRA 的 implicit regularization 效果——即低秩分解起到了一种正则化（regularization）的作用，从而防止了 overfitting。

8.2 推理性能与训练效率

8.3 LoRA 的局限性

LoRA 并不总是与 Full Fine-tuning 等价。最近的研究（Biderman et al., 2024，"LoRA vs Full Fine-tuning: An Illusion of Equivalence"）指出了以下几点：

1. SVD 结构的差异：由 LoRA 与 Full Fine-tuning 训练出的权重矩阵，其 Singular Value Decomposition 结构并不相同。
2. 分布外泛化（OOD Generalization）：对于超出训练数据分布的输入，LoRA 与 Full Fine-tuning 模型展现出不同的泛化模式。
3. 对数据集规模的依赖：当数据集规模大幅超过 LoRA 的可训练参数数量时，Full Fine-tuning 可能占据优势。

因此在应用 LoRA 时，需要综合考虑任务复杂度与数据集规模，合理设置 rank 与 target modules。

9. 实战技巧：Learning Rate、Rank、Alpha 调整

9.1 Learning Rate

• LoRA 所需的 learning rate 比 Full Fine-tuning 高约 10 倍。若 Full Fine-tuning 使用 1e-5～3e-5，那么 LoRA 使用 1e-4～3e-4 区间较为合适。
• Learning rate 应该先于其他 hyperparameter 进行优化，因为 Rank 与 alpha 的效果都依赖于 learning rate。
• Cosine annealing 调度器在 SGD 中效果显著，但在 Adam/AdamW 中影响甚微。

9.2 Rank（r）设置

• 起点：从 r=16 开始评估性能，再根据需要进行调整。
• 设置过低的风险：Rank 过低会导致任务所需的表达能力不足。
• 设置过高的风险：Rank 过高可能引发 overfitting，并增加内存与计算成本。
• 使用 rsLoRA：当使用 r=32 以上的高 rank 时，建议设置 use_rslora=True，将 scaling factor 调整为 $\frac{\alpha}{\sqrt{r}}$，这能改善高 rank 下的训练稳定性。

9.3 Alpha 设置

• 常见经验法则：设置 alpha = 2 * r。也就是说，若 rank 为 16，则将 alpha 设为 32。
• 这一比例在大多数情况下都能取得不错的结果，但最优比例会因模型和数据集而异。
• 在 Sebastian Raschka 的实验中，也有 r=256、alpha=128（0.5 倍比例）取得更好结果的案例。

9.4 Dropout

• LoRA dropout 通常设置在 0.05～0.1 范围内。
• 数据集较小或担心 overfitting 时可考虑 0.1，大规模数据集则可考虑 0.05 或直接禁用（0.0）。

9.5 优化器选择

• AdamW：最稳定且最广泛使用的选择。
• SGD：在低 rank 下与 AdamW 的内存差异很小，但在高 rank（r=256）下能带来有意义的内存节省（17.86 GB vs 14.46 GB）。
• 大多数情况下以 AdamW 为默认选择，但在内存极其受限、又必须使用高 rank 的环境中可以考虑 SGD。

9.6 数据集相关技巧

• 注意 Multi-epoch 训练：对同一数据集重复训练多次可能引发 overfitting。在 Sebastian Raschka 的实验中，对 Alpaca 数据集训练 2 个 epoch 时，性能反而出现下降。
• 数据质量 > 数量：曾有案例显示，包含 1K 个样本的 LIMA 数据集取得了与包含 50K 个样本的 Alpaca 数据集相近甚至更好的结果。构建高质量数据集，可能比 hyperparameter tuning 更为重要。

9.7 实战配置模板

以下是可以在实务中直接使用的 LoRA 配置模板。

from peft import LoraConfig

# 常见的 Instruction Tuning 配置
config_standard = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules="all-linear",
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

# 以节省内存为优先的配置（配合 QLoRA 使用）
config_memory_efficient = LoraConfig(
    r=8,
    lora_alpha=16,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.1,
    bias="none",
    task_type="CAUSAL_LM",
)

# 性能最大化配置
config_high_performance = LoraConfig(
    r=64,
    lora_alpha=128,
    target_modules="all-linear",
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    use_rslora=True,  # 在高 rank 下使用 Rank-Stabilized LoRA
)

10. LoRA 生态系统与变体技术

LoRA 取得成功之后，各种变体技术相继出现。简要整理如下：

HuggingFace PEFT 库通过 LoraConfig 的选项或独立的 Config 类，支持所有这些技术，只需极少的代码改动，就能尝试各种不同的方法。

11. 结语

LoRA 从「预训练模型的权重变化量具有较低 intrinsic rank」这一简洁的假设出发，大幅降低了大规模语言模型的 Fine-tuning 成本。数学上优雅、实现简单、推理时没有额外开销——这三大优点，使 LoRA 成为当下 LLM Fine-tuning 的标准。

随着 QLoRA 的出现，即便在消费级 GPU 上，也能对大规模模型进行 Fine-tuning，而 HuggingFace PEFT 库则让这些技术只需几行代码即可应用。如果你正在从事使用 LLM 的项目，LoRA 是必须掌握的核心技术。

参考资料

1. Hu, E. J., Shen, Y., Wallis, P., Allen-Zhu, Z., Li, Y., Wang, S., Wang, L., & Chen, W. (2021). LoRA: Low-Rank Adaptation of Large Language Models. arXiv. https://arxiv.org/abs/2106.09685

2. Dettmers, T., Pagnoni, A., Holtzman, A., & Zettlemoyer, L. (2023). QLoRA: Efficient Finetuning of Quantized LLMs. arXiv. https://arxiv.org/abs/2305.14314

3. Aghajanyan, A., Gupta, S., & Zettlemoyer, L. (2020). Intrinsic Dimensionality Explains the Effectiveness of Language Model Fine-Tuning. arXiv. https://arxiv.org/abs/2012.13255

4. HuggingFace PEFT - LoRA Documentation. https://huggingface.co/docs/peft/en/package_reference/lora

5. HuggingFace PEFT - LoRA Methods Guide. https://huggingface.co/docs/peft/en/task_guides/lora_based_methods

6. HuggingFace PEFT GitHub Repository. https://github.com/huggingface/peft

7. Microsoft LoRA GitHub Repository. https://github.com/microsoft/LoRA

8. Raschka, S. (2023). Practical Tips for Finetuning LLMs Using LoRA (Low-Rank Adaptation). Sebastian Raschka's Magazine. https://magazine.sebastianraschka.com/p/practical-tips-for-finetuning-llms

9. Biderman, S., et al. (2024). LoRA vs Full Fine-tuning: An Illusion of Equivalence. arXiv. https://arxiv.org/abs/2410.21228

10. Kalajdzievski, D. (2023). Rank-Stabilized LoRA (rsLoRA). arXiv. https://arxiv.org/abs/2312.03732

11. Liu, S., et al. (2024). DoRA: Weight-Decomposed Low-Rank Adaptation. arXiv. https://arxiv.org/abs/2402.09353

12. HuggingFace Blog - Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA. https://huggingface.co/blog/4bit-transformers-bitsandbytes