大模型技术实践（四）｜参数高效微调技术解析及AdaLoRA的应用

在上一期的大模型技术实践中，我们为大家介绍了基于“LangChain+LLM”框架快速搭建知识增强后的问答机器人，并探讨了提升模型内容理解和执行能力的潜在优化方向。

本期内容UCloud将为您介绍参数高效微调技术（PEFT），即对已预训练好的模型，固定住其大部分参数，而仅调整其中小部分或额外增加的参数，以达到与全部参数微调相近的效果。

参数高效微调方法，可大致分为三个类别：增加式方法、选择式方法和重新参数化式方法[1]。

01

增加式方法（Additive methods）

增加式方法通过增加额外的参数或层来扩展现有的预训练模型，且仅训练新增加的参数。目前，这是PEFT方法中被应用最广泛的类别。

在增加式方法中，大致分为Adapter类方法和软提示（Soft Prompts）。2019年1月至2022年3月期间，Adapter类的方法Adapter Tuning，软提示类的方法Prefix Tuning、P-Tuning、Prompt Tuning和P-Tuning v2相继出现。

1.1 Adapter Tuning

Adapter的架构如下[2]：
左图是一个Transformer层，右图是一个Adapter层。在每一个Transformer层中的每个子层之后插入两个串行的Adapter。在Adapter微调期间，绿色层是根据下游数据进行训练的，而预训练模型的原参数保持不变。

Adapter的特点:

Adapter 模块主要由两个前馈（Feed-forward）子层组成。

1. 第一个前馈子层将原始特征的维度d投影到一个更小的维度m，应用非线性函数，再投影回维度d的特征（作为Adapter模块的输出）。

2. 总参数量为2md + d + m。通过设置m < d，我们限制了每个任务添加的参数数量。

3. 当投影层的参数初始化接近零时，根据一个skip-connection（跳跃连接），将该模块就初始化为近似恒等函数，以确保微调的有效性。

Adapter的实验结果：

使用公开的预训练BERT作为基础模型，Adapter微调具有高参数效率，可以生成性能强劲的紧凑模型，与完全微调相比表现相当。Adapter通过使用原始模型0.5-5%大小的参数量来微调，性能与BERT-LARGE上具有竞争力的结果相差不到1%。

1.2 Soft Prompts

早期的提示微调通过修改输入文本来控制语言模型的行为，称为硬提示（Hard Prompts）微调。这些方法很难优化，且受到最大模型输入长度的限制。下图为离散的人工设计的Prompt示例：

比如改变输入形式去询问模型：

软提示（Soft Prompts）将离散的“提示”问题转为连续的“提示”问题，通过反向传播和梯度下降更新参数来学习Prompts，而不是人工设计Prompts。有仅对输入层进行训练，也有对所有层进行训练的类型。

下面将介绍几种热门的Soft Prompts微调方法。

Prefix Tuning

其结构如下[3]：

只优化前缀（红色前缀块），该前缀添加到每一个Transformer Block中。

Prefix Tuning的特点:

1. 冻结预训练语言模型的参数，为每个任务存储特定的连续可微的前缀，节省空间。

2. 训练间增加MLP层以达到稳定。

3. 对于不同模型构造不同的Prefix。

Prefix Tuning的实验结果：

对于表格到文本任务，使用GPT-2-Medium和GPT-2-Large模型。在表格到文本任务上，Prefix Tuning优于Fine-Tuning（全量微调）和Adapter-Tuning。对于摘要任务，使用BART-LARGE模型。在摘要任务上，Prefix Tuning比全量微调弱。

P-Tuning

其结构如下[4]：
在（a）中，提示生成器只接收离散的奖励；在（b）中，伪提示和提示编码器可以以可微分的方式进行优化。

优化h(i)时，为避免陷入局部最优和增强Prompt嵌入关联性，语言模型的真实输入嵌入为：

P-Tuning的特点：

1. P-Tuning只在输入层加入可微的Virtual Token，其会自动插入到文本提示的离散Token嵌入中。

2. Virtual Token不一定作为前缀，其插入位置是可选的。

P-Tuning的实验结果：

使用的是GPT系列和BERT系列的模型。P-Tuning与全参数效果相当，且在一些任务上优于全参数微调，可以显著提高GPT模型在自然语言理解方面的性能，并且BERT风格的模型也可以获得较小的增益。

Prompt Tuning

其结构如下[5]：

上图中，仅Virtual Token部分会由梯度下降法去更新参数。

