window系统使用transformers库和SFT本地微调Qwen模型

杭家y

已于 2025-03-31 17:25:07 修改

阅读量359

点赞数 4

CC 4.0 BY-SA版权

分类专栏：大模型文章标签： python transformer SFT训练微调

于 2025-03-31 11:19:49 首次发布

本文链接：https://blog.youkuaiyun.com/chenhangx/article/details/146800086

大模型专栏收录该内容

1 篇文章

订阅专栏

从0开始使用pycharm搭建python环境，下载模型权重，安装依赖，运行模型，本地微调

一、文档说明与环境准备

1.1 文档说明

访问qwen开源代码，了解模型差异和使用教程

https://github.com/QwenLM/Qwen
https://qwen.readthedocs.io/zh-cn/latest/getting_started/quickstart.html

1.2 运行环境准备

下载pycharm，一直下一步安装即可，使用pycharm提供的虚拟环境部署运行项目

二、相关文件下载

2.1 安装虚拟环境

#安装本地python虚拟环境
PS D:\workspace\AI\code\scratch-llm-main> python -m venv qwenvm
#激活
PS D:\workspace\AI\code\scratch-llm-main> qwenvm\scripts\activate

2.2 模型文件下载
推荐使用国内的模型库魔搭或者huggingface镜像，模型下的全部文件都要下载

https://www.modelscope.cn/
https://hf-mirror.com/
https://huggingface.co/

可以手动下载也可以使用命令行下载

(qwenvm) PS D:\workspace\AI\code\scratch-llm-main> modelscope download --model Qwen/Qwen2.5-0.5B-Instruct

下载完成后的目录

下载微调代码demo （demo中包含测试训练数据集）

https://github.com/FutureAI-X/scratch-llm

三、安装项目依赖

#导包，可以使用镜像加速下载
 pip install --upgrade pip
 pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

#也可以只安装需要的依赖
pip install torch
pip install datasets
pip install --no-cache-dir transformers -i https://pypi.tuna.tsinghua.edu.cn/simple

#在代码运行过程中，根据提示额外安装一些依赖
 pip install accelerate==0.27.2
 pip install --no-cache-dir trl==0.13.0 -i https://pypi.tuna.tsinghua.edu.cn/simple

四、在本地虚拟环境中推理

第一步：指定本地地址，加载模型

from transformers import AutoModelForCausalLM, AutoTokenizer

# model_name = "Qwen/Qwen2.5-0.5B-Instruct"
model_name = r"D:/workspace/AI/modelspace/Qwen2___5-0___5B-Instruct"
# 加载预训练模型，自动推断和选择 数据类型和设备
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)
print("1.model加载成功")

第二步：加载分词器

prompt = "介绍一下浙江,他的省会在哪里"
messages = [
    {"role": "system", "content": "You are Qwen, 一个大聪明."},
    {"role": "user", "content": prompt},
]
# 格式化输入
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,#不分词，展示原始文本格式
    add_generation_prompt=True,#添加生成提示,会生成更多的响应
)
#将格式化的文本转为模型输入，并转换成pytorch张量，移动到指定设备
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
# 生成文本
generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=512 #最大token
)
#从生成的id中提取新生成的id
generated_ids = [
    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]
#使用分词器将id解码成文本，并跳过特殊token
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(response)

第三步：启动推理脚本(可以使用pycharm右键运行文件)

 python .\qwenquikstart.py

运行结果

五、在本地虚拟环境中进行微调

配置训练参数，执行本地训练

06_pretrain_province_qwen2_trainer.py(可以使用pycharm右键运行文件)

"""
自定义 Transformer 模型预训练
模型：自定义 Transformer 模型
数据集：省份介绍/省会数据
方式：使用 Hugging Face 的 trainer 类
"""
# 安装加载依赖库
import torch
from datasets import load_dataset
from transformers import AutoTokenizer, TrainingArguments, Trainer

from model_define.model_qwen.configuration_qwen2 import Qwen2Config
from model_define.model_qwen.modeling_qwen2 import Qwen2ForCausalLM

