OpenAI O1 API 教程：如何连接到 OpenAI 的 API

本文最后由 Demo Marco 更新于 2025-02-22. 如有资源已失效，请留言反馈，将会及时处理。 【推荐：不翻墙访问被墙网站方法 | 自用高速专线机场 | 高速CN2线路 | 高质量家宽住宅IP】

OpenAI最近发布了人们期待已久的具有“博士推理”能力的模型，它不是我们许多人认为的 GPT-5，而是OpenAI o1模型。

OpenAI o1 的运作方式标志着计算资源分配的重要范式转变，更加注重训练和推理阶段。这种方法使其在复杂的推理任务上表现出色，但与其兄弟 GPT-4o 和 GPT-4o mini 相比也非常慢。

尽管如此，对于需要快速响应、图像处理或函数调用的应用程序， GPT-4o和GPT-4o mini仍然是首选。但是，如果您的项目需要高级推理能力并且可以容忍稍长的响应时间，那么 o1 模型是最佳选择。

我有机会通过 OpenAI 的 API 探索 o1，在这篇博客中，我将逐步指导您如何做到这一点。我将向您展示如何连接到 API、管理成本，最后，我将分享一些提示技巧，以帮助您最大限度地减少开支并获得更好的响应。

如果你正在寻找更具入门性的文章，请查看此OpenAI o1 指南。

注意：在撰写本教程时，o1 模型仍处于测试阶段。但是，连接到 API 的过程保持不变。

OpenAI O1 API 要求和速率限制

您需要知道的第一件事是，目前，通过 API 访问 o1 模型需要 Tier 5 使用级别。

要检查您的使用层，请转到OpenAI 开发者平台上的帐户页面，然后查看组织下的限制部分。

每个使用等级都有特定的速率限制。截至撰写本文时，以下是第 5 级的速率限制：

O1 模型在推理阶段需要花费大量时间来处理，这导致其 RPM 限制低于 GPT-4o 模型。请注意，o1 模型目前不支持批处理，这意味着您无法同时对模型的多个请求进行分组（批处理）。

O1 模型仍很新，因此这些要求和速率限制可能会在未来几周内发生变化。例如，OpenAI 最初宣布 o1-preview 的每周速率限制为 30 条消息，o1-mini 的每周速率限制为 50 条消息。然而，仅仅几天后，他们将 o1-preview 的速率限制更新为每周 50 次查询，o1-mini 的速率限制更新为每天 50 次查询。

OpenAI O1 推理代币

我们马上就会进入实际操作部分，但在此之前，让我们先澄清一个通过 API 使用 o1 的基本概念：推理令牌。理解这个概念对于理解您的每月 OpenAI 账单至关重要。

如果您通过ChatGPT界面使用过 o1-preview ，您就会发现它在生成答案之前会“大声思考”。

当我们通过 API 使用 o1 模型时，它也会经历同样的思考过程。唯一的不同是，与 ChatGPT 界面不同，推理过程是不可见的，我们看到的只是最终的答案。

然而，推理仍然是标记化的（因此得名“推理令牌”），而且正如您可能已经猜到的那样，它是可计费的。推理令牌按输出令牌计费，比输入令牌贵四倍。

我们很快就会学习如何控制代币数量和管理成本，但现在，让我们专注于连接到OpenAI 的 API以使用 o1 模型。

OpenAI O1 API：如何连接到 OpenAI 的 API

在本节中，我们将概述一系列步骤，以帮助您通过 API 连接到 o1-preview 模型。稍后，我们还将介绍如何连接到 o1-mini 模型。

步骤 1：获取 API 凭证

如果您有一个活跃帐户，您可以从 OpenAI 的API 密钥页面获取您的秘密 API 密钥。

如果您是组织的一员，您可能还需要组织 ID 和项目 ID，这可以帮助您的团队更有效地管理成本。请务必与您的团队核实此事。

