通义千问 ( 一 ) 基础实例

春哥的魔法书

于 2024-08-17 08:24:49 发布

阅读量490

点赞数 11

分类专栏：人工智能文章标签：通义千问人工智能 AI

本文链接：https://blog.csdn.net/yuanchun05/article/details/141275199

版权

人工智能专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.相关概念

1.1.模型与平台

1.1.1.通义千问

通义千问 : 是阿里云研发的大语言模型；用于理解和分析用户输入的自然语言，在不同领域和任务为用户提供服务和帮助。

具体应用场景如下：

文字创作：撰写故事、公文、邮件、剧本和诗歌等。
文本处理：润色文本和提取文本摘要等。
编程辅助：编写和优化代码等。
翻译服务：提供各类语言的翻译服务，如英语、日语、法语或西班牙语等。
对话模拟：扮演不同角色进行交互式对话。
数据可视化：图表制作和数据呈现等。

1.1.2.灵积 ( DashScope )

灵积 (英文名 DashScope ) : 是阿里云推出的模型服务平台，提供了包括通义千问在内的多种模型的服务接口，建立在“模型即服务”（Model-as-a-Service，MaaS）的理念基础之上，围绕AI各领域模型，通过标准化API接口提供模型推理等服务，为用户打造一站式模型解决方案。

1.2.API-KEY

API-KEY

DashScope使用API-KEY作为调用API的密钥。API-KEY承担了调用鉴权、计量计费等功能。API-KEY被广泛应用于DashScope API中，通过 api-key 参数指定。DashScope中所有不同的模型API服务都可以使用一个API-KEY、以一致的编程方式进行调用，方便开发者进行跨模态的、多个模型的接续调用。

API-KEY是访问DashScope的密钥，请务必妥善保存。不要以任何方式公开到外部渠道，避免因未经授权的使用造成安全风险或资金损失。

推荐将API-KEY配置到环境变量中以降低API-KEY的泄漏风险

https://help.aliyun.com/zh/dashscope/developer-reference/acquisition-and-configuration-of-api-key?spm=a2c4g.11186623.0.0.42b6b400xOdsJb

如何获取通义千问API的KEY_模型服务灵积(DashScope)-阿里云帮助中心 (aliyun.com)

1.3.模型分类及token与收费

1.3.1.qwen-max

通义千问系列效果最好的模型，适合复杂、多步骤的任务。

上下文长度（Token数）	最大输入（Token数）	最大输出（Token数）	输入成本（每千Token）	输出成本（每千Token）
8k	6k	2k	0.04元	0.12元

1.3.2.qwen-plus

能力均衡，推理效果和速度介于通义千问-Max和通义千问-Turbo之间，适合中等复杂任务。

上下文长度（Token数）	最大输入（Token数）	最大输出（Token数）	输入成本（每千Token）	输出成本（每千Token）
32k	30k	8k	0.004元	0.012元

1.3.3.qwen-turbo

通义千问系列速度最快、成本很低的模型，适合简单任务。

上下文长度（Token数）	最大输入（Token数）	最大输出（Token数）	输入成本（每千Token）	输出成本（每千Token）
8k	6k	1.5k	0.002元	0.006元

每个模型还有一些小模型

对于中文文本来说，千问模型的1个token平均对应1.5-1.8个汉字；

对于英文文本来说，1个token通常对应一个单词或词根。

2.基础说明

2.1.基础案例

创建springboot 项目导入 spring web 依赖

2.1.1.maven导入依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/dashscope-sdk-java -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dashscope-sdk-java</artifactId>
    <version>2.16.2</version>
</dependency>

2.1.2.调用代码

创建 controller 类

import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;
import com.alibaba.dashscope.utils.JsonUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;

@RestController
@RequestMapping("/tongyi")
public class CallBaseController {

    @Value("${tongyi.api-key}")
    private String apiKey;


    @RequestMapping("/call/base")
    public String callBase(@RequestParam(value = "message", required = false, defaultValue = "中国的首都是哪里?") String message) throws NoApiKeyException, InputRequiredException {

        GenerationResult result = callWithMessage(message);
        System.out.println(JsonUtils.toJson(result));
        return result.getOutput().getChoices().get(0).getMessage().getContent();

    }


