大模型系列：OpenAI使用技巧_Assistants API 概述

新的 助手API是我们 聊天完成API的有状态演进，旨在简化助手式体验的创建，并使开发者可以访问强大的工具，如代码解释器和检索。

Chat Completions API vs Assistants API

聊天完成 API 的基本元素是 Messages，您可以使用 Model（gpt-3.5-turbo、gpt-4 等）对其执行 Completion。它轻巧而强大，但本质上是无状态的，这意味着您必须手动管理对话状态、工具定义、检索文档和代码执行。

助手 API 的基本元素是：

• Assistants，它们封装了基本模型、指令、工具和（上下文）文档，
• Threads，它们表示对话的状态，以及
• Runs，它们驱动在 Thread 上执行 Assistant，包括文本响应和多步骤工具使用。

我们将看看如何使用它们创建强大的有状态体验。

设置

Python SDK

注意
我们已经更新了我们的Python SDK，以支持助手API，所以您需要将其更新到最新版本（写作时为1.2.3）。

# 安装openai库的最新版本
!pip install --upgrade openai
1
2

并确保通过运行来更新它：

# 打印openai库的版本信息
!pip show openai | grep Version
1
2
3
4

Version: 1.2.3
1

Pretty Printing Helper

# 导入json模块
import json

# 定义一个函数show_json，参数为obj
def show_json(obj):
    # 调用json模块的loads方法，将obj的model_dump_json()方法返回的json字符串转换为Python对象
    # 然后通过display函数展示出来
    display(json.loads(obj.model_dump_json()))
1
2
3
4
5
6
7
8

带有助手 API 的完整示例

助理们

使用助手API最简单的方法是通过助手游乐场开始。

让我们首先创建一个助手！我们将创建一个数学导师，就像我们的文档中所示。

您可以在助手仪表板中查看您创建的助手。

您还可以通过Assistants API直接创建助手，如下所示：

# 导入OpenAI模块

from openai import OpenAI

# 创建OpenAI客户端实例

client = OpenAI()

# 创建助手
# 指定助手的名称为"Math Tutor"
# 指定助手的指令为"你是一位个人数学导师。简要回答问题，用一句话或更少的话。"
# 指定助手的模型为"gpt-4-1106-preview"

assistant = client.beta.assistants.create(
    name="Math Tutor",
    instructions="You are a personal math tutor. Answer questions briefly, in a sentence or less.",
    model="gpt-4-1106-preview",
)

# 显示助手的JSON信息

show_json(assistant)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

{'id': 'asst_9HAjl9y41ufsViNcThW1EXUS',
 'created_at': 1699828331,
 'description': None,
 'file_ids': [],
 'instructions': 'You are a personal math tutor. Answer questions briefly, in a sentence or less.',
 'metadata': {},
 'model': 'gpt-4-1106-preview',
 'name': 'Math Tutor',
 'object': 'assistant',
 'tools': []}
1
2
3
4
5
6
7
8
9
10

无论您是通过仪表板还是API创建助手，您都需要记住助手ID。这是您在Threads和Runs中引用助手的方式。

接下来，我们将创建一个新的线程并向其添加一条消息。这将保存我们对话的状态，这样我们就不必每次都重新发送整个消息历史记录。

线程

创建一个新线程：

# 创建一个新的线程
thread = client.beta.threads.create()
# 打印线程的信息
show_json(thread)
1
2
3
4

{'id': 'thread_bw42vPoQtYBMQE84WubNcJXG',
 'created_at': 1699828331,
 'metadata': {},
 'object': 'thread'}
1
2
3
4

然后将消息添加到线程中：

# 创建一个新的消息对象
message = client.beta.threads.messages.create(
    thread_id=thread.id,  # 指定消息所属的线程ID
    role="user",  # 指定消息的角色为用户
    content="I need to solve the equation `3x + 11 = 14`. Can you help me?",  # 指定消息的内容为需要解决的方程
)

# 调用show_json函数显示消息对象的JSON表示
show_json(message)
1
2
3
4
5
6
7
8
9

