GPT3 探索指南（一）

绝不原创的飞龙2024-05-02 22:51

原文：zh.annas-archive.org/md5/e19ec4b9c1d08c12abd2983dace7ff20

译者：飞龙

协议：CC BY-NC-SA 4.0

序言

如果这本书是由人工智能写的呢？你会阅读吗？我希望会，因为其中的部分确实是由人工智能写的。是的，GPT-3 被用来创建这本书的部分内容。我知道这有点元，一本关于 GPT-3 的书被 GPT-3 写的。但创造内容是 GPT-3 的许多伟大用途之一。那又何妨呢？此外，对我来说，内容生成是最引起我的兴趣的用例之一。我想知道是否可以在我正在开发的产品中使用 GPT-3 自动化生成技术学习材料。

你可能也有自己对 GPT-3 感兴趣的特定原因。也许是出于求知欲。或者可能是因为你有一个你认为 GPT-3 可以实现的想法。你可能已经在网上看过 GPT-3 生成内容、编写代码、写诗或其他东西的演示，并且想知道 GPT-3 是否可以用于你的想法。如果是这样，那么这本书就是专门为你写的。

我写这本书的目标是为了提供一个实用的资源，帮助你尽快入门 GPT-3，而无需任何必要的技术背景。话虽如此，在我写这些文字的时候，GPT-3 仍然处于私有测试阶段。因此，每个人都在不断学习。但我确切学到的一件事是，GPT-3 的可能应用是广泛的，而且没有办法知道所有可能性，更不用说把它写进一本书中了。所以，我希望这本书使入门变得容易，但我也希望它只是你探索 探索 GPT-3 旅程的开始。

这本书适合谁

这本书适合任何对自然语言处理或学习 GPT-3 感兴趣的人，无论其是否具有技术背景。想要了解自然语言处理、人工智能和 GPT-3 的开发人员、产品经理、企业家和爱好者都会发现这本书很有用。只需基本的计算机技能就能充分利用这本书。虽然有现代编程语言的经验会有所帮助，但并非必需。提供的代码示例适合初学者，即使你是编写代码的新手也很容易理解。

这本书涵盖了哪些内容

第一章 ，介绍 GPT-3 和 OpenAI API，是对 GPT-3 和 OpenAI API 的高级介绍。

第二章 ，GPT-3 的应用和用例，概述了核心 GPT-3 的用例：文本生成、分类和语义搜索。

第三章 ，使用 OpenAI Playground，是对 OpenAI Playground 和开发者门户的半深入介绍。

第四章 ，使用 Postman 调用 OpenAI API，是介绍如何使用 Postman 调用 OpenAI API 的简介。

第五章 ，在代码中调用 OpenAI API，是介绍如何使用 Node.js/JavaScript 和 Python 调用 OpenAI API 的简介。

第六章 ，内容过滤，解释了如何实现内容过滤。

第七章 ，生成和转换文本，包含了用于生成和转换文本的代码和提示示例。

第八章 ，文本分类和分类，更详细地讨论了文本分类和 OpenAI API 分类端点。

第九章 ，构建基于 GPT-3 的问答应用，讲解了如何构建一个功能齐全的基于 GPT-3 的网络知识库。

第十章 ，使用 OpenAI 应用上线，讲解了 OpenAI 应用审查和批准流程，并讨论了为审查做准备的事项。

要充分利用本书

本书中的所有代码示例都是使用来自replit.com的基于 Web 的集成开发环境 （IDE）编写的。一个免费的 replit.com 账户就足以跟随示例。要使用 replit.com，只需一个现代的 web 浏览器和一个 replit.com 账户即可。该代码还在 macOS 上使用 Visual Studio Code 进行了测试，尽管它应该可以在任何代码编辑器和适当配置的操作系统上正常工作。代码示例提供了 Node.js/JavaScript 和 Python 两种版本。对于 Node.js，使用的是版本 12.16.1，对于 Python，使用的是版本 3.8.2。

本书中的所有代码示例都需要 OpenAI API 密钥和对 OpenAI API 的访问权限。您可以通过访问 https://openai.com/api 来申请对 OpenAI API 的访问权限。

如果您使用本书的数字版，我们建议您自己打字输入代码或通过 GitHub 存储库（链接在下一部分中可用）访问代码。这样做可以帮助您避免与复制和粘贴代码相关的潜在错误。

下载彩色图片

我们还提供了一个 PDF 文件，其中包含了本书中使用的屏幕截图/图表的彩色图片。您可以在这里下载：https://static.packt-cdn.com/downloads/9781800563193_ColorImages.pdf。

使用的约定

本书中使用了许多文本约定。

文本中的代码：表示文本中的代码词，数据库表名，文件夹名，文件名，文件扩展名，路径名，虚拟 URL，用户输入和 Twitter 句柄。这里有一个例子："然而，假设您不希望完成生成对话的人的一面，您希望使用标签AI：而不是Assistant：？"

代码块如下所示：

py 复制代码 
English: I do not speak Spanish Spanish:

粗体 ：表示一个新术语，一个重要词，或屏幕上看到的词。例如，菜单或对话框中的单词在文本中出现如下所示。这里有一个例子："每次单击 提交 按钮时"。

提示或重要说明

看起来像这样。

联系方式

我们始终欢迎读者的反馈。

customercare@packtpub.com。

勘误: 尽管我们已尽一切努力确保内容的准确性，但错误确实会发生。如果您在本书中发现了错误，我们将不胜感激您向我们报告。请访问 www.packtpub.com/support/errata，选择您的书，点击勘误提交表单链接，并输入详细信息。

copyright@packt.com，并附上材料的链接。

如果您有兴趣成为作者：如果您在某个主题上有专业知识，并且对编写或贡献一本书感兴趣，请访问 authors.packtpub.com。

评论

请留下您的评论。一旦您阅读并使用了这本书，为什么不在您购买它的网站上留下一条评论呢？潜在的读者可以看到并使用您的公正意见来做出购买决定，我们在 Packt 可以了解您对我们产品的看法，而我们的作者可以看到您对他们的书的反馈。谢谢！

欲了解更多关于 Packt 的信息，请访问 packt.com。

第一部分：理解 GPT-3 和 OpenAI API

本部分的目标是向您提供关于 GPT-3 和 OpenAI API 的高层介绍，以及展示开始使用起来是多么容易。目标是通过有趣的例子吸引您，这些例子快速而简单地实现。

本部分包括以下章节：

  • 第一章 ，介绍 GPT-3 和 OpenAI API

  • 第二章 ，GPT-3 应用与使用案例

第一章：介绍 GPT-3 和 OpenAI API

关于生成式预训练变换器第 3 版 （GPT-3 ）的讨论始于 2020 年 6 月 11 日，由领先的人工智能 （AI）研究实验室 OpenAI 发布的一篇博客文章。该帖子以以下方式开始：

我们正在发布一个用于访问 OpenAI 开发的新 AI 模型的 API。与大多数专为一个用例设计的 AI 系统不同，该 API 今天提供了一个通用的"文本输入，文本输出"接口，允许用户在几乎任何英语语言任务上尝试它。

早期测试人员的在线演示很快就出现了------有些看起来太好以至于难以置信。GPT-3 正在撰写文章，写诗，回答问题，以栩栩如生的方式进行聊天，将文本从一种语言翻译为另一种语言，总结复杂的文件，甚至编写代码。这些演示令人印象深刻------这是我们以前从未见过的一般用途人工智能系统所做的事情------但同样令人印象深刻的是，许多演示是由在人工智能和机器学习 （ML）方面具有有限或没有正式背景的人创造的。GPT-3 提高了标准，不仅在技术方面，还在人工智能可访问性方面。

GPT-3 是一个通用的语言处理 AI 模型，几乎任何人都可以在几分钟内理解并开始使用。您不需要计算机科学的哲学博士 （PhD）------甚至不需要知道如何编写代码。实际上，您开始所需的一切都在这本书中。在本章中，我们将从以下主题开始：

  • GPT-3 简介

  • 使 NLP 大众化

  • 理解提示、完成和标记

  • 介绍达芬奇、巴贝奇、居里和艾达

  • 理解 GPT-3 的风险

技术要求

本章需要您访问OpenAI 应用程序编程接口 （API ）。您可以通过访问openapi.com注册 API 访问权限。

GPT-3 简介

简言之，GPT-3 是一个语言模型：一个计算一系列单词的概率分布的统计模型。换句话说，GPT-3 是一个系统，当输入文本时，猜测接下来的文本是什么。

现在，在我们更深入地了解 GPT-3 是什么之前，让我们对自然语言处理 （NLP）进行简要介绍（或复习）。

简化自然语言处理（NLP）

NLP 是人工智能的一个分支，它专注于利用自然人类语言进行各种计算应用。NLP 是一个广泛的类别，涵盖了许多不同类型的语言处理任务，包括情感分析、语音识别、机器翻译、文本生成和文本摘要等。

在自然语言处理中，语言模型用于计算一系列单词的概率分布。语言模型的重要性在于人类语言的复杂和微妙的特性。例如，pay in full 和 painful 或 tee time 和 teatime 听起来相似，但意思完全不同。she's on fire 这样的表达可能是字面的，也可能是比喻的；而 big 和 large 这样的词在某些情况下可以互换使用，但在其他情况下不能------例如，用 big 来指代一个年长的兄弟就不会有使用 large 的含义。因此，语言模型用于处理这种复杂性，但这说起来容易做起来难。

尽管人们对词义和适当的使用似乎很容易理解，但自然语言处理任务对机器来说可能是具有挑战性的。这对于更复杂的语言处理任务尤为真实，例如识别讽刺或挖苦------甚至有时连人类本身都会感到困难。

如今，对于特定的自然语言处理任务来说，最好的技术方法取决于任务本身。因此，大多数表现最佳的 最先进 （SOTA ）自然语言处理系统都是针对单一目的或狭窄范围任务进行了细化调整的专门系统。然而，理想情况下，一个单一系统应该能够成功地处理任何自然语言处理任务。这就是 GPT-3 的目标：提供一个通用的自然语言处理系统。因此，尽管今天表现最佳的自然语言处理系统往往是专门的、针对特定任务定制的系统，GPT-3 在多个常见自然语言处理任务中达到了 SOTA 表现，展现了未来通用自然语言处理系统能够为任何自然语言处理任务提供 SOTA 表现的潜力。

GPT-3 到底是什么？

尽管 GPT-3 是一种通用的自然语言处理系统，但它实际上只做了一件事：基于提供的文本预测接下来会出现什么。但事实证明，通过合适的架构和足够的数据，这"一件事"能够处理惊人的一系列语言处理任务。

GPT-3 是来自 OpenAI 的 GPT 语言模型的第三个版本。因此，尽管它在 2020 年夏天开始变得流行，但 GPT 的第一个版本是在 2 年前宣布的，接下来的版本 GPT-2 是在 2019 年 2 月宣布的。但即使 GPT-3 是第三个版本，系统的设计和架构与 GPT-2 没有太大的变化。然而，有一个很大的区别，那就是用于训练的数据集的大小。

GPT-3 是使用从互联网、书籍和其他来源获取的文本组成的海量数据集进行训练的，包含大约 570 亿个单词和 1750 亿个参数。这比 GPT-2 和其他最大规模的语言模型大 10 倍。为了让模型的大小有所了解，一个普通人一生中可能会读、写、说和听到超过 10 亿个单词。因此，GPT-3 在估计处理的单词数量上约是大多数人的 57 倍。

GPT-3 语言模型庞大而庞大，因此它不是你可以在笔记本电脑上下载和摸索的东西。但即使你可以（事实上你不可以因为它无法下载），每次构建模型都需要数百万美元的计算资源。如果你必须依靠自己的计算资源来使用它，这将使 GPT-3 对大多数小公司和几乎所有个人都不可及。幸运的是，你不必这样做。OpenAI 通过一个既经济又易于使用的 API 提供 GPT-3，所以，任何人都可以使用一些有史以来最先进的人工智能！

使自然语言处理民主化

任何人都可以通过访问 OpenAI API 使用 GPT-3。API 是一个通用的文本输入，文本输出接口，几乎可以用于任何语言任务。要使用 API，你只需输入文本，然后得到一个文本回复。任务可能是情感分析、写一篇文章、回答一个问题或总结一篇文档。对于 API 来说，这并不重要 ------ 它都是以相同的方式完成的，这使得即使对非程序员来说，使用 API 也变得非常容易。

你传入的文本被称为提示 ，返回的文本称为完成 。提示被 GPT-3 用于确定如何最好地完成任务。在最简单的情况下，提示可以提供一些词语作为开始。例如，如果提示是 如果今天是星期一，明天是 ，GPT-3 可能会回复 星期二 ，以及一些额外的文本，例如 如果今天是星期二，明天是星期三，依此类推。这意味着你从 GPT-3 中得到的取决于你发送给它的内容。

你可能会猜到，完成的质量在很大程度上取决于提示。GPT-3 使用提示中的所有文本来帮助生成最相关的完成。每个词语以及提示的结构方式都有助于改善语言模型的预测结果。因此，理解如何编写和测试提示是解锁 GPT-3 真正潜力的关键。

理解提示、完成和标记

实际上，任何文本都可以用作提示 ------ 输入一些文本，得到一些文本返回。然而，尽管看到 GPT-3 如何处理随机字符串可能很有趣，但真正的力量来自于理解如何编写有效的提示。

提示

提示是让 GPT-3 做你想要的事情的方式。这就像编程，但用的是简单的英语。所以，你必须知道自己想要实现什么，但不是编写代码，而是使用单词和纯文本。

当你编写提示时，要记住的主要事情是，GPT-3 正试图弄清楚接下来应该出现的文本，因此包括诸如说明和示例等内容提供了上下文，帮助模型找出最佳完成的方式。此外，质量很重要 ------ 例如，拼写、不清晰的文本以及提供的示例数量都会影响完成的质量。

另一个关键考虑因素是提示大小。虽然提示可以是任何文本，但提示和生成的完成必须少于 2048 个令牌。我们将稍后在本章中讨论令牌，但大致相当于 1500 个单词。

因此，提示文本可以是任何文本，没有像编写代码时必须遵循的硬性规则。但是，有一些指导原则可以帮助您在获得最佳结果方面构建提示文本的结构。

不同类型的提示

我们将在本书中深入探讨提示写作，但让我们从不同的提示类型开始。以下是概述：

  • 零次提示

  • 单次提示

  • 少数提示

零次提示

一个Subject::

py 复制代码 
Write an email to my friend Jay from me Steve thanking him for covering my shift this past Friday. Tell him to let me know if I can ever return the favor.
Subject:

以下屏幕截图来自一个名为Playground 的基于 Web 的测试工具。我们将在 Chapter 2 , GPT-3 Applications and Use Cases, 和 Chapter 3 , Working with the OpenAI Playground 中更多地讨论 Playground，但现在我们将其用作显示由于前面的提示而生成的完成的演示。请注意，原始提示文本为粗体，完成显示为普通文本：

![Figure 1.1 -- Zero-shot prompt example

]（img / B16854_01_001.jpg）

图 1.1-零次提示示例

因此，零次提示只是一些词或短描述，没有任何示例的任务。有时候，这就是 GPT-3 完成任务所需要的全部。其他时候，您可能需要包括一个或多个示例。提供单个示例的提示称为单次提示。

单次提示

单次提示提供一个示例，GPT-3 可以利用它来学习如何最好地完成任务。以下是一个提供任务描述（第一行）和单个示例（第二行）的单次提示的示例：

py 复制代码 
A list of actors in the movie Star Wars 
1\. Mark Hamill: Luke Skywalker

仅凭描述和一个示例，GPT-3 就会了解任务是什么以及应该完成任务。在此示例中，任务是创建《星球大战》电影演员的列表。以下屏幕截图显示了此提示生成的完成：

![Figure 1.2 -- One-shot prompt example

]（img / B16854_01_002.jpg）

图 1.2-单次提示示例

单次提示适用于列表和通常理解的模式。但有时您需要多个例子。在这种情况下，您将使用几次提示。

少数提示

几次提示提供多个例子-通常为 10 到 100 个。多个示例可用于显示 GPT-3 应该继续完成的模式。少数提示和更多示例可能会增加完成的质量，因为提示为 GPT-3 提供了更多的学习机会。

以下是生成模拟对话的几次提示的示例。请注意，这些示例提供了来回对话，提供了可能在对话中说的内容：

py 复制代码 
This is a conversation between Steve, the author of the book Exploring GPT-3 and someone who is reading the book.
Reader: Why did you decide to write the book?
Steve: Because I'm super fascinated by GPT-3 and emerging technology in general.
Reader: What will I learn from this book?
Steve: The book provides an introduction to GPT-3 from OpenAI. You'll learn what GPT-3 is and how to get started using it.
Reader: Do I need to be a coder to follow along?
Steve: No. Even if you've never written a line of code before, you'll be able to follow along just fine.
Reader:

在下面的截图中，您可以看到 GPT-3 继续了在提示中提供的示例中启动的模拟对话：

图 1.3 -- 少量示例提示

现在您了解了不同的提示类型，让我们来看一些提示示例。

提示示例

OpenAI API 可以处理各种任务。可能性范围从生成原始故事到执行复杂的文本分析，以及其中的所有内容。为了熟悉 GPT-3 可以执行的任务类型，OpenAI 提供了许多提示示例。您可以在 Playground 和 OpenAI 文档中找到示例提示。

在 Playground 中，这些示例被称为预设 。再次强调，我们将在第三章 ，与 OpenAI Playground 一起工作中详细介绍 Playground，但下面的截图显示了一些可用的预设：

