大模型微调---Lora微调实战

一、前言

LoRA是一种参数高效的微调技术，通过低秩转换对大型语言模型进行适应性更新，减少了权重矩阵的更新成本。它通过学习低秩矩阵来调整权重，以适应特定任务，同时保持计算效率。
在这里插入图片描述
大模型都是过参数化的，当用于特定任务时，其实只有一小部分参数起主要作用。也就是参数矩阵维度很高，但可以用低维矩阵分解近似。

具体做法是，在网络中增加一个旁路结构，旁路是A和B两个矩阵相乘。 A矩阵的维度是[d,r], B 矩阵的维度是[r,d], 其中r<<d, 一般r取1，2，4，8就够了。那么这个旁路的参数量将远远小于原来网络的参数W。LoRA训练时，我们冻结原来网络的参数W, 只训练旁路参数A和B。由于A和B的参数量远远小于W, 那么训练时需要的显存开销就大约等于推理时的开销。

LoRA微调并没有改变原有的预训练参数，只是针对特定任务微调出了新的少量参数，新的这些参数要与原有的预训练参数配合使用（实际使用时，都是把旁路的参数和原来的参数直接合并，也就是参数相加，这样就完全不会增加推理时间）。

二、LoRA实战

我们使用huggingface的 pert库来简单使用LoRA

预训练模型与分词模型——Qwen/Qwen2.5-0.5B-Instruct
数据集——lyuricky/alpaca_data_zh_51k

2.1、下载模型到本地

# 下载数据集
dataset_file = load_dataset("lyuricky/alpaca_data_zh_51k", split="train", cache_dir="./data/alpaca_data")
ds = load_dataset("./data/alpaca_data", split="train")

# 下载分词模型
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
# Save the tokenizer to a local directory
tokenizer.save_pretrained("./local_tokenizer_model")

#下载与训练模型
model = AutoModelForCausalLM.from_pretrained(
    pretrained_model_name_or_path="Qwen/Qwen2.5-0.5B-Instruct",  # 下载模型的路径
    torch_dtype="auto",
    low_cpu_mem_usage=True,
    cache_dir="./local_model_cache"  # 指定本地缓存目录
)

2.2、加载模型与数据集

#加载分词模型
tokenizer_model = AutoTokenizer.from_pretrained("../local_tokenizer_model")

# 加载数据集
ds = load_dataset("../data/alpaca_data", split="train[:10%]")

# 记载模型
model = AutoModelForCausalLM.from_pretrained(
    pretrained_model_name_or_path="../local_llm_model/models--Qwen--Qwen2.5-0.5B-Instruct/snapshots/7ae557604adf67be50417f59c2c2f167def9a775",
    torch_dtype="auto",
    device_map="cuda:0")

2.3、处理数据

"""
并将其转换成适合用于模型训练的输入格式。具体来说，
它将原始的输入数据（如用户指令、用户输入、助手输出等）转换为模型所需的格式，
包括 input_ids、attention_mask 和 labels。
"""
def process_func(example, tokenizer=tokenizer_model):
    MAX_LENGTH = 256
    input_ids, attention_mask, labels = [], [], []
    instruction = tokenizer("\n".join(["Human: " + example["instruction"], example["input"]]).strip() + "\n\nAssistant: ")
    if example["output"] is not None:
        response = tokenizer(example["output"] + tokenizer.eos_token)
    else:
        return
    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)

在这里插入图片描述

2.4、LoRA微调

这里我们只要配置一下就可以使用LoRA，

# lora
config = LoraConfig(task_type=TaskType.CAUSAL_LM,target_modules= ['q_proj', 'k_proj','v_proj'])

target_modules这个参数指定了要应用 LoRA技术的模块。这些模块通常是模型中用于计算注意力权重的部分，

加载peft配置

peft_model = get_peft_model(model, config)

print(peft_model.print_trainable_parameters())

在这里插入图片描述

可以看到要训练的模型相比较原来的全量模型要少很多

2.5、训练参数配置

# 配置模型参数
args = TrainingArguments(
    output_dir="chatbot",   # 训练模型的输出目录
    per_device_train_batch_size=1,
    gradient_accumulation_steps=4,
    logging_steps=10,
    num_train_epochs=1,
)

2.6、开始训练

# 创建训练器
trainer = Trainer(
    args=args,
    model=model,
    train_dataset=tokenized_ds,
    data_collator=DataCollatorForSeq2Seq(tokenizer_model, padding=True )
)
# 开始训练
trainer.train()

可以看到，损失有所下降
在这里插入图片描述

三、模型评估

