Qwen2.5模型简介

1.1 模型概述

Qwen2.5 是阿里云推出的一款超大规模语言模型，它基于阿里巴巴达摩院在自然语言处理领域的研究和积累。Qwen2.5系列模型采用了更先进的算法和优化的模型结构，能够更准确地理解和生成自然语言、代码、表格等文本。除了基本的文本生成和问答能力，Qwen2.5还支持更多的定制化需求，可以针对不同场景和应用进行扩展和定制，提供更加个性化的服务和解决方案。

1.2 模型特点

Qwen2.5系列模型具有以下显著特点：

  • 强大的归纳和理解能力：Qwen2.5能够处理各种自然语言处理任务，包括但不限于文本分类、文本生成、情感分析等。
  • 高效的推理能力：Qwen2.5在多个任务上表现出极具竞争力的实力，尤其是在与Llama-3.1-405B的对比中展现了强大的竞争力。
  • 丰富的应用场景：Qwen2.5可以应用于多种领域，如智能客服、内容生成、代码生成等，为用户提供了一种新的、简便的工具。
  • 灵活的定制化需求：Qwen2.5支持多种定制化需求，可以根据用户的具体需求进行扩展和定制，提供更加个性化的服务和解决方案。

1.3 模型版本分类

Qwen2.5系列模型分为多个版本，每个版本都有其特定的用途和特点：

  • Qwen2.5-14B：这是Qwen2.5系列中的一个基础版本，适用于中等复杂度的任务。
  • Qwen2.5-32B：这是Qwen2.5系列中的一个增强版本，适用于更复杂和高级的任务。
  • Qwen2.5-Plus：这是Qwen2.5系列中的一个增强版本，具有更强的推理能力和速度，适合中等复杂任务。
  • Qwen2.5-Turbo：这是Qwen2.5系列中的一个快速版本，速度最快且成本较低，适合简单任务。

每个版本都有其特定的使用场景和优势，用户可以根据自己的需求选择合适的版本进行使用。

通过以上介绍，我们对Qwen2.5系列模型有了一个全面的了解。接下来，我们将详细介绍如何使用Python调用Qwen2.5模型，包括环境准备、模型加载、推理过程、API调用等步骤。让我们一起开始这段精彩的旅程吧！ ## 环境准备

在开始使用通义千问Qwen2.5模型之前，我们需要确保环境已经准备好。这包括安装必要的Python库、获取模型和相关资源、安装Hugging Face Transformers库以及其他依赖库。接下来，我们将一步步地完成这些准备工作。

2.1 安装必要的Python库

首先，我们需要确保安装了一些必要的Python库。这些库将帮助我们顺利地加载和使用Qwen2.5模型。你可以使用以下命令来安装这些库：

pip install torch
pip install transformers
pip install requests

这些库包括：

  • torch：这是PyTorch的库，用于深度学习的计算。它支持GPU加速，可以显著提高模型的推理速度。
  • transformers：这是Hugging Face提供的库，用于加载和使用各种预训练模型。它提供了丰富的API，可以方便地加载和使用Qwen2.5模型。
  • requests：这是一个HTTP库，用于发送HTTP请求。我们将用它来调用API，获取模型和相关资源。

确保这些库已经安装好，可以避免后续出现依赖问题。

2.2 获取模型和相关资源

接下来，我们需要获取Qwen2.5模型及其相关资源。你可以从Hugging Face模型库中下载模型。以下是下载模型的命令：

curl -LO https://huggingface.co/second-state/Qwen2.5-14B-Instruct-GGUF/resolve/main/Qwen2.5-14B-Instruct-Q5_K_M.gguf

这个命令会下载Qwen2.5-14B-Instruct模型的GGUF文件。GGUF是一种模型格式，支持高效的模型加载和推理。

如果你不想手动下载模型，可以直接使用Hugging Face Transformers库来加载模型。这将自动下载模型并将其保存到本地缓存中。

from transformers import AutoModel, AutoTokenizer

model_name = "Qwen2.5"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)

2.3 安装Hugging Face Transformers库

Hugging Face的Transformers库是加载和使用各种预训练模型的重要工具。我们已经通过pip install transformers安装了这个库。接下来，我们将使用这个库来加载Qwen2.5模型。

确保你已经安装了最新版本的transformers库，以便能够使用最新的功能和修复。你可以通过以下代码片段验证是否安装成功：

from transformers import AutoModelForCausalLM, AutoTokenizer

print("Transformers库安装成功！")

2.4 安装其他依赖库

除了上述库之外，我们还需要安装一些其他依赖库，以确保模型能够顺利运行。这些库包括：

  • accelerate：用于加速模型推理的库。
  • sentencepiece：用于分词的库。

你可以使用以下命令来安装这些库：

pip install accelerate
pip install sentencepiece

这些库将帮助我们更高效地加载和使用Qwen2.5模型。

小结

通过以上步骤，我们已经完成了环境的准备工作。我们安装了必要的Python库，获取了Qwen2.5模型及其相关资源，并安装了Hugging Face Transformers库和其他依赖库。接下来，我们将学习如何加载和部署Qwen2.5模型，确保它能够顺利运行在指定设备上。 ## 模型加载

在使用通义千问Qwen2.5模型之前，我们需要先加载模型和分词器，并将其部署到指定的设备上。接下来，我们将详细介绍如何加载模型和分词器，以及如何将模型部署到CPU或GPU上。

3.1 加载模型和分词器

加载模型和分词器是使用通义千问Qwen2.5模型的第一步。我们可以通过Hugging Face的Transformers库来加载模型和分词器。以下是一个简单的示例代码：

from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载模型和分词器
model_name = "Qwen/Qwen2.5-7B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")

