LMDeploy 量化部署实践闯关任务---基于书生·浦语大模型

一：概述

        什么是部署呢？在软件工程中，部署通常指的是将开发完毕的软件投入使用的过程。在人工智能领域，模型部署是实现深度学习算法落地应用的关键步骤。简单来说，模型部署就是将训练好的深度学习模型在特定环境中运行的过程。它的应用场景有：服务器端：CPU部署、单GPU/TPU/NPU部署，多卡/集群部署......移动端/边缘端：移动机器人，手机等。

        LMDeploy是一个由MMRazor和MMDeploy团队联合开发的工具包，专为大型语言模型（LLM）提供全面的轻量化、部署和服务解决方案。

         LMDeploy的推理性能：

        大模型缓存推理技术：

        

        大模型量化技术

        KV Cache量化

        

        AWQ量化方案：   

    

        

        大模型外推技术

        

          

        

        

        Function Calling
        

二：LMDeploy 量化部署实践

        <1>创建开发机

点选开发机，自拟一个开发机名称，选择Cuda12.2-conda镜像。

我们要运行参数量为7B的InternLM2.5，由InternLM2.5的码仓查询InternLM2.5-7b-chat的config.json文件可知，该模型的权重被存储为bfloat16格式

        对于一个7B（70亿）参数的模型，每个参数使用16位浮点数（等于 2个 Byte）表示，则模型的权重大小约为：

        70×10^9 parameters×2 Bytes/parameter=14GB

        70亿个参数×每个参数占用2个字节=14GB

        所以我们需要大于14GB的显存，选择 30%A100*1(24GB显存容量)，后选择立即创建，等状态栏变成运行中，点击进入开发机，我们即可开始部署。

          <2>打开开发机，创建conda专属环境

                        2.1 安装和下载所需要的编译环境以及包

conda create -n lmdeploy  python=3.10 -y
conda activate lmdeploy
conda install pytorch==2.1.2 torchvision==0.16.2 torchaudio==2.1.2 pytorch-cuda=12.1 -c pytorch -c nvidia -y
pip install timm==1.0.8 openai==1.40.3 lmdeploy[all]==0.5.3

        2.2 InternStudio环境获取模型   

        为方便文件管理，我们需要一个存放模型的目录，本教程统一放置在/root/models/目录。

运行以下命令，创建文件夹并设置开发机共享目录的软链接。

mkdir /root/models
ln -s /root/share/new_models/Shanghai_AI_Laboratory/internlm2_5-7b-chat /root/models
ln -s /root/share/new_models/Shanghai_AI_Laboratory/internlm2_5-1_8b-chat /root/models
ln -s /root/share/new_models/OpenGVLab/InternVL2-26B /root/models

        此时，我们可以看到/root/models中会出现internlm2_5-7b-chat、internlm2_5-1_8b-chat和InternVL2-26B文件夹。

        由于上述模型量化会消耗大量时间(约8h)，量化尽量使用internlm2_5-1_8b-chat模型完成

             <3> LMDeploy验证启动模型文件     

        在量化工作正式开始前，我们还需要验证一下获取的模型文件能否正常工作，以免竹篮打水一场空。

        让我们进入创建好的conda环境并启动internlm2_5-1_8b-chat！

conda activate lmdeploy
lmdeploy chat /root/models/internlm2_5-1_8b-chat

        运行后的结果如下图所示：

        此时，我们可以在CLI(“命令行界面” Command Line Interface的缩写)中和InternLM2.5尽情对话了，注意输入内容完成后需要按两次回车才能够执行，以下为示例。

        注意到屏幕右上角，这是InternStudio提供的资源监控。

现在显存占用约23GB

        选择 50%A100*1 建立机器，同样运行InternLM2.5 7B模型，会发现此时显存占用为36GB。

        nternLM2.5 7B模型为bf16，LMDpeloy推理精度为bf16的7B模型权重需要占用14GB显存；如下图所示，lmdeploy默认设置cache-max-entry-count为0.8，即kv cache占用剩余显存的80%；

        此时对于24GB的显卡，即30%A100，权重占用14GB显存，剩余显存24-14=10GB，因此kv cache占用10GB*0.8=8GB，加上原来的权重14GB，总共占用14+8=22GB。

        而对于40GB的显卡，即50%A100，权重占用14GB，剩余显存40-14=26GB，因此kv cache占用26GB*0.8=20.8GB，加上原来的权重14GB，总共占用34.8GB。

        实际加载模型后，其他项也会占用部分显存，因此剩余显存比理论偏低，实际占用会略高于22GB和34.8GB。

        此外，如果想要实现显存资源的监控，我们也可以新开一个终端输入如下两条指令的任意一条，查看命令输入时的显存占用情况。