加载基础模型输出对比测试

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
tokenizer_model = AutoTokenizer.from_pretrained("../../local_tokenizer_model")
base_model = AutoModelForCausalLM.from_pretrained(
    "../../local_llm_model/models--Qwen--Qwen2.5-0.5B-Instruct/snapshots/7ae557604adf67be50417f59c2c2f167def9a775", low_cpu_mem_usage=True)

# 构建prompt
ipt = "Human: {}\n{}".format("我们如何在日常生活中减少用水？", "").strip() + "\n\nAssistant: "
pipe = pipeline("text-generation", model=base_model , tokenizer=tokenizer_model)
output = pipe(ipt, max_length=256, do_sample=False, truncation=True)
print(output)

输出结果
输出结果：

加载基础模型和LoRA模型进行合并，输出测试

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline

#  基础模型
model = AutoModelForCausalLM.from_pretrained(
    "../../local_llm_model/models--Qwen--Qwen2.5-0.5B-Instruct/snapshots/7ae557604adf67be50417f59c2c2f167def9a775", low_cpu_mem_usage=True)
# 在基础模型上加载LoRA模型
peft_model = PeftModel.from_pretrained(model=model, model_id="./chatbot/checkpoint-500")
# 将基础模型和Lora模型合并
peft_model.merge_and_unload()
peft_model = peft_model.cuda()
#
#加载分词模型
tokenizer_model = AutoTokenizer.from_pretrained("../../local_tokenizer_model")
ipt = tokenizer_model("Human: {}\n{}".format("我们如何在日常生活中减少用水？", "").strip() + "\n\nAssistant: ", return_tensors="pt").to(
    peft_model.device)
print(tokenizer_model.decode(peft_model.generate(**ipt, max_length=128, do_sample=False)[0], skip_special_tokens=True))

输出结果：
在这里插入图片描述
可见我们微调后的模型和基础模型的差异

四、完整训练代码



from datasets import load_dataset
from peft import PromptTuningConfig, TaskType, PromptTuningInit, get_peft_model, PeftModel, PromptEncoderConfig, \
    PromptEncoderReparameterizationType, PrefixTuningConfig, LoraConfig
from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModelForCausalLM, TrainingArguments, \
    DataCollatorForSeq2Seq, Trainer

# 下载数据集
# dataset_file = load_dataset("lyuricky/alpaca_data_zh_51k", split="train", cache_dir="./data/alpaca_data")
# ds = load_dataset("./data/alpaca_data", split="train")
# print(ds[0])

# 下载分词模型
# tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
# Save the tokenizer to a local directory
# tokenizer.save_pretrained("./local_tokenizer_model")

#下载与训练模型
# model = AutoModelForCausalLM.from_pretrained(
#     pretrained_model_name_or_path="Qwen/Qwen2.5-0.5B-Instruct",  # 下载模型的路径
#     torch_dtype="auto",
#     low_cpu_mem_usage=True,
#     cache_dir="./local_model_cache"  # 指定本地缓存目录
# )

#加载分词模型
tokenizer_model = AutoTokenizer.from_pretrained("../../local_tokenizer_model")

# 加载数据集
ds = load_dataset("../../data/alpaca_data", split="train[:10%]")

# 记载模型
model = AutoModelForCausalLM.from_pretrained(
    pretrained_model_name_or_path="../../local_llm_model/models--Qwen--Qwen2.5-0.5B-Instruct/snapshots/7ae557604adf67be50417f59c2c2f167def9a775",
    torch_dtype="auto",
    device_map="cuda:0")


for name,param in model.named_parameters():
    print(name)


# 处理数据
"""
并将其转换成适合用于模型训练的输入格式。具体来说，
它将原始的输入数据（如用户指令、用户输入、助手输出等）转换为模型所需的格式，
包括 input_ids、attention_mask 和 labels。
"""
def process_func(example, tokenizer=tokenizer_model):
    MAX_LENGTH = 256
    input_ids, attention_mask, labels = [], [], []
    instruction = tokenizer("\n".join(["Human: " + example["instruction"], example["input"]]).strip() + "\n\nAssistant: ")
    if example["output"] is not None:
        response = tokenizer(example["output"] + tokenizer.eos_token)
    else:
        return
    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)


# lora
config = LoraConfig(task_type=TaskType.CAUSAL_LM,target_modules= ['q_proj', 'k_proj','v_proj'])

peft_model = get_peft_model(model, config)

print(peft_model.print_trainable_parameters())

# 训练参数

args = TrainingArguments(
    output_dir="chatbot",
    per_device_train_batch_size=1,
    gradient_accumulation_steps=8,
    logging_steps=10,
    num_train_epochs=1
)

# 创建训练器
trainer = Trainer(model=peft_model, args=args, train_dataset=tokenized_ds,
                  data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer_model, padding=True))


# 开始训练
trainer.train()