大模型微调技术详解与实战代码实现

考虑到直接对 Embedding 参数进行优化会存在这样两个挑战：

① Discretenes：对输入正常语料的 Embedding 层已经经过预训练，而如果直接对输入的 prompt embedding 进行随机初始化训练，容易陷入局部最优。

② Association：无法捕捉到 prompt embedding 之间的相关关系。

所以作者提出用 MLP+LSTM 的方式来对 prompt embedding 进行一层处理。P-Tuning 的优点是它可以极大地降低微调大型模型的计算和内存开销，因为它只需优化少量的参数。此外，因为这些参数是独立于任务的，我们可以将同一模型用于不同的任务，只需更换 soft prompt 即可。

（5）LoRA

在机器学习的实践中，虽然许多模型具有大量的参数（被称为过度参数化），但实际有效的参数或被学习到的特性可能只存在于这些参数空间的一个较低维度的子空间中。

举个例子，考虑一个深度神经网络，它可能有数百万或数十亿的参数。然而，通过训练，网络可能找到了一个有效的解决方案，这个解决方案在参数空间中可能只占据一个较小的区域，即只需要改变一部分参数就可以在不同任务间进行有效的迁移。这就说明这个模型可能在一个低内在维度的子空间上工作。低秩自适应（LoRA）方法假设在模型自适应过程中权重的变化也具有较低的'内在秩'，它的核心思想很简单：

在原始 PLM (Pre-trained Language Model) 旁边增加一个旁路，做一个降维再升维的操作，来模拟所谓的 intrinsic rank。

训练的时候固定 PLM 的参数，只训练降维矩阵 A 与升维矩阵 B。而模型的输入输出维度不变，输出时将 AB 与 PLM 的参数叠加。

用随机高斯分布初始化 A，用 0 矩阵初始化 B，保证训练的开始此旁路矩阵依然是 0 矩阵。

LoRA 的这种思想有点类似于残差连接，同时使用这个旁路的更新来模拟 Full Fine-Tuning 的过程。并且，Full Fine-Tuning 可以被看做是 LoRA 的特例（当 r 等于 k 时）。

到目前为止，LoRA 方法已在多个任务和预训练模型上显示出了良好的性能，包括在自然语言处理、计算机视觉和强化学习任务中。

代码实现

（1）配置环境

实验环境：GeForce GTX 3090 with 22 GB memory，CUDA 11.6，Python3.8

依赖包：Pytorch, transformers, PEFT

import os
import pandas as pd
import torch
from torch.utils.data import DataLoader, TensorDataset, random_split, RandomSampler, SequentialSampler
from transformers import BertTokenizer, BertForSequenceClassification, AutoModelForSequenceClassification, AdamW, get_linear_schedule_with_warmup
from peft import PeftType, PrefixTuningConfig, PromptTuningConfig, PromptEncoderConfig, LoraConfig

（2）数据预处理

数据集：CoLA 数据集，做单句语法分类任务

下载数据集：

url = 'https://nyu-mll.github.io/CoLA/cola_public_1.1.zip'
os.system(f'wget {url}')
if not os.path.exists('./cola_public/'):
    os.system('unzip cola_public_1.1.zip')
df = pd.read_csv("./cola_public/raw/in_domain_train.tsv", delimiter='\t', header=None, names=['sentence_source', 'label', 'label_notes', 'sentence'])

分词（我们选取的预训练大模型为 bert-base-uncased）：

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)

添加特殊符号：

sentences = df.sentence.values
labels = df.label.values
max_len = 0
for sent in sentences:
    input_ids = tokenizer.encode(sent, add_special_tokens=True)
    max_len = max(max_len, len(input_ids))

input_ids_list = []
attention_masks = []
for sent in sentences:
    encoded_dict = tokenizer.encode_plus(
        sent,
        add_special_tokens=True, # 添加 '[CLS]' 和 '[SEP]'
        max_length=64,           # padding / 截断
        pad_to_max_length=True,
        return_attention_mask=True,
        return_tensors='pt'
    )
    input_ids_list.append(encoded_dict['input_ids'])
    attention_masks.append(encoded_dict['attention_mask'])

input_ids = torch.cat(input_ids_list, dim=0)
attention_masks = torch.cat(attention_masks, dim=0)
labels = torch.tensor(labels)

划分数据集：

dataset = TensorDataset(input_ids, attention_masks, labels)
train_size = int(0.9 * len(dataset))
val_size = len(dataset) - train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])