图 1.4 -- 预设

示例提示也可以在 OpenAI 文档中找到。OpenAI 文档非常出色，包含许多优秀的提示示例，并提供了链接以在 Playground 中打开和测试它们。下面的截图显示了来自 OpenAI 文档的示例提示。请注意提示示例下方的在 Playground 中打开此示例链接。您可以使用该链接在 Playground 中打开提示：

图 1.5 -- OpenAI 文档提供提示示例

现在您了解了提示，让我们谈谈 GPT-3 如何使用它们来生成完成。

完成

再次强调，完成指的是生成并返回的文本，作为提供的提示/输入的结果。您还会记得，GPT-3 并没有专门训练来执行任何一种类型的自然语言处理任务------它是一个通用的语言处理系统。然而，GPT-3 可以通过提示来展示如何完成给定任务。这称为元学习。

元学习

大多数自然语言处理系统，在训练基础的机器学习模型时，使用的数据是提供的。所以，要改进给定任务的结果，必须更新底层训练，并构建新版本的模型。GPT-3 的工作方式不同，因为它没有针对任何特定任务进行训练。相反，它被设计为识别提示文本中的模式，并使用底层的通用模型继续模式。这种方法被称为元学习 ，因为提示被用来教导 GPT-3 如何生成最佳完成，而无需重新训练。因此，不同的提示类型（零次、一次和少次）可以用于为不同类型的任务编程 GPT-3，你可以在提示中提供大量指令------最多 2,048 个令牌。好的------现在是谈论令牌的好时机。

令牌

当提示被发送到 GPT-3 时，它会被分解为令牌。令牌是单词或更常见的单词部分的数值表示。数字被用作令牌而不是单词或句子，因为它们可以更有效地处理。这使得 GPT-3 能够处理相对较大的文本量。尽管如此，正如你所学到的，仍然存在 2,048 个令牌的限制（约~1,500 个单词），用于组合提示和生成的完成结果。

你可以通过估算提示和生成的完成结果中将使用的令牌数量来保持在令牌限制以下。平均而言，对于英文单词，每四个字符代表一个令牌。所以，只需将提示中的字符数加上响应长度，然后除以四即可。这将给你一个大致的所需令牌数量。如果你想要了解完成一系列任务所需的令牌数量，这非常有帮助。

另一种获取令牌计数的方法是使用 Playground 中的令牌计数指示器。这位于大型文本输入框的正下方，位于右下角。以下屏幕截图中放大的区域显示了令牌计数。如果你将鼠标悬停在数字上，你还将看到完成后的总计数。对于我们的示例，提示Do or do not. There is no try. ---来自尤达大师的智慧---使用了10 个令牌，完成后的总计数为74个令牌：

图 1.6 -- 令牌计数

虽然理解令牌对于保持在 2,048 个令牌限制以下很重要，但它们也很重要，因为令牌是 OpenAI 用作使用费基础的东西。你的账户中可以获得整体令牌使用情况报告，网址为beta.openai.com/account/usage。下面的屏幕截图显示了一个示例使用报告。我们将在第三章 ，使用 OpenAI Playground中进一步讨论这个：

图 1.7 -- 使用统计

除了令牌使用外，影响使用 GPT-3 的成本的另一件事是你选择用来处理提示的引擎。引擎是指将要使用的语言模型。引擎之间的主要区别在于相关模型的大小。较大的模型可以完成更复杂的任务，但较小的模型更高效。因此，根据任务的复杂性，你可以通过使用较小的模型显着降低成本。以下屏幕截图显示了发布时的模型定价。正如你所见，成本差异可能很大：

图 1.8 -- 模型定价

因此，每个引擎或模型的成本都不同，但你需要的那个取决于你正在执行的任务。接下来我们来看看不同的引擎选项。

介绍达芬奇、巴贝奇、居里和艾达

用于训练 GPT-3 的庞大数据集是其如此强大的主要原因。然而，当有必要时，更大并不总是更好------更多的能力会带来成本。出于这些原因，OpenAI 提供了多个可供选择的模型。今天有四个主要模型可用，以及一个用于内容过滤和指令模型的模型。

可用的模型或引擎（也称为）分别命名为达芬奇、巴贝奇、居里和艾达。在这四个中，达芬奇是最大且最强大的。 达芬奇可以执行任何其他引擎可以执行的任务。 巴贝奇是下一个最强大的引擎，可以做任何居里或艾达可以做的事情。 艾达是最不强大但性能最佳且成本最低的引擎。

当你刚开始并且在初步测试新提示时，通常会想从达芬奇开始，然后尝试艾达、巴贝奇或居里，看看它们中的哪一个可以更快或更具成本效益地完成任务。以下是每个引擎的概述以及可能最适合每个引擎的任务类型。但是，请记住，你需要测试。尽管较小的引擎可能没有受过太多数据的训练，但它们仍然是通用模型。

达芬奇

达芬奇是最强大的模型，可以做任何其他模型能做的事情，而且更多------通常只需更少的指令。 达芬奇能够解决逻辑问题，确定因果关系，理解文本意图，生成创意内容，解释人物动机，并处理复杂的总结任务。

居里

居里试图平衡力量和速度。它可以做任何艾达或巴贝奇可以做的事情，但它还能处理更复杂的分类任务和更细致的任务，如总结、情感分析、聊天机器人应用和问答。

巴贝奇

Babbage比Ada更有能力，但并不那么高效。它可以执行与Ada相同的所有任务，但还可以处理更复杂的分类任务，并且非常适合语义搜索任务，以确定文档与搜索查询匹配程度。

Ada

Ada通常是最快的模型，成本最低。它最适合于较少细微差别的任务，例如解析文本、重新格式化文本和更简单的分类任务。您提供给Ada的上下文越多，它的表现就越好。

内容过滤模型

为了防止不当补全，OpenAI 提供了一个内容过滤模型，该模型经过微调，以识别可能含有冒犯性或伤人的言语。

指导模型

这些模型是在Davinci和Curie模型的基础上构建的。指导模型被调整过，以使得更容易告诉 API 想让它做什么。清晰的指示通常比相关的核心模型产生更好的结果。

时间的一瞥

关于所有引擎的最后一点要牢记的是，它们都是一个时间的一瞥，也就是说用于训练它们的数据截止于构建模型的日期。因此，GPT-3 并非使用最新的甚至最新的数据------它可能是几周甚至几个月之前的数据。OpenAI 打算在未来增加更多的持续训练，但今天这是一个需要考虑的因素。

所有的 GPT-3 模型都非常强大，能够生成与人类编写的文本几乎无法区分的文本。这对各种潜在应用都具有巨大的潜力。在大多数情况下，这是一件好事。但是，并非所有潜在的用例都是好事。

了解 GPT-3 风险

GPT-3 是一项了不起的技术，具有许多实际和有价值的潜在应用。但通常情况下，强大技术的潜力就意味着风险。对 GPT-3 而言，其中一些风险包括不当的结果和潜在的恶意用途。

不当或冒犯性的结果

GPT-3 文本生成得如此出色，以至于看起来像是它意识到自己在说什么。但其实不是这样的。它是一个具有出色语言模型的 AI 系统－绝对不会有意识，所以从来不会在说出伤人或不当的话语。

但是，理解 GPT-3 有时会生成冒犯性文本，并考虑在使用 GPT 或向他人公开 GPT-3 结果时需要理解这一点。特别是对于可能被儿童看到的结果。我们将在第六章 中更详细地讨论这一点，内容过滤。

恶意使用的潜力

想象一下，GPT-3 可能被用于恶意或有害用途并不难。OpenAI 甚至描述了 GPT-3 可能被"武器化"用于误导性宣传或制造虚假产品评论。但 OpenAI 的宣称使命是"确保人工通用智能造福于人类"，因此，追求该使命包括采取负责任的措施，防止他们的 AI 被用于错误的目的。因此，OpenAI 为所有使用 GPT-3 或 OpenAI API 的应用程序实施了一个应用批准流程。

但作为应用程序开发人员，我们也需要考虑这一点。当我们构建使用 GPT-3 的应用程序时，我们需要考虑应用程序可能被用于错误的目的，并采取必要的措施来防止它。我们将在第十章 中更详细地讨论这个问题，OpenAI 动力应用的实时运行。

摘要

在本章中，您了解到 GPT-3 是一个用于处理几乎任何语言处理任务的通用语言模型。您了解了 GPT-3 的高级工作原理，以及关键术语和概念。我们介绍了可用的模型，并讨论了所有 GPT-3 应用程序必须经过批准流程才能防止潜在的不适当或有害结果。

在接下来的章节中，我们将讨论使用 GPT-3 不同的方式，并查看特定的 GPT-3 用例示例。

第二章：GPT-3 的应用和用例

GPT-3 被设计为通用语言处理模型，这意味着它并未专门针对任何一种语言处理任务进行训练。因此，可能的应用包括几乎任何您能想象到的自然语言处理任务，以及可能还有一些尚未被想象到的任务。新的 GPT-3 用例不断被发现，这对很多用户来说是其魅力的一大部分。当然，它在某些任务上表现更好，但仍然有数百种可能的用途。在本章中，我们将分解一些通用用例，并看看如何开始测试自己的提示。

本章的主题如下：

  • 理解通用 GPT-3 用例

  • 介绍游乐场

  • 处理文本生成和分类任务

  • 理解语义搜索

技术要求

本章需要您访问 OpenAI API。您可以通过访问openapi.com注册 API 访问权限。

理解通用 GPT-3 用例

在上一章中，您了解到 OpenAI API 是一个文本输入，文本输出 接口。因此，它总是对文本输入（称为提示 ）返回一个文本响应（称为完成）。完成可能是生成新文本，分类文本，或为语义搜索提供结果。GPT-3 的通用性意味着它可以用于几乎任何语言处理任务。为了让我们集中精力，我们将看一下以下常见用例：文本生成，分类和语义搜索。

  • 文本生成：文本生成任务是创建新的原创文本内容的任务。例如包括文章写作和聊天机器人。

  • 分类：分类任务标记或分类文本。分类任务的例子包括情感分析和内容过滤。

  • 语义搜索：语义搜索任务将查询与语义相关的文档进行匹配。例如，查询可能是一个问题，会匹配一个或多个提供答案的文档。

为了说明不同的用例，我们将使用 OpenAI Playground。因此，在我们深入研究不同的示例用例之前，让我们先熟悉一下游乐场。

介绍游乐场

要开始使用 GPT-3，OpenAI 提供了游乐场。游乐场是一个基于 Web 的工具，它可以方便地测试提示，并熟悉 API 的工作原理。几乎你可以通过调用 API 来做的每件事情（我们稍后将更详细地讨论），你也可以在游乐场中完成。最重要的是，通过游乐场，你可以开始使用 GPT-3 而不需要编写一行代码-你只需提供一个用简单英语编写的文本输入（提示）。

开始使用游乐场

要访问游乐场，您需要登录openai.com。在验证登录后，您将能够从主菜单中导航到游乐场。

游乐场非常简单易用。主要由一个大文本输入组成。您只需将文本输入到大文本输入框中，然后单击提交按钮即可开始测试 GPT-3。

单击提交按钮后，您将看到原始输入文本之后添加了额外的文本 -- 这是由 GPT-3 生成的完成文本。

每次单击提交按钮后，GPT-3 将在文本输入框中附加一个附加的完成。附加的完成使用您的原始文本以及先前的完成作为下一个完成的提示。

以下屏幕截图显示了具有初始提示文本的游乐场：如果今天是星期一，明天就是 。您会注意到原始提示文本以粗体显示，而完成文本则以普通文本显示。在此示例中，单击提交按钮多次以说明每个完成是如何在上一个完成的基础上构建的：

图 2.1 -- 游乐场窗口

除了用于提示和完成文本的大文本输入外，游乐场还允许您指定各种 API 设置，这些设置可以在 GPT-3 处理提示时提供一些控制。我们稍后将更详细地讨论这些设置，但是如果您查看图 2.1 中的屏幕截图，您将看到一个响应长度 设置。这是将返回的响应的长度。因此，每次单击提交按钮时，将向文本框添加一个新的具有该长度的响应。

再次，我们稍后将更详细地介绍所有设置。目前，这是每个设置所做的快速介绍：

  • 引擎：将要使用的语言模型

  • 响应长度：包含在完成中的文本量

  • 温度：控制结果的随机性

  • Top P ：用于控制随机性的温度的替代品

  • 频率惩罚：减少模型重复同一行的可能性

  • 存在惩罚：增加模型谈论新主题的可能性

  • 最佳选择 ：仅返回n 个完成中的最佳一个

  • 停止序列：用于结束完成的一系列字符

  • 注入起始文本：将包含在提示之前的文本

  • 注入重新启动文本：将包含在完成后的文本

  • 显示概率：显示完成中每个单词/标记的权重

熟悉游乐场就是开始使用 GPT-3 所需的一切。从那里，您可以开始尝试如何使用提示来编程GPT-3 来处理不同类型的语言处理任务，例如文本生成和分类任务。

现在我们已经看到了如何开始使用游乐场，让我们再学习一些关于文本生成和分类任务的知识。

处理文本生成和分类任务

文本生成和文本分类是自然语言处理任务的两个常见类别。每个类别都涵盖了许多 GPT-3 处理得非常出色的潜在用例。让我们看看其中一些，从文本生成用例开始。

文本生成

关于 GPT-3 可以做的所有事情中，文本生成是它的超能力。文本生成有很多潜在的用例，所以我们将进一步将文本生成分为三个子主题：生成文本、总结文本和转换文本。

生成文本

GPT-3 能够生成通常与人工书写的文本难以区分的原始文本内容。这可以用于各种应用，从创造网页内容到头脑风暴、对话应用、诗歌、歌词创作、写作编码和创建数据列表。让我们看一些例子。

内容创建

内容创建是 GPT-3 所能做的最酷的事情之一。有了正确的提示，GPT-3 可以创建文章、博客文章或社交媒体内容。下面的截图显示了一个提示的结果，引导 GPT-3 创建首次购房者的建议清单。然而，这种通用方法可以用于创建几乎任何主题的内容：

图 2.2 -- 文本生成示例 -- 首次购房者的建议

再次，你可以使用 GPT-3 来创建几乎任何主题的列表，因此有很多可能性。另一个很好的示例用例是创意生成。

创意生成

GPT-3 还可以是头脑风暴的一个好工具。以下提示和随后的截图显示了 GPT-3 被用于生成 3D 打印项目创意的制造者日活动。当然，这也可以是几乎任何事情的想法清单：

py 复制代码 
Maker day 3D printer project ideas 
1\. GoPro Mount A mount for a GoPro camera that mounts the camera on a mountain bike 
2.

结果显示在以下截图中：

图 2.3 -- 文本生成示例 -- 3D 打印项目创意

图 2.3中的粗体文本是提供的提示，常规文本是由 GPT-3 生成的。很酷，对吧？这里还有另一个很酷的例子------对话应用。

对话应用

对话应用也是 GPT-3 的一个潜在用例，例如在聊天机器人、IVR 和语音助手中。下面的文本可以用来提示 GPT-3 模拟 AI 支持助手与客户之间的对话：

py 复制代码 
The following is a conversation with a customer support AI assistant. The assistant is helpful, creative, clever, and very friendly. 
Customer: Hello, can you help me?
AI: I can sure try. I'm an AI support assistant and I'm here to help!
Customer:

前面提示的结果显示在以下截图中。在这种情况下，GPT-3 生成了对话的两端，但在现实世界的应用中，对话的用户端会来自实际的客户：

图 2.4 -- 文本生成示例 -- 客服 AI 助手

您可以使用多种技术来帮助引导 GPT-3 如何作出回应。例如，在图 2.4 中，您会注意到提示包括 The assistant is helpful creative, clever, and very friendly - 这指导了 GPT-3 关于回应的整体风格和语调。我们将在接下来的章节中更详细地讨论这一点，但现在，让我们继续并看看如何使用 GPT-3 生成列表。

列表生成

以下截图显示了 GPT-3 正在用于创建一份公司及其所属类别的列表。您可以从提示中看到，它正在继续之前开始的模式。所以，您可以用这种方式生成几乎任何列表：

py 复制代码 
The following is a list of companies and the categories they fall into
Cisco -- Technology, Networking, Enterprise Software
AT&T -- Telecom, Technology, Conglomerate
United Airlines -- Aviation, Transportation
Nvidia -- Technology, Computing, Semiconductors

上一个提示的结果如下截图所示：

图 2.5 -- 文本生成示例 -- 列表生成

在图 2.5中，您会注意到不仅添加了更多公司到列表中，GPT-3 也能够准确地按行业对公司进行分类。记住，GPT-3 并不是从数据库中提取这些信息 - 而是生成它！但令人印象深刻的是，GPT-3 还能完成更复杂的生成任务。例如，在下一个示例中，我们将看看如何使用 GPT-3 生成一份测验。

测验生成

GPT-3 也能够生成测验。例如，下面的提示可以用于编制测试问题和可能的答案，以测试学生识别押韵单词的能力：

py 复制代码 
words that rhyme have similar sounding endings 
q: what rhymes with "cat" 
a: bat, hat, mat 
q: what rhymes with "small" 
a: tall, wall, call 
q: what rhymes with "pig" 
a: big, dig, fig 
q:

以下截图显示了 GT-3 从先前提示生成的完成状态：

图 2.6 -- 文本生成示例 -- 测验生成

内容创建，创意生成，对话应用程序，创建列表和生成测验只是可能文本生成用例中的一小部分。但文本生成不仅仅是关于创建新内容；还可以用于其他用例，如总结现有内容。

总结文本

