探索ChatGPT结构化数据支持的极限

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "summary": [
    "不使用付费ChatGPT API就无法充分利用ChatGPT的潜力",
    "系统提示和提示工程是最大化ChatGPT能力的关键",
    "ChatGPT中的结构化数据支持允许对输出和输入进行更多控制"
  ],
  "blurb": "通过系统提示和结构化数据支持解锁ChatGPT的全部潜力。学习如何最大化ChatGPT的能力并获得对输出和输入的更多控制。",
  "categories": ["AI与机器学习", "技术", "编程"],
  "keywords": ["ChatGPT", "系统提示", "结构化数据"]
}

1
2
3
4
5
6

def is_palindrome(s):
    # 将字符串转换为小写并移除非字母数字字符
    cleaned_string = ''.join(char.lower() for char in s if char.isalnum())
    
    # 比较清理后的字符串与其反向
    return cleaned_string == cleaned_string[::-1]

1
2
3
4
5
6
7
8

def is_palindrome(s):
    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

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

{
  "name": "get_current_weather",
  "description": "Get the current weather in a given location",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "The city and state, e.g. San Francisco, CA"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"]
      }
    },
    "required": ["location"]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from pydantic import BaseModel, Field
import json

class answer_question(BaseModel):
    """返回用户所问问题的答案"""
    
    answer: int = Field(description="用户问题的答案")
    ones_name: str = Field(description="答案个位数的名称")

print(json.dumps(answer_question.model_json_schema(), indent=2))

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

{
  "description": "返回用户所问问题的答案",
  "properties": {
    "answer": {
      "description": "用户问题的答案",
      "title": "Answer",
      "type": "integer"
    },
    "ones_name": {
      "description": "答案个位数的名称",
      "title": "Ones Name",
      "type": "string"
    }
  },
  "required": ["answer", "ones_name"],
  "title": "answer_question",
  "type": "object"
}

 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