    public GenerationResult callWithMessage(String message) throws ApiException, NoApiKeyException, InputRequiredException {
        // 设置API密钥
        Constants.apiKey = apiKey;
        // 初始化生成对象
        Generation gen = new Generation();

        // 构建[ 系统 ]消息，说明AI助手的角色定位
        Message systemMsg = Message.builder()
                .role(Role.SYSTEM.getValue())
                .content("你是一个乐于助人的AI助手.")
                .build();

        // 构建[ 用户 ]消息，内容为用户的问题或指令
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content(message)
                .build();

        // 构建生成参数对象，用于定制化生成请求
        GenerationParam param = GenerationParam.builder()
                .model("qwen-turbo") // 选择使用的模型
                .messages(Arrays.asList(systemMsg, userMsg)) // 设置消息列表，包括系统消息和用户消息
                .resultFormat(GenerationParam.ResultFormat.MESSAGE) // 设置返回格式为消息格式
                .topK(50) // 设置Top-K参数，控制生成结果的多样性
                .temperature(0.8f) // 设置温度参数，控制生成结果的随机性
                .topP(0.8) // 设置Top-P参数，进一步控制生成结果的多样性
                .seed(1234) // 设置随机种子，以获得可复现的生成结果
                .build();

        // 调用生成对象的call方法，执行生成请求，并返回生成结果
        return gen.call(param);

    }
}

请求

GET http://localhost:8081/tongyi/call/base?message=你是谁？

HTTP/1.1 200 

我是阿里云开发的一款超大规模语言模型，我叫通义千问。作为一个AI助手，我的目标是帮助用户获得准确、有用的信息，解决他们的问题和困惑。无论是提供知识解答、创意建议，还是进行信息查询，我都致力于以最有效的方式提供帮助。

返回的结果

{
  "requestId": "fbd59659-bf46-9bf8-9c9b-58934190e57d",
  "usage": {
    "input_tokens": 25,
    "output_tokens": 60,
    "total_tokens": 85
  },
  "output": {
    "choices": [
      {
        "finish_reason": "stop",
        "message": {
          "role": "assistant",
          "content": "我是阿里云开发的一款超大规模语言模型，我叫通义千问。作为一个AI助手，我的目标是帮助用户获得准确、有用的信息，解决他们的问题和困惑。无论是提供知识解答、创意建议，还是进行信息查询，我都致力于以最有效的方式提供帮助。"
        }
      }
    ]
  }
}

2.2.多轮对话案例

多轮对话可以让大模型参考历史对话信息，更符合日常交流的场景。

实现多轮对话的关键在于维护一个存放历史对话信息的列表，并将更新后的列表作为大模型的输入，从而使大模型可以参考历史对话信息进行回复。

如果对话轮数较多，可能会超过大模型可以输入的token上限。需要控制输入大模型的token数量。

2.2.1.调用代码

import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/tongyi")
public class CallManyController {

    @Value("${tongyi.api-key}")
    private String apiKey;


    // 历史消息列表
    private List<Message> historyMessage =
            new ArrayList<>(List.of(createMessage(Role.SYSTEM, "你是一个乐于助人的AI助手. 可以按照使用者来设置身份, 你要记住这些设置!")));
    // 历史消息列表的最大长度
    private int maxLen = 10;


    @RequestMapping("/call/many")
    public String callMany(@RequestParam(value = "message", required = false, defaultValue = "中国的首都是哪里?") String message) throws NoApiKeyException, InputRequiredException {

        // 用户输入的文本是UserMessage
        historyMessage.add(createMessage(Role.USER, message));

        // 发给AI前对历史消息对列的长度进行检查
        if (historyMessage.size() > maxLen) {
            historyMessage = historyMessage.subList(historyMessage.size() - maxLen - 1, historyMessage.size());
        }
        System.out.println("模型输入：" + historyMessage);

        GenerationParam param = createGenerationParam(historyMessage);
        GenerationResult result = callGenerationWithMessages(param);
        System.out.println("模型输出：" + result.getOutput().getChoices().get(0).getMessage().getContent());
        historyMessage.add(result.getOutput().getChoices().get(0).getMessage());

        return result.getOutput().getChoices().get(0).getMessage().getContent();
    }


    public GenerationParam createGenerationParam(List<Message> messages) {
        return GenerationParam.builder()
                .model("qwen-turbo")
                .messages(messages)
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .topP(0.8)
                .build();
    }

