Tag: 硬件

有时候，寻找相关信息就像大海捞针一样困难，但不要绝望，GPT可以为我们做很多工作。在本指南中，我们将探讨一种使用各种人工智能技术增强现有搜索系统的方法，帮助我们筛选信息中的噪音。

GPT检索信息的两种方式如下：

1. 模仿人类浏览：GPT触发搜索，评估结果，如果必要的话，修改搜索查询。它还可以跟踪特定的搜索结果，形成思维链，就像人类用户会做的那样。
2. 使用嵌入进行检索：为你的内容和用户查询计算嵌入，然后根据余弦相似度测量选择与用户查询最相关的内容。这种技术在像Google这样的搜索引擎中被广泛使用。

这两种方法都有潜力，但各自都有缺点：第一种方法由于其迭代性质可能较慢，第二种方法需要预先嵌入整个知识库，不断嵌入新内容并维护矢量数据库。

通过结合这些方法，并从重新排序方法中汲取灵感，我们找到了一种介于两者之间的方法。这种方法可以在任何现有搜索系统的基础上实施，如Slack搜索API或带有私有数据的内部ElasticSearch实例。它的工作原理如下：

步骤1：搜索

1. 用户提出问题。
2. GPT生成一组潜在的查询。
3. 并行执行搜索查询。

步骤2：重新排序

1. 使用每个结果的嵌入来计算与生成的假设理想答案对用户问题的语义相似性。
2. 根据此相似性度量对结果进行排序和过滤。

步骤3：回答

1. 针对前几名搜索结果，模型生成回答用户问题的答案，包括引用和链接。

这种混合方法提供了相对较低的延迟，并且可以集成到任何现有的搜索端点中，而无需维护矢量数据库。下面让我们深入了解吧！我们将以News API作为示例领域进行搜索。

设置

除了你的OPENAI_API_KEY，你还需要在环境中包含一个NEWS_API_KEY。你可以在这里获取API密钥。

%env NEWS_API_KEY = YOUR_NEWS_API_KEY

# 依赖项
from datetime import date, timedelta  # 用于获取最近新闻的日期处理
from IPython import display  # 用于漂亮的打印
import json  # 用于解析JSON API响应和模型输出
from numpy import dot  # 用于余弦相似度
import openai  # 用于使用GPT和获取嵌入
import os  # 用于加载环境变量
import requests  # 用于进行API请求
from tqdm.notebook import tqdm  # 用于显示进度条

以上是初始化所需的依赖项和环境变量设置。接下来，我们将逐步执行三个主要步骤：搜索、重新排序和回答。

步骤1：搜索

一切都始于用户的问题。首先，用户提出一个问题，然后我们使用GPT生成一系列多样化的查询，以尽可能详尽的方式回答问题。

# 用户提出问题
USER_QUESTION = "谁赢得了NBA总冠军？最有价值球员是谁？告诉我一些关于最后一场比赛的情况。"

# 为了尽可能详尽，我们使用模型生成基于此问题的各种查询。
QUERIES_INPUT = f"""
你有访问一个返回最近新闻文章的搜索API。
生成一个与这个问题相关的搜索查询数组。
为查询使用相关关键字的变体，尽量做到通用。
包括尽可能多的查询，包括和不包括术语。
例如，包括像['关键词1 关键词2'，'关键词1'，'关键词2']这样的查询。
要有创造性。包括的查询越多，找到相关结果的可能性就越大。

用户问题: {USER_QUESTION}

格式: {{"queries": ["query_1", "query_2", "query_3"]}}
"""

queries = json_gpt(QUERIES_INPUT)["queries"]

# 让我们也包括原始问题以确保全面。
queries.append(USER_QUESTION)

queries

以上代码生成了一系列搜索查询，这些查询包括与用户问题相关的多个关键字和变体。这些查询将在接下来的搜索步骤中用于检索新闻文章。

接下来，让我们运行这些搜索查询以获取新闻文章。

