从零学习大模型（七）-----LoRA（中）

自注意力层中的 LoRA 应用

Transformer 的自注意力机制是模型理解输入序列之间复杂关系的核心部分。自注意力层通常包含多个线性变换，包括键（Key）、查询（Query） 和 值（Value） 三个权重矩阵的线性映射，这些权重矩阵需要被训练来适应不同的任务。

LoRA 在自注意力层中的步骤：

冻结原始权重：将自注意力层中的键、查询、值矩阵的权重参数冻结，不进行训练。这些原始权重是通过预训练获得的，用于保留模型在大规模数据上学习到的通用知识。

添加低秩适配矩阵：对于键、查询、值矩阵的权重分别添加低秩适配矩阵 $A$ 和 $B$ 。例如，如果键矩阵 $W_k \in \mathbb{R}^{d_k \times d_{\text{model}}}$ ，则引入两个适配矩阵：
$A_k \in \mathbb{R}^{d_k \times r}, \quad B_k \in \mathbb{R}^{r \times d_{\text{model}}}$
其中 $r$ 是低秩值，通常比 $d_k$ 和 $d_{\text{model}}$ 小很多。

权重变换：在执行前向传播时，键、查询、值矩阵的线性变换将使用 $W_k' = W_k + A_k B_k$ ,作为新的权重矩阵，其中 $W_k$ 是冻结的原始权重， $A_k B_k$ 是任务特定的微调部分。

训练适配矩阵：在特定任务的微调过程中，仅更新新增的适配矩阵 $A_k$ 和 $B_k$ 的参数，而不更新原始的键矩阵权重。这使得微调过程变得高效和轻量化。

前馈网络中的 LoRA 应用

Transformer 的前馈网络（FFN） 通常由两个线性层和一个非线性激活函数（如 ReLU）组成。在前馈网络中，参数数量非常庞大，因为它在每个位置上独立地对输入进行两次线性变换。

LoRA 在前馈网络中的步骤：

冻结全连接层权重：前馈网络中的两个全连接层的权重也被冻结。这些层用于对每个输入位置进行独立的变换，其预训练参数保持不变，用于保留预训练期间获得的通用知识。

添加适配矩阵：对于每个全连接层，添加低秩适配矩阵。例如，假设前馈网络中的第一层权重矩阵为 $W_{ff} \in \mathbb{R}^{d_{ff} \times d_{\text{model}}}$ ，则 LoRA 在这个矩阵上引入两个适配矩阵： $A_{ff} \in \mathbb{R}^{d_{ff} \times r}, \quad B_{ff} \in \mathbb{R}^{r \times d_{\text{model}}}$

权重变换与前向传播：在前向传播中，使用权重矩阵 $W_{ff}' = W_{ff} + A_{ff} B_{ff}$ 来代替原始的全连接层权重矩阵。这样，前馈网络的线性变换就不仅包含原始的预训练权重，还包含适配矩阵的贡献，用于更好地适应特定任务。

训练适配矩阵：在训练过程中，仅更新适配矩阵 $A_{ff}$ 和 $B_{ff}$ ，而冻结的原始权重 $W_{ff}$ 不变，这大大减少了训练中需要更新的参数数量。

LoRA 在 Transformer 中的整体优势

参数效率：在自注意力层和前馈网络中引入低秩适配矩阵，可以大大减少需要训练的参数数量，同时保留模型在大规模数据上学到的知识。

任务适应性：LoRA 的方法允许对每个特定任务引入单独的低秩适配矩阵，而保持预训练模型的核心不变，这使得同一个预训练模型可以高效地适应多种任务。

降低计算与存储开销：由于适配矩阵的秩 rrr 通常远小于模型的维度，LoRA 显著降低了训练和存储的开销，使得大模型在计算资源受限的情况下能够得到有效应用。

代码实现LoRA微调Bert的过程

