）。其他训练参数无需更改，但是如果您的新训练数据比以前的训练数据小很多，您可能会发现将learning\_rate\_multiplier减少2到4倍是有用的。
### 权重和偏置
您可以将微调结果与Weights & Biases同步，以跟踪实验、模型和数据集。
要开始使用，您需要一个Weights & Biases帐户和一个付费的OpenAI计划。为确保您使用的是最新版本的openai和wandb，请运行:
```bash
pip install --upgrade openai wandb
```
要将您的微调与Weights＆Biases同步，请运行：
```bash
openai wandb sync
```
## 示例笔记本
### 分类
[finetuning-classification.ipynb ](https://github.com/openai/openai-cookbook/blob/main/examples/Fine-tuned_classification.ipynb)
此笔记本将演示如何微调模型，以对输入文本是否与棒球或曲棍球相关进行分类。我们将在笔记本中执行以下四个步骤：
* 数据探索将概述数据源和示例的外观。
* 数据准备将把我们的数据源转换为可用于微调的jsonl文件。
* 微调将启动微调作业并解释所得到的模型性能。
* 使用该模型将演示如何向经过微调的模型发出请求以获取预测结果。
### 回答问题
[olympics-1-collect-data.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/fine-tuned_qa/olympics-1-collect-data.ipynb)
[olympics-2-create-qa.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/fine-tuned_qa/olympics-2-create-qa.ipynb)
[olympics-3-train-qa.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/fine-tuned_qa/olympics-3-train-qa.ipynb)
该项目的想法是创建一个问答模型，基于提供的几段文本。基于GPT-3模型在回答问题时表现良好，当答案包含在段落中时，但如果答案不包含在其中，则基础模型往往会尽力回答，导致混淆的答案。 为了创建仅在有足够上下文情况下才回答问题的模型，我们首先创建了一个基于文本段落的问题和答案数据集。为了训练模型只有当存在答案时才回答，在这些情况下我们还添加对抗性示例，其中问题与上下文不匹配。在这些情况下，我们要求模型输出“没有足够的上下文来回答问题”。 我们将通过三个笔记本执行此任务：
* 第一个笔记本专注于收集最近数据，在预训练期间GPT-3没有看到过这些数据。 我们选择了2020年奥运会（实际上发生在2021年夏季）作为主题，并下载了713个独特页面。 我们按单独部分组织数据集，并将其用作询问和回复问题的背景。
* 第二个笔记本将利用Davinci-instruct根据Wikipedia章节提出一些问题，并根据该章节回答回应那些问题。
* 第三个笔记本将利用上下文、问句和解释对数据集来额外地创造对抗性问句和背景对, 在这种情况下, 该模型被提示以"无足够背景信息来解析此类问题" 来进行响应. 我们还将训练鉴别器模型, 以预测是否可以根据环境或其他因素来解析某一类特定类型或者所有类型 的相关内容.
# 嵌入
OpenAI的文本嵌入（embeddings）可以测量文本字符串之间的相关性。嵌入通常用于：
* 搜索（结果按查询字符串的相关性排序）
* 聚类（将文本字符串按相似性分组）
* 推荐（推荐具有相关文本字符串的物品）
* 异常检测（识别具有较少相关性的异常值）
* 多样性测量（分析相似性分布）
* 分类（将文本字符串按其最相似的标签分类）
嵌入是由浮点数组成的向量（列表）。两个向量之间的距离可以衡量它们之间的相关性。小距离表明高相关性，大距离则表明低相关性。
请访问我们的[定价](https://openai.com/api/pricing/)页面了解嵌入的价格。请求基于输入中的token数量计费。
要了解嵌入的实际运用，请查看本文中的示例：
* 分类
* 主题聚类
* 搜索
* 推荐
## 如何获取嵌入
要获取嵌入，将您的文本字符串发送到嵌入API端点，并选择一个嵌入模型ID（例如text-embedding-ada-002）。响应将包含一个嵌入，您可以提取、保存和使用。
示例请求:
```shell
# 获取嵌入
curl https://api.openai.com/v1/embeddings \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{"input": "Your text string goes here",
"model":"text-embedding-ada-002"}'
```
示例响应:
```
{
"data": [
{
"embedding": [
-0.006929283495992422,
-0.005336422007530928,
...
-4.547132266452536e-05,
-0.024047505110502243
],
"index": 0,
"object": "embedding"
}
],
"model": "text-embedding-ada-002",
"object": "list",
"usage": {
"prompt_tokens": 5,
"total_tokens": 5
}
}
```
在[OpenAI Cookbook](https://github.com/openai/openai-cookbook/)中查看更多Python代码示例。 使用OpenAI嵌入时，请记住它们的限制和风险。
## 嵌入模型
OpenAI 提供了一个第二代嵌入模型（在模型 ID 中标记为 -002）和 16 个第一代模型（在模型 ID 中标记为 -001）。 我们建议几乎所有用例都使用 text-embedding-ada-002。它更好、更便宜、更简单易用。请阅读博客文章公告。
| 模型版本 | 分词器 | 最大输入词元 | 知识截止时间 |
| ---- | ------------ | ------ | -------- |
| V2 | cl100k\_base | 8191 | Sep 2021 |
| V1 | GPT-2/GPT-3 | 2046 | Aug 2020 |
使用按输入词元计价，每1000个词元的费率为0.0004美元，或者大约1美元可以翻译3000页（假设每页有800个词元）：
| 模型 | 每美元的粗糙页面数 | BEIR 搜索评估的示例性能 |
| ---------------------- | --------- | -------------- |
| text-embedding-ada-002 | 3000 | 53.9 |
| *-davinci-*-001 | 6 | 52.8 |
| *-curie-*-001 | 60 | 50.9 |
| *-babbage-*-001 | 240 | 50.4 |
| *-ada-*-001 | 300 | 49.0 |
### 第二代模型
| 模型 | 分词器 | 最大词元数 | 输出维度 |
| ---------------------- | ------------ | ----- | ---- |
| text-embedding-ada-002 | cl100k\_base | 8191 | 1536 |
### 第一代模型（不推荐）
官方也不推荐使用其他的第一代模型，这边就不翻译了
## 使用案例
这里我们展示一些代表性的使用案例。接下来的例子中，我们将使用[亚马逊美食评论数据集](https://www.kaggle.com/snap/amazon-fine-food-reviews)。
### 获取嵌入
该数据集包含截至2012年10月亚马逊用户留下的共568,454条食品评论。我们将使用最近1,000条评论的子集进行说明。这些评论是用英语编写的，往往是积极或消极的。每个评论都有一个ProductId、UserId、Score、评价标题（Summary）和评价正文（Text）。例如：
| 产品 ID | 用户 ID | 得分 | 总结 | 文本 |
|---|
| B001E4KFG0 | A3SGXH7AUHU8GW | 5 | 优质狗粮 | 我已经买了几罐活力饮料... |
| B00813GRG4 | A1D87F6ZCVE5NK | 1 | 不如广告所述 | 产品标签上写着巨型盐腌花生... |
我们将把评论摘要和评论文本合并成一个组合文本。模型将对这个组合文本进行编码，并输出一个单一的向量嵌入。
[Obtain\_dataset.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/Obtain_dataset.ipynb)
```python
def get_embedding(text, model="text-embedding-ada-002"):
text = text.replace("\n", " ")
return openai.Embedding.create(input = [text], model=model)['data'][0]['embedding']
df['ada_embedding'] = df.combined.apply(lambda x: get_embedding(x, model='text-embedding-ada-002'))
df.to_csv('output/embedded_1k_reviews.csv', index=False)
```
要从保存的文件中加载数据，您可以运行以下命令：
```python
import pandas as pd
df = pd.read_csv('output/embedded_1k_reviews.csv')
df['ada_embedding'] = df.ada_embedding.apply(eval).apply(np.array)
```
### 数据2D可视化
[Visualizing\_embeddings\_in\_2D.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/Visualizing_embeddings_in_2D.ipynb)
嵌入的大小取决于底层模型的复杂性。为了可视化这个高维数据，我们使用t-SNE算法将数据转换成二维。 我们根据评论者给出的星级评分来着色每个单独的评论：
* 1星：红色
* 2星：深橙色
* 3星：金色
* 4星：青绿色
* 5星：深绿色
可视化似乎产生了大约3个聚类，其中一个主要是负面评价。
```python
import pandas as pd
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import matplotlib
df = pd.read_csv('output/embedded_1k_reviews.csv')
matrix = df.ada_embedding.apply(eval).to_list()
# Create a t-SNE model and transform the data
tsne = TSNE(n_components=2, perplexity=15, random_state=42, init='random', learning_rate=200)
vis_dims = tsne.fit_transform(matrix)
colors = ["red", "darkorange", "gold", "turquiose", "darkgreen"]
x = [x for x,y in vis_dims]
y = [y for x,y in vis_dims]
color_indices = df.Score.values - 1
colormap = matplotlib.colors.ListedColormap(colors)
plt.scatter(x, y, c=color_indices, cmap=colormap, alpha=0.3)
plt.title("Amazon ratings visualized in language using t-SNE")
```
### 将嵌入作为文本特征编码器用于机器学习算法
[Regression\_using\_embeddings.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/Regression_using_embeddings.ipynb)
嵌入可以作为机器学习模型中通用的自由文本特征编码器。如果一些相关输入是自由文本，那么加入嵌入将提高任何机器学习模型的性能。嵌入也可以作为ML模型中分类特征编码器使用。如果分类变量名称有意义且数量众多（例如职位名称），则此方法最具价值。相似度嵌入通常比搜索嵌入在此任务上表现更好。
我们观察到，通常情况下，嵌入表示的信息密度很高。例如，使用SVD或PCA降低输入维数即使只有10％，在特定任务的下游性能方面通常会导致更差的结果。
该代码将数据分成训练集和测试集，并将被以下两个用例使用：回归和分类。
```python
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
list(df.ada_embedding.values),
df.Score,
test_size = 0.2,
random_state=42
)
```
#### 使用嵌入特征的回归
嵌入提供了一种优雅的方法来预测数值。在这个例子中，我们根据评论文本预测评论者的星级评分。由于嵌入所包含的语义信息非常丰富，即使只有很少的评论，也可以得到不错的预测结果。
我们假设得分是1到5之间的连续变量，并允许算法预测任何浮点值。机器学习算法将预测值与真实得分之间的距离最小化，并取得了0.39 的平均绝对误差，这意味着平均而言，预测偏差不到半颗星。
```python
from sklearn.ensemble import RandomForestRegressor
rfr = RandomForestRegressor(n_estimators=100)
rfr.fit(X_train, y_train)
preds = rfr.predict(X_test)
```
### 使用嵌入特征进行分类
[Classification\_using\_embeddings.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/Classification_using_embeddings.ipynb)
这一次，我们不再让算法预测1到5之间的任意值，而是尝试将评论中的星级精确分类为5个档次，范围从1星到5星。
经过训练后，模型学会了更好地预测1和5星评价，而对于更微妙的评价（2-4星），由于情感表达不够极端可能效果较差。
```python
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score
clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train, y_train)
preds = clf.predict(X_test)
```
### 零样本分类
[Zero-shot\_classification\_with\_embeddings.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/Zero-shot_classification_with_embeddings.ipynb)
我们可以使用嵌入来进行零样本分类，而无需任何标记的训练数据。对于每个类别，我们将类名或类的简短描述嵌入其中。为了以零样本方式对一些新文本进行分类，我们将其嵌入与所有类别嵌入进行比较，并预测相似度最高的类别。
```python
from openai.embeddings_utils import cosine_similarity, get_embedding
df= df[df.Score!=3]
df['sentiment'] = df.Score.replace({1:'negative', 2:'negative', 4:'positive', 5:'positive'})
labels = ['negative', 'positive']
label_embeddings = [get_embedding(label, model=model) for label in labels]
def label_score(review_embedding, label_embeddings):
return cosine_similarity(review_embedding, label_embeddings[1]) - cosine_similarity(review_embedding, label_embeddings[0])
prediction = 'positive' if label_score('Sample Review', label_embeddings) > 0 else 'negative'
```
### 获取用户和产品嵌入以进行冷启动推荐
[User\_and\_product\_embeddings.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/User_and_product_embeddings.ipynb)
我们可以通过对用户所有评论进行平均来获得用户嵌入。同样地，我们可以通过对有关该产品的所有评论进行平均来获得产品嵌入。为了展示这种方法的实用性，我们使用50k个评论的子集以涵盖更多用户和产品的评论。
我们在一个单独的测试集上评估这些嵌入的实用性，在那里我们绘制用户和产品嵌入相似度作为评分函数。有趣的是，基于这种方法，即使在用户收到产品之前，我们也能比随机预测他们是否会喜欢该产品。
```
user_embeddings = df.groupby('UserId').ada_embedding.apply(np.mean)
prod_embeddings = df.groupby('ProductId').ada_embedding.apply(np.mean)
```
### 聚类
[Clustering.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/Clustering.ipynb)
聚类是理解大量文本数据的一种方法。嵌入对于这个任务非常有用，因为它们提供了每个文本的语义向量表示。因此，在无监督的情况下，聚类将揭示我们数据集中隐藏的分组。
在这个例子中，我们发现四个不同的簇：一个专注于狗粮，一个专注于负面评论，另外两个则是关于正面评论。
```python
import numpy as np
from sklearn.cluster import KMeans
matrix = np.vstack(df.ada_embedding.values)
n_clusters = 4
kmeans = KMeans(n_clusters = n_clusters, init='k-means++', random_state=42)
kmeans.fit(matrix)
df['Cluster'] = kmeans.labels_
```
### 使用嵌入进行文本搜索
[Semantic\_text\_search\_using\_embeddings.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/Semantic_text_search_using_embeddings.ipynb)
为了检索出最相关的文档，我们使用查询嵌入向量和每个文档之间的余弦相似度，并返回得分最高的文档。
```python
from openai.embeddings_utils import get_embedding, cosine_similarity
def search_reviews(df, product_description, n=3, pprint=True):
embedding = get_embedding(product_description, model='text-embedding-ada-002')
df['similarities'] = df.ada_embedding.apply(lambda x: cosine_similarity(x, embedding))
res = df.sort_values('similarities', ascending=False).head(n)
return res
res = search_reviews(df, 'delicious beans', n=3)
```
### 使用嵌入进行代码搜索
[Code\_search.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/Code_search.ipynb)
代码搜索与基于嵌入式文本搜索类似。我们提供一种从给定存储库中的所有Python文件中提取Python函数的方法。然后，每个函数都由text-embedding-ada-002模型进行索引。
要执行代码搜索，我们使用相同的模型将查询以自然语言形式进行嵌入。然后，我们计算结果查询嵌入和每个函数嵌入之间的余弦相似度。最高余弦相似度结果最相关。
```python
from openai.embeddings_utils import get_embedding, cosine_similarity
df['code_embedding'] = df['code'].apply(lambda x: get_embedding(x, model='text-embedding-ada-002'))
def search_functions(df, code_query, n=3, pprint=True, n_lines=7):
embedding = get_embedding(code_query, model='text-embedding-ada-002')
df['similarities'] = df.code_embedding.apply(lambda x: cosine_similarity(x, embedding))
res = df.sort_values('similarities', ascending=False).head(n)
return res
res = search_functions(df, 'Completions API tests', n=3)
```
### 使用嵌入推荐
[Recommendation\_using\_embeddings.ipynb](https://github.com/openai/openai-cookbook/blob/main/examples/Recommendation_using_embeddings.ipynb)
因为嵌入向量之间的距离越短，表示它们之间的相似度越大，所以嵌入可以用于推荐。
下面我们展示一个基本的推荐器。它接收一组字符串和一个“源”字符串，计算它们的嵌入向量，然后返回按相似度从高到低排名的字符串列表。作为具体例子，下面链接的笔记本将这个函数应用于 AG 新闻数据集（采样至 2,000 条新闻文章描述），以返回与任何给定源文章最相似的前 5 篇文章。
```python
def recommendations_from_strings(
strings: List[str],
index_of_source_string: int,
model="text-embedding-ada-002",
) -> List[int]:
"""Return nearest neighbors of a given string."""
# get embeddings for all strings
embeddings = [embedding_from_string(string, model=model) for string in strings]
# get the embedding of the source string
query_embedding = embeddings[index_of_source_string]
# get distances between the source embedding and other embeddings (function from embeddings_utils.py)
distances = distances_from_embeddings(query_embedding, embeddings, distance_metric="cosine")
# get indices of nearest neighbors (function from embeddings_utils.py)
indices_of_nearest_neighbors = indices_of_nearest_neighbors_from_distances(distances)
return indices_of_nearest_neighbors
```
## 限制和风险
在某些情况下，我们的嵌入模型可能不可靠或存在社会风险，并且在没有缓解措施的情况下可能会造成伤害。
### 社会偏见
限制：模型通过刻板印象或对某些群体的负面情感编码了社会偏见。 我们通过运行SEAT（[May等人，2019](https://arxiv.org/abs/1903.10561)）和Winogender（[Rudinger等人，2018](https://arxiv.org/abs/1804.09301)）基准测试发现了我们模型中存在偏差的证据。这些基准测试共包括7个测试，用于衡量当应用于性别化名称、地区名称和一些刻板印象时，模型是否包含隐含偏见。
例如，我们发现与非洲裔美国人姓名相比，我们的模型更强烈地将欧洲裔美国人姓名与积极情感联系起来，并将负面刻板印象与黑人女性联系起来。 这些基准测试有若干局限性：(a) 它们可能无法推广到您特定的使用案例中；(b) 它们仅针对可能出现的很小一部分社会偏见进行测试。
这些测试是初步结果，请根据您特定使用案例运行相关测试。这些结果应被视为该现象存在的证据而非其在您使用案例中明确描述。请参阅我们的使用政策以获取更多详细信息和指导建议。 如果您有任何问题，请通过聊天联系支持团队；我们很乐意为此提供建议。
### 盲目忽略最近事件
限制：模型缺乏关于2020年8月之后发生事件的知识。 我们的模型是训练在数据集上，在其中包含了截至2020年8月真实世界事件方面一定程度上信息。如果你依赖于代表最近事件的模型，则它们可能不会表现得很好 。常问问题 如何确定我要嵌入字符串之前有多少词元？ 在Python中, 您可以使用OpenAI 的tokenizer tiktoken 将一个字符串分割成词元. 示例代码:
```python
import tiktoken
def num_tokens_from_string(string: str, encoding_name: str) -> int:
"""Returns the number of tokens in a text string."""
encoding = tiktoken.get_encoding(encoding_name)
num_tokens = len(encoding.encode(string))
return num_tokens
num_tokens_from_string("tiktoken is great!", "cl100k_base")
```
对于像text-embedding-ada-002这样的第二代嵌入模型，请使用cl100k\_base编码。
更多细节和示例代码在OpenAI Cookbook指南中[如何使用tiktoken计算词元中](https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb)。
### 如何快速检索K个最近的嵌入向量？
为了快速搜索许多向量，我们建议使用矢量数据库。您可以在GitHub上的我们的Cookbook中找到有关与矢量数据库和OpenAI API一起工作的示例。 矢量数据库选项包括：
* Pinecone，完全托管的矢量数据库
* Weaviate，开源矢量搜索引擎
* Faiss，Facebook提供的矢量搜索算法
* Redis作为一个向量数据库
* Qdrant，一个向量搜索引擎
* Typesense是一个开源搜索引擎，并带有向量搜索功能。
#### 我应该使用哪种距离函数？
我们推荐[余弦相似度](https://en.wikipedia.org/wiki/Cosine_similarity)。距离函数的选择通常并不重要。 OpenAI嵌入被归一化为长度1，这意味着：
* 余弦相似性可以通过仅使用点积来稍微更快地计算出来
* 余弦相似性和欧几里得距离将产生相同的排名
# 语音转文本
学习如何将音频转换为文本。
## 介绍
语音转文本 API 提供了两个端点，即基于我们最先进的开源大型-v2 Whisper 模型的转录和翻译。它们可以用于：
* 将音频转录为任何语言。
* 将音频翻译并转录成英语。
目前文件上传限制为 25 MB，并支持以下输入文件类型：mp3、mp4、mpeg、mpga、m4a、wav 和 webm。
## 快速入门
### 转录
转录 API 的输入是您要进行转录的音频文件以及所需输出格式的音频文字稿。我们目前支持多种输入和输出文件格式。
```python
# Note: you need to be using OpenAI Python v0.27.0 for the code below to work
import openai
audio_file= open("/path/to/file/audio.mp3", "rb")
transcript = openai.Audio.transcribe("whisper-1", audio_file)
```
默认情况下，响应类型将是包含原始文本的 JSON。
```
{
"text": "Imagine the wildest idea that you've ever had, and you're curious about how it might scale to something that's a 100, a 1,000 times bigger.
....
}
```
要在请求中设置其他参数，您可以添加更多带有相关选项的--form行。例如，如果您想将输出格式设置为文本，则应添加以下行：
```
...
--form file=@openai.mp3 \
--form model=whisper-1 \
--form response_format=text
```
### 翻译
翻译API以任何支持的语言作为输入音频文件，并在必要时将音频转录成英文。这与我们的/Transcriptions端点不同，因为输出不是原始输入语言，而是被翻译成英文文本。
```python
# Note: you need to be using OpenAI Python v0.27.0 for the code below to work
import openai
audio_file= open("/path/to/file/german.mp3", "rb")
transcript = openai.Audio.translate("whisper-1", audio_file)
```
在这种情况下，输入的音频是德语，输出的文本看起来像：
```
Hello, my name is Wolfgang and I come from Germany. Where are you heading today?
```
我们目前仅支持英语翻译。
## 支持的语言
我们目前通过转录和翻译端点支持以下语言：
南非荷兰语，阿拉伯语，亚美尼亚语，阿塞拜疆语，白俄罗斯语，波斯尼亚文，保加利亚文，加泰罗尼亚文，中文，克罗地亚文、捷克文、丹麦文、荷兰文、英国英语、爱沙尼亚文、芬兰文、法国法式英語, 加利西亞語, 德國語, 希臘語, 希伯來語, 印地語, 匈牙利語, 冰島icelandic 読音: \[ˈaɪsləndɪk], 印度尼西雅Indonesian 読音: \[indoneˈsia], 意大利Italian 読音: \[iːtæljən], 日本Japanese 読音: \[dʒæpəniːz], 卡纳达Kannada 読音: \[kʌn'na:dʌ] ,哈萨克Kazakh 読音:\[kɑzɑx] , 韩国Korean 读作：\[hanguk] ，拉脫維Latvian 读作：\[lætvijan] ，立陶宛Lithuanian 读作：\[liθu'einjən] ，马其顿Macedonian 读作：\[mækidouniən ] ，马来Malay 读作：\['meilei ] ，馬拉地Marathi 讀作:\[ma'rathi ],毛里求斯Maori 讀作:\[mauri ], 尼泊尔Nepali 讀作:\[ne'pa:l ],挪威Norwegian 讀作:\['no:wijiən ] ， 波斯Persian讀做\[persi'an ] , 波蘇尼Serbian讀做sǎrbijǝTagalog讀做tӕgӕ'lɔg，坦米爾Tamil讀做'tæmil, 泰Thai讀做\[tai], 土耳其Turkish讀健\[turki'sh], 烏Crainian(乌克兰)Ukrainian 讀健\[jukreinjǝn ], 烏Urdu(乌尔都)Urdu 讓你\[u:rdu:],越南Vietnamese (越南)Vietnamese 和威尔士Welsh。
虽然底层模型是在98种不同的语言上进行了培训。但我们只列出了超过50%单词错误率（WER）的标准行业基准测试所支持的那些。该模型将返回未列出以上列表中的其他所有可能存在输入结果但质量会较低。
## 更长输入
默认情况下Whisper API仅支持小于25 MB 的文件。如果您有一个比这更长的音频文件，则需要将其分成每个小于25 MB 的块或使用压缩后格式。为了获得最佳性能，请避免在句子中间断开声音以避免丢失一些上下文字信息。 处理此问题的一种方法是使用PyDub开源Python软件包来拆分声频文件。
```python
from pydub import AudioSegment
song = AudioSegment.from_mp3("good_morning.mp3")
# PyDub handles time in milliseconds
ten_minutes = 10 * 60 * 1000
first_10_minutes = song[:ten_minutes]
first_10_minutes.export("good_morning_10.mp3", format="mp3")
```
OpenAI对于像PyDub这样的第三方软件的可用性或安全性不作任何保证。
## 提示
您可以使用提示来提高Whisper API生成的转录质量。模型将尝试匹配提示的风格，因此如果提示也使用大写和标点符号，则更有可能使用它们。但是，当前的提示系统比我们其他语言模型要受限得多，并且仅提供对生成音频的有限控制。以下是一些示例，说明如何在不同情况下使用提示：
1. 对于模型经常错误识别音频中特定单词或缩略语非常有帮助。例如，以下提示改善了DALL·E和GPT-3这些单词（以前被写成“GDP 3”和“DALI”）的转录。
```
该转录涉及OpenAI开发类似DALL·E、GPT-3和ChatGPT等技术，并希望有一天构建一个造福人类所有人的AGI系统。
```
2. 为了保留分段文件的上下文，请使用先前片段的转录来引导模型。这将使转录更准确，因为模型将利用先前音频中相关信息。该模型只会考虑最后224个标记并忽略之前任何内容。
3. 有时候，在转录中可能会跳过标点符号。您可以通过使用包含标点符号简单提示来避免这种情况：
```
你好，欢迎参加我的讲座。
```
2. 该模型还可能在音频中省略常见填充词汇。如果您想在您的转录中保留填充词汇，则可以使用包含它们的指示：
```
嗯... 让我想想, 呃... 好吧, 这就是我正在思考 的事情.
```
3. 某些语言可以用不同方式书写，例如简体或繁体中文。默认情况下，该模型可能无法始终按照所需书写风格进行处理 。通过在首选书写风格上添加指示即可改进此问题.
# 内容审核
## 概述
Moderation 端点是一个工具，您可以使用它来检查内容是否符合 OpenAI 的使用政策。开发人员因此可以识别违反我们使用政策的内容，并采取行动，例如通过过滤它。
该模型分类以下类别：
| 类别 | 描述 |
| ------------------ | --------------------------------------------- |
| `hate` | 表达、煽动或宣传基于种族、性别、民族、宗教、国籍、性取向、残疾状态或种姓的仇恨内容。 |
| `hate/threatening` | 包括针对目标群体的暴力或严重伤害的仇恨内容。 |
| `self-harm` | 促进、鼓励或描绘自我伤害行为，如自杀，割伤和饮食障碍等。 |
| `sexual` | 旨在引起性兴奋的内容，例如描述性活动或推广性服务（不包括性教育和健康）。 |
| `sexual/minors` | 包含未满18岁个体的性内容。 |
| `violence` | 推广或美化暴力，庆祝他人遭受苦难或屈辱的内容。 |
| `violence/graphic` | 描述死亡, 暴力, 或极端图形细节中造成严重身体损伤.
|
当监控 OpenAI API 的输入和输出时，可免费使用审核端点。我们目前不支持第三方流量监控。
我们正在不断努力提高分类器准确度，并特别致力于改善对仇恨言论，自我伤害以及图形暴力等类型文章进行分类。我们目前对非英语语言支持有限。
## 快速入门
要获取文本片段的分类，请像以下代码片段中演示的那样向审核端点发出请求:
```python
curl https://api.openai.com/v1/moderations \
-X POST \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{"input": "Sample text goes here"}'
```
以下是端点的示例输出。它返回以下字段：
* flagged：如果模型将内容分类为违反OpenAI使用政策，则设置为true，否则为false。
* categories：包含每个类别二进制使用政策违规标志的字典。对于每个类别，如果模型将相应的类别标记为违规，则该值为true，否则为false。
* category\_scores：包含由模型输出的每个类别原始分数的字典，表示模型对输入是否违反OpenAI有关该类别的政策的信心。该值介于0和1之间，其中较高的值表示更高的置信度。不应将得分解释为概率。
```python
{
"id": "modr-XXXXX",
"model": "text-moderation-001",
"results": [
{
"categories": {
"hate": false,
"hate/threatening": false,
"self-harm": false,
"sexual": false,
"sexual/minors": false,
"violence": false,
"violence/graphic": false
},
"category_scores": {
"hate": 0.18805529177188873,
"hate/threatening": 0.0001250059431185946,
"self-harm": 0.0003706029092427343,
"sexual": 0.0008735615410842001,
"sexual/minors": 0.0007470346172340214,
"violence": 0.0041268812492489815,
"violence/graphic": 0.00023186142789199948
},
"flagged": false
}
]
}
```
OpenAI将持续升级调节端点的基础模型。因此，依赖于类别分数的自定义策略可能需要随时间重新校准。
# 速率限制
## 概述
### 什么是速率限制？
速率限制是API对用户或客户端在指定时间内访问服务器的次数施加的限制。
### 为什么我们有速率限制？
速率限制是API的常见实践，它们出于几个不同的原因而被设置：
* 它们有助于防止滥用或误用API。例如，恶意行为者可能会通过请求来淹没API，试图使其超载或导致服务中断。通过设置速率限制，OpenAI可以防止这种活动发生。
* 速率限制有助于确保每个人都能公平地访问API。如果一个人或组织进行过多的请求，可能会拖累其他所有人使用API。通过调节单个用户可以进行的请求数量，OpenAI确保最多数量的人有机会使用API而不经历减缓。
* 速率限制可以帮助OpenAI管理其基础设施上的总负载。如果对API的请求急剧增加，则可能会给服务器带来压力并导致性能问题。通过设置速率限制，OpenAI可以帮助所有用户维护平稳一致体验。
请完整阅读本文档以更好地了解OpenAI 的 速度极值系统如何工作。我们提供代码示例和处理常见问题所需解决方案，请在填写“极值增长申请表”之前遵循此指南，并详细说明如何在最后一部分填写该表格。
### 我们 API 的极值是什么？
我们根据使用特定端点以及您拥有哪种类型账户，在组织级别而非用户级别强化极值控管 。 极值按两种方式测量：RPM（每分钟请求数）和TPM（每分钟词元数）。下表突出显示了我们 API 的默认极值 ，但这些极值可根据您的用例在填写“Rate Limit Increase Request” 表格后进行增加 。
TPM（每分钟标记数）单位因模型而异：
| 类型 | 1 TPM 等价于 |
| ------- | --------- |
| davinci | 1 词元/分钟 |
| curie | 25 词元/分钟 |
| babbage | 100 词元/分钟 |
| ada | 200 词元/分钟 |
从实际角度来看，这意味着您可以每分钟向ada模型发送大约200倍的令牌，而相对于davinci模型则更多。
| | TEXT & EMBEDDING | CHAT | CODEX | EDIT | IMAGE | AUDIO |
| ---------------- | ------------------------------------ | ----------------------------------- | ------------------------------ | ------------------------------- | --------------- | ------ |
| 免费试用用户 | •20 RPM
•150,000 TPM
| •20 RPM
•40,000 TPM
| •20 RPM
•40,000 TPM
| •20 RPM
•150,000 TPM
| 50 images / min | 50 RPM |
| 按使用量付费用户（前48小时） | •60 RPM
•250,000 TPM\*
| •60 RPM
•60,000 TPM\*
| •20 RPM
•40,000 TPM
| •20 RPM
•150,000 TPM
| 50 images / min | 50 RPM |
| 按使用量付费用户（48小时以后） | •3,500 RPM
•350,000 TPM\*
| •3,500 RPM
•90,000 TPM\*
| •20 RPM
•40,000 TPM
| •20 RPM
•150,000 TPM
| 50 images / min | 50 RPM |
需要注意的是，速率限制可以由任一选项触发，取决于哪个先发生。例如，您可能会向Codex端点发送20个请求，并仅使用100个代币来填充您的限制，即使在这些20个请求中没有发送40k代币。
### 速率限制如何工作？
如果您的速率限制为每分钟60个请求和每分钟150k davinci代币，则将受到两者之一的限制，无论哪种情况先发生。例如，如果您的最大请求数/分为60，则应能够每秒发送1个请求。如果您每800毫秒发送1次请求，在达到速率限制后，只需让程序休眠200毫秒即可再次发送一个请求；否则后续请求将失败。对于默认值3,000 requests/min，默认值下客户可以有效地每20ms或0.02秒发送1次请求。
### 如果我遇到了速率限制错误会怎样？
速率限制错误看起来像这样： Rate limit reached for default-text-davinci-002 in organization org-{id} on requests per min. Limit: 20.000000 / min. Current: 24.000000 / min. 如果你遇到了速度上线问题，则意味着你在短时间内进行了过多的申请，并且API拒绝履行进一步申请直至经过指定时间。
### 速度上限与max\_tokens
我们提供的每种模型都有一个固定数量的token可以作为输入传递给它们进行处理。不能增加模型接收标记数目上界。例如： 如果使用text-ada-001，则可以向该模型发送最多2048词元每个请求。
## 错误处置
### 我可以采取哪些措施来减轻此类问题？
OpenAI Cookbook有一个[Python笔记本](https://github.com/openai/openai-cookbook/blob/main/examples/How_to_handle_rate_limits.ipynb)详细说明如何避免出现频率极高（rate limit）错误。
当提供编程式访问、批量处理功能和自动化社交媒体发布时，请谨慎考虑 - 可以考虑仅针对信任客户启用这些功能。
为防止自动化和高容量滥用，在指定时间范围内（日、周或月），设置单个用户使用量上界 。 对于超出此上界用户，请考虑实施硬性规定或手动审核流程。
### 通过指数回退重试
避免频繁调用API方法导致频繁报错也很简单——随机等待并重新尝试调用API方法就好了！具体做法是：当 API 返回“429 Too Many Requests”状态码时暂停执行代码片段，并根据当前已经重试过几次计算出等待时间 t ，然后再重新尝试调用 API 方法；若依旧返回“429 Too Many Requests”状态码则再暂停 t 秒钟之后重复以上操作…… 直至成功获取数据！
指数回退意味着在命中第一个 rate limit 错误时执行短暂休眠并重试不成功的 request 。 如果 request 仍未成功，则增加 sleep 长度并重复该过程。 这将持续到 request 成功或达到最大重试次数为止。 此方法具有许多优点：
* 自动重试意味着您可以从 speed limit errors 中恢复而不会崩溃或丢失数据
* 指数回退意味着首先尝试快捷方式retry ，同时仍然从较长延迟中获益retry ，因此前几次 retry 失败。
* 添加随机抖动以延迟 retries 不同时刻击中所有 retries 的效果。
请注意，不成功的请求会影响您每分钟的限制，因此持续重新发送请求是行不通的。 以下是一些使用指数退避的 Python 示例解决方案。
#### 示例1：使用Tenacit库
Tenacity是一个Apache 2.0许可的通用重试库，使用Python编写，旨在简化将重试行为添加到几乎任何内容的任务。要向您的请求添加指数退避，请使用tenacity.retry装饰器。下面的示例使用tenacity.wait\_random\_exponential函数向请求添加随机指数退避。
```python
import openai
from tenacity import (
retry,
stop_after_attempt,
wait_random_exponential,
) # for exponential backoff
@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))
def completion_with_backoff(**kwargs):
return openai.Completion.create(**kwargs)
completion_with_backoff(model="text-davinci-003", prompt="Once upon a time,")
```
请注意，Tenacity库是第三方工具，OpenAI不对其可靠性或安全性做出任何保证。
#### 示例2：使用backoff库
另一个提供退避和重试功能修饰符的Python库是backoff：
```python
import backoff
import openai
@backoff.on_exception(backoff.expo, openai.error.RateLimitError)
def completions_with_backoff(**kwargs):
return openai.Completion.create(**kwargs)
completions_with_backoff(model="text-davinci-003", prompt="Once upon a time,")
```
#### 示例3：手动实现指数回退
如果您不想使用第三方库，可以按照此示例实现自己的退避逻辑：
```python
# imports
import random
import time
import openai
# define a retry decorator
def retry_with_exponential_backoff(
func,
initial_delay: float = 1,
exponential_base: float = 2,
jitter: bool = True,
max_retries: int = 10,
errors: tuple = (openai.error.RateLimitError,),
):
"""Retry a function with exponential backoff."""
def wrapper(*args, **kwargs):
# Initialize variables
num_retries = 0
delay = initial_delay
# Loop until a successful response or max_retries is hit or an exception is raised
while True:
try:
return func(*args, **kwargs)
# Retry on specific errors
except errors as e:
# Increment retries
num_retries += 1
# Check if max retries has been reached
if num_retries > max_retries:
raise Exception(
f"Maximum number of retries ({max_retries}) exceeded."
)
# Increment the delay
delay *= exponential_base * (1 + jitter * random.random())
# Sleep for the delay
time.sleep(delay)
# Raise exceptions for any errors not specified
except Exception as e:
raise e
return wrapper
@retry_with_exponential_backoff
def completions_with_backoff(**kwargs):
return openai.Completion.create(**kwargs)
```
再次声明，OpenAI 对此解决方案的安全性或效率不作任何保证，但它可以成为您自己解决方案的良好起点。
### 批量请求
OpenAI API 对每分钟的请求数和令牌数有单独的限制。
如果您达到了每分钟请求次数的限制，但是在每分钟令牌方面有可用容量，则可以将多个任务分批处理到每个请求中，以增加吞吐量。这将允许您处理更多的令牌，特别是对于我们较小的模型。
发送一批提示与正常 API 调用完全相同，只需将字符串列表传递给 prompt 参数即可。
#### 不使用批处理的例子：
```python
import openai
num_stories = 10
prompt = "Once upon a time,"
# serial example, with one story completion per request
for _ in range(num_stories):
response = openai.Completion.create(
model="curie",
prompt=prompt,
max_tokens=20,
)
# print story
print(prompt + response.choices[0].text)
```
使用批处理的例子
```python
import openai # for making OpenAI API requests
num_stories = 10
prompts = ["Once upon a time,"] * num_stories
# batched example, with 10 story completions per request
response = openai.Completion.create(
model="curie",
prompt=prompts,
max_tokens=20,
)
# match completions to prompts by index
stories = [""] * len(prompts)
for choice in response.choices:
stories[choice.index] = prompts[choice.index] + choice.text
# print stories
for story in stories:
print(story)
```
> 警告：响应对象可能不会按提示的顺序返回完成情况，因此请始终记住使用索引字段将响应与提示匹配。
## 请求增加
### 我应该在什么时候考虑申请速率限制增加？
我们的默认速率限制有助于最大化稳定性并防止滥用我们的API。我们会增加限制以启用高流量应用程序，因此申请速率限制增加的最佳时间是当您认为您拥有必要的流量数据来支持提高速率限制的强有力理由时。没有支持数据的大幅度速率限制增加请求不太可能被批准。如果您正在准备产品发布，请通过10天分阶段发布获得相关数据。
请记住，速率限制增加有时需要7-10天，因此如果存在支持当前增长数字将达到您的速率限制所需数据，则尽早计划并提交是明智之举。
### 我的速率限制增加请求会被拒绝吗？
一个常见原因是缺乏证明其合理性所需数据而导致拒绝。下面提供了数值示例，展示如何最好地支持一个速率上升请求，并尽力批准所有符合安全策略和显示支持数据要求的请求。我们致力于使开发人员能够使用我们的API进行规模化和成功。
### 我已经为我的文本/代码API实现了指数退避算法，但仍然出现错误。如何提高我的频次上线？
目前，我们不支持提高免费测试端点（例如编辑端点）等功能。 我们也不会提高ChatGPT频次上线，但你可以参与ChatGPT专业版访问列表。
我们知道受到频次上线约束可能带来多大挫败感，并且很想为每个人都提高默认值。 但是由于共享容量约束，在Rate Limit Increase Request表单中只能批准付费客户证明需要通过审查后方可进行频次上线调整 。 为了帮助评估您真正需要哪些内容，请在“分享需求证据”部分中提供关于当前使用情况或基于历史用户活动预测 的统计信息 。 如果没有这些信息，则建议采取逐步释放方法：首先以当前比例释放服务给一小部分用户，在10个工作日内收集使用情况数据 ，然后根据该数据提交正式频次上线调整请求以供审核和批准。
如果您提交了申请并获得批准，则在7-10个工作日内通知您审批结果。 以下是填写此表格的一些示例：
#### DALL-E API示例
| 模型 | 预估词元数/分钟 | 预估请求数 | 用户数 | 需要的证据 | 1小时最大吞吐成本 |
|---|
| DALL-E API | N/A | 50 | 1000 | 我们的应用目前正在生产中，根据过去的流量情况，我们每分钟大约发出10个请求。 | $60 |
| DALL-E API | N/A | 150 | 10,000 | 我们的应用在App Store中越来越受欢迎，我们开始遇到速率限制。我们能否获得默认限制的三倍，即每分钟50个图像？如果需要更多，我们将提交新表格。谢谢！ | $180 |
语言模型示例
| 模型 | 预估词元数/分钟 | ESTIMATE预估请求数 REQUESTS/MINUTE | 用户数 | 需要的证据 | 1小时最大吞吐成本 |
|---|
| text-davinci-003 | 325,000 | 4,0000 | 50 | 我们将向一组初始的Alpha测试人员发布，并需要更高的限制来适应他们的初始使用。 我们在这里提供了一个链接到我们的Google Drive，显示分析和API使用情况。 | $390 |
| text-davinci-002 | 750,000 | 10,000 | 10,000 | 我们的应用程序受到了很多关注，我们有50,000人在等待列表上。 我们希望每天向1000人的小组推出，直到达到50,000个用户。 请查看此链接，以了解过去30天内我们当前令牌/分钟流量情况。 这是针对500个用户的，并且根据他们的使用情况，我们认为750,000个令牌/分钟和10,000个请求/分钟将作为一个良好的起点。 | $900 |
#### Code模型示例
| 模型 | 预估词元数/分钟 | ESTIMATE预估请求数 REQUESTS/MINUTE | 用户数 | 需要的证据 | 1小时最大吞吐成本 |
| ---------------- | -------- | ----------------------------- | --- | ------------------------------------------------------------------------------- | -------------------------------------- |
| code-davinci-002 | 150,000 | 1,000 | 15 | 我们是一组正在撰写论文的研究人员。我们估计，在本月底之前完成研究，需要在code-davinci-002上获得更高的速率限制。这些估计基于以下计算\[...] | Codex模型目前处于免费测试阶段，因此我们可能无法立即为这些模型提供增量。 |
请注意，这些示例仅为一般用例场景，实际使用率将根据具体的实现和使用情况而有所不同。
# 错误码
## 错误代码
本指南包括您可能从API和我们的官方Python库中看到的错误代码概述。在概述中提到的每个错误代码都有一个专门的部分，提供进一步的指导。
### API 错误
| CODE | OVERVIEW |
| ------------------------- | --------------------------------------------------------------------- |
| 401 - 无效身份验证 | 原因：身份验证无效。
解决方法：确保使用了正确的 API 密钥和请求组织。
|
| 401 - 提供了不正确的 API 密钥 | 原因：请求 API 密钥不正确。
解决方法：确保使用了正确的 API 密钥，清除浏览器缓存或生成新密钥。
|
| 401 - 必须是组织成员才能使用 API | 原因：您的帐户不属于任何组织。
解决方法：联系我们以加入新组织，或要求您所在组织管理员邀请您加入该组织。
|
| 429 - 请求速率达到限制 | 原因：发送请求过快。
解决方法：控制好请求速率。阅读速率限制指南。
|
| 429 - 您已超出当前配额，请检查计划和账单详情 | 原因: 您已达到最大月度支出（硬性限制），可以在账户计费部分查看此信息.
解决方法: 申请增加配额.
|
| 429 - 引擎目前负载过高，请稍后再试 | 原因: 我们服务器正在经历高流量.
解决办法: 稍等片刻后重试你们得请求.
|
| 500-服务器处理您得请求时发生错误. | 原因: 我们服务器上存在问题.
解决办法: 稍等片刻后重试,如果问题仍然存在,请与我们联系. 查看状态页面。
|
# 安全最佳实践
# 生产应用最佳实践
# API 参考
# 介绍
# 身份认证
# 创建请求
# 模型
# 完成
# 聊天
# 编辑
# 图片
# 嵌入
# 音频
# 文件
# 微调
# 内容审核
# 引擎
# 参数详情
# 翻译修订记录
## 修订记录
* 2023年3月8日：第一版翻译完成，包含开始、指南部分的核心内容