lora微调Qwen模型全流程

风乍起1024

已于 2024-07-29 20:26:44 修改

阅读量3.6k

点赞数 19

分类专栏：人工智能文章标签：人工智能

于 2024-07-28 21:31:51 首次发布

本文链接：https://blog.csdn.net/qq_62231627/article/details/140756188

版权

人工智能专栏收录该内容

12 篇文章

订阅专栏

LoRA 微调 Qwen 模型的技术原理概述

LoRA（Low-Rank Adaptation）是一种用于大模型高效微调的方法。通过对模型参数进行低秩分解和特定层的微调，LoRA 能在保持模型性能的前提下显著减少训练所需的参数量和计算资源。接下来是对 LoRA 微调 Qwen 模型的完整技术流程概述：

模型和分词器加载
首先，从预训练模型库中加载预训练的 Qwen 模型和分词器。预训练模型是大规模语料上训练的通用语言模型，能够为特定任务提供强大的语言理解和生成能力。
配置 LoRA
定义 LoRA 配置，包括任务类型、目标模块、秩（rank）、alpha 参数和 dropout 比例等。LoRA 通过在特定层中引入低秩矩阵，减少需要微调的参数数量。具体配置如下：

任务类型：因果语言模型（Causal Language Model）。
目标模块：指定模型中的哪些模块将应用 LoRA，例如 Transformer 层中的投影矩阵。
秩和 alpha 参数：控制低秩矩阵的大小和缩放因子。
Dropout 比例：用于正则化，防止过拟合。
3. 加载数据集
使用适当的工具加载和处理数据集。数据集通常以 JSON 格式存储，包含指令、输入和预期输出。数据预处理步骤包括对文本进行标记化（tokenization）、生成输入 ID 和注意力掩码，并构建适用于模型的输入格式。

数据加载器
创建数据加载器（DataLoader），用于批量处理数据，以便在训练过程中有效地喂入模型。这一步有助于优化训练效率和内存管理。
微调模型
进行模型微调，即在特定任务数据集上进一步训练预训练模型。使用优化算法（如 AdamW）和适当的学习率，针对特定任务调整模型参数。通过 LoRA 技术，仅更新一小部分参数，大大减少了计算开销。
保存微调后的模型
将微调后的模型和分词器保存到本地，以便后续加载和使用。这一步确保了模型的可重用性和部署的便利性。
模型生成
加载微调后的模型和分词器，输入新的指令和上下文，进行文本生成。微调后的模型能够根据特定任务的需求，生成更符合预期的输出。

技术优势
参数高效：LoRA 通过低秩分解，仅微调少量参数，大幅减少了训练和推理的计算资源需求。
性能保持：尽管微调的参数数量减少，LoRA 依然能够保持模型的性能，适用于大多数语言任务。
灵活性高：LoRA 配置灵活，可以根据不同任务和模型架构进行调整，广泛适用于各类深度学习模型。
通过以上技术流程，LoRA 微调实现了对 Qwen 模型的高效优化，使其能够在特定任务上表现优异，同时显著降低了计算成本。

代码实现

安装依赖

python -m pip install --upgrade pip
# 更换 pypi 源加速库的安装
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

pip install modelscope==1.9.5
pip install "transformers>=4.39.0"
pip install streamlit==1.24.0
pip install sentencepiece==0.1.99
pip install accelerate==0.27
pip install transformers_stream_generator==0.0.4
pip install datasets==2.18.0
pip install peft==0.10.0

# 可选
MAX_JOBS=8 pip install flash-attn --no-build-isolation

数据准备
整体流程是加载和合并不同领域的数据，添加领域标识后进行数据采样，拆分为训练集和测试集，最后保存并可视化数据分布。这样可以确保在不同领域的数据中进行均匀采样和合理拆分，有助于模型的训练和测试。

import json
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split

# 加载JSON文件
def load_json(file_path):
    with open(file_path, 'r', encoding='utf-8') as f:
        data = json.load(f)
    return data