除了创作新的原始文本，您还可以使用 GPT-3 创建文档摘要。有多种方法可以用于总结文本。您可以使用基本摘要、一句话总结、年级调整的摘要，或者通过从文档中提取关键点进行总结。让我们快速看一下每种方法。

基本摘要

创建摘要的最简单方法就是在想要总结的文本后加上tl;dr:。这将提示 GPT-3 总结前面的文本。在每种情况下这并不是一种可靠的总结方法，但对许多情况来说都很有效。例如，下面的提示提供了有关量子力学的文本，该文本是从 en.wikipedia.org/wiki/Quantum_mechanics 复制的：

py 复制代码 
Quantum mechanics is a fundamental theory in physics that provides a description of the physical properties of nature at the scale of atoms and subatomic particles.[2]:1.1 It is the foundation of all quantum physics including quantum chemistry, quantum field theory, quantum technology, and quantum information science. 
Classical physics, the description of physics that existed before the theory of relativity and quantum mechanics, describes many aspects of nature at an ordinary (macroscopic) scale, while quantum mechanics explains the aspects of nature at small (atomic and subatomic) scales, for which classical mechanics is insufficient. Most theories in classical physics can be derived from quantum mechanics as an approximation valid at large (macroscopic) scale.[3] 
tl;dr:

上一个提示的结果如图 2.7所示：

图 2.7 -- 文本生成示例 -- tl;dr：摘要

您会注意到原始文本由三段组成，但生成的摘要只有几句话。您还可以指示 GPT-3 将文本总结为一句话。

单句摘要

另一种总结文本的方法是在您想总结的文本后面添加 单句摘要： 。这个与将 停止序列 设置为句号一起，将生成提供文本的单句摘要。

以下提示将创建一个单句摘要，摘自位于 beta.openai.com/terms-of-use 的 OpenAI 使用条款页面的段落：

py 复制代码 
(b) Ownership. As between you and OpenAI, we and our affiliates own all rights, title, and interest in and to the APIs, Content, and Developer Documentation and all associated elements, components, and executables. Subject to the foregoing, you own all rights, title, and interest in and to your Application. You have no right to distribute or allow access to the stand-alone APIs. Except as expressly provided in these Terms, neither party grants, nor shall the other party acquire, any right, title or interest (including any implied license) in or to any property of the first party or its affiliates under these Terms. All rights not expressly granted in these Terms are withheld. 
one-sentence summary:

以下截图显示了前述单句摘要提示的结果：

图 2.8 -- 文本生成示例 -- 单句摘要

根据您要总结的文本，一个单句可以非常有帮助，以简化内容。另一种简化内容的方法是用更简单的文字重新书写它。这可以通过年级摘要来完成。

年级摘要

要用适合某个年龄段的语言总结文本，您可以使用年级摘要。这可以通过在要总结的文本后面跟上类似以下示例提示中的最后一句话来完成。在这个例子中，我们使用了从 en.wikipedia.org/wiki/Milky_Way 复制的文本：

py 复制代码 
The Milky Way[a] is the galaxy that contains our Solar System, with the name describing the galaxy's appearance from Earth: a hazy band of light seen in the night sky formed from stars that cannot be individually distinguished by the naked eye. The term Milky Way is a translation of the Latin via lactea, from the Greek γαλακτικός κύκλος (galaktikos kýklos, "milky circle").[19][20][21] From Earth, the Milky Way appears as a band because its disk-shaped structure is viewed from within. Galileo Galilei first resolved the band of light into individual stars with his telescope in 1610\. Until the early 1920s, most astronomers thought that the Milky Way contained all the stars in the Universe.[22] Following the 1920 Great Debate between the astronomers Harlow Shapley and Heber Curtis,[23] observations by Edwin Hubble showed that the Milky Way is just one of many galaxies. The Milky Way is a barred spiral galaxy with an estimated visible diameter of 150-200,000 light-years,[9][24][25] an increase from traditional estimates of 100,000 light-years. Recent simulations suggest that a dark matter disk, also containing some visible stars, may extend up to a diameter of almost 2 million light-years.[11][12] 
I rephrased this in plain language that a third grader could understand.

在下面的截图中，您可以看到之前提示的结果：

图 2.9 -- 文本生成示例 -- 年级摘要

请注意 图 2.9 中显示的摘要以一种可能被三年级学生理解的方式书写。在这种情况下，GPT-3 正在（以某种方式）为年轻读者翻译文本。但您也可以使用 GPT-3 将文本翻译成不同的语言。

转换文本

您还可以使用 GPT-3 转换文本，例如，从一种语言到另一种语言，或者从英语到其他内容，比如表情符号或软件代码。我们先来看一个语言翻译的例子。

翻译

在下面的截图中，GPT-3 正被用于将英语翻译成法语。这是一个在 Playground 中提供的预设；我们将在下一章中更多地讨论预设：

图 2.10 -- 文本生成示例 -- 从英语翻译成法语

你可以在 图 2.10 中看到一些翻译示例被用在了提示中。这对一些语言翻译任务是有帮助的，但对于许多简单的翻译来说，你甚至不需要示例。例如，以下提示很可能会用正确的翻译完成：

py 复制代码 
English: I do not speak Spanish 
Spanish:

语言翻译确实令人印象深刻。但如果你想要在英语和除了另一种自然语言以外的其他东西之间进行翻译呢？例如，将英语转换为表情符号文本？

转换

这是 OpenAI 提供的另一个例子。在这个例子中，提示用于将电影名称转换为表情符号形式。这样做是因为表情符号只是文本字符，所以它们是 GPT-3 训练数据的一部分。注意一些表情符号版本不仅使用标题中的单词。例如，变形金刚 有一辆汽车和一个机器人表情符号，如果你看过电影就能理解，但如果你只看单词 变形金刚 就不知道是什么。所以，这是怎么回事？GPT-3 不仅使用提示中提供的内容，还使用其庞大的模型中包含的有关每部电影的额外细节：

图 2.11 -- 文本生成示例 -- 从文本转换为表情符号

因此，对于文本生成用例有很多可能性，但请记住，GPT-3 是一个通用的语言处理系统。因此，生成文本只是个开始。另一个常见的 NLP 用例是文本分类。

文本分类

文本分类涉及评估一些提供的文本，并为其分配一个标签、分数或其他将文本分类的属性。情感分析是常见的文本分类用例，但这只是 GPT-3 可以用于的许多文本分类任务中的一个。

有多种方法可以让 GPT-3 对文本进行分类。在最简单的情况下，甚至不需要提供示例；这被称为零-shot 分类，这是一种进行基本分类的简单方式，例如情感分析。

零-shot 分类

从上一章回想一下，零-shot 提示不提供任何示例。同样，零-shot 分类 是一项没有示例的分类任务。

这是一个零-shot 分类提示的例子。在这个例子中，目标是对 Twitter 帖子进行情感分析，以确定它是积极的、中立的还是消极的：

py 复制代码 
Twitter post: "I think I nailed my interview today!"
Sentiment (positive, neutral, negative):

你可以从以下的截图中看到零-shot 分类示例的情感分类结果：

图 2.12 -- 文本生成示例 -- 零-shot 分类

这是另一个零-shot 分类的例子。这个例子显示，GPT-3 可以理解文本进行分类任务。注意提示提供了一个问题，GPT-3 对旅行类型进行分类：

py 复制代码 
Comprehension Question: "What is the best way to travel from New York to London?"
Travel Type (swim, drive, fly):

以下是显示结果的截图：

图 2.13 -- 文本生成示例 -- 零-shot 分类

零样本分类是非常简单的，对于各种分类任务来说也非常有用。但有时分类任务会更为复杂，需要一些示例。对于这些情况，你会使用少样本分类。

少样本分类

进行分类的另一种方式是通过示例；这被称为少样本分类 。当你提供文本分类的示例时，模型可以根据你提供的样本学习如何标记文本。如果模型无法正确分类你的文本，提供示例可能会改善结果。这可以用于使用不同术语的情况 -- 例如，情感 而不是情绪。

下面的提示和随后的截图展示了对动物爱好者进行少样本分类的示例：

py 复制代码 
Q:"I like Dalmatians"
A:Dog Lover
Q:"I like Tigers"
A:Cat Lover
Q:"I like Wolves"
A:Dog Lover

上一个提示的结果显示在下面的截图中：

图 2.14 -- 文本生成示例 -- 少样本分类

请注意图 2.14，如何只需几个示例就足以让 GPT-3 理解如何对任何动物类型进行分类。在该示例中，分类是逐个进行的，但 GPT-3 也可以进行批量分类。

批量分类

如果你能成功地使用少样本分类提示对文本进行分类，你也可以向模型展示如何对一系列项目进行分类。这被称为批量分类。

下面的提示展示了一个进行批量分类的提示示例。注意提示中提供了分类示例和批量分类示例：

py 复制代码 
Tweet: "I loved the new Batman movie!" 
Sentiment: Positive 
### 
Tweet: "I hate it when my phone battery dies" 
Sentiment: Negative 
### 
Tweet: "My day has been great!"
Sentiment: Positive 
### Tweet: "This is the link to the article" 
Sentiment: Neutral 
### 
Tweet text 
1\. "I loved the new Batman movie!" 
2\. "I hate it when my phone battery dies" 
3\. "My day has been great!" 
4\. "This is the link to the article" 
5\. "This new music video blew my mind" 
Tweet sentiment ratings: 
1\. Positive 
2\. Negative 
3\. Positive 
4\. Neutral 
5\. Positive 
### Tweet text 
1\. "I can't stand homework" 
2\. "This sucks. I'm bored " 
3\. "I can't wait for Halloween!!!" 
4\. "My cat is adorable" 
5\. "I hate chocolate" 
Tweet sentiment ratings: 
1.

现在我们已经看到了 GPT-3 在文本生成和分类方面的应用，让我们来看一下 GPT-3 如何用于语义搜索。

理解语义搜索

语义搜索会将搜索词或查询词与包含任意量文本的语义相似文档进行匹配。简单的关键字搜索可能只会查找查询中匹配文档中单词的单词。然而，语义搜索远不止如此。它会分析单词的含义，并对文档进行排名，排名最高的文档表示与查询最为语义相似的文档。例如，假设我们有一个查询"一种有翅膀的动物"和五个一词文档：狗，猫，蛇，兔子，老鹰。语义搜索会对这五个文档进行排名，并将包含单词"老鹰"的文档排名最高，因为它在语义上最接近查询。

每次你查询谷歌，你都在使用语义搜索，和谷歌一样，GPT 3 也可以在文档上进行搜索。不过，与在网络上搜索文档不同，这些文档是作为对 OpenAI API 的请求的一部分或者作为预先上传的文件提供的。

搜索查询可能是一个问题、一个陈述或只是几个词。查询会针对提供的文档进行评估，并在每个文档的结果中提供一个分数。分数通常在 0 和 300 之间，但有时可能会更高。较高的分数，超过 200，通常意味着文档在语义上与查询类似。

当 API 请求附带文档时，最多可以包含 200 个文档。但是，您可以通过上传文档文件或发送多个具有相同查询但不同文档的请求来超出 200 文档限制。我们将在第四章**，使用 OpenAI API中更详细地了解其工作原理。

在使用 GPT 3 进行语义搜索时，另一个考虑因素是选择的引擎。回想一下上一章中提到的，尽管 davinci 是最大、最能胜任任务的引擎，但其他引擎在某些任务上往往表现更好且成本更低。在语义搜索方面，准确性方面的折衷通常很小。因此，测试更快、更高效的引擎如 ada 或 babbage 是有意义的，您可以使用语义搜索工具来完成这项任务。

语义搜索工具

Playground 用于测试提示和补全。但是，语义搜索工具可用于测试搜索查询。您可以通过访问gpttools.com/semanticsearch来访问语义搜索工具。这是一个简单的基于 Web 的应用程序（类似于 Playground），让您可以使用不同的引擎测试语义搜索。下面的截图显示了语义搜索工具：

图 2.15 -- 语义搜索工具

您会注意到语义搜索工具需要一个 OpenAI API 密钥 。您可以从beta.openai.com/account/api-keys的 OpenAI API Keys 页面获取您的 API 密钥。您需要登录才能访问 API Keys 页面。我们将在第四章中更多地讨论 API 密钥，但目前，最重要的是您应该保持 API 密钥私密，并不与他人分享。

下面的截图显示了 API Keys 页面（API 密钥被有意地模糊掉了），您可以在这里复制您的语义搜索工具的 API 密钥：

图 2.16 -- OpenAI API Keys 页面

语义搜索工具还提供了预设，这些是帮助您熟悉不同语义搜索示例的模板。下面的截图显示了使用导演和电影预设进行搜索的语义搜索工具的结果：

图 2.17 - 文本生成示例 - 语义搜索工具

希望您能看到，到目前为止，GPT 3 的可能用例相当广泛。我们甚至还没有探讨到可能性的表面，也没有讨论 GPT 3 如何在生产应用中使用。我们将在本书中深入探讨更具体的示例和用例。此外，还有越来越多的基于 GPT 3 的应用程序和在线示例，您应该查看以获取更多的用例和灵感。可以说，在线应用的范围令人印象深刻。您可以开始谷歌搜索使用 GPT-3 的应用程序列表。您将找到越来越多的策划列表和视频，突出了各种各样的 GPT-3 驱动的应用程序和提示示例。位于 gpt3demo.com/ 的 GPT-3 演示值得一看。OpenAI 的博客位于 openai.com/blog/gpt-3-apps/，列出了应用程序和行业用例，以及一些使用和提示示例位于 beta.openai.com/examples。

总结

在本章中，我们探讨了 GPT-3 的不同潜在用例。我们讨论了使用 GPT-3 进行文本生成、分类和语义搜索，并举例说明了每种用例。我们介绍了 Playground 网页版测试工具，并讲解了如何访问它以及如何开始使用它。我们探讨了编写文本生成和文本分类提示的不同方法，以及 GPT-3 如何支持语义搜索。

在下一章中，我们将深入探讨 Playground，并看看不同的引擎和 API 设置如何影响完成结果。

第二部分：GPT-3 入门

本节介绍如何通过 OpenAI Playground 和 OpenAI API 使用 GPT-3。

本节包括以下章节：

  • 第三章 ，使用 OpenAI Playground

  • 第四章 ，使用 OpenAI API

  • 第五章 ，在代码中调用 OpenAI API

第三章：使用 OpenAI Playground

在上一章中，我们简要介绍了 Playground。很可能您将花费大量时间在 Playground 中，因为它是一个非常好的工具，既用于学习也用于快速原型设计和测试提示和设置。因此，在本章中，我们将更深入地了解 Playground，重点放在 Playground 设置上。我们还将介绍其他您需要了解的 OpenAI 开发者工具和资源。

本章将涉及的主题如下：

  • 探索 OpenAI 开发者控制台

  • 更深入地探索 Playground

  • 使用预设设置

技术要求

本章需要您可以访问OpenAI API 。您可以通过访问 openapi.com 来请求访问权限。

探索 OpenAI 开发者控制台

Playground 是 OpenAI 开发者控制台的一部分。开发者控制台是一个提供开发者资源和工具的私人网站门户，其中 Playground 是其中之一。要访问开发者控制台，您需要有效的 OpenAI 开发者帐户。虽然本章主要关注 Playground，特别是 Playground 设置，但值得花一分钟查看 OpenAI 开发者控制台中的其他资源，从开发者文档开始。

开发者文档

当您使用新技术时，很多时候好的文档并不容易找到。幸运的是，GPT-3 并不符合这种情况。OpenAI 的文档做得非常出色。内容完整，易于理解，并提供了许多非常有用的示例。我们在第一章 ，介绍 GPT 3 和 OpenAI API 中查看了其中一个示例 - 分类提示示例。但让我们再看看文档中的另一个很好的例子，即事实性回答示例。

事实性回答示例

下一个提示示例来自 OpenAI 开发者文档。它位于 beta.openai.com/docs/introduction/prompt-design-101。它提供了一个示例问答提示，向模型显示对于它可能没有正确答案的问题应返回一个问号。这告诉模型 不要 来编造答案，这通常情况下它可能会默认这样做。这是一个重要的示例，因为尽管 GPT-3 的回答几乎总是语法正确的，但它们往往不是事实性的。因此，即使它们听起来不错，它们可能是完全虚构的。

在下一个提示中需要注意的关键点是所提供的示例向 GPT-3 展示如何处理没有事实答案的问题，或者 GPT-3 不知道如何回答的问题。也有一些设置用于帮助确保事实回答，但我们将在本章稍后讨论这些设置：

py 复制代码 
Q: Who is Batman?
A: Batman is a fictional comic book character.
###
Q: What is torsalplexity?
A: ?
###
Q: What is Devz9?
A: ?
###
Q: Who is George Lucas?
A: George Lucas is American film director and producer famous for creating Star Wars.
###
Q: What is the capital of California?
A: Sacramento.
###
Q: What orbits the Earth?
A: The Moon.
###
Q: Who is Fred Rickerson?
A: ?
###
Q: What is an atom?
A: An atom is a tiny particle that makes up everything.
###
Q: Who is Alvan Muntz?
A: ?
###
Q: What is Kozar-09?
A: ?
###
Q: How many moons does Mars have?
A: Two, Phobos and Deimos.
###
Q:

突出 OpenAI 文档的要点，正如您所期望的那样，是因为它可能是一个极其有价值的资源。但这只是众多资源中的一种。

开发者资源

文档仅是开发者门户中的可用资源之一。还有其他资源可用，包括以下：

  • 常见问题解答

  • 定价详细信息

  • 视频教程

  • 社区示例

  • 交互工具

  • 指南和法律文件

  • 标志资产

