
视频 

提取音频轨道

音频转文字

文字翻译 and 音色克隆

读文本 导出音频

替换音频轨道

导出

视频翻译

:::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为实例名称
# win+r shell:startup

```bash
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()

```

爬取聚合数据API

:::info{title="相关信息"}
2023年随着大语言模型的兴起，AIGC也受到了越来越多公司和企业的关注，展开了一系列的AIGC业务。在这其中词嵌入（embeddings）作为数据检索的核心也在AIGC产品中占据着主要地位，例如基于文档的问答（OA over document）、大模型的推理（将自然语言转成词向量语义向量）。本文将介绍从传统的数据库检索到向量检索的最小示例。
:::

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

# 基本环境准备
开始之前请先确保您的电脑或服务器已经安装了Docker、python，内存在8G以上。
创建一个项目文件夹，我这里以es_to_vs为例

```bash
cd /data/projects
mkdir es_to_vs
cd es_to_vs
```

## embeddings模型
这里使用的模型为离线模型，OpenAI的sda模型做embedding的效果要好很多，根据自己的需求选择，如果您使用OpenAI的sda模型可以跳过此步骤。

[text2vec-base-chinese](https://huggingface.co/shibing624/text2vec-base-chinese)是huggingface开源针对中文的embeddings模型。

```bash
# 请先确保您已经安装了git-lfs
git lfs install

# 如果报错的话请先安装
# CentOS
yum -y install git-lfs
# Ubuntu
apt-get install git-lfs

# 下载模型到本地
git clone https://huggingface.co/shibing624/text2vec-base-chinese
# 如果无法访问huggngface可以使用我提供的地址http://openwrt.mrbun.cn:5000/sharing/0kgJQUnDC，下载后解压即可
unzip text2vec-base-chinese.zip 
```
## 部署向量数据库Milvus
这里提供一个docker-compose文件，直接执行up -d命令即可,如果端口冲突请更改映射到宿主机的端口，成功部署后访问http://127.0.0.1:8000 用户名密码不写，点击链接即可。如果有安全需求可以在配置文件设置用户名和密码。

docker-compose.yaml
```yaml
version: '3.5'

services:
  etcd:
    container_name: milvus-etcd
    image: quay.io/coreos/etcd:v3.5.5
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
      - ETCD_SNAPSHOT_COUNT=50000
    volumes:
      - ${DOCKER_VOLUME_DIRECTORY:-.}/volumes/etcd:/etcd
    command: etcd -advertise-client-urls=http://127.0.0.1:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd

  minio:
    container_name: milvus-minio
    image: minio/minio:RELEASE.2023-03-20T20-16-18Z
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    volumes:
      - ${DOCKER_VOLUME_DIRECTORY:-.}/volumes/minio:/minio_data
    command: minio server /minio_data
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  standalone:
    container_name: milvus-standalone
    image: milvusdb/milvus:v2.2.11
    command: ["milvus", "run", "standalone"]
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    volumes:
      - ${DOCKER_VOLUME_DIRECTORY:-.}/volumes/milvus:/var/lib/milvus
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - "etcd"
      - "minio"

  attu:
    container_name: milvus-attu
    image: zilliz/attu:v2.2.3
    environment:
      MILVUS_URL: milvus-standalone:19530
    ports:
      - "8000:3000"
    depends_on:
      - "standalone"

networks:
  default:
    name: milvus

```
启动milvus

```bash
docker compose up -d
```
![20b2f36f3ed4ce1dfd35a2ad11218e20.image.webp](/static/img/c93cfaf1aa9df7023a15a31808121187.20b2f36f3ed4ce1dfd35a2ad11218e20.image.webp)
## 创建Python项目
这里使用Flask进行演示

```bash
conda create -n es-to-vs python=3.10
conda activate es-to-vs
pip install flask langchain pymilvus sentence-transformers

# 如果下载较慢或直接超时报错请使用清华源
-i https://pypi.tuna.tsinghua.edu.cn/simple some-package
```
在es_to_vs中创建一个app.py的文件

```bash
touch app.py
```

# 实现流程

```python
import json
import os
import sys

from langchain.embeddings import HuggingFaceEmbeddings
from langchain.schema import Document
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Milvus
from pymilvus import Collection, connections
from flask import Flask, request, jsonify

app = Flask(__name__)
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
VECTOR_FILE_PATH = os.path.join(sys.path[0], 'text2vec-base-chinese')
MILVUS_HOST = '127.0.0.1'
MILVUS_PORT = '19530'
COLLECTION_NAME = 'vector_sample_data'
embeddings = HuggingFaceEmbeddings(model_name=VECTOR_FILE_PATH)


@app.route("/", methods=['POST'])
def storing_data():
    """
    对数据做向量化并存入Milvus向量数据库
    :return:
    """
    try:
        data = json.loads(request.data)
        # 准备数据，这里text是一个列表，列表中的元素为Document对象
        text = [Document(page_content=qa.get('q'), metadata={"id": qa.get('id'), "answer": qa.get('a')}) for qa in
                data['data']]
        # 实例化splitter
        text_splitter = CharacterTextSplitter()
        docs = text_splitter.split_documents(text)
        # 数据embedding并存储到Milvus
        Milvus.from_documents(
            docs,
            embedding=embeddings,
            connection_args={
                "host": MILVUS_HOST,
                "port": MILVUS_PORT},
            collection_name=COLLECTION_NAME
        )

        return jsonify(
            {
                "code": 200,
                "msg": "success",
                "data": {}
            }
        )
    except Exception as e:
        print(f"error:{e}")
        return jsonify(
            {
                "code": 400,
                "msg": f"error:{e}",
                "data": {}
            }
        )


@app.route("/search", methods=['GET'])
def vector_search():
    """
    对问题做embedding之后做向量查询，返回查询结果
    :return:
    """
    try:

        query = request.args.get("query")
        connections.connect(host=MILVUS_HOST, port=MILVUS_PORT)
        vector = embeddings.embed_query(query)
        results_vec = []
        collection = Collection(COLLECTION_NAME)
        collection.load()

        search_param = {
            "data": [vector],
            "anns_field": "vector",
            "param": {"metric_type": "L2", "offset": 0},
            "limit": 10,
            "expr": None,
            "output_fields": ['text', "answer"],
            "consistency_level": "Strong"
        }
        results = collection.search(**search_param)
        for result in results[0]:
            data = {
                "ids": result.id,
                "collection_name": COLLECTION_NAME,
                "text": result.entity.get('text'),
                "answer": result.entity.get('answer'),
                "distance": result.distance,
                "score": distance_to_score(result.distance)
            }
            results_vec.append(data)
        return jsonify(
            {
                "code": 200,
                "msg": f"success",
                "data": results_vec
            }
        )
    except Exception as e:
        print(f"error:{e}")
        return jsonify(
            {
                "code": 400,
                "msg": f"error:{e}",
                "data": {}
            }
        )


def distance_to_score(distance: float) -> float:
    """
    将欧几里得距离转换为分数

    Parameters:
        distance (float or numpy array): 欧几里得距离，可以是单个值或者由多个距离组成的numpy数组

    Returns:
        float or numpy array: 对应的分数，取值范围从0到1
    """
    return 1 / (1 + distance)


if __name__ == '__main__':
    app.run(host="0.0.0.0", port=5000)
```
# 结果展示
数据入库接口调用结果

:::warning{title="注意"}
注意 这里的数据是做测试使用，实际业务数据需要对接口进行改造
:::

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


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

向量查询

![image.png](/static/img/cb8e326fb133a88530063218a88903c2.image.webp)
返回结果


```json
{
    "code": 200,
    "data": [
        {
            "answer": "了解如何查找 iPhone、iPad、iPod、HomePod、Mac 或其他 Apple 产品的序列号。https://support.apple.com/zh-cn/HT204308",
            "collection_name": "vector_sample_data",
            "distance": 228.32852172851562,
            "ids": 444474468395128268,
            "score": 0.004360556604397525,
            "text": "查找 Apple 产品的序列号"
        },
        {
            "answer": "如需获知最新情况，请等待最长 48 小时。需要多长时间才会出现在帐户或对账单上，取决于付款方式。您可能无法再访问已退款的项目。https://support.apple.com/zh-cn/HT210904",
            "collection_name": "vector_sample_data",
            "distance": 359.940185546875,
            "ids": 444474468395128269,
            "score": 0.0027705421564098213,
            "text": "查看从 Apple 购买的 App 或内容的退款状态"
        },
        {
            "answer": "将 Beats Fit Pro 耳塞放入产品托盘中的圆形凹槽内。 盖上白色包装盒的盖子。 将白色包装盒放入装运箱中。 合上装运箱的盖子。 使用提供的胶带封好装运箱*。 从装运箱上揭下顶层标签。这就是你的收据。确保退还发运标签仍贴在装运箱上。 *Apple 对运输过程中的任何损坏概不负责。...https://support.apple.com/zh-cn/HT212831",
            "collection_name": "vector_sample_data",
            "distance": 383.781494140625,
            "ids": 444474468395128270,
            "score": 0.002598877584363589,
            "text": "如何从美国和加拿大将 Beats Fit Pro 耳塞寄送到 Apple 进行维修"
        }
    ],
    "msg": "success"
}
```