DLAI-o1-推理笔记-全-

DLAI o1 推理笔记（全）

001：课程介绍 🧠

在本课程中，我们将学习如何有效地提示和使用OpenAI的o1模型。这个新发布的模型在推理和规划任务上展现了显著的进步。

课程概述

欢迎来到《使用o1进行推理》课程，本课程是与OpenAI合作开发的。您的讲师是Colin Jarvis，他是OpenAI的AI解决方案负责人。我们很高兴能与您一起探索这个强大的模型。

在之前的短期课程中，OpenAI的Isabella Fulford介绍了一些提示技巧，以优化GPT-3.5的性能。她描述了思维链技术，这是一种让模型有时间思考的方法。

思维链技术详解

上一节我们提到了思维链，本节中我们来看看它的具体运作方式。

使用思维链提示时，您可能会指示模型“逐步思考”，并可能提供一些逐步推理的示例。作为回应，模型不会直接给出答案，而是会逐步处理查询。

以下是2022年论文《Chain-of-Thought Prompting Elicits Reasoning in Large Language Models》中的一个例子。在使用思维链提示时，您还需要为模型提供一个将问题分解为最简单步骤的响应示例。在回答查询时，模型会创建一系列简单步骤，从而成功回答问题。

o1模型的突破

OpenAI将这一技术提升到了新的高度，通过强化学习对模型进行微调，使其能够自主地将逐步推理的思维链整合到其响应过程中。

虽然我们今天看到的性能令人印象深刻，但从长远来看，更重要的是测试时间或推理时间的扩展性。

我们发现，o1的性能会随着更多强化学习（称为训练时间计算）和更多思考时间（称为测试时间或推理时间计算）而持续提升。这为您扩展语言模型性能提供了一个全新的维度。

然而，o1模型并非适用于所有情况。在本课程中，您将学会识别哪些任务适合o1，以及何时可能需要使用更小、更快的模型，或将两者结合使用。

课程大纲

以下是本课程的主要内容安排：

o1模型概览与适用场景：我们将从o1模型的概述开始，了解何时使用它们，以及推理时性能扩展的工作原理。
如何有效提示o1模型：您将学习如何提示o1模型以获得最佳性能。提示o1的最佳方式与早期模型有很大不同。
使用o1解决复杂多步骤任务：您将学习如何使用o1通过规划来解决复杂的多步骤任务。例如，使用一个由o1协调器和4.0工作者组成的系统来优化供应链物流挑战。您将结合使用多种模型：o1用于规划任务序列，而更快、成本更低的模型用于任务执行。
使用o1进行编程：之后，您将使用o1进行一些编码工作。它在这方面非常出色。
图像推理新功能：接着，您将尝试一个非常酷的新功能：图像推理。图像理解传统上难以投入生产，但借助o1，我们在这些任务上看到了新的性能水平。
使用o1生成和优化提示：最后，我们将总结如何使用o1来生成和优化您的提示，这种技术我们称之为“元提示”。

总结

本节课中，我们一起学习了《使用o1进行推理》课程的介绍部分。我们回顾了思维链技术的基础，了解了o1模型如何通过自主整合推理步骤和利用推理时间计算来实现性能突破，并预览了课程将涵盖的核心主题，包括模型选择、提示技巧、复杂任务规划、编码和图像理解等。接下来，让我们进入下一个视频，详细了解o1是如何被训练的。

002：o1模型介绍 🧠

概述

在本节课中，我们将全面介绍OpenAI的o1系列模型。我们将了解它与以往模型的核心区别、其工作原理、以及人们如何使用它。o1模型的核心在于“先思考，再回答”，这使其在数学、编程、科学等复杂任务上达到了新的性能高度。

o1模型的核心思想：先思考，再回答 🤔

在o1模型出现之前，大多数模型可以被看作是“孩子”，它们总是说出脑海中浮现的第一个想法。随着成长，它们需要学习一个宝贵的经验：在开口之前先思考。

o1模型之所以如此不同，是因为它每次都会在回答前进行显式的思考。这帮助它在数学、编程、科学、策略和物流等复杂任务和领域中达到了新的性能水平。

其实现方式是使用思维链来探索所有可能的路径，并在生成答案时进行验证。这意味着o1模型需要更少的上下文和提示，就能产生非常有效的结果。

o1系列模型简介 📦

OpenAI发布了o1系列的前两个模型。

o1：这是我们的主力推理模型，适用于需要广泛常识的复杂任务，支持函数调用和图像输入。
o1-mini：这是一个更快、更具成本效益的版本，专为编码、数学和科学任务量身定制，适用于对成本或延迟更敏感的场景。

o1系列模型的关键区别在于，它们将思维链原生地整合到了解决问题的过程中。

o1如何工作：一个示例 🔍

让我们通过一个例子来理解o1的思考过程。假设我们给模型一些打乱的字母，并展示如何翻译它们，然后给它一个新问题去解决。

它的解决过程大致如下：

它思考给定的信息，并“自言自语”地分析如何解决问题。
它识别示例，并理解这里发生的转换规则。
然后，它提出假设并进行测试。例如，它可能认为这里存在字谜或密码。
接着，它注意到密文单词的长度正好是原文的两倍。
于是它提出一个想法进行测试，发现行不通，但利用这个结果迭代出新的假设，最终找到正确答案。

简而言之，这就是o1如此特别的原因。我们无需通过提示来要求它这样做，而是通过训练让模型原生地应用这种推理过程，从而使其能够在科学、法律、编码和数学等众多不同领域中处理更复杂的问题。

使用o1的权衡：推理令牌 ⚖️

使用o1系列模型会引入一个权衡：模型会生成额外的完成令牌，这些令牌你实际上看不到，但模型正用它们来解决问题。

以下是其工作原理。完成令牌可以分为两个不同的类别：

推理令牌：模型用于内部思考和解决问题的令牌。
输出令牌：最终提供给你的生成结果的令牌。

需要注意以下几点：

推理令牌不会从一个对话轮次传递到下一个轮次。如果你想实现类似效果，需要提示模型输出某种推理过程，然后由你选择是否将其传递下去。
你需要将推理令牌计入使用成本。
在计算上下文限制时，推理令牌也会计入。如果你的输出超过了这个限制，输出将被截断。

性能提升的两大关键突破 🚀

o1性能提升的两大关键突破是：

1. 更长的推理时间
在训练后过程中我们发现，进行的强化学习越多，模型就越准确。但更令人惊讶的是，在推理时允许它思考更长时间，性能提升更为显著。因此，关键突破在于能够在推理时进行更长时间的思考以获得更好的结果。