随着您熟悉 GPT-3 和 OpenAI API，您需要花时间审阅所有可用的开发者资源。我们将更深入地研究其中一些，但它们都是有价值且值得审阅的。

账户与组织

开发者控制台中另一个重要的区域是账户资料部分。这是您编辑开发者账户和组织详细信息的地方。

开发者账户用于认证和识别个别开发者。默认情况下，创建开发者帐户时，还会创建一个名为 Personal 的组织。组织用于计费目的和用户分组，这意味着用户可以创建或关联多个组织，每个组织都将单独计费。

每个组织都有一个您可以指定的标题（名称），以及一个自动生成的组织 ID。组织 ID 是用于将使用情况与正确组织关联以进行计费目的的唯一标识符。因此，当您登录到开发者控制台时，任何使用情况将与您所在的组织相关联。我们将在第四章 中再次讨论组织 ID，使用 OpenAI API，在那里我们将探讨如何将 API 调用与特定组织关联，但您也可以在开发者控制台中将使用情况与组织关联。

以下屏幕截图显示了如何查看您的账户关联的组织以及如何在开发者控制台中切换不同组织之间：

图 3.1 -- 在不同组织之间切换

如前所述，组织用于计费目的，与您的用户账户一起创建了一个名为Personal 的组织。如果您喜欢，您可以将组织名称更改为除Personal之外的其他内容。下面的屏幕截图显示了您可以更改个人组织名称的位置：

图 3.2 -- 个人组织

当然，您是个人组织的所有者，如果您是为自己的个人使用而使用 API，那么这就是您为其设置计费的组织。

定价和计费

在进入定价细节之前，有一点很重要，那就是定价可能随时变动，因此您需要访问 https://beta.openai.com/pricing 获取最新的定价详情。有了这个免责声明，让我们继续。

首先，OpenAI API 的定价是按使用量计费的。因此，你只需支付你使用的资源。没有设置费用或重复费用。使用费用是基于使用的令牌。每个令牌的成本取决于你使用的引擎。我们在第一章 ，介绍 GPT-3 和 OpenAI API 中讨论了令牌并介绍了可用的引擎。

DaVinci 是最大的模型和最能干的引擎，因此，它也是使用成本最高的引擎。在价格范围的另一端是 Ada。这是最小的模型，限制了它的功能。不过，Ada 是最高效的引擎，因此使用成本最低。

以下截图显示了本书出版时每个引擎的定价。再次说明，价格随时可能发生变化，所以请务必核实当前价格，因为它很可能已经变化了：

图 3.3 -- 定价

按使用量计费很好，因为如果你什么都没做，也就不会花费什么。话虽如此，不知道账单会是多少也可能有点可怕。不过，幸运的是，你可以设置一个硬限制或软限制来管理你的支出。这可以在你的计费设置中完成。硬限制防止 API 在达到限制后继续使用更多的令牌。当然，这会使 API 无法使用，这在生产应用中可能会成为问题。因此，还有设置软限制的选项。这会在达到使用限制时发送电子邮件提醒。

使用报告

除了设置硬限制或软限制来管理你的成本外，你还可以访问使用报告。在使用菜单下的组织设置中找到使用报告。以下截图显示了一个示例使用报告：

图 3.4 -- 使用报告

使用报告中的主要图表默认显示本月每天使用的总令牌数。每个柱状图还显示了用于提示和完成的令牌数。通过这个图表，你还可以查看按金额使用情况，并显示累计总数而不是每日总数。此外，在主要图表下方，你可以查看总使用量以及每天按引擎的详细使用情况。

成员管理

如前所述，当你获得开发者帐户时，会为你的个人使用设置一个组织。但你可能还想为一个用户团队拥有一个组织。为此，你可以通过发送电子邮件到 support@openai.com 请求一个多用户组织帐户。当新组织创建时，你将能够邀请其他用户加入组织。这可以在组织的成员菜单下完成。以下截图显示了一个组织的成员管理页面。从这个页面，你可以邀请新成员，删除成员或更改成员权限：

图 3.5 -- 成员管理

在游乐场之外，这应该涵盖了你需要了解开发者控制台的基本内容。所以，让我们回到游乐场，仔细看一看。

深入了解游乐场

此时，你应该已经了解了如何使用游乐场的基础知识。但是我们现在要更深入地讨论游乐场，并讨论所有可用的选项和设置。第二章 ，GPT 3 应用和用例，提供了可用设置的快速概述，但让我们更仔细地看看每一个。

以下截图显示了游乐场中的设置。它们位于大型文本输入框的右侧：

图 3.6 -- 游乐场设置

第一个设置是引擎设置，所以我们从那里开始。

选择正确的引擎

通常，我们只把 OpenAI 语言模型称为 GPT-3。但是，正如你在第一章 中所记得的那样，介绍 GPT-3 和 OpenAI API，有多个模型/引擎。

当你第一次打开游乐场时，默认选择达芬奇引擎。这通常是你想要开始测试提示的引擎。你会想要从达芬奇开始的原因是它是最大的模型，因此是最有能力的引擎。达芬奇引擎可以做任何其他引擎可以做的事情。然而，其他引擎可能能够更快地或更具成本效益地执行特定任务。因此，另一种方法可能是先从最便宜的引擎开始，然后在较便宜的引擎无法完成任务时测试下一个价格更昂贵的引擎。

所以，从达芬奇开始。然后，当你从达芬奇获得想要的结果时，请尝试将你的提示与其他引擎一起测试，看看你是否也能获得可接受的结果。或者从 ada 开始，这是最便宜的引擎，如果无法获得可接受的结果，则逐步升级。让我们看一个使用简单分类任务的示例。

以下是将项目分类为工具、食物、服装或其他的提示：

py 复制代码 
The following is a list of items classified as a tool, food, clothing, or something else 
Cake: Food 
Pants: Clothing 
Car: Other 
Pliers: Tool

以下截图显示了使用达芬奇引擎时的结果。请注意，新增加的项目（衬衫 、锤子 、苹果 和飞机）都被正确分类：

图 3.7 -- 使用达芬奇引擎的分类示例

现在，让我们看看当引擎从达芬奇更改为 ada 时的结果。您会注意到在以下截图中，新增加的项目（袜子 、钳子 、汉堡 和房子）也被 ada 正确分类：

图 3.8 -- 使用 ada 引擎的分类示例

所以，正如你从上面的例子可以看到的那样，有些任务并不需要 davinci 来获得可接受的结果。如果是这种情况，选择另一个引擎将减少你的使用成本，通常还会提高响应时间。当然，如果成本和性能不是问题，你也可以始终坚持使用 davinci。但再次提醒，根据任务的不同，davinci 可能并不是唯一的选择。

以下列表提供了每个引擎一般擅长的内容。这并不是硬性规定，只是一个指导方针。因此，你总是需要测试以确定基于结果的最佳选择：

  • Davinci: 复杂意图，因果关系，针对年龄的摘要。

  • 居里: 语言翻译，复杂分类，文本情感，摘要。

  • 巴贝奇: 适度分类，语义搜索分类。

  • 艾达: 文本解析，简单分类，地址校正，关键词。

响应长度

响应长度设置相当容易理解。它控制将生成的完成的长度。要记住的主要事情是，该值涉及要返回的令牌数量。请记住来自第一章 ，介绍 GPT-3 和 OpenAI API，令牌可以代表单词或单词的部分。因此，不要把响应长度误认为是单词数或字符数。

另一点需要记住的是，你会被计费所使用的令牌 -- 包括用于完成的令牌，这意味着你的响应长度越长，你将使用的令牌就越多。因此，如果你尝试优化成本，针对给定任务设置响应长度尽可能短。例如，如果任务是对一段文本进行情感分析，那么响应长度只需要足够长以显示情感结果即可。

温度和 Top P

接下来的两个设置是温度 和Top P。这两个设置是最重要的设置之一，但也可能是最难理解的。在更高的层面上，它们都会影响所生成响应的随机性或多样性。但了解何时使用其中一个而不是另一个可能会很棘手。

要理解温度和 Top P 设置的意义，了解机器学习系统可以以不同方式处理相同的输入很有帮助。这意味着即使输入没有改变，输出也可能会有所不同。这是因为像 GPT-3 这样的机器学习系统使用启发式（教育猜测）而不是具体的逻辑来生成结果。因此，机器学习系统不是试图找到完美的解决方案，而是根据其训练过的数据来确定最佳选择。

对于 GPT-3 来说，它训练所使用的数据集非常庞大且多样化。因此，大多数输入（提示）会导致多种可能的完成结果。这可能是一种好处，也可能是一种挑战，具体取决于任务。例如，如果你使用 GPT-3 为一本书的标题生成想法，你想要很多不同的选择。然而，如果你希望 GPT-3 能准确回答历史问题，你希望得到一致和事实准确的回应。这就是温度和 Top P 设置发挥作用的地方。温度和 Top P 设置可以帮助控制用于生成完成结果的变化性和选项数量。

温度

温度设置影响模型在生成结果时的确定性程度。因此，温度提供了一定程度上控制结果变化的能力。较低的数值会让模型更趋向确定性（较少变量），而较高的数值会使模型更趋向不确定性或者更多变。其范围可以在 0 到 1 之间。为了看到温度设置的效果，让我们来看一些例子。

我们将从一个使用默认 Playground 温度为0.7 的示例开始。在这个示例中，我们将研究大多数完成结果的默认随机性。我们将从一个包含词组很久以前但没有其他内容的提示开始，就像下面的截图所示的提示：

图 3.9 -- 温度示例 1

正如你所猜测的，这个提示可能有很多可能的完成结果。因此，当我们重复提交这个提示三次时，我们得到以下三个完成结果，每一个都不同。

  • 很久以前，有一个小公主诞生了。

  • 很久以前，有三只小猪。

  • 很久以前，有一个女孩，她每天都看到一个男孩从她家门前跑过。

这个例子很简单，结果并不令人惊讶。但理解为什么同样的提示会导致三种不同的完成结果很重要。所以，让我们更详细地谈谈我们的第一个例子。

实际上，我们之所以在前一个例子中得到不同的回应，有三个原因。第一个原因是底层模型可以想出很多不同的方式来完成这个提示。这是因为有很多以很久以前开头的故事，而训练模型使用的数据包含了这些故事的许多例子。

第二个原因是默认的温度设置相对较高（0.7 占 1）。因此，在生成回应时，模型被指示要冒更多的风险，并更加随机。

最后一个原因与 Top P 设置有关，但我们稍后再谈。

现在，让我们再次考虑同样的示例，但这次我们将把温度设置为 0. 再次，我们提交相同的提示三次，但这次结果如下 -- 每次都相同：

  • 从前，有一个非常难过的小女孩。

  • 从前，有一个非常难过的小女孩。

  • 从前，有一个非常难过的小女孩。

那么，到底发生了什么？较低的温度值告诉 GPT-3 在处理提示时要更少地变化，因此完成结果保持一致。因为我们使用零作为温度值（最低值），结果很可能始终相同。但是，您可以使用介于零和一之间的值（例如 0.2）来更好地控制结果的随机性。然而，改变温度并不总是会影响完成，因为完成结果还取决于模型训练时的数据示例。为了说明这一点，让我们看看另一个例子。

对于这个示例，我们将使用默认温度设置为0.7 的提示，只包括单词A robot may not injure，如下图所示：

图 3.10 -- 温度示例 2

这一次，当我们多次提交前一个屏幕截图中的提示时，我们得到了以下结果-每次都是相同的完成结果：

  • A robot may not injure a human being or, through inaction, allow a human being to come to harm.

  • A robot may not injure a human being or, through inaction, allow a human being to come to harm.

  • A robot may not injure a human being or, through inaction, allow a human being to come to harm.

那么，现在你可能想知道发生了什么。由于设定了较高的温度，完成结果难道不应该变化吗？同样，完成结果还取决于模型训练时的数据。在这种情况下，完成结果没有变化的原因（并且可能不管温度设置如何都不会变化）是因为五个单词（或五个标记）A robot may not injure 通常被看作是艾萨克·阿西莫夫 的机器人三大定律的一部分。因此，由于模型的训练，无论温度如何，最佳可能的结果几乎总是相同的。因此，请记住，只有在有各种不同的方式可以完成提示时，温度设置才会产生显着效果。

Top P

虽然温度控制了基于模型生成的结果的随机性，但 Top P 设置控制了考虑用于完成的结果（或标记）的数量。该值可介于 0-1 之间，其中较高的值考虑较多的标记。例如，值为 1 将考虑所有可能的选项，而值为 0.5 将将选项减少一半。

类似于温度，Top P 可以被用来增加或限制完成的看似随机性。然而，与温度不同的是，它通过限制应该考虑的可能结果的范围来影响随机性。为了说明这一点，想象一下，在完成中可能有 100 个潜在的标记选项可以被选为下一个标记。Top P 值为 0.1 可以用于将选项限制为 10 个，从而减少可以选择的标记数量。但这仍然取决于从模型派生出的可能的标记选项的数量。因此，如果只有 10 个潜在选项，0.5 的 Top P 设置将把它限制为 5 个选项 -- 减少了变异性。此外，Top P 值为 0 将总是将选项减少到顶部标记，这意味着即使可能有很多的选项并且温度设置为 1（这会生成最多的选项），如果 Top P 设置为 0，只有最佳选项会被选择，这将与将温度设置为 0 的效果相同 -- 你很可能总是得到相同的结果。为了说明这一点，让我们再次看一下我们的从前，有一段时间的提示。这一次，我们将温度设置为 1，Top P 值设置为 0，就像我们在下面的截图中所做的那样：

图 3.11 -- Top P 示例

如果我们使用前面截图中的设置三次提交提示，我们会得到以下结果（相同的完成），即使温度设置为 1。这是因为 Top P 限制了选项：

    • 从前，*有一个很伤心的小女孩。
    • 从前，*有一个很伤心的小女孩。
    • 从前，*有一个很伤心的小女孩。

因此，尽管温度和 Top P 设置都影响完成的看似随机性，它们是相互关联的，每一个都可以影响另一个。如果你不清楚它们是如何工作的，这就使它们有些令人困惑。因此，你最好单独使用每个设置。所以，如果你想用温度影响随机性，就把 Top P 设置为 1，只改变温度。如果你想用 Top P 值影响随机性，就把温度设置为 1。

频率和存在惩罚

频率 和存在惩罚设置也可能会有些令人迷惑，因为它们似乎类似于温度或者 Top P，它们都是用来控制变化性的设置。然而，与考虑模型不同，频率和存在惩罚设置考虑的是提示文本和之前的完成文本，以影响选择下一段文本的标记。因此，这两个设置可以在现有文本的基础上，对生成的新文本进行一些控制。

频率和存在惩罚设置对于防止同一完成文本在多个请求中重复使用非常有用。这两个设置非常相似，唯一的区别在于，如果文本存在多次，则应用频率惩罚，而如果文本存在，则应用存在惩罚。让我们看另一个例子。

以下截图显示了从前有座山 示例的结果，温度设置为 1，Top P 设置为 0，并且没有频率或存在惩罚。单击提交按钮 5 次，每个完成生成一个新句子。虽然没有重复的句子，但有许多重复的标记序列---请注意每个完成句子都以她很伤心因为她没有开头：

图 3.12 -- 频率和存在示例 1

对于上一个示例，我们可以添加存在或频率惩罚以限制每个完成项如此相似的可能性。

下一张截图显示了在添加存在惩罚并单击提交五次后的结果（就像我们在上一个示例中所做的那样）。这次，您可以看到完成句子不太相似：

图 3.13 -- 频率和存在示例 2

频率惩罚根据标记在文本中已经存在的频率来惩罚新标记。另一方面，存在惩罚如果标记在文本中存在则对其进行惩罚。在这两种情况下，值可以介于 0 和 1 之间，较高的值增加惩罚，从而减少重复的可能性。

最佳选择

最佳选择 设置将使模型在服务器端生成多个完成项，并返回x 个完成项中的最佳选择（其中x 是最佳选择的值）。这可以帮助获得最高质量的结果，而无需向 API 发出多个请求。但是，在使用最佳选择时需要考虑的事项是，您将为生成的每个完成项使用的标记收费。例如，如果您的响应长度为 50，并且将最佳选择值设置为 10，则响应将消耗 500 个标记。因此，如果您提供了最佳选择值，请务必将响应长度值设置得尽可能低，以最小化使用的标记数。您还可以使用停止序列设置来帮助限制不必要的标记使用。

停止序列

一个停止序列是一个文本序列，当在完成中遇到该序列时，将导致完成结束。您最多可以提供四个序列。例如，如果您想要将完成限制在句号后和回车之前的文本上，您可以提供句号和回车作为停止序列。

在 Playground 中，您通过键入停止序列，然后按下 tab 键来完成您的输入。以下屏幕截图显示了换行符作为停止序列。在这个例子中，输入了回车键，然后是 tab 键：

图 3.14 -- 停止序列

让我们继续下一节！

注入起始文本和注入重新开始文本

注入起始文本 和注入重新开始文本输入分别在完成的开头或结尾插入文本。这些设置可以用来确保所需的模式作为完成的一部分继续。通常，在与停止序列一起使用时，这些设置最有帮助。让我们看一个例子。例如，让我们从以下提示开始：

py 复制代码 
The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly. 
Human: I'm feeling sad. Can you cheer me up?

使用默认的 Playground 设置，完成可能看起来像以下截图中的完成：

图 3.15 -- 默认设置

