:::info{title="相关信息"}
本文主要记录chatglm3工具调用相关代码实现

demo并没有做边界情况及异常处理，旨在提供一种思路，请大家自行完善相关代码
:::

# 视频教程
<div style="position: relative; overflow: hidden; width: 100%; padding-top: 56.25%;">
    <iframe src="//player.bilibili.com/player.html?aid=277635915&bvid=BV1Yc411Z7dP&cid=1314160181&p=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true" style="position: absolute; top: 0; left: 0; bottom: 0; right: 0; width: 100%; height: 100%; border: none;" allowfullscreen="true"> </iframe>
    </div>
    
# 源文件

**tools.py**

```python
tools = [
    {
        "name": "get_current_weather_by_location",
        "description": "根据城市获取当前天气",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "description": "城市名称 e.g. 北京，上海，武汉"
                }
            },
            "required": ['location']
        }
    },
    {
        "name": "recommend_dress_by_weather",
        "description": "根据天气信息推荐穿衣风格",
        "parameters": {
            "type": "object",
            "properties": {
                "temp": {
                    "description": "温度（摄氏度） e.g. 36.4,37.8"
                },
                "wind_scale": {
                    "description": "风力大小 e.g. 1,2,3"
                }
            },
            "required": ['temp']
        }
    },
    {
        "name": "cocktail_list",
        "description": "获取流行的鸡尾酒清单",
        "parameters": {}
    },
    {
        "name": "cocktail_recipe_suggestions",
        "description": "获取鸡尾酒配方建议",
        "parameters": {}
    },
    {
        "name": "get_news_about_birthday",
        "description": "获取生日庆祝相关的新闻文章",
        "parameters": {}
    }
]
system_info = {"role": "system",
               "content": "Answer the following questions as best as you can. You have access to the following tools:",
               "tools": tools}

```

**function_map.py**


```python
# 根据地区获取当前天气
def get_current_weather_by_location(location: str):
    print("天气函数被调用了")
    if location == "北京":
        return {
            "location": location,
            "temp": "24",
            "text": "多云",
            "windDir": "东南风",
            "windScale": "1"
        }
    elif location == "武汉":
        return {
            "location": location,
            "temp": "26",
            "text": "晴",
            "windDir": "西北风",
            "windScale": "2"
        }


# 根据温度风力大小推荐穿着
def recommend_dress_by_weather(temp, wind_scale):
    print(f"推荐函数被调用了，入参为:温度{temp},风力等级{wind_scale}")
    if float(temp) < 24:
        return {
            "style": "长袖，外套"
        }
    else:
        return {
            "style": "短袖"
        }


# 获取流行的鸡尾酒清单
def cocktail_list():
    return {
        "cocktail_list": [
            {
                "name": "莫吉托（Mojito）"
            }, {
                "name": "马丁尼（Martini）"
            }, {
                "name": "辛普尔（Sazerac）"
            }, {
                "name": "白俄罗斯（White Russian）"
            }, {
                "name": "莫斯科骡子（Moscow Mule）"
            }, {
                "name": "青蛙跳（Long Island Iced Tea）"
            }, {
                "name": "柯尔克特尾巴（Kir Royale）"
            }, {
                "name": "毛利人（Mai Tai）"
            }, {
                "name": "哈瓦那特（Havana Special）"
            }, {
                "name": "草地边（Grasshopper）"
            }
        ]
    }


# 获取鸡尾酒配方建议
def cocktail_recipe_suggestions():
    return {
        "recipe": [
            {
                "name": "白朗姆酒"
            }, {
                "name": "薄荷叶"
            }, {
                "name": "糖"
            }, {
                "name": "青柠汁"
            }, {
                "name": "苏打水"
            }, {
                "name": "伏特加或琴酒"
            }, {
                "name": "干苦艾酒"
            }, {
                "name": "咖啡利口酒"
            }, {
                "name": "伏特加"
            }, {
                "name": "龙舌兰酒"
            }
        ]
    }


# 获取生日庆祝相关的新闻文章
def get_news_about_birthday():
    return {
        "content": """
        参加朋友的生日会，你也一起出主意、构想庆祝内容，是不是会更有参与感、更难忘？

学前儿童刊物《小小拇指》为庆祝创刊10周年，将在6月至8月的巡回展上，举办多场免费的华语讲故事活动。这次讲故事活动的最大特色是将以参与式剧场的形式，带领孩童和家长一同参加“小拇指的生日会”。这种形式鼓励参与者积极发挥创意、贡献点子，每个人都是故事的创建者，参与越多，融入感就越强。

主讲者符妙娟（39岁，戏剧工作者）与同伴林慈暄（协助执行）用了一个月的时间，构思故事脚本和互动方式。故事带领小朋友回顾10年来《小小拇指》的重要内容，比如认识新加坡、各种新鲜趣闻，以及朗朗上口的本土儿歌，过程中会穿插各种想法交流和亲自动手的环节。
        
        """
    }

```