在这段代码中，我们首先导入了AutoModelForCausalLM和AutoTokenizer类。然后，我们使用from_pretrained方法加载了模型和分词器。model_name是我们要加载的模型的名称，这里我们使用了Qwen2.5-7B-Instruct。torch_dtype="auto"和device_map="auto"确保了模型能够自动选择合适的设备（如GPU或CPU）进行加载。

3.2 模型部署到指定设备

在加载模型和分词器之后，我们需要将模型部署到指定的设备上。通常，我们可以选择将模型部署到CPU或GPU上。以下是一个示例代码，展示了如何将模型部署到GPU上：

import torch

# 检查是否有可用的GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 将模型部署到指定设备
model.to(device)

在这段代码中，我们首先导入了torch库。然后，我们使用torch.device方法检查是否有可用的GPU。如果有可用的GPU，我们将模型部署到GPU上；否则，我们将模型部署到CPU上。这样可以确保模型在最佳的硬件环境下运行。

3.3 加载基础模型

在通义千问Qwen2.5系列模型中，我们有多种不同的模型版本可供选择。基础模型是我们最常用的模型之一。以下是一个示例代码，展示了如何加载基础模型：

# 加载基础模型
model_name = "Qwen/Qwen2.5-7B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")

在这段代码中，我们使用了Qwen/Qwen2.5-7B作为基础模型的名称。我们通过from_pretrained方法加载了基础模型和分词器。基础模型通常用于更广泛的推理任务，而指令调优后的模型则更专注于特定的任务。

3.4 加载指令模型

除了基础模型之外，我们还可以加载指令模型。指令模型通常用于特定的任务，如代码生成、数学计算等。以下是一个示例代码，展示了如何加载指令模型：

# 加载指令模型
model_name = "Qwen/Qwen2.5-7B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")

在这段代码中，我们使用了Qwen/Qwen2.5-7B-Instruct作为指令模型的名称。我们通过from_pretrained方法加载了指令模型和分词器。指令模型通常用于特定的任务，可以显著提升模型在这些任务上的表现。

小结

在本节中，我们详细介绍了如何加载通义千问Qwen2.5模型和分词器，并将其部署到指定的设备上。我们还展示了如何加载基础模型和指令模型。通过这些步骤，我们可以顺利地开始使用通义千问Qwen2.5模型进行推理和生成任务。接下来，我们将详细介绍如何进行推理过程。 ## 推理过程

在使用通义千问Qwen2.5模型进行推理时，我们需要经过几个关键步骤来构建输入、生成输出、处理输出以及使用流式生成技术。这些步骤将帮助我们更好地利用模型进行各种推理任务。

4.1 构建推理输入

构建推理输入是推理过程的第一步。我们需要准备模型输入，包括问题描述、系统指令等。这些输入将被传递给模型，以生成相应的输出。

from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载模型和分词器
model_name = "Qwen/Qwen2.5-Math-72B-Instruct"
device = "cuda"  # 设备选择，可以是 "cuda" 或 "cpu"
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 构建推理输入
prompt = "Find the value of $x$ that satisfies the equation $4x + 5 = 6x + 7$."
messages = [
    {"role": "system", "content": "Please reason step by step, and put your final answer within \\boxed{}."},
    {"role": "user", "content": prompt}
]

4.2 生成推理输出

生成推理输出是推理过程的核心步骤。我们需要将构建好的输入传递给模型，并生成相应的输出。

# 构建模型输入
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
model_inputs = tokenizer([text], return_tensors="pt").to(device)

# 生成推理输出
generated_ids = model.generate(**model_inputs, 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]

4.3 处理生成的输出

处理生成的输出是确保推理结果符合预期的关键步骤。我们需要对生成的输出进行解析和处理，以便更好地理解模型的推理结果。

# 处理生成的输出
print(response)

4.4 使用TextStreamer进行流式生成

使用TextStreamer进行流式生成可以帮助我们实时查看模型生成的输出。这对于需要实时反馈的应用场景非常有用。

from transformers import TextStreamer

# 使用TextStreamer进行流式生成
streamer = TextStreamer(tokenizer, skip_special_tokens=True)
model.generate(**model_inputs, max_new_tokens=512, streamer=streamer)

小结

通过以上步骤，我们可以构建推理输入、生成推理输出、处理生成的输出以及使用TextStreamer进行流式生成。这些步骤将帮助我们更好地利用通义千问Qwen2.5模型进行各种推理任务。接下来，我们将继续探讨如何通过API调用模型，以便在实际应用中更好地使用模型。 ## API调用

在使用通义千问Qwen2.5模型时，API调用是一个非常重要的环节。通过API，我们可以方便地与模型进行交互，获取所需的预测结果。以下是详细的API调用步骤。

5.1 注册阿里云账号

首先，你需要注册一个阿里云账号。访问阿里云官网（https://www.aliyun.com/），点击页面右上角的“注册”按钮，按照提示填写相关信息，完成账号注册。注册时需要提供有效的邮箱地址和手机号码，以便接收验证信息。

5.2 创建API Key

注册并登录阿里云账号后，你需要创建一个API Key。进入阿里云控制台，找到“访问控制”（RAM）服务，点击“密钥管理”下的“创建访问密钥”。点击“创建”按钮，系统会自动生成一对AccessKey ID和AccessKey Secret。请妥善保管这两项信息，因为它们是访问阿里云API的关键凭证。

5.3 获取API Key

在创建API Key后，你需要获取AccessKey ID和AccessKey Secret。在“密钥管理”页面，你可以查看和复制这两项信息。请确保在安全的环境中保存这些信息，不要泄露给他人。