# 合并不同领域的数据
domain1_data = load_json('xiyouji.json')
domain2_data = load_json('zhenhuanzhuan.json')
# domain3_data = load_json('domain3.json')

# 为每个数据添加领域标识
for item in domain1_data:
    item['domain'] = 'domain1'
for item in domain2_data:
    item['domain'] = 'domain2'
# for item in domain3_data:
    # item['domain'] = 'domain3'

# 合并数据
all_data = domain1_data + domain2_data
# 将数据转换为DataFrame以便于操作和可视化
df = pd.DataFrame(all_data)

# 可视化数据分布
def visualize_data_distribution(df, title, file_name, domain_column='domain'):
    plt.figure(figsize=(10, 6))
    sns.countplot(data=df, x=domain_column)
    plt.title(title)
    plt.savefig(file_name)
    plt.show()

# 可视化初始数据分布
visualize_data_distribution(df, "Initial Data Distribution Across Domains", "initial_data_distribution.png")

# 对每个领域进行采样（每个领域采样20条数据）
sampled_df = df.groupby('domain').apply(lambda x: x.sample(n=20, random_state=42)).reset_index(drop=True)

# 可视化采样后的数据分布
visualize_data_distribution(sampled_df, "Sampled Data Distribution Across Domains", "sampled_data_distribution.png")

# 将采样后的数据制作成训练集和测试集
train_df, test_df = train_test_split(sampled_df, test_size=0.2, random_state=42)

# 保存采样后的训练集和测试集
train_df.to_json('train_dataset.json', orient='records', force_ascii=False, lines=True)
test_df.to_json('test_dataset.json', orient='records', force_ascii=False, lines=True)

# 检查采样后的数据分布
visualize_data_distribution(train_df, "Train Data Distribution After Sampling", "train_data_distribution.png")
visualize_data_distribution(test_df, "Test Data Distribution After Sampling", "test_data_distribution.png")

导入依赖

from datasets import Dataset
import pandas as pd
from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForSeq2Seq, TrainingArguments, Trainer, GenerationConfig

下载模型
使用 modelscope 中的 snapshot_download 函数下载模型。

#模型下载
from modelscope import snapshot_download
model_dir = snapshot_download('qwen/Qwen1.5-0.5B')
print(f"Model downloaded to: {model_dir}")

输出结果：
在这里插入图片描述

加载数据，查看

# 数据加载，查看
from datasets import load_dataset
# 加载json格式的训练数据集
_dataset = load_dataset("json", data_files="train_dataset.json", split="train")
_dataset

在这里插入图片描述

数据集特征
特征结构：数据集包含 instruction（指令）、input（输入）、output（输出）和 domain（领域）。这些特征是合理的，适合用于训练一个角色扮演的对话模型。

instruction：模型应该遵循的指令。
input：用户输入。
output：模型期望生成的输出。
domain：数据的领域标识，可能用于多任务学习或领域适应。

加载分词器模型

加载本地的Qwen1.5-0.5B模型

tokenizer = AutoTokenizer.from_pretrained('/root/.cache/modelscope/hub/qwen/Qwen1___5-0___5B', use_fast=False, trust_remote_code=True)
tokenizer

数据格式化处理

Lora 训练的数据是需要经过格式化、编码之后再输入给模型进行训练的，我们一般需要将输入文本编码为 input_ids，将输出文本编码为 labels，编码之后的结果都是多维的向量。我们首先定义一个预处理函数，这个函数用于对每一个样本，编码其输入、输出文本并返回一个编码后的字典。

定义处理函数