import torch
import torch.nn as nn
import torch.optim as optim
from transformers import BertModel# 假设我们有一个预训练好的 Transformer 模型，例如 BERT
pretrained_model = BertModel.from_pretrained('bert-base-uncased')# 定义 LoRA 适配层
class LoRAAdapter(nn.Module):def __init__(self, input_dim, low_rank_dim):super(LoRAAdapter, self).__init__()self.A = nn.Linear(input_dim, low_rank_dim, bias=False)  # 低秩矩阵 Aself.B = nn.Linear(low_rank_dim, input_dim, bias=False)  # 低秩矩阵 Bdef forward(self, x):return self.B(self.A(x))  # 输出 B(A(x))# 定义一个新的 BERT 模型，包含 LoRA 适配器
class LoRABertModel(nn.Module):def __init__(self, pretrained_model, low_rank_dim):super(LoRABertModel, self).__init__()self.bert = pretrained_modelself.low_rank_dim = low_rank_dim# 为 BERT 的每一层添加 LoRA 适配器for layer in self.bert.encoder.layer:layer.attention.self.query_adapter = LoRAAdapter(layer.attention.self.query.in_features, low_rank_dim)layer.attention.self.key_adapter = LoRAAdapter(layer.attention.self.key.in_features, low_rank_dim)layer.attention.self.value_adapter = LoRAAdapter(layer.attention.self.value.in_features, low_rank_dim)# 冻结原始 BERT 模型的所有参数for param in self.bert.parameters():param.requires_grad = False# 只训练 LoRA 适配层for layer in self.bert.encoder.layer:for param in layer.attention.self.query_adapter.parameters():param.requires_grad = Truefor param in layer.attention.self.key_adapter.parameters():param.requires_grad = Truefor param in layer.attention.self.value_adapter.parameters():param.requires_grad = Truedef forward(self, input_ids, attention_mask=None, token_type_ids=None):# 对每一层应用 LoRA 适配器for layer in self.bert.encoder.layer:# 使用适配后的 Query、Key、Value 进行注意力计算query = layer.attention.self.query(input_ids) + layer.attention.self.query_adapter(input_ids)key = layer.attention.self.key(input_ids) + layer.attention.self.key_adapter(input_ids)value = layer.attention.self.value(input_ids) + layer.attention.self.value_adapter(input_ids)# 注意力计算attn_output, _ = layer.attention.self.attn(query, key, value)input_ids = attn_outputreturn self.bert(input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)# 创建包含 LoRA 适配器的 BERT 模型
low_rank_dim = 16
lora_bert = LoRABertModel(pretrained_model, low_rank_dim)# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(filter(lambda p: p.requires_grad, lora_bert.parameters()), lr=1e-4)# 生成一些随机数据用于训练
data = torch.randint(0, 30522, (8, 64))  # 随机输入数据，批量大小为 8，序列长度为 64
labels = torch.randint(0, 2, (8, 64))  # 随机标签# 训练循环
num_epochs = 5
for epoch in range(num_epochs):# 前向传播outputs = lora_bert(data).last_hidden_statelogits = outputs.view(-1, outputs.size(-1))labels = labels.view(-1)# 计算损失loss = criterion(logits, labels)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()# 打印损失值print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}")

利用LoRA对LLAMA2进行微调的代码

import torch
import torch.nn as nn
import torch.optim as optim
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from datasets import load_dataset# 1. 加载预训练的 LLaMA 2 7B 模型
model_name = "meta-llama/Llama-2-7b-hf"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)# 2. 手动添加 LoRA 适配器
class LoRAAdapter(nn.Module):def __init__(self, input_dim, low_rank_dim):super(LoRAAdapter, self).__init__()self.A = nn.Linear(input_dim, low_rank_dim, bias=False)  # 低秩矩阵 Aself.B = nn.Linear(low_rank_dim, input_dim, bias=False)  # 低秩矩阵 Bdef forward(self, x):return self.B(self.A(x))  # 输出 B(A(x))# 添加 LoRA 适配器到模型的注意力层
low_rank_dim = 16
for name, module in model.named_modules():if "attn" in name.lower() and hasattr(module, 'q_proj') and hasattr(module, 'k_proj') and hasattr(module, 'v_proj'):# 为 Query, Key, Value 添加 LoRA 适配器input_dim = module.q_proj.in_featuresmodule.q_proj_lora = LoRAAdapter(input_dim, low_rank_dim)module.k_proj_lora = LoRAAdapter(input_dim, low_rank_dim)module.v_proj_lora = LoRAAdapter(input_dim, low_rank_dim)# 使用 hooks 修改前向传播逻辑def hook_fn_forward_q(module, input, output):return output + module.q_proj_lora(input[0])def hook_fn_forward_k(module, input, output):return output + module.k_proj_lora(input[0])def hook_fn_forward_v(module, input, output):return output + module.v_proj_lora(input[0])module.q_proj.register_forward_hook(hook_fn_forward_q)module.k_proj.register_forward_hook(hook_fn_forward_k)module.v_proj.register_forward_hook(hook_fn_forward_v)# 3. 定义训练参数和优化器
training_args = TrainingArguments(output_dir="./llama2_7b_lora_finetuned",num_train_epochs=3,per_device_train_batch_size=4,gradient_accumulation_steps=8,learning_rate=1e-4,logging_dir="./logs",logging_steps=10,save_total_limit=2,fp16=True  # 采用混合精度加速训练
)optimizer = optim.AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-4)# 4. 加载训练数据集
train_dataset = load_dataset("daily_dialog", split="train")# 5. 定义 Trainer 对象
trainer = Trainer(model=model,args=training_args,train_dataset=train_dataset,tokenizer=tokenizer,optimizers=(optimizer, None)
)# 6. 开始训练
trainer.train()# 7. 验证和保存模型
trainer.evaluate()
model.save_pretrained("./llama2_7b_lora_finetuned")