    public GenerationResult callGenerationWithMessages(GenerationParam param) throws ApiException, NoApiKeyException, InputRequiredException {
        // 设置API密钥
        Constants.apiKey = apiKey;
        Generation gen = new Generation();
        return gen.call(param);
    }


    private static Message createMessage(Role role, String content) {
        return Message.builder().role(role.getValue()).content(content).build();
    }

}

2.2.2.测试

###
GET http://localhost:8081/tongyi/call/many?
    message=你现在的名字叫王小二

###
GET http://localhost:8081/tongyi/call/many?
    message=你是一名大学生

###
GET http://localhost:8081/tongyi/call/many?
    message=你的学习成绩很好, 也很乐意帮助别人

###
GET http://localhost:8081/tongyi/call/many?
    message=现在介绍一下你自己, 你的名字, 你的身份, 你的性格

2.3.prompt

通过prompt方式调用时，输入与输出的数据格式比messages方式简单，更适合单轮问答等简单场景；在更复杂的场景中推荐您通过messages方式调用。

import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.aigc.generation.models.QwenParam;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.ResultCallback;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;
import com.alibaba.dashscope.utils.JsonUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.concurrent.Semaphore;

@RestController
@RequestMapping("/tongyi")
public class CallPromptController {

    @Value("${tongyi.api-key}")
    private String apiKey;


    @RequestMapping("/call/prompt")
    public String callBase(@RequestParam(value = "message", required = false, defaultValue = "中国的首都是哪里?") String message) throws NoApiKeyException, InputRequiredException {

        try {
            GenerationResult result = qwenQuickStart(message);

            qwenQuickStartCallback(message);
            System.out.println(JsonUtils.toJson(result));
            return result.getOutput().getText();
        } catch (ApiException | NoApiKeyException | InputRequiredException
                 | InterruptedException e) {
            System.out.println(String.format("Exception %s", e.getMessage()));
        }
        return null;
    }

    /**
     * 使用通义灵码快速开始生成文本
     */
    public GenerationResult qwenQuickStart(String prompt) throws NoApiKeyException, ApiException, InputRequiredException {
        // 设置API密钥
        Constants.apiKey = apiKey;
        // 创建Generation实例，用于调用API生成文本
        Generation gen = new Generation();
        // 构建请求参数
        QwenParam param = QwenParam.builder()
                .model(Generation.Models.QWEN_TURBO) // 设置使用的模型为Qwen Turbo
                .prompt(prompt) // 设置提示词
                .topP(0.8) // 设置采样参数topP，0.8表示在概率为0.8的范围内采样
                .build();
        // 调用API生成文本
        GenerationResult result = gen.call(param);
        // 打印生成结果的JSON格式
        System.out.println(JsonUtils.toJson(result));
        // 返回生成结果
        return result;
    }


    // 回调方式实现的轻量级快速开始示例
    // 该方法演示了如何通过回调实时处理请求
    // 参数：prompt - 生成文本的提示信息
    // 异常：NoApiKeyException - 未设置API密钥异常, ApiException - API调用异常, InputRequiredException - 必需输入缺失异常, InterruptedException - 线程中断异常
    public void qwenQuickStartCallback(String prompt) throws NoApiKeyException, ApiException, InputRequiredException, InterruptedException {
        // 设置API密钥
        Constants.apiKey = apiKey;
        // 创建生成实例
        Generation gen = new Generation();
        // 构建请求参数
        QwenParam param = QwenParam.builder()
                .model(Generation.Models.QWEN_TURBO) // 指定模型
                .prompt(prompt) // 设置提示信息
                .topP(0.8) // 设置采样参数，这里表示top-p采样
                .build();

        // 使用信号量控制回调的完成
        Semaphore semaphore = new Semaphore(0);

        // 调用生成接口，并指定回调处理结果
        gen.call(param, new ResultCallback<GenerationResult>() {

            // 当生成结果时触发
            @Override
            public void onEvent(GenerationResult message) {
                System.out.println(message);
            }

            // 当发生错误时触发
            @Override
            public void onError(Exception ex) {
                System.out.println(ex.getMessage());
                semaphore.release(); // 释放信号量，允许线程继续执行
            }

            // 当生成完成时触发
            @Override
            public void onComplete() {
                System.out.println("onComplete");
                semaphore.release(); // 释放信号量，允许线程继续执行
            }

        });
        // 等待回调完成
        semaphore.acquire();
    }
}