无论您是 API 新手还是经验丰富的开发人员，遵循API 最佳实践始终是一个好主意。

第 2 步：导入openai库

OpenAI 通过其Python 库 轻松地与其 API 进行交互openai。你可以使用以下命令安装它：

pip install openai

安装后，我们OpenAI从库中导入类openai：

from openai import OpenAI

步骤 3：初始化客户端对象

为了与 OpenAI 的 API 交互，我们使用我们的秘密 API 密钥初始化一个客户端：

client = OpenAI(api_key=’your-api-key’)

如果您是某个组织的一部分，您可能还需要您的组织 ID 和项目 ID，因此这一步对您来说可能是这样的：

client = OpenAI(
    organization=’your-organization-id’,
    project=’your-project-id’,
    api_key=’your-api-key’
)

步骤 4：进行 API 调用

在撰写本文时，唯一可用的 o1 模型是o-1 preview和o1-mini。它们都可以通过端点获得。在下面的代码中，请注意：chat.completions

• 我们通过 来调用端点client.chat.completions.create()。
• ”o1-preview”我们为参数指定字符串model。
• 我们将提示作为值传递给”content”键。
• 我们通过 访问最终的答复response.choices[0].message.content。

response = client.chat.completions.create(
    model="o1-preview",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format."
        }
    ]
)
print(response.choices[0].message.content)

```python
import ast

# Read the input string
s = input()

# Add outer brackets to make it a valid list representation
input_str = '[' + s + ']'

# Safely evaluate the string to a list of lists
matrix = ast.literal_eval(input_str)

# Transpose the matrix
transposed = list(map(list, zip(*matrix)))

# Convert the transposed matrix back to the required string format
transposed_str = ','.join('[' + ','.join(map(str, row)) + ']' for row in transposed)

# Print the result
print(transposed_str)

如何确定推理标记的数量

如前所述，底层推理仍算作可计费令牌。对于我们上面运行的代码，以下是所有使用的令牌的明细：

print(response.usage)

CompletionUsage(completion_tokens=1279, prompt_tokens=43, total_tokens=1322, completion_tokens_details={'reasoning_tokens': 1024})

通过检查输出，我们看到推理标记的数量是 1024 completion_tokens_details={'reasoning_tokens': 1024}：。

该模型使用 1279 个标记（）生成了补全completion_tokens=1279，其中 1024 个是不可见推理标记——约占 80%！

使用新的 o1 模型，成本管理变得更加复杂，因此让我们更详细地讨论这一点。

如何使用 OpenAI O1 模型控制成本

在之前的模型中，我们使用max_tokens参数来控制完成标记的数量。事情相当简单：生成的标记数量和可见标记数量始终相同。

然而，对于 o1 模型，我们需要一个参数来设置所有完成标记的上限，包括可见的输出标记和不可见的推理标记。出于这个原因，OpenAI 添加了该max_completion_tokens参数，同时弃用max_tokens并使其与 o1 模型不兼容。

让我们尝试max_completion_tokens一下之前的示例。我们将它设置为300并查看结果。要使用此新参数，请注意，openai如果您使用的是旧版本，则可能需要更新库。

response_with_limit = client.chat.completions.create(
    model="o1-preview",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format."
        }
    ],
    max_completion_tokens=300
)
print(response_with_limit.choices[0].message.content)

请注意，我们没有得到任何输出。但我们仍在付费吗？答案是肯定的。

print(response_with_limit.usage)

CompletionUsage(completion_tokens=300, prompt_tokens=43, total_tokens=343, completion_tokens_details=CompletionTokensDetails(reasoning_tokens=300))

如果 o1 模型在得出最终答案之前达到令牌限制，它将停止推理过程并且不会返回任何输出。因此，设置max_completion_tokens为保证输出的值非常重要 – 否则我们将为推理令牌和输入令牌付费而得不到任何回报。

您需要max_completion_tokens根据具体用例尝试确切的值，但 OpenAI 建议为完成令牌的总数量保留至少 25,000 个令牌。 

为了避免输出被截断（或根本没有输出），如果您的用例涉及大量标记，您还需要注意上下文窗口。o1-preview 和 o-1 mini 模型的上下文窗口为 128,000 个标记。但请注意，o1-preview 的输出标记（可见和不可见）上限为 32,768 个标记，o1-mini 的输出标记上限为 65,536 个标记。

来源：OpenAI

OpenAI O1-Mini API：如何连接到 OpenAI 的 API

大型 o1 模型在高级推理方面功能强大，但速度也很慢。如果您需要应用程序的响应时间更快，并且愿意在推理性能上做出一点妥协，那么 o1-mini 模型可能是更好的选择。

要通过 API 连接到 o1-mini 模型，请按照我们针对 o1-preview 模型介绍的所有步骤进行操作 – 除了model参数之外，您需要使用字符串”o1-mini”。

我们将使用与上一个示例相同的提示，以便我们可以比较令牌的使用情况：

response_mini = client.chat.completions.create(
    model="o1-mini",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format."
        }
    ]
)
print(response_mini.choices[0].message.content)

Certainly! Below is a Python script that takes a matrix represented as a string in the format `'[1,2],[3,4],[5,6]'`, computes its transpose, and prints the transposed matrix in the same string format.

```python
def parse_matrix(matrix_str):
    """
    Parses a matrix string like '[1,2],[3,4],[5,6]' into a list of lists.
    """
    # Split the string by '],[' to separate the rows
    rows = matrix_str.strip().split('],[')
    
    # Clean the first and last elements by removing any leading '[' or trailing ']'
    rows[0] = rows[0].lstrip('[')
    rows[-1] = rows[-1].rstrip(']')
    
    # Convert each row into a list of integers
    matrix = []
    for row in rows:
        # Split each row by ',' and convert each element to integer
        matrix.append([int(num) for num in row.split(',')])
    
    return matrix