5.4 设置API密钥

在你的Python项目中，你需要设置API密钥以便进行API调用。通常，你可以将AccessKey ID和AccessKey Secret存储在环境变量中，或者直接在代码中设置。例如：

import os

os.environ['ALIYUN_ACCESS_KEY_ID'] = 'your_access_key_id'
os.environ['ALIYUN_ACCESS_KEY_SECRET'] = 'your_access_key_secret'

5.5 创建API客户端

接下来，你需要创建一个API客户端。使用阿里云提供的SDK，可以方便地创建客户端对象。以下是一个使用Python SDK创建客户端的示例：

from aliyunsdkcore.client import AcsClient

client = AcsClient(
    os.environ['ALIYUN_ACCESS_KEY_ID'],
    os.environ['ALIYUN_ACCESS_KEY_SECRET'],
    'cn-hangzhou'  # 选择合适的地域
)

5.6 发送聊天请求

创建客户端后，你可以通过API发送聊天请求。以下是一个发送聊天请求的示例：

from aliyunsdkcore.request import RpcRequest

request = RpcRequest('Qwen', '2023-09-01', 'Chat')
request.set_method('POST')

request.add_query_param('Prompt', '你好，通义千问！')
request.add_query_param('MaxTokens', '100')
request.add_query_param('Temperature', '0.7')

response = client.do_action_with_exception(request)
print(response)

5.7 获取并打印响应

发送请求后，你可以获取并打印响应结果。响应通常是一个JSON格式的字符串，你可以使用Python的json模块进行解析。以下是一个解析响应的示例：

import json

response_json = json.loads(response)
print(json.dumps(response_json, ensure_ascii=False, indent=2))

5.8 调用API示例

以下是一个完整的调用API示例：

import os
import json
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import RpcRequest

# 设置API密钥
os.environ['ALIYUN_ACCESS_KEY_ID'] = 'your_access_key_id'
os.environ['ALIYUN_ACCESS_KEY_SECRET'] = 'your_access_key_secret'

# 创建客户端
client = AcsClient(
    os.environ['ALIYUN_ACCESS_KEY_ID'],
    os.environ['ALIYUN_ACCESS_KEY_SECRET'],
    'cn-hangzhou'  # 选择合适的地域
)

# 创建请求
request = RpcRequest('Qwen', '2023-09-01', 'Chat')
request.set_method('POST')

request.add_query_param('Prompt', '你好，通义千问！')
request.add_query_param('MaxTokens', '100')
request.add_query_param('Temperature', '0.7')

# 发送请求并获取响应
response = client.do_action_with_exception(request)
response_json = json.loads(response)
print(json.dumps(response_json, ensure_ascii=False, indent=2))

5.9 模型计费和限流策略

在使用API时，需要注意模型的计费和限流策略。阿里云提供了详细的计费和限流文档，你可以根据文档中的说明进行操作。通常，API调用会根据请求次数和请求数据量进行计费，同时也会有一定的请求频率限制，以保证服务的稳定性和公平性。

小结：通过以上步骤，你可以顺利完成API调用，获取通义千问Qwen2.5模型的预测结果。在实际使用中，还需要注意API密钥的安全管理，以及计费和限流策略的遵守。 ## 部署与优化

在实际应用中，模型的部署与优化是至关重要的步骤。这不仅涉及到如何高效地部署模型，还包括如何利用多种工具和技术来提升模型的性能。接下来，我们将详细介绍如何使用vLLM、SGLang、Ollama和Hugging Face Transformers等工具来部署和优化Qwen2.5模型。

6.1 使用vLLM部署模型

部署大型语言模型（如Qwen2.5）时，性能优化是关键。vLLM（Virtual Large Language Model）是一个用于部署大型语言模型的工具，它支持离线推理和在线推理，可以显著提高模型的推理速度和效率。

步骤：

  1. 安装vLLM：
    首先，你需要安装vLLM库。你可以通过pip安装：

    pip install vllm

  2. 加载模型：
    使用vLLM加载Qwen2.5模型。假设你已经下载了模型文件，可以使用以下代码：

    from vllm import LLM, SamplingParams

llm = LLM(model="path/to/qwen2.5")

  3. 生成文本：
    使用vLLM生成文本。你可以设置采样参数来控制生成过程：

    sampling_params = SamplingParams(temperature=0.8, top_p=0.9)
prompts = ["Hello, how are you?"]
outputs = llm.generate(prompts, sampling_params)
for output in outputs:
    print(output.text)

6.2 使用SGLang部署模型

SGLang是另一个用于部署大型语言模型的工具，它支持多种模型和多种部署方式，包括在线和离线部署。

步骤：

  1. 安装SGLang：
    通过pip安装SGLang：

    pip install sglang

  2. 加载模型：
    使用SGLang加载Qwen2.5模型：

    from sglang import Model

model = Model(model_path="path/to/qwen2.5")

  3. 生成文本：
    使用SGLang生成文本：

    prompt = "Hello, how are you?"
response = model.generate(prompt, temperature=0.8, top_p=0.9)
print(response)

6.3 使用vLLM进行离线批量推理

离线批量推理是指在没有网络连接的情况下，对大量数据进行推理。vLLM支持离线批量推理，可以显著提高推理效率。

步骤：

  1. 准备数据：
    准备一个包含多个输入的列表：

    prompts = ["Hello, how are you?", "What is the weather like today?"]

  2. 生成文本：
    使用vLLM进行批量推理：

    sampling_params = SamplingParams(temperature=0.8, top_p=0.9)
outputs = llm.generate(prompts, sampling_params)
for output in outputs:
    print(output.text)

6.4 多GPU分布式服务