2. 通过共识投票验证输出
另一个关键突破是教会模型通过共识投票来验证输出。其工作方式是：我们生成一批解决方案，并训练语言模型选择最常见的那个。你可以将其类比为在低“温度”参数下进行采样。

在一项测试中，仅通过共识投票，数学基准测试的成绩就从33%提高到了50%。共识投票的效果在大约100个样本之前就趋于稳定，因此你不需要海量样本就能实现性能提升。

o1的性能表现 📈

这些突破带来了显著的成果。o1模型的表现非常出色，例如：

数学：o1在基准测试中达到了83%，而GPT-4o仅为13%，提升巨大。
编码：o1达到89%，GPT-4o为11%。
科学：o1也有超过20个百分点的提升。
其他领域：在法律考试、MMLU（大规模多任务语言理解）等各类基准测试中，o1均表现出全面且显著的提升，例如在大学数学科目中达到了98.1%的惊人成绩。

o1的工作原理与抽象推理能力 🧩

o1模型工作的关键因素是，它使用大规模强化学习在回答前生成思维链。它产生的思维链比仅通过提示所能获得的更长、质量更高，并且包含错误纠正、尝试多种策略并选择最佳方案、或将问题自然分解为更小步骤等行为。

o1模型在抽象推理方面也代表了超越4o模型的新性能标准。例如，在一个挑战中，给模型16个单词，要求识别出将这些单词联系起来的4个类别，并将每个词放入正确的类别。GPT-4o的表现相当随意，而o1则能正确识别所有4个类别和全部16个单词。

这种抽象推理能力并不容易归类到编码、数学等传统基准中，但它展示了o1模型开始显现的一些新兴能力。

生成器-验证器差距的应用场景 🎯

o1系列模型展现出显著新兴能力的另一个领域是存在生成器-验证器差距的问题。

所谓生成器-验证器差距，是指对于某些问题，验证一个好的解决方案比首先生成完美的解决方案更容易。例如，在数独、数学、编程中，你通常可以先生成一个尚可的解决方案，验证它，找出问题，然后利用这些信息迭代到下一个方案，这比一开始就构建完美方案要容易得多。

当然，也存在验证-生成方法不适用的情况，例如信息检索（问题需要第一次就回答正确）或图像识别（需要第一次就正确识别图像内容）。但在存在生成器-验证器差距、并且我们拥有可以运行验证过程的良好验证器的场景下，我们可以在推理时投入更多计算资源以获得更好的性能。在这些方面，o1展现出了强大的能力。

o1的潜在应用领域 💡

那么，o1模型可能应用于哪些领域呢？

数据分析：解释复杂数据集，如基因组序列。
数学问题求解：性能相比前代模型有阶跃式提升。
实验设计：为化学、物理等专业领域提出创新方法。
科学编码：涉及大量STEM（科学、技术、工程、数学）主题。
生物化学推理
算法开发
文献综述：跨越多篇研究论文进行推理，形成连贯的结论或摘要。

关键要点总结 ✨

让我们回顾一下o1介绍的关键要点：

核心机制：o1系列模型通过在推理时生成用于迭代推理问题的令牌，来扩展计算规模。
权衡：o1提供更高的智能，但代价是更高的延迟和成本，因此并非适用于所有用例。
优势场景：它在需要“测试-学习”方法、可以迭代验证结果的任务上表现出色。
新兴用例：规划、编码，或法律、STEM等领域的特定推理。

实践应用示例 💻

现在，让我们跳转到一些实际应用，并了解如何为你的用例使用o1。

我将展示一个在聊天补全中o1如何工作的快速示例。

首先，导入API密钥并设置OpenAI客户端。我将使用o1-mini模型，并准备一个聊天补全请求。你可以看到o1请求与典型的聊天补全请求完全相同：我们指定一个o1模型，然后向它提出经典问题：“strawberry（草莓）这个词里有几个字母r？”

让我们看看返回的响应对象。这里我们关注的是o1的不同之处。我们可以打印出令牌使用情况：提示令牌、总完成令牌，以及完成令牌的组成部分（包括推理令牌和输出令牌）。

你会发现，模型在这里进行了大量的“思考”。我们只给了它15个提示令牌，但它产生了超过1000个推理令牌才得出输出。这突显了使用o1的关键权衡：你获得了更高的智能，但在这个案例中，我们为此支付了10倍于输出令牌的成本。

这是一个重要的考量点：不要在所有事情上都使用o1。它仅适用于那些智能提升值得用延迟和成本来交换的用例。

期待在下一课中与你相见，我们将深入探讨如何提示o1以获得最佳性能。

003：o1模型提示四原则 🧠

在本节课中，我们将学习如何有效地提示OpenAI的o1系列推理模型。我们将介绍四个核心原则，这些原则能帮助你更好地利用o1模型的能力，并理解其与其他模型（如GPT系列）在交互方式上的关键区别。

概述

o1模型是经过专门训练、擅长进行深度推理的模型。为了充分发挥其潜力，我们总结了四个关键的提示原则。这些原则并非详尽无遗，但它们为你探索o1模型与其他模型之间的差异提供了一个绝佳的起点。我们期待听到哪些原则对你最有效。

原则一：简洁直接 ✨

第一个原则是保持提示的简洁和直接。尝试编写简单明了、言简意赅的提示。你会发现，对于o1模型，直接的指令往往能产生最佳效果。

原则二：无需显式思维链 🔗

第二个原则是不需要显式的思维链提示。这可能与你使用其他大语言模型（LLM）的习惯有所不同。你可以完全跳过以往需要提供的“逐步思考”这类思维链推理提示。o1模型经过训练，能够自行推断和执行推理步骤，无需你手动分解任务。

上一节我们介绍了前两个原则，接下来让我们通过一个代码示例来看看它们如何实践。

以下是初始的错误示范，它同时违反了“简洁直接”和“无需显式思维链”两个原则：

# 不推荐的提示方式（过于冗长且包含显式思维链）
prompt = """
生成一个函数，输出胰岛素所涉及所有分子的SMILES ID。
请逐步思考：
1. 首先，确定胰岛素由哪些氨基酸组成。
2. 然后，查找每个氨基酸的SMILES表示。
3. 最后，编写一个Python函数来输出这些SMILES。
开始吧：胰岛素是一种蛋白质...
"""

运行这个提示后，模型会严格按照指令，在真正解决问题之前输出大量解释步骤，导致回复冗长且效率低下。