**function_call_demo.py**


```python
import json
from transformers import AutoTokenizer, AutoModel

from tools import system_info

tokenizer = AutoTokenizer.from_pretrained("/data/models/llm/chatglm3-6b/", trust_remote_code=True)
model = AutoModel.from_pretrained("/data/models/llm/chatglm3-6b/", trust_remote_code=True).cuda()
model = model.eval()


def model_chat(task_query):
    model_history = [system_info]
    model_response, model_history = model.chat(tokenizer, task_query, history=model_history)
    return run_task(model_response, model_history)


def run_task(model_response, model_history):
    if isinstance(model_response, dict):
        import function_map
        func = getattr(function_map, model_response.get("name"))
        param = model_response.get("parameters")
        func_response = func(**param)
        result = json.dumps(func_response, ensure_ascii=False)
        model_response, model_history = model.chat(tokenizer, result, history=model_history, role="observation")
        model_response, model_history = run_task(model_response, model_history)
        return model_response, model_history
    else:
        return model_response, model_history


if __name__ == '__main__':
    query = """
        今天下午我要去北京出差，请帮我查询一下当地的天气，另外我应该采取什么样的穿衣风格？
    """
    response, _ = model_chat(query)
    print(response)
    # while True:
    #     query = input("query:")
    #     response, _ = model_chat(query)
    #     print(response)

```

ChatGLM3 API工具调用能力测试

:::info{title="相关信息"}
本文介绍如何根据文本检索视频中对应位置

本文仅为demo实现，旨在提供一种解决思路。

