从零学习大模型（七）-----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)  # 低秩矩阵 A
        self.B = nn.Linear(low_rank_dim, input_dim, bias=False)  # 低秩矩阵 B

    def 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_model
        self.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 = True
            for param in layer.attention.self.key_adapter.parameters():
                param.requires_grad = True
            for param in layer.attention.self.value_adapter.parameters():
                param.requires_grad = True

    def 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_output
        return 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_state
    logits = 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)  # 低秩矩阵 A
        self.B = nn.Linear(low_rank_dim, input_dim, bias=False)  # 低秩矩阵 B

    def 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')

秒客网