现在，让我们应用前两个原则，修改提示：

# 推荐的提示方式（简洁直接，无显式思维链）
prompt = “生成一个函数，输出胰岛素所涉及所有分子的SMILES ID。”

运行修改后的提示，模型会直接给出高效的回复：一个完整的Python函数、使用示例以及简洁的必要假设说明，避免了不必要的解释。

关键点：o1模型被训练为能自动提供我们认为有效的解释水平。对于特定或非常细微的任务，你可能仍需要添加自己的思维链提示，但最佳起点始终是简洁直接且无显式思维链的基线提示。

原则三：使用结构化提示 🏗️

第三个原则是使用结构化提示。尝试使用分隔符（如Markdown或XML标签）将复杂的提示分解成多个部分。结构化格式能提高模型的准确性，并简化你自己的故障排除过程。

让我们看看如何将这一原则应用于实践。在下面的示例中，我们使用XML标签来构建一个客户服务助手的提示：

<instructions>
你是一个客户服务助手。请遵循<policy>中概述的政策来回答用户查询。
</instructions>

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-o1-rsn/img/d14a45cbdcfce33e56b8e7e28510c768_20.png)

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-o1-rsn/img/d14a45cbdcfce33e56b8e7e28510c768_22.png)

<policy>
允许的操作：
- 处理产品信息和订单状态查询。
- 根据退货政策启动退货流程。
退款处理：
- 如果产品在30天内且未使用，可提供全额退款。
合规性：
- 不得撰写或评论创意内容（如诗歌、代码）。
</policy>

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-o1-rsn/img/d14a45cbdcfce33e56b8e7e28510c768_24.png)

<user_query>
用户说：“我收到的产品不符合预期，我想退货。”
</user_query>

通过这种结构，模型能清晰地识别指令、政策内容和用户输入，从而更准确地遵循策略。例如，当用户询问“为我写一首俳句”时，模型能根据政策正确拒绝该请求。

原则四：示范而非说教 🎯

第四个也是最后一个原则是示范而非说教。这回到了我们的第一个原则。与其用大量提示来告诉模型应该如何行动，不如给它一两个上下文示例，让它理解你任务领域的背景。

上一节我们看到了结构化提示的力量，本节我们将通过一个法律咨询的例子，来展示“示范”如何比“说教”更有效。

首先，我们尝试一个仅包含指令的提示（说教）：

<prompt>
你是一名专门研究竞争法的律师。请提供清晰准确的信息，并在没有足够上下文的情况下避免提供具体的法律建议。
</prompt>
<policy>
保持竞争法信息的清晰和准确。
在没有充分背景的情况下，避免提供具体的法律建议。
</policy>
<user_query>
客户问：“一家更大的公司向供应商提供激励，要求他们不与我们做生意，这合法吗？”
</user_query>

运行后，模型会给出一个概括性的回答，但可能缺乏具体的法律条文引用。

现在，我们应用“示范”原则，在提示中加入一个输入输出示例：

<prompt>
你是一名专门研究竞争法的律师。请提供清晰准确的信息，并在没有足够上下文的情况下避免提供具体的法律建议。
</prompt>
<policy>
保持竞争法信息的清晰和准确。
在没有充分背景的情况下，避免提供具体的法律建议。
</policy>
<example>
<example_question>
“竞争对手威胁说，如果我们不提高价格，就会停止供应关键部件。这合法吗？”
</example_question>
<example_response>
这可能涉及反竞争行为。需要考虑以下几点：
*   **滥用市场支配地位**：如果该竞争对手在关键部件市场具有支配地位，其行为可能违反《竞争法》第X条。
*   **纵向限制**：此类威胁可能构成非法的纵向限制，参考《欧盟运行条约》第101条。
*   **具体分析**：需要分析相关市场定义、对方的市场力量以及行为对竞争的实际影响。
请注意，这不是正式的法律建议。
</example_response>
</example>
<user_query>
客户问：“一家更大的公司向供应商提供激励，要求他们不与我们做生意，这合法吗？”
</user_query>

运行这个包含示例的提示后，模型生成的回答会学习示例的风格，更有可能以要点列表的形式呈现，并引用相关的法律条文（如《谢尔曼法》第1条），从而使回答更具结构性和参考价值。

核心思想：通过“示范”，你让模型自己推断出达成一致表现所需的推理模式，这通常比单纯“说教”更有效。

总结

本节课中，我们一起学习了有效提示o1推理模型的四个核心原则：

简洁直接：编写简单明了的指令。
无需显式思维链：信任模型自身的推理能力。
使用结构化提示：利用XML等标签组织复杂提示。
示范而非说教：通过示例来引导模型理解任务风格。

记住，最佳实践是从一个简洁、直接、无显式思维链的基线提示开始，然后根据需要引入结构化和示例来优化复杂任务的性能。鼓励你尝试打破这些规则，观察不同提示方式的影响，从而找到最适合你特定用例的方法。

004：规划 🧠

在本节课中，我们将学习如何利用o1模型的强大推理能力来制定任务计划。我们将看到如何结合o1-mini的智能规划和GPT-4o-mini的高效执行，以平衡智能、延迟和成本，从而解决复杂的多步骤任务。

概述

o1模型的一个突出应用场景是：在给定一组执行工具和任务约束的条件下，创建解决问题的计划。如果每一步都使用o1模型，整个过程会非常缓慢。因此，我们将采用一种实用的权衡策略：使用o1-mini生成计划，然后使用GPT-4o-mini执行每个步骤。这种以智能换取延迟和成本的方法在实践中非常有效。

整体架构

在深入代码细节之前，我们先了解任务的整体架构，以免迷失在细节中。

整个流程始于一个场景，这通常来自客户提出的、需要多步骤逻辑来回答的请求。这个场景会被提供给o1-mini模型。o1-mini将根据如何构建计划的指令，以及一系列可用于执行计划的工具，来制定一个详细的计划。这是o1模型的绝佳用例，我们利用其多步骤推理逻辑来制定一个稳健的计划。

计划制定完成后，我们将启用GPT-4o-mini作为“工人”，来执行计划中的每一步。一旦计划执行完毕，我们将得到一个答案，并将其反馈给客户。

现在，让我们深入代码，看看这在实践中是如何运作的。

代码实现步骤

以下是实现上述架构的关键步骤。

1. 初始设置

首先，导入OpenAI密钥，并初始化OpenAI客户端以及o1和GPT-4o模型。

