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 和注意力掩码，并构建适用于模型的输入格式。

4. 数据加载器
   创建数据加载器（DataLoader），用于批量处理数据，以便在训练过程中有效地喂入模型。这一步有助于优化训练效率和内存管理。

5. 微调模型
   进行模型微调，即在特定任务数据集上进一步训练预训练模型。使用优化算法（如 AdamW）和适当的学习率，针对特定任务调整模型参数。通过 LoRA 技术，仅更新一小部分参数，大大减少了计算开销。

6. 保存微调后的模型
   将微调后的模型和分词器保存到本地，以便后续加载和使用。这一步确保了模型的可重用性和部署的便利性。

7. 模型生成
   加载微调后的模型和分词器，输入新的指令和上下文，进行文本生成。微调后的模型能够根据特定任务的需求，生成更符合预期的输出。

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

代码实现

• 安装依赖

python -m pip install --upgrade pip
# 更换 pypi 源加速库的安装
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simplepip 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_tokensprint(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咱们也是要关注的所以 补充为1labels = [-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 torchmodel = 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_modelconfig = 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
  启用梯度检查点，可以在训练大模型时节省显存。启用该功能后，模型在计算反向传播时会逐层计算和保存梯度，而不是一次性全部计算和保存。

模型训练

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 PeftModelmode_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'])