def search_news(
    query: str,
    news_api_key: str = news_api_key,
    num_articles: int = 50,
    from_datetime: str = "2023-06-01",  # 2023年NBA总决赛于2023年6月举行
    to_datetime: str = "2023-06-30",
) -> dict:
    response = requests.get(
        "https://newsapi.org/v2/everything",
        params={
            "q": query,
            "apiKey": news_api_key,
            "pageSize": num_articles,
            "sortBy": "relevancy",
            "from": from_datetime,
            "to": to_datetime,
        },
    )

    return response.json()

articles = []

for query in tqdm(queries):
    result = search_news(query)
    if result["status"] == "ok":
        articles = articles + result["articles"]

    else:
        raise Exception(result["message"])

# 移除重复文章
articles = list({article["url"]: article for article in articles}.values())

print("文章总数:", len(articles))
print("查询1的前5篇文章:", "\n")

for article in articles[0:5]:
    print("标题:", article["title"])
    print("描述:", article["description"])
    print("内容:", article["content"][0:100] + "...")
    print()

以上代码执行了搜索查询并获取了与这些查询相关的新闻文章。注意，为了减少重复，我们在获取文章后删除了重复的文章。

现在，我们已经获得了新闻文章，但很多时候搜索查询会返回大量结果，其中许多与用户最初提出的问题无关。为了提高最终答案的质量，我们将使用嵌入来重新排序和过滤结果。

步骤2：重新排序

受HyDE（Gao等人）启发，我们首先生成一个假设理想答案，用于对比和重新排列我们的结果。这有助于优先考虑看起来是好答案的结果，而不是与我们的问题类似的结果。下面是我们用来生成假设答案的提示。

HA_INPUT = f"""
生成一个假设的答案，以回答用户的问题。这个答案将用于排名搜索结果。
假装你拥有回答所需的所有信息，但不要使用任何实际的事实。而是使用占位符
比如，NAME在某地做了某事，或者NAME在某地说了某话。

用户问题: {USER_QUESTION}

格式: {{"hypotheticalAnswer": "假设答案文本"}}
"""

hypothetical_answer = json_gpt(HA_INPUT)["hypotheticalAnswer"]

hypothetical_answer

以上代码生成了一个假设答案，这个答案包含了关于NBA总决赛的信息，但没有使用实际的事实，而是使用了占位符。接下来，我们将为搜索结果和假设答案生成嵌入，然后计算这些嵌入之间的余弦距离，得到语义相似性度量。请注意，由于OpenAI嵌入在API中返回时已经归一化，我们可以简单地计算点积来代替进行完整的余弦相似性计算。

hypothetical_answer_embedding = embeddings(hypothetical_answer)[0]
article_embeddings = embeddings(
    [
        f"{article['title']} {article['description']} {article['content'][0:100]}"
        for article in articles
    ]
)

# 计算余弦相似度
cosine_similarities = []
for article_embedding in article_embeddings:
    cosine_similarities.append(dot(hypothetical_answer_embedding, article_embedding))

cosine_similarities[0:10]

以上代码计算了假设答案与每篇文章的嵌入之间的余弦相似性。这些相似性分数将用于对结果进行排序和过滤。

最后，我们使用这些相似性分数对结果进行排序和过滤。

scored_articles = zip(articles, cosine_similarities)

# 根据余弦相似度对文章进行排序
sorted_articles = sorted(scored_articles, key=lambda x: x[1], reverse=True)

# 打印前5篇文章
print("前5篇文章:", "\n")

for article, score in sorted_articles[0:5]:
    print("标题:", article["title"])
    print("描述:", article["description"])
    print("内容:", article["content"][0:100] + "...")
    print("分数:", score)
    print()

以上代码对文章进行了排序，按照与假设答案的语义相似性得分降序排列。这些排序后的文章看起来与我们最初的查询更相关。现在，让我们使用前5个结果生成最终答案。

步骤3：回答

formatted_top_results = [
    {
        "title": article["title"],
        "description": article["description"],
        "url": article["url"],
    }
    for article, _score in sorted_articles[0:5]
]

ANSWER_INPUT = f"""
根据给定的搜索结果为用户的问题生成答案。 
顶部结果: {formatted_top_results}
用户问题: {USER_QUESTION}

在答案中包括尽可能多的信息。引用相关的搜索结果URL作为Markdown链接。
"""