nvidia-smi 
studio-smi 

        下面来演示一下效果：

        实验室提供的环境为虚拟化的显存，nvidia-smi是NVIDIA GPU驱动程序的一部分，用于显示NVIDIA GPU的当前状态，故当前环境只能看80GB单卡 A100 显存使用情况，无法观测虚拟化后30%或50%A100等的显存情况。针对于此，实验室提供了studio-smi 命令工具，能够观测到虚拟化后的显存使用情况。

        <4>LMDeploy与InternLM2.5

                        启动API服务器

我们进入创建好的conda环境，并通下命令启动API服务器，部署InternLM2.5模型：

conda activate lmdeploy
lmdeploy serve api_server \
    /root/models/internlm2_5-1-8b-chat \
    --model-format hf \
    --quant-policy 0 \
    --server-name 0.0.0.0 \
    --server-port 23333 \
    --tp 1

命令解释：

1. lmdeploy serve api_server：这个命令用于启动API服务器。
2. /root/models/internlm2_5-7b-chat：这是模型的路径。
3. --model-format hf：这个参数指定了模型的格式。hf代表“Hugging Face”格式。
4. --quant-policy 0：这个参数指定了量化策略。
5. --server-name 0.0.0.0：这个参数指定了服务器的名称。在这里，0.0.0.0是一个特殊的IP地址，它表示所有网络接口。
6. --server-port 23333：这个参数指定了服务器的端口号。在这里，23333是服务器将监听的端口号。
7. --tp 1：这个参数表示并行数量（GPU数量）。

稍待片刻，终端显示如下。

本地需要做一下ssh转发才能直接访问。在你本地打开一个cmd或powershell窗口，输入命令如下：

 ssh -CNg -L 23333:127.0.0.1:23333 root@ssh.intern-ai.org.cn -p 你的ssh端口号

然后打开浏览器，访问http://127.0.0.1:23333看到如下界面即代表部署成功。

        看到上面这个界面表示已经部署成功了。

        <5>以命令行形式连接API服务器      

                        关闭http://127.0.0.1:23333网页，但保持终端和本地窗口不动，按箭头操作新建一个终端。

        运行如下命令，激活conda环境并启动命令行客户端。

conda activate lmdeploy
lmdeploy serve api_client http://localhost:23333

        稍待片刻，等出现double enter to end input >>>的输入提示即启动成功，此时便可以随意与InternLM2.5对话，同样是两下回车确定，输入exit退出。

        <6>以Gradio网页形式连接API服务器

                保持第一个终端不动，在新建终端中输入exit退出。

                输入以下命令，使用Gradio作为前端，启动网页。

lmdeploy serve gradio http://localhost:23333 \
    --server-name 0.0.0.0 \
    --server-port 6006

        稍待片刻，等终端如下图所示便保持两个终端不动。

        关闭之前的cmd/powershell窗口，重开一个，再次做一下ssh转发(因为此时端口不同)。在你本地打开一个cmd或powershell窗口，输入命令如下。

ssh -CNg -L 6006:127.0.0.1:6006 root@ssh.intern-ai.org.cn -p <你的ssh端口号>

        重复上述操作，待窗口保持在如下状态即可。

        打开浏览器，访问地址http://127.0.0.1:6006，然后就可以与模型尽情对话了。

        <7>LMDeploy Lite

                随着模型变得越来越大，我们需要一些大模型压缩技术来降低模型部署的成本，并提升模型的推理性能。LMDeploy 提供了权重量化和 k/v cache两种策略。

                7.1 设置最大kv cache缓存大小

      kv cache是一种缓存技术，通过存储键值对的形式来复用计算结果，以达到提高性能和降低内存消耗的目的。在大规模训练和推理中，kv cache可以显著减少重复计算量，从而提升模型的推理速度。理想情况下，kv cache全部存储于显存，以加快访存速度。

模型在运行时，占用的显存可大致分为三部分：模型参数本身占用的显存、kv cache占用的显存，以及中间运算结果占用的显存。LMDeploy的kv cache管理器可以通过设置--cache-max-entry-count参数，控制kv缓存占用剩余显存的最大比例。默认的比例为0.8。

        首先我们先来回顾一下InternLM2.5正常运行时占用显存。

        占用了23GB，那么试一试执行以下命令，再来观看占用显存情况。