Prompt Tuning的特点：

1. 只在输入层加入prompt，并且不需要加入MLP进行调整来解决难训练的问题。

2. 提出了Prompt Ensembling，即通过在同一任务上训练N个提示，也就是在同一个批次中，对同一个问题添加不同的Prompt，相当于为任务创建了N个独立的“模型”，同时仍然共享核心语言建模参数。

Prompt Tuning的实验结果：

使用的是预训练的各种T5模型。在流行的SuperGLUE基准测试中，Prompt Tuning的任务性能与传统的模型调优相当，且随着模型规模的增加，差距逐渐减小。在零样本领域迁移中，Prompt Tuning可以改善泛化性能。

P-Tuning v2

其结构如下[6]：

上图表示了P-Tuning到P-Tuning v2的转变。橙色块指的是可训练的提示嵌入，蓝色块是由冻结的预训练语言模型存储或计算得出的嵌入。

P-Tuning v2的特点：

P-Tuning v2每一层的输入都加入了Tokens，允许更高的任务容量同时保持参数效率；且添加到更深层的提示对模型的预测有更直接的影响。

P-Tuning v2的实验结果：

使用的是BERT系列和GLM系列模型。P-Tuning v2是一种在不同规模和任务中都可与微调相媲美的提示方法。在NLU任务中，整体上P-Tuning v2与全量微调的性能相差很小。

02

选择式方法

选择性方法对模型的现有参数进行微调，可以根据层的深度、层类型或者甚至是个别参数进行选择。

2.1 BitFit

这是一种稀疏微调方法，仅修改模型的Bias（偏置项）或其中的子集[7]。

BitFit的特点:

1. 冻结大部分Transformer编码器的参数，只训练偏置项和任务特定的分类层。

2. 优化的偏置项参数包括：①Attention模块中计算Query、Key、Value，②计算MLP层，③计算Layer Normalization层时遇到的偏置项参数。

3. 每个新任务只需要存储偏置项参数向量（占总参数数量的不到0.1%）和任务特定的最终线性分类器层。

BitFit的实验结果：

使用公开可用的预训练BERT-BASE、BERT-LARGE和RoBERTa-BASE模型。BitFit微调结果不及全量参数微调，但在极少数参数可更新的情况下，远超Frozen（冻结模型参数）方式。

03

重新参数化方法

基于重新参数化的高效微调方法利用低秩表示来最小化可训练参数的数量，其中包括2021年10月到2023年3月间出现的LoRA和AdaLoRA方法。

3.1 LoRA

该方法认为模型权重矩阵在特定微调后具有较低的本征秩，故基于秩分解的概念，将预训练模型的现有权重矩阵分成两个较小的矩阵[8]。

LoRA的特点：

1. 将矩阵乘积BA加到原模型参数矩阵W上可以避免推理延迟。

2. 可插拔的低秩分解矩阵模块，方便切换到不同的任务。

LoRA的实验结果：

使用的模型是RoBERTa、DeBERTa、GPT-2和GPT-3-175B。在多个数据集上，LoRA在性能上能和全量微调相近，且在某些任务上优于全量微调。

3.2 AdaLoRA

AdaLoRA的特点：

该方法基于权重矩阵的重要性而自适应调整不同模块的秩[9]，节省计算量，可理解为LoRA的升级版。
AdaLoRA的做法是让模型学习SVD分解的近似。在损失函数中增加了惩罚项，防止矩阵P和Q偏离正交性太远，以实现稳定训练。

AdaLoRA的实验结果：

使用的模型是DeBERTaV3-BASE 和BART-LARGE模型。AdaLoRA的性能通常高于参数量更高的方法。其中，AdaLoRA在0.32M微调参数时，在CoLA数据集上达到了70.04的Mcc分数。

04

参数高效微调方法小结

以上几类参数高效微调方法，各有千秋。Adapter方法在预训练模型的层中插入可训练模块的形式简单，但增加推理延时。Soft Prompts方法避免了人工“硬提示”的局限性，却可能难收敛。

Soft Prompts方法中，Prefix Tuning率先提出可用梯度下降法优化的的Tokens，而P-Tuning、Prompt Tuning和P-Tuning v2相继作出不同的改变，比如：

1. 加入的Tokens：P-Tuning仅限于输入层，而Prefix-Tuning在每一层都加。

2. P-Tuning和Prompt Tuning仅将连续提示插入到输入嵌入序列中，而Prefix Tuning的“软提示”添加在每一个Transformer Block中。