{'id': 'msg_IBiZDAWHhWPewxzN0EfTYNew',
 'assistant_id': None,
 'content': [{'text': {'annotations': [],
    'value': 'I need to solve the equation `3x + 11 = 14`. Can you help me?'},
   'type': 'text'}],
 'created_at': 1699828332,
 'file_ids': [],
 'metadata': {},
 'object': 'thread.message',
 'role': 'user',
 'run_id': None,
 'thread_id': 'thread_bw42vPoQtYBMQE84WubNcJXG'}
1
2
3
4
5
6
7
8
9
10
11
12

注意
即使您不再每次发送完整的历史记录，每次运行仍将收取整个对话历史记录的令牌费用。

运行

注意我们创建的线程与之前创建的助手没有关联！线程存在于助手之外，这可能与您使用ChatGPT（其中线程与模型/GPT绑定）时的预期不同。

要为给定的线程获取助手的完成，我们必须创建一个运行。创建运行将指示助手查看线程中的消息并采取行动：通过添加单个响应或使用工具。

注意
运行是助手API和聊天完成API之间的一个关键区别。在聊天完成中，模型只会回复一条消息，而在助手API中，运行可能导致助手使用一个或多个工具，并可能向线程添加多条消息。

为了让我们的助手回复用户，让我们创建运行。如前所述，您必须同时指定助手和线程。

# 创建运行实例
run = client.beta.threads.runs.create(
    thread_id=thread.id,  # 指定线程ID
    assistant_id=assistant.id,  # 指定助手ID
)

# 显示运行实例的JSON数据
show_json(run)
1
2
3
4
5
6
7
8

{'id': 'run_LA08RjouV3RemQ78UZXuyzv6',
 'assistant_id': 'asst_9HAjl9y41ufsViNcThW1EXUS',
 'cancelled_at': None,
 'completed_at': None,
 'created_at': 1699828332,
 'expires_at': 1699828932,
 'failed_at': None,
 'file_ids': [],
 'instructions': 'You are a personal math tutor. Answer questions briefly, in a sentence or less.',
 'last_error': None,
 'metadata': {},
 'model': 'gpt-4-1106-preview',
 'object': 'thread.run',
 'required_action': None,
 'started_at': None,
 'status': 'queued',
 'thread_id': 'thread_bw42vPoQtYBMQE84WubNcJXG',
 'tools': []}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

与在聊天完成API中创建完成不同，创建运行是一个异步操作。它将立即返回运行的元数据，其中包括一个status，最初将设置为queued。当助手执行操作（如使用工具和添加消息）时，status将被更新。

为了知道助手何时完成处理，我们可以在循环中轮询运行。（流支持即将推出！）虽然在这里我们只检查queued或in_progress状态，但在实践中，运行可能会经历各种状态更改，您可以选择将其呈现给用户。（这些称为步骤，稍后将介绍。）

# 定义一个函数，参数为run和thread
def wait_on_run(run, thread):
    # 当run的状态为"queued"或"in_progress"时，执行循环
    while run.status == "queued" or run.status == "in_progress":
        # 通过client.beta.threads.runs.retrieve()方法获取run的信息
        run = client.beta.threads.runs.retrieve(
            thread_id=thread.id,
            run_id=run.id,
        )
        # 等待0.5秒
        time.sleep(0.5)
    # 返回run
    return run
1
2
3
4
5
6
7
8
9
10
11
12
13

# 定义一个函数wait_on_run，该函数接收两个参数run和thread，用于等待线程的运行
run = wait_on_run(run, thread)

# 调用函数show_json，将run以json格式输出
show_json(run)
1
2
3
4
5

{'id': 'run_LA08RjouV3RemQ78UZXuyzv6',
 'assistant_id': 'asst_9HAjl9y41ufsViNcThW1EXUS',
 'cancelled_at': None,
 'completed_at': 1699828333,
 'created_at': 1699828332,
 'expires_at': None,
 'failed_at': None,
 'file_ids': [],
 'instructions': 'You are a personal math tutor. Answer questions briefly, in a sentence or less.',
 'last_error': None,
 'metadata': {},
 'model': 'gpt-4-1106-preview',
 'object': 'thread.run',
 'required_action': None,
 'started_at': 1699828332,
 'status': 'completed',
 'thread_id': 'thread_bw42vPoQtYBMQE84WubNcJXG',
 'tools': []}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Messages

