13 对话大模型微调IA3

汀沿河

已于 2024-09-02 18:26:49 修改

阅读量646

点赞数 25

分类专栏： # 9transformers 文章标签：深度学习人工智能

于 2024-08-31 15:17:03 首次发布

本文链接：https://blog.csdn.net/qq_28611929/article/details/141752442

版权

9transformers 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

1 算法思想

IA3（论文：Few-Shot Parameter-Efficient Fine-Tuning is Better and Cheaper than In-Context Learning），通过学习向量来对激活层加权进行缩放，从而获得更强的性能，同时仅引入相对少量的新参数，如下图左边所示，它的诞生背景是为了改进 LoRA。

与 LoRA 类似，IA3 具有许多相同的优点：

IA3 通过大幅减少可训练参数的数量，使微调更加高效。对于 T0 模型，使用 IA3 只有大约 0.01% 的可训练参数，而使用 LoRA 有 > 0.1% 的可训练参数。
原始的预训练权重保持冻结状态，这意味着您可以拥有多个轻量级、便携式 IA3 模型，用于在其之上构建的各种下游任务。
使用 IA3 微调的模型的性能与完全微调的模型的性能相当。
IA3 不会增加任何推理延迟，因为适配器（adapter）权重可以与基础模型合并。

2 参数

peft_config = IA3Config(task_type=TaskType.CAUSAL_LM,
                        target_modules=["query_key_value", "mlp.dense_4h_to_h"],
                        inference_mode=False, 
                        feedforward_modules=["mlp.dense_4h_to_h"])

参数说明：

task_type：指定任务类型。如：条件生成任务（SEQ_2_SEQ_LM），因果语言建模（CAUSAL_LM）等。
inference_mode：是否在推理模式下使用Peft模型。
module_to_save：这些模块通常是模型中的关键组件，除了 IA3 层之外要设置为可训练并保存在最终检查点中的模块列表。这些通常包括模型的自定义头（head），该头是为微调任务随机初始化的。例如，在序列分类或Token分类任务中，最后一层classifier/score是随机初始化的，因此需要可训练和保存。
feedforward_modules：指定前馈网络（Feed-Forward Network）中的哪些模块应用 IA3 方法。target_modules 中被视为前馈（feedforward）层的模块名称列表或模块名称的正则表达式。虽然学习向量与注意力块的输出激活相乘，但向量与经典前馈层的输入相乘。在 PEFT 中支持的模型中默认的前馈层模块名如下所示：

TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING = {
    "t5": ["wo"],
    "mt5": [],
    "gpt2": ["mlp.c_proj"],
    "bloom": ["mlp.dense_4h_to_h"],
    "roberta": ["output.dense"],
    "opt": ["fc2"],
    "gptj": ["fc_out"],
    "gpt_neox": ["dense_4h_to_h"],
    "gpt_neo": ["c_proj"],
    "bart": ["fc2"],
    "gpt_bigcode": ["mlp.c_proj"],
    "llama": ["down_proj"],
    "bert": ["output.dense"],
    "deberta-v2": ["output.dense"],
    "deberta": ["output.dense"],
}

target_modules：指定要在哪些模块中应用 IA3 方法。要替换为 IA3 的模块名称列表或模块名称的正则表达式，例如，注意力块。在 PEFT 中支持的模型中默认的模块名如下所示：

TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING = {
    "t5": ["k", "v", "wo"],
    "mt5": ["k", "v", "wi_1"],
    "gpt2": ["c_attn", "mlp.c_proj"],
    "bloom": ["query_key_value", "mlp.dense_4h_to_h"],
    "roberta": ["key", "value", "output.dense"],
    "opt": ["q_proj", "k_proj", "fc2"],
    "gptj": ["q_proj", "v_proj", "fc_out"],
    "gpt_neox": ["query_key_value", "dense_4h_to_h"],
    "gpt_neo": ["q_proj", "v_proj", "c_proj"],
    "bart": ["q_proj", "v_proj", "fc2"],
    "gpt_bigcode": ["c_attn", "mlp.c_proj"],
    "llama": ["k_proj", "v_proj", "down_proj"],
    "bert": ["key", "value", "output.dense"],
    "deberta-v2": ["key_proj", "value_proj", "output.dense"],
    "deberta": ["in_proj", "output.dense"],
}