speech-to-text模型：[Whisper](https://github.com/openai/whisper)

Vector-DB：[Milvus](https://milvus.io/)
:::


# 思路剖析
不知道你是否用过字幕生成，这里的原理跟字幕生成是差不多的，我们先来分析一下字幕生成的思路
- 从视频中分离音频轨道
- 分离音频中的人声
- 音频转文字
- 记录每句话的开始帧和结束帧
- 格式化数据，即1、旁白序号2、开始时间-->结束时间3、旁白内容
- 将上述数据导出为CRT或其他字幕文件

本文的步骤在上面的基础中多了Embeddings和向量数据库检索。
- 拿到格式化数据后对数据做Embedding之后入库
- 对自然语言做Embedding后到向量数据库做相似度查询
- 返回id，start_time,end_time,text
- 前端可以根据开始时间跳转到指定位置即为自然语言查询的时间点

# 快速开始
1. 安装ffmpeg


```bash
yum install epel-release -y
yum update -y
rpm --import http://li.nux.ro/download/nux/RPM-GPG-KEY-nux.ro
rpm -Uvh http://li.nux.ro/download/nux/dextop/el7/x86_64/nux-dextop-release-0-5.el7.nux.noarch.rpm
yum install ffmpeg ffmpeg-devel -y
ffmpeg
```
2. 创建虚拟环境


```bash
conda create -n video-similarity-search python=3.10
conda activate video-similarity-search
```
3. 安装依赖文件

创建requirements.txt文件

**requirements.txt**
```txt
flask~=2.3.3
flask-restful
flask-cors
openai-whisper
langchain
werkzeug
pymilvus
openai
```

```bash
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple some-package
```


4. 创建app.py文件


:::note{title="注"}
这里的 OPENAI_API_KEY,OPENAI_API_BASE,MILVUS_HOST,MILVUS_PORT为另外一个配置文件内容，请替换为自己的真实配置
:::
**app.py**
```python
import os
import tempfile
import time

import whisper
from langchain.embeddings import OpenAIEmbeddings
from langchain.schema import Document
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores.milvus import Milvus
from pymilvus import connections, Collection
from flask import Flask, jsonify
from flask_restful import reqparse
from flask_cors import CORS
from werkzeug.datastructures import FileStorage
from config import (
    OPENAI_API_KEY,
    OPENAI_API_BASE,
    MILVUS_HOST,
    MILVUS_PORT
)

app = Flask(__name__)
CORS(app=app)


@app.route("/embedding", methods=['POST'])
def create_segments_by_whisper():
    parser = reqparse.RequestParser()
    parser.add_argument('video', type=FileStorage, default=None, location='files', action='append')
    args = parser.parse_args()
    collection_names = []
    with tempfile.TemporaryDirectory() as temp_dir:
        for video in args.video:
            subtitle_list = []
            video_path = os.path.join(temp_dir, video.filename)
            video.save(video_path)
            result = model.transcribe(video_path)

            segments = result.get("segments")
            for segment in segments:
                seg_id = segment.get('id') + 1  # SRT字幕文件序号从1开始，whisper下标从0开始
                seg_start_time = segment.get('start')
                seg_end_time = segment.get('end')
                seg_text = segment.get('text')
                subtitle_list.append((seg_id, seg_start_time, seg_end_time, seg_text))
            collection_name = create_srt_file(subtitle_list)
            collection_names.append(collection_name)
    return jsonify(
        {
            "code": 200,
            "data": collection_names,
            "msg": "success"
        }
    )


def create_srt_file(transcripts):
    documents = []
    collection_name = f"collection_{int(time.time())}"
    for i, start_time, end_time, text in transcripts:
        document = Document(
            page_content=text,
            metadata={
                "id": i,
                "start_time": start_time,
                "end_time": end_time
            }
        )
        documents.append(document)
    embedding_to_milvus(documents, collection_name)
    return collection_name


def format_time(seconds):
    # 将秒数转换为SRT时间格式
    hours, remainder = divmod(seconds, 3600)
    minutes, seconds = divmod(remainder, 60)
    return "{:02}:{:02}:{:02},000".format(int(hours), int(minutes), int(seconds))


def embedding_to_milvus(documents, collection_name):
    # 实例化splitter
    text_splitter = CharacterTextSplitter()
    docs = text_splitter.split_documents(documents)
    # 数据embedding并存储到Milvus
    Milvus.from_documents(
        docs,
        embedding=embeddings,
        connection_args={
            "host": MILVUS_HOST,
            "port": MILVUS_PORT},
        collection_name=collection_name
    )


@app.route("/search", methods=['GET'])
def vector_search():
    """
    对问题做embedding之后做向量查询，返回查询结果
    :return:
    """
    parser = reqparse.RequestParser()
    parser.add_argument('query', type=str, default=None)
    parser.add_argument('collection_name', type=str, default=None)
    args = parser.parse_args()
    connections.connect(host=MILVUS_HOST, port=MILVUS_PORT)
    vector = embeddings.embed_query(args.query)
    results_vec = []
    collection = Collection(args.collection_name)
    collection.load()

    search_param = {
        "data": [vector],
        "anns_field": "vector",
        "param": {"metric_type": "L2", "offset": 0},
        "limit": 10,
        "expr": None,
        "output_fields": ['id', "start_time", "end_time", "text"],
        "consistency_level": "Strong"
    }
    results = collection.search(**search_param)
    for result in results[0]:
        data = {
            "id": result.entity.get('id'),
            "text": result.entity.get('text'),
            "start_time": result.entity.get('start_time'),
            "end_time": result.entity.get('end_time'),
            "distance": result.distance
        }
        results_vec.append(data)
    results_vec = [item for item in results_vec if item['distance'] <= 0.35]
    return jsonify(
        {
            "code": 200,
            "data": results_vec,
            "msg": "success"
        }
    )


if __name__ == '__main__':
    model = whisper.load_model("base")
    embeddings = OpenAIEmbeddings(
        openai_api_base=OPENAI_API_BASE,
        openai_api_key=OPENAI_API_KEY,
        openai_api_type="azure",
        deployment="text-embedding-ada-002"
    )
    app.run(host="0.0.0.0", port=5000)

```

# 效果展示
**支持上传多个文件，返回的是Milvus的Collection_name，也是查询接口的入参**

![image.png](/static/img/2dafc4990122606393a245d2a30a708b.image.webp)

**将上面获取的Collection_name复制到body中，输入查询的问题**

![image.png](/static/img/fe63e14658212d3db72cf67f38b75418.image.webp)

# 测试数据

:::tip{title="提示"}
RTF“实时因子”（Real-Time Factor)

这里的数据是我自己电脑跑出来的数据，可能因为CPU或GPU不同测试结果也会有所差异，请勿对号入座
:::
**base 模型**

gpu下

模型显存占用 1.7G  4分10秒的视频解析用时9秒

RTF 1:27.7

cpu下

内存占用 1G，4分10秒的视频解析用时32秒

RTF 1:7.8

自然语言获取视频内相关位置

:::info{title="相关信息"}
本文主要介绍大语言模型对工具(API)的调用，如Openai Function Calling，Langchain agent，ToolBench ToolLLaMA，Qwen。大语言模型下文统称LLM
:::


# 解惑
**大语言模型怎么调用API？**

LLM自身并不能调用API，我们知道LLM的交互方式是文本到文本，所以并不具备调用API的能力，但是我们可以提供一个格式化的API配置信息如json串，我们可以在json串中对API的作用、API的参数、API的返回等等信息进行描述，并告诉LLM当你无法完成某件事情的时候可以使用这些API，并返回该API的json对象。例如我们问今天北京天气怎么样，LLM显然不可能查询到天气信息，但LLM可以返回查询天气的API json，我们拿到这个json之后编写代码实现API调用，并把返回内容再次给到LLM，这样LLM就可以完成例如查询天气这样的任务。
# Openai Function Calling
**官方介绍**

在API调用中，您可以描述要发送给gpt-3.5-turbo-0613和gpt-4-0613的函数，并让模型智能地选择输出一个包含调用这些函数的参数的JSON对象。Chat completions API不会调用该函数；相反，模型会生成JSON，您可以在代码中使用该JSON来调用函数。

最新的模型（gpt-3.5-turbo-0613和gpt-4-0613）已经经过微调，既可以检测何时应该调用函数（取决于输入），又可以以符合函数签名的JSON进行响应。然而，这种能力也带来了潜在的风险。我们强烈建议在代表用户采取影响世界的行动之前（发送电子邮件、发布内容、进行购买等），在用户确认流程中进行构建。

**官方示例**

```python
import openai
import json

# Example dummy function hard coded to return the same weather
# In production, this could be your backend API or an external API
def get_current_weather(location, unit="fahrenheit"):
    """Get the current weather in a given location"""
    weather_info = {
        "location": location,
        "temperature": "72",
        "unit": unit,
        "forecast": ["sunny", "windy"],
    }
    return json.dumps(weather_info)

def run_conversation():
    # Step 1: send the conversation and available functions to GPT
    messages = [{"role": "user", "content": "What's the weather like in Boston?"}]
    functions = [
        {
            "name": "get_current_weather",
            "description": "Get the current weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    },
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                },
                "required": ["location"],
            },
        }
    ]
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-0613",
        messages=messages,
        functions=functions,
        function_call="auto",  # auto is default, but we'll be explicit
    )
    response_message = response["choices"][0]["message"]

    # Step 2: check if GPT wanted to call a function
    if response_message.get("function_call"):
        # Step 3: call the function
        # Note: the JSON response may not always be valid; be sure to handle errors
        available_functions = {
            "get_current_weather": get_current_weather,
        }  # only one function in this example, but you can have multiple
        function_name = response_message["function_call"]["name"]
        function_to_call = available_functions[function_name]
        function_args = json.loads(response_message["function_call"]["arguments"])
        function_response = function_to_call(
            location=function_args.get("location"),
            unit=function_args.get("unit"),
        )

        # Step 4: send the info on the function call and function response to GPT
        messages.append(response_message)  # extend conversation with assistant's reply
        messages.append(
            {
                "role": "function",
                "name": function_name,
                "content": function_response,
            }
        )  # extend conversation with function response
        second_response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo-0613",
            messages=messages,
        )  # get a new response from GPT where it can see the function response
        return second_response

print(run_conversation())
```
**流程解析**

当调用ChatCompletion api时传入functions参数后，api返回结构中包含function_call字段，如果这个字段不为空则表明需要调用api，此时可以从function_call对象中取得name和arguments属性，name是api的名字，arguments是该api需要的参数，我们可以使用很多方法拿到函数对象进行调用，就比如示例中是将函数存入字典中用使用name对字典取值就可以拿到对应的函数对象。示例流程如下
<div style="text-align: center;">

```mermaid
                    graph TD
                    A(chatcompletion) --> C{function_call}
                    C{function_call} -- true --> B[call_function]
                    C{function_call} -- false --> D[final_answer]
                    B[call_function] --> D[final_answer]
```
</div> 

**思考**

上面是一个最小示例，如果我们的任务需要调用多个api的时候就需要对代码进行改造了，例如可以把函数调用的内容封装成一个函数，递归的判断api返回中function_call是否为空，直到为空为止退出递归给出最终答案。
# ToolBench
在继续之前建议先了解一下[langchain agents](https://python.langchain.com/docs/modules/agents/)将会对下面的内容理解有所帮助

**示意图**

![image.png](/static/img/831fca7c9fb0264abcc5eda3b53bef02.image.webp)

**流程图**

每个流程具体内容请见[ToolBench运行流程梳理](https://blog.mrbun.cn/post/14)
<div style="text-align: center;">

```mermaid
graph TD;
    A[on_tool_retrieval_start] --> B[on_tool_retrieval_end];
    B --> C[on_request_start];
    C --> D[on_chain_start];
    D --> E[on_llm_start];
    E --> F[on_llm_end];
    F --> G[on_agent_action];
    G --> H[on_tool_start];
    H --> I[on_tool_end];
    I --> J[on_chain_end];
    J --> K[on_agent_end];
    K --> L[on_request_end];
    subgraph Loop
        D1[on_chain_start] --> E1[on_llm_start];
        E1 --> F1[on_llm_end];
        F1 --> G1[on_agent_action];
        G1 --> H1[on_tool_start];
        H1 --> I1[on_tool_end];
        I1 --> D1;
    end
```
</div> 

**ToolBench解决了什么问题**

思考一下，LLM的token是有上限的，不管是多大的上下文哪怕是100k的上下文或者是后面更大的上下文都是有上限的，那么在很庞大的api数量下上下文是一个致命的问题，ToolBench收集了16000+个Rapid API，这些API信息都放进LLM的上下文中显然是不现实的，因此，ToolBench提出了在LLM前面加一个Retriever模型，它负责将问题与api的描述信息做语义查询（可参考这篇文章[Embeddings](https://blog.mrbun.cn/post/11)），找出最符合要求的top_k个结果，这些结果是Rapid API的路径，通过这些路径可以得到api的调用脚本以及描述。将这些api交给LLM进行调用。这样就解决了上下文的问题，看到这里想必大家都知道了，这个跟RAG(Retrieval-augmented generation)很相似.

**ToolBench有哪些创新**

目前大多数的工具调用方式多为CoT或ReAct，ToolBench提出了基于DFSDT（深度优先决策树）的方式，该方式极大程度上提高了任务执行的成功率，

![image.png](/static/img/efd4343a8c9a54f8200861f49b00f285.image.webp)

**ToolBench Custom API Tool**

后面我会写一个自动生成ToolBench自定义API的工具，由于目前OpenBMB还未发布中文模型，暂时搁置，后面会更新。。。。。。

# Qwen
Qwen对langchain的agents做了定向训练，可以实现不错的工具集调用效果。

**最小示例**

:::tip{title="提示"}
请自行实现TOOLS中的api配置

官方示例：https://github.com/QwenLM/Qwen/blob/main/examples/react_demo.py
:::

```python
import json
from typing import List

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.generation import GenerationConfig
import utils.calamity_request as calamity
from src.tools.tools_multiple_dialog import TOOLS


for _ in range(10):  # 网络不稳定，多试几次
    try:
        name = '/data/models/Qwen-7B-Chat'
        tokenizer = AutoTokenizer.from_pretrained(name, trust_remote_code=True)
        generation_config = GenerationConfig.from_pretrained(name, trust_remote_code=True)
        model = AutoModelForCausalLM.from_pretrained(
            name, device_map="auto", trust_remote_code=True
        ).eval()
        model.generation_config = generation_config
        model.generation_config.top_k = 1
        break
    except Exception as e:
        print(e)

# 将一个插件的关键信息拼接成一段文本的模版。
TOOL_DESC = """{name_for_model}: Call this tool to interact with the {name_for_human} API. What is the {name_for_human} API useful for? {description_for_model} Parameters: {parameters} Response: {response}"""

# ReAct prompting 的 instruction 模版，将包含插件的详细信息。
PROMPT_REACT = """Answer the following questions as best you can. You have access to the following APIs:

{tools_text}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tools_name_text}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can be repeated zero or more times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {query}"""


#
# 本示例代码的入口函数。
#
# 输入：
#   prompt: 用户的最新一个问题。
#   history: 用户与模型的对话历史，是一个 list，
#       list 中的每个元素为 {"user": "用户输入", "bot": "模型输出"} 的一轮对话。
#       最新的一轮对话放 list 末尾。不包含最新一个问题。
#   list_of_plugin_info: 候选插件列表，是一个 list，list 中的每个元素为一个插件的关键信息。
#       比如 list_of_plugin_info = [plugin_info_0, plugin_info_1, plugin_info_2]，
#       其中 plugin_info_0, plugin_info_1, plugin_info_2 这几个样例见本文档前文。
#
# 输出：
#   模型对用户最新一个问题的回答。
#
def llm_with_plugin(prompt: str, history, list_of_plugin_info=()):
    chat_history = [(x['user'], x['bot']) for x in history] + [(prompt, '')]

    # 需要让模型进行续写的初始文本
    planning_prompt = build_input_text(chat_history, list_of_plugin_info)

    text = ''
    while True:
        output = text_completion(planning_prompt + text, stop_words=['Observation:', 'Observation:\n'])
        action, action_input, output = parse_latest_plugin_call(output)
        if action:  # 需要调用插件
            # action、action_input 分别为需要调用的插件代号、输入参数
            # observation是插件返回的结果，为字符串
            observation = call_plugin(action, action_input)
            output += f'\nObservation: {observation}\nThought:'
            text += output
        else:  # 生成结束，并且不再需要调用插件
            text += output
            break

    new_history = []
    new_history.extend(history)
    new_history.append({'user': prompt, 'bot': text})
    return text, new_history


# 将对话历史、插件信息聚合成一段初始文本
def build_input_text(chat_history, list_of_plugin_info) -> str:
    # 候选插件的详细信息
    tools_text = []
    for plugin_info in list_of_plugin_info:
        tool = TOOL_DESC.format(
            name_for_model=plugin_info["name_for_model"],
            name_for_human=plugin_info["name_for_human"],
            description_for_model=plugin_info["description_for_model"],
            parameters=json.dumps(plugin_info["parameters"], ensure_ascii=False),
            response=json.dumps(plugin_info["response"], ensure_ascii=False)
        )
        if plugin_info.get('args_format', 'json') == 'json':
            tool += " Format the arguments as a JSON object."
        elif plugin_info['args_format'] == 'code':
            tool += ' Enclose the code within triple backticks (`) at the beginning and end of the code.'
        else:
            raise NotImplementedError
        tools_text.append(tool)
    tools_text = '\n\n'.join(tools_text)

    # 候选插件的代号
    tools_name_text = ', '.join([plugin_info["name_for_model"] for plugin_info in list_of_plugin_info])

    im_start = '<|im_start|>'
    im_end = '<|im_end|>'
    prompt = f'{im_start}system\nYou are a helpful assistant.{im_end}'
    for i, (query, response) in enumerate(chat_history):
        if list_of_plugin_info:  # 如果有候选插件
            # 倒数第一轮或倒数第二轮对话填入详细的插件信息，但具体什么位置填可以自行判断
            if (len(chat_history) == 1) or (i == len(chat_history) - 2):
                query = PROMPT_REACT.format(
                    tools_text=tools_text,
                    tools_name_text=tools_name_text,
                    query=query,
                )
        query = query.lstrip('\n').rstrip()  # 重要！若不 strip 会与训练时数据的构造方式产生差异。
        response = response.lstrip('\n').rstrip()  # 重要！若不 strip 会与训练时数据的构造方式产生差异。
        # 使用续写模式（text completion）时，需要用如下格式区分用户和AI：
        prompt += f"\n{im_start}user\n{query}{im_end}"
        prompt += f"\n{im_start}assistant\n{response}{im_end}"

    assert prompt.endswith(f"\n{im_start}assistant\n{im_end}")
    prompt = prompt[: -len(f'{im_end}')]
    return prompt


def text_completion(input_text: str, stop_words) -> str:  # 作为一个文本续写模型来使用
    im_end = '<|im_end|>'
    if im_end not in stop_words:
        stop_words = stop_words + [im_end]
    stop_words_ids = [tokenizer.encode(w) for w in stop_words]

    # TODO: 增加流式输出的样例实现
    input_ids = torch.tensor([tokenizer.encode(input_text)]).to(model.device)
    output = model.generate(input_ids, stop_words_ids=stop_words_ids)
    output = output.tolist()[0]
    output = tokenizer.decode(output, errors="ignore")
    assert output.startswith(input_text)
    output = output[len(input_text) :].replace('<|endoftext|>', '').replace(im_end, '')

    for stop_str in stop_words:
        idx = output.find(stop_str)
        if idx != -1:
            output = output[: idx + len(stop_str)]
    return output  # 续写 input_text 的结果，不包含 input_text 的内容


def parse_latest_plugin_call(text):
    plugin_name, plugin_args = '', ''
    i = text.rfind('\nAction:')
    j = text.rfind('\nAction Input:')
    k = text.rfind('\nObservation:')
    if 0 <= i < j:  # If the text has `Action` and `Action input`,
        if k < j:  # but does not contain `Observation`,
            # then it is likely that `Observation` is ommited by the LLM,
            # because the output text may have discarded the stop word.
            text = text.rstrip() + '\nObservation:'  # Add it back.
        k = text.rfind('\nObservation:')
        plugin_name = text[i + len('\nAction:') : j].strip()
        plugin_args = text[j + len('\nAction Input:') : k].strip()
        text = text[:k]
    return plugin_name, plugin_args, text


#
# 输入：
#   plugin_name: 需要调用的插件代号，对应 name_for_model。
#   plugin_args：插件的输入参数，是一个 dict，dict 的 key、value 分别为参数名、参数值。
# 输出：
#   插件的返回结果，需要是字符串。
#   即使原本是 JSON 输出，也请 json.dumps(..., ensure_ascii=False) 成字符串。
#
def call_plugin(plugin_name: str, plugin_args: str) -> str:
    #
    # 请开发者自行完善这部分内容。这里的参考实现仅是 demo 用途，非生产用途。
    #
    query = json.loads(plugin_args)
    params = [v for k, v in query.items()]
    func = getattr(calamity, plugin_name)
    return func(*params)


def do_chat(query: str, history: List[dict]):
    print(f"User's Query:\n{query}\n")
    response, history = llm_with_plugin(prompt=query, history=history, list_of_plugin_info=TOOLS)
    print(f"Qwen's Response:\n{response}\n")
    return response, history


# if __name__ == "__main__":
#     test()
```
# 总结
经过测试，目前Openai Function Calling的效果最好，Qwen紧跟其后，Qwen的json解析能力超出了我的预期，Qwen对自然语言的参数提取效果出奇的好，因为Openai无法保证私域数据的安全性因此Qwen成为了首选。ToolBench提出的框架很好，但是受限于ToolLLaMA的表现效果不太理想。

LLM工具调用

:::info{title="相关信息"}
本文主要介绍如何微调大语言模型比如ChatGLM或类LLaMA的模型

GitHub仓库地址:

ChatGLM：https://github.com/hiyouga/ChatGLM-Efficient-Tuning

LLaMA：https://github.com/hiyouga/LLaMA-Factory
:::


**两个仓库功能类似，这里以LLaMA为例。作者提供了一站式训练推理的web平台，实现了几乎零代码训练和推理**
## 视频教程
<iframe src="//player.bilibili.com/player.html?aid=962262106&bvid=BV1oH4y1R7xi&cid=1304601108&p=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"> </iframe>

## 准备环境
**硬件**
- 一张大于等于24G显存的显卡（推荐），使用QLoRA 4bit量化可以在16G显存的显卡上跑7b模型的微调任务

实测截图(llama-7b qlora 4bit sft)

![image.png](/static/img/5b188bdd838caa22d1ec41b55cf574a4.image.webp)

![image.png](/static/img/8e661595fad5f06b6694ff0bc8e637e4.image.webp)

**系统环境**

Windows

Linux(推荐)

Windows上安装依赖包可能会有很多报错，如果只有Windows可以开启Windows子系统WSL，详细教程请见[Windows开启WSL](https://blog.mrbun.cn/post/10)

**Python解释器**

这里推荐使用[Anaconda](https://www.anaconda.com/download)，当然你也可以使用python的virtualenv
## 快速开始
**克隆仓库到本地**

```bash
git clone https://github.com/hiyouga/LLaMA-Factory.git

# 如果你的网络无法访问GitHub请使用下面的链接

git clone https://ghproxy.com/https://github.com/hiyouga/LLaMA-Factory.git
```

**创建python虚拟环境**

```bash
conda create -n llm-fine-tune python=3.10
conda activate llm-fine-tune
```
**安装依赖**

```bash
cd LLaMA-Factory/
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple some-package
```
**Web UI ALL IN ONE 启动😅**

```bash
CUDA_VISIBLE_DEVICES=0 python src/train_web.py
```
**如果你无法使用Web UI也可以使用命令运行**

**Pre-Training**

```bash
CUDA_VISIBLE_DEVICES=0 python src/train_bash.py \
    --stage pt \
    --model_name_or_path path_to_llama_model \
    --do_train \
    --dataset wiki_demo \
    --finetuning_type lora \
    --lora_target q_proj,v_proj \
    --output_dir path_to_pt_checkpoint \
    --overwrite_cache \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_steps 1000 \
    --learning_rate 5e-5 \
    --num_train_epochs 3.0 \
    --plot_loss \
    --fp16
```
**Supervised Fine-Tuning**

```bash
CUDA_VISIBLE_DEVICES=0 python src/train_bash.py \
    --stage sft \
    --model_name_or_path path_to_llama_model \
    --do_train \
    --dataset alpaca_gpt4_en \
    --template default \
    --finetuning_type lora \
    --lora_target q_proj,v_proj \
    --output_dir path_to_sft_checkpoint \
    --overwrite_cache \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_steps 1000 \
    --learning_rate 5e-5 \
    --num_train_epochs 3.0 \
    --plot_loss \
    --fp16
```
**Reward Modeling**

```bash
CUDA_VISIBLE_DEVICES=0 python src/train_bash.py \
    --stage rm \
    --model_name_or_path path_to_llama_model \
    --do_train \
    --dataset comparison_gpt4_en \
    --template default \
    --finetuning_type lora \
    --lora_target q_proj,v_proj \
    --resume_lora_training False \
    --checkpoint_dir path_to_sft_checkpoint \
    --output_dir path_to_rm_checkpoint \
    --per_device_train_batch_size 2 \
    --gradient_accumulation_steps 4 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_steps 1000 \
    --learning_rate 1e-6 \
    --num_train_epochs 1.0 \
    --plot_loss \
    --fp16
```
**PPO Training**

```bash
CUDA_VISIBLE_DEVICES=0 python src/train_bash.py \
    --stage ppo \
    --model_name_or_path path_to_llama_model \
    --do_train \
    --dataset alpaca_gpt4_en \
    --template default \
    --finetuning_type lora \
    --lora_target q_proj,v_proj \
    --resume_lora_training False \
    --checkpoint_dir path_to_sft_checkpoint \
    --reward_model path_to_rm_checkpoint \
    --output_dir path_to_ppo_checkpoint \
    --per_device_train_batch_size 2 \
    --gradient_accumulation_steps 4 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_steps 1000 \
    --learning_rate 1e-5 \
    --num_train_epochs 1.0 \
    --plot_loss \
    --fp16
```
**DPO Training**

```bash
CUDA_VISIBLE_DEVICES=0 python src/train_bash.py \
    --stage dpo \
    --model_name_or_path path_to_llama_model \
    --do_train \
    --dataset comparison_gpt4_en \
    --template default \
    --finetuning_type lora \
    --lora_target q_proj,v_proj \
    --resume_lora_training False \
    --checkpoint_dir path_to_sft_checkpoint \
    --output_dir path_to_dpo_checkpoint \
    --per_device_train_batch_size 2 \
    --gradient_accumulation_steps 4 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_steps 1000 \
    --learning_rate 1e-5 \
    --num_train_epochs 1.0 \
    --plot_loss \
    --fp16
```
**模型合并**

```bash
python src/export_model.py \
    --model_name_or_path path_to_llama_model \
    --template default \
    --finetuning_type lora \
    --checkpoint_dir path_to_checkpoint \
    --export_dir path_to_export \
    --fp16
```
# 模型推理
**API Demo**

```bash
python src/api_demo.py \
    --model_name_or_path path_to_llama_model \
    --template default \
    --finetuning_type lora \
    --checkpoint_dir path_to_checkpoint
```
**CLI Demo**

```bash
python src/cli_demo.py \
    --model_name_or_path path_to_llama_model \
    --template default \
    --finetuning_type lora \
    --checkpoint_dir path_to_checkpoint
```
**Web Demo**

```bash
python src/web_demo.py \
    --model_name_or_path path_to_llama_model \
    --template default \
    --finetuning_type lora \
    --checkpoint_dir path_to_checkpoint
```

# 关于数据集
这个项目的数据集均使用开源数据集，如果有自己的数据集请按照仓库中数据集的格式进行格式化，另外添加数据集后需要在**data/dataset_info.json**中配置自己的数据集。

**举个🌰**

我本地有一个数据集demo.json已经按照仓库中的数据集格式进行了格式化，并且已经放到本地项目的data目录下了，此时需要编辑一下dataset_info.json文件添加以下内容

```json
"mathinstruct": {
    "file_name": "demo.json",
    "columns": {
      "prompt": "instruction",
      "query": "",
      "response": "output",
      "history": ""
    }
  }
```
这里的columns需要与文件内的key值对应，例如demo.json中的数据如下

```json
[
    {
	"question": "三原色是什么？",
	"input": "",
	"answer": "三原色通常指的是红色、绿色和蓝色（RGB）。"
	}
]
```
那么对应的dataset_info.json中应该改为

```json
"mathinstruct": {
    "file_name": "demo.json",
    "columns": {
      "prompt": "question",
      "query": "input",
      "response": "answer"
    }
  }
```
# 总结
写这个是因为最近在B站和公众号看到很多人拿一些开源的东西包装成课在卖，而且不便宜。如果你是卖课的我劝你有这精力不如多研究一下怎么赚外国人的钱。

作为这两个项目的贡献者，我也希望这两个项目能被更多人使用，提出宝贵意见，大家一起共建。

LLM Fine Tune

:::info{title="相关信息"}
记录genai-stack调研内容
:::



genai-stack核心为ollama,ollama提供大预言模型的推理以及词嵌入(embeddings)接口供stack中的ai应用使用。

本地配置文件示例

```yaml
OPENAI_API_KEY=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
OLLAMA_BASE_URL=http://192.168.98.209:11434
NEO4J_URI=neo4j://192.168.98.209:7687
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=xh980904
LLM=llama2 #or any Ollama model tag, or gpt-4 or gpt-3.5
EMBEDDING_MODEL=openai #or openai or ollama

LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"
LANGCHAIN_TRACING_V2=true # false
LANGCHAIN_PROJECT=gen-stack
LANGCHAIN_API_KEY=ls__c87d1a5552ca430e9733f7bea82889dc
```
**agent-bot**

![image.png](/static/img/518c859bed4681600e840fbb9f2c1479.image.webp)
开启RAG可以进行Neo4j搜索，找到相关内容加到上下文中。

![image.png](/static/img/3b12ba9f5de4324fb11af69832f14a3a.image.webp)

**Loder**

从StackOverflow中检索关键字load到neo4j

![image.png](/static/img/09cd295d8fb3d8ac2dbece4d3c753e03.image.webp)

在neo4j中信息以关系对的形式组成一张图，在agent-bot中开启RAG将会从这里进行检索相关数据加入到上下文以便回答用户问题

![image.png](/static/img/04790b627286c32fd8526aa7218b6afc.image.webp)

**Chat with your pdf file**


![image.png](/static/img/b13c539c0abda88fa8ed2cbd9ab414e9.image.webp)