现在运行已经完成，我们可以列出线程中的消息，看看助手添加了什么。

# 获取指定线程的所有消息
messages = client.beta.threads.messages.list(thread_id=thread.id)

# 打印消息的 JSON 格式
show_json(messages)
1
2
3
4
5

{'data': [{'id': 'msg_S0ZtKIWjyWtbIW9JNUocPdUS',
   'assistant_id': 'asst_9HAjl9y41ufsViNcThW1EXUS',
   'content': [{'text': {'annotations': [],
      'value': 'Yes. Subtract 11 from both sides to get `3x = 3`, then divide by 3 to find `x = 1`.'},
     'type': 'text'}],
   'created_at': 1699828333,
   'file_ids': [],
   'metadata': {},
   'object': 'thread.message',
   'role': 'assistant',
   'run_id': 'run_LA08RjouV3RemQ78UZXuyzv6',
   'thread_id': 'thread_bw42vPoQtYBMQE84WubNcJXG'},
  {'id': 'msg_IBiZDAWHhWPewxzN0EfTYNew',
   'assistant_id': None,
   'content': [{'text': {'annotations': [],
      'value': 'I need to solve the equation `3x + 11 = 14`. Can you help me?'},
     'type': 'text'}],
   'created_at': 1699828332,
   'file_ids': [],
   'metadata': {},
   'object': 'thread.message',
   'role': 'user',
   'run_id': None,
   'thread_id': 'thread_bw42vPoQtYBMQE84WubNcJXG'}],
 'object': 'list',
 'first_id': 'msg_S0ZtKIWjyWtbIW9JNUocPdUS',
 'last_id': 'msg_IBiZDAWHhWPewxzN0EfTYNew',
 'has_more': False}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

正如您所看到的，消息按照时间倒序排序 - 这样做是为了最新的结果始终在第一页（因为结果可以分页）。请注意这一点，因为这与聊天完成 API 中的消息顺序相反。

让我们请助手进一步解释一下结果！

# 创建要附加到我们线程的消息
message = client.beta.threads.messages.create(
    thread_id=thread.id, role="user", content="Could you explain this to me?"
)

# 执行我们的运行
run = client.beta.threads.runs.create(
    thread_id=thread.id,
    assistant_id=assistant.id,
)

# 等待完成
wait_on_run(run, thread)

# 检索在我们最后一条用户消息之后添加的所有消息
messages = client.beta.threads.messages.list(
    thread_id=thread.id, order="asc", after=message.id
)
show_json(messages)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

{'data': [{'id': 'msg_9MAeOrGriHcImeQnAzvYyJbs',
   'assistant_id': 'asst_9HAjl9y41ufsViNcThW1EXUS',
   'content': [{'text': {'annotations': [],
      'value': 'Certainly. To solve for x in the equation `3x + 11 = 14`:\n\n1. Subtract 11 from both sides: `3x + 11 - 11 = 14 - 11` simplifies to `3x = 3`.\n2. Divide both sides by 3: `3x / 3 = 3 / 3` simplifies to `x = 1`.\n\nSo, the solution is `x = 1`.'},
     'type': 'text'}],
   'created_at': 1699828335,
   'file_ids': [],
   'metadata': {},
   'object': 'thread.message',
   'role': 'assistant',
   'run_id': 'run_IFHfsubkJv7RSUbDZpNVs4PG',
   'thread_id': 'thread_bw42vPoQtYBMQE84WubNcJXG'}],
 'object': 'list',
 'first_id': 'msg_9MAeOrGriHcImeQnAzvYyJbs',
 'last_id': 'msg_9MAeOrGriHcImeQnAzvYyJbs',
 'has_more': False}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这可能会感觉像是一系列繁琐的步骤来获取回应，尤其对于这个简单的例子来说。然而，您很快就会看到，我们可以在不改变太多代码的情况下为我们的助手添加非常强大的功能！

示例

让我们来看看如何将所有这些组合在一起。下面是您需要使用已创建的助手的所有代码。

