hugging face参数高效微调peft源码解析

已于 2023-07-19 09:08:33 修改
阅读量3.1k 收藏 30
点赞数 10
文章标签： 大模型微调 peft LoRA PrefixTuning PTuning
于 2023-07-09 11:07:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxx654/article/details/131620130
版权

大模型参数高效微调(PEFT) - 知乎

让天下没有难Tuning的大模型-PEFT技术简介 - 知乎

大模型参数高效微调技术原理综述（三）-P-Tuning、P-Tuning v2 - 知乎

你似乎来到了没有知识存在的荒原 - 知乎

大模型参数高效微调技术原理综述（六）-MAM Adapter、UniPELT - 知乎

GitHub - huggingface/peft: 🤗 PEFT: State-of-the-art Parameter-Efficient Fine-Tuning.

ChatGPT等大模型高效调参大法——PEFT库的算法简介 - 知乎

PEFT

PEFT：Parameter Efficient Fine-Tuning技术旨在通过最小化微调参数的数量和计算复杂度，来提高预训练模型在新任务上的性能，从而缓解大型预训练模型的训练成本。 

Prefix-Tuning（软提示/连续提示）

  1. 在每一层的token之前构造一段任务相关的tokens作为Prefix，训练时只更新Prefix部分的参数，而Transformer中的其他部分参数固定
  2. 一个Prefix模块就是一个可学习的id到embedding映射表，可以在多层分别添加Prefix模块
  3. 为了防止直接更新Prefix的参数导致训练不稳定的情况，在Prefix层前面加了MLP结构
  4. 作用阶段：所有transformer block的Attention注意力计算

Prompt-Tuning（软提示/连续提示）

  1. 可看做是Prefix-Tuning的简化版本，只在输入层加入prompt tokens，并不需要加入MLP进行调整
  2. 提出 Prompt Ensembling 方法来集成预训练语言模型的多种 prompts
  3. 在只额外对增加的3.6%参数规模（相比原来预训练模型的参数量）的情况下取得和Full-finetuning接近的效果
  4. 作用阶段：第一层transformer block的Attention注意力计算

P-Tuning（软提示/连续提示）

  1. P-Tuning只是在输入的时候加入Embedding，并通过LSTM+MLP对prompt embedding序列进行编码
  2. 根据人工设计模板动态确定prompt token的添加位置，可以放在开始，也可以放在中间
  3. 作用阶段：第一层transformer block的Attention注意力计算

P-Tuning V2（软提示/连续提示）

  1. 可看做是Prefix-Tuning的优化版本。在模型的每一层都添加连续的 prompts
  2. P-Tuning v2在不同规模和任务中都可与微调效果相媲美
  3. 移除重参数化的编码器（如：Prefix Tuning中的MLP、P-Tuning中的LSTM）、针对不同任务采用不同的提示长度、引入多任务学习等
  4. 作用阶段：所有transformer block的Attention注意力计算

Adapter（变体：AdapterFusion、AdapterDrop）

  1. 在Transformer Block中加入两层MLP，固定住原来预训练模型的参数不变，只对新增的Adapter结构进行微调
  2. 在只额外对增加的3.6%参数规模（相比原来预训练模型的参数量）的情况下取得和Full-finetuning接近的效果
  3. 作用阶段：Transformer Block主体

LoRA（变体：AdaLoRA、QLoRA）

  1. 在训练阶段，预训练参数W固定，只更新A和B参数，A和B模拟W的变化量。
  2. 在推理阶段，用A、B参数与原预训练参数相加替换原有预训练模型的参数。推理过程没有额外的参数量和计算量
  3. 相当于是用LoRA去模拟Full-finetune的过程，几乎不会带来效果损失
  4. 由于没有使用Prompt方式，避免了Prompt方法的一系列问题（Prompt的问题：难训练、序列长度受限、效果不如finetune），在推理阶段也没有引入额外的参数
  5. 作用阶段：Transformer Block主体query、value

BitFit

  1. 不需要对预训练模型做任何改动，只微调训练指定神经网络中的偏置Bias
  2. 参数量只有不到2%，但是效果可以接近全量参数
  3. 作用阶段：模型Backbone主体

PEFT方法总结

  1. 增加额外参数，如：Prefix Tuning、Prompt Tuning、Adapter Tuning及其变体
  2. 选取一部分参数更新，如：BitFit
  3. 引入重参数化，如：LoRA、AdaLoRA、QLoRA
  4. 混合高效微调，如：MAM Adapter、UniPELT