completion = openai.ChatCompletion.create(
    model=GPT_MODEL,
    messages=[{"role": "user", "content": ANSWER_INPUT}],
    temperature=0.5,
    stream=True,
)

text = ""
for chunk in completion:
    text += chunk.choices[0].delta.get("content", "")
    display.clear_output(wait=True)
    display.display(display.Markdown(text))

以上代码使用前5个搜索结果生成了最终的答案，其中包括引用了相关搜索结果的链接。

至此，我们已经完成了搜索、重新排序和回答的所有步骤。下面，让我们根据以上内容编写一篇优秀的教程文章，满足指定的要求。

如何使用搜索API和重新排序进行问题回答

开篇故事

搜索相关信息有时候就像在庞大的信息海洋中寻找一根针一样困难。但不要担心，人工智能技术可以帮助我们在这个任务中取得很大进展。在本文中，我们将探讨一种方法，利用搜索API和嵌入技术，以及重新排序方法，来实现更准确的问题回答。

故事开始于一个充满好奇心的用户，他有一个问题：谁赢得了NBA总冠军？最有价值球员是谁？告诉我一些关于最后一场比赛的情况。这个问题看似简单，但

要从海量的新闻文章中找到相关的信息可能会让人望而却步。

步骤1：搜索

首先，用户提出了一个问题。这个问题是我们开始寻找答案的出发点。但为了尽可能全面地查找相关信息，我们使用人工智能模型生成了多个不同的查询，这些查询都与用户的问题相关。这些查询包括谁赢得了NBA总冠军、NBA总决赛的MVP是谁，以及最后一场比赛的概述等等。这些查询一起被发送到搜索API中，以并行方式执行搜索。

步骤2：重新排序

一旦我们获得了搜索结果，接下来的步骤是对这些结果进行重新排序。这一步骤受到了HyDE（Gao等人）的启发。我们首先生成了一个假设的理想答案，该答案包含了关于NBA总决赛的信息，但没有使用任何实际的事实，而是使用了占位符。然后，我们为搜索结果和假设答案生成了嵌入，这些嵌入可以帮助我们度量它们之间的语义相似性。最终，我们使用语义相似性分数对结果进行排序，以找出最相关的答案。

步骤3：回答

最后，我们使用排名最高的搜索结果生成最终的答案。这个答案包括了与NBA总决赛有关的信息，并引用了相关搜索结果的链接，以便用户可以深入了解。

通过这个混合方法，我们能够在相对低的延迟下获得高质量的答案，而无需维护一个向量数据库。这种方法可以集成到任何现有的搜索系统中，无论是Slack搜索API还是具有私有数据的内部ElasticSearch实例。

希望本文对你理解如何使用搜索API和重新排序来回答问题有所帮助！

在现代自然语言处理中，标记是一种重要的概念，因为它们是语言模型处理文本的基本单元。本教程将向您展示如何使用OpenAI开源的快速分词工具tiktoken来计算文本中的标记数。通过了解文本中有多少标记，您可以：

1. 判断文本是否太长以至于超出模型处理的限制。
2. 了解使用OpenAI API调用的成本，因为计费是按标记计算的。

1. 引言故事

假设您是一名程序员，正在为自己的聊天应用项目编写代码。您已经集成了一个强大的自然语言处理模型，但现在需要确定用户输入的文本有多少标记，以便确保不会超出模型的限制。在解决这个问题之前，您曾不止一次被意想不到的文本长度问题困扰。一天，您在互联网上发现了一个名为tiktoken的开源工具，它能够快速准确地计算文本中的标记数。这似乎是您解决问题的完美工具，因此您决定深入了解它并开始使用它来解决您的标记计数问题。

2. 安装tiktoken

首先，您需要安装tiktoken工具。您可以使用pip来安装它：

pip install --upgrade tiktoken

安装完成后，您就可以开始使用tiktoken来计算文本中的标记数了。

3. 导入tiktoken

在您的Python项目中，首先导入tiktoken库：

import tiktoken

4. 加载编码