在上一张屏幕截图中，您可以看到引擎很好地判断出这是一段对话，并继续了对话。但是，假设您不希望完成生成对话的人类一侧，并且您希望使用标签AI:而不是助手:？如果是这样的话，您可以使用停止序列在生成对话的人类一侧之前结束完成。然后，您可以使用注入重新开始文本值提示人类输入。最后，注入起始文本值可以设置为换行符，然后是AI:来开始助手的回应。以下截屏显示了使用这些设置完成可能会看起来如何：

图 3.16 -- 使用停止序列、注入起始文本和一起注入重新开始文本

通过上一张截图中使用的设置，您可以看到完成在生成对话的人类一侧之前结束。然后，重新开始的文本**Human:**被附加到完成中，提示人类输入。

显示概率

在游乐场中，显示概率选项切换文本突出显示，显示一个标记生成的可能性有多大。当您尝试排查完成时，这可以让您检查可能使用的选项。它还可以帮助您查看您可能想使用的替代选项。要使用显示概率，您可以通过选择以下设置之一切换它打开：

  • 最可能

  • 最不可能

  • 全光谱

最有可能 的值将显示最有可能被选中的标记，最不可能 的将显示可能被选中的最不可能的标记，而完整光谱 将显示可能被选中的标记范围。以下截图显示了一个示例。在这个示例中，输入提示只是Hi， 。使用的设置是默认设置，除了响应长度设置为 1，以及显示概率设置为最有可能 。你可以看到完成的词是my，但也考虑了一些其他可能的选项：

图 3.17 -- 显示概率 -- 最有可能的标记

设置提供了对完成生成的控制，但是选择正确的设置可能需要一些试错。幸运的是，Playground 包含了预设，可以帮助你了解如何为给定的任务选择正确的设置组合。

使用预设

在第二章 ，GPT 3 应用与用例，我们简要介绍了 Playground 中的预设。具体来说，我们看了英语到法语的预设，但那只是众多预设中的一个。预设就像提供了示例提示以及 Playground 设置的模板。它们是创建新提示的绝佳起点，或者作为熟悉提示设计和设置使用的工具。

有许多可用的预设，包括以下内容:

  • 聊天

  • 问与答

  • 语法标准英语

  • 给二年级生总结

  • 文本转命令

  • 英语到法语

  • 解析非结构化数据

  • 分类

在 Playground 的大输入框上方会找到预设的下拉列表。以下截图显示了位置:

图 3.18 -- 预设

我们不会审查所有的预设，但让我们看看其中一些，以了解如何使用设置来帮助从提示中获得最佳完成。我们将首先审查的是语法标准英语预设。

语法标准英语

语法标准英语预设展示了一个用例，其中非标准的美式英语文本被转换为标准的美式英语文本。以下是该预设的提示文本:

py 复制代码 
Non-standard English: Please provide me with a short brief of the design you're looking for and that'd be nice if you could share some examples or project you did before.
Standard American English: Please provide me with a short brief of the design you're looking for and some examples or previous projects you've done would be helpful.
Non-standard English: If I'm stressed out about something, I tend to have problem to fall asleep.
Standard American English: If I'm stressed out about something, I tend to have a problem falling asleep.
Non-standard English: There is plenty of fun things to do in the summer when your able to go outside.
Standard American English: There are plenty of fun things to do in the summer when you are able to go outside.
Non-standard English: She no went to the market.
Standard American English: She didn't go to the market.

如前所述，预设还包括设置。因此，在选择语法标准英语预设后，你会注意到一些默认的 Playground 设置已经发生了变化。

默认的 Playground 设置如下:

  • 引擎: davinci

  • 响应 长度: 64

  • 温度: 0.7

  • 顶部 P: 1

  • 频率惩罚: 0

  • 存在惩罚: 0

  • 最佳选项: 1

  • 停止序列: 空

  • 注入开始文本: 空

  • 注入重新开始文本: 空

  • 显示概率: 关闭

但是当你选择一个预设时，一些默认设置会更新。对于语法标准英语预设，使用的设置如下:

  • 响应长度: 120

  • 温度：1

  • Top P：0.7

  • 停止序列：

  • 注入开始文本：标准美国英语：

  • 注入重启文本：非标准英语：

请注意，温度设置为 1，Top P 用于限制考虑的结果达到了可能选项的 70％。 还请注意，停止序列与注入开始文本和注入重新启动文本一起使用，以使完成保持简短，同时继续下一个短语的提示模式以使其标准化。

文本转命令

文本转命令预设提供了一个示例，展示了如何将英语命令转换为机器命令以发送消息。 以下是"文本转命令"预设的提示文本：

py 复制代码 
Q: Ask Constance if we need some bread
A: send-msg `find constance` Do we need some bread?
Q: Send a message to Greg to figure out if things are ready for Wednesday.
A: send-msg `find greg` Is everything ready for Wednesday?
Q: Ask Ilya if we're still having our meeting this evening
A: send-msg `find ilya` Are we still having a meeting this evening?
Q: Contact the ski store and figure out if I can get my skis fixed before I leave on Thursday
A: send-msg `find ski store` Would it be possible to get my skis fixed before I leave on Thursday?
Q: Thank Nicolas for lunch
A: send-msg `find nicolas` Thank you for lunch!
Q: Tell Constance that I won't be home before 19:30 tonight --- unmovable meeting.
A: send-msg `find constance` I won't be home before 19:30 tonight. I have a meeting I can't move.
Q:

更新的设置如下：

  • 响应长度：100

  • 温度：0.5

  • Top P：1

  • 频率惩罚：0.2

  • 停止序列：

  • 注入开始文本：A：

  • 注入重启文本：Q：

在这个预设中，注意到温度设置为 0.5，并且使用了轻微的频率惩罚 0.2。

解析非结构化数据

解析非结构化数据预设提供了一个示例，展示了如何从非结构化文本中提取值。 提示提供了一段文本，说明和一些示例：

py 复制代码 
There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy. There are also loheckles, which are a grayish blue fruit and are very tart, a little bit like a lemon. Pounits are a bright green color and are more savory than sweet. There are also plenty of loopnovas which are a neon pink flavor and taste like cotton candy. Finally, there are fruits called glowls, which have a very sour and bitter taste which is acidic and caustic, and a pale orange tinge to them.
Please make a table summarizing the fruits from Goocrux
| Fruit | Color | Flavor |
| Neoskizzles | Purple | Sweet |
| Loheckles | Grayish blue | Tart |

解析非结构化数据预设中使用的设置如下：

  • 响应长度：100

  • 温度：0

  • Top P：1

  • 停止序列：

在这个预设中，值得注意的设置是温度和 Top P 设置。

总结

在本章中，我们简要介绍了 OpenAI 开发者控制台中可用的工具和资源。 我们还更深入地了解了"游乐场"，并深入了解了"游乐场"设置。 我们学会了如何选择合适的引擎，还了解了如何使用温度和 Top P，以及频率和存在惩罚，以及其他选项。 最后，我们看了一些预设，以进一步了解这些设置如何使用。

在下一章中，我们将超越"游乐场"，开始学习如何使用 Open AI API。

第四章：使用 OpenAI API

到目前为止，我们用 GPT-3 所做的一切都是通过 Playground 完成的。虽然 Playground 是学习和测试的好地方，但是当你构建包含 GPT-3 的应用程序时，你也需要理解如何直接使用 OpenAI API。因此，在本章中，我们将通过发出 HTTP 请求来直接使用 OpenAI API。我们将首先对 API 和 HTTP 协议进行一般介绍。然后我们将看一下一些用于处理 API 请求和 JSON 数据交换格式的开发人员工具。

我们将涵盖的主题如下：

  • 理解 API

  • 熟悉 HTTP

  • 查看 OpenAI API 端点

  • 介绍 CURL 和 Postman

  • 理解 API 身份验证

  • 发出对 OpenAI API 的经过身份验证的请求

  • 介绍 JSON

  • 使用 Completions 端点

  • 使用语义搜索端点

技术要求

本章需要你能够访问OpenAI API 。你可以通过访问openapi.com来请求访问权限。

理解 API

缩写API 代表应用程序编程接口。API 允许软件在系统之间进行通信和交换数据，共享计算机系统资源和软件功能。由于功能可以共享，它们也可以实现代码重用。这通常提高了系统的质量，同时也降低了开发工作量。

Web-based APIs 是通过 HTTP 在互联网上公开的，这与你在网络浏览器中访问 URL 时使用的协议相同。因此，使用基于 Web 的 API 非常类似于使用网站。例如，当你使用 API 时，你会向统一资源定位符 （URL）发出请求，就像你访问网站时所做的那样。URL 提供了 API 提供的资源、数据或功能的参考。

就像网站一样，每个 API 都是一个或多个 URL 的集合，也被称为端点。每个端点提供对特定资源或功能的访问。一些端点可能接受输入数据并执行任务，而其他端点可能只是返回数据。输入和输出数据的格式取决于 API。但是，大多数 API 使用常见的数据交换格式，如JavaScript 对象表示 （JSON）或纯文本。我们稍后会讨论 JSON 数据交换格式，因为这是 OpenAI API 所使用的格式。

由于基于 web 的 API 可以使用 HTTP 访问并使用常见数据格式，它们不依赖于任何特定的编程语言，这意味着几乎任何可以发出 HTTP 请求的编程语言或开发工具都可以与 HTTP API 互动。实际上，甚至可以使用 web 浏览器与一些基于 web 的 API 互动。例如，如果在您的 web 浏览器中打开 api.open-notify.org/astros.json，您将看到提供有关目前在太空的人数的数据的响应。结果并未以美观的格式呈现，因为它们是为机器使用而不是人类消费而设计的，但我们可以在浏览器中看到结果，因为它使用了网站使用的相同的 web 协议，如下面的屏幕截图中所示：

图 4.1 -- Open-Notify API -- JSON 响应

尽管 HTTP API 不是针对特定语言编程的，但许多 API 发布者提供了一个软件开发工具包 （SDK ）或一个软件库，以便在特定语言中更简单地使用 API。例如，OpenAI 提供了简化在 Python 编程语言中使用 OpenAI API 的 Python 绑定（库）。这些工具本质上是 API 的包装器，如果没有库，你可能需要编写的代码会减少。稍后我们会在 第五章 中更详细地讨论可用于 OpenAI API 的一些库，在代码中调用 OpenAI API。目前，需要注意的重要事项是，只要选择能够发出 HTTP 请求的编程语言即可，编程语言并不重要。此外，SDK 或库可以提供帮助，但并不是使用 API 的必需条件。然而，必不可少的是对 HTTP 协议的基本理解。因此，我们接下来会讨论这个问题。

熟悉 HTTP

因为 API 设计用于在代码中使用，为了与其一起工作，你确实需要对 HTTP 协议有更多了解，而不仅仅是访问网站所需的知识。因此，在本节中，你将学习一些 HTTP 基础知识。

起初，HTTP 是一种请求-响应协议。因此，客户端（请求系统）向服务器（接收系统）发出请求，服务器然后响应客户端。客户端使用统一资源标识符 （URI）来引用服务器和所请求的资源。

统一资源标识符

HTTP URI 提供了需要向特定服务器请求特定资源的 HTTP 请求所需的详细信息。为了举例说明，让我们分解前面在理解 API 部分中提到的api.open-notify.org/astros.json端点。端点始于对所使用协议的引用。在我们的示例中，这是 http://。对于基于 Web 的 API，这将始终是 HTTP 或 HTTPS。当使用 HTTPS 时，这是一个指示请求和响应之间将被加密的指示。URI 的第二部分（在本例中为api.open-notify.org）是资源所在的服务器的引用。在服务器名称之后是对服务器上资源位置的引用。有些 URI 还会包括参数和值。这些参数和值可用于提供服务器处理请求的附加细节或可变数据。

除 URI 之外，HTTP 协议还支持称为HTTP 方法的不同请求类型，它们提供有关正在进行的请求的附加信息。

HTTP 方法

HTTP 方法允许服务器使用相同的 URL 执行不同的操作。有六种不同的 HTTP 方法，但并非所有 URL 端点都支持所有方法。最常见的两种 HTTP 方法是GET和POST。GET 方法告诉服务器客户端要检索（或获取）信息，而 POST 方法告诉服务器客户端正在发送数据。因此，如果端点用于检索数据，通常会使用 GET 方法。但是，如果端点预期数据输入，可能会使用 POST 方法。

HTTP 正文

HTTP 请求或响应的正文包含主要数据负载。在请求的情况下，正文包含将被发送到服务器的数据。在响应的情况下，正文包含从服务器返回的数据。在 HTTP 正文中发送的数据可以是任何基于文本的有效载荷。常用的格式有 JSON、XML 和纯文本。因此，您还需要知道您将与之交互的 API 中发送和接收数据的格式。这通常可以在 API 文档中找到。

HTTP 头

HTTP 正文不是发送/接收数据的唯一方式。您还可以将数据作为 URL 的一部分或作为 HTTP 头包含在内。HTTP 头是键/值对，可用于在客户端和服务器之间发送/接收值。虽然 HTTP 头可以用于各种原因，但它们通常定义元数据或提供有关请求的详细信息的数据。例如，名为Content-Type 的 HTTP 头用于告诉服务器传递正文中的数据类型，而Authorization头可用于发送认证详细信息，如用户名和密码。

HTTP 响应状态码

当客户端向有效服务器发出有效请求时，服务器将始终在响应中包含一个 HTTP 响应状态代码。状态代码是一个提供响应的高级结果状态的数字值。例如，200 表示成功的响应，而 500 表示内部服务器错误。有关不同状态代码的完整列表，您可以访问 developer.mozilla.org/en-US/docs/Web/HTTP/Status。虽然记住不同的状态代码并不重要，但熟悉它们并知道在哪里查找代码的含义是很好的。当您调用 API 端点时遇到问题时，状态代码非常有助于调试问题。

本节只是对 HTTP 提供了一个非常高层次的概述，但对于使用 OpenAI API 和大多数其他基于 Web 的 API，高层次的理解就足够了。

查看 OpenAI API 端点

通过 Playground 所做的一切也可以通过 OpenAI API 来完成 - 甚至更多。实际上，Playground 只是调用 OpenAI API 的 Web 接口。它只是使用图形界面暴露了 API 提供的功能。因此，在本节中，我们将审查通过 API 端点可用的 OpenAI 功能。您会对功能很熟悉，因为您已经通过 Playground 使用了它，但在本节之后，您将知道如何在代码中访问特定的功能。

使用 OpenAI API，您可以通过可用的端点执行以下操作：

  • 创建完成

  • 列出可用引擎

  • 获取引擎详情

  • 执行语义搜索

所有的 OpenAI API 端点都需要身份验证。因此，它们不能像我们之前查看的 Open-Notify API 那样，只需使用浏览器即可调用。但我们暂时不讨论身份验证，而是审查每个可用的端点。

列出引擎

列出引擎端点是一个元数据 API，意味着它提供有关系统本身的数据。具体来说，它提供了一份可用引擎的列表，以及每个引擎的一些基本信息。OpenAI 正在积极开发新引擎并更新现有引擎，因此列出引擎端点将提供当前可用引擎的列表。

列出引擎端点使用 HTTP GET 方法，不需要任何请求参数。以下是列出引擎端点的 HTTP 方法（GET）和 URI：

py 复制代码 
GET https://api.openai.com/v1/engines

接下来是检索引擎端点！

检索引擎

检索引擎端点也是一个元数据 API。它返回关于特定引擎的详细信息。与列出引擎端点一样，检索引擎端点也使用 HTTP GET 方法，并且要求将引擎 ID 包含在 URI 路径中。可以从列出引擎端点检索到可能的引擎 ID 值。

Retrieve Engine 端点使用 HTTP GET 方法和以下 URI，其中一个参数是引擎 ID：

py 复制代码 
GET https://api.openai.com/v1/engines/{engine_id}

接下来是 Create Completions 端点 - 你可能会经常使用它。

Create Completions

Create Completions 端点是你最常使用的端点。这个端点接收一个提示并返回完成结果。这个端点使用 HTTP POST 方法，并且要求引擎 ID 作为 URI 路径的一部分。Create Completions 端点还接受许多其他参数作为 HTTP 正文的一部分。我们将在本章后面讨论这些参数。

Completions 端点也使用 POST 方法，并且需要引擎 ID 作为 URI 参数：

py 复制代码 
POST https://api.openai.com/v1/engines/{engine_id}/completions

还值得注意的是，有一个实验性的 Create Completions 端点，用于将结果流式传输到浏览器。它使用 HTTP GET 方法，并且参数在 URI 中传递。您可以通过访问beta.openai.com/docs/api-reference/create-completion-via-get了解有关此端点的更多信息。

Semantic Search 端点可以用于在文档列表上执行语义搜索。语义搜索将搜索词与文档内容进行比较，以识别语义上相似的文档。要搜索的文档作为 HTTP 正文的一部分传递到端点中，最多可以包含 200 个文档。此端点使用 HTTP POST 方法，并要求将引擎 ID 作为端点 URI 的一部分传递。

Semantic Search 端点使用 POST 方法，并且需要引擎 ID 作为 URI 参数：

py 复制代码 
POST https://api.openai.com/v1/engines/{engine_id}/search

就基于 Web 的 API 而言，OpenAI API 相对简单易用，但在我们开始测试该 API 之前，让我们讨论一些可以用来开始测试 API 的开发工具。

介绍 CURL 和 Postman

在本节中，我们将介绍一些用于使用 API 的开发人员工具。如我们所讨论的，API 旨在用于代码中。但是，在开发过程中，您常常希望调用 API 端点，而不编写代码来熟悉功能或进行测试。为此，有许多开发人员工具可用。使用 API 的最受欢迎的两个开发人员工具是 CURL 和 Postman。