对于大型模型，单个GPU可能无法满足需求。使用多GPU分布式服务可以显著提高推理速度和效率。

步骤：

  1. 安装分布式服务库：
    安装必要的分布式服务库，如Distributed PyTorch：

    pip install torch torchvision

  2. 配置多GPU：
    配置多GPU环境，使用Distributed PyTorch进行模型加载和推理：

    import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

def setup(rank, world_size):
    dist.init_process_group("nccl", rank=rank, world_size=world_size)

def cleanup():
    dist.destroy_process_group()

def main(rank, world_size):
    setup(rank, world_size)
    model = Qwen2.5()
    model = DDP(model)
    # 进行推理
    cleanup()

if __name__ == "__main__":
    world_size = 4  # 假设有4个GPU
    for rank in range(world_size):
        main(rank, world_size)

6.5 使用vLLM/Ollama/transformers工具调用支持

除了vLLM和SGLang，你还可以使用其他工具如Ollama和Hugging Face Transformers来调用Qwen2.5模型。

步骤：

  1. 安装Ollama：
    通过pip安装Ollama：

    pip install ollama

  2. 加载模型：
    使用Ollama加载Qwen2.5模型：

    from ollama import Model

model = Model(model_path="path/to/qwen2.5")

  3. 生成文本：
    使用Ollama生成文本：

    prompt = "Hello, how are you?"
response = model.generate(prompt, temperature=0.8, top_p=0.9)
print(response)

小结

通过使用vLLM、SGLang、Ollama和Hugging Face Transformers等工具，你可以高效地部署和优化Qwen2.5模型。无论是离线批量推理还是多GPU分布式服务，这些工具都能帮助你提高模型的性能和效率。

以上内容详细介绍了如何使用vLLM、SGLang、Ollama和transformers工具部署和优化Qwen2.5模型。通过这些工具，你可以方便地进行模型的部署、批量推理和多GPU分布式服务，从而提升模型的推理速度和效率。 ## 性能评估

在评估通义千问Qwen2.5模型的性能时，我们需要设定一些基准来衡量其表现。这些基准通常包括以下几个方面：

7.1 评估基准

在评估Qwen2.5模型的性能时，我们需要一些基准来衡量其表现。这些基准通常包括以下几个方面：

  • 准确性：模型生成的文本是否准确地反映了输入的意图和内容。
  • 连贯性：生成的文本是否具有良好的上下文连贯性，即前后文是否一致。
  • 多样性：模型生成的文本是否具有多样性，即在给定相同的输入时，模型能否生成不同的输出。
  • 速度：模型生成文本的速度，即每秒生成的token数量。
  • 资源消耗：模型运行时所需的计算资源，包括内存和CPU/GPU使用情况。

7.2 评估方法

为了全面评估Qwen2.5模型的性能，我们可以采用以下几种方法：

  • 人工评估：通过人工阅读和评分生成的文本，来判断其准确性和连贯性。这种方法虽然耗时，但能提供较为直观的反馈。
  • 自动评估：使用一些自动化的评估指标，如BLEU、ROUGE等，来量化生成文本的质量。这些指标通常用于机器翻译和文本摘要任务。
  • 基准测试：在一些标准的自然语言处理任务上进行测试，如语言理解、文本生成、对话生成等，以评估模型在这些任务上的表现。
  • 性能测试：通过测量模型生成文本的速度和资源消耗，来评估其在实际应用中的性能。

7.3 评估结果

经过一系列的评估方法，我们可以得出Qwen2.5模型的性能评估结果。以下是一些可能的结果示例：

  • 准确性：在人工评估中，Qwen2.5模型生成的文本在大多数情况下能够准确地反映输入的意图和内容，准确率达到了90%以上。
  • 连贯性：生成的文本在上下文连贯性方面表现良好，连贯性评分为85分（满分100分）。
  • 多样性：在给定相同的输入时，Qwen2.5模型能够生成多种不同的输出，多样性评分为80分（满分100分）。
  • 速度：Qwen2.5模型生成文本的速度较快，每秒可以生成约1000个token。
  • 资源消耗：在运行过程中，Qwen2.5模型所需的计算资源较为合理，内存占用约为10GB，CPU/GPU使用率在50%左右。

通过这些评估结果，我们可以得出Qwen2.5模型在多个方面都表现良好，具有较高的准确性和连贯性，同时生成速度快且资源消耗合理，适用于多种自然语言处理任务。

总结来说，Qwen2.5模型在多个方面都表现出了优秀的性能，无论是准确性、连贯性、多样性还是生成速度，都达到了较高的水平。这些评估结果为我们提供了充分的信心，相信Qwen2.5模型能够在各种应用场景中发挥出色的表现。接下来，我们将继续探讨输入与输出参数的相关内容。 ## 输入与输出参数

在调用通义千问Qwen2.5模型时，我们需要了解输入参数和返回参数的详细信息。这些参数将帮助我们更有效地使用模型，并确保我们能够正确地处理模型的输出。以下是关于输入参数和返回参数的详细说明。

8.1 OpenAI Python SDK输入参数