import openai

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-o1-rsn/img/9b13eb50de29b0f45b82f1f5eedc9c51_13.png)

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-o1-rsn/img/9b13eb50de29b0f45b82f1f5eedc9c51_15.png)

# 初始化客户端和模型
client = openai.OpenAI(api_key='your_api_key')
o1_model = "o1-mini"
gpt4_model = "gpt-4o-mini"

2. 定义约束和上下文

接下来，定义任务场景的约束条件和上下文变量。

消息列表：因为我们的GPT-4o工人需要循环执行多个步骤，所以需要一个消息列表来累积历史记录，以便工人知道它已经执行了计划中的哪些步骤。
上下文变量：包括库存清单、客户订单、供应商信息（用于补充库存）、运输选项以及客户元数据等。
状态管理：由于会进行多轮对话，需要维护对话状态。在实际应用中，可以考虑在特定节点重置状态，以允许客户提交多个场景。

# 示例上下文变量
message_history = []
inventory = {...}
customer_order = {...}
suppliers = [...]
shipping_options = [...]
customer_metadata = {...}
conversation_state = {}

3. 定义o1-mini的系统提示词

我们需要为o1-mini定义一个提示词，指导它如何构建解决问题的计划。这个提示词包含几个主要部分：

角色和任务：告诉它，它是一个供应链助手，任务是审查给定的挑战（场景）并创建一个详细的计划来回答它。
可用资源：告知它将可以访问一个LLM代理（即GPT-4o-mini工人），并提供一个函数列表。这里需要注意，o1模型本身不会直接调用这些OpenAI函数，这些函数是提供给GPT-4o-mini工人使用的。但o1需要知道这些函数是什么以及它们的大致功能，以便为GPT-4o-mini工人制定多步骤计划。
计划格式指令：给o1一套指令，告诉它如何布局这个计划，以便我们之后能够解析它并提供给GPT-4o-mini执行。

o1_system_prompt = """
你是一个供应链助手。你的任务是审查面临的挑战（场景），并创建一个详细的计划来应对它。
你将可以访问一个LLM代理来执行具体步骤。
以下是代理可以使用的工具函数列表：
- fetch_new_orders: 获取新订单状态。
- get_inventory_status: 检查库存状态。
- check_production_capacity: 检查生产能力。
- ... (其他函数)

请按照以下结构创建计划：
1. 第一步：使用 [函数名] 做某事。
2. 第二步：对于每个X，做Y。
...
确保计划清晰、可执行。
"""

4. 定义GPT-4o-mini的系统提示词和函数

接下来，定义指导GPT-4o-mini工人如何工作的系统提示词。

角色和职责：告诉它是一个负责执行给定策略（即计划）的助手，必须严格按照书面计划执行。
决策解释：要求它在各个步骤中解释其决策过程，这在后续很有用，例如决定是否更新客户进度或是否遇到障碍。
逐步指令：给予它一些思维链提示，帮助其做出正确决策。
注入计划：最后，将o1生成的那个计划（策略）实例化，并提供给GPT-4o-mini执行。

为了让GPT-4o-mini能够对计划的每一步采取行动，它需要能够进行OpenAI函数调用。我们需要定义这些函数，每个函数对应计划中的一个步骤。

# 示例：定义一个检查生产能力的函数
function_definitions = [
    {
        "name": "check_production_capacity",
        "description": "检查在给定时间范围内的生产能力。",
        "parameters": {
            "type": "object",
            "properties": {
                "timeframe": {
                    "type": "string",
                    "enum": ["immediate", "next_week", "next_month"],
                    "description": "要检查生产能力的时间范围。"
                }
            },
            "required": ["timeframe"]
        }
    },
    # ... 其他函数定义
]

# 对应的Python执行函数
def check_production_capacity(timeframe):
    # 根据timeframe查询生产能力的逻辑
    capacity = query_capacity_from_db(timeframe)
    return {"capacity": capacity}

5. 创建编排函数

现在，我们已经定义了输入变量、两个模型的系统提示词以及函数定义，接下来可以创建一个函数，将所有部分编织在一起，以编排整个过程。

编排函数的主要步骤是：

生成计划：接收客户提供的场景，调用o1-mini生成计划。
执行计划：获取该计划，并初始化一个GPT-4o-mini工人。这个工人将循环工作，直到完成整个计划，然后返回消息记录。
返回结果：将最终结果返回给用户，告知他们我们是如何处理其给出的场景的。

def orchestrate_scenario(scenario):
    # 步骤1: 调用o1-mini生成计划
    plan = generate_plan_with_o1(scenario, o1_system_prompt)
    
    # 步骤2: 使用GPT-4o-mini执行计划
    final_messages = execute_plan_with_gpt4o(plan, gpt4_system_prompt, function_definitions)
    
    # 步骤3: 从final_messages中提取答案返回给用户
    answer = extract_answer(final_messages)
    return answer

在编排包装器内部，主要包含以下辅助函数：

append_message_function: 负责管理消息历史，为GPT-4o提供上下文。
generate_plan_with_o1: 将场景提供给o1并生成计划响应。
execute_plan_with_gpt4o: 调用GPT-4o执行o1生成的计划。这里会启动一个循环，GPT-4o-mini根据计划内容产生工具调用，并决定采取什么行动，直到收到“指令完成”的信号为止。

6. 运行示例

定义好所有变量后，剩下的就是提出一个客户希望我们执行的场景。

# 示例场景
customer_scenario = """
我们收到了一批重要的新订单。
请生成一个计划，以获取等待处理的订单列表，并确定履行这些订单的最佳策略。
计划应包括检查库存、处理积压订单、安排运输等。
在完成前应通知客户。
优先考虑尽可能发出所有可能的订单，同时为任何积压项目下订单。
"""

# 运行编排流程
result = orchestrate_scenario(customer_scenario)
print(result)

计划与执行分析

运行上述代码后，o1-mini会生成一个清晰的Markdown格式计划。例如，计划可能包括：

检索新订单（使用 fetch_new_orders 函数）。
逐个处理每个订单：提取变量、检查可用性、处理积压数量（使用 get_inventory_status, check_production_capacity 等函数，并包含if-else逻辑）。
为可用库存安排运输。
通知客户（根据订单是完全履行、部分履行还是有积压，提供不同信息）。
最终完成指令（调用 instructions_complete 函数，跳出循环）。

接着，GPT-4o-mini会严格按照这个计划执行。通过查看执行过程中的消息记录，我们可以验证它是否遵循了计划。例如，它可能依次调用了 fetch_new_orders、get_inventory_status、allocate_stock、check_available_suppliers、place_purchase_order、check_production_capacity（分立即和下周检查）、calculate_shipping_options，最后 send_order_update 给客户，并成功结束流程。