由于我们已经创建了我们的数学助手，我已经将其ID保存在MATH_ASSISTANT_ID中。然后我定义了两个函数：

• submit_message：在线程上创建一条消息，然后启动（并返回）一个新的运行
• get_response：返回线程中的消息列表

# 导入OpenAI模块
from openai import OpenAI

# 定义一个常量，存储机器人的ID
MATH_ASSISTANT_ID = assistant.id  # 或者像 "asst-..." 这样硬编码一个ID

# 创建一个OpenAI客户端
client = OpenAI()

# 定义一个函数，用于向对话线程中提交用户消息
def submit_message(assistant_id, thread, user_message):
    # 向对话线程中添加用户消息
    client.beta.threads.messages.create(
        thread_id=thread.id, role="user", content=user_message
    )
    # 返回一个新的对话运行实例
    return client.beta.threads.runs.create(
        thread_id=thread.id,
        assistant_id=assistant_id,
    )

# 定义一个函数，用于获取对话线程中机器人的回复
def get_response(thread):
    # 获取对话线程中的消息列表，并按时间升序排列
    return client.beta.threads.messages.list(thread_id=thread.id, order="asc")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

我还定义了一个create_thread_and_run函数，我可以重复使用（实际上与我们API中的client.beta.threads.create_and_run复合函数几乎完全相同;)）。最后，我们可以将模拟用户请求提交到新的线程中。

请注意，所有这些API调用都是异步操作；这意味着我们在代码中实际上获得了异步行为，而无需使用异步库！（例如asyncio）

# 定义一个函数create_thread_and_run，用于创建线程并运行
def create_thread_and_run(user_input):
    # 创建一个线程
    thread = client.beta.threads.create()
    # 提交用户输入的消息，并返回运行结果
    run = submit_message(MATH_ASSISTANT_ID, thread, user_input)
    # 返回线程和运行结果
    return thread, run


# 模拟并发用户请求
# 创建线程1并运行
thread1, run1 = create_thread_and_run(
    "I need to solve the equation `3x + 11 = 14`. Can you help me?"
)
# 创建线程2并运行
thread2, run2 = create_thread_and_run("Could you explain linear algebra to me?")
# 创建线程3并运行
thread3, run3 = create_thread_and_run("I don't like math. What can I do?")

# 现在所有的运行都在执行中...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

一旦所有运行都开始了，我们可以等待每一个并获取响应。

# 导入time模块

import time

# 定义一个pretty_print函数，用于打印消息
def pretty_print(messages):
    print("# Messages")
    # 遍历消息列表，打印每个消息的角色和内容
    for m in messages:
        print(f"{m.role}: {m.content[0].text.value}")
    print()

# 定义一个wait_on_run函数，用于等待运行完成
def wait_on_run(run, thread):
    # 当运行状态为"queued"或"in_progress"时，循环等待
    while run.status == "queued" or run.status == "in_progress":
        # 获取运行状态
        run = client.beta.threads.runs.retrieve(
            thread_id=thread.id,
            run_id=run.id,
        )
        # 等待0.5秒
        time.sleep(0.5)
    # 返回运行状态
    return run

# 等待Run 1完成
run1 = wait_on_run(run1, thread1)
# 打印Thread 1的响应消息
pretty_print(get_response(thread1))

# 等待Run 2完成
run2 = wait_on_run(run2, thread2)
# 打印Thread 2的响应消息
pretty_print(get_response(thread2))

# 等待Run 3完成
run3 = wait_on_run(run3, thread3)
# 打印Thread 3的响应消息
pretty_print(get_response(thread3))

# 在Thread 3上感谢我们的助手 :)
run4 = submit_message(MATH_ASSISTANT_ID, thread3, "Thank you!")
# 等待Run 4完成
run4 = wait_on_run(run4, thread3)
# 打印Thread 3的响应消息
pretty_print(get_response(thread3))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# Messages
user: I need to solve the equation `3x + 11 = 14`. Can you help me?
assistant: Yes, subtract 11 from both sides to get `3x = 3`, then divide both sides by 3 to find `x = 1`.

# Messages
user: Could you explain linear algebra to me?
assistant: Linear algebra is the branch of mathematics that deals with vector spaces, linear equations, and matrices, focusing on the properties and operations that can be applied to vectors and linear transformations.