def process_func(example):
    MAX_LENGTH = 384    # Llama分词器会将一个中文字切分为多个token，因此需要放开一些最大长度，保证数据的完整性
    input_ids, attention_mask, labels = [], [], []
    instruction = tokenizer(f"<|im_start|>system\n现在你要充当一名角色扮演者。<|im_end|>\n<|im_start|>user\n{example['instruction'] + example['input']}<|im_end|>\n<|im_start|>assistant\n", add_special_tokens=False)  # add_special_tokens 不在开头加 special_tokens
    print(instruction)
    response = tokenizer(f"{example['output']}", add_special_tokens=False)
    input_ids = instruction["input_ids"] + response["input_ids"] + [tokenizer.pad_token_id]
    attention_mask = instruction["attention_mask"] + response["attention_mask"] + [1]  # 因为eos token咱们也是要关注的所以 补充为1
    labels = [-100] * len(instruction["input_ids"]) + response["input_ids"] + [tokenizer.pad_token_id]  
    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
    }

单纯的一问一答的数据集格式像这样的：

 {
        "case": "患者李某，男，45岁，最近患病毒性感冒，初起恶寒发热，继而身热持续不退，频转矢气，胸脘痞满，腹部胀痛拒按，大便秘结，数日未行，咽痛口苦，口舌生疮，头痛目赤。潮热谵语，小便短赤，舌苔厚黄，舌生芒刺，脉沉实数。此患者主症为大便秘结，腹部胀痛拒按，以及其他症状包括身热、频转矢气、胸脘痞满、潮热、谵语、小便短赤、咽痛、口舌生疮、头痛、目赤、舌苔厚黄、舌生芒刺、脉沉实。根据这些症状的描述，我们可以推断出该患者可能患有病毒性感冒。",
        "diagnosis": "诊断：阳明热结。建议处方：小承气汤。建议中成药：厚朴排气合剂或牛黄清胃丸"
    }

数据处理的部分代码就需要改一下：

def process_func(example):
    MAX_LENGTH = 384  # Llama分词器会将一个中文字切分为多个token，因此需要放开一些最大长度，保证数据的完整性
    
    # 构建instruction和response的token化结果
    instruction_text = f"system\n现在你要充当一名角色扮演者。\nuser\n{example['case']}\nassistant\n"
    response_text = example['diagnosis']

    instruction = tokenizer(instruction_text, add_special_tokens=False)
    response = tokenizer(response_text, add_special_tokens=False)

    input_ids = instruction["input_ids"] + response["input_ids"] + [tokenizer.pad_token_id]
    attention_mask = instruction["attention_mask"] + response["attention_mask"] + [1]  # eos token也需要关注
    labels = [-100] * len(instruction["input_ids"]) + response["input_ids"] + [tokenizer.pad_token_id]

    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_id = _dataset.map(process_func, remove_columns=_dataset.column_names)
tokenized_id

在这里插入图片描述

加载模型

import torch

model = AutoModelForCausalLM.from_pretrained('/root/.cache/modelscope/hub/qwen/Qwen1___5-0___5B', device_map="auto",torch_dtype=torch.bfloat16)
model

在这里插入图片描述

开启梯度检查，查看精度

model.enable_input_require_grads() # 开启梯度检查点时，要执行该方法
model.dtype # 查看精度

lora配置

from peft import LoraConfig, TaskType, get_peft_model

config = LoraConfig(
    task_type=TaskType.CAUSAL_LM, 
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    inference_mode=False, # 训练模式
    r=8, # Lora 秩
    lora_alpha=32, # Lora alaph，具体作用参见 Lora 原理
    lora_dropout=0.1# Dropout 比例
)
config

task_type=TaskType.CAUSAL_LM：指定任务类型为因果语言模型（Causal Language Model）。这表明该配置用于训练一个自回归语言模型。
target_modules=[“q_proj”, “k_proj”, “v_proj”, “o_proj”, “gate_proj”, “up_proj”, “down_proj”]：指定要应用 LoRA 的目标模块列表。这里列出了常见的变压器（Transformer）模块，如查询投影（q_proj）、键投影（k_proj）、值投影（v_proj）等。
inference_mode=False：指定当前模式为训练模式（False），而非推理模式（True）。这意味着模型会进行训练更新。
r=8：指定 LoRA 的秩（rank）。这是低秩分解的秩值，表示要将参数矩阵分解为两个秩为 8 的矩阵。
lora_alpha=32：LoRA 的缩放因子。用于调整低秩分解后矩阵的值的范围。
lora_dropout=0.1：Dropout 比例。表示在应用 LoRA 的层中，10% 的神经元会被随机丢弃以防止过拟合。