总结

本节课中，我们一起学习了如何利用o1-mini的智能规划能力与GPT-4o-mini的高效执行能力，构建一个智能体工作流。o1扮演编排者的角色，负责制定复杂的多步骤计划；而GPT-4o则作为执行者，以较低的延迟和成本按顺序执行该计划。这种模式在需要复杂推理和分步操作的任务中非常实用，例如供应链管理、复杂问题解答等。

现在，你可以退一步思考，在你的应用场景中，是否有机会使用这种规划范式，将o1的智能与GPT-4o的低延迟、低成本结合起来，处理复杂的多步骤智能体流程。

接下来，我们将把焦点从规划转向o1模型的另一个非常常见的用例：编程。期待在那里与你相见！🚀

005：编码实践 🧑‍💻

在本节课中，我们将学习如何利用o1模型来辅助编程任务。我们将通过两个具体的实验来对比o1-mini和GPT-4o模型的表现：一个是创建一个全新的React应用，另一个是编辑和优化一段已有的代码。通过实践，你将了解o1在代码生成和代码编辑方面的优势。

创建新应用

上一节我们介绍了如何利用规划来辅助任务，本节中我们来看看如何将类似的方法应用于编码任务。o1模型在创建新应用和编辑现有代码方面表现最佳，尤其是在使用简单、直接的提示时。

为了验证这一点，我们将运行两场编码竞赛：一场是使用o1-mini和GPT-4o从头创建一个全新的应用，另一场是让它们编辑一段现有的代码。

首先，我们需要导入必要的变量，例如OpenAI API密钥，以及我们将要使用的GPT-4o和o1模型。

以下是获取模型聊天补全响应的函数定义：

def get_chat_completion(model, prompt):
    # 调用OpenAI API获取响应
    response = openai.ChatCompletion.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

接下来，我们需要定义一个提示词，指导o1和GPT-4o如何思考并创建这个应用。

以下是提供给模型的提示词内容，它要求创建一个优雅、令人愉悦的面试反馈表单React组件，并给出了一些性能标准和总体目标：

请创建一个优雅、令人愉悦的React组件，用于面试反馈表单。
该表单应包含以下评分类别：技术能力、沟通技巧、问题解决能力、团队合作、总体评价。
每个类别使用1-5分的下拉菜单进行评分。
表单底部应有一个文本框用于收集总体反馈。
提交后，表单应显示一个感谢信息。
请确保UI美观、响应式，并提供清晰的视觉反馈。

现在，我们将使用GPT-4o和o1分别生成代码，然后渲染两个应用，并直观地比较它们的质量。

我们先从GPT-4o开始。让它生成应用代码，然后进行渲染。

# 使用GPT-4o生成代码
gpt4o_prompt = "请根据以上要求，生成React面试反馈表单的代码。"
gpt4o_code = get_chat_completion("gpt-4o", gpt4o_prompt)
print(gpt4o_code)

代码生成后，我们将其复制到开发环境中进行渲染。下图展示了GPT-4o生成的表单效果：

我们可以看到这是一个面试反馈表单，但外观并不理想，存在一些奇怪的格式问题。希望o1能够对此进行改进。

现在，我们使用相同的提示词，用o1模型重复这个过程。

# 使用o1生成代码
o1_prompt = "请根据以上要求，生成React面试反馈表单的代码。"
o1_code = get_chat_completion("o1-mini", o1_prompt)
print(o1_code)

代码生成后，我们同样进行渲染。下图展示了o1生成的表单效果：

我们可以看到，o1生成的无疑是一个更优秀的应用。它为不同的评分数字使用了下拉菜单，完整遵循了所有指令（而非只包含部分类别），并且提供了一个美观的绿色反馈框。

这个简单的例子展示了当你有一个应用的高层设计并希望获得一个良好的起点时，o1如何提供帮助。在相同的提示下，o1通常能比GPT-4o走得更远一些。

如果你想亲自尝试这段代码，可以按照Notebook中的说明，将代码复制到编辑器中，它将渲染出表单。你可以看到在填写内容时推荐信息的变化，并且可以提交反馈。Notebook中还提供了如何下载包含可在本地计算机上运行的应用程序的zip文件的说明。

编辑现有代码

接下来，我们将转向编辑现有代码，展示o1如何提供有用的反馈，从而再次产生优于GPT-4o的代码。

为了比较GPT-4o和o1的代码编辑能力，我们准备了一段存在明显问题的代码，例如多重嵌套循环、缺乏错误处理，并且整体可读性不佳。

我们将这段代码同时提供给两个模型，观察它们如何清理代码。然后，我们将使用o1模型作为“裁判”来评估两个生成的代码块，并告诉我们哪个更好。

我们再次从一个简单直接的提示词开始，首先使用GPT-4o进行生成。

提示词如下：“我有一段需要清理和改进的代码，请只返回修复了问题的更新后的代码。”然后附上我们之前展示的代码片段。

# 待改进的原始代码
problematic_code = """
def process_data(data):
    result = []
    for i in range(len(data)):
        for j in range(len(data[i])):
            for k in range(len(data[i][j])):
                val = data[i][j][k]
                if val > 0:
                    result.append(val * 2)
    return result
"""

# 使用GPT-4o改进代码
edit_prompt_gpt4o = f"请清理并改进以下代码，只返回更新后的代码：\n{problematic_code}"
gpt4o_edited_code = get_chat_completion("gpt-4o", edit_prompt_gpt4o)
print("GPT-4o改进后的代码：")
print(gpt4o_edited_code)

现在，我们生成改进后的代码。乍一看，结果似乎好了一些。但让我们生成o1的代码，然后用大语言模型作为裁判来比较两者。

# 使用o1改进代码
edit_prompt_o1 = f"请清理并改进以下代码，只返回更新后的代码：\n{problematic_code}"
o1_edited_code = get_chat_completion("o1-mini", edit_prompt_o1)
print("o1改进后的代码：")
print(o1_edited_code)

同样，结果看起来是合理的。但最好的判断方法是利用AI来比较两者。我们使用o1作为评分员，因为在这种需要细微、多步骤推理的过程中，o1通常比GPT-4o表现更好。

我们再次使用一个简单直接的提示词：“哪段代码更好？为什么？选项1是GPT-4o的代码，选项2是o1的代码。”