# Messages
user: I don't like math. What can I do?
assistant: Try finding aspects of math that relate to your interests or daily life, and consider a tutor or interactive resources to make learning more enjoyable.

# Messages
user: I don't like math. What can I do?
assistant: Try finding aspects of math that relate to your interests or daily life, and consider a tutor or interactive resources to make learning more enjoyable.
user: Thank you!
assistant: You're welcome! If you have any more questions, feel free to ask.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

你可能已经注意到，这段代码实际上并不是针对我们的数学助手而言的… 只需更改助手ID，这段代码就可以适用于您创建的任何新助手！这就是助手API的威力。

工具

助手API的一个关键特性是能够为助手配备工具，例如代码解释器、检索和自定义函数。让我们逐个来看一下。

代码解释器

让我们为我们的数学导师配备代码解释器工具，我们可以从仪表板上完成这个操作…

…或者使用助手ID，通过API进行操作。

# 更新数学助手
assistant = client.beta.assistants.update(
    MATH_ASSISTANT_ID,  # 数学助手的ID
    tools=[{"type": "code_interpreter"}],  # 添加一个代码解释器工具
)

# 显示助手的JSON信息
show_json(assistant)
1
2
3
4
5
6
7
8

{'id': 'asst_9HAjl9y41ufsViNcThW1EXUS',
 'created_at': 1699828331,
 'description': None,
 'file_ids': [],
 'instructions': 'You are a personal math tutor. Answer questions briefly, in a sentence or less.',
 'metadata': {},
 'model': 'gpt-4-1106-preview',
 'name': 'Math Tutor',
 'object': 'assistant',
 'tools': [{'type': 'code_interpreter'}]}
1
2
3
4
5
6
7
8
9
10

现在，让我们要求助理使用它的新工具。

# 导入create_thread_and_run、wait_on_run、get_response、pretty_print函数
# 这里假设已经导入了这些函数，因此不需要再次导入

# 创建一个线程并运行，线程的任务是生成前20个斐波那契数列
thread, run = create_thread_and_run("Generate the first 20 fibbonaci numbers with code.")

# 等待线程运行结束
run = wait_on_run(run, thread)

# 打印线程的返回结果
pretty_print(get_response(thread))
1
2
3
4
5
6
7
8
9
10
11

# Messages
user: Generate the first 20 fibbonaci numbers with code.
assistant: The first 20 Fibonacci numbers are: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, and 4181.
1
2
3

步骤

这就是全部！助手在后台使用了代码解释器，并给出了最终的响应。

对于某些用例来说，这可能已经足够了 - 但是，如果我们想要更多关于助手正在做什么的细节，我们可以查看运行步骤。

一个运行由一个或多个步骤组成。与运行类似，每个步骤都有一个可以查询的“状态”。这对于向用户呈现步骤的进度非常有用（例如，当助手正在编写代码或执行检索时，可以显示旋转器）。

# 获取客户端beta版本中的threads、runs、steps列表
run_steps = client.beta.threads.runs.steps.list(
    # 指定线程id
    thread_id=thread.id, 
    # 指定运行id
    run_id=run.id, 
    # 指定步骤顺序为升序
    order="asc"
)
1
2
3
4
5
6
7
8
9
10
11

让我们来看看每个步骤的“步骤详情”。

# 遍历run_steps.data中的每一个元素，将每个元素赋值给变量step
for step in run_steps.data:
    # 获取step的step_details属性，并将其赋值给变量step_details
    step_details = step.step_details
    # 调用show_json函数，将step_details转换为JSON格式，并使用4个空格进行缩进
    # 然后使用print函数打印输出结果
    print(json.dumps(show_json(step_details), indent=4))
1
2
3
4
5
6
7