2 代码

版本：

依赖	版本
transformers	'4.44.2'
accelerate	'0.29.0'
torch	'1.13.1+cu117'
peft	'0.12.0'

target_modules参数：

'.*\.1.*query_key_value'

model：下图中ia3_l就是添加的微调层；

可调参数占比：

trainable params: 344,064 || all params: 1,303,455,744 || trainable%: 0.0264

from datasets import Dataset
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForSeq2Seq, TrainingArguments, Trainer

ds = Dataset.load_from_disk("../data/")
tokenizer = AutoTokenizer.from_pretrained("../bloom-model/")
def process_func(example):
    MAX_LENGTH = 256
    input_ids, attention_mask, labels = [], [], []
    instruction = tokenizer("\n".join(["Human: " + example["instruction"], example["input"]]).strip() + "\n\nAssistant: ")
    response = tokenizer(example["output"] + tokenizer.eos_token)
    input_ids = instruction["input_ids"] + response["input_ids"]
    attention_mask = instruction["attention_mask"] + response["attention_mask"]
    labels = [-100] * len(instruction["input_ids"]) + response["input_ids"]
    if len(input_ids) > MAX_LENGTH:
        input_ids = input_ids[:MAX_LENGTH]
        attention_mask = attention_mask[:MAX_LENGTH]
        labels = labels[:MAX_LENGTH]
    return {
        "input_ids": input_ids,
        "attention_mask": attention_mask,
        "labels": labels
    }

tokenized_ds = ds.map(process_func, remove_columns=ds.column_names)

from transformers import DataCollatorWithPadding
from transformers.trainer_callback import TrainerCallback
import matplotlib.pyplot as plt

from peft import LoraConfig, TaskType, get_peft_model,IA3Config

# config = LoraConfig(task_type=TaskType.CAUSAL_LM, 
#                     target_modules=".*\.1.*query_key_value", 
#                     modules_to_save=["word_embeddings"])

config = IA3Config(task_type=TaskType.CAUSAL_LM)
config

# 自定义回调类，用于在训练过程中打印损失
model = AutoModelForCausalLM.from_pretrained("../bloom-model/")
model = get_peft_model(model, config)
print(model.print_trainable_parameters())


class PrintLossCallback(TrainerCallback):
    
    def __init__(self):
        self.losses = []
        self.steps = []

    def on_log(self, args, state, control, logs=None, **kwargs):
        # 打印训练过程中的日志信息
        try:
            if logs is not None:
                print(f"Step {state.global_step}: Loss={logs['loss']:.4f}, Learning Rate={logs['learning_rate']:.6f}")
                self.losses.append(logs['loss'])
                self.steps.append(state.global_step)

        except Exception as e :
            print(f'on_log error {e}')
    
    def plot_losses(self):
        plt.figure(figsize=(10, 5))
        plt.plot(self.steps, self.losses, label='Training Loss')
        plt.xlabel('Steps')
        plt.ylabel('Loss')
        plt.title('Training Loss Over Time')
        plt.legend()
        plt.show()
        

args = TrainingArguments(
    output_dir="./chatbot_ptune",
    per_device_train_batch_size=8,
    gradient_accumulation_steps=8,
    logging_steps=10,
    num_train_epochs=1,
    save_steps=1000,
    learning_rate=4e-5
)
plot_losses_callback = PrintLossCallback()
trainer = Trainer(
    model=model,
    args=args,
    tokenizer=tokenizer,
    train_dataset=tokenized_ds,
    data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, padding=True),
    callbacks=[plot_losses_callback]  # 注册自定义回调
)



if torch.cuda.is_available():
    trainer.model = trainer.model.to("cuda")
# 训练模型
trainer.train()

模型没有收敛！调整一下参数，终于收敛了。错误不可怕，积累经验！效果对比之前的微调方法，感觉还行！

args = TrainingArguments(
output_dir="./chatbot_ptune",
per_device_train_batch_size=8,
gradient_accumulation_steps=8,
logging_steps=10,
num_train_epochs=1,
save_steps=1000,
learning_rate=3e-3,
optim='adamw_torch'
)