# 使用o1作为裁判进行评估
judge_prompt = f"""
请评估以下两段代码，指出哪段更好并说明原因。
选项1 (GPT-4o):
{gpt4o_edited_code}

选项2 (o1):
{o1_edited_code}

请只返回评估结果，格式为：'更好的代码是：选项X。原因：...'
"""
judgment = get_chat_completion("o1-mini", judge_prompt)
print("裁判评估结果：")
print(judgment)

评估结果已出。o1推断两者都在尝试做同一件事，但两个实现之间存在几个关键差异，使得选项2（o1的代码）更好。它指出了可读性和结构、错误处理和健壮性（选项2选择了更有效的方法）、数据处理和计算、调试和日志记录以及一般的性能考虑。

这再次提供了一个有用的例子，说明即使你不依赖GPT-4o作为代码编辑器或代码助手来帮助你解决问题和编辑现有代码，o1在这方面也表现得相当出色。

总结

本节课中，我们一起学习了如何使用o1来辅助编程。无论是创建全新的应用程序，还是帮助改进现有代码，o1都能提供有力的支持。特别是在你拥有高层设计并希望获得一个出色的初步实现时，o1展现出了巨大的潜力。我们期待在下一阶段与你一起，探索o1如何在图像上进行推理。

006：图像推理 🖼️

在本节课中，我们将要学习如何利用o1模型进行图像理解。我们将探讨o1与GPT-4在图像理解能力上的差异，并通过一个组织架构图的实际案例，演示如何将图像信息提取为结构化数据，以便进行后续的文本问答分析。

模型图像理解能力对比

上一节我们介绍了o1模型的基本推理原理，本节中我们来看看它在图像理解方面的具体表现。

GPT-4在理解图像方面可以表现良好，但通常需要思维链提示、少量示例或微调才能达到最佳效果。

相反，o1在开箱即用的情况下就能很好地理解图像。这是由于它在推理过程中遵循的“测试与学习”方法，使其在提供答案之前有多次机会检测幻觉。

一个新兴的用例是预先承担o1的延迟和成本，对图像进行预处理，并用丰富的细节为其建立索引，以便后续用于问答。这很有趣。

实战：处理组织架构图

对于这个图像推理任务，我们将使用一个虚构组织的架构图。这是一种包含空间推理的微妙图表，GPT-4通常会在此类图表上产生幻觉，但我们发现o1的表现要好得多。这归功于我们之前提到的测试与学习方法，它会先对图表传达的信息形成初步印象，然后不断迭代，直到认为自己对该图表的用途有了一个像样的概述。

我们将从相当基础的问题开始，先让o1告诉我们这是什么，然后我们将转向一个我们发现客户在现实世界中经常使用的实际用例：使用o1进行图像理解，并提取一个详细的JSON来描述该图像及其中的详细内容，然后你可以进行纯文本的后续操作来解释这些信息。这样，你就不必每次都为处理图像支付额外的成本和延迟，而是用o1以高质量、详细的方式有效地预处理它，然后将其用于后续的问答。

让我们继续，看看这在实践中是如何运作的。和往常一样，我们将从导入开始。

环境准备

以下是我们的标准库，我们将视觉请求存储在一个工具文件中，并在这里导入。为此，我们将使用新的主线o1模型，因为它是能够进行图像推理的模型。

# 导入必要的库和变量
import openai
from utils import vision_request

为了理解我们将要处理的图像，你应该打开我们提供的组织架构图文件。你将能够看到，顶部有一位CEO，下面是他们的C级高管、经理，然后是这些经理的下属。

基础图像描述

我们将从一个简单的问题开始：“这是什么？”，以便获得该组织架构图图像中包含内容的详细说明。

# 发起一个简单的图像描述请求
prompt_basic = "What is this?"
response_basic = vision_request(prompt_basic, image_path="org_chart.png", model="o1")
print(response_basic)

模型会给你一个详细的说明：这是一个组织结构图，它指出了不同的层级，并简要描述了图表的组织方式和目的。

这很有信息量，但不是特别有用，所以我们接下来要做的是将其处理成数据，以便我们可以用于后续问题，从而在此组织架构图的基础上进行分析，并理解这些不同角色如何相互关联的细节。

提取结构化数据

我们即将在这里进行的工作，是我们开始真正看到从GPT-4到o1在图像理解质量方面的改进。我们之前在GPT-4上看到的是，它通常可以对图像内容给出一个高层次的描述。但一旦你开始询问关于空间推理的微妙问题，比如那个箭头指向什么，或者组织架构图中谁向谁汇报，GPT-4的表现会不一致，通常需要少量示例或微调才能达到体面的性能水平。

我们在这里用o1应该看到的是，开箱即用，它的表现会相当好，并且能够将我们相当复杂的组织架构图简化为一个简单的JSON数组，然后我们可以用它进行分析。

为了实现这一点，我们这里有一个结构化的提示，再次运用我们在第2课中学到的原则。我们有一些指令，其中有一个处理组织数据的咨询助手，我们希望它提取组织层级。我们为它指定了我们想要的JSON格式。

# 用于提取组织层级结构的结构化提示
prompt_extract = """
You are a consulting assistant who processes organizational data.
Extract the hierarchy from the provided organizational chart image.

Return the data as a JSON array of objects. Each object should represent a person and have the following keys:
- `id`: An arbitrary unique integer ID for the person.
- `name`: The person's name.
- `role`: The person's role/title.
- `reports_to`: An array of IDs representing who this person reports to. (Empty array if they report to no one).
- `direct_reports`: An array of IDs representing who reports directly to this person.
"""

所以我们希望它为每个人编造一个任意的ID、姓名、角色，然后给我们一个他们汇报对象的ID数组和一个向他们汇报的ID数组。一旦我们有了这个，我们就有了将图像中的关系编码为数据的东西，并使其能够进行持续处理。

# 执行提取请求
response_extract = vision_request(prompt_extract, image_path="org_chart.png", model="o1")
print(response_extract)

你执行这个单元格，我们打印出提示。现在，你可以将该提示与图像一起输入到o1请求中。如果我们运行它并打印结果，我们应该收到一个JO字典数组，它描述了该组织架构图中的不同人员以及他们彼此之间的关系。

你现在可以在面前看到该组织架构图的数据表示了。我们得到了我们的字典数组。每个都包含那个任意的ID。如果我们只核对第一个，我们有Juliana Silva，CEO，ID 1，我们可以看到她不向任何人汇报，她是CEO，这是正确的，她的下属是编号2、3和4。如果我们检查2、3和4，这些确实是CFO、CTO、COO，很好。