由于peft更在快速开发迭代中，代码变动可能会比较大，本文相关代码来自于peft的0.3.0版本。

        下面看一下hugging face peft开源代码中对于上述几种方法的实现。tuners目录下实现了PrefixTuning、PromptTuning、PTuning、Adapter、LoRA、AdaLoRA这些方法配置文件的构造、解析，新增训练参数模型的构造，各种PEFT方法配置文件类之间的继承关系，如下：

PeftConfig -> PromptLearningConfig -> (PrefixTuningConfig、PromptEncoderConfig、PromptTuningConfig)

PeftConfig -> LoraConfig -> AdaLoraConfig

PushToHubMixin -> PeftConfigMixin -> PeftConfig

        下面先看一下PrefixTuning、PromptTuning、PTuningV1模块的输入、输出情况：

Prefix-Tuning

PrefixEncoder(
  (embedding): Embedding(20, 18432)
)
在每一层transformer block的key和value的前面都加上virtual embedding，2 * layers * hidden = 2 * 12 * 768 = 18432，其中2就对应key和value 

from peft import PrefixEncoder, PrefixTuningConfig
import torch

config = PrefixTuningConfig(
    peft_type="PREFIX_TUNING",
    task_type="SEQ_2_SEQ_LM",
    num_virtual_tokens=20,
    token_dim=768,
    num_transformer_submodules=1,
    num_attention_heads=12,
    num_layers=12,
    encoder_hidden_size=768,
    prefix_projection=False
)
print(config)

# 初始化PrefixEncoder
prefix_encoder = PrefixEncoder(config)
print(prefix_encoder)

Prompt-Tuning

PromptEmbedding(
  (embedding): Embedding(20, 768)
)
只在输入层的原始序列上面添加prompt embedding 

from peft import PromptTuningConfig, PromptEmbedding
import torch

word_embedding = torch.nn.Embedding(num_embeddings=100, embedding_dim=768)
config = PromptTuningConfig(
    peft_type="PROMPT_TUNING",
    task_type="SEQ_2_SEQ_LM",
    num_virtual_tokens=20,
    token_dim=768,
    num_transformer_submodules=1,
    num_attention_heads=12,
    num_layers=12,
    # encoder_hidden_size=768
)
print(config)

# 初始化PromptEncoder
prompt_encoder = PromptEmbedding(config, word_embedding)
print(prompt_encoder)

PTuningV1

PromptEncoder(
  (embedding): Embedding(20, 768)
  (mlp_head): Sequential(
    (0): Linear(in_features=768, out_features=768, bias=True)
    (1): ReLU()
    (2): Linear(in_features=768, out_features=768, bias=True)
    (3): ReLU()
    (4): Linear(in_features=768, out_features=768, bias=True)
  )
)
只在输入层的原始序列上面添加prompt embedding，并且使用了MLP加强学习能力 

from peft import PromptEncoderConfig, PromptEncoder
import torch

config = PromptEncoderConfig(
    peft_type="PREFIX_TUNING",
    task_type="SEQ_2_SEQ_LM",
    num_virtual_tokens=20,
    token_dim=768,
    num_transformer_submodules=1,
    num_attention_heads=12,
    num_layers=12,
    encoder_hidden_size=768,
    # prefix_projection=False
)
print(config)

# 初始化PrefixEncoder
p_encoder = PromptEncoder(config)
print(p_encoder)

 PTuningV2

PrefixEncoder(
  (embedding): Embedding(20, 768)
  (transform): Sequential(
    (0): Linear(in_features=768, out_features=768, bias=True)
    (1): Tanh()
    (2): Linear(in_features=768, out_features=18432, bias=True)
  )
)
与PrefixTuning一样（实际上也是使用同一个类来实现的），在每一层transformer block的key和value的前面都加上virtual embedding，2 * layers * hidden = 2 * 12 * 768 = 18432，2对应的就是key和value 

from peft import PrefixEncoder, PrefixTuningConfig
import torch

config = PrefixTuningConfig(
    peft_type="PREFIX_TUNING",
    task_type="SEQ_2_SEQ_LM",
    num_virtual_tokens=20,
    token_dim=768,
    num_transformer_submodules=1,
    num_attention_heads=12,
    num_layers=12,
    encoder_hidden_size=768,
    prefix_projection=True
)
print(config)

# 初始化PrefixEncoder
prefix_encoder = PrefixEncoder(config)
print(prefix_encoder)

        PrefixTuning和PTuningV2在实现上基本上是一样的，其实就是一样的。下面是peft作者回复的关于PrefixTuning和PTuningV2在实现上的关系。

LoRA