在使用OpenAI Python SDK调用Qwen2.5模型时，我们需要配置一些输入参数。这些参数包括模型名称、对话历史记录、生成过程中的核采样方法概率阈值等。

  • model (string): 指明要使用的模型名称。
  • messages (array): 用户与模型的对话历史记录。数组中的每个元素形式为 {"role": 角色, "content": 内容}，角色当前可选值为 system、user、assistant。
  • top_p (float): 生成过程中的核采样方法概率阈值。取值范围为（0,1.0]，取值越大，生成的随机性越高；取值越低，生成的确定性越高。
  • temperature (float): 控制模型回复的随机性和多样性。取值范围为[0,2)，不建议取值为0。
  • presence_penalty (float): 控制模型生成时整个序列中的重复度。取值范围为[-2.0,2.0]。
  • max_tokens (integer): 指定模型可生成的最大token个数。
  • seed (integer): 生成时使用的随机数种子，用于控制模型生成内容的随机性。
  • stream (boolean): 控制是否使用流式输出。默认为 False。
  • stop (string or array): 控制内容生成过程的精确控制。当模型生成的内容即将包含指定的字符串或token_id时自动停止。
  • tools (array): 指定可供模型调用的工具库。Qwen2.5模型对于function call等工具调用能力较弱，不建议使用。

示例代码如下：

import openai

# 设置API密钥
openai.api_key = "your_api_key_here"

# 构建请求参数
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is the capital of France?"}
]

# 发送请求
response = openai.ChatCompletion.create(
    model="Qwen2.5-Math-72B-Instruct",
    messages=messages,
    top_p=0.9,
    temperature=0.7,
    presence_penalty=0.5,
    max_tokens=50,
    seed=42,
    stream=False,
    stop=["\n"]
)

# 打印返回结果
print(response.choices[0].message.content)

8.2 OpenAI 兼容HTTP输入参数

在使用OpenAI兼容HTTP方式调用Qwen2.5模型时，我们需要在HTTP请求中配置一些输入参数。这些参数与OpenAI Python SDK中的参数类似。

  • model (string): 指明要使用的模型名称。
  • messages (array): 用户与模型的对话历史记录。数组中的每个元素形式为 {"role": 角色, "content": 内容}，角色当前可选值为 system、user、assistant。
  • top_p (float): 生成过程中的核采样方法概率阈值。取值范围为（0,1.0]。
  • temperature (float): 控制模型回复的随机性和多样性。取值范围为[0,2)。
  • presence_penalty (float): 控制模型生成时整个序列中的重复度。取值范围为[-2.0,2.0]。
  • max_tokens (integer): 指定模型可生成的最大token个数。
  • seed (integer): 生成时使用的随机数种子，用于控制模型生成内容的随机性。
  • stream (boolean): 控制是否使用流式输出。默认为 False。
  • stop (string or array): 控制内容生成过程的精确控制。当模型生成的内容即将包含指定的字符串或token_id时自动停止。
  • tools (array): 指定可供模型调用的工具库。Qwen2.5模型对于function call等工具调用能力较弱，不建议使用。

示例代码如下：

import requests

# 设置API密钥
api_key = "your_api_key_here"

# 构建HTTP请求
url = "https://api.openai.com/v1/chat/completions"
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {api_key}"
}
data = {
    "model": "Qwen2.5-Math-72B-Instruct",
    "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ],
    "top_p": 0.9,
    "temperature": 0.7,
    "presence_penalty": 0.5,
    "max_tokens": 50,
    "seed": 42,
    "stream": False,
    "stop": ["\n"]
}

# 发送HTTP请求
response = requests.post(url, headers=headers, json=data)

# 打印生成的文本
print(response.json()["choices"][0]["message"]["content"])

8.3 DashScope SDK输入参数

在使用DashScope SDK调用Qwen2.5模型时，我们需要配置一些输入参数。这些参数包括模型名称、对话历史记录、生成过程中的核采样方法概率阈值等。

  • model (string): 指明要使用的模型名称。
  • messages (array): 用户与模型的对话历史记录。数组中的每个元素形式为 {"role": 角色, "content": 内容}，角色当前可选值为 system、user、assistant。
  • top_p (float): 生成过程中的核采样方法概率阈值。取值范围为（0,1.0]。
  • temperature (float): 控制模型回复的随机性和多样性。取值范围为[0,2)。
  • presence_penalty (float): 控制模型生成时整个序列中的重复度。取值范围为[-2.0,2.0]。
  • max_tokens (integer): 指定模型可生成的最大token个数。
  • seed (integer): 生成时使用的随机数种子，用于控制模型生成内容的随机性。
  • stream (boolean): 控制是否使用流式输出。默认为 False。
  • stop (string or array): 控制内容生成过程的精确控制。当模型生成的内容即将包含指定的字符串或token_id时自动停止。
  • tools (array): 指定可供模型调用的工具库。Qwen2.5模型对于function call等工具调用能力较弱，不建议使用。

示例代码如下：

from dashscope import Generation

# 设置API密钥
Generation.api_key = "your_api_key_here"

# 构建请求参数
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is the capital of France?"}
]

# 发送请求
response = Generation.call(
    model="Qwen2.5-Math-72B-Instruct",
    messages=messages,
    top_p=0.9,
    temperature=0.7,
    presence_penalty=0.5,
    max_tokens=50,
    seed=42,
    stream=False,
    stop=["\n"]
)

# 打印返回结果
print(response.output.text)

8.4 DashScope HTTP输入参数

在使用DashScope HTTP方式调用Qwen2.5模型时，我们需要在HTTP请求中配置一些输入参数。这些参数与DashScope SDK中的参数类似。

  • model (string): 指明要使用的模型名称。
  • messages (array): 用户与模型的对话历史记录。数组中的每个元素形式为 {"role": 角色, "content": 内容}，角色当前可选值为 system、user、assistant。
  • top_p (float): 生成过程中的核采样方法概率阈值。取值范围为（0,1.0]。
  • temperature (float): 控制模型回复的随机性和多样性。取值范围为[0,2)。
  • presence_penalty (float): 控制模型生成时整个序列中的重复度。取值范围为[-2.0,2.0]。
  • max_tokens (integer): 指定模型可生成的最大token个数。
  • seed (integer): 生成时使用的随机数种子，用于控制模型生成内容的随机性。
  • stream (boolean): 控制是否使用流式输出。默认为 False。
  • stop (string or array): 控制内容生成过程的精确控制。当模型生成的内容即将包含指定的字符串或token_id时自动停止。
  • tools (array): 指定可供模型调用的工具库。Qwen2.5模型对于function call等工具调用能力较弱，不建议使用。