{'tool_calls': [{'id': 'call_WMNqd63PtX8vZzTwaA6eWpBg',
   'code_interpreter': {'input': '# Python function to generate the first 20 Fibonacci numbers\ndef fibonacci(n):\n    fib_sequence = [0, 1]\n    while len(fib_sequence) < n:\n        fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])\n    return fib_sequence\n\n# Generate the first 20 Fibonacci numbers\nfirst_20_fibonacci = fibonacci(20)\nfirst_20_fibonacci',
    'outputs': [{'logs': '[0,\n 1,\n 1,\n 2,\n 3,\n 5,\n 8,\n 13,\n 21,\n 34,\n 55,\n 89,\n 144,\n 233,\n 377,\n 610,\n 987,\n 1597,\n 2584,\n 4181]',
      'type': 'logs'}]},
   'type': 'code_interpreter'}],
 'type': 'tool_calls'}


null



{'message_creation': {'message_id': 'msg_z593lE5bvcD6BngeDFHDxzwm'},
 'type': 'message_creation'}


null
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

我们可以看到两个步骤的step_details：

1. tool_calls（复数，因为在单个步骤中可能有多个）
2. message_creation

第一个步骤是tool_calls，具体使用了包含以下内容的code_interpreter：

• input，这是在调用工具之前生成的Python代码
• output，这是运行代码解释器的结果。

第二个步骤是message_creation，其中包含添加到线程中以向用户传达结果的message。

检索

在助手API中，另一个强大的工具是检索：即上传文件，助手将使用这些文件作为知识库来回答问题。我们可以从仪表板或API中启用此功能，并上传我们想要使用的文件。

# 导入所需模块已省略

# 上传文件
file = client.files.create(
    file=open(
        "data/language_models_are_unsupervised_multitask_learners.pdf", # 文件路径
        "rb", # 以二进制方式读取文件
    ),
    purpose="assistants", # 文件用途为助手
)

# 更新助手
assistant = client.beta.assistants.update(
    MATH_ASSISTANT_ID, # 助手ID
    tools=[{"type": "code_interpreter"}, {"type": "retrieval"}], # 助手工具类型
    file_ids=[file.id], # 文件ID
)

show_json(assistant) # 显示助手信息的JSON格式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

{'id': 'asst_9HAjl9y41ufsViNcThW1EXUS',
 'created_at': 1699828331,
 'description': None,
 'file_ids': ['file-MdXcQI8OdPp76wukWI4dpLwW'],
 'instructions': 'You are a personal math tutor. Answer questions briefly, in a sentence or less.',
 'metadata': {},
 'model': 'gpt-4-1106-preview',
 'name': 'Math Tutor',
 'object': 'assistant',
 'tools': [{'type': 'code_interpreter'}, {'type': 'retrieval'}]}
1
2
3
4
5
6
7
8
9
10

# 调用create_thread_and_run函数，传入一个问题作为参数，并将返回的线程和运行结果分别赋值给thread和run变量
thread, run = create_thread_and_run("What are some cool math concepts behind this ML paper pdf? Explain in two sentences.")

# 调用wait_on_run函数，传入run和thread作为参数，并将返回的运行结果赋值给run变量
run = wait_on_run(run, thread)

# 调用pretty_print函数，传入运行结果作为参数，打印运行结果
pretty_print(get_response(thread))
1
2
3
4
5
6
7
8
9
10

# Messages
user: What are some cool math concepts behind this ML paper pdf? Explain in two sentences.
assistant: I am unable to find specific sections referring to "cool math concepts" directly in the paper using the available tools. I will now read the beginning of the paper to identify any mathematical concepts that are fundamental to the paper.
assistant: The paper discusses leveraging large language models as a framework for unsupervised multitask learning, where tasks are implicitly defined by the context within sequences of text. It explores the zero-shot learning capabilities of such models by showing that when a language model is trained on a vast dataset, it begins to generalize and perform tasks without explicit supervision, achieving competitive results across various natural language processing tasks using a probabilistic framework based on sequential modeling and conditional probabilities.
1
2
3
4

注意
检索中还有更多的细节，比如注释，可能会在另一本食谱中介绍。

函数

作为您的助手的最后一个强大工具，您可以指定自定义函数（类似于Chat Completions API中的函数调用）。在运行期间，助手可以指示它想要调用您指定的一个或多个函数。然后，您需要负责调用函数，并将输出提供给助手。

让我们通过为我们的数学导师定义一个display_quiz()函数来看一个示例。