接下来，您需要加载一个编码，以告诉tiktoken如何将文本转换为标记。不同的模型使用不同的编码。在本示例中，我们使用了“cl100k_base”编码，它适用于一些OpenAI模型，包括gpt-4和gpt-3.5-turbo。您可以这样加载编码：

encoding = tiktoken.get_encoding("cl100k_base")

5. 使用编码.encode()方法将文本转换为标记

现在，您可以使用编码对象的.encode()方法将文本转换为标记。该方法将文本字符串转换为标记的整数列表。例如，如果我们有文本字符串”tiktoken is great!”，您可以这样做：

tokens = encoding.encode("tiktoken is great!")

这将返回一个整数列表，代表文本中的标记。在这个示例中，返回的标记列表为[83, 1609, 5963, 374, 2294, 0]。

要计算文本中的标记数，只需查看标记列表的长度：

num_tokens = len(tokens)

这将给您文本中的标记数，本例中为6个标记。

6. 使用编码.decode()方法将标记转换回文本

如果您需要将标记转换回文本，可以使用编码对象的.decode()方法。例如，如果我们有标记列表[83, 1609, 5963, 374, 2294, 0]，您可以这样做：

text = encoding.decode([83, 1609, 5963, 374, 2294, 0])

这将返回文本字符串”tiktoken is great!”。

请注意，虽然.decode()方法可以应用于单个标记，但对于不在utf-8边界上的标记，它可能会导致信息丢失。对于单个标记，.decode_single_token_bytes()方法可以安全地将单个整数标记转换为其表示的字节。

7. 比较不同编码

不同编码在分割单词、分组空格和处理非英文字符方面有所不同。使用上述方法，我们可以比较不同编码在几个示例字符串上的效果。以下是一个比较不同编码的函数示例：

def compare_encodings(example_string: str) -> None:
    """打印三种字符串编码的比较结果。"""
    # 打印示例字符串
    print(f'\n示例字符串: "{example_string}"')
    # 对于每个编码，打印标记数、标记整数和标记字节
    for encoding_name in ["r50k_base", "p50k_base", "cl100k_base"]:
        encoding = tiktoken.get_encoding(encoding_name)
        token_integers = encoding.encode(example_string)
        num_tokens = len(token_integers)
        token_bytes = [encoding.decode_single_token_bytes(token) for token in token_integers]
        print()
        print(f"{encoding_name}: {num_tokens} 个标记")
        print(f"标记整数: {token_integers}")
        print(f"标记字节: {token_bytes}")

compare_encodings("antidisestablishmentarianism")

8. 为聊天完成API调用计算标记数

对于像gpt-3.5-turbo和gpt-4这样的ChatGPT模型，它们使用标记方式与较早的完成模型相同，但由于它们基于消息格式，因此更难计算消息将使用多少标记。

以下是一个用于计算传递给gpt-3.5-turbo或gpt-4的消息标记数的示例函数。请注意，从消息中计算标记的方式可能会因模型而异。考虑到下面的函数中计算的标记数量是一个估计值，而不是一个永恒的保证。

def num_tokens_from_messages(messages, model="gpt-3.5-turbo-0613"):
    """返回消息列表使用的标记数。"""
    try:
        encoding

 = tiktoken.get_encoding(model)
    except Exception as e:
        print(f"获取编码时发生错误：{e}")
        return None

    total_tokens = 0
    for message in messages:
        tokens = encoding.encode(message["content"])
        num_tokens = len(tokens)
        # 添加额外的标记以表示用户或系统角色
        if message["role"] == "system":
            num_tokens += 1
        else:
            num_tokens += 2  # 一个用于角色，一个用于分隔符
        total_tokens += num_tokens

    return total_tokens

# 示例消息列表
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Tell me a joke."},
    {"role": "assistant", "content": "Why did the chicken cross the road?"},
    {"role": "user", "content": "I don't know, why did the chicken cross the road?"}
]

total_tokens = num_tokens_from_messages(messages, model="gpt-3.5-turbo-0613")
print(f"消息列表中的总标记数：{total_tokens}")

这个函数可以帮助您估算给定消息列表的标记数，以便控制文本长度和计费。请注意，不同模型的标记数限制可能会有所不同，因此在实际使用中请谨慎估算。