lora微调Qwen模型全流程

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

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

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

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

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

技术优势
参数高效：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 installmodelscope==1.9.5
pip install"transformers>=4.39.0"
pip installstreamlit==1.24.0
pip installsentencepiece==0.1.99
pip installaccelerate==0.27
pip installtransformers_stream_generator==0.0.4
pip installdatasets==2.18.0
pip installpeft==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')# 为每个数据添加领域标识foritemin domain1_data:
    item['domain']='domain1'foritemin 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, # 建议你置成100learning_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 的显存使用情况foriin 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"]formsgin 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":["悟空，我们的干粮不多了，接下来该怎么办？"]})# 对测试数据进行预测foriin 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']}")