lmdeploy chat /root/models/internlm2_5-7b-chat --cache-max-entry-count 0.4

稍待片刻，观测显存占用情况，可以看到减少了约4GB的显存 

让我们计算一下4GB显存的减少缘何而来，

对于修改kv cache默认占用之前，即如所示直接启动模型的显存占用情况(23GB)：

1、在 BF16 精度下，7B模型权重占用14GB：70×10^9 parameters×2 Bytes/parameter=14GB

2、kv cache占用8GB：剩余显存24-14=10GB，kv cache默认占用80%，即10*0.8=8GB

3、其他项1GB

是故23GB=权重占用14GB+kv cache占用8GB+其它项1GB

对于修改kv cache占用之后的显存占用情况(19GB)：

1、与上述声明一致，在 BF16 精度下，7B模型权重占用14GB

2、kv cache占用4GB：剩余显存24-14=10GB，kv cache修改为占用40%，即10*0.4=4GB

3、其他项1GB

是故19GB=权重占用14GB+kv cache占用4GB+其它项1GB

而此刻减少的4GB显存占用就是从10GB*0.8-10GB*0.4=4GB，这里计算得来。

       7.2  设置在线 kv cache int4/int8 量化

                自 v0.4.0 起，LMDeploy 支持在线 kv cache int4/int8 量化，量化方式为 per-head per-token 的非对称量化。此外，通过 LMDeploy 应用 kv 量化非常简单，只需要设定 quant_policy 和cache-max-entry-count参数。目前，LMDeploy 规定 quant_policy=4 表示 kv int4 量化，quant_policy=8 表示 kv int8 量化。

        通过以下的命令启动API服务器：

lmdeploy serve api_server     /root/models/internlm2_5-1_8b-chat  --model-format hf     --quant-policy 4     --cache-max-entry-count 0.4    --server-name 0.0.0.0     --server-port 23333     --tp 1

稍待片刻，显示如下即代表服务启动成功。

        

        可以明显的发现这个显存的占用效果。

        相比使用BF16精度的kv cache，int4的Cache可以在相同4GB的显存下只需要4位来存储一个数值，而BF16需要16位。这意味着int4的Cache可以存储的元素数量是BF16的四倍。

        <8>W4A16 模型量化和部署

       模型量化是一种优化技术，旨在减少机器学习模型的大小并提高其推理速度。量化通过将模型的权重和激活从高精度（如16位浮点数）转换为低精度（如8位整数、4位整数、甚至二值网络）来实现。

W4A16又是什么意思呢？

• W4：这通常表示权重量化为4位整数（int4）。这意味着模型中的权重参数将从它们原始的浮点表示（例如FP32、BF16或FP16，Internlm2.5精度为BF16）转换为4位的整数表示。这样做可以显著减少模型的大小。
• A16：这表示激活（或输入/输出）仍然保持在16位浮点数（例如FP16或BF16）。激活是在神经网络中传播的数据，通常在每层运算之后产生。因此，W4A16的量化配置意味着：
• 权重被量化为4位整数。
• 激活保持为16位浮点数。

让我们回到LMDeploy，在最新的版本中，LMDeploy使用的是AWQ算法，能够实现模型的4bit权重量化。输入以下指令，执行量化工作。(不建议运行，在InternStudio上运行需要8小时)

        使用1.8B模型进行量化：(建议运行以下命令)

命令解释：

1. lmdeploy lite auto_awq: lite这是LMDeploy的命令，用于启动量化过程，而auto_awq代表自动权重量化（auto-weight-quantization）。
2. /root/models/internlm2_5-7b-chat: 模型文件的路径。
3. --calib-dataset 'ptb': 这个参数指定了一个校准数据集，这里使用的是’ptb’（Penn Treebank，一个常用的语言模型数据集）。
4. --calib-samples 128: 这指定了用于校准的样本数量—128个样本
5. --calib-seqlen 2048: 这指定了校准过程中使用的序列长度—2048
6. --w-bits 4: 这表示权重（weights）的位数将被量化为4位。
7. --work-dir /root/models/internlm2_5-7b-chat-w4a16-4bit: 这是工作目录的路径，用于存储量化后的模型和中间结果。

                等终端输出如下时，说明正在推理中，稍待片刻。

在运行上面这个模型时，会报出如下的错误：