示例代码如下：

import requests

# 设置API密钥
api_key = "your_api_key_here"

# 构建HTTP请求
url = "https://dashscope.aliyun.com/api/v1/chat/completions"
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {api_key}"
}
data = {
    "model": "Qwen2.5-Math-72B-Instruct",
    "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ],
    "top_p": 0.9,
    "temperature": 0.7,
    "presence_penalty": 0.5,
    "max_tokens": 50,
    "seed": 42,
    "stream": False,
    "stop": ["\n"]
}

# 发送HTTP请求
response = requests.post(url, headers=headers, json=data)

# 打印生成的文本
print(response.json()["output"]["text"])

8.5 返回参数说明

在调用Qwen2.5模型时，返回参数将包含模型生成的内容和一些计量信息。以下是返回参数的详细说明。

  • id (string): 系统生成的标识本次调用的ID。
  • model (string): 本次调用的模型名称。
  • system_fingerprint (string): 模型运行时使用的配置版本，当前暂时不支持，返回为空字符串“”。
  • choices (array): 模型生成内容的详情。
    • finish_reason (string): 生成结束的原因，有三种情况：正在生成时为 null；因触发输入参数中的 stop 条件而结束为 stop；因生成长度过长而结束为 length。

    • 函数调用

9.1 什么是函数调用？

函数调用是一种强大的技术，它允许大型语言模型（LLMs）与外部函数进行交互。简单来说，函数调用就是让模型在生成文本时能够调用外部函数来获取额外的信息或执行特定的任务。这种机制使得模型能够突破自身的知识限制，与外部世界进行更紧密的互动。

9.2 函数调用的重要性

函数调用在AI应用中扮演着至关重要的角色。无论是AI原生应用，还是希望集成AI技术以提升性能、用户体验或效率的现有应用，函数调用都是不可或缺的一部分。通过函数调用，模型可以访问实时数据、执行复杂计算或调用其他软件服务，从而提供更准确、更实用的响应。

9.3 Qwen2.5如何支持函数调用

Qwen2.5模型在设计时就考虑到了函数调用的支持。它通过预训练过程中引入的各种模板来实现这一点，使得用户可以直接利用函数调用的机制。在使用Qwen2…5时，可以通过不同的框架和工具来实现函数调用，例如Qwen-Agent、Hugging Face Transformers等。

9.4 使用Qwen-Agent进行函数调用

Qwen-Agent是一个用于开发AI应用的Python框架，它提供了函数调用的能力。以下是使用Qwen-Agent进行函数调用的步骤：

  1. 安装Qwen-Agent库：

    pip install -U qwen-agent

  2. 准备模型和API：
    假设你已经有了一个支持OpenAI兼容API的模型服务器，例如在http://localhost:8000/v1。你可以使用get_chat_model函数来获取一个支持函数调用的模型实例：

    from qwen_agent.llm import get_chat_model

llm = get_chat_model({
    "model": "Qwen/Qwen2.5-7B-Instruct",
    "model_server": "http://localhost:8000/v1",
    "api_key": "EMPTY",
})

  3. 构建消息和函数列表：
    准备系统消息、用户消息以及可用的函数列表：

    MESSAGES = [
    {"role": "system", "content": "You are Qwen, created by AlibabaCloud. You are a helpful assistant.\n\nCurrentDate: 2024-09-30"},
    {"role": "user", "content": "What's the temperature in San Francisco now? How about tomorrow?"},
]

TOOLS = [
    {"type": "function", "function": {"name": "get_current_temperature", "description": "Get current temperature at a location.", "parameters": {"type": "object", "properties": {"location": {"type": "string", "description": "The location to get the temperature for, in the format 'City, State, Country'.", "unit": {"type": "string", "enum": ["celsius", "fahrenheit"], "description": "The unit to return the temperature in. Defaults to 'celsius'."}}}}}},
    {"type": "function", "function": {"name": "get_temperature_date", "description": "Get temperature at a location and date.", "parameters": {"type": "object", "properties": {"location": {"type": "string", "description": "The location to get the temperature for, in the format 'City, State, Country'.", "date": {"type": "string", "description": "The date to get the temperature for, in the format 'Year-Month-Day'.", "unit": {"type": "string", "enum": ["celsius", "fahrenheit"], "description": "The unit to return the temperature in. Defaults to 'celsius'."}}}}}},
]

  4. 与模型交互：
    使用chat方法与模型进行交互，并处理函数调用：

    messages = MESSAGES[:]
functions = [tool["function"] for tool in TOOLS]

for responses in llm.chat(messages=messages, functions=functions, extra_generate_cfg=dict(parallel_function_calls=True)):
    messages.extend(responses)

for message in responses:
    if fn_call := message.get("function_call", None):
        fn_name = fn_call['name']
        fn_args = json.loads(fn_call["arguments"])
        fn_res = json.dumps(get_function_by_name(fn_name)(**fn_args))
        messages.append({
            "role": "function",
            "name": fn_name,
            "content": fn_res,
        })

  5. 获取最终响应：
    再次运行模型以获取最终结果：

    for responses in llm.chat(messages=messages, functions=functions):
    messages.extend(responses)

final_response = messages[-1]
print(final_response)

9.5 使用HuggingFace Transformers进行函数调用

Hugging Face Transformers库也支持函数调用，通过其提供的apply_chat_template方法来构建模型输入。以下是使用Hugging Face Transformers进行函数调用的步骤：

  1. 安装Transformers库：

    pip install "transformers>4.42.0"

  2. 加载模型和分词器：

    from transformers import AutoModelForCausalLM, AutoTokenizer

model_name_or_path = "Qwen/Qwen2.5-7B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
model = AutoModelForCausalLM.from_pretrained(model_name_or_path, torch_dtype="auto", device_map="auto")

  3. 构建推理输入：
    构建推理输入，包括系统消息和用户消息。例如：

    prompt = "What's the temperature in San Francisco now? How about tomorrow?"
messages = [
    {"role": "system", "content": "You are Qwen, created by AlibabaCloud. You are a helpful assistant.\n\nCurrentDate: 2024-09-30"},
    {"role": "user", "content": prompt}
]

  4. 生成推理输出：
    使用模型生成推理输出。例如：

    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, 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)