def transpose_matrix(matrix):
    """
    Transposes a given matrix (list of lists).
    """
    # Use zip with unpacking to transpose the matrix
    transposed = list(zip(*matrix))
    # Convert each tuple in the transposed matrix back to a list
    transposed = [list(row) for row in transposed]
    return transposed

def matrix_to_string(matrix):
    """
    Converts a list of lists into a string format like '[1,3,5],[2,4,6]'.
    """
    # Convert each row to a string
    row_strings = []
    for row in matrix:
        # Convert each number to string and join with commas
        row_str = ','.join(str(num) for num in row)
        # Enclose the row in brackets
        row_strings.append(f'[]')
    
    # Join all rows with commas
    return ','.join(row_strings)

def main():
    # Example input
    input_str = '[1,2],[3,4],[5,6]'
    
    # Parse the input string into a matrix
    matrix = parse_matrix(input_str)
    
    # Compute the transpose of the matrix
    transposed = transpose_matrix(matrix)
    
    # Convert the transposed matrix back to string format
    output_str = matrix_to_string(transposed)
    
    # Print the result
    print(output_str)

if __name__ == "__main__":
    main()
```

### How It Works:

1. **Parsing the Input String:**
    - The `parse_matrix` function takes the input string and splits it into individual rows by looking for the pattern `"],["`.
    - It cleans the first and last rows by removing any leading `[` or trailing `]`.
    - Each row string is then split by `,` to extract individual numbers, which are converted to integers and stored in a nested list.

2. **Transposing the Matrix:**
    - The `transpose_matrix` function uses the `zip` function along with unpacking (`*`) to transpose the matrix. This effectively switches rows with columns.
    - Since `zip` returns tuples, each transposed row is converted back into a list.

3. **Converting Back to String:**
    - The `matrix_to_string` function takes the transposed matrix and converts each row back into a string in the desired format.
    - It joins the elements of each row with commas and encloses them in brackets.
    - Finally, all row strings are joined together with commas to form the final output string.

4. **Main Execution:**
    - The `main` function demonstrates the usage with an example input. You can modify `input_str` to test with different matrices.
    - It prints the transposed matrix in the specified string format.

### Example:

Given the input string:
```
'[1,2],[3,4],[5,6]'
```
The script will output:
```
[1,3,5],[2,4,6]
```

### Handling User Input:

If you'd like the script to accept user input instead of having a hardcoded string, you can modify the `main` function as follows:

```python
def main():
    # Take user input
    input_str = input("Enter the matrix string (e.g., '[1,2],[3,4],[5,6]'): ").strip()
    
    # Parse the input string into a matrix
    matrix = parse_matrix(input_str)
    
    # Compute the transpose of the matrix
    transposed = transpose_matrix(matrix)
    
    # Convert the transposed matrix back to string format
    output_str = matrix_to_string(transposed)
    
    # Print the result
    print(output_str)