device = 'cuda' if torch.cuda.is_available() else 'cpu'
"""
MODULE 2 Tokenizer 与 Model 定义
"""
# 2.1 初始化 Tokenizer（使用 Qwen 2.5 的 Tokenizer）
# tokenizer = AutoTokenizer.from_pretrained("../tokenizer_file/tokenizer_qwen")
tokenizer = AutoTokenizer.from_pretrained("D:/workspace/AI/modelspace/Qwen2___5-0___5B-Instruct")

# 2.2初始化模型参数
config = Qwen2Config()
config.max_position_embeddings = 32
config.hidden_size = 64
config.num_attention_heads = 8
config.num_key_value_heads = 2
config.num_hidden_layers = 4

# 2.3 初始化模型
model = Qwen2ForCausalLM(config)
model = model.to(device)

"""
MODULE 3 数据集加载与Token化
"""
# 3.1 加载数据集
dataset = load_dataset('json', data_files={"train": f"../dataset_file/dataset_province/{dataset_file_name}.jsonl"})

# 3.2 定义数据集[token化]处理函数
def tokenize_function(batch):
    """
    对原始文本进行token化，生成新的参数：
        input_ids       token化之后的数值
        attention_mask  损失掩码，为1表示需要计算损失，为0表示不计算损失
    """
    tokenizer_temp = tokenizer(batch["text"], padding="max_length", truncation=True, max_length=config.max_position_embeddings + 1)
    tokenizer_temp["labels"] = tokenizer_temp["input_ids"].copy()
    return tokenizer_temp

# 3.3 执行数据集[token化]处理
tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=["text"])

"""
MODULE 4 定义训练参数
"""
training_args = TrainingArguments(
	# 保存模型
    output_dir=f"../checkpoint_folder/checkpoint_province/{model_save_path}",
    overwrite_output_dir=True,  # 如果设置为 True，则允许覆盖输出目录中的现有内容。
    num_train_epochs=1000,  # 训练的总轮数（epoch），即整个数据集会被遍历 500 次。
    per_device_train_batch_size=10,  # 每个设备（GPU/CPU）上的训练批次大小。如果使用多个 GPU，总批次大小将是这个值乘以 GPU 数量。
    save_steps=100,  # 每多少步保存一次模型检查点。这里表示每 50 步保存一次。
    save_total_limit=3,  # 最多保存多少个检查点。当超过这个限制时，最早的检查点将被删除。
    logging_steps=1,  # 每多少步记录一次日志。这里表示每 1 步记录一次。
    learning_rate=1e-3,  # 学习率，用于优化器更新模型参数的速度。这里设置为 0.001。
    weight_decay=0.01,  # 权重衰减（L2正则化）系数，用于防止过拟合。
)

"""
MODULE 5 定义训练器并执行训练
"""
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"]
)

trainer.train()

推理微调模型

06_pretrain_province_qwen2_trainer_test.py

from transformers import AutoTokenizer

from model_define.model_qwen.modeling_qwen2 import Qwen2ForCausalLM
import torch

"""
MODULE 0 定义任务类型
city：省会信息
else：省份介绍
"""
dataset_type = "city1"
model_save_name = "qwen2-province-intro"
eval_prompt_list = ['台湾']

"""
MODULE 1 定义运行设备
"""
device = 'cuda' if torch.cuda.is_available() else 'cpu'


"""
MODULE 2 Tokenizer 与 Model 定义，加载微调后保存的模型
"""
model_path = f"../checkpoint_folder/checkpoint_province/{model_save_name}/checkpoint-2000"
tokenizer = AutoTokenizer.from_pretrained("../tokenizer_file/tokenizer_qwen")
model = Qwen2ForCausalLM.from_pretrained(model_path)

"""
MODULE 3 生成测试
"""
for start in eval_prompt_list:
    for i in range(3):
        inputs = tokenizer(start, return_tensors="pt")

        generate_ids = model.generate(inputs.input_ids, max_new_tokens=10)
        response = tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]

        print('---------------')
        print(response) #输出数据集中定义的内容
        print('---------------')