基于数据的问答分析

现在你已经将这个组织架构图简化为数据，你现在可以用它进行分析了，所以让我们继续，在此数据基础上做一些问答，看看o1是否能够使用处理过的数据来准确回答一些关于组织架构图的问题。

你可以先加载o1的响应，假设它是JSON。然后我们可以创建一个提示，将这些数据添加到其中，然后向它提问。

import json

# 假设 response_extract.content 包含 JSON 字符串
org_data = json.loads(response_extract.content)

# 创建分析提示
analysis_prompt = f"""
You are an org chart expert assistant. Your role is to answer any org chart questions using the provided organizational data.

<org_data>
{json.dumps(org_data, indent=2)}
</org_data>
"""

在你向AI数据提出分析问题之前，你需要初始化一个新的OpenAI客户端。我们不使用o1视觉请求的原因是，我们现在只是发出一个纯文本请求。既然我们已经预处理了那个图像，我们不需要每次发送图像，我们只是使用我们提取的数据，并用它进行我们的问答。

# 初始化OpenAI客户端（纯文本）
client = openai.OpenAI(api_key="your-api-key")

# 构建包含数据和问题的请求
question = """
Based on the organizational data provided:
1. Who has the highest-ranking direct reports?
2. Which manager has the most direct reports?
"""

full_prompt = analysis_prompt + "\n\n" + question

response_analysis = client.chat.completions.create(
    model="gpt-4", # 或任何适合纯文本分析的模型
    messages=[
        {"role": "user", "content": full_prompt}
    ]
)

这里你有一个简单的请求。你有了开头的分析提示，然后这里有一个结构化的问题。其中包含两个问题。1. 谁拥有最高级别的直接下属？2. 哪个经理拥有最多的直接下属？

# 打印分析结果
print(response_analysis.choices[0].message.content)

你可以将结果显示为Markdown。我们可以解读我们得到的答案。首先，Juliana Silva，CEO，拥有最高级别的直接下属。这是正确的。她所有的下属都是C级高管。哪个经理拥有最多的下属？首先，它成功地筛选出只有角色为经理的人。确实，这两个人确实拥有最多的直接下属。所以这是对问题的正确答案，也是我们图像理解任务的结论。

扩展练习：实体关系图

在我们结束之前，我想再分享一个例子，以便你可以将所学知识应用并测试到一个新的图像和领域。

在文件夹中，你可以看到我们包含的一张实体关系图照片。这是图像理解的一个很好的用例。想象一下你处理过的所有数据仓库，都有一个复杂的ERD，需要本地的数据科学家或仓库的所有者为你讲解。现在，我们可以通过图像理解将其提供给o1，并让它为你解析。

所以，给你的挑战是为这个实体关系图想出几个用例。例如，你可能想要求具有视觉功能的o1生成一个订单记录表，这些记录具有链接到这些产品和客户表的ID，然后让它生成SQL来实际查询这三个表。在这些情况下，生成合成数据是我们为客户站点使用视觉功能的一个很好的用例。

我们非常有兴趣看到你想出什么用例，并且非常兴奋地看到你将o1与图像理解用于什么用途。

期待在下一课与你见面，我们将深入探讨提示工程，如何使用o1自动优化你的提示。期待在那里见到你。

总结

本节课中我们一起学习了o1模型在图像推理方面的强大能力。我们了解到o1通过其“测试与学习”的推理方法，在开箱即用的情况下就能出色地理解复杂图像，避免了GPT-4可能产生的幻觉问题。通过将组织架构图提取为结构化JSON数据的实战案例，我们掌握了如何利用o1预处理图像信息，并将其转化为可用于高效、低成本后续问答分析的数据源。最后，我们探讨了将此方法应用于实体关系图等其他领域的可能性。

007：元提示工程 🧠

在本节课中，我们将学习如何使用更智能的模型（如o1）来迭代优化一个相对简单的模型（如GPT-4o）的指令，这个过程被称为“元提示工程”。我们将通过一个具体的用例——将面向人类的知识库文章转换为适合LLM执行的“规程”——来演示这一过程。

概述

优化大型语言模型以达到生产级别的准确性，是开发者面临的主要挑战之一。面对众多的提示工程、RAG和微调方法，如何确定正确的优化方向并解决评估问题，本身就是一个难题。幸运的是，o1模型似乎非常擅长处理这类用例。本节课程将重点介绍如何使用o1-mini，结合一组评估集，来优化特定任务的提示，并提升评估分数。

步骤一：从原始策略生成规程

上一节我们介绍了元提示工程的概念，本节中我们来看看具体如何操作。首先，我们需要将面向人类编写的知识库策略，转换为适合LLM执行的“规程”。

我们以一份航班取消与改签政策为例。这份政策是为人类客服设计的，内容分散，没有明确告知LLM哪些是外部操作，哪些可以直接执行。我们的第一步是使用o1来重写这份政策，使其指令更清晰、更易于LLM可靠地遵循。

以下是用于转换的提示词，它定义了目标并给出了转换过程的指令：

conversion_prompt = """
目标：将面向人类客服的策略文档，转换为适合LLM执行的、结构化的规程。
指令：
1. 仔细阅读提供的策略文档。
2. 将策略中的各个流程分解为独立的、有明确界限的指令集。
3. 为每个指令步骤指定LLM应调用的函数。
4. 确保规程易于程序化地遵循和执行。
5. 只使用提供的函数列表，不要创建新的函数。
6. 输出格式请遵循指定的结构化格式。

![](https://github.com/OpenDocCN/dsai-notes-pt1-zh/raw/master/docs/dlai-o1-rsn/img/0a4ffbd0d05c5d5d2bf4b76113738b83_13.png)

请将以下策略转换为格式化的规程：
{policy}
"""

我们定义一个函数来执行此转换：

def generate_routine(policy):
    response = client.chat.completions.create(
        model="o1-mini",
        messages=[
            {"role": "system", "content": "你是一个将人类策略转换为LLM规程的助手。"},
            {"role": "user", "content": conversion_prompt.format(policy=policy)}
        ]
    )
    return response.choices[0].message.content

运行此函数后，我们得到了第一个由LLM生成的规程。这个规程将原始策略中的复杂流程分解为清晰的、分步骤的指令，并为每个步骤指定了应调用的函数，使得LLM的逻辑判断（如if-then-else）变得更加简单。

在评估之前，我们需要检查生成的规程是否存在数据质量问题，例如是否使用了未定义的函数。

步骤二：评估规程性能