```

With this modification, when you run the script, it will prompt you to enter the matrix string:

```
Enter the matrix string (e.g., '[1,2],[3,4],[5,6]'): [1,2],[3,4],[5,6]
[1,3,5],[2,4,6]
```

### Notes:

- **Error Handling:** The current script assumes that the input string is well-formatted. For production code, you might want to add error handling to manage malformed inputs.
- **Non-integer Elements:** If your matrix contains non-integer elements (e.g., floats or strings), you'll need to adjust the parsing logic accordingly.

### Running the Script:

1. **Save the Script:** Save the above code to a file, say `transpose_matrix.py`.
2. **Run the Script:** Open a terminal or command prompt, navigate to the directory containing the script, and execute:

   ```bash
   python transpose_matrix.py
   ```

3. **Provide Input:** If you've modified it to accept user input, enter the matrix string when prompted.

This script provides a straightforward way to transpose a matrix represented as a string and can be easily adapted or extended based on specific requirements.

与 o1-preview 的输出相比，可见输出更加详细 – 让我们比较一下用法：

print(response_mini.usage) # o1-mini
print(response.usage) # o1-preview

CompletionUsage(completion_tokens=1511, prompt_tokens=43, total_tokens=1554, completion_tokens_details=CompletionTokensDetails(reasoning_tokens=256))
CompletionUsage(completion_tokens=1279, prompt_tokens=43, total_tokens=1322, completion_tokens_details={'reasoning_tokens': 1024})

o1-mini 模型的推理量比 o1 模型少四倍（256 vs. 1024 个推理标记）。但是，由于其答案冗长，因此完成标记的总数实际上更大。尽管 o1-mini 比 o1-preview 便宜得多，但这仍然不理想。

我们可以缓解这种情况的一种方法是通过提示工程——我们将指示模型避免解释和介绍，并将其输出限制为答案。

response_mini_2 = client.chat.completions.create(
    model="o1-mini",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format. Limit yourself to the answer and don't add explanations or introductions."
        }
    ]
)
print(response_mini_2.choices[0].message.content)

```python
import ast

def parse_matrix(matrix_str):
    rows = matrix_str.split('],[')
    rows[0] = rows[0].lstrip('[')
    rows[-1] = rows[-1].rstrip(']')
    matrix = [ast.literal_eval(f'[]') for row in rows]
    return matrix

def transpose(matrix):
    return list(zip(*matrix))

def format_matrix(transposed):
    return ','.join([f'[{",".join(map(str, row))}]' for row in transposed])

input_str = '[1,2],[3,4],[5,6]'
matrix = parse_matrix(input_str)
transposed = transpose(matrix)
output_str = format_matrix(transposed)
print(output_str)

好多了！完成 token 的总数大约减少了三倍：

print(response_mini_2.usage)