加载lora

model = get_peft_model(model, config)
config

查看可训练参数

model.print_trainable_parameters()

配置训练参数

args = TrainingArguments(
    output_dir="./output/Qwen1___5-0___5B",
    per_device_train_batch_size=64,
    gradient_accumulation_steps=4,
    logging_steps=10,
    num_train_epochs=100,
    save_steps=100, # 建议你置成100
    learning_rate=1e-4,
    save_on_each_node=True,
    gradient_checkpointing=True
)

参数解释：

output_dir：
output_dir=“./output/Qwen1___5-0___5B”
指定训练过程中保存模型和其他输出文件的目录。所有的检查点和最终的模型将保存在这个目录中。
per_device_train_batch_size：
per_device_train_batch_size=64
每个设备（如 GPU 或 CPU）的训练批处理大小。在分布式训练或多 GPU 训练中，这个参数指的是每个设备上的批处理大小。
gradient_accumulation_steps：
gradient_accumulation_steps=4
梯度累积步数。此参数允许在多次前向传递后再进行一次梯度更新，以模拟更大的批处理大小。例如，如果设置为 4，则会在 4 个批次之后进行一次梯度更新，相当于将实际的批处理大小乘以 4。
logging_steps：
logging_steps=10
指定记录日志的频率（以步数为单位）。每 10 步会记录一次日志信息，包括训练损失和其他指标。
num_train_epochs：
num_train_epochs=100
训练的总轮数。模型将在整个训练集上训练 100 个周期。
save_steps：
save_steps=100
指定保存模型检查点的频率（以步数为单位）。每 100 步会保存一次模型检查点。这对于长时间训练的过程非常有用，可以在训练过程中定期保存模型。
learning_rate：
learning_rate=1e-4
训练过程中使用的学习率。学习率控制了模型参数更新的步幅，是训练中最重要的超参数之一。
save_on_each_node：
save_on_each_node=True
在分布式训练中，是否在每个节点上保存检查点。设置为 True 可以确保在分布式环境下每个节点都会保存检查点。
gradient_checkpointing：
gradient_checkpointing=True
启用梯度检查点，可以在训练大模型时节省显存。启用该功能后，模型在计算反向传播时会逐层计算和保存梯度，而不是一次性全部计算和保存。

模型训练

训练之前检查并释放GPU

def check_and_release_gpu_memory():
    # 检查每个 GPU 的显存使用情况
    for i in range(torch.cuda.device_count()):
        print(f"Device {i}: {torch.cuda.get_device_name(i)}")
        print(f"  Total Memory: {torch.cuda.get_device_properties(i).total_memory / (1024 ** 3):.2f} GB")
        print(f"  Allocated: {torch.cuda.memory_allocated(i) / (1024 ** 3):.2f} GB")
        print(f"  Cached: {torch.cuda.memory_reserved(i) / (1024 ** 3):.2f} GB")
    
    # 释放所有 GPU 的显存
    torch.cuda.empty_cache()
    print("All GPU memory caches have been released.")

# 调用函数检查和释放显存
check_and_release_gpu_memory()

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=tokenized_id,
    data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, padding=True),
)
trainer.train()

在这里插入图片描述

模型合并

将训练后的lora权重加载到原来的模型中，形成新的模型。并保存带本地。

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

