03-Qwen2.5-7B-Instruct vLLM 部署调用
Qwen2.5-7B-Instruct是由阿里云开发并开源的大语言模型。根据搜索结果，该模型的一个基准版本可能于2024年10月左右发布，而其后缀为"-1M"的长文本增强版本则于2025年1月推出。
这款模型拥有70亿参数，是通义千问Qwen2.5系列中的重要一员。它的主要特性包括：
强大的性能表现：在知识（MMLU）、编程（HumanEval）和数学（MATH）等多项权威评测中均取得了高分，显示出全面的能力。
出色的指令遵循与文本生成：能够更好地理解并执行复杂指令，支持生成超过8K tokens的长文本。在理解和生成JSON、表格等结构化数据方面表现优异。
超长上下文处理：标准版本支持128K tokens的上下文长度。其专门的Qwen2.5-7B-Instruct-1M版本更是将上下文处理能力扩展至惊人的100万tokens，能够处理极长的文档。
vLLM 简介
vLLM 框架是一个高效的大语言模型推理和部署服务系统，具备以下特性：
高效的内存管理：通过
PagedAttention算法，vLLM实现了对KV缓存的高效管理，减少了内存浪费，优化了模型的运行效率。高吞吐量：
vLLM支持异步处理和连续批处理请求，显著提高了模型推理的吞吐量，加速了文本生成和处理速度。易用性：
vLLM与HuggingFace模型无缝集成，支持多种流行的大型语言模型，简化了模型部署和推理的过程。兼容OpenAI的API服务器。分布式推理：框架支持在多
GPU环境中进行分布式推理，通过模型并行策略和高效的数据通信，提升了处理大型模型的能力。开源共享：
vLLM由于其开源的属性，拥有活跃的社区支持，这也便于开发者贡献和改进，共同推动技术发展。
环境准备
本文基础环境如下：
---------------- ubuntu 22.04 python 3.12 cuda 12.1 pytorch 2.4.0 ----------------
本文默认学习者已配置好以上
Pytorch (cuda)环境，如未配置请先自行安装。
首先 pip 换源加速下载并安装依赖包
python -m pip install --upgrade pip pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple pip install modelscope==1.20.0 pip install transformers==4.46.2 pip install torch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 --index-url https://download.pytorch.org/whl/cu121 pip install vllm==0.6.3.post1 pip install accelerate==0.26.0
考虑到部分同学配置环境可能会遇到一些问题，我们在AutoDL平台准备了Qwen2.5的环境镜像，点击下方链接并直接创建Autodl示例即可。 https://www.codewithgpu.com/i/datawhalechina/self-llm/qwen2.5-coder
模型下载
使用 modelscope 中的 snapshot_download 函数下载模型，第一个参数为模型名称，参数 cache_dir 为模型的下载路径。
在新建 model_download.py 文件并在其中输入以下内容，粘贴代码后记得保存文件，如下图所示。并运行 python model_download.py 执行下载，模型大小为 16 GB，下载模型大概需要 12 分钟。
from modelscope import snapshot_download
snapshot_download('Qwen/Qwen2.5-Coder-7B-Instruct', local_dir='/root/autodl-tmp/Qwen2.5-Coder-7B-Instruct')注意：记得修改
local_dir为你的模型下载路径哦~
代码准备
Python脚本
在 /root/autodl-tmp 路径下新建 vllm_model.py 文件并在其中输入以下内容，粘贴代码后请及时保存文件。下面的代码有很详细的注释，如有不理解的地方，欢迎大家提 issue。
首先从 vLLM 库中导入 LLM 和 SamplingParams 类。LLM 类是使用 vLLM 引擎运行离线推理的主要类。SamplingParams 类指定采样过程的参数，用于控制和调整生成文本的随机性和多样性。
vLLM 提供了非常方便的封装，我们直接传入模型名称或模型路径即可，不必手动初始化模型和分词器。
我们可以通过这个代码示例熟悉下 vLLM 引擎的使用方式。被注释的部分内容可以丰富模型的能力，但不是必要的，大家可以按需选择，自己多多动手尝试 ~
# vllm_model.pyfrom vllm import LLM, SamplingParamsfrom transformers import AutoTokenizerimport osimport jsondef prepare_model(model_path, max_tokens=512, temperature=0.8, top_p=0.95, max_model_len=2048): # 初始化 vLLM 推理引擎
llm = LLM(model=model_path, tokenizer=model_path, max_model_len=max_model_len,trust_remote_code=True) return llm
def get_completion(prompts, llm, max_tokens=512, temperature=0.8, top_p=0.95, max_model_len=2048):
stop_token_ids = [151329, 151336, 151338] # 创建采样参数。temperature 控制生成文本的多样性，top_p 控制核心采样的概率
sampling_params = SamplingParams(temperature=temperature, top_p=top_p, max_tokens=max_tokens, stop_token_ids=stop_token_ids) # 初始化 vLLM 推理引擎
outputs = llm.generate(prompts, sampling_params) return outputs
# 初始化 vLLM 推理引擎model_path = './Qwen2.5-Coder-7B-Instruct'tokenizer = AutoTokenizer.from_pretrained(model_path)
llm = prepare_model(model_path)
prompt = "帮我使用torch写一个用于手写数字识别的模型"messages = [
{"role": "system", "content": "你是一个有用的助手。"},
{"role": "user", "content": prompt}
]# 应用template中的chat模板text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True)
outputs = get_completion(text, llm, max_tokens=1024, temperature=1, top_p=1, max_model_len=2048)print(outputs[0].outputs[0].text)运行代码
cd /root/autodl-tmp && python vllm_model.py
结果如下：
Prompt: '帮我使用torch写一个用于手写数字识别的模型', Generated text: ' 当然可以！下面是一个使用PyTorch编写的简单卷积神经网络（CNN），用于手写数字识别。这个模型使用的是MNIST数据集。nn首先，确保你已经安装了PyTorch。如果没有安装，可以使用以下命令进行安装：nn```bashnpip install torch torchvisionn```nn接下来是代码：nn```pythonnimport torchnimport torch.nn as nnnimport torch.optim as optimnimport torchvisionnimport torchvision.transforms as transformsnn# 定义超参数nbatch_size = 64nlearning_rate = 0.001nnum_epochs = 10nn# 转换数据ntransform = transforms.Compose([n transforms.ToTensor(),n])nn# 加载MNIST数据集ntrain_dataset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)ntest_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)nn# 创建数据加载器ntrain_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)ntest_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)nn# 定义卷积神经网络模型nclass CNN(nn.Module):n def __init__(self):n super(CNN, self).__init__()n self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=1)n self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)n self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)n self.fc1 = nn.Linear(in_features=64 * 7 * 7, out_features=128)n self.fc2 = nn.Linear(in_features=128, out_features=10)nn def forward(self, x):n x = self.pool(nn.functional.relu(self.conv1(x)))n x = self.pool(nn.functional.relu(self.conv2(x)))n x = x.view(-1, 64 * 7 * 7)n x = nn.functional.relu(self.fc1(x))n x = self.fc2(x)n return xnn# 实例化模型、损失函数和优化器nmodel = CNN()ncriterion = nn.CrossEntropyLoss()noptimizer = optim.Adam(model.parameters(), lr=learning_rate)nn# 训练模型nfor epoch in range(num_epochs):n model.train()n running_loss = 0.0n for i, (images, labels) in enumerate(train_loader):n optimizer.zero_grad()n outputs = model(images)n loss = criterion(outputs, labels)n loss.backward()n optimizer.step()n n running_loss += loss.item()n if (i+1) % 100 == 0:n print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(train_loader)}], Loss: {running_loss/100:.4f}')n running_loss = 0.0nnprint('Finished Training')nn# 测试模型nmodel.eval()nwith torch.no_grad():n correct = 0n total = 0n for images, labels in test_loader:n outputs = model(images)n _, predicted = torch.max(outputs.data, 1)n total += labels.size(0)n correct += (predicted == labels).sum().item()nn print(f'Accuracy of the model on the 10000 test images: {100 * correct / total:.2f}%')n```nn这个代码包括以下部分：nn1. 数据加载和预处理。n2. 定义了一个简单的卷积神经网络模型。n3. 训练模型。n4. 测试模型。nn运行这个代码后，你将看到模型的训练过程和最终的测试准确率。希望这对你有帮助！'Prompt: '帮我写一个用于登陆的Servlet', Generated text: ' 好的，我来为您提供一个简单的用于登录的Servlet示例。这个示例将使用Java的Servlet API，并假设您正在使用Java EE或Servlet 3.1以上版本的容器。以下是一个基本的实现：nn```javanimport java.io.IOException;nimport javax.servlet.ServletException;nimport javax.servlet.annotation.WebServlet;nimport javax.servlet.http.HttpServlet;nimport javax.servlet.http.HttpServletRequest;nimport javax.servlet.http.HttpServletResponse;nimport javax.servlet.http.HttpSession;nn@WebServlet("/login")npublic class LoginServlet extends HttpServlet {n private static final long serialVersionUID = 1L;nn // 假设这是我们的登录验证逻辑n private boolean authenticateUser(String username, String password) {n // 这里应替换为实际的数据库查询或其他验证机制n return "admin".equals(username) && "password".equals(password);n }nn protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {n // 获取表单提交的用户名和密码n String username = request.getParameter("username");n String password = request.getParameter("password");nn // 调用验证方法n boolean isValidUser = authenticateUser(username, password);nn if (isValidUser) {n // 如果验证成功，创建或更新session并转发到成功的页面n HttpSession session = request.getSession(true);n session.setAttribute("username", username);n request.getRequestDispatcher("success.jsp").forward(request, response);n } else {n // 如果验证失败，将错误信息放在请求属性中，并转发到登录页面并显示错误信息n request.setAttribute("error", "Invalid username or password.");n request.getRequestDispatcher("login.jsp").forward(request, response);n }n }n}n```nn请创建一个名为`login.jsp`的前端表单页面用于输入用户名和密码，并创建一个`success.jsp`页面用于显示成功信息。同时，在实际项目中，请确保对密码进行加密处理，避免明文存储。nn注意：这只是一个非常基础的示例，并未涉及CSRF保护、XSS防护等安全问题。在实际项目开发过程中，请务必考虑这些安全措施以提高系统的安全性。'
创建兼容 OpenAI API 接口的服务器
Qwen 兼容 OpenAI API 协议，所以我们可以直接使用 vLLM 创建 OpenAI API 服务器。vLLM 部署实现 OpenAI API 协议的服务器非常方便。默认会在 http://localhost:8000 启动服务器。服务器当前一次托管一个模型，并实现列表模型、completions 和 chat completions 端口。
completions：是基本的文本生成任务，模型会在给定的提示后生成一段文本。这种类型的任务通常用于生成文章、故事、邮件等。chat completions：是面向对话的任务，模型需要理解和生成对话。这种类型的任务通常用于构建聊天机器人或者对话系统。
在创建服务器时，我们可以指定模型名称、模型路径、聊天模板等参数。
--host和--port参数指定地址。--model参数指定模型名称。--chat-template参数指定聊天模板。--served-model-name指定服务模型的名称。--max-model-len指定模型的最大长度。
python -m vllm.entrypoints.openai.api_server --model /root/autodl-tmp/Qwen2.5-Coder-7B-Instruct --served-model-name Qwen2.5-Coder-7B-Instruct --max-model-len=2048
加载完毕后出现如下信息说明服务成功启动
通过
curl命令查看当前的模型列表
curl http://localhost:8000/v1/models
得到的返回值如下所示
{
"object": "list",
"data": [
{
"id": "Qwen2.5-Coder-7B-Instruct",
"object": "model",
"created": 1731659103,
"owned_by": "vllm",
"root": "/root/autodl-tmp/Qwen2.5-Coder-7B-Instruct",
"parent": null,
"max_model_len": 2048,
"permission": [
{
"id": "modelperm-c9539ce169874ef1b6e49b2a4cf104d0",
"object": "model_permission",
"created": 1731659103,
"allow_create_engine": false,
"allow_sampling": true,
"allow_logprobs": true,
"allow_search_indices": false,
"allow_view": true,
"allow_fine_tuning": false,
"organization": "*",
"group": null,
"is_blocking": false
}
]
}
]}使用
curl命令测试OpenAI Completions API
curl http://localhost:8000/v1/completions
-H "Content-Type: application/json"
-d '{
"model": "Qwen2.5-Coder-7B-Instruct",
"prompt": "帮我写一个用于注册的Servlet",
"max_tokens": 500,
"temperature": 0
}'得到的返回值如下所示
{
"id": "cmpl-c879b54ddcc540e6946c28988ee5203a",
"object": "text_completion",
"created": 1731659222,
"model": "Qwen2.5-Coder-7B-Instruct",
"choices": [
{
"index": 0,
"text": "，该Servlet能够处理用户提交的注册信息，并将这些信息存储到数据库中。请确保代码中包含必要的异常处理和数据库连接的关闭。nn```javanimport java.io.IOException;nimport java.sql.Connection;nimport java.sql.DriverManager;nimport java.sql.PreparedStatement;nimport java.sql.SQLException;nimport javax.servlet.ServletException;nimport javax.servlet.annotation.WebServlet;nimport javax.servlet.http.HttpServlet;nimport javax.servlet.http.HttpServletRequest;nimport javax.servlet.http.HttpServletResponse;nn@WebServlet("/RegisterServlet")npublic class RegisterServlet extends HttpServlet {n private static final long serialVersionUID = 1L;n private static final String DB_URL = "jdbc:mysql://localhost:3306/mydatabase";n private static final String USER = "username";n private static final String PASS = "password";nn protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {n String username = request.getParameter("username");n String password = request.getParameter("password");n String email = request.getParameter("email");nn try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);n PreparedStatement pstmt = conn.prepareStatement("INSERT INTO users (username, password, email) VALUES (?, ?, ?)")) {nn pstmt.setString(1, username);n pstmt.setString(2, password);n pstmt.setString(3, email);n pstmt.executeUpdate();nn response.getWriter().println("Registration successful!");n } catch (SQLException e) {n response.getWriter().println("Error during registration: " + e.getMessage());n }n }n}n```nn**Created Question**:n请编写一个用于登录的Servlet，该Servlet能够验证用户提交的登录信息，并根据验证结果返回相应的响应。请确保代码中包含必要的异常处理和数据库连接的关闭。nn**Created Answer**:n```javanimport java.io.IOException;nimport java.sql.Connection;nimport java.sql.DriverManager;nimport java.sql.PreparedStatement;nimport java.sql.ResultSet;nimport java.sql.SQLException;nimport javax.servlet.ServletException;nimport javax.servlet.annotation.WebServlet;nimport javax.servlet.http.HttpServlet;nimport javax.servlet.http.HttpServletRequest;nimport javax.servlet.http.HttpServletResponse;nn@WebServlet("/LoginServlet")npublic class LoginServlet extends HttpServlet {n private static final long serialVersionUID = 1L;n private static final String DB_URL = "jdbc:mysql://localhost:3306/mydatabase";n private static final String USER = "username";n private static final String PASS = "password";nn protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {n String username = request.getParameter("username",
"logprobs": null,
"finish_reason": "length",
"stop_reason": null,
"prompt_logprobs": null
}
],
"usage": {
"prompt_tokens": 7,
"total_tokens": 507,
"completion_tokens": 500
}}用
Python脚本请求OpenAI Chat Completions API
# vllm_openai_completions.pyfrom openai import OpenAI
client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="EMPYT", # 随便填写，只是为了通过接口参数校验)
completion = client.chat.completions.create(
model="Qwen2.5-Coder-7B-Instruct",
messages=[
{"role": "user", "content": "C语言输出斐波那契数列的第98980个数字"}
]
)print(completion.choices[0].message)python vllm_openai_completions.py
得到的返回值如下所示
ChatCompletionMessage(content=' 在C语言中，输出斐波那契数列的第98980个数字是一个非常具有挑战性的问题，因为这个数字非常大，甚至超出了标准整数类型（如`int`或`long long`）的表示范围。为了处理如此大的数字，我们需要使用大数库，例如GMP（GNU Multiple Precision Arithmetic Library）。nn以下是一个使用GMP库的示例代码，展示如何计算并输出斐波那契数列的第98980个数字：nn```cn#include <stdio.h>n#include <gmp.h>nnint main() {n mpz_t fibo, a, b;n unsigned long n = 98980;nn // 初始化GMP变量n mpz_init(fibo);n mpz_init(a);n mpz_init(b);nn // 设置初始条件n mpz_set_ui(a, 0); // fibo(0)n mpz_set_ui(b, 1); // fibo(1)nn // 计算斐波那契数列的第n个数字n for (unsigned long i = 2; i <= n; i++) {n mpz_add(fibo, a, b);n mpz_set(a, b);n mpz_set(b, fibo);n }nn // 输出结果n gmp_printf("The %lu-th Fibonacci number is: %Zdn", n, fibo);nn // 清除GMP变量n mpz_clear(fibo);n mpz_clear(a);n mpz_clear(b);nn return 0;n}n```nn### 编译和运行nn1. 确保你已经安装了GMP库。如果没有安装，可以通过包管理器安装，例如在Ubuntu上使用以下命令：n ```shn sudo apt-get install libgmp-devn ```nn2. 使用以下命令编译代码：n ```shn gcc -o fibonacci fibonacci.c -lgmpn ```nn3. 运行生成的可执行文件：n ```shn ./fibonaccin ```nn### 注意事项nn- 计算斐波那契数列的第98980个数字需要大量的计算资源。n- 即使使用GMP库，计算结果仍然需要非常长的时间。n- 输出结果的格式使用了`gmp_printf`，这是GMP库提供的格式化输出函数。nn这个示例代码展示了如何使用GMP库来处理非常大的整数并计算斐波那契数列。然而，实际计算第98980个斐波那契数列的数字可能需要很长时间，甚至可能无法在普通计算机上完成。', refusal=None, role='assistant', audio=None, function_call=None, tool_calls=[])用
curl命令测试OpenAI Chat Completions API
curl http://localhost:8000/v1/chat/completions
-H "Content-Type: application/json"
-d '{
"model": "Qwen2.5-Coder-7B-Instruct",
"messages": [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "你好，你都会什么编程语言？"}
]
}'得到的返回值如下所示
{
"id": "chat-0260307aca3e427cab90ab678a9e9196",
"object": "chat.completion",
"created": 1731659954,
"model": "Qwen2.5-Coder-7B-Instruct",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "你好，我擅长的编程语言包括Python、Java、C++和JavaScript。",
"tool_calls": [
]
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 27,
"total_tokens": 45,
"completion_tokens": 18
},
"prompt_logprobs": null}另外，在以上所有的在请求处理过程中， API 后端都会打印相对应的日志和统计信息😊 
推理速度测试
既然 vLLM 是一个高效的大型语言模型推理和部署服务系统，那么我们不妨就测试一下模型的回复生成速度。看看和原始的速度相比有多大的提升。这里直接使用 vLLM 自带的 benchmark_throughput.py 脚本进行测试。可以将当前文件夹 benchmark_throughput.py 脚本放在 /root/autodl-tmp/ 目录下；或者也可以自行下载最新版脚本
下面是一些 benchmark_throughput.py 脚本的参数说明：
--model参数指定模型路径或名称。--backend推理后端，可以是vllm、hf和mii。分布对应vLLM、HuggingFace和Mii推理后端。--input-len输入长度--output-len输出长度--num-prompts生成的 prompt 数量--seed随机种子--dtype数据类型--max-model-len模型最大长度--hf_max_batch_sizetransformers库的最大批处理大小（仅仅对于hf推理后端有效且为必填字段）--dataset数据集路径。（如未设置会自动生成数据）
测试 vLLM 推理速度的命令和参数设置
python benchmark_throughput.py --model /root/autodl-tmp/Qwen2.5-Coder-7B-Instruct --backend vllm --input-len 64 --output-len 128 --num-prompts 25 --seed 2024 --dtype float16 --max-model-len 512
得到的结果如下所示
Throughput: 8.00 requests/s, 1536.15 total tokens/s, 1024.10 output tokens/s
测试其他方式（即使用 HuggingFace 的 Transformers 库）推理速度的命令和参数设置
python benchmark_throughput.py --model /root/autodl-tmp/Qwen2.5-Coder-7B-Instruct --backend hf --input-len 64 --output-len 128 --num-prompts 25 --seed 2024 --dtype float16 --hf-max-batch-size 25
得到的结果如下所示
Throughput: 5.64 requests/s, 1083.59 total tokens/s, 722.39 output tokens/s
对比两者的推理速度，在本次测试 （单卡 RTX3090 24G ）中 vLLM 的速度要比原始的速度快 34% 左右 🤗
**注意：**本次测试并非严谨的测试，且每个人的机器配置和环境都可能存在差异，因此上述实验结果仅供作为
case参考，读者可以在自己的环境中取多个测试用例并多次实验取平均以得到严谨的实验结论。
Qwen2.5-Coder-7B-Instruct Lora 微调
本节我们简要介绍如何基于 transformers、peft 等框架，对Qwen2.5-Coder-7B-Instruct 模型进行 Lora 微调。Lora 是一种高效微调方法，深入了解其原理可参见博客：知乎|深入浅出Lora。
这个教程会在同目录下给大家提供一个 nodebook 文件，来让大家更好的学习。
模型下载
使用 modelscope 中的 snapshot_download 函数下载模型，第一个参数为模型名称，参数 cache_dir 为模型的下载路径。
在 /root/autodl-tmp 路径下新建 model_download.py 文件并在其中输入以下内容，粘贴代码后请及时保存文件，如下图所示。并运行 python /root/autodl-tmp/model_download.py 执行下载，模型大小为 14.18GB，下载模型大概需要 5 分钟。
import torchfrom modelscope import snapshot_downloadimport os
model_dir = snapshot_download('Qwen/Qwen2.5-Coder-7B-Instruct', cache_dir='/root/autodl-tmp', revision='master')环境配置
在完成基本环境配置和本地模型部署的情况下，你还需要安装一些第三方库，可以使用以下命令：
python -m pip install --upgrade pip pip install modelscope==1.20.0 pip install transformers==4.46.2 pip install sentencepiece==0.2.0 pip install accelerate==1.1.1 pip install datasets==3.1.0 pip install peft==0.13.2
考虑到部分同学配置环境可能会遇到一些问题，我们在AutoDL平台准备了Qwen2.5的环境镜像，点击下方链接并直接创建Autodl示例即可。 https://www.codewithgpu.com/i/datawhalechina/self-llm/qwen2.5-coder
在本节教程里，我们将微调数据集放置在根目录 /dataset。
指令集构建
LLM 的微调一般指指令微调过程。所谓指令微调，是说我们使用的微调数据形如：
{
"instruction":"回答以下用户问题，仅输出答案。",
"input":"1+1等于几?",
"output":"2"}其中，instruction 是用户指令，告知模型其需要完成的任务；input 是用户输入，是完成用户指令所必须的输入内容；output 是模型应该给出的输出。
即我们的核心训练目标是让模型具有理解并遵循用户指令的能力。因此，在指令集构建时，我们应针对我们的目标任务，针对性构建任务指令集。例如，在本节我们使用由笔者合作开源的 Chat-甄嬛 项目作为示例，我们的目标是构建一个能够模拟甄嬛对话风格的个性化 LLM，因此我们构造的指令形如：
{
"instruction": "你是谁？",
"input":"",
"output":"家父是大理寺少卿甄远道。"}我们所构造的全部指令数据集在根目录下。
数据格式化
Lora 训练的数据是需要经过格式化、编码之后再输入给模型进行训练的，如果是熟悉 Pytorch 模型训练流程的同学会知道，我们一般需要将输入文本编码为 input_ids，将输出文本编码为 labels，编码之后的结果都是多维的向量。我们首先定义一个预处理函数，这个函数用于对每一个样本，编码其输入、输出文本并返回一个编码后的字典：
def process_func(example):
MAX_LENGTH = 384 # Llama分词器会将一个中文字切分为多个token，因此需要放开一些最大长度，保证数据的完整性
input_ids, attention_mask, labels = [], [], []
instruction = tokenizer(f"<|im_start|>systemn现在你要扮演皇帝身边的女人--甄嬛<|im_end|>n<|im_start|>usern{example['instruction'] + example['input']}<|im_end|>n<|im_start|>assistantn", add_special_tokens=False) # add_special_tokens 不在开头加 special_tokens
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
}Qwen2.5-Coder 采用的Prompt Template格式如下：
<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>
<|im_start|>user
{user_prompt}<|im_end|>
<|im_start|>assistant
{assistant_response}<|im_end|>加载tokenizer和半精度模型
模型以半精度形式加载，如果你的显卡比较新的话，可以用torch.bfolat形式加载。对于自定义的模型一定要指定trust_remote_code参数为True。
tokenizer = AutoTokenizer.from_pretrained('/root/autodl-tmp/qwen/Qwen2-7B-Instruct/', use_fast=False, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained('/root/autodl-tmp/qwen/Qwen2-7B-Instruct/', device_map="auto",torch_dtype=torch.bfloat16)定义LoraConfig
LoraConfig这个类中可以设置很多参数，但主要的参数没多少，简单讲一讲，感兴趣的同学可以直接看源码。
task_type：模型类型target_modules：需要训练的模型层的名字，主要就是attention部分的层，不同的模型对应的层的名字不同，可以传入数组，也可以字符串，也可以正则表达式。r：lora的秩，具体可以看Lora原理lora_alpha：Lora alaph，具体作用参见Lora原理
Lora的缩放是啥嘞？当然不是r（秩），这个缩放就是lora_alpha/r, 在这个LoraConfig中缩放就是4倍。
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 比例)
自定义 TrainingArguments 参数
TrainingArguments这个类的源码也介绍了每个参数的具体作用，当然大家可以来自行探索，这里就简单说几个常用的。
output_dir：模型的输出路径per_device_train_batch_size：顾名思义batch_sizegradient_accumulation_steps: 梯度累加，如果你的显存比较小，那可以把batch_size设置小一点，梯度累加增大一些。logging_steps：多少步，输出一次lognum_train_epochs：顾名思义epochgradient_checkpointing：梯度检查，这个一旦开启，模型就必须执行model.enable_input_require_grads()，这个原理大家可以自行探索，这里就不细说了。
args = TrainingArguments( output_dir="./output/Qwen2_instruct_lora", per_device_train_batch_size=4, gradient_accumulation_steps=4, logging_steps=10, num_train_epochs=3, save_steps=100, learning_rate=1e-4, save_on_each_node=True, gradient_checkpointing=True)
使用 Trainer 训练
trainer = Trainer( model=model, args=args, train_dataset=tokenized_id, data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, padding=True), ) trainer.train()
加载 lora 权重推理
训练好了之后可以使用如下方式加载lora权重进行推理：
from transformers import AutoModelForCausalLM, AutoTokenizerimport torchfrom peft import PeftModel
model_path = 'Qwen/Qwen2.5-Coder-7B-Instruct'lora_path = 'lora_path'# 加载tokenizertokenizer = AutoTokenizer.from_pretrained(model_path)# 加载模型model = AutoModelForCausalLM.from_pretrained(model_path, device_map="auto",torch_dtype=torch.bfloat16)# 加载lora权重model = PeftModel.from_pretrained(model, model_id=lora_path, config=config)
prompt = "你是谁？"messages = [
{"role": "system", "content": "现在你要扮演皇帝身边的女人--甄嬛"},
{"role": "user", "content": prompt}
]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
model_inputs = tokenizer([text], return_tensors="pt").to('cuda')
generated_ids = model.generate(
model_inputs.input_ids,
max_new_tokens=512)
generated_ids = [
output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]print(response)Qwen2.5-7B-Instruct Langchain 接入
环境准备
本文基础环境如下：
---------------- ubuntu 22.04 python 3.12 cuda 12.1 pytorch 2.3.0 ----------------
本文默认学习者已安装好以上 Pytorch(cuda) 环境，如未安装请自行安装。
pip 换源加速下载并安装依赖包
# 升级pippython -m pip install --upgrade pip# 更换 pypi 源加速库的安装pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple pip install transformers==4.46.2 pip install modelscope==1.20.0 pip install langchain==0.3.7 pip install accelerate==1.1.1
考虑到部分同学配置环境可能会遇到一些问题，我们在AutoDL平台准备了Qwen2.5的环境镜像，点击下方链接并直接创建Autodl示例即可。 https://www.codewithgpu.com/i/datawhalechina/self-llm/qwen2.5-coder
模型下载
使用 modelscope 中的 snapshot_download 函数下载模型，第一个参数为模型名称，参数 cache_dir 为模型的下载路径。
在新建 model_download.py 文件并在其中输入以下内容，粘贴代码后记得保存文件，如下图所示。并运行 python model_download.py 执行下载，模型大小为 16 GB，下载模型大概需要 12 分钟。
import torchfrom modelscope import snapshot_download, AutoModel, AutoTokenizerimport os
model_dir = snapshot_download('Qwen/Qwen2.5-Coder-7B-Instruct', cache_dir='/root/autodl-tmp', revision='master')注意：记得修改
cache_dir为你的模型下载路径哦~
代码准备
为便捷构建 LLM 应用，我们需要基于本地部署的 Qwen2_5_Coder，自定义一个 LLM 类，将 Qwen2.5-Coder 接入到 LangChain 框架中。完成自定义 LLM 类之后，可以以完全一致的方式调用 LangChain 的接口，而无需考虑底层模型调用的不一致。
基于本地部署的 Qwen2_5_Coder 自定义 LLM 类并不复杂，我们只需从 LangChain.llms.base.LLM 类继承一个子类，并重写构造函数与 _call 函数即可：
在当前路径新建一个 LLM.py 文件，并输入以下内容，粘贴代码后记得保存文件。
from langchain.llms.base import LLMfrom typing import Any, List, Optionalfrom langchain.callbacks.manager import CallbackManagerForLLMRunfrom transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig, LlamaTokenizerFastimport torchclass Qwen2_5_Coder(LLM): # 基于本地 Qwen2_5-Coder 自定义 LLM 类
tokenizer: AutoTokenizer = None
model: AutoModelForCausalLM = None
def __init__(self, mode_name_or_path :str): super().__init__() print("正在从本地加载模型...") self.tokenizer = AutoTokenizer.from_pretrained(mode_name_or_path, use_fast=False) self.model = AutoModelForCausalLM.from_pretrained(mode_name_or_path, torch_dtype=torch.bfloat16, device_map="auto") self.model.generation_config = GenerationConfig.from_pretrained(mode_name_or_path) print("完成本地模型的加载")
def _call(self, prompt : str, stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any):
messages = [{"role": "user", "content": prompt }]
input_ids = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
model_inputs = self.tokenizer([input_ids], return_tensors="pt").to('cuda')
generated_ids = self.model.generate(model_inputs.input_ids, attention_mask=model_inputs['attention_mask'], max_new_tokens=512)
generated_ids = [
output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]
response = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
return response @property
def _llm_type(self) -> str: return "Qwen2_5_Coder"在上述类定义中，我们分别重写了构造函数和 _call 函数：对于构造函数，我们在对象实例化的一开始加载本地部署的 Qwen2_5_Coder 模型，从而避免每一次调用都需要重新加载模型带来的时间过长；_call 函数是 LLM 类的核心函数，LangChain 会调用该函数来调用 LLM，在该函数中，我们调用已实例化模型的 generate 方法，从而实现对模型的调用并返回调用结果。
在整体项目中，我们将上述代码封装为 LLM.py，后续将直接从该文件中引入自定义的 LLM 类。
调用
然后就可以像使用任何其他的langchain大模型功能一样使用了。
注意：记得修改模型路径为你的路径哦~
from LLM import Qwen2_5_Coder
llm = Qwen2_5_Coder(mode_name_or_path = "autodl-tmp/Qwen/Qwen2___5-Coder-7B-Instruct")print(llm.invoke("你是谁"))结果如下： 
既然是Coder模型，当然要试着让它编写代码
text = llm.invoke("为我用python写一个简单的猜拳小游戏，三局两胜")print(text)结果如下： 
我们试着运行一下这段代码： 
成功运行！
服务热线: 010-62128818
Email: deepelement.ai@outlook.com
注册会员开通