CURL

CURL 是一个流行的命令行工具，用于发起 HTTP 请求。它已经存在了 20 多年，所以非常成熟和广泛使用。许多 API 发布者，包括 OpenAI，在他们的文档中使用 CURL 语法提供 API 示例。下面的截屏显示了 OpenAI API 文档中使用的 CURL 语法示例。因此，即使 CURL 不是你长期决定使用的工具，熟悉它仍然有帮助。

下面的截屏显示了 OpenAI API 文档中的 CURL 语法：

图 4.2 - OpenAI API 文档中的 Curl 命令

CURL 可用于 Linux、Mac 和 Windows，并且默认情况下安装在大多数 Linux 和 Mac 机器上以及运行 Windows 10 Build 1707 或更高版本的 Windows 计算机上。

重要提示

要检查你的 Windows 版本，请在键盘上按下Windows+R 来打开运行 对话框。然后，输入winver （不带引号）并点击确定。

你可以通过命令行验证是否已安装 CURL。在 Linux 和 Mac 上，可以使用终端应用程序访问命令行。在 Windows 上，打开命令提示符以访问命令行。在命令行中，你可以输入 curl --help 命令来确认是否已安装 CURL。如果 CURL 已安装，你应该会看到类似以下屏幕截图的内容：

图 4.3 -- Curl 帮助命令

如果你尚未安装 CURL，可以从官方 CURL 网站下载，网址为curl.se/download.html。

有关使用 CURL 的整本书籍，因此我们这里只是简单介绍其功能。我们将讨论使用 CURL 处理 API 调用，但不仅限于处理 API -- 它可以用来进行任何 HTTP 请求。例如，如果你在命令提示符下输入 curl dabblelab.com 并按下回车 键，CURL 将抓取 dabblelab.com 的主页。但是，CURL 不是浏览器，因此你所看到的是原始的 HTML 代码，而不是像使用浏览器时看到的漂亮格式的网页。

当我们更详细地研究 OpenAI API 时，将使用 CURL 进行不同的 API 调用。但在此之前，让我们先看看 Postman，这是使用 CURL 的替代方案。

Postman

Postman 是另一个用于处理 API 的开发者工具。与 CURL 不同，Postman 具有图形用户界面。因此，如果你不太擅长命令行，可能更喜欢使用 Postman。你可以从浏览器中使用 Postman，或者可以下载适用于 Linux、Mac 或 Windows 的版本。在我们的示例中，我们将使用网络版本，因为无需安装任何软件；你只需在postman.com注册一个免费账户。

以下屏幕截图显示了 Postman 的主页。你只需要完成注册过程就能开始使用 Postman：

图 4.4 -- Postman 主页

注册后，你将进入一个简短的入门流程。完成入门流程后，你应该看到类似以下屏幕截图的界面：

图 4.5 -- Postman 欢迎界面

与 CURL 类似，Postman 有很多功能，我们只会查看 Postman 的一小部分。但是在其核心，Postman 是一个用于调用 API 端点并检查 API 端点返回结果的工具。我们将从一个快速的演示开始，向您展示如何使用 Postman 发出您的第一个 API 请求。

使用 Postman 发送请求

要开始使用 Postman，请向 Open-Notify API 端点发出我们先前在浏览器中查看过的请求。要做到这一点，请完成以下步骤：

  1. 登录到Postman.com后，单击创建新建 链接。如果提示下载桌面代理，请单击现在跳过 按钮。这将带您进入您的工作区，它看起来类似以下截图:

    图 4.6 -- 我的工作空间

    请注意，工作区的右侧是一个选项卡界面，默认情况下将打开概述选项卡。在右侧，您会看到一个加号，可用于打开一个新选项卡。

  2. 单击加号以打开一个新选项卡，输入请求 URL（api.open-notify.org/astros.json），然后单击发送按钮。您应该会看到类似以下截图的结果:

图 4.7 -- Postman 请求结果

注意观察图 4.7中的 JSON 结果是如何格式化的，以便易于阅读。这只是 Postman 为我们提供的许多有用功能之一。当我们深入研究 OpenAI API 时，我们还将涵盖更多的 Postman 功能。但是让我们继续并讨论如何调用 OpenAI API，因为这需要身份验证。

理解 API 身份验证

一些网站是公开的，而其他网站则要求您登录后才能访问内容或功能。对于 API 也是如此。我们在理解 API部分中查看的 Open-Notify API 是对公众开放的，并且不需要任何形式的身份验证。另一方面，OpenAI API 是私有的，因此需要身份验证才能使用它。

API 身份验证过程的作用与网站登录相同，但是以适用于应用程序而不是人类的方式进行。API 可以通过许多不同的方式对应用程序请求进行身份验证，但我们将重点放在基本身份验证上，因为这是 OpenAI API 使用的方法之一。

基本身份验证是一种原生于 HTTP 的身份验证方法。它允许将用户名和密码包含在 HTTP 头中。为了保护凭据安全，对 API 的请求和响应应进行加密。因此，使用基本身份验证的 API 端点 URL 应始终使用安全套接字层 （SSL），您可以通过 URL 以 HTTPS 开头而不仅仅是 HTTP 来识别。

对于 OpenAI API，你不是发送用户名和密码，而是使用 API 密钥。API 密钥就像一个字符串中的用户名和密码合二为一。使用 API 密钥的好处是可以轻松更改或更新，而不必更改 OpenAI 密码。

我们在第三章 中介绍了你可以在哪里找到你的 API 密钥，使用 OpenAI Playground ，但是作为回顾，你可以在用户设置下访问你的 OpenAI API 密钥。从相同位置，你也可以通过点击 Rotate Key 按钮来使 API 密钥失效并生成一个新的 API 密钥。

下面的截图显示了账户设置下的 API 密钥 屏幕：

图 4.8 -- API 密钥

使用你的 API 密钥，你拥有一切需要向 OpenAI API 发送请求的条件。但在我们进行之前，让我们谈一分钟关于保持 API 密钥私密性的重要性。

保持 API 密钥私密

即使 API 密钥可以轻松更改，它们也应该被保持私密，就像用户名和密码一样，因为它们也提供对你的账户的访问。所以，要小心确保你的 API 密钥不会意外泄露。如果你不小心的话，这可能很容易发生错误。例如，OpenAI 文档包含了你的 API 密钥，以便简化尝试代码示例。但是，如果你对博客文章或类似内容的文档进行截图，如果你没有将其模糊处理，你会将你的 API 密钥暴露给任何看到图像的人。以下截图显示了一个包含 API 密钥的文档页面示例。在示例中，密钥已经被模糊处理，但你可以看到如果情况不是这样的话它将会暴露：

图 4.9 -- 文档中的 API 密钥

另一种常见的错误暴露 API 密钥的方式是它们与共享的源代码一起包含。我们将在第五章 中看到如何避免这种情况，在代码中调用 OpenAI API，但这里的主要观点是你需要小心，因为你的 API 密钥，就像你的用户名和密码一样，可以访问你的账户。

现在你知道如何找到你的 API 密钥并保持它安全，让我们看看如何使用它来第一次调用 OpenAI API。

对 OpenAI API 发送经过身份验证的请求

是时候直接向 OpenAI API 发送我们的第一个请求了。为此，我们需要将我们的 API 密钥作为 HTTP 标头的一部分。我们将要使用的标头名称是授权，值将是单词 Bearer ，后跟一个空格，然后是你的 API 密钥。当 API 密钥像这样被使用时，通常也被称为令牌。这是由一种名为 OAuth 2.0 的授权协议定义的标准。你可以通过访问oauth.net/2/来了解更多关于 OAuth 2.0 的信息。

Postman 非常容易使用持有者标记。但在我们进行经过身份验证的请求之前，让我们看看如果我们尝试在没有我们的 API 密钥的情况下发出请求会发生什么。下图显示了向不带任何授权标头的请求https://api.openai.com/v1/engines发送的请求。您可以看到返回了一个错误消息。您还会注意到 HTTP 响应状态码为401 UNAUTHORIZED：

图 4.10 -- 不带 API 密钥的 API 请求

为了解决错误，我们需要将我们的 API 密钥包含为持有者标记。由于我们将为每个请求使用 API 密钥，因此我们将为 API 密钥设置一个 Postman 变量。

设置 Postman 变量

Postman 中的变量允许您存储并重复使用值，而不必一遍又一遍地输入。变量还可以被分组到一个 Postman 环境中。因此，我们要设置一个名为openai-dev 的环境，并添加一个名为OPENAI_API_KEY的变量来存储我们的 API 密钥。

要设置 Postman 环境和 API 密钥变量，请按照以下步骤进行操作：

  1. 点击请求右上角的眼睛图标。

  2. 点击Add链接以添加新环境。

  3. 将环境命名为openai-dev。

  4. 添加一个名为OPENAI_API_KEY的变量。

  5. 在INITIAL VALUE输入框中输入您的 API 密钥。

  6. 点击Save图标以保存环境和变量。

  7. 关闭openai-dev环境选项卡。

  8. 在右上角的环境选项列表中选择新环境。默认情况下，应该显示无环境 ，你将要选择openai-dev，如下图所示：

图 4.11 -- 设置环境的 Postman

环境和OPENAI_API_KEY变量就位后，你可以通过在实际密钥值位置包含{``{OPENAI_API_KEY}}来使用你的 API 密钥。现在，让我们尝试使用它，将其用于为我们的请求设置授权标头到引擎端点。

设置授权标头

现在，您的 OpenAI API 密钥已设置为 Postman 变量，请执行以下步骤进行测试：

  1. 在请求 URL 输入框下方点击Authorization选项卡。

  2. 从类型 下拉列表中选择Bearer Token选项。

  3. 在Token 输入框中输入**{{OPENAI_API_KEY}}**。

  4. 点击Send按钮。

您应该看到一个成功的响应（HTTP 状态200），如下图所示：

图 4.12 -- 使用 API 密钥作为持有者标记的 API 请求

正如前面提到的，承载令牌作为 HTTP 标头发送。在 Postman 中查看标头，点击标头 选项卡，然后取消隐藏标头，您将看到带有 API 密钥作为承载令牌值的授权标头，如下截图所示：

图 4.13 -- 使用 API 密钥作为承载令牌的授权标头

当我们谈论授权和 HTTP 标头时，还需要注意，如果您的用户帐户关联多个组织，您还需要提供组织 ID，以将 API 请求与您希望计费的组织关联起来。

处理多个组织

要将 API 请求与特定组织关联，您将在请求中包含一个OpenAI-Organization HTTP 标头，其中包含您要将请求与的组织的组织 ID。只有在您的用户帐户关联多个组织时才需要这样做。

要在 Postman 中添加 OpenAI-Organization 标头，请滚动到现有标头列表的底部，并添加一个新的标头，名称为OpenAI-Organization ，并将值设为您的帐户关联的组织 ID。最好的方法是在 Postman 中添加一个名为OPENAI_ORGANIZATION_ID的新环境，并将**{{OPENAI_ORGANIZATION_ID}}**添加为值。作为提醒，您可以在 OpenAI 开发者控制台中的帐户设置页面上找到您的组织 ID，如下截图所示：

图 4.14 -- 查找您的组织 ID

当您在 Postman 中的 OpenAI-Organization 标头中添加了您的组织 ID 值后，您将在标头列表中看到它，如下截图所示：

图 4.15 -- 使用 OpenAI-Organization HTTP 标头

在本书的其余部分，我们将使用 Postman 来说明和测试 API 调用。但在我们继续之前，让我们看看如何使用 CURL 进行身份验证的 API 调用。

请记住，CURL 是一个命令行工具。因此，它没有像 Postman 那样的图形用户界面。使用 CURL，HTTP 标头作为命令行参数传递。以下是调用列表引擎端点的 CURL 命令示例：

py 复制代码 
curl https://api.openai.com/v1/engines \
  -H 'Authorization: Bearer {your-api-key}' \
  -H 'OpenAI-Organization: {your-orgainzation-id}'

在替换 {your-api-key} 占位符和 {your-organization-id} 占位符之后，这条命令将返回类似下面截图中所示的结果：

图 4.16 -- 使用 CURL 调用列表引擎端点

现在您知道如何进行对 OpenAI API 的身份验证调用，让我们花点时间来谈谈 JSON，这是 OpenAI API 使用的数据交换格式。

介绍 JSON

在本节中，我们将快速介绍 JSON。JSON 是一种流行的数据交换格式，它轻量级，易于机器解析，也易于人类阅读。

JSON 语法基于 JavaScript 编程语言的子集，它定义了两种数据结构：

  • 名称/值对的集合

  • 有序值列表

这两种数据结构在现代几乎所有编程语言中都以某种方式得到支持。因此，尽管 JSON 语法基于 JavaScript 的子集，但也可以轻松地与其他语言一起使用。

JSON 中的两种数据结构分别定义为对象或数组。对象以左大括号开头，以右大括号结束。一个空对象看起来像下面的示例：

py 复制代码 
{}

对象可以包含一组名称/值对，称为元素。对象中的元素不需要按任何特定顺序排列，值可以是字符串（用双引号括起来）、数字、true 或 false、null、另一个对象或数组。元素名称和值之间用冒号分隔，元素本身用逗号分隔。以下代码块是来自 OpenAI API 响应的 JSON 对象示例。您会注意到它以大括号开头和结束，并包含具有名称和值的不同元素。请注意，"choices" 元素的值包含以左方括号开头和以右方括号结尾的值 - 那是一个数组：

py 复制代码 
{
    "id": "cmpl-2T0IrOkctsOm8uVFvDDEmc1712U9R",
    "object": "text_completion",
    "created": 1613265353,
    "model": "davinci:2020-05-03",
    "choices": [
        {
            "text": ", there was a dog",
            "index": 0,
            "logprobs": null,
            "finish_reason": "length"
        }
    ]
}

一个数组是一组有序的值。这些值可以是一组字符串、数字、true 或 false 值、null 值、对象或其他数组。数组始终以左方括号开头，以右方括号结尾，值之间用逗号分隔。

在前面的示例对象中，"choices" 元素的值是一个包含一个对象的数组。该对象包含带有值的元素（text、index、logprobs、finish_reason）。因此，对象和数组可以嵌套。

关于 JSON 的最后一点是，文本的格式，诸如空格、制表符和换行符，是为了人类可读性而做的，但并不是机器所必需的。因此，只要语法有效，它就可以在代码中使用。

例如，以下两个 JSON 对象是相同的，且都是有效的：

例 1：

py 复制代码 
{"question":"Is this correct? ","answer":"Yes"}

例 2：

py 复制代码 
{
    "question" : "Is this correct?",
    "answer" : "Yes"
}

如本节前面提到的，OpenAI API 使用 JSON 在客户端和服务器之间发送和接收数据。本节的介绍应该足以开始使用 OpenAI API，但要了解更多关于 JSON 的信息，您也可以访问 www.json.org/。

到目前为止，您已经学会了开始使用主要的 OpenAI API 端点 - Completions 端点所需的所有内容。所以，接下来让我们深入了解一下。

使用 Completions 端点

当你使用 OpenAI API 时，你大部分时间可能会涉及到使用 Completions 端点。这是你发送提示的端点。除了提交你的提示外，你还可以包含值来影响完成的生成，就像 Playground 中的设置一样。

使用 Completions 端点比我们在上一节介绍 JSON 中看到的 List Engines 端点更加复杂。这是因为 Completions 端点使用 HTTP POST 方法，并且需要一个 JSON 对象作为正文。从技术上讲，JSON 正文可以只是一个空对象（就像 {} 一样），但至少，你会想至少包含 prompt 元素，并将其值设置为你的 prompt 字符串，例如以下的 JSON 示例:

py 复制代码 
{"prompt": "Once upon a time"}

前面的例子是一个简单的例子，但这是我们如何使用 Postman 提交它。假设授权如前一节所讨论的设置，从 Postman 完成调用 Completions 端点有五个步骤。这些步骤如下:

  1. 将请求类型设置为POST。

  2. 输入 https://api.openai.com/v1/engines/davinci/completions 作为端点。

  3. 将正文设置为raw。

  4. 选择JSON作为正文内容类型。

  5. 输入 {"prompt": "Once upon a time"} 作为 JSON 正文文本。

    下面的屏幕截图标签显示了每个步骤的完成位置：

图 4.17 - Completions 终端的 Postman 设置

点击Send按钮后，我们得到了 Completions 端点的响应，如下面的屏幕截图所示:

图 4.18 - Completions 终端的 Postman 响应

默认情况下，Postman 将使用Pretty 设置来显示 JSON 响应，使其对人类查看友好。但是，如果切换到Raw设置，你将看到响应实际上是如何发送的，正如下面的屏幕截图所示：

图 4.19 - Completions 终端的 Postman 响应 -- Raw

前面的例子是一个简单的例子，只有一个请求参数 - prompt。然而，端点接受许多其他类似于 Playground 设置的额外参数。为了在请求中包含其他参数，这些参数被包含为 JSON 正文对象中的元素。例如，要发送提示并限制返回的标记数（就像 Playground 中的响应长度设置一样），我们可以包含 max_tokens 参数，如下面的屏幕截图所示:

图 4.20 - Completions 终端的 Postman 响应含有 max_tokens

注意，为了包含max_tokens参数和值，一个新的max_tokens元素被添加到 JSON 主体对象中，并且与"prompt"元素用逗号分隔。其他参数会以相同的方式添加。

可以在 beta.openai.com/docs/api-reference/create-completion 找到所有可用参数的列表，我们这里不会全部涵盖。然而，大多数参数在 Playground 中都有对应的设置，我们在第三章 ，使用 OpenAI Playground 中已经介绍过，所以它们对你来说应该是熟悉的。