from peft import LoraConfig, LoraModel, get_peft_model
from peft.tuners.lora import LoraLayer
import os
from transformers import AutoModelForSequenceClassification
from torch import nn
from typing import Any, List, Optional, Union

os.environ["HF_HOME"] = "./hf_downloads"


model_name_or_path = "bert-base-chinese"
tokenizer_name_or_path = "bert-base-chinese"

lora_config = LoraConfig(
    peft_type="LORA",
    task_type="SEQ_2_SEQ_LM",
    inference_mode=False,
    # 如果r=0，bias='all'，就变成了了BitFit微调方法
    r=8,
    lora_alpha=16,
    lora_dropout=0.1,
    fan_in_fan_out=False,
    # bias -> none 所有层的bias都不微调
    # bias -> all 所有层的bias都微调
    # bias -> lora_only 只有LoRA相关层的bias进行微调
    # bias 对应BitFit高效微调方法
    bias='lora_only'
)

model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path)
model = get_peft_model(model, lora_config)
print(model)

         打印出来的model结构中包含LoRA在query和value部分添加的权重参数：

PeftModelForSeq2SeqLM(
  (base_model): LoraModel(
    (model): BertForSequenceClassification(
      (bert): BertModel(
        (embeddings): BertEmbeddings(
          (word_embeddings): Embedding(21128, 768, padding_idx=0)
          (position_embeddings): Embedding(512, 768)
          (token_type_embeddings): Embedding(2, 768)
          (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (encoder): BertEncoder(
          (layer): ModuleList(
            (0-11): 12 x BertLayer(
              (attention): BertAttention(
                (self): BertSelfAttention(
                  (query): Linear(
                    in_features=768, out_features=768, bias=True
                    (lora_dropout): ModuleDict(
                      (default): Dropout(p=0.1, inplace=False)
                    )
                    (lora_A): ModuleDict(
                      (default): Linear(in_features=768, out_features=8, bias=False)
                    )
                    (lora_B): ModuleDict(
                      (default): Linear(in_features=8, out_features=768, bias=False)
                    )
                    (lora_embedding_A): ParameterDict()
                    (lora_embedding_B): ParameterDict()
                  )
                  (key): Linear(in_features=768, out_features=768, bias=True)
                  (value): Linear(
                    in_features=768, out_features=768, bias=True
                    (lora_dropout): ModuleDict(
                      (default): Dropout(p=0.1, inplace=False)
                    )
                    (lora_A): ModuleDict(
                      (default): Linear(in_features=768, out_features=8, bias=False)
                    )
                    (lora_B): ModuleDict(
                      (default): Linear(in_features=8, out_features=768, bias=False)
                    )
                    (lora_embedding_A): ParameterDict()
                    (lora_embedding_B): ParameterDict()
                  )
                  (dropout): Dropout(p=0.1, inplace=False)
                )
                (output): BertSelfOutput(
                  (dense): Linear(in_features=768, out_features=768, bias=True)
                  (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
                  (dropout): Dropout(p=0.1, inplace=False)
                )
              )
              (intermediate): BertIntermediate(
                (dense): Linear(in_features=768, out_features=3072, bias=True)
                (intermediate_act_fn): GELUActivation()
              )
              (output): BertOutput(
                (dense): Linear(in_features=3072, out_features=768, bias=True)
                (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
                (dropout): Dropout(p=0.1, inplace=False)
              )
            )
          )
        )
        (pooler): BertPooler(
          (dense): Linear(in_features=768, out_features=768, bias=True)
          (activation): Tanh()
        )
      )
      (dropout): Dropout(p=0.1, inplace=False)
      (classifier): Linear(in_features=768, out_features=2, bias=True)
    )
  )
)

        下面看一下模型里面的可训练参数有哪些，因为在LoraConfig中设置了bias参数为lora_only，所以所有lora层的bias参数也会被设置为可训练：

for name, param in model.named_parameters():
    if param.requires_grad:
        print(name)
base_model.model.bert.encoder.layer.0.attention.self.query.bias
base_model.model.bert.encoder.layer.0.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.0.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.0.attention.self.value.bias
base_model.model.bert.encoder.layer.0.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.0.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.1.attention.self.query.bias
base_model.model.bert.encoder.layer.1.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.1.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.1.attention.self.value.bias
base_model.model.bert.encoder.layer.1.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.1.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.2.attention.self.query.bias
base_model.model.bert.encoder.layer.2.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.2.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.2.attention.self.value.bias
base_model.model.bert.encoder.layer.2.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.2.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.3.attention.self.query.bias
base_model.model.bert.encoder.layer.3.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.3.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.3.attention.self.value.bias
base_model.model.bert.encoder.layer.3.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.3.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.4.attention.self.query.bias
base_model.model.bert.encoder.layer.4.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.4.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.4.attention.self.value.bias
base_model.model.bert.encoder.layer.4.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.4.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.5.attention.self.query.bias
base_model.model.bert.encoder.layer.5.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.5.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.5.attention.self.value.bias
base_model.model.bert.encoder.layer.5.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.5.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.6.attention.self.query.bias
base_model.model.bert.encoder.layer.6.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.6.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.6.attention.self.value.bias
base_model.model.bert.encoder.layer.6.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.6.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.7.attention.self.query.bias
base_model.model.bert.encoder.layer.7.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.7.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.7.attention.self.value.bias
base_model.model.bert.encoder.layer.7.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.7.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.8.attention.self.query.bias
base_model.model.bert.encoder.layer.8.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.8.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.8.attention.self.value.bias
base_model.model.bert.encoder.layer.8.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.8.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.9.attention.self.query.bias
base_model.model.bert.encoder.layer.9.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.9.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.9.attention.self.value.bias
base_model.model.bert.encoder.layer.9.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.9.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.10.attention.self.query.bias
base_model.model.bert.encoder.layer.10.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.10.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.10.attention.self.value.bias
base_model.model.bert.encoder.layer.10.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.10.attention.self.value.lora_B.default.weight
base_model.model.bert.encoder.layer.11.attention.self.query.bias
base_model.model.bert.encoder.layer.11.attention.self.query.lora_A.default.weight
base_model.model.bert.encoder.layer.11.attention.self.query.lora_B.default.weight
base_model.model.bert.encoder.layer.11.attention.self.value.bias
base_model.model.bert.encoder.layer.11.attention.self.value.lora_A.default.weight
base_model.model.bert.encoder.layer.11.attention.self.value.lora_B.default.weight

        下面将LoRA参数合并到预训练参数中，合并之后的模型和原始预训练模型一模一样：

merged_model = model.merge_and_unload()
print(merged_model)
BertForSequenceClassification(
  (bert): BertModel(
    (embeddings): BertEmbeddings(
      (word_embeddings): Embedding(21128, 768, padding_idx=0)
      (position_embeddings): Embedding(512, 768)
      (token_type_embeddings): Embedding(2, 768)
      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
      (dropout): Dropout(p=0.1, inplace=False)
    )
    (encoder): BertEncoder(
      (layer): ModuleList(
        (0-11): 12 x BertLayer(
          (attention): BertAttention(
            (self): BertSelfAttention(
              (query): Linear(in_features=768, out_features=768, bias=True)
              (key): Linear(in_features=768, out_features=768, bias=True)
              (value): Linear(in_features=768, out_features=768, bias=True)
              (dropout): Dropout(p=0.1, inplace=False)
            )
            (output): BertSelfOutput(
              (dense): Linear(in_features=768, out_features=768, bias=True)
              (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
              (dropout): Dropout(p=0.1, inplace=False)
            )
          )
          (intermediate): BertIntermediate(
            (dense): Linear(in_features=768, out_features=3072, bias=True)
            (intermediate_act_fn): GELUActivation()
          )
          (output): BertOutput(
            (dense): Linear(in_features=3072, out_features=768, bias=True)
            (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
      )
    )
    (pooler): BertPooler(
      (dense): Linear(in_features=768, out_features=768, bias=True)
      (activation): Tanh()
    )
  )
  (dropout): Dropout(p=0.1, inplace=False)
  (classifier): Linear(in_features=768, out_features=2, bias=True)
)

        下面以peft_model.py文件中PeftModelForSequenceClassification的forward函数实现为例，看一下在推理阶段如何对于PrefixTuning、PromptTuning、PTuningV1、PTuningV2、Adapter、LoRA进行操作。

        1、首先通过配置文件的所继承的父类类型来判断PEFT方法是否属于Prompt相关的，如果不是，就表示使用的是Adapter、LoRA等方法，直接执行推理。LoRA的具体推理计算过程后面再补充

        2、如果通过配置文件的所继承的父类类型判断PEFT方法属于Prompt相关的，因为要在transformer block的序列开始位置添加虚拟token的embedding，所以也要补全attention mask

        3、通过配置文件的类型来判断PEFT方法到底是PrefixTuning/PTuningV2，还是PromptTuning/PTuningV1。如果是PromptTuning/PTuningV1，则将虚拟token的embedding直接concat到原始输入序列的前面，送入base model模型进行推理。如果是PrefixTuning/PTuningV2，由于涉及到给每一个transformer block的key和value添加虚拟token的embedding，还需要使用_prefix_tuning_forward函数进行额外的处理。

PromptTuning/PTuningV1源码

        PromptTuning和PTuningV1的共同点都是使用了浅层的Prompt，只在输入层使用。所以PromptTuning和PTuningV1在使用时的方式基本相同。

        PromptTuning的源码详见src/peft/tuners/prompt_tuning.py，里面包含了相关的配置项以及Encoder的创建过程。

        PTuningV1的源码详见src/peft/tuners/p_tuning.py，里面包含了相关的配置项以及Encoder的创建过程。

        PromptTuning/PTuningV1的推理过程就是将虚拟token的embedding直接concat到原始输入序列的前面，并对attention mask进行扩充，送入base model模型进行推理。对应上面讲到的2和3。

PrefixTuning/PTuningV2源码

        PrefixTuning和PTuningV2的共同点都是使用了深层的Prompt，在每层Transformer Block都使用，所以PrefixTuning和PTuningV2的实现放在一起。

        上面说到当执行的PEFT类型是PrefixTuning/PTuningV2时，由于要给每个Transformer Block的Key和Value前面都加上可以学习的virtual token embedding，需要使用_prefix_tuning_forward函数进行额外的处理。

        在看_prefix_tuning_forward函数之前先了解一些相关知识。自然语言处理任务可以分为Auto-Encoding（也叫NLU、自然语言理解、Masked Language Model）和Auto-Regressive（也叫NLG、自然语言生成、Language Model）。对于Auto-Encoding类型的任务，在模型的训练和预测阶段，self-attention都可以并行计算。对于Auto-Regressive类型的任务，在模型训练阶段通过使用attention mask也能够进行并行计算，但是在模型预测阶段，由于是时序生成任务，只能一步一步的生成，没办法并行。我们来看一下在生成阶段每个时间步有哪些计算：

        时间步t：

        Query：来自前一个时间步t-1时刻的输出，使用query矩阵（就是一个全连接层）转换之后得到

        Key：来自前t-1个时间步[1,……,t-1]的输出，使用key矩阵（就是一个全连接层）转换之后得到

        Value：来自前t-1个时间步[1,……,t-1]的输出，使用value矩阵（就是一个全连接层）转换之后得到

        时间步t + 1：

        Query：来自前一个时间步t时刻的输出，使用query矩阵（就是一个全连接层）转换之后得到

        Key：来自前t个时间步[1,……,t-1,t]的输出，使用key矩阵（就是一个全连接层）转换之后得到

        Value：来自前t个时间步[1,……,t-1,t]的输出，使用value矩阵（就是一个全连接层）转换之后得到

        可以看到，每个时间步的Query都和上一个时间步的输出相关，每一步都需要重新计算Query，但是key和value来自前t-1个时间步的输出相关，所以t+1时刻的key和value与t时刻的key和value在[1,……,t-1]时刻上的计算结果是相同的，也就是这些结果是可以复用的，在每个时刻可以复用前一时刻计算的key和value，然后追加上当前时刻新增的key和value，构成完整的key和value。

        在hugging face实现的self-attention模块中，为了复用decode生成阶段的key和value，会传入一个past_key_values参数，如果past_key_values不是None，表示前面时间步已经有计算结果了，直接复用上一步的结果，然后将当前时间步的key和value拼接上去，更新后的past_key_values将继续传递到下一个时间步。

        有了上面的背景知识，对于_prefix_tuning_forward函数中关于PrefixTuning/PTuningV2方法的实现就很好理解了，就是将生成的virtual token embedding通过past_key_values参数带入到transformer block的每一层，放在每一层key和value的前面。

LoRA源码

        LoRA算法的主要流程可以分为以下几步：

  1. 根据LoraConfig中的target_module参数在base model中找到需要进行Lora操作的module
  2. 为找到的target module添加Lora相关参数，将进行Lora操作之后的module封装成LoraLayer层，然后使用Lora后的新module替换掉base model中老的module。
  3. 在训练阶段，将新添加的Lora参数和bias参数（如果bias设置为all或者lora_only的话）设置为可训练的，requires_grad=True，其余预训练参数都冻结
  4. 在推理阶段，将所有参数设置为requires_grad=False，并将做了Lora操作的层进行参数融合，将新添加的Lora参数融合到预训练参数中

        上述这些流程在add_adapter函数中进行串联起来：

    def add_adapter(self, adapter_name, config=None):
        if config is not None:
            # 基于model config更新lora config，主要补充的是target_module参数
            model_config = self.model.config.to_dict() if hasattr(self.model.config, "to_dict") else self.model.config
            config = self._prepare_lora_config(config, model_config)
            self.peft_config[adapter_name] = config
        # 根据target module参数，在base model中寻找并更新目标模块，将lora相关内容更新到模型架构中
        self._find_and_replace(adapter_name)
        if len(self.peft_config) > 1 and self.peft_config[adapter_name].bias != "none":
            raise ValueError(
                "LoraModel supports only 1 adapter with bias. When using multiple adapters, set bias to 'none' for all adapters."
            )
        # 设置只有lora相关的参数可以微调，冻结其他参数
        mark_only_lora_as_trainable(self.model, self.peft_config[adapter_name].bias)
        if self.peft_config[adapter_name].inference_mode:
            # 在推理模式下冻结所有参数
            _freeze_adapter(self.model, adapter_name)

基于上述流程，Lora源码主要包括以下大的模块（类）：

1、LoraConfig：Lora配置文件

        a)、LoraConfig中记录Lora相关的配置参数，其中重点看一下target_module、bias、modules_to_save这几个参数。

        b)、target_module参数用来指出base model中叫什么名字的参数需要执行Lora操作，在other.py中TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING列出了每个模型中需要进行Lora操作的参数名称。

        c)、bias对应的就是BitFit参数微调方法，就是在微调时是否微调bias参数：

# bias -> none 所有层的bias都不微调
# bias -> all 所有层的bias都微调
# bias -> lora_only 只有LoRA相关层的bias进行微调

        modules_to_save用来存放哪些模型参数是重新训练过的，保存模型的时候可以只保存这些参数，其他的都是预训练参数，可以不保存。

2、LoraLayer：用于记录Lora相关参数，初始化Lora部分的模型。在LoraLayer部分目前仅支持两种子模型的Lora操作，分别是nn.Embedding和nn.Linear（Conv1D等价于nn.Linear），下面看一下这部分主要的三个类：

        a)、LoraLayer：LoraLayer中实现了在Linear层中添加Lora操作的方法update_layer和在Embedding层中添加Lora操作的update_layer_embedding方法，这两个方法中根据原始参数形状初始化了Lora参数，分别在子类Linear和子类Embedding中调用。

        b)、Linear：Linear层继承nn.Linear和LoraLayer，实现了在nn.Linear层和Conv1D层（hugging face的transformers中实现）中使用Lora。使用nn.Linear创建和原始参数相同形状的参数，后面用来存储预训练的参数部分，使用LoraLayer的update_layer函数创建Lora新增的参数部分，这样就将一个Linear子模块改造成了添加了Lora的子模块。Linear层中还实现了merge和unmerge函数用来将Lora参数合入原始Linear层的预训练参数中，或者将Lora参数从原始Linear层的参数中分离出来。

        c)、Embedding：Embedding层继承nn.Embedding和LoraLayer，与Linear的实现几乎一样，Embedding也是创建了和原始Embedding参数相同形状的参数，后面用来存储预训练的参数部分，使用update_layer_embedding函数创建Lora新增的参数部分，这样就将一个Embedding子模块改造成了添加了Lora的子模块。Embedding层中也实现了merge和unmerge函数用来将Lora参数合入原始Embedding层的预训练参数中，或者将Lora参数从原始Embedding层的参数中分离出来。

3、LoraModel：基于上述组件，LoraModel可以拆解为以下部分：

        a)、遍历base model的所有子module，根据LoraConfig中的target_module参数找到需要进行Lora操作的module，在LoraModel的_find_and_replace函数中实现

        b)、基于上一步找到的target module，找到其父模块parent，并为找到的target module添加Lora相关参数，将进行Lora操作之后的module封装成LoraLayer层