{
  "tools": [
    {
      "name": "answer_question",
      "description": "返回用户所问问题的答案",
      "parameters": {
        "properties": {
          "answer": {
            "description": "用户问题的答案",
            "type": "integer"
          },
          "ones_name": {
            "description": "答案个位数的名称",
            "type": "string"
          }
        },
        "required": ["answer", "ones_name"],
        "type": "object"
      }
    }
  ],
  "tool_choice": {
    "type": "function",
    "function": {
      "name": "answer_question"
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from simpleaichat import AIChat

ai = AIChat(console=False,
            save_messages=False,
            model="gpt-3.5-turbo",
            params={"temperature": 0.0}  # 用于一致的演示输出
            )

response_structured = ai(
    "从旧金山到洛杉矶有多少英里？",
    output_schema=answer_question
)

1
2
3
4

{
  "answer": 382,
  "ones_name": "two"
}

1
2
3
4
5
6
7
8
9

class answer_code_question(BaseModel):
    """返回用户所问编码问题的答案"""
    
    code: str = Field(description="用户请求的代码，无代码注释")

response_structured = ai(
    "编写一个Python函数来检测字符串是否为回文，尽可能高效",
    output_schema=answer_code_question
)

1
2
3

{
  "code": "def is_palindrome(s):\n    return s == s[::-1]"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from simpleaichat.utils import fd

class answer_code_question(BaseModel):
    """返回用户所问编码问题的答案"""
    
    code: str = fd("用户请求的代码，无代码注释")
    optimized_code: str = fd("来自先前响应的算法优化代码")

response_structured = ai(
    "编写一个Python函数来检测字符串是否为回文，尽可能高效",
    output_schema=answer_code_question,
)

1
2
3
4

{
  "code": "def is_palindrome(s):\n    return s == s[::-1]",
  "optimized_code": "def is_palindrome(s):\n    left = 0\n    right = len(s) - 1\n    while left < right:\n        if s[left] != s[right]:\n            return False\n        left += 1\n        right -= 1\n    return True"
}

1
2
3
4
5

from typing import Literal

class get_current_weather(BaseModel):
    location: str = fd("城市和州，如San Francisco, CA")
    unit: Literal["celsius", "fahrenheit"] = None

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class calculate_equation(BaseModel):
    """返回用户所问数学方程的答案"""
    
    value_a: int
    value_b: int
    op: Literal["+", "-", "*", "/"] = fd("在value_a和value_b之间执行的运算符")

equation = calculate_equation(value_a=223, value_b=-323, op="*")

response = ai(
    equation,
    input_schema=calculate_equation,
)

1
2
3
4
5

response_structured = ai(
    equation,
    input_schema=calculate_equation,
    output_schema=answer_question
)

1
2
3
4

{
  "answer": -71929,
  "ones_name": "nine"
}

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

class Chat(BaseModel):
    """来自角色的聊天对话"""
    
    character: str = fd("角色名称")
    text: str = fd("角色的文本对话")

class get_dialogue(BaseModel):
    """返回两个角色之间的对话"""
    
    dialogue: list[Chat] = fd("角色之间的对话", min_length=5)

system_prompt = """你是一位世界著名的喜剧演员。编写一个关于名为Alice和Bob的角色之间琐碎冲突的有趣打斗场景。脚本应大致关于用户提供的主题。每包含一个笑话将获得500美元小费。"""

response_structured = ai(
    "Python编程语言和沙滩排球",
    output_schema=get_dialogue,
    system=system_prompt,
)

 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
48

{
  "dialogue": [
    {
      "character": "Alice",
      "text": "嘿Bob，你试过用Python编程吗？"
    },
    {
      "character": "Bob",
      "text": "是的，试过。就像和蛇打沙滩排球！"
    },
    {
      "character": "Alice",
      "text": "什么意思？"
    },
    {
      "character": "Bob",
      "text": "嗯，你以为玩得开心，但然后蛇用语法错误咬你！"
    },
    {
      "character": "Alice",
      "text": "哈哈，没错。但一旦掌握，就像精确扣球！"
    },
    {
      "character": "Bob",
      "text": "是的，直到意识到拼错变量名，球飞进海里！"
    },
    {
      "character": "Alice",
      "text": "哦得了吧，Bob。没那么糟。Python是一种强大的语言。"
    },
    {
      "character": "Bob",
      "text": "强大，是的。但有时感觉像用勺子在沙子里挖洞！"
    },
    {
      "character": "Alice",
      "text": "嗯，至少编码时不用担心晒伤！"
    },
    {
      "character": "Bob",
      "text": "没错，但调试Python代码比沙滩排球比赛更让你出汗！"
    },
    {
      "character": "Alice",
      "text": "哈哈，没错。与Python是爱恨关系，就像沙滩排球！"
    }
  ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from typing import Union

class Background(BaseModel):
    """用户背景设置"""
    
    background: str = fd("用户问题的背景", min_length=30)

class Thought(BaseModel):
    """关于用户问题的思考"""
    
    thought: str = fd("思考文本")
    helpful: bool = fd("思考是否有助于解决用户问题")
    flawed: bool = fd("思考是否有缺陷或误导性")

class Answer(BaseModel):
    """用户问题的答案"""
    
    answer: str = fd("答案文本")
    score: int = fd("先前答案正确程度的1到10分", min_value=1, max_value=10)

class reason_question(BaseModel):
    """返回用户问题的详细推理"""
    
    reasonings: list[Union[Background, Thought, Answer]] = fd("解决用户问题的推理", min_length=5)

1
2
3
4
5
6
7
8
9

system_prompt = """
你是世界上最聪明的人。

如果遵守所有这些规则，将获得500美元小费：
- 首先，为用户的问题建立详细的背景。
- 每个思考还必须包括是否相关和是否有用。
- 答案必须准确和诚实地评分。
- 继续有思考和答案，直到有一个至少8分的答案，然后立即以学术教授的风格回应FinalAnswer。
"""

1
2
3
4
5

response_structured = ai(
    "23件衬衫在外面晾干需要1小时，44件衬衫需要多长时间？",
    output_schema=reason_question,
    system=system_prompt.strip(),
)

 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

{
  "reasonings": [
    {
      "background": "用户询问衬衫挂在外面晾干的时间。这是一个涉及理解衬衫数量与晾干时间之间关系的问题。假设是，只要所有衬衫有足够的空间和空气流通以有效晾干，晾干时间不受衬衫数量的影响。"
    },
    {
      "thought": "如果23件衬衫需要1小时晾干，意味着晾干时间与衬衫数量无关，假设有足够的空间和空气流通。这意味着44件衬衫在相同条件下也需要1小时晾干。",
      "helpful": true,
      "flawed": false
    },
    {
      "thought": "如果晾衣架或晾衣空间有限，那么晾干44件衬衫可能需要更长时间，因为它们必须分批晾干。",
      "helpful": true,
      "flawed": false
    },
    {
      "thought": "问题没有指定衬衫晾干的条件。湿度、温度、风和阳光可用性等因素会影响晾干时间。然而，这些因素不是问题的一部分，因此不应在答案中考虑。",
      "helpful": true,
      "flawed": false
    },
    {
      "thought": "问题可能被解释为直接比例问题，两倍的衬衫数量需要两倍的时间晾干。然而，这种解释是有缺陷的，因为它假设晾干时间与衬衫数量直接成正比，这不一定是真的。",
      "helpful": true,
      "flawed": true
    },
    {
      "answer": "44件衬衫需要与23件衬衫相同的时间晾干，即1小时，假设所有衬衫有足够的空间和空气流通以有效晾干。",
      "score": 9
    }
  ]
}

1
2
3
4
5

response_structured = ai(
    "Kayley有三个兄弟。每个兄弟有两个姐妹。Kayley有多少个姐妹？",
    output_schema=reason_question,
    system=system_prompt.strip(),
)

 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

{
  "reasonings": [
    {
      "background": "这是一个经典的逻辑谜题示例，常用于测试一个人处理信息和避免被假设误导的能力。谜题涉及家庭结构，要求解决者根据给定信息推断兄弟姐妹的数量。"
    },
    {
      "thought": "问题可能试图欺骗读者认为每个兄弟有不同的姐妹。",
      "helpful": true,
      "flawed": false
    },
    {
      "thought": "如果Kayley有三个兄弟，每个兄弟有两个姐妹，可能看起来总共有六个姐妹。",
      "helpful": false,
      "flawed": true
    },
    {
      "thought": "由于兄弟是Kayley的兄弟姐妹，他们必须共享相同的姐妹。",
      "helpful": true,
      "flawed": false
    },
    {
      "thought": "谜题旨在测试理解和逻辑推理，而不是数学计算。",
      "helpful": true,
      "flawed": false
    },
    {
      "answer": "Kayley有一个姐妹。",
      "score": 10
    }
  ]
}

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

{
  "description": "返回用户所问问题的答案",
  "properties": {
    "answer": {
      "description": "用户问题的答案",
      "type": "integer"
    },
    "ones_name": {
      "description": "答案个位数的名称",
      "type": "string"
    }
  },
  "required": ["answer", "ones_name"],
  "type": "object"
}

1
2
3
4

{
  "answer": 383,
  "ones_name": "three"
}