在我们继续之前，让我们看看另一个例子，一个你无法从 Playground 中完成的例子。在这个例子中，我们将同时提交多个提示，并针对每个提示返回一个完成。我们将使用以下 JSON：

py 复制代码 
{
  "prompt": ["The capital of California is:", "Once upon a time"],
  "max_tokens":7,
  "temperature": 0,
  "stop": "\n"
}

注意"prompt"元素的值是一个 JSON 数组，包含两个值，"加利福尼亚的首府是：", 和 "从前有一只"。通过发送提示的数组，完成端点将为每个提示返回完成，如下面的截图所示：

图 4.21 -- 发送多个提示

从这个例子中得出的主要结论是，有一些事情你可以通过 API 做到，但在 Playground 中做不到。因此，了解如何使用 OpenAI API 使你能够超越 Playground 的功能。

API 中可以做但 Playground 中无法做的另一个例子是语义搜索。下面我们来看看这个。

使用语义搜索端点

在第二章 ，GPT-3 应用与用例中，我们讨论了语义搜索。简单回顾一下，语义搜索让你可以在提供的文档列表上执行类似 Google 的搜索。一个查询（一个词、短语、问题或语句）会与文档内容进行比较，以确定是否存在语义相似性。结果是每个文档的排名或得分。得分通常介于 0 和 300 之间，但有时会更高。一个更高的分数，超过 200，通常意味着文档在语义上与查询相似。

要使用 API 进行语义搜索，您需要向语义搜索端点发出 POST 请求。 就像创建补全端点一样，在请求主体中还需要包含一个 JSON 对象。 JSON 主体对象有两个元素-文档元素和查询元素。 文档元素是要搜索的文档数组，数组中的每个项目都是表示文档的字符串。 或者，可以在请求中引用预先上传的文件中提供的文档。 在第九章 ，构建一个 GPT-3 驱动的问答应用程序，我们将详细讨论如何使用文件。 然而，现在我们将重点放在通过端点请求提供文档。

一个文档可以是单词，句子，段落或更长的文本。 查询元素的值是包含将与文档进行搜索的搜索词或短语的字符串。 这可能是类似问题或陈述的一些东西。

再次，语义搜索根据其在语义上与一个或多个文档的相似性来对查询进行排名。 因此，这不一定是搜索相似单词。 例如，以下 JSON 对象提供了车辆（飞机，船，宇宙飞船或汽车）的列表作为文档，查询为"带轮子的车辆"：

py 复制代码 
{
  "documents": [
    "plane",
    "boat",
    "spaceship",
    "car"
  ],
  "query": "A vehicle with wheels"
}

让我们看看上述 JSON 的结果会是什么样子。 我们将使用 Postman。 请记住，所有 OpenAI API 端点都需要授权，因此在 Postman 中，我们首先确保适当的授权设置得以展开。 从那里开始，步骤与发出对补全端点的请求是一样的：

  1. 将请求类型设置为POST。

  2. 输入URI端点。

  3. 将主体设置为原始。

  4. 选择JSON作为主体内容类型。

  5. 输入 JSON 主体。

语义搜索端点 URI 是 https://api.openai.com/v1/engines/{engine_id}/search，其中 {engine_id} 被有效的引擎 ID（如 davinci 或 ada）替换。 在 Postman 中设置并提交 API 调用后，您应该看到类似以下截图的结果：

图 4.22 -- 语义搜索结果

语义搜索端点返回的 JSON 对象包含三个元素：对象，数据和引擎。 数据元素的值是结果的 JSON 数组-每个文档的一个项目。 从我们之前对 JSON 的介绍中回忆，数组中的项目是有序的，意味着每个项目都可以用数字引用，第一个从零开始。 因此，在我们的例子中，以下值会适用：

  • 0 = 飞机

  • 1 = 船

  • 2 = 太空船

  • 3 = 汽车

知道每个文档都与一个数字值相关联后，当您查看从搜索 API 返回的以下结果时，您会发现文档 3（汽车）获得了最高分，因此代表了与语义最相似的文档：

py 复制代码 
{
    "object": "list",
    "data": [
        {
            "object": "search_result",
            "document": 0,
            "score": 56.118
        },
        {
            "object": "search_result",
            "document": 1,
            "score": 46.883
        },
        {
            "object": "search_result",
            "document": 2,
            "score": 94.42
        },
        {
            "object": "search_result",
            "document": 3,
            "score": 178.947
        }
    ],
    "model": "davinci:2020-05-03"
}

数据数组中包含的是文档号而不是文档本身，因为文档本身可能是一长串文本，使用文档号更有效。因此，在匹配返回的结果与发送的文档时，您需要使用文档号。但当您使用代码进行操作时，这相对直接 -- 这也是我们将在下一章开始的内容。

总结

在本章中，我们讨论了如何使用 OpenAI API。我们从介绍/回顾 API 是什么开始，然后熟悉了 HTTP 协议的基础知识。我们审查了 OpenAI API 的端点，并涵盖了如何使用 OpenAI API 密钥进行基本身份验证以访问 API，以及如何对具有对多个组织访问权限的帐户进行身份验证。然后，我们了解了 JSON 数据交换格式，然后学习了如何使用 Postman 对 Completions 端点、Engines 端点和 Semantic Search 端点进行 API 调用。

在下一章，我们将把本章学到的知识付诸实践，深入了解如何使用代码调用 API。

第五章：在代码中调用 OpenAI API

在上一章中，我们看了一下如何使用 Postman 调用 OpenAI API。在这一章中，你将学习如何在代码中开始使用 API。因为 OpenAI API 几乎可以与任何编程语言一起使用，我们将看一下两种流行的语言，JavaScript 和 Python。如果你不是程序员，没问题。我们将使用一个在线环境，让入门编程变得非常简单。而且，JavaScript 和 Python 都提供了易于跟随的代码示例，因此你可以选择最适合你的语言。此外，为了清晰起见，示例故意尽可能少地写代码。因此，示例可能并不总是遵循编码最佳实践，但目标是使跟随变得更容易！

本章将涵盖以下主题：

  • 选择编程语言

  • 介绍 replit.com

  • 使用 Node.js/JavaScript 使用 OpenAI API

  • 使用 Python 使用 OpenAI API

  • 使用其他编程语言

技术要求

本章需要你可以访问OpenAI API 。你可以通过访问以下网址请求访问权限：openai.com。

选择编程语言

OpenAI API 是一个基于标准的 API，可用于几乎任何现代编程语言。在本章中，我们将介绍 JavaScript 和 Python 的例子。但这只是众多可用语言中的两种。选择 JavaScript 和 Python 是因为它们都非常受欢迎且易于上手。如果你精通其他现代编程语言，那可能是最好的选择。但如果你是新手，或者你的编程技能有些生疏，或者想尝试一种新语言，那么 JavaScript 和 Python 都是很好的选择。但是每种语言的例子都是相同的，只是编程语言不同。因此，你可以跳到你偏好的语言部分。或者，如果你感到有冒险精神，当然你可以尝试两种语言！

介绍 replit

在本章以及接下来的章节中，我们将会编写代码。因此，我们需要某种代码编辑器。就像编程语言一样，当涉及到代码编辑器时，有很多选择。选择正确的代码编辑器是一个个人偏好和观点问题。对于我们的例子，我们将使用来自replit.com的在线代码编辑器。

虽然我们将要讨论的所有示例都可以在任何代码编辑器中完成，但 replit 可以让我们跳过安装和软件设置过程，因为我们可以在网页浏览器中完成所有操作。

此外，使用代码编辑器时，需要在本地计算机上进行一些设置。例如，JavaScript 和 Python 都需要安装运行环境。我们会跳过这些，这样就能更多时间专注于学习 GPT-3 和 OpenAI API。

那么，replit.com 是什么？它是一个基于浏览器的代码编辑器和集成开发环境（IDE），让你可以在 50 多种编程语言中开始编码，而无需花费时间设置本地开发环境。所以，对于我们的示例，即使你的本地计算机没有设置好运行 Node.js 或 Python 的环境，你也可以立即开始编码。

下面的截图展示了 replit 的主页，如果你还没有，则可以在这里免费注册一个 replit 账户：

��5.1 -- replit 主页

创建一个账户只需要点击注册按钮并完成注册过程。在本书的示例中，你只需要一个免费账户。

在你注册完后，你将登录到默认的主页，如图 5.2所示：

图 5.2 -- Replit 默认主页

从这里，我们将创建两个代码项目，它们在 replit 中被称为repl。

创建一个 repl

我们将会查看 JavaScript 和 Python 的代码示例。所以，我们需要分别为两种语言设置 repl。对于 JavaScript，我们将会使用Node.js （或者简称为 Node），它是 JavaScript 的运行环境。我们会在使用 Node.js/JavaScript 调用 OpenAI API部分详细讨论 Node.js。首先，我们会创建一个 Python 的 repl。然后，再创建一个 Node.js/JavaScript 的 repl。

为 Python 创建一个 repl

让我们从为 Python 创建一个新的 repl 开始。如果你更喜欢只使用 Node.js/JavaScript 进行示例，你可以直接跳到为 Node.js 创建一个 repl。

从主页，点击**+ New Repl**按钮：

  1. 从 repl 类型下拉菜单中选择 Python。

  2. 将 repl 命名为 exploring-gpt3-python。

  3. 点击创建 repl按钮。

接下来，我们将为 Node.js 创建一个 repl。如果你只会使用 Python，你可以跳过下一部分。

为 Node.js 创建一个 repl

如果你跟着做 Node.js 实例，你将需要一个 Node repl。要创建一个 Node repl，按照以下步骤。从主页，点击**+ New Repl**按钮：

  1. 从 repl 类型下拉菜单中选择 Node.js。

  2. 将 repl 命名为 exploring-gpt3-node。

  3. 点击创建 repl按钮。

下面的截图展示了为 Python 创建一个新的 repl。同样的，对于 JavaScript，你会选择 Node.js 而不是 Python，然后将 repl 命名为 exploring-gpt3-node：

图 5.3 -- 设置 Python 的 repl

创建完 repl 后，你会自动被重定向到 replit 编辑器，里面已经加载了你的新 repl。编辑器分为三个窗格：导航 窗格、代码编辑 窗格和输出窗格。新的 repl 包括一个默认文件，当你第一次访问 repl 时会在代码编辑器（中间窗格）打开。

对于 Python 项目， 默认文件命名为main.py; 对于 Node.js 项目，默认文件命名为index.js。以下屏幕截图显示了在编辑器窗格中打开的main.py的 replit 编辑器。Node.js repl 看起来相同，但默认文件名为index.js而不是main.py：

图 5.4 - 具有默认 Python repl 的 Replit 编辑器

默认文件是默认情况下在单击Run按钮时运行的代码文件。运行按钮位于位于三个编辑窗格正上方的顶部导航栏中间。然后，在 replit 控制台 - 右侧的输出窗格中显示代码的结果或输出。

重要提示

默认文件在首次创建 repl 时为空，因此单击Run按钮不会执行任何操作，直到您编写一些代码为止。

在三个编辑窗格的上方导航栏左侧是一个汉堡菜单（看起来像是叠在一起的线条的图标）。如果您点击该图标，则会显示主导航选项。您可以使用此菜单通过选择我的 repls菜单并选择要打开的 repl 来在 repl 之间导航。

以下屏幕截图显示了选定了我的 repls选项的主菜单：

图 5.5 - 访问主导航菜单

为您想要使用的语言创建 repl（或两种语言），您将需要将您的 OpenAI API 密钥存储为环境变量。

将您的 OpenAI API 密钥设置为环境变量

环境变量是可以在代码中访问但不会与其他人共享的命名值。通常，您使用环境变量来设置私有或特定于用户的参数值，例如，您的 OpenAI API 密钥。

在 replit 中，您可以通过单击导航窗格中的挂锁图标（Secrets ）并添加名称和值对来保存环境变量。您需要为您正在使用的每个 repl 进行此操作 - 因此，在您的exploring-gpt3-node repl 和/或exploring-gpt3-python repl 中的一个中都需要这样做。要将您的 OpenAI API 密钥添加为环境变量，请执行以下操作：

  1. 打开您的 repl。

  2. 单击导航窗格中间的挂锁图标（Secrets ），如下面的屏幕截图所示：

    图 5.6 - 在 Replit 中添加新的秘密/环境变量

  3. 在OPENAI_API_KEY中。

  4. 在Value输入文本区域中，粘贴您的 OpenAI API。

  5. 单击Add new secret按钮。

同样，如果您要跟随 Node.js 和 Python 进行操作，则需要向每个 repl 添加OPENAI_API_KEY秘密/环境变量。因此，如果您同时跟随两者，您将完成上述步骤两次。

重要提示

如果您使用的是 replit.com 的免费版本，默认情况下，您的代码将是公开的。但是，secrets/environment variables 不会被公开共享，但可以被明确邀请到 repl 的合作人员看到。这很重要，因为您不希望共享或意外暴露您的 OpenAI API 密钥。要了解更多关于在 replit 中使用秘密和环境变量的信息，访问docs.replit.com/repls/secret-keys。

在开始编码之前，我们需要创建一个特殊的文件，即.replit文件。

理解并创建.replit文件。

在 replit 中，默认情况下，当您单击时，main.py 文件将为 Python repl 运行，index.js 文件将为 Node.js repl 运行。但是，您可以创建一个名为.replit的文件，并更改由.replit文件执行的代码文件。要创建.replit文件，请执行以下操作：

  1. 打开您的 repl。

  2. 单击导航窗格右上角的添加文件图标。

  3. 将文件命名为.replit。

  4. 将以下文本添加到.replit文件的第一行中：

    对于 Python repl：

    py 复制代码 
    run = "python main.py"

    对于 Node.js repl：

    py 复制代码 
    run = "node index.js"

您可能已经注意到，我们刚刚添加了要按默认方式运行的文件的说明。现在没问题，稍后我们将回来编辑我们.replit文件中的run语句。

当您为 Node.js 或 Python 创建 repl，并将您的 OpenAI API 密钥添加为环境变量，并添加一个.replit文件后，您就可以开始编码了。因此，在下一节中，我们将看一下使用 Node.js/JavaScript 的示例。但是，如果您只是在 Python 方面跟着做，您可以直接跳到在 Python 中使用 OpenAI API。

使用 Node.js/JavaScript 调用 OpenAI API

JavaScript 是我们要看的第一种编程语言。JavaScript 最初是为在网页上编写脚本功能而创建的。然而，如今，JavaScript 可以用于几乎任何类型的应用程序开发，从构建网站和移动应用程序到创建命令行工具、聊天机器人和语音助手 - 这一切都归功于 Node。如前所述，Node 是 JavaScript 的运行时环境。它使我们能够在网页浏览器之外使用 JavaScript。

JavaScript 和 Node.js 都是免费使用的，并且可以在 Linux、macOS 和 Windows 操作系统上运行。但我们不会安装 Node.js，也不会在本地运行任何东西，因为我们所有的代码都将在 replit 上运行。但是，我们将编写的代码中没有任何与 replit 有关的依赖。因此，我们将要做的所有事情都可以在任何为 Node 开发正确配置的环境中完成。

好了，让我们开始编码。为了在 Node 中使用 OpenAI API，我们基本上只需做和第四章 ，与 OpenAI API 一起工作一样的步骤 -- 对 OpenAI API 端点进行身份验证的 HTTP 请求。但是我们不会使用 Postman，而是会使用 JavaScript 进行 HTTP 请求。我们将从最简单的例子开始 -- 调用 engines 端点。

调用 engines 端点