mode_path = '/root/.cache/modelscope/hub/qwen/Qwen1___5-0___5B'
lora_path = './output/Qwen1___5-0___5B/checkpoint-100' # 这里改称你的 lora 输出对应 checkpoint 地址

# 加载tokenizer
tokenizer = AutoTokenizer.from_pretrained(mode_path, trust_remote_code=True)

# 加载模型
model = AutoModelForCausalLM.from_pretrained(mode_path, device_map="auto", torch_dtype=torch.bfloat16, trust_remote_code=True).eval()

# 加载lora权重
model = PeftModel.from_pretrained(model, model_id=lora_path)

# 保存合并后的模型和分词器
save_path = './output/merged_model'
model.save_pretrained(save_path)
tokenizer.save_pretrained(save_path)

模型推理

基于合并后（加载了lora权重）的模型进行推理

# 现在加载合并后的模型和分词器进行生成
model = AutoModelForCausalLM.from_pretrained(save_path, device_map="auto", torch_dtype=torch.bfloat16).eval()
tokenizer = AutoTokenizer.from_pretrained(save_path)

# 准备生成输入
prompt = "悟空，我们的干粮不多了，接下来该怎么办？"
messages = [
    {"role": "system", "content": "现在你要充当一名角色扮演者。"},
    {"role": "user", "content": prompt}
]

# 使用分词器准备输入
inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_tensors="pt", return_dict=True).to('cuda')

# 生成设置
gen_kwargs = {"max_length": 2500, "do_sample": True, "top_k": 1}

# 生成文本
with torch.no_grad():
    outputs = model.generate(**inputs, **gen_kwargs)
    outputs = outputs[:, inputs['input_ids'].shape[1]:]
    print(tokenizer.decode(outputs[0], skip_special_tokens=True))

在这里插入图片描述

使用pipeline运行：

from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer

# 加载合并后的模型和分词器
save_path = "myqwen2-0.5b"  # 根据实际保存路径进行调整
model = AutoModelForCausalLM.from_pretrained(save_path, torch_dtype=torch.bfloat16).eval()
tokenizer = AutoTokenizer.from_pretrained(save_path)

# 准备生成输入
prompt = "悟空，我们的干粮不多了，接下来该怎么办？"
messages = [
    {"role": "system", "content": "现在你要充当一名角色扮演者。"},
    {"role": "user", "content": prompt}
]

# 将消息转化为输入字符串
input_text = " ".join([msg["content"] for msg in messages])

# 使用pipeline进行文本生成
text_generation_pipeline = pipeline("text-generation", model=model, tokenizer=tokenizer)

# 生成设置
gen_kwargs = {"max_length": 256, "do_sample": True, "top_k": 1, "temperature": 0.7}

# 生成文本
outputs = text_generation_pipeline(input_text, **gen_kwargs)

# 输出生成的文本
print(outputs[0]['generated_text'])

或者：

from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
import pandas as pd

# 加载合并后的模型和分词器
save_path = "myqwen2-0.5b"  # 根据实际保存路径进行调整
model = AutoModelForCausalLM.from_pretrained(save_path, torch_dtype=torch.bfloat16).eval()
tokenizer = AutoTokenizer.from_pretrained(save_path)

# 创建文本生成Pipeline
text_generator = pipeline("text-generation", model=model, tokenizer=tokenizer)

# 准备测试数据
test_data = pd.DataFrame({
    "prompt": ["悟空，我们的干粮不多了，接下来该怎么办？"]
})

# 对测试数据进行预测
for i in range(len(test_data)):
    prompt = test_data["prompt"][i]
    generated_text = text_generator(
        prompt, 
        max_length=100,  # 增加生成长度
        do_sample=True, 
        top_k=50,       # 增加多样性
        top_p=0.95,     # 增加多样性
        temperature=0.7,  # 调整生成温度
        repetition_penalty=1.2  # 加入重复惩罚
    )
    print(f"Prompt: {prompt}")
    print(f"Generated Text: {generated_text[0]['generated_text']}")