lmdeploy lite auto_awq    /root/models/internlm2_5-1_8b-chat   --calib-dataset 'ptb'   --calib-samples 128   --calib-seqlen 2048   --w-bits 4   --w-group-size 128   --batch-size 1   --search-scale False   --work-dir /root/models/internlm2_5-1_8b-chat-w4a16-4bit
Loading checkpoint shards: 100%|█████████████████████████████████| 2/2 [00:04<00:00,  2.46s/it]
Move model.tok_embeddings to GPU.
Move model.layers.0 to CPU.
Move model.layers.1 to CPU.
Move model.layers.2 to CPU.
Move model.layers.3 to CPU.
Move model.layers.4 to CPU.
Move model.layers.5 to CPU.
Move model.layers.6 to CPU.
Move model.layers.7 to CPU.
Move model.layers.8 to CPU.
Move model.layers.9 to CPU.
Move model.layers.10 to CPU.
Move model.layers.11 to CPU.
Move model.layers.12 to CPU.
Move model.layers.13 to CPU.
Move model.layers.14 to CPU.
Move model.layers.15 to CPU.
Move model.layers.16 to CPU.
Move model.layers.17 to CPU.
Move model.layers.18 to CPU.
Move model.layers.19 to CPU.
Move model.layers.20 to CPU.
Move model.layers.21 to CPU.
Move model.layers.22 to CPU.
Move model.layers.23 to CPU.
Move model.norm to GPU.
Move output to CPU.
Loading calibrate dataset ...
Traceback (most recent call last):
  File "/root/.conda/envs/lmdeploy/bin/lmdeploy", line 8, in <module>
    sys.exit(run())
  File "/root/.conda/envs/lmdeploy/lib/python3.10/site-packages/lmdeploy/cli/entrypoint.py", line 36, in run
    args.run(args)
  File "/root/.conda/envs/lmdeploy/lib/python3.10/site-packages/lmdeploy/cli/lite.py", line 139, in auto_awq
    auto_awq(**kwargs)
  File "/root/.conda/envs/lmdeploy/lib/python3.10/site-packages/lmdeploy/lite/apis/auto_awq.py", line 80, in auto_awq
    vl_model, model, tokenizer, work_dir = calibrate(model,
  File "/root/.conda/envs/lmdeploy/lib/python3.10/site-packages/lmdeploy/lite/apis/calibrate.py", line 216, in calibrate
    calib_loader, _ = get_calib_loaders(calib_dataset,
  File "/root/.conda/envs/lmdeploy/lib/python3.10/site-packages/lmdeploy/lite/utils/calib_dataloader.py", line 302, in get_calib_loaders
    return get_ptb(tokenizer, nsamples, seed, seqlen)
  File "/root/.conda/envs/lmdeploy/lib/python3.10/site-packages/lmdeploy/lite/utils/calib_dataloader.py", line 58, in get_ptb
    traindata = load_dataset('ptb_text_only', 'penn_treebank', split='train')
  File "/root/.conda/envs/lmdeploy/lib/python3.10/site-packages/datasets/load.py", line 2074, in load_dataset
    builder_instance = load_dataset_builder(
  File "/root/.conda/envs/lmdeploy/lib/python3.10/site-packages/datasets/load.py", line 1832, in load_dataset_builder
    builder_instance: DatasetBuilder = builder_cls(
TypeError: 'NoneType' object is not callable

        解决这个问题的办法就是降低dataset的版本号

pip install datasets==2.21.0

这个需要的评测时间比较长，经过长期的等待......

                等待推理完成，便可以直接在你设置的目标文件夹看到对应的模型文件。那么推理后的模型和原本的模型区别在哪里呢？最明显的两点是模型文件大小以及占据显存大小。我们可以输入如下指令查看在当前目录中显示所有子目录的大小。

那么原模型大小呢？输入以下指令查看。

cd /root/share/new_models/Shanghai_AI_Laboratory/
du -sh *

        可以明显的看出优势。

那么显存占用情况对比呢？输入以下指令启动量化后的模型。

lmdeploy chat /root/models/internlm2_5-7b-chat-w4a16-4bit/ --model-format awq

        稍待片刻，我们直接观测右上角的显存占用情况。

        明显这个内存占用是小于未量化前的。

<9>W4A16 量化+ KV cache+KV cache 量化

        输入以下指令，让我们同时启用量化后的模型、设定kv cache占用和kv cache int4量化。

lmdeploy serve api_server \
    /root/models/internlm2_5-1_8b-chat-w4a16-4bit/ \
    --model-format awq \
    --quant-policy 4 \
    --cache-max-entry-count 0.4\
    --server-name 0.0.0.0 \
    --server-port 23333 \
    --tp 1

此时，显存占用了大约11.3G。

<10>LMDeploy与InternVL2

        InternVL2-26B进行演示，其实就根本来说作为一款VLM和上述的InternLM2.5在操作上并无本质区别，仅是多出了"图片输入"这一额外步骤，但作为量化部署进阶实践，选用InternVL2-26B目的是带领大家体验一下LMDeploy的量化部署可以做到何种程度。

        10.1 LMDeploy Lite

        针对InternVL系列模型，让我们先进入conda环境，并输入以下指令，执行模型的量化工作。(本步骤耗时较长，请耐心等待)

conda activate lmdeploy
lmdeploy lite auto_awq \
   /root/models/internlm2_5-1_8b-chat \
  --calib-dataset 'ptb' \
  --calib-samples 128 \
  --calib-seqlen 2048 \
  --w-bits 4 \
  --w-group-size 128 \
  --batch-size 1 \
  --search-scale False \
  --work-dir /root/models/InternVL2-26B-w4a16-4bit

        此时表明已经在推理当中了。

        经过漫长的等待，最终完成了。

        可以看到左侧的Models出现了这个生成的模型。

          10.2 W4A16 量化+ KV cache+KV cache 量化

                输入以下指令，让我们启用量化后的模型。

lmdeploy serve api_server \
    /root/models/InternVL2-26B-w4a16-4bit \
    --model-format awq \
    --quant-policy 4 \
    --cache-max-entry-count 0.1\
    --server-name 0.0.0.0 \
    --server-port 23333 \
    --tp 1

        启动后观测显存占用情况，此时只需要约23.8GB的显存，已经是一张30%A100即可部署的模型了。

        InternVL2 26B是由一个6B的ViT、一个100M的MLP以及一个19.86B的internlm组成的。

        <11>LMDeploy API部署InterVL2

                                通过以下命令启动API服务器，部署InternVL2模型：

lmdeploy serve api_server \
    /root/models/InternVL2-26B-w4a16-4bit/ \
    --model-format awq \
    --quant-policy 4 \
    --cache-max-entry-count 0.1 \
    --server-name 0.0.0.0 \
    --server-port 23333 \
    --tp 1

        这个查看和上面的步骤一样。

                命令行方式启动：

conda activate lmdeploy
lmdeploy serve api_client http://localhost:23333

        

        稍待片刻，等出现double enter to end input >>>的输入提示即启动成功，此时便可以随意与InternLM2.5对话，同样是两下回车确定，输入exit退出。

                gradio网页

lmdeploy serve gradio http://localhost:23333 \
    --server-name 0.0.0.0 \
    --server-port 6006

        打开浏览器，访问地址http://127.0.0.1:6006，然后就可以与模型对话了。

        <12>LMDeploy之FastAPI与Function call

                        12.1 API开发

                与之前一样，让我们进入创建好的conda环境并输入指令启动API服务器。

conda activate lmdeploy
lmdeploy serve api_server \
    /root/models/internlm2_5-1_8b-chat-w4a16-4bit \
    --model-format awq \
    --cache-max-entry-count 0.4 \
    --quant-policy 4 \
    --server-name 0.0.0.0 \
    --server-port 23333 \
    --tp 1

        保持终端窗口不动，按箭头操作新建一个终端。

        在新建终端中输入如下指令，新建internlm2_5.py。

touch /root/internlm2_5.py

        将以下内容复制粘贴进internlm2_5.py。

# 导入openai模块中的OpenAI类，这个类用于与OpenAI API进行交互
from openai import OpenAI


# 创建一个OpenAI的客户端实例，需要传入API密钥和API的基础URL
client = OpenAI(
    api_key='YOUR_API_KEY',  
    # 替换为你的OpenAI API密钥，由于我们使用的本地API，无需密钥，任意填写即可
    base_url="http://0.0.0.0:23333/v1"  
    # 指定API的基础URL，这里使用了本地地址和端口
)

# 调用client.models.list()方法获取所有可用的模型，并选择第一个模型的ID
# models.list()返回一个模型列表，每个模型都有一个id属性
model_name = client.models.list().data[0].id

# 使用client.chat.completions.create()方法创建一个聊天补全请求
# 这个方法需要传入多个参数来指定请求的细节
response = client.chat.completions.create(
  model=model_name,  
  # 指定要使用的模型ID
  messages=[  
  # 定义消息列表，列表中的每个字典代表一个消息
    {"role": "system", "content": "你是一个友好的小助手，负责解决问题."},  
    # 系统消息，定义助手的行为
    {"role": "user", "content": "帮我讲述一个关于狐狸和西瓜的小故事"},  
    # 用户消息，询问时间管理的建议
  ],
    temperature=0.8,  
    # 控制生成文本的随机性，值越高生成的文本越随机
    top_p=0.8  
    # 控制生成文本的多样性，值越高生成的文本越多样
)

# 打印出API的响应结果
print(response.choices[0].message.content)

        现在让我们在新建终端输入以下指令激活环境并运行python代码。

conda activate lmdeploy
python /root/internlm2_5.py

        终端会出现如下的效果。

        我们再返回第一个终端，会看到如下信息，这代表其成功的完成了一次用户问题GET与输出POST。

        12.2 Function call

关于Function call，即函数调用功能，它允许开发者在调用模型时，详细说明函数的作用，并使模型能够智能地根据用户的提问来输入参数并执行函数。完成调用后，模型会将函数的输出结果作为回答用户问题的依据。

首先让我们进入创建好的conda环境并启动API服务器。

 conda activate lmdeploy
lmdeploy serve api_server \
    /root/models/internlm2_5-1_8b-chat \
    --model-format hf \
    --quant-policy 0 \
    --server-name 0.0.0.0 \
    --server-port 23333 \
    --tp 1

        目前LMDeploy在0.5.3版本中支持了对InternLM2, InternLM2.5和llama3.1这三个模型，故我们选用InternLM2.5 封装API。

让我们使用一个简单的例子作为演示。输入如下指令，新建internlm2_5_func.py。

touch /root/internlm2_5_func.py

        双击打开，并将以下内容复制粘贴进internlm2_5_func.py。

                

from openai import OpenAI


def add(a: int, b: int):
    return a + b


def mul(a: int, b: int):
    return a * b


tools = [{
    'type': 'function',
    'function': {
        'name': 'add',
        'description': 'Compute the sum of two numbers',
        'parameters': {
            'type': 'object',
            'properties': {
                'a': {
                    'type': 'int',
                    'description': 'A number',
                },
                'b': {
                    'type': 'int',
                    'description': 'A number',
                },
            },
            'required': ['a', 'b'],
        },
    }
}, {
    'type': 'function',
    'function': {
        'name': 'mul',
        'description': 'Calculate the product of two numbers',
        'parameters': {
            'type': 'object',
            'properties': {
                'a': {
                    'type': 'int',
                    'description': 'A number',
                },
                'b': {
                    'type': 'int',
                    'description': 'A number',
                },
            },
            'required': ['a', 'b'],
        },
    }
}]
messages = [{'role': 'user', 'content': 'Compute (3+5)*2'}]

client = OpenAI(api_key='YOUR_API_KEY', base_url='http://0.0.0.0:23333/v1')
model_name = client.models.list().data[0].id
response = client.chat.completions.create(
    model=model_name,
    messages=messages,
    temperature=0.8,
    top_p=0.8,
    stream=False,
    tools=tools)
print(response)
func1_name = response.choices[0].message.tool_calls[0].function.name
func1_args = response.choices[0].message.tool_calls[0].function.arguments
func1_out = eval(f'{func1_name}(**{func1_args})')
print(func1_out)

messages.append({
    'role': 'assistant',
    'content': response.choices[0].message.content
})
messages.append({
    'role': 'environment',
    'content': f'3+5={func1_out}',
    'name': 'plugin'
})
response = client.chat.completions.create(
    model=model_name,
    messages=messages,
    temperature=0.8,
    top_p=0.8,
    stream=False,
    tools=tools)
print(response)
func2_name = response.choices[0].message.tool_calls[0].function.name
func2_args = response.choices[0].message.tool_calls[0].function.arguments
func2_out = eval(f'{func2_name}(**{func2_args})')
print(func2_out)

        现在让我们输入以下指令运行python代码。

python /root/internlm2_5_func.py

        稍待片刻终端输出如下。

        我们可以看出InternLM2.5将输入'Compute (3+5)*2'根据提供的function拆分成了"加"和"乘"两步，第一步调用function add实现加，再于第二步调用function mul实现乘，再最终输出结果16.

        到此为止，这个任务就完成了。