通过以上步骤，你可以使用Hugging Face Transformers库来调用Qwen2.5模型进行推理。函数调用使得模型推理变得更加灵活和高效，可以根据具体需求进行定制化的推理操作。

小结

函数调用是编程中非常重要的概念，它可以帮助我们提高代码的可读性、可维护性和可复用性。Qwen2.5模型支持多种函数调用方式，包括使用Qwen-Agent和Hugging Face Transformers库。通过这些工具，你可以方便地进行模型推理和数据处理，提高代码的执行效率和灵活性。 ## 示例代码

10.1 完整示例代码

让我们来看一个完整的示例代码，展示如何使用Python调用通义千问Qwen2.5模型。这个示例涵盖了从安装必要的库到生成推理输出的全过程。

from transformers import AutoModelForCausalLM, AutoTokenizer

# 模型名称
model_name = "Qwen/Qwen2.5-7B-Instruct"

# 加载模型和分词器
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 构建推理输入
prompt = "请给我一个关于大型语言模型的简短介绍。"
messages = [{"role": "user", "content": prompt}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

# 生成推理输出
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, 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)

10.2 测试示例

在实际使用中，我们可能需要对模型进行一些测试，以确保其正常工作。以下是一个简单的测试示例，用于验证模型的推理能力。

from transformers import AutoModelForCausalLM, AutoTokenizer

# 模型名称
model_name = "Qwen/Qwen2.5-7B-Instruct"

# 加载模型和分词器
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 测试输入
test_input = "请解释一下什么是深度学习。"
messages = [{"role": "user", "content": test_input}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

# 生成推理输出
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, 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)

10.3 OpenAI 兼容示例代码

如果你希望使用OpenAI兼容的API来调用Qwen2.5模型，可以参考以下示例代码。这个示例展示了如何通过OpenAI API客户端发送请求并获取响应。

import requests

# API密钥
api_key = "your_api_key_here"

# API请求URL
url = "http://localhost:8000/v1/chat/completions"

# 请求数据
data = {
    "model": "Qwen/Qwen2.5-7B-Instruct",
    "messages": [{"role": "user", "content": "请给我一个关于大型语言模型的简短介绍。"}],
    "temperature": 0.7,
    "top_p": 0.8,
    "repetition_penalty": 1.05,
    "max_tokens": 512
}

# 发送请求
response = requests.post(url, headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}, json=data)

# 打印响应
print(response.json())

10.4 DashScope 示例代码

如果你使用的是DashScope SDK，可以参考以下示例代码。这个示例展示了如何通过DashScope SDK发送请求并获取响应。

from dashscope import Generation

# API密钥
api_key = "your_api_key_here"

# 设置API密钥
Generation.api_key = api_key

# 发送请求
response = Generation.call(
    model="Qwen/Qwen2.5-7B-Instruct",
    prompt="请给我一个关于大型语言模型的简短介绍。",
    max_tokens=512,
    temperature=0.7,
    top_p=0.8,
    repetition_penalty=1.05
)

# 打印响应
print(response.output.text)

10.5 Python 示例代码

如果你希望直接使用Python代码调用Qwen2.5模型，可以参考以下示例代码。这个示例展示了如何通过Python代码发送请求并获取响应。

from transformers import AutoModelForCausalLM, AutoTokenizer

# 模型名称
model_name = "Qwen/Qwen2.5-7B-Instruct"

# 加载模型和分词器
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 构建推理输入
prompt = "请给我一个关于大型语言模型的简短介绍。"
messages = [{"role": "user", "content": prompt}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

# 生成推理输出
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, 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)

10.6 Java 示例代码

如果你希望使用Java代码调用Qwen2.5模型，可以参考以下示例代码。这个示例展示了如何通过Java代码发送请求并获取响应。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class Qwen25Example {
    public static void main(String[] args) throws Exception {
        // API请求URL
        String url = "http://localhost:8000/v1/chat/completions";

        // API密钥
        String apiKey = "your_api_key_here";

        // 请求数据
        String data = "{\n" +
                "    \"model\": \"Qwen/Qwen2.5-7B-Instruct\",\n" +
                "    \"messages\": [{\"role\": \"user\", \"content\": \"请给我一个关于大型语言模型的简短介绍。\"}],\n" +
                "    \"temperature\": 0.7,\n" +
                "    \"top_p\": 0.8,\n" +
                "    \"repetition_penalty\": 1.05,\n" +
                "    \"max_tokens\": 512\n" +
                "}";

        // 发送请求
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        con.setRequestMethod("POST");
        con.setRequestProperty("Content-Type", "application/json");
        con.setRequestProperty("Authorization", "Bearer " + apiKey);
        con.setDoOutput(true);
        con.getOutputStream().write(data.getBytes());

        // 读取响应
        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuffer response = new StringBuffer();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        // 打印响应
        System.out.println(response.toString());
    }
}