我们将首先设置一个新的文件夹来进行本章的工作。然后，我们将添加一个文件作为我们第一个示例，并更新 .replit 文件，以便 replit Run 按钮执行我们的新文件。以下是要遵循的步骤：

  1. 打开您的exploring-gpt3-node repl。

  2. 点击导航窗格右上角的添加文件夹图标。

  3. 命名文件夹为 chapter05。

  4. 选择 chapter05 文件夹，然后单击 engines.js。

  5. 编辑 .replit 文件，使 chapter05/engines.js 使用以下文本：

    py 复制代码 
    run = "node chapter05/engines.js"

  6. 现在，通过单击导航窗格中的文件名来打开您的 replit 编辑器中的 chapter05/engines.js 文件。您的 replit 编辑器应该看起来类似以下屏幕截图：

    图 5.7 -- 在 Replit 编辑器中编辑 engines.js

  7. 现在，我们要编写一些代码调用 https://api.openai.com/v1/engines。有许多种方式可以使用 Node 和 JavaScript 进行 HTTP 请求。我们不会详细介绍所有不同选项或一个方法优于另一个方法的优点和缺点。我们只会使用一个流行的代码库（称为 axios）。

    重要提示

    Node.js 中打包和共享的代码库在大多数现代编程语言中都很常见。在 Node.js 中，包（或模块）最常使用一个名为 npm 的包管理器共享。要了解更多关于 npm 的信息，您可以访问 npmjs.com。replit 自动管理 Node.js 项目的包依赖关系。但是，在本地开发环境中，通常使用 Npm 命令行工具来管理代码中使用的包。

  8. 简而言之，axios 模块最大程度地减少了我们使用 JavaScript 进行 HTTP 请求时需要编写的代码。因此，我们将在我们的 engines.js 文件的第一行包含对 axios 模块的引用，代码如下：

    py 复制代码 
    const axios = require('axios);

  9. 你会记得第四章 , 与 OpenAI API 一起工作，所有 OpenAI API 端点都需要授权。因此，在下一行，我们将添加一个变量来保存我们的 OpenAI API 密钥。但是，我们不会硬编码数值，而是从我们设置的环境变量中获取：

    py 复制代码 
    const apiKey = process.env.OPENAI_API_KEY;

  10. 接下来，我们将创建一个内部 HTTP 客户端来进行请求。axios 模块使这变得非常简单。为了创建 HTTP 客户端实例，我们将添加以下代码：

    py 复制代码 
    const client = axios.create({
    headers: { 'Authorization': 'Bearer ' + apiKey }
});

    请注意，在上述代码中，我们添加了一个使用我们的 OpenAI API 密钥作为令牌的 HTTP Authorization头。这样，axios客户端可以对 API 端点进行身份验证请求。现在剩下的只是实际发出请求的代码。以下是该代码的样子：

    py 复制代码 
    client.get('https://api.openai.com/v1/engines')
  .then(result => {
    console.log(result.data);
}).catch(err => {
    console.log(err.message);
});

    在上述代码中，我们使用axios客户端实例向https://api.openai.com/v1/engines端点发出 GET 请求。然后，我们将从端点返回的结果记录到控制台中。或者，在出现错误时，我们将错误消息记录到控制台中。

  11. 此时，您应该能够在 replit 中单击运行按钮，并在 replit 控制台中看到结果，在那里会有一个如下所示的输出：

图 5.8 -- 运行 engines.js 代码的结果

因此，我们使用了 12 行代码（实际上是 11 行，因为有一行是空的），我们使用 JavaScript 和 Node 进行了我们的第一个 API 请求。

现在让我们看看如何调用 Completions 端点。这个稍微复杂一些，因为我们需要向端点发送数据。但是，代码仍然非常简单。

调用 Completions 端点

现在我们将看看如何调用完成端点。我们将首先在chapter05文件夹中创建一个名为completions.js的新文件，并编辑我们的.replit文件，以便运行按钮将执行我们的新文件。要做到这一点，请按照以下步骤操作：

  1. 打开您的exploring-gpt3-node repl。

  2. 在导航窗格中选择chapter05文件夹。

  3. 单击completions.js。

  4. 编辑.replit文件，以便使用以下文本chapter05/completions.js：

    py 复制代码 
    run = "node chapter05/completions.js"

  5. 接下来，将chapter05/engines.js中的前五行代码复制到chapter05/completions.js中，以便您的completions.js文件以以下代码开始：

    py 复制代码 
    const axios = require('axios');
const apiKey = process.env.OPENAI_API_KEY;
const client = axios.create({
    headers: { 'Authorization': 'Bearer ' + apiKey }
});

    对于 Completions 端点，我们将发送参数。因此，我们接下来要做的是添加将成为 HTTP 正文中发送的 JSON 对象。请回想一下第四章 ，使用 OpenAI API ，Completions 端点接受许多参数。但是，对于本示例，我们只发送prompt参数和max_tokens参数。以下是代码的样子：

    py 复制代码 
    const completionParams = {
  "prompt": "Once upon a time", 
  "max_tokens": 10
}

    现在我们只需实际发出请求。这一次我们将进行 HTTP POST 请求并传递参数。因此，代码与上一个示例略有不同，但看起来像这样：

    py 复制代码 
    client.post('https://api.openai.com/v1/engines/davinci/completions', completionParams)
  .then(result => {
  console.log(result.data);
}).catch(err => {
  console.log(err);
});

    就这样。现在当您在 replit 中单击运行按钮时，您应该会从 Completions 端点收到一个类似以下截图的结果：

图 5.9 -- Completions.js 的输出

正如我们在第四章 中所讨论的，使用 OpenAI API ，从端点返回的响应是以 JSON 格式返回的。但是，如果您想要格式化输出，您可以从 JSON 中提取您想要显示的内容。例如，您可以使用以下代码更新console.log(result.data)以显示 API 返回的原始提示文本从前，有一只...和完成文本：

py 复制代码 
console.log(completionParams.prompt + result.data.choices[0].text);

如果您进行了更改并再次运行代码，则输出将类似于以下截图中的输出：

图 5.10 -- 来自 completions.js 的格式化结果

仅仅通过两个示例，我们就介绍了您需要使用所有 OpenAI 端点的基本代码。但在我们继续之前，让我们看一看使用搜索端点的另一个示例。

调用搜索端点

对于我们的搜索示例，我们将在chapter05文件夹中创建一个名为search.js的新文件，并编辑我们的.replit文件，以便chapter05/search.js。要实现这一点，请按照以下步骤进行：

  1. 打开您的exploring-gpt3-node repl。

  2. 在导航窗格中选择chapter05文件夹。

  3. 点击search.js。

  4. 编辑.replit文件，使chapter05/search.js使用以下run命令：

    py 复制代码 
    run = "node chapter05/completions.js"

  5. 接下来，将chapter05/engines.js中的前五行代码复制到chapter05/search.js中，使您的search.js文件以以下代码开始：

    py 复制代码 
    const axios = require('axios');
const apiKey = process.env.OPENAI_API_KEY;
const client = axios.create({
    headers: { 'Authorization': 'Bearer ' + apiKey }
});

  6. 对于搜索端点，我们将发送参数。因此，接下来我们将添加即将发送到 HTTP 主体中的 JSON 对象。在第四章中，我们讨论了搜索端点的参数，但以下是我们将在此示例中使用的代码：

    py 复制代码 
    const data = {
  "documents": ["plane", "boat", "spaceship", "car"],
  "query": "A vehicle with wheels"
}

  7. 剩下的就是实际发出请求。就像完成示例一样，我们将进行 HTTP POST 并传递我们的参数：

    py 复制代码 
    client.post('https://api.openai.com/v1/engines/davinci/search', data)
  .then(result => {
    console.log(result.data);
  }).catch(err => {
    console.log(err);
  });

  8. 就这样。现在，当您在 replit 中点击运行按钮时，您应该会从搜索端点获得类似以下截图的结果：

图 5.11 -- 来自 search.js 的结果

我们在本节中讨论的所有 JavaScript 示例都相当简单。但是，它们应该给您一个使用 JavaScript 和 Node.js 开始调用 OpenAI API 的一般思路，这正是我们的目标。在接下来的章节中，我们将更深入地讨论，但现在我们将转向我们的下一个语言--Python。

使用 Python 中的 OpenAI API

Python 是另一种流行的编程语言，在机器学习社区中尤其受欢迎。 这是一种强大的语言，但也非常适合初学者。 如果你是第一次编程，那么 Python 可能是最容易入门的语言之一。 与 JavaScript/Node 一样，Python 是开源的，可以在 Linux、macOS 或 Windows 上使用。 它还包含在许多操作系统中，包括 macOS 和大多数 Linux 发行版。 但由于我们将在 replit 中工作，所以不需要担心 Python 是否安装在我们的本地机器上。 也就是说，我们将要编写的代码中没有任何依赖于 replit 特定内容的地方。 因此，我们将在任何正确配置用于 Python 开发的计算机上完成所有工作。

对于我们的第一个示例，我们将看一下如何使用 Python 调用 OpenAI Engines 端点。

调用 engines 端点

我们将通过为本章中即将开发的 Python 代码设置一个新文件夹开始。 然后，我们将添加一个文件作为我们的第一个示例，并更新.replit文件，以便 replit Run 按钮可执行我们的新文件。 应按照以下步骤操作：

  1. 打开你的exploring-gpt3-python replit。

  2. 点击导航窗格右上角的添加文件夹图标。

  3. 将文件夹命名为chapter05。

  4. 选择chapter05文件夹，然后点击engines.py。

  5. 编辑.replit文件，使得chapter05/engines.py使用以下文本：

    py 复制代码 
    run = "python chapter05/engines.py"

  6. 现在，通过导航窗格中点击文件名，在 replit 编辑器中打开chapter05/engines.py文件。 您的 replit 编辑器应该看起来类似于以下截图：

    图 5.12 -- 在 Replit 编辑器中编辑 engines.py

  7. 现在，我们将编写一些 Python 代码，以向https://api.openai.com/v1/engines端点发出 HTTP 请求。 有许多方法可以使用 Python 发出 HTTP 请求。 我们不会深入探讨所有不同的选项，或者一种方法胜过另一种方法的利弊。 我们只是将使用流行的requests库。

    重要提示

    包装和共享的代码库在大多数现代编程语言中很常见。 在 Python 中，包（或库）通常使用一个名为 PIP 的软件包管理器进行共享。 要了解有关 PIP 的更多信息，您可以访问pypi.org/project/pip/。 replit 自动管理 Python 项目的软件包依赖关系。 但是，在本地开发环境中，常用的是使用 PIP 命令行工具来管理 Python 包。

  8. 简而言之，requests库最大程度地减少了我们需要编写的代码，以使用 Python 进行 HTTP 请求。 因此，我们将在我们的engines.py文件的第一行包含对requests库的引用，代码如下所示：

    py 复制代码 
    import requests

  9. 你可能还记得第四章 ，使用 OpenAI API ，OpenAI API 的所有端点都需要授权。所以下一步我们将添加一些代码来获取我们在.env文件中设置的 API 密钥，并将其保存到一个变量中。我们将使用以下行来做到这一点：

    py 复制代码 
    import os
apiKey = os.environ.get("OPENAI_API_KEY")

  10. 接下来，我们将创建一个名为headers的变量来保存我们的授权信息，这些信息将被用于发起 HTTP 请求：

    py 复制代码 
    headers = {
    'Authorization':'Bearer ' + apiKey
    }

  11. 现在我们所需要做的就是发起请求。我们将使用以下代码来做到这一点，并将响应保存到一个名为result的变量中：

    py 复制代码 
    result = requests.get('https://api.openai.com/v1/engines'
,headers=headers)

  12. 为了在控制台中显示 JSON 结果，我们将添加最后一行，如下所示：

    py 复制代码 
    print(result.json())

  13. 在这一点上，你应该能够在 replit 中点击Run按钮，在 replit 控制台中看到结果，并看到一个类似以下截图的输出：

图 5.13 -- 运行 engines.py 代码的结果

所以，用 12 行代码（实际上是 9 行，因为有三行是空白行），我们已经使用 Python 发起了我们的第一个 API 请求。现在让我们来看一下调用 Completions 端点。这个端点需要更多的代码，因为我们需要向端点发送数据。但正如你将看到的，这还是相当简单的。

调用 completions 端点

我们将从在chapter05文件夹中创建一个名为completions.py的新文件开始。然后我们将编辑我们的.replit文件，使chapter05/completions.py。要做到这一点，请按照以下步骤操作：

  1. 打开你的exploring-gpt3-python repl。

  2. 在导航窗格中选择chapter05文件夹。

  3. 点击completions.py。

  4. 编辑.replit文件，使chapter05/completions.py使用以下文本：

    py 复制代码 
    run = "python chapter05/completions.py"

  5. 接下来，我们将添加以下代码。它与chapter05/engines.py中的起始代码非常相似，但我们需要添加json库和Content-Type头。所以，你的completions.py文件应该以以下代码开头：

    py 复制代码 
    import requests
import os
import json
apiKey = os.environ.get("OPENAI_API_KEY")
headers = {
    'Content-Type': 'application/json',
    'Authorization':'Bearer ' + apiKey
    }

  6. 对于 completions 端点，我们将发送参数。所以下一步我们要做的就是添加即将成为发送到 HTTP 主体的 JSON 对象。回想一下第四章 ，使用 OpenAI API ，completions 端点接受许多参数。但是对于这个示例，我们只会发送prompt参数和max_tokens参数。代码如下所示：

    py 复制代码 
    data = json.dumps({
    "prompt":"Once upon a time",
    "max_tokens":15
    })

    为了使代码更易读，我们还将使用以下代码创建一个端点 URL 的变量：

    py 复制代码 
    url = 'https://api.openai.com/v1/engines/davinci/completions'

  7. 唯一剩下的就是实际发起请求并打印出结果。这次，我们将进行 HTTP POST，并传递我们的参数。所以，代码与上一个示例略有不同，但看起来像这样：

    py 复制代码 
    result = requests.post(url,headers=headers,data=data)
print(result.json())

  8. 就这样。现在当你点击 replit 中的Run 按钮时，你应该会从 completions 端点得到一个结果，类似于以下截图所示：

    图 5.14 -- completions.js 的输出

  9. 正如我们在Chapter 4 中讨论的，使用 OpenAI API ，从端点返回的响应是 JSON 格式的。但是如果你想格式化输出，你可以从 JSON 中提取你想要显示的内容。例如，你可以使用以下代码更新 console.log(result.data)，以显示 API 返回的原始提示文本 Once upon a time 和完成文本：

    py 复制代码 
    console.log(completionParams.prompt + result.data.choices[0].text);

  10. 如果您进行了这些更改并再次运行代码，则控制台输出应该与以下截图中的输出类似：

图 5.15 -- completions.py 的格式化结果

好的，让我们看一个更多的例子。这次我们将使用 Python 调用搜索端点。

调用搜索端点

对于我们的搜索示例，我们将在 chapter05 文件夹中创建一个名为 search.py 的新文件，并且我们将编辑我们的 .replit 文件，以便 chapter05/search.py。要做到这一点，请按照以下步骤进行：

  1. 打开你的 exploring-gpt3-python repl。

  2. 在导航面板中选择 chapter05 文件夹。

  3. 点击 search.py。

  4. 编辑 .replit 文件，使运行按钮执行 chapter05/search.py，使用以下 run 命令：

    py 复制代码 
    run = "python chapter05/search.py"

  5. 接下来，将 chapter05/completions.py 中的前九行代码复制到 chapter05/search.py 中，这样你的 search.py 文件将以以下代码开头：

    py 复制代码 
    import requests
import os
import json
apiKey = os.environ.get("OPENAI_API_KEY")
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer ' + apiKey
}

  6. 对于搜索端点，我们将像在 chapter05/completions.py 中那样发送参数。所以，我们接下来要做的就是添加将成为 HTTP 正文中发送的 JSON 对象。在Chapter 4 中，使用 OpenAI API，我们涵盖了搜索端点的参数，我们将使用相同的示例 -- 这是我们将使用的代码：

    py 复制代码 
    data = json.dumps({
    "documents": ["plane", "boat", "spaceship", "car"],
    "query": "A vehicle with wheels"
})

  7. 我们将添加一个变量来存储端点 URL，以便代码更容易阅读一些：

    py 复制代码 
    url = 'https://api.openai.com/v1/engines/davinci/search'

  8. 最后，我们将添加代码来发起请求并打印结果：

    py 复制代码 
    result = requests.post(url, headers=headers, data=data)
print(result.json())

  9. 就这样。现在，当你点击 replit 中的 Run 按钮时，你应该会从完成端点得到一个类似以下截图的结果：

图 5.16 -- search.py 的结果

本节的目标是提供一些简单的 Python 示例，调用 OpenAI API。到目前为止，我们已经涵盖了基础知识，但在接下来的章节中，我们将看到更深入的例子。

使用其他编程语言

在本章中，我们只看了使用 JavaScript 和 Python 的代码示例。但再次强调，几乎任何现代编程语言都可以使用。OpenAI API 是一个基于标准的 HTTP API，所以你只需要一种能够发起 HTTP 请求并处理 JSON 的语言，而这几乎包括所有现代编程语言。

此外，在本章的示例中，我们直接使用通用的 HTTP 库调用 API。我们也可以使用专为 OpenAI API 构建的库。JavaScript、Python 和其他语言包括 C#/.NET、Go、Java 和 Unity 都存在多个库。您可以在beta.openai.com/docs/developer-quickstart/community-libraries找到社区维护的库列表。

库可以简化与 OpenAI API 的使用。然而，了解如何直接调用端点以及 API 的使用相当简单是很有帮助的。出于这些原因，我们将在本书的所有示例中直接使用 API。

总结

在本章中，我们在代码中使用了 OpenAI API。我们首先介绍了在浏览器中使用的集成开发环境 replit。然后，我们看了一下调用引擎端点、完成端点和搜索端点的代码示例，使用了 Node.js/JavaScript 和 Python。最后，我们讨论了其他可以使用的语言和可以简化与 OpenAI API 集成工作的库。

在下一章中，我们将讨论内容过滤，并查看使用 JavaScript 和 Python 实现内容过滤的代码示例。

相关推荐
古希腊掌管学习的神39 分钟前
[机器学习]XGBoost（3）——确定树的结构
人工智能·机器学习
ZHOU_WUYI1 小时前
4.metagpt中的软件公司智能体 (ProjectManager 角色)
人工智能·metagpt
靴子学长2 小时前
基于字节大模型的论文翻译（含免费源码）
人工智能·深度学习·nlp
AI_NEW_COME3 小时前
知识库管理系统可扩展性深度测评
人工智能
海棠AI实验室3 小时前
AI的进阶之路：从机器学习到深度学习的演变（一）
人工智能·深度学习·机器学习
hunteritself3 小时前
AI Weekly『12月16-22日』：OpenAI公布o3，谷歌发布首个推理模型，GitHub Copilot免费版上线！
人工智能·gpt·chatgpt·github·openai·copilot
IT古董4 小时前
【机器学习】机器学习的基本分类-强化学习-策略梯度（Policy Gradient，PG）
人工智能·机器学习·分类
centurysee4 小时前
【最佳实践】Anthropic：Agentic系统实践案例
人工智能
mahuifa4 小时前
混合开发环境---使用编程AI辅助开发Qt
人工智能·vscode·qt·qtcreator·编程ai
四口鲸鱼爱吃盐4 小时前
Pytorch | 从零构建GoogleNet对CIFAR10进行分类
人工智能·pytorch·分类
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程