这个函数将接受一个title和一个question数组，显示测验，并为每个问题从用户那里获取输入：

• title
• questions
  • question_text
  • question_type: [MULTIPLE_CHOICE, FREE_RESPONSE]
  • choices: [“choice 1”, “choice 2”, …]

不幸的是，我不知道如何在Python Notebook中获取用户输入，所以我将使用get_mock_response...来模拟响应。这是您将获取用户实际输入的地方。

# 定义函数get_mock_response_from_user_multiple_choice，用于模拟用户选择多项的回答
def get_mock_response_from_user_multiple_choice():
    return "a"

# 定义函数get_mock_response_from_user_free_response，用于模拟用户自由回答的回答
def get_mock_response_from_user_free_response():
    return "I don't know."

# 定义函数display_quiz，用于展示问卷的标题和问题，并获取用户的回答
def display_quiz(title, questions):
    print("Quiz:", title)  # 打印问卷标题
    print()
    responses = []  # 创建一个空列表用于存储用户的回答

    for q in questions:  # 遍历问题列表
        print(q["question_text"])  # 打印问题文本
        response = ""  # 初始化回答变量

        # 如果问题类型是多项选择，则打印选项并获取用户的回答
        if q["question_type"] == "MULTIPLE_CHOICE":
            for i, choice in enumerate(q["choices"]):
                print(f"{i}. {choice}")
            response = get_mock_response_from_user_multiple_choice()

        # 否则，只需获取用户的回答
        elif q["question_type"] == "FREE_RESPONSE":
            response = get_mock_response_from_user_free_response()

        responses.append(response)  # 将用户的回答添加到回答列表中
        print()

    return responses  # 返回用户的回答列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

这是一个样例测验的样子：

# 调用display_quiz函数，传入问卷标题和问题列表，并将返回的回答列表赋值给responses变量
responses = display_quiz(
    "Sample Quiz",
    [
        {"question_text": "What is your name?", "question_type": "FREE_RESPONSE"},
        {
            "question_text": "What is your favorite color?",
            "question_type": "MULTIPLE_CHOICE",
            "choices": ["Red", "Blue", "Green", "Yellow"],
        },
    ],
)

# 打印responses变量的值
print("Responses:", responses)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Quiz: Sample Quiz

What is your name?

What is your favorite color?
0. Red
1. Blue
2. Green
3. Yellow

Responses: ["I don't know.", 'a']
1
2
3
4
5
6
7
8
9
10
11

现在，让我们以JSON格式定义此函数的接口，这样我们的助手就可以调用它了。

# 定义一个名为function_json的字典，用于描述一个显示测验的函数
function_json = {
    "name": "display_quiz", # 函数名为display_quiz
    "description": "Displays a quiz to the student, and returns the student's response. A single quiz can have multiple questions.", # 函数描述
    "parameters": { # 函数参数
        "type": "object", # 参数类型为对象
        "properties": { # 参数属性
            "title": {"type": "string"}, # 标题属性，类型为字符串
            "questions": { # 问题属性，类型为数组
                "type": "array", # 数组类型
                "description": "An array of questions, each with a title and potentially options (if multiple choice).", # 问题数组的描述
                "items": { # 数组元素
                    "type": "object", # 元素类型为对象
                    "properties": { # 元素属性
                        "question_text": {"type": "string"}, # 问题文本属性，类型为字符串
                        "question_type": { # 问题类型属性，类型为字符串
                            "type": "string", 
                            "enum": ["MULTIPLE_CHOICE", "FREE_RESPONSE"], # 枚举类型，只能是MULTIPLE_CHOICE或FREE_RESPONSE
                        },
                        "choices": {"type": "array", "items": {"type": "string"}}, # 选项属性，类型为数组，元素类型为字符串
                    },
                    "required": ["question_text"], # 必须包含问题文本属性
                },
            },
        },
        "required": ["title", "questions"], # 必须包含标题和问题属性
    },
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

再次，让我们通过仪表板或API来更新我们的助手。

注意
由于缩进等原因，将函数JSON粘贴到仪表板上有点棘手。我刚刚让ChatGPT将我的函数格式化为仪表板上的一个示例的样式

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/294771