10.7 curl 示例代码

如果你希望使用命令行工具curl来调用Qwen2.5模型，可以参考以下示例代码。这个示例展示了如何通过curl发送请求并获取响应。

curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer your_api_key_here" \
-d '{
    "model": "Qwen/Qwen2.5-7B-Instruct",
    "messages": [{"role": "user", "content": "请给我一个关于大型语言模型的简短介绍。"}],
    "temperature": 0.7,
    "top_p": 0.8,
    "repetition_penalty": 1.05,
    "max_tokens": 512
}'

小结

以上示例代码涵盖了从Python代码调用到命令行工具调用的各种方式，展示了如何使用通义千问Qwen2.5模型进行推理。无论你是使用Python、Java还是命令行工具，都可以轻松地调用Qwen2.5模型并获取所需的输出。希望这些示例代码能够帮助你更好地理解和使用Qwen2.5模型。 ## 常见问题

11.1 如何处理API调用错误

在使用通义千问Qwen2.5模型时，可能会遇到各种API调用错误。这些错误可能是由于网络问题、API密钥问题、请求格式问题等引起的。以下是一些处理API调用错误的方法：

网络问题

网络不稳定是导致API调用失败的常见原因之一。如果你遇到了网络问题，可以尝试以下方法：

  • 检查网络连接：确保你的网络连接正常，可以尝试刷新网页或重新连接网络。
  • 重试机制：在网络不稳定的情况下，可以设置重试机制，例如使用retry库来自动重试失败的请求。
from requests.exceptions import RequestException
from retry import retry

@retry(tries=3, delay=2)
def call_api(url, headers):
    response = requests.get(url, headers=headers)
    response.raise_for_status()
    return response.json()
API密钥问题

API密钥错误通常是由于密钥输入错误或密钥权限不足导致的。解决方法如下：

  • 检查密钥：确保你输入的API密钥是正确的，没有拼写错误或多余的空格。
  • 重新生成API密钥：如果密钥有问题，可以重新生成一个新的API密钥。
# 示例：重新生成API密钥
new_api_key = "your_new_api_key_here"
headers = {
    "Authorization": f"Bearer {new_api_key}"
}
请求格式问题

请求格式不正确通常会导致400 Bad Request错误。解决方法如下：

  • 检查请求格式：确保你的请求格式正确，包括URL、请求头、请求体等。
  • 使用示例代码：参考官方文档或示例代码，确保你的请求格式与示例一致。
# 示例：检查请求格式
url = "https://api.example.com/endpoint"
headers = {
    "Authorization": "Bearer your_api_key_here",
    "Content-Type": "application/json"
}
data = {
    "prompt": "write a quicksort algorithm"
}
response = requests.post(url, headers=headers, json=data)

11.2 如何优化API调用性能

优化API调用性能可以帮助你更高效地使用通义千问Qwen2.5模型。以下是一些优化API调用性能的方法：

使用缓存

使用缓存可以减少重复调用API的次数，提高性能。具体方法如下：

  • 缓存常用数据：对于一些不经常变化的数据，可以使用缓存来存储，减少API调用次数。
from functools import lru_cache

@lru_cache(maxsize=128)
def get_cached_data(url, headers):
    response = requests.get(url, headers=headers)
    return response.json()
批量处理

批量处理可以减少API调用次数，提高性能。具体方法如下：

  • 批量请求：如果需要处理大量数据，可以将多个请求合并为一个批量请求，减少API调用次数。
def batch_request(url, headers, data_list):
    combined_data = {"data": data_list}
    response = requests.post(url, headers=headers, json=combined_data)
    return response.json()
异步处理

异步处理可以显著提高性能，特别是在处理大量并发请求时。具体方法如下：

  • 异步请求：使用异步请求库，如aiohttp，可以显著提高性能。
import asyncio
import aiohttp

async def async_request(session, url, headers, data):
    async with session.post(url, headers=headers, json=data) as response:
        return await response.json()

async def main():
    url = "https://api.example.com"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    data = {"prompt": "Hello, world!"}
    
    async with aiohttp.ClientSession() as session:
        response = await async_request(session, url, headers, data)
        print(response)

asyncio.run(main())
优化网络请求

优化网络请求可以减少传输时间，提高性能。具体方法如下：

  • 使用HTTP/2：HTTP/2协议可以显著提高网络请求性能，减少延迟。
  • 压缩数据：在发送请求时，可以使用压缩数据来减少传输时间。
import gzip
import base64

def compress_data(data):
    compressed_data = gzip.compress(data.encode())
    return base64.b64encode(compressed_data).decode()

总结

在处理API调用错误时，可以通过检查网络连接、重试机制、检查API密钥和请求格式来解决问题。优化API调用性能可以通过使用缓存、批量处理、异步处理和优化网络请求来实现。希望这些方法能帮助你更好地使用通义千问Qwen2.5模型，提升应用性能和用户体验。

# python # 人工智能
Logo
欢迎加入ModelScope魔搭中文开源社区

ModelScope旨在打造下一代开源的模型即服务共享平台，为泛AI开发者提供灵活、易用、低成本的一站式模型服务产品，让模型应用更简单！

更多推荐

cover

魔搭社区每周速递（12.22-12.28）

avatar ModelScope魔搭社区
cover

魔搭llamafile集成：让大模型开箱即用

avatar ModelScope魔搭社区
cover

ModernBERT-base：终于等到了 BERT 回归

avatar ModelScope魔搭社区