batch_size = 32

# 训练数据
train_dataloader = DataLoader(
    train_dataset,
    sampler=RandomSampler(train_dataset),
    batch_size=batch_size
)

# 验证数据
validation_dataloader = DataLoader(
    val_dataset,
    sampler=SequentialSampler(val_dataset),
    batch_size=batch_size
)

（3）训练模型

加载模型，如果选择全量微调，则直接加载预训练好的模型：

model_name_or_path = "bert-base-uncased"
model = BertForSequenceClassification.from_pretrained(
    model_name_or_path,
    num_labels=2,
    output_attentions=False,
    output_hidden_states=False,
    return_dict=False
)

若选择高效微调方法，则需要先指定一种微调技术再加载模型：

p_type = "lora"
if p_type == "prefix-tuning":
    peft_type = PeftType.PREFIX_TUNING
    peft_config = PrefixTuningConfig(task_type="SEQ_CLS", num_virtual_tokens=20)
elif p_type == "prompt-tuning":
    peft_type = PeftType.PROMPT_TUNING
    peft_config = PromptTuningConfig(task_type="SEQ_CLS", num_virtual_tokens=20)
elif p_type == "p-tuning":
    peft_type = PeftType.P_TUNING
    peft_config = PromptEncoderConfig(task_type="SEQ_CLS", num_virtual_tokens=20, encoder_hidden_size=128)
elif p_type == "lora":
    peft_type = PeftType.LORA
    peft_config = LoraConfig(task_type="SEQ_CLS", inference_mode=False, r=8, lora_alpha=16, lora_dropout=0.1)

model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, num_labels=2)

加载优化器：

optimizer = AdamW(model.parameters(), lr=2e-5, eps=1e-8)
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0, num_training_steps=total_steps)

开始微调模型：

epochs = 3
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

for epoch_i in range(0, epochs):
    total_train_loss = 0
    model.train()
    avg_train_loss, training_time = 0, 0
    
    for step, batch in enumerate(train_dataloader):
        b_input_ids = batch[0].to(device)
        b_input_mask = batch[1].to(device)
        b_labels = batch[2].to(device)
        
        model.zero_grad()
        loss, logits = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask, labels=b_labels)
        
        total_train_loss += loss.item()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        scheduler.step()
    
    avg_train_loss = total_train_loss / len(train_dataloader)

（4）测试性能

total_test_accuracy = 0
predictions = []
true_labels = []

for batch in prediction_dataloader:
    batch = tuple(t.to(device) for t in batch)
    b_input_ids, b_input_mask, b_labels = batch
    
    with torch.no_grad():
        outputs = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask)
    
    logits = outputs[0]
    logits = logits.detach().cpu().numpy()
    label_ids = b_labels.to('cpu').numpy()
    
    predictions.append(logits)
    true_labels.append(label_ids)
    
    # 假设 flat_accuracy 函数已定义
    total_test_accuracy += flat_accuracy(logits, label_ids)

avg_test_accuracy = total_test_accuracy / len(prediction_dataloader)
print("Accuracy: {:.4f}".format(avg_test_accuracy))

实验分析

（1）性能比较

上图展示了不同微调技术性能对比图，横坐标为训练次数，纵坐标为准确率。通过观察可以发现，在所有微调方法中，全量微调性能最好；LoRA 是几种高效微调技术中表现最好的，与全量微调相差不大。提示微调在模型不够大时表现欠佳，这也与提示微调原文中得到的结论相吻合。

（2）综合比较

下表为不同微调技术性能、算力对比表格。通过该表可以看出，全量微调所需训练时间最长，内存占用最多。高效微调训练参数量、训练时长、内存占用都远小于全量微调。综合比较下，LoRA 表现最好，性能和全量微调不相上下，计算效率也很高。

总结

大规模预训练模型已经在各种任务中表现出惊人的效果，但为了在特定的应用场景中最大化其效果，微调技术已成为一个必不可少的工具。微调允许我们在保持模型的大部分权重不变的同时，对模型进行细粒度的调整，以更好地适应特定的任务或数据集。然而，尽管微调在许多情况下都非常有效，但它也有一些挑战，如灾难性遗忘和稳定性问题。新兴的技术，如 Prompt Tuning，P-Tuning，以及低秩自适应方法（LoRA）等，为这些挑战提供了有前景的解决方案。无论我们在哪个行业，都有必要理解和掌握微调技术，以便充分利用大规模预训练模型的潜力。