:::info{title="相关信息"}
GitHub地址[ToolBench](https://github.com/OpenBMB/ToolBench)

代码仓库可能已经更新，源码位置可能会不准确，还请诸位自行甄别

解析从自然语言到模型的最终答案ToolBench的运行过程，注意这里的所有内容是以开放性问题（Open domain）进行的，
:::


# ToolBench运行流程如下
```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
```
**在Loop中状态的改变是由ToolLLaMA决定的，当ToolLLaMA认为可以给出最终答案时会改变最后一个node的success为1，此时DFS函数达到退出递归条件，结束loop。**

# on_tool_retrieval_start & on_tool_retrieval_end
这个过程retriever模型会对问题进行embedding，然后到corpus.tsv中进行语义搜索，返回最相关的Top_k条记录作为task放到task_list中。

源码请见rapidapi.py 488-490行，retriever.py 35-56行
```python
query_embedding = self.embedder.encode(query, convert_to_tensor=True)
hits = util.semantic_search(query_embedding, self.corpus_embeddings, top_k=10*top_k, score_function=util.cos_sim)
```
# on_request_start & on_request_end
询问开始主要处理了请求中的参数，初始化一些工具类，询问结束则是处理在DFS中返回的节点内的信息，处理整个过程中的历史对话信息。

详情见rapidapi.py 496-522行

# on_chain_start & on_chain_end
返回chain_block_id

```python
    def on_chain_start(self, inputs: str, depth: int) -> Any:
        """Run when chain starts running."""
        print("on_chain_start method called")
        self.llm_block_id += 1
        block_id = "llm-" + str(self.llm_block_id)
        self.add_to_queue(
            "on_chain_start",
            block_id=block_id,
            messages=inputs,
            depth=depth
        )
        return block_id
```
# on_llm_start & on_llm_end
把上面语义搜索的task以及问题给ToolLLaMA，让他决定是否需要调用API，要调用哪个API，返回API的名称以及所需要的参数
# on_agent_action & on_agent_end
返回agent_block_ids
# on_tool_start & on_tool_end
拿到接口名称及参数进行接口调用，详情见DFS.py 266-267行，Tree/server.py 85-99行

```python
def run(toolbench_code_string, toolbench_api_name, toolbench_input_params_str):
    # get observation
    success_flag = False
    switch_flag = False
    save_cache = False
    exec(toolbench_code_string)
    try:
        eval_func_str = f"{toolbench_api_name}({toolbench_input_params_str})"
        new_func = eval(eval_func_str)
        response, save_cache, switch_flag = process_error(new_func)
        success_flag = True
    except Exception as e:
        response = {"error": f"Function executing {toolbench_code_string} error...\n{e}", "response": ""}
        save_cache = False
    return success_flag, switch_flag, response, save_cache
```

ToolBench运行流程梳理

:::info{title="相关信息"}
记录安装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
```

CentOS安装ffmpeg

:::info{title="相关信息"}
嵌入（Embeddings）是机器学习领域中的一个概念，主要用于将高维的数据转化为低维空间，以便于算法更好地处理和理解数据。嵌入通常用于将离散的、高维的特征转换为连续的、低维的向量表示。本文将以经典的嵌入模型word2vec为例介绍其训练过程，embedding过程，通过阅读，您将理解一段文本是如何转化为n维向量的。
:::




# word2vec

Word2Vec 是一种用于生成词嵌入的算法，它基于分布式假设，即假设上下文相似的单词在语义上也是相似的。Word2Vec 有两种主要的训练模型：连续词袋模型（Continuous Bag of Words，CBOW）和跳字模型（Skip-gram）。
  <center>
    <img src="/static/img/6829e11e18f0bb3425388628d295755b.image.webp"/>
 </center>

CBOW：通过给定一个词的上下文单词，来预测中心词，模型的输入是上下文词的词向量，输出是中心词的词向量。CBOW 的训练目标是最大化预测中心词的概率，从而得到能够很好地表示上下文语境的词向量。
  <center>
    <img src="/static/img/95d8b9bb072705925381e01b87141419.image.webp"/>
 </center>

Skip-gram：Skip-gram 的思想与 CBOW 相反，它通过给定一个中心词，来预测其周围的上下文词。模型的输入是中心词的词向量，输出是上下文词的词向量。Skip-gram 的训练目标是最大化预测上下文词的概率，从而得到能够很好地捕捉词语语义的词向量。

# Embedding过程
 
word2vec模型有一张词表，词表中包含训练数据中所有单词所对应的词向量，当使用word2vec将句子转化为向量时，一种常见的方法是将句子中所有单词的词向量取平均或加权平均。这可以帮助将整个句子的语义信息编码到一个向量中。大致步骤如下
- 获取每个单词的词向量，将句子中的每个单词都映射到Word2Vec模型中的词向量空间，得到对应的词向量。
- 计算平均向量：将所有单词的词向量取平均，得到句子的平均向量。

假设目前有一个已经训练好的word2vec模型，模型的输入为“我喜欢苹果”，分词向量表如下。请注意这里的词向量维度为3，实际词表中的维度远远大于这个值。
<div style="display: flex; justify-content: center;">
  
| 单词 | 词向量 |
| :-: | :-: |
|我  | [0.2, 0.3, 0.5]|
|喜欢|[0.4, 0.1, 0.8]|
|苹果|[0.6, 0.7, 0.9]|

</div>

接下来我们使用词向量平均的方法，将这个句子转化为向量。设我的词向量为α1 ，喜欢的词向量为α2 ，苹果的词向量为α3 

```math
Avg_vec = (α1 + α2 + α3) / 3
		 = ([0.2, 0.3, 0.5] + [0.4, 0.1, 0.8] + [0.6, 0.7, 0.9]) / 3
		 = [1.2, 1.1, 2.2] / 3
		 = [0.4, 0.367, 0.733]
```

这样，"我喜欢苹果" 这个句子就被转化为了一个向量 [0.4, 0.367, 0.733]，其中每个维度代表了句子在对应语义维度上的平均值。这个向量可以用于表示句子的语义特征。

# 计算向量之间相似性
在计算向量之间的相似性时，常用的方法包括余弦相似度（Cosine Similarity）以及欧几里得距离（Euclidean Distance）

- 余弦相似度衡量了两个向量之间的夹角，取值范围在-1到1之间。相似的向量夹角接近0度，余弦相似度接近1，表示相似性高；夹角接近180度，余弦相似度接近-1，表示相似性低；夹角为90度，余弦相似度接近0，表示两向量正交，无明显相似特征。

<center>
<img src="/static/img/f46deaa5177b3bc6918fb776b003b663.image.webp" style="width:50%"/>
</center>


- 欧几里得距离是计算两个向量之间的距离，值越小表示越相似，值越大表示越不相似。

<center>
<img src="/static/img/9e988a07de2f5cbd38e6f724a87e0b74.image.webp" style="width:50%"/>
</center>


以余弦相似度为例，假设我想要得到在向量数据库中与我的问题最接近的文本，首先我需要对我的问题做向量化，假设用word2vec向量化后的问题向量为β1  = [0.3, 0.7, 0.5]，最接近的文本向量为β2  = [0.4, 0.6, 0.9]
1. 首先对β1 以及 β2 做内积，以及分别取摸

```math
β1 ·β2  = (0.3 * 0.4) + (0.7 * 0.6) + (0.5 * 0.9) = 0.99
||β1|| = √(0.32 + 0.72 + 0.52) = 0.911
||β2|| = √(0.42 + 0.62 + 0.92) = 1.153
```

2. 然后使用余弦相似度公式计算β1 以及 β2 做相似度

```math
similarity = (β1 ·β2) / (||β1|| * ||β2 ||)
           = 0.99 / (0.911 * 1.153)
           = 0.9425
```

这个计算出的余弦相似度值接近于1，说明向量 β1 和向量 β2 在方向上非常相似，夹角很小。这表示向量 β1 和向量 β2 在某种意义上是相似的，具有一定的语义相关性。

# word2vec模型的训练过程
之前提到模型词表中已经存储了词向量，因此我们句子可以被分词之后到词表中找到对应词的词向量做加权平均得到句子的向量表示，那么词表中的词向量是从哪来的？接下来我将介绍word2vec模型的训练过程，从而解释这个问题
1. 准备数据

将文本分解为词语序列，构建词汇表，并为词汇表中的每个词分配初始的词向量。这些初始的词向量通常是随机的，这些随机初始化的词向量没有任何具体语义含义，它们只是作为模型训练的起点。随机初始化词向量的原因是，在开始训练之前，模型并不知道每个词汇的语义信息。通过随机初始化，模型有了一个初始状态，然后通过训练过程逐步调整这些词向量，使它们能够捕捉到词汇之间的语义关系。随机初始化的词向量可以是服从某种分布的随机数，比如均匀分布或正态分布。这些初始向量会在训练过程中逐渐调整，以使模型在预测上下文词汇时更准确。一个好的embedding模型拥有海量(GB,TB,PB)的文本作为训练数据，打个比方，同一个词出现的句子越多，在之后做embedding时越接近真实语义。

2. 上下文，中心词对
<center>
<img src="/static/img/32524356b5d9ffa9f67ddddd9929f772.image.webp" style="width:50%"/>
</center>
  对于一段文本，从第一个词开始以固定的窗口大小对文本进行切分，计算每个词出现的概率，每个词会拥有两个概率表示，一个为作为中心词出现的概率，另一个为作为上下文时出现的概率对应的，我们用两个词向量表示词表中的每个词，一个表示该词作为中心词时，另一个表示该词作为上下文时。
  
3. 计算概率分布

计算预测概率分布时使用了softmax函数。这个函数将模型的输出转化为概率分布，以便用于计算损失并进行优化。模型会根据输入的中心词或上下文词的词向量，计算每个词汇成为目标的概率。然后，使用softmax函数对这些概率进行归一化处理，确保它们形成一个合理的概率分布。这个概率分布表示给定上下文条件下，每个词汇成为中心词或上下文词的概率。这个分布会被用于计算损失函数（通常使用交叉熵损失），进而用于优化模型的参数，使得模型能够更好地预测实际的上下文或中心词。
<center>
<img src="/static/img/7ac970d919b3f813a2c4c6284b9317dc.image.webp" style="width:50%"/>
</center>
假设词向量为：

```math
Apple: [0.2, 0.4]
Banana: [0.5, 0.7]
Orange: [0.3, 0.6]
```
在Skip-gram模型中，我们要计算给定上下文词 "apple" 的情况下，每个词汇成为中心词的概率分布。我们可以使用 softmax 函数来计算这些概率。

首先计算内积

对于“banana” vapple ·vbanana = (0.2∗0.5)+(0.4∗0.7)=0.1+0.28=0.38

对于“orange” vapple ·vorange = (0.2∗0.3)+(0.4∗0.6)=0.06+0.24=0.3

使用softmax函数计算概率


$$
P("banana" | "apple") = \frac{e^{u"apple" \cdot u"banana"}}{e^{u"apple" \cdot u"banana"} + e^{u"apple" \cdot u"orange"}} =  \frac{e^{0.38}}{e^{0.38}+ e^{0.3}} \approx 0.55
$$
$$
P("orange" | "apple") = \frac{e^{u"apple" \cdot u"orange"}}{e^{u"apple" \cdot u"banana"} + e^{u"apple" \cdot u"orange"}} =  \frac{e^{0.3}}{e^{0.38}+ e^{0.3}} \approx 0.45
$$
在以apple为上下文的情况下，“banana”和“orange”成为中心词的概率分布，从结果可以得知，“banana”成为中心词的概率比较高
4. 损失函数梯度更新
	
使用模型的输出概率分布和实际上下文或中心词汇，计算损失，通常使用交叉熵损失函数。使用损失函数计算模型的梯度，然后使用优化算法（如梯度下降）来更新词向量，使预测更接近实际。
 <center>
<img src="https://blog.mrbun.cn/static/img/b9dbf3d128929323e19e935aadd05555.image.webp" style="width:50%"/>
</center>
其中V是词汇表大小，yi 是实际目标概率分布中词汇wi的概率（如果词汇是目标，则为1，否则为0），pi 是模型预测的概率分布中词汇wi的概率。使用损失函数的梯度来更新模型的参数，通常采用梯度下降等优化算法。目标是通过反向传播算法调整模型的参数，使得损失函数最小化。

5. 迭代训练

重复上述步骤多次，迭代训练模型。随着训练的进行，词向量会逐渐调整以更好地捕捉词汇之间的语义关系。
	

# 总结
2013年Google员工Tomas Mikolov等人提出了word2vec。用于在计算机中处理和分析文本数据。这个过程涉及将文本中的单词、短语或句子转化为向量表示，使得计算机能够处理和比较文本信息。Word2Vec利用深度学习模型，通过预测上下文词汇来生成词向量，从而捕捉单词之间的语义关系。这种向量表示使得文本信息能够在计算机中进行数学计算和分析，为自然语言处理任务提供了基础。

# 参考文献
- [Word2vecPaper ](https://arxiv.org/abs/1301.3781)
- [Word2vec模型训练源码 ](https://github.com/shouxieai/word_2_vec)
- [斯坦福《深度学习自然语言处理》Stanford CS224N](https://www.bilibili.com/video/BV1Nf4y1K7kU/?spm_id_from=333.1007.top_right_bar_window_custom_collection.content.click&vd_source=cfe03f3882bf44ea6b9a669d738759a0)

Embeddings

:::info{title="相关信息"}
主要介绍如何在Windows下安装WSL(Linux子系统)实现显卡共享
:::


# B站视频教程
<iframe src="//player.bilibili.com/player.html?aid=447215102&bvid=BV1ej41167KV&cid=1232713992&p=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"> </iframe>

# CentOS安装包下载地址
https://github.com/mishamosher/CentOS-WSL

如果无法访问GitHub可以使用我上传的地址

http://openwrt.mrbun.cn:5000/sharing/QvxNHFAlh
# 启用systemctl
```bash
vi /etc/wsl.conf

# 输入以下内容
[boot]
systemd=true

# 退出wsl并重启wsl
exit
wsl --shutdown
wsl

# 验证是否已经开启systemctl
ps --no-headers -o comm 1
```
# 启用nvidia-smi

```bash
cp /usr/lib/wsl/lib/nvidia-smi /usr/bin/nvidia-smi
chmod ogu+x /usr/bin/nvidia-smi
```

# 设置网卡 
# 文件管理器 %USERPROFILE%

```bash
[wsl2]
networkingMode=bridged
vmSwitch=openwrt
ipv6=true
```

# 开机自启 ，创建wsl-startup.vbs文件并写入一下内容，其中CentOS9-stream为实例名称

```bash
win+r shell:startup
set ws=wscript.CreateObject("wscript.shell")
ws.run "wsl -d CentOS9-stream", 0
```

Windows开启WSL命令记录

:::info{title="相关信息"}
本周主要在帮助一个开源项目[ToolBench](https://github.com/OpenBMB/ToolBench)的todo做贡献，需要中文的API数据，国内的开放平台搜寻之后发现聚合数据API最合适，原因是种类多，主要GET类型。本文主要分享一下经验，源码。
:::


聚合数据API官网做了反爬，我刚开始在爬的时候sleep时间为1秒，没过一会就看到了405错误，后来加到5秒，使用了随机UA之后便正常了。我这里开了代理，代理端口是7890，如果没有代理可以去掉这个，不过建议还是开代理，多个代理来回切换着。


`utils.py`

```python
# -*- coding: utf-8 -*-
import json
import keyword
import os
from time import sleep
from fake_useragent import UserAgent
import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin
from juhe.translate import do_zh_to_en

BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


def get_random_ua():
    ua = UserAgent()  # 创建User-Agent对象
    useragent = ua.random
    return useragent


proxies = {
    'http': 'http://127.0.0.1:7890',
    'https': 'http://127.0.0.1:7890',
}


def post_to_api(url: str) -> str:
    headers = {
        'User-Agent': get_random_ua()
    }
    response = requests.request("GET", url, headers=headers, proxies=proxies)
    if response.status_code == 405:
        sleep(3600)
        post_to_api(url)
    return response.text


def get_api_doc_urls() -> list[dict]:
    """
    收集所有api分类地址
    :return:
    """
    page_list = [f"https://www.juhe.cn/docs/{page_index}" for page_index in range(1, 20)]
    api_category_urls = []
    visited_urls = set()
    for page_url in page_list:
        headers = {
            'User-Agent': get_random_ua()
        }
        response = requests.request("GET", page_url, headers=headers, proxies=proxies)
        html = response.text
        soup = BeautifulSoup(html, 'html.parser')
        for a in soup.find_all('a', class_='api-a-block'):
            href = a.get('href')
            if href and href not in visited_urls:
                visited_urls.add(href)
                if not href.startswith('http'):
                    href = 'https://www.juhe.cn' + href
                h2 = a.find('h2', class_='api-name')
                if h2:
                    print(h2.text)
                api_category_urls.append({
                    "api_category": h2.text,
                    "href": href
                })
                print(f"已解析分类地址{href}")

    sleep(5)
    return api_category_urls


def get_api_des_url(urls: list[dict]) -> list[dict]:
    """
    获取id1，id2用来调用api详情接口
    :param urls:
    :return:
    """
    api_callable_url = []
    for url in urls:
        headers = {
            'User-Agent': get_random_ua()
        }
        response = requests.request("GET", url.get("href"), headers=headers, proxies=proxies)
        html = response.text
        soup = BeautifulSoup(html, 'html.parser')
        p_tags = soup.find_all('p', attrs={'data-id1': True, 'data-id2': True})
        result = {
            "api_category": url.get("api_category"),
            "api_href_list": []
        }
        for p_tag in p_tags:
            img_tag = p_tag.find('img')
            if img_tag and 'GET' in img_tag.get('src', ''):
                data_id1 = p_tag.get('data-id1')
                data_id2 = p_tag.get('data-id2')
                if data_id1 and data_id2:
                    url = urljoin('https://www.juhe.cn/docs/api/id/', data_id1) + '/aid/' + data_id2 + '/' + data_id1
                    result.get("api_href_list").append(url)
                    print(f"已解析api调用地址{url}")
                    sleep(5)
        api_callable_url.append(result)
    return api_callable_url


def get_param(url: str) -> dict:
    try:
        # 解析字符串
        json_obj = json.loads(post_to_api(url))
        html_content = json_obj["result"]["html"]

        soup = BeautifulSoup(html_content, 'html.parser')

        api_name = soup.find('div', class_="docs-top-title").text

        # api_url
        api_url = soup.find('b', string="接口地址：").find_next_sibling().text

        # header
        p_tag = soup.find('p', string="请求Header：")
        table = p_tag.find_next('table')
        # 在这个<table>标签中找到所有的<td>标签
        tds = table.find_all('td')
        # 通过索引获取到Content-Type和application/x-www-form-urlencoded
        content_type = tds[1].text
        application = tds[2].text
        header = content_type + ":" + application

        # request_params
        p_tag = soup.find('p', string="请求参数说明：")
        table = p_tag.find_next('table')
        rows = table.find_all('tr')[1:]  # 从1开始
        request_params = []
        for row in rows:
            tds = row.find_all('td')
            if tds[1].text == "key":
                continue
            info = {
                "名称": tds[1].text,
                "必填": tds[2].text,
                "类型": tds[3].text,
                "说明": tds[4].text.replace('\n', ' ').strip(),  # 去掉换行符和空格
            }
            request_params.append(info)
            print(f"已添加api信息{info}")

        result = {
            "api_name": api_name,
            "url": api_url,
            "header": header,
            "params": request_params
        }
        return result
    except Exception as e:
        print(e)
        raise RuntimeError(e)


def format_to_python_func_name(text: str) -> str:
    # 将文本转换为小写并分割为单词
    words = text.lower().split()
    # 使用下划线连接单词
    function_name = "_".join(words)
    # 移除非字母数字和下划线的字符
    function_name = "".join(c for c in function_name if c.isalnum() or c == '_')
    return function_name


def write_api_file(api_info_list: list[dict]):
    tool_dir = os.path.join(BASE_PATH, "juhe_tools")
    for url in api_info_list:
        category_name = url.get("api_category")
        if category_name[0].isdigit():
            category_name = "_" + category_name
        if '/' in category_name:
            category_name.replace('/', "")
        api_url_list = url.get("api_href_list")
        api_file_path = os.path.join(tool_dir, category_name)
        os.makedirs(api_file_path, exist_ok=True)

        api_file_content = """
import requests

"""
        for api_url in api_url_list:
            api_param = get_param(api_url)
            sleep(5)
            url = api_param.get("url")
            header = api_param.get("header")
            api_name = api_param.get("api_name")
            api_name_en = format_to_python_func_name(do_zh_to_en(api_name))
            if api_name_en[0].isdigit():
                api_name_en = "_" + api_name_en
            params_list = api_param.get("params")
            # 生成函数参数
            required_params = ["key"]
            optional_params = []
            for param in params_list:
                param_name = param.get("名称")
                if not param_name:  # 跳过空参数
                    continue
                param_name = param_name.replace("-", "_")
                if keyword.iskeyword(param_name):  # 如果参数名是python关键字，添加"_"
                    param_name += "_"
                is_required = param.get("必填")

                if is_required == "是":
                    required_params.append(f"{param_name}")
                else:
                    optional_params.append(f"{param_name}=None")

            # 生成params
            params_str = f"""
    if key is not None:
        params['key'] = key
            """
            for param in params_list:
                param_name = param.get("名称")
                if not param_name:  # 跳过空参数
                    continue
                param_name_in_func = param_name.replace("-", "_")
                if keyword.iskeyword(param_name_in_func):  # 如果参数名是python关键字，添加"_"
                    param_name_in_func += "_"
                params_str += f"""
    if {param_name_in_func} is not None:
        params['{param_name}'] = {param_name_in_func}
    """

            header_key, header_value = header.split(":")
            headers = {header_key.strip(): header_value.strip()}

            # 生成函数内容
            api_file_content += f"""
def {api_name_en}({', '.join(required_params + optional_params)}) -> str:    
    url = f"{url}"
    params = {{}}
    headers = {
            headers
            }
    {params_str}
    response = requests.get(url, headers=headers, params=params)
    return response.text
    
"""
        api_file_path = os.path.join(api_file_path, "api.py")
        with open(api_file_path, 'w') as api_file:
            api_file.write(api_file_content)

```
`main.py`

```python
from utils import (
    get_api_doc_urls,
    get_api_des_url,
    write_api_file
)


def main():
    # 获取所有分类
    urls = get_api_doc_urls()

    # 获取所有api详情接口地址
    api_urls = get_api_des_url(urls=urls)

    # 写文件
    write_api_file(api_urls)


if __name__ == '__main__':
    main()

```