在生成了初始规程之后，我们需要评估它的性能。本节我们将建立一个多轮对话评估框架。

评估的核心思想是模拟一个真实的客户服务场景。我们有一个评估集，其中每个例子都包含：

客户请求：对话的起始点。
客户信息：用于模拟客户在对话中提供的信息。
预期响应：正确的最终响应（包括调用的工具和参数）。

我们设计多轮评估是因为客户服务通常是多回合的。流程如下：

将o1生成的规程作为策略提供给GPT-4o智能体。
从一个硬编码的客户请求开始。
同时启动一个模拟客户，它根据评估集中定义的信息与智能体进行多轮对话。
对话持续进行，直到智能体调用一个“退出工具”（如退款、改签），此时对话终止。
对于每个评估记录，我们评估两点：是否正确调用了工具，以及是否提供了正确的参数。

以下是评估循环中处理单行评估数据的核心函数逻辑：

def process_row(row, policy, model):
    # 初始化客户系统提示词，包含基本信息
    customer_sys_prompt = f"""你是客户。{row['context']} 你的名字是{row['name']}，预订号是{row['booking_reference']}，航班号是{row['flight_number']}。"""
    transcript = [{"role": "user", "content": row['request']}]

    for turn in range(MAX_TURNS):
        # 获取智能体响应
        agent_response = get_agent_response(transcript, policy, model)
        transcript.append({"role": "assistant", "content": agent_response})

        # 检查是否调用了工具
        if tool_called(agent_response):
            tool_name = extract_tool_name(agent_response)
            if tool_name in EXIT_TOOLS:
                # 对话结束，评估结果
                return evaluate_result(row, tool_name, agent_response)
            else:
                # 模拟工具执行结果，并生成客户回复，继续对话
                tool_result = simulate_tool_call(tool_name, row)
                customer_reply = generate_customer_reply(tool_result, row)
                transcript.append({"role": "user", "content": customer_reply})
        else:
            # 智能体未调用工具，生成客户回复继续对话
            customer_reply = generate_customer_reply(None, row)
            transcript.append({"role": "user", "content": customer_reply})
    return None  # 超过最大轮数，评估失败

运行基线评估后，我们得到了一个准确率（例如65%）。通过查看错误案例，我们可以发现智能体在遵循规程时出现的问题，例如错误地提供了航班积分而非部分退款，或者在多轮对话中未能成功获取必要信息。

步骤三：通过元提示工程优化规程

有了基线评估结果，我们现在进入最关键的步骤：使用元提示工程来优化GPT-4o的规程。

元提示工程的核心是让更智能的o1模型分析评估结果，找出规程中的问题，并生成改进后的新规程。我们将进行多次迭代。

首先，我们定义向o1发送的元提示词。这个提示词需要包含：

o1的角色定义（优化指令的智能体）。
优化目标（分析问题、改进规程、确保合规）。
提供的材料（原始策略、可用函数列表、当前规程、评估结果，可能还有历史编辑记录）。
输出格式要求（使用JSON结构化输出，返回更新后的规程）。

meta_prompt = """
你是一个负责优化指令质量的智能体。你被给予以下材料：
1. 原始的人类编写策略。
2. 可用的函数列表。
3. 当前的LLM规程指令。
4. 使用该规程在评估集上的结果。

请分析现有指令，找出任何问题。改进它们以解决发现的不足，并确保所有更改都符合原始策略。你只能使用提供的工具列表。

请将改进后的规程以以下JSON格式返回：
{{
  "updated_routine": "这里放置完整的、改进后的规程文本"
}}
"""

接下来，我们设置元提示循环。循环多次（例如3次），每次：

将当前规程、评估结果和历史信息（在token限制内）发送给o1。
o1分析并生成新的规程。
使用新规程在评估集上再次运行评估。
记录新的准确率。
为下一次迭代准备数据。

以下是循环的核心逻辑：

routines = [initial_routine]
results = []
accuracies = []

for i in range(NUM_ITERATIONS):
    # 准备发送给o1的消息，包含历史数据
    messages_for_o1 = prepare_messages(original_policy, available_functions, routines[-1], results, accuracies)

    # 从o1获取更新后的规程
    response = get_openai_response(model="o1", messages=messages_for_o1, response_format=json_schema)
    new_routine = response.parsed.updated_routine
    routines.append(new_routine)

    # 使用新规程进行评估
    new_results_df, new_accuracy = run_evaluation(new_routine, eval_dataset)
    results.append(new_results_df)
    accuracies.append(new_accuracy)

    print(f"Iteration {i+1} Accuracy: {new_accuracy:.2%}")

运行元提示循环后，我们观察到准确率的变化。例如，基线为65%，第一次迭代后可能变为71%，第二次迭代后提升到88%，第三次迭代可能略有回落到82%。我们会选择准确率最高的规程（如第二次迭代的88%）作为最终优化结果。

检查这个最佳规程，我们发现o1可能采用了一些非传统的优化方式，例如改变了步骤的注释格式或调整了逻辑顺序，从而显著提升了性能。

总结

本节课中我们一起学习了元提示工程的完整流程。

我们首先从一个为人类客服编写的知识库策略出发，使用o1将其转换为适合LLM执行的规程。接着，我们创建了一个多轮对话评估框架，模拟AI客户与基于规程的AI智能体之间的交互，并得到了基线评估分数。

由于对基线结果不满意，我们进行了第三步——元提示工程。通过多次迭代，让o1分析评估结果并优化规程，最终成功将评估准确率从基线水平显著提升。

元提示工程不仅适用于客户服务场景，任何涉及多轮对话、需要迭代优化变量或工具使用的复杂任务，都可以应用这种方法。希望本课程能为你提供启发，并期待看到你利用这些能力构建出出色的应用。

008：结论

在本节课中，我们将回顾并总结关于推理模型的核心知识，包括其工作原理、提示方法以及实际应用案例。

课程回顾 🧠

上一节我们探讨了推理模型的具体应用场景，本节中，我们将对整个课程内容进行总结。

在本课程中，你学习了我们的推理模型如何工作，以及如何对它们进行提示。

你还了解了一些开发者正在现实世界中交付的优秀应用案例。

你现在已经掌握了开始使用这类新型模型进行构建所需的知识。

我们非常期待看到你将创造出什么。

本节课中我们一起学习了推理模型的基础原理、提示技巧及其多样化的实际应用。你现在已经具备了利用这类强大模型进行创新开发的基础。

posted @ 2026-03-26 08:12 绝不原创的飞龙阅读(1) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