CompletionUsage(completion_tokens=487, prompt_tokens=55, total_tokens=542, completion_tokens_details=CompletionTokensDetails(reasoning_tokens=320))供电

API 测试版限制

在撰写本教程时，o1 模型仍处于测试阶段。虽然 OpenAI 已宣布计划在未来几周内推出更多功能和更友好的速率限制，但以下是使用测试版 o1 模型时会遇到的限制：

• 形式：仅支持文本；无法处理图像。
• 消息类型：只允许发送用户消息和助手消息；不允许发送系统消息。
• 流媒体：该功能不可用。
• 工具：不包括函数调用、工具和响应格式参数。
• Logprobs：不支持此参数。
• 其他设置：、、 和固定为，而和均设置为。 temperaturetop_pn1presence_penaltyfrequency_penalty0
• 助手和批处理：这些模型不能与助手 API 或批处理 API 一起使用。

OpenAI O1 API：定价

目前，OpenAI 在高级推理领域似乎没有太多竞争对手。因此，价格可能有点虚高，而且如你所见，与 GPT-4o 模型相比，它们的价格要高得多：

使用 O1 模型的最佳提示实践

o1 模型与我们习惯的模型（例如 GPT-4o 或Claude 3.5 Sonnet）有很大不同。由于 o1 模型已经参与了思路链推理，因此它们在简单的提示下效果最佳。使用少量提示或要求模型“逐步”思考实际上可能会降低其性能。

以下是OpenAI开发人员推荐的一些最佳提示实践：

• 保持提示简洁明了：模型依靠简短、直接的指令而蓬勃发展，而不需要复杂的解释。
• 避免思路链提示：这些模型在内部处理推理，因此无需要求它们“一步一步思考”或“解释你的推理”。
• 利用分隔符来提高清晰度：使用三重引号、XML 标签或章节标题等分隔符来清楚地定义输入的不同部分。
• 限制检索增强生成 (RAG)中的额外上下文：添加上下文或文档时，仅包含最相关的信息，以避免使模型的响应复杂化。

结论

通过这个博客，我分享了通过 OpenAI 的 API 连接到 o1 模型的分步指导。

如果您的项目需要高级推理能力并且可以适应稍长的响应时间，那么 o1 模型是极好的选择。

对于需要快速响应、图像处理或功能调用的应用，GPT-4o 和 GPT-4o mini 仍然是首选。

常见问题解答

OpenAI o1 有 API 吗？

是的，OpenAI 提供了用于访问其 O1 模型的 API。该 API 允许您将 o1 模型的功能集成到您的应用程序中，从而实现生成文本、翻译语言等任务。上面的教程概述了使用此 API 连接到 o1 模型的步骤。

OpenAI 的 o1 API 是免费的吗？

OpenAI 的 o1 不是免费的——有关更多详细信息，请参阅本教程的定价部分。

o1 版本（不是 o1-preview）预计何时发布？

OpenAI 通常通过官方渠道宣布完整 o1 版本（预览版除外）的发布日期。请关注 OpenAI 的博客、网站或社交媒体，了解有关 o1 发布时间表的最新更新和公告。

OpenAI o1 模型的定价是多少？

o1-preview的定价为每 100 万个输入代币 15.00 美元，每 100 万个输出代币 60.00 美元，而o1-mini 的定价为每 100 万个输入代币 3.00 美元，每 100 万个输出代币 12.00 美元。相比之下，gpt-4o 的定价为每 100 万个输入代币 5.00 美元，每 100 万个输出代币 15.00 美元，而gpt-4o-mini 的定价为每 100 万个输入代币 0.150 美元，每 100 万个输出代币 0.600 美元。

OpenAI o1 模型中的推理标记是什么？

在o1 模型中，推理令牌是指模型在思考过程中内部使用的令牌。虽然推理令牌会消耗计算资源并计入总令牌使用量（因此也计入成本），但它们不会作为输出的一部分显示给最终用户。