Python调用通义千问qwen2.5模型步骤

于 2024-09-30 09:46:54 发布
阅读量567 收藏 9
点赞数 13
文章标签： python 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40999403/article/details/142649843
版权

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模型，提升应用性能和用户体验。

我就是全世界
关注
通义千问7B本地部署的实战方案
herosunly的博客
08-06 6万+
本文主要介绍了通义千问7B本地部署的实战方案，希望对学习大语言模型的同学们有所帮助。 文章目录 1. 介绍 2. 配置环境 2.1 安装虚拟环境 2.2 安装依赖库 3. 下载权重文件 4. 运行通义千问7B
通义千问部署搭建
huiguo_的博客
09-01 7750
为了方便我把模型移动到一开始的文件夹里面。然后ctrl+s 保存。这就好了，重新运行下。也可以使用web依赖。
开源模型应用落地-Qwen2.5-Coder模型小试-码无止境（一）
没有卑微的工作，只有卑微的心态，与其抱怨，不如埋头实干
09-23 3627
使用Qwen2.5-Coder-7B-Instruct模型，帮助开发人员获得高效、准确和个性化的代码支持
【AI大模型】通义千问：开启语言模型新篇章与Function Call技术的应用探索
啊猪是的读来过倒的博客
08-01 3005
在人工智能的不断演进中，大模型正成为技术革新的先锋。这些模型以其庞大的规模和深刻的理解力，开启了智能应用的新篇章。本文将精炼地探讨大模型的核心概念、发展历程，以及它们在多个场景下的实际应用。我们将重点介绍通义千问，这一前沿的语言模型，它在技术突破和实际应用中展现了卓越的灵活性和广泛性。从单轮到多轮对话，从实时交互到异步通信，通义千问的应用场景广泛而深远。此外，文章还将讨论大模型面对的挑战，例如实时性问题和特定领域知识的处理，并探索Function call技术如何帮助提升其性能。
必看！阿里通义千问完整技术报告
TheArtofLLMs的博客
03-07 2819
摘要 大型语言模型（LLMs）已经彻底改变了人工智能领域，使得以前被认为是人类专属的自然语言处理任务成为实现可能。在这项工作中，我们介绍了QWEN，我们大型语言模型系列的第一个版本。QWEN是一个全面的语言模型系列，包括参数数量不同的不同模型。它包括QWEN，基础预训练语言模型，以及QWEN-CHAT，使用人类对齐技术微调的聊天模型。基础语言模型在多种下游任务中始终表现出优异的性能，而聊天模型，特别是那些使用人类反馈强化学习（RLHF）训练的模型，具有很高的竞争力。聊天模型具有先进的工具使用和规划能力，可用
实战精选 | 5分钟利用 OpenVINO™ 部署 Qwen2.5
huang9604的博客
09-25 649
本文将以 Qwen2.5-7B-Instruct 为例，介绍如何利用 OpenVINO™ 的 Python API 在本地部署 Qwen2.5 系列模型。
RAG 实践-Ollama+AnythingLLM 搭建本地知识库_anythingllm+通义千问
2401_85379281的博客
07-08 1226
RAG，即检索增强生成（Retrieval-Augmented Generation），是一种先进的自然语言处理技术架构，它旨在克服传统大型语言模型（LLMs）在处理开放域问题时的信息容量限制和时效性不足。RAG的核心机制融合了信息检索系统的精确性和语言模型的强大生成能力，为基于自然语言的任务提供了更为灵活和精准的解决方案。
阿里Qwen2开源大模型本地部署及调试全攻略
weixin_39558582的博客
08-17 1806
阿里Qwen2开源大模型本地部署及调试全攻略#Qwen2系列大模型性能卓越，超越业界知名模型。开源后受到AI开发者关注，支持多种语言，提升多语言理解。在预训练和微调上优化，实现智能水平提升。Qwen2系列模型在各项能力上均领先，为全球开发者提供更多选择。通义千问 Qwen2，登顶国内第一大模型！相比近期推出同等规模的开源最好的Llama3-8B、GLM4-9B等模型，Qwen2-7B-Instruct依然能在多个评测上取得显著的优势，尤其是代码及中文理解上。
Qwen-Free-API 使用指南
gitblog_00132的博客
08-22 839
Qwen-Free-API 使用指南 qwen-free-api???? 阿里通义千问2.5大模型逆向API白嫖测试【特长：六边形战士】，支持高速流式输出、无水印AI绘图、长文档解读、图像解析、多轮对话，零配置部署，多路token支持，自动清理会话痕迹。项目地址:https://gitcode.com/gh_mirrors/qw/qwen-free-api 本指南旨在帮助开发者快速理解和上手 Qwen...
算法部署-使用TensorRT-LLM部署通义千问Qwen-7B大模型-附详细优化+分析流程教程-优质大模型部署项目实战.zip
03-06
算法部署_使用TensorRT-LLM部署通义千问Qwen-7B大模型_附详细优化+分析流程教程_优质大模型部署项目实战
python实现通义千问VLLM推理部署项目源码（优质项目）.zip
04-22
python实现通义千问VLLM推理部署项目源码（优质项目）.zip本项目代码经过严格调试，确保可以运行！放心下载使用。可作为期末课程设计、课程大作业、毕业设计等。具有较高的学习借鉴价值！ python实现通义千问VLLM...
大语言模型部署-使用OpenVINO部署通义千问QWen2-附项目源码+流程教程-优质项目实战.zip
06-07
本文将详细解析如何利用OpenVINO工具套件部署通义千问QWen2这一先进的人工智能模型。OpenVINO全称为Open Visualization Inference and Neural Network Optimization，是一个由Intel开发的高性能推理平台，它旨在加速...
Ollama本地私有化部署通义千问大模型Qwen2.5
L
09-26 193
Qwen是阿里巴巴集团Qwen团队的大型语言模型和大型多模态模型系列。现在大型语言模型已经升级到Qwen2.5。语言模型和多模态模型都是在大规模多语言和多模态数据上进行预训练的，并在符合人类偏好的高质量数据上进行后训练。Qwen具有自然语言理解、文本生成、视觉理解、音频理解、工具使用、角色扮演、人工智能代理等功能。在Qwen2发布的过去三个月里，许多开发人员在Qwen2语言模型上构建了新的模型，向我们提供了宝贵的反馈。在此期间，我们专注于创建更智能、知识更丰富的语言模型。
VeighNa：强大的Python开源量化交易平台
Unity打怪升级
09-26 686
VeighNa（简称 VN 或 vn.py）是一个基于 Python 的开源量化交易平台，专为量化交易爱好者和专业交易员设计。VeighNa 是由国内开发者社区推动的开源项目，旨在提供一个功能丰富、灵活且易于扩展的量化交易解决方案。该框架不仅支持多种资产类别的交易，如股票、期货、期权、加密货币等，还支持多种交易接口和协议，使得用户能够轻松进行多市场、多品种的交易策略开发和部署。
第二百五十四节 JPA教程 - JPA 多对多映射示例
2301_78772942的博客
09-27 701
第二百五十四节 JPA教程 - JPA 多对多映射示例
Python精选200Tips：171-175
AnFany
09-26 1272
Python深度学习的项目
python中的深浅拷贝以及总体框架了解
AgostoDu的博客
09-26 1164
1、当b使用copy.deepcopy()深拷贝的时候，可以理解为b不仅外面的整体开辟了一个新的内存地址，b里面包含的列表也开辟了新的内存地址和a里面的内存地址没有任何关系，所以当a修改里面列表元素的值时不会影响b里面列表元素的值。print(mr) #{'name': 'lis', 'age': 18, 'scroe': 100}<br>备注：已经存在的值的优先级>默认值<br>6.3 直接修改 值，显示最新修改值 （修改默认值优先级小于直接添加的字典值）<br>
ubuntu安装libtorch
meng_152634的博客
09-25 752
nouveau是由第三方为NVIDIA显卡开发的一个开源3D驱动，ubuntu默认集成了nouveau驱动，安装NVIDIA驱动前必须禁用系统自带的显卡驱动nouveau，否则安装NVIDIA驱动时会报错。，一定要确定好安装的CUDA版本是否支持显卡的算力，否则安装成功也无法使用GPU加速。如果cmake版本低于3.18，会出现下面的报错，这是由于低于3.18的cmake不支持CUDA17的编译，需要更新cmake版本。因为安装的CUDA版本为12.1，这里选择最新版的CUDNN 9.4.0进行安装。
docker 部署Qwen2.5-14B-instruct
最新发布
09-28
Docker部署Qwen2.5-14B-instruct（通义千问的一个版本）主要是将这个大语言模型封装成容器，以便于管理和复用。以下是基本的部署流程： 1. **下载镜像**：首先你需要从官方仓库或Hugging Face Hub下载Qwen的Docker镜像，例如`huggingface/instruct-beta:qwen2.5-14b`。 2. **创建Dockerfile**：编写一个Dockerfile，内容通常包括基础镜像的选择、复制必要的文件（如模型权重、配置）、设置环境变量以及运行启动命令。 ```dockerfile # 使用官方镜像作为基础 FROM huggingface/instruct-beta # 复制模型和配置文件到容器内部 COPY qwen_model /model COPY config.json /config.json # 设置工作目录和启动指令 WORKDIR /app ENTRYPOINT ["python", "-m", "transformers-cli.inference", "/config.json"] ``` 3. **构建镜像**：使用`docker build -t my_qwen_container .`命令构建自定义的Docker镜像。 4. **运行容器**：用`docker run -p <host_port>:<container_port> my_qwen_container`命令运行容器，并映射本地端口到容器内的服务端口。 5. **配置环境**：可能需要设置相应的环境变量，比如`HF_HOST`指向Hugging Face的Hub地址。 注意：部署前确保你的机器满足运行该模型所需的硬件资源（如GPU）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我就是全世界

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值