备注：当前PEFT版本中支持进行Lora的层只有nn.Linear、nn.Embedding和Conv1D（来自hugging face的transformers库，实际上就是一个weight做了转置的nn.Linear层）。根据重参数化Reparameterization的思想（重参数化详见RepVGG），卷积操作也可以使用Lora，peft-main分支里面已经正在开发这个功能了。

        c)、根据找到的target module的父模块，使用Lora后的新module替换掉base model中对应的老的module，在_replace_module函数中实现

        d)、在训练阶段，将新添加的Lora参数和bias参数（如果bias设置为all或者lora_only的话）设置为可训练的，requires_grad=True，其余预训练参数都冻结

        e)、在推理阶段，将所有参数设置为requires_grad=False，并将做了Lora操作的层进行参数融合，将新添加的Lora参数融合到预训练参数中

胖胖大海
关注
  • 10
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
LLM-微调：Peft库--get_peft_model()--＞在llm基座模型的基础上注入Lora模块（加载流程）【注入的Lora模块的初始参数是随机初始化的】
u013250861的博客
10-22 1104
【代码】LLM-微调：Peft库--get_peft_model()函数【在llm基座模型的基础上加载Lora模块（Lora模块的初始参数是随机初始化的）】
Transformers源码解析/Hugging Face实战/NLP实战//预训练模型/分词器
07-12
你只需要知道，到了今天在NLP领域的所有任务，都可以用Transformer结合Hugging Face去玩就行了。 2012年的word2vec到现在除了科研机构，已经完全不需要使用了。绝大多数的算法工程师和科研人员都没有机会去参与词...
ChatGLM的模型架构
跨过一座座山
06-08 4394
ChatGLM的部署微调等，很多资料，不再赘述。
大模型里prefix-decoder、casual-decoder、encoder-decoder区别
锴笑口常开的博客
04-28 992
Prefix Decoder在训练时可能更关注于从输入到输出的映射，因此损失函数。
几种预训练模型微调方法和peft包的使用介绍
Yangchenju的博客
10-11 2149
Adapter 方法不需要微调预训练模型的全部参数，通过引入少量针对特定任务的参数，来存储有关该任务的知识，降低对模型微调的算力要求。具体的，给每个任务定义 Prompt，拼接到数据上作为输入，同时 freeze 预训练模型进行训练，在没有加额外层的情况下，可以看到随着模型体积增大效果越来越好，最终追上了精调的效果。PEFT（Parameter-Efficient Fine-Tuning，参数高效微调），是一个用于在不微调所有模型参数的情况下，高效地将预训练语言模型（PLM）适应到各种下游应用的库。
大模型训练之微调篇
人工智能讲师分享前沿技术
05-14 1014
介绍了大模型训练的微调方法，包括prompt tuning、prefix tuning、LoRA、p-tuning和AdaLoRA等。介绍了使用deepspeed和LoRA进行大模型训练的相关代码。给出了petals的介绍，它可以将模型划分为多个块，每个用户的机器负责其中一块，分摊了计算压力。
大模型参数高效微调技术实战（四）-Prefix Tuning / P-Tuning v2
人工智能曾小健
08-07 737
本文对 Prefix Tuning / P-Tuning v2 的基本原理进行了简述；同时，讲解了使用 Prefix Tuning / P-Tuning v2 技术进行模型训练及推理。下文将对 LoRA 微调技术进行实战讲解。
大模型参数高效微调 (PEFT) 浅析
胭脂草的ABC博客
03-26 522
以上这些 PEFT 方法，都是在原来模型参数之外，添加不到原参数量 1% 的参数。在这些新添加的参数上做微调，很多时候就可以媲美全参数微调了。以我个人经验来说，LoRA 和 QLoRA 是现在比较常用的，库也很好地支持了这两种方法。像是 Adapter 以及基于 pseudo soft prompt 的一些方法比较少会用到。【一家之言，欢迎评论区交流】一些论文几篇博文解密Prompt系列3. 冻结LM微调Prompt: Prefix-Tuning & Prompt-Tuning & P-Tuning。
window hugging face cuda环境包
最新发布
05-28
适用于win平台上运行transformers的cuda环境
Hugging-Face:拥抱脸笔记本
03-17
总的来说，Hugging Face的拥抱脸笔记本结合了Jupyter Notebook的强大交互性，与Hugging Face平台的丰富资源，为NLP开发提供了一个高效且易用的工作环境。无论是初学者还是经验丰富的开发者，都能从中受益，快速实现...
notebooks:使用Hugging Face库的笔记本:hugging_face:
03-21
标题中的“notebooks:使用Hugging Face库的笔记本:hugging_face:”表明这是一个关于使用Hugging Face库在Jupyter Notebook环境中进行...通过这些教程，用户可以学习到如何高效地利用Hugging Face库提升自己的NLP项目。
Python本地离线运行机器翻译代码示例 基于Hugging Face
08-14
# Python本地离线运行机器翻译代码示例 基于Hugging Face 本项目演示了如何调用Hugging Face的大模型实现本地离线实现机器翻译，Python代码简洁易懂，方便上手，能够快速实现强大的离线翻译功能。 使用方法： 1. ...
peft代码解读:Prefix Tuning/LoRA/P-Tuning/Prompt Tuning
weixin_36378508的博客
06-28 2361
peft
大模型微调之P-tuning方法解析
热门推荐
qq_41771998的博客
04-04 1万+
Bert时代，我们常做预训练模型微调（Fine-tuning），即根据不同下游任务，引入各种辅助任务loss和垂直领域数据，将其添加到预训练模型中，以便让模型更加适配下游任务的方式。每个下游任务都存下整个预训练模型的副本，并且推理必须在单独的批次中执行。那么能不能将所有自然语言处理的任务转换为语言模型任务？就是所有任务都可以被统一建模，任务描述与任务输入视为语言模型的历史上下文，而输出则为语言模型需要预测的未来信息。
知识图谱：【知识图谱问答KBQA（六）】——P-tuning V2训练代码解析
u013010473的博客
02-18 2727
文章目录一.arguments.pyDataTrainingArguments类ModelArguments类QuestionAnwseringArguments类get_args()函数二.run.pyStep 1. 获取所有参数Step 2. 根据任务名称选择导入对应的get_trainerStep 3. 将参数args传入get_trainer,得到trainer1）根据模型名称或路径加载tokenizer2）根据tokenizer和参数data_args、training_args加载数据集data
Hugging Face PEFT 调优实战附代码
sinat_39483965的博客
05-22 2184
Hugging Face PEFT调优实战附代码
huggingface - PEFT.参数效率微调
人工智能曾小健
06-21 1078
我们可以观察到，只有参数可训练，我们实现的性能 (F1 0.777) 可与完全微调 (F1 0.786) 相媲美（没有任何 hyerparam 调整运行以提取更多性能），并且此检查点仅为. 现在，如果有这样的数据集，只需为每个数据集一个这些 PEFT 模型，并节省大量存储空间，而不必担心骨干/基础模型的灾难性遗忘或过度拟合问题。需要注意的一点是，我们并没有尝试通过使用输入指令模板、LoRA 超参数和其他与训练相关的超参数来压缩性能。使用具有 CPU 卸载的 DeepSpeed 的 PEFT-LoRA。
比较Causal decoder、Prefix decoder和encoder-decoder
发现问题，并解决问题，批判性思维
05-17 6802
码器-解码器（encoder-decoder）：传统 Transformer 模型是建立在编码器-解码器架构上的 ，由两个 Transformer 块分别作为编码器和解码器。编码器采用堆叠的多头自注意层对输入序列进行编码以生成其潜在表示，而解码器对这些表示进行交叉注意并自回归地生成目标序列。目前，只有少数大语言模型是基于编码器-解码器架构构建的例如 Flan-T5。 因果解码器（causal decoder）：因果解码器架构采用单向注意力掩码，以确保每个输入标记只能关注过去的标记和它本身。输入和输出标记通过
大模型LLM相关面试题整理-PEFT
weixin_36378508的博客
10-17 1158
PEFT（Performance Estimation and Modeling for Fine-Tuning）是一种用于微调任务的性能估计和建模方法。它的目的是帮助研究人员和从业者在微调过程中更好地理解和预测模型的性能，并进行更有效的模型选择和调优。PEFT的主要思想是通过预测模型在微调任务上的性能，提供对不同模型和参数设置的性能估计。这样可以避免在大规模数据集上进行昂贵的微调实验，从而节省时间和计算资源。数据采样：从原始数据集中采样一小部分数据用于性能估计。
hugging face
09-10
Hugging Face是一个开源的自然语言处理（NLP）模型和数据集库。它提供了各种预训练模型和数据集，可以帮助开发者在NLP任务中快速构建和训练模型。 Hugging Face提供了Transformer类库，其中包含了各种预训练的NLP模型，如BERT、GPT等。这些模型可以用来进行文本分类、命名实体识别、问答系统等各种NLP任务。 此外，Hugging Face还提供了Datasets类库，其中包含了各种常用的NLP数据集，如IMDB电影评论、新闻分类等。开发者可以使用这些数据集来进行模型训练和评估。 除了提供现成的模型和数据集，Hugging Face还支持迁移学习。当Hugging Face提供的预训练模型不能满足需求时，开发者可以使用这些模型作为基础，在自己的数据集上进行微调训练，以适应特定的NLP任务。 要使用Hugging Face进行迁移学习，首先需要访问Hugging Face Datasets页面，选择合适的数据集。这些数据集可以根据标签或名称进行筛选。 总之，Hugging Face是一个强大的NLP工具库，提供了丰富的预训练模型和数据集，可以帮助开发者更高效地开展自然语言处理任务。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值