3. Prompt Tuning不需要额外的MLP来解决难训练的问题，P-Tuning v2移除了重参数化的编码器。

BitFit方法只更新模型内部偏置项参数所以训练参数量很微小，但整体效果比LoRA、Adapter等方法弱。LoRA方法不存在推理延时，但无法动态更新增量矩阵的秩，不过改进版AdaLoRA解决了这个问题。

05

AdaLoRA方法的实验

实验模型为ChatGLM2-6B

模型下载参见

(https://github.com/THUDM/ChatGLM2-6B)

可去Hugging Face下载其模型文件。应用AdaLoRA之后的模型训练参数仅占总参数的0.0468%。

trainable params: 2,924,880 ||

all params: 6,246,508,908 ||

trainable%: 0.04682423483386154

实验数据为中文医疗问答数据

下载链接为(https://github.com/Toyhom/Chinese-medical-dialogue-data)

包括儿科、外科等问答数据，数据中会有建议去医院看病之类的文字。此处选取儿科和外科的数据分别10000条数据作为训练数据集，将文件保存为json格式。

构造数据集

文件为dataset.py。

向上滑动查看

from torch.utils.data import Dataset
import torch
import json
import numpy as np
from torch.nn.utils.rnn import pad_sequence
from transformers import AutoTokenizer
from torch.utils.data import DataLoader
from tqdm import tqdm
import sys

class my_dataset(Dataset):
def __init__(self, data_path, tokenizer, max_source_length, max_target_length, is_train = True):
super().__init__()
self.tokenizer = tokenizer
self.max_source_length = max_source_length
self.max_target_length = max_target_length
self.max_seq_length = self.max_source_length + self.max_target_length

self.data_path = data_path
self.data = self._load_data()
self.is_train = is_train

def __len__(self):
return len(self.data)

def __getitem__(self, index):
item_data = self.data[index]
if self.is_train:
model_inputs = self._preprocess(**item_data)
return model_inputs

def _load_data(self):
data = []
with open(self.data_path, "r", encoding='utf-8') as f:
for line in f:
if not line or line == "":
continue
json_line = json.loads(line)
ask = json_line.get("ask")
answer = json_line.get("answer")
if ask and answer:
data.append({"question": ask, "answer": answer})
return data

def _preprocess(self, question, answer):
model_inputs = {
"input_ids": None,
"labels": None,
}
Prompt = self.tokenizer.build_Prompt(question, None)
a_ids = self.tokenizer.encode(text=Prompt, add_special_tokens=True, truncation=True,
max_length = self.max_source_length)
b_ids = self.tokenizer.encode(text=answer, add_special_tokens=False, truncation=True,
max_length = self.max_target_length)

context_length = len(a_ids)
input_ids = a_ids + b_ids + [self.tokenizer.eos_token_id]
labels = [self.tokenizer.pad_token_id] * context_length + b_ids + [self.tokenizer.eos_token_id]

pad_len = self.max_seq_length - len(input_ids)
input_ids = input_ids + [self.tokenizer.pad_token_id] * pad_len
labels = labels + [self.tokenizer.pad_token_id] * pad_len
labels = [(l if l != self.tokenizer.pad_token_id else -100) for l in labels]

model_inputs["input_ids"] = torch.tensor(input_ids, dtype=torch.long)
model_inputs["labels"] = torch.tensor(labels, dtype=torch.long)

return model_inputs

训练代码

1. 文件为FT.py。

向上滑动查看

from transformers import AutoTokenizer, AutoModel
from peft import AdaLoraConfig, get_peft_model, TaskType
from dataset import my_dataset
from tqdm import tqdm
import torch
from torch.utils.data import DataLoader
import pandas as pd
import os, sys
import argparse
import shutil
from accelerate import Accelerator, DeepSpeedPlugin

parser = argparse.ArgumentParser()
parser.add_argument("--model_name", type=str, default="/data/chatglm2-6b")
parser.add_argument("--r", type=int, default = 8)
parser.add_argument("--lora_alpha", type=int, default = 32)
parser.add_argument("--lora_dropout", type=float, default = 0.01)
parser.add_argument("--epochs", type=int, default = 5)
parser.add_argument("--batch_size", type=int, default = 1)
parser.add_argument("--max_source_length", type=int, default = 128)
parser.add_argument("--max_target_length", type=int, default = 256)
parser.add_argument("--train_json_path", type=str, default = "./test_data/train.json")
parser.add_argument("--lr", type=float, default=1e-4)
parser.add_argument("--model_output_dir", type=str, default="output")
args = parser.parse_args()

accelerator = Accelerator()
device = accelerator.device
accelerator.print(f'device {str(accelerator.device)} is used!')

def main():
adaLoRA_config = AdaLoraConfig(
peft_type = "ADALORA", task_type = "CAUSAL_LM",
r = args.r, lora_alpha = args.lora_alpha,
target_modules = ["query_key_value"],
lora_dropout = args.lora_dropout,
)

tokenizer = AutoTokenizer.from_pretrained(args.model_name, trust_remote_code=True)
model = AutoModel.from_pretrained(args.model_name, trust_remote_code=True)

model = get_peft_model(model, adaLoRA_config)
print(model)
model.print_trainable_parameters()
model = model.half()

train_set = my_dataset(args.train_json_path, tokenizer, args.max_source_length, args.max_target_length)
train_loader = DataLoader(train_set, batch_size = args.batch_size, shuffle = True)

optimizer = torch.optim.AdamW(params = model.parameters(), lr = args.lr)

if os.path.exists(args.model_output_dir):
shutil.rmtree(args.model_output_dir)
os.makedirs(args.model_output_dir)

model, optimizer, data_loader = accelerator.prepare(model, optimizer, train_loader)
for epoch in range(args.epochs):
total_loss = 0
for step, batch in enumerate(t:=tqdm(data_loader)):
with accelerator.accumulate(model):
outputs = model(**batch)
loss_detach = outputs.loss.detach().cpu().float()
t.set_description(f"loss: {loss_detach}")
total_loss += loss_detach

loss = outputs.loss
accelerator.backward(loss)

optimizer.step()
optimizer.zero_grad()
unwrapped_model = accelerator.unwrap_model(model)
unwrapped_model.save_pretrained(os.path.join(args.model_output_dir, f'{epoch}_epoch'),
save_function=accelerator.save,
state_dict=accelerator.get_state_dict(model))

if __name__ == '__main__':
main()

2. 配置文件config_accelerate.yml

deepspeed_config:
gradient_clipping: 1.0
gradient_accumulation_steps: 16
distributed_type: DEEPSPEED

3. 执行文件run.sh

CONFIG_FILE='config_accelerate.yml'
accelerate launch --config_file $CONFIG_FILE FT.py

测试代码

import torch
from transformers import AutoTokenizer, AutoModel
from peft import PeftConfig, PeftModel
import os
import shutil

device = torch.device("cuda:0")

model_name = "/data/chatglm2-6b"
adalora_path = "output_20000_all5/y_epoch"

def ans():
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModel.from_pretrained(model_name, trust_remote_code=True)
model = PeftModel.from_pretrained(model, adalora_path)

model = model.half()
model = model.to(device)
model.eval()

ask = input("请输入问题：")
response, history = model.chat(tokenizer, ask, history = [])
print("回答：", response)

if __name__ == "__main__":
ans()

结果为：

06

结语

PEFT技术除了以上三种主流分类之外，还包括了对上述PEFT方法进行综合改进的“混合参数高效微调方法”：MAM Adapter和UniPELT。其中，MAM Adapter引入了Adapter和Prompt-Tuning的思想，而UniPELT综合了LoRA、Prefix Tuning和Adapter的思想。混合参数高效微调方法效果优于单个高效微调方法的概率较大，但同时也存在训练参数和推理延时增加的局限，感兴趣的读者可以阅读原论文了解技术细节。

下一期将会对大模型的加速并行框架进行探讨，欢迎大家持续关注！

【参考文献】

[1] 《Scaling Down to Scale Up: A Guide to Parameter-Efficient Fine-Tuning》

[2] 《Parameter-Efficient Transfer Learning for NLP》

[3] 《Prefix-Tuning: Optimizing Continuous Prompts for Generation》

[4] 《GPT Understands, Too》

[5] 《The Power of Scale for Parameter-Efficient Prompt Tuning》

[6] 《P-Tuning v2: Prompt Tuning Can Be Comparable to Fine-tuning Universally Across Scales and Tasks》

[7] 《BitFit: Simple Parameter-efficient Fine-tuning for Transformer-based Masked Language-models》

[8] 《LoRA: LOW-RANK ADAPTATION OF LARGE LANGUAGE MODELS》

[9] 《ADAPTIVE BUDGET ALLOCATION FOR PARAMETEREFFICIENT FINE-TUNING》