გადადით მთავარ შინაარსზე
OpenAI

6 აგვისტო, 2024

კომპანია

API-ში სტრუქტურირებული შედეგების წარდგენა

API-ში ვნერგავთ სტრუქტურირებულ შედეგებს — მოდელის შედეგები ახლა სანდოდ მისდევს დეველოპერის მიერ მიწოდებულ JSON Schema-ებს.

სურათზე ჩანს პატარა კვადრატების აბსტრაქტული ნიმუში ლურჯის, მწვანის და ღია ყვითლის სხვადასხვა ტონებში. კვადრატები ბადის მსგავსადაა განლაგებული, რაც რბილი, პასტელური ფერთა პალიტრით მოზაიკურ ეფექტს ქმნის.

გასულ წელს DevDay-ზე წარმოვადგინეთ JSON რეჟიმი — სასარგებლო საძირკველი დეველოპერებისთვის, რომლებსაც ჩვენს მოდელებთან სანდო აპლიკაციების შექმნა სურთ. მიუხედავად იმისა, რომ JSON რეჟიმი აუმჯობესებს მოდელის სანდოობას ვალიდური JSON შედეგების გენერირებისთვის, ის არ იძლევა გარანტიას, რომ მოდელის პასუხი კონკრეტულ სქემას დაემორჩილება. დღეს API-ში წარმოგიდგენთ სტრუქტურირებულ შედეგებს — ახალ ფუნქციას, რომელიც შექმნილია იმისთვის, რომ მოდელის მიერ გენერირებული შედეგები ზუსტად დაემთხვეს დეველოპერების მიერ მიწოდებულ JSON Schema-ებს.

არასტრუქტურირებული შეყვანებიდან სტრუქტურირებული მონაცემების გენერირება დღევანდელ აპლიკაციებში AI-ის გამოყენების ერთ-ერთი ძირითადი შემთხვევაა. დეველოპერები იყენებენ OpenAI API-ს ძლიერი ასისტენტების ასაშენებლად, რომლებსაც შეუძლიათ მონაცემების მოტანა და კითხვებზე პასუხის გაცემა ფუნქციის გამოძახების⁠(იხსნება ახალ ფანჯარაში) საშუალებით, მონაცემების შეყვანისთვის სტრუქტურირებული მონაცემების ამოღება და მრავალსაფეხურიანი აგენტური სამუშაო ნაკადების შექმნა, რომლებიც LLM-ებს მოქმედების შესრულების საშუალებას აძლევს. დეველოპერები დიდი ხანია ამ სფეროში LLM-ების შეზღუდვებს გვერდს უვლიან open source ხელსაწყოებით, მოთხოვნებით და მოთხოვნების განმეორებითი გაგზავნით, რათა დარწმუნდნენ, რომ მოდელის შედეგები მათ სისტემებთან თავსებადობისთვის საჭირო ფორმატებს შეესაბამება. სტრუქტურირებული შედეგები ამ პრობლემას აგვარებს OpenAI-ის მოდელების დეველოპერის მიერ მიწოდებულ სქემებთან შეზღუდვით და ჩვენი მოდელების უკეთ დატრენინგებით რთული სქემების გასაგებად.

რთული JSON Schema-ს მიდევნების ჩვენს შეფასებებში ჩვენი ახალი მოდელი gpt-4o-2024-08-06 სტრუქტურირებული შედეგებით სრულ 100%-ს იღებს. შედარებისთვის, gpt-4-0613 40%-ზეც ნაკლებს იღებს.

სტრუქტურირებული შედეგებით gpt-4o-2024-08-06 ჩვენს შეფასებებში აღწევს 100% სანდოობას და იდეალურად ემთხვევა შედეგის სქემებს.

როგორ გამოვიყენოთ სტრუქტურირებული შედეგები

API-ში სტრუქტურირებულ შედეგებს ორი ფორმით წარმოგიდგენთ: 

1. ფუნქციის გამოძახება: tools-ის მეშვეობით სტრუქტურირებული შედეგები ხელმისაწვდომია თქვენი ფუნქციის განსაზღვრებაში strict: true-ის დაყენებით. ეს ფუნქცია მუშაობს ყველა იმ მოდელთან, რომელსაც ხელსაწყოების მხარდაჭერა აქვს, მათ შორის ყველა მოდელთან gpt-4-0613 და gpt-3.5-turbo-0613 და უფრო გვიან ვერსიებთან. როცა სტრუქტურირებული შედეგები ჩართულია, მოდელის შედეგები მიწოდებულ ხელსაწყოს განსაზღვრებას დაემთხვევა.

JSON

1
POST /v1/chat/completions
2
{
3
  "model": "gpt-4o-2024-08-06",
4
  "messages": [
5
    {
6
      "role": "system",
7
      "content": "You are a helpful assistant. The current date is August 6, 2024. You help users query for the data they are looking for by calling the query function."
8
    },
9
    {
10
      "role": "user",
11
      "content": "look up all my orders in may of last year that were fulfilled but not delivered on time"
12
    }
13
  ],
14
  "tools": [
15
    {
16
      "type": "function",
17
      "function": {
18
        "name": "query",
19
        "description": "Execute a query.",
20
        "strict": true,
21
        "parameters": {
22
          "type": "object",
23
          "properties": {
24
            "table_name": {
25
              "type": "string",
26
              "enum": ["orders"]
27
            },
28
            "columns": {
29
              "type": "array",
30
              "items": {
31
                "type": "string",
32
                "enum": [
33
                  "id",
34
                  "status",
35
                  "expected_delivery_date",
36
                  "delivered_at",
37
                  "shipped_at",
38
                  "ordered_at",
39
                  "canceled_at"
40
                ]
41
              }
42
            },
43
            "conditions": {
44
              "type": "array",
45
              "items": {
46
                "type": "object",
47
                "properties": {
48
                  "column": {
49
                    "type": "string"
50
                  },
51
                  "operator": {
52
                    "type": "string",
53
                    "enum": ["=", ">", "<", ">=", "<=", "!="]
54
                  },
55
                  "value": {
56
                    "anyOf": [
57
                      {
58
                        "type": "string"
59
                      },
60
                      {
61
                        "type": "number"
62
                      },
63
                      {
64
                        "type": "object",
65
                        "properties": {
66
                          "column_name": {
67
                            "type": "string"
68
                          }
69
                        },
70
                        "required": ["column_name"],
71
                        "additionalProperties": false
72
                      }
73
                    ]
74
                  }
75
                },
76
                "required": ["column", "operator", "value"],
77
                "additionalProperties": false
78
              }
79
            },
80
            "order_by": {
81
              "type": "string",
82
              "enum": ["asc", "desc"]
83
            }
84
          },
85
          "required": ["table_name", "columns", "conditions", "order_by"],
86
          "additionalProperties": false
87
        }
88
      }
89
    }
90
  ]
91
}

2. ახალი ვარიანტი response_format პარამეტრისთვის: დეველოპერებს ახლა შეუძლიათ მიაწოდონ JSON Schema json_schema-ის საშუალებით — ახალი ვარიანტი response_format პარამეტრისთვის. ეს სასარგებლოა მაშინ, როდესაც მოდელი ხელსაწყოს არ იძახებს, არამედ მომხმარებელს სტრუქტურირებული ფორმით პასუხობს. ეს ფუნქცია მუშაობს ჩვენს უახლეს GPT‑4o მოდელებთან: დღეს გამოშვებულ gpt-4o-2024-08-06-თან და gpt-4o-mini-2024-07-18-თან. როდესაც response_format მიეწოდება პარამეტრით strict: true, მოდელის შედეგები მიწოდებულ სქემას დაემთხვევა.

მოთხოვნა

1
POST /v1/chat/completions
2
{
3
  "model": "gpt-4o-2024-08-06",
4
  "messages": [
5
    {
6
      "role": "system",
7
      "content": "You are a helpful math tutor."
8
    },
9
    {
10
      "role": "user",
11
      "content": "solve 8x + 31 = 2"
12
    }
13
  ],
14
  "response_format": {
15
    "type": "json_schema",
16
    "json_schema": {
17
      "name": "math_response",
18
      "strict": true,
19
      "schema": {
20
        "type": "object",
21
        "properties": {
22
          "steps": {
23
            "type": "array",
24
            "items": {
25
              "type": "object",
26
              "properties": {
27
                "explanation": {
28
                  "type": "string"
29
                },
30
                "output": {
31
                  "type": "string"
32
                }
33
              },
34
              "required": ["explanation", "output"],
35
              "additionalProperties": false
36
            }
37
          },
38
          "final_answer": {
39
            "type": "string"
40
          }
41
        },
42
        "required": ["steps", "final_answer"],
43
        "additionalProperties": false
44
      }
45
    }
46
  }
47
}

უსაფრთხო სტრუქტურირებული შედეგები

უსაფრთხოება OpenAI-ისთვის უმაღლესი პრიორიტეტია — სტრუქტურირებული შედეგების ახალი ფუნქციონალი ჩვენს არსებულ უსაფრთხოების პოლიტიკებს დაემორჩილება და მოდელს მაინც მისცემს არაუსაფრთხო მოთხოვნის უარყოფის შესაძლებლობას. განვითარების გასამარტივებლად, API პასუხებში დაემატა ახალი refusal სტრიქონული მნიშვნელობა, რომელიც დეველოპერებს საშუალებას აძლევს პროგრამულად განსაზღვრონ, შექმნა თუ არა მოდელმა უარყოფა სქემასთან შესაბამისი შედეგის ნაცვლად. როცა პასუხი უარყოფას არ შეიცავს და მოდელის პასუხი ნაადრევად არ შეწყვეტილა (რაც მითითებულია finish_reason-ით), მაშინ მოდელის პასუხი სანდოდ წარმოქმნის მიწოდებულ სქემასთან შესატყვის ვალიდურ JSON-ს.

JSON

1
{
2
  "id": "chatcmpl-9nYAG9LPNonX8DAyrkwYfemr3C8HC",
3
  "object": "chat.completion",
4
  "created": 1721596428,
5
  "model": "gpt-4o-2024-08-06",
6
  "choices": [
7
    {
8
      "index": 0,
9
      "message": {
10
        "role": "assistant",
11
        "refusal": "I'm sorry, I cannot assist with that request."
12
      },
13
      "logprobs": null,
14
      "finish_reason": "stop"
15
    }
16
  ],
17
  "usage": {
18
    "prompt_tokens": 81,
19
    "completion_tokens": 11,
20
    "total_tokens": 92
21
  },
22
  "system_fingerprint": "fp_3407719c7f"
23
}

SDK-ის მშობლიური მხარდაჭერა

ჩვენი Python და Node SDK-ები განახლდა სტრუქტურირებული შედეგების მშობლიური მხარდაჭერით. ხელსაწყოებისთვის ან პასუხის ფორმატად სქემის მიწოდება ისეთივე მარტივია, როგორც Pydantic ან Zod ობიექტის მიწოდება, ხოლო ჩვენი SDK-ები თავად იზრუნებს მონაცემთა ტიპის მხარდაჭერად JSON სქემად გარდაქმნაზე, JSON პასუხის ტიპიზებულ მონაცემთა სტრუქტურად ავტომატურ დესერიალიზაციაზე და უარყოფების დამუშავებაზე, თუ ასეთი წარმოიშვა.

ქვემოთ მოყვანილი მაგალითები აჩვენებს სტრუქტურირებული შედეგების მშობლიურ მხარდაჭერას ფუნქციის გამოძახებით.

Python

1
from enum import Enum
2
from typing import Union
3

4
from pydantic import BaseModel
5

6
import openai
7
from openai import OpenAI
8

9

10
class Table(str, Enum):
11
    orders = "orders"
12
    customers = "customers"
13
    products = "products"
14

15

16
class Column(str, Enum):
17
    id = "id"
18
    status = "status"
19
    expected_delivery_date = "expected_delivery_date"
20
    delivered_at = "delivered_at"
21
    shipped_at = "shipped_at"
22
    ordered_at = "ordered_at"
23
    canceled_at = "canceled_at"
24

25

26
class Operator(str, Enum):
27
    eq = "="
28
    gt = ">"
29
    lt = "<"
30
    le = "<="
31
    ge = ">="
32
    ne = "!="
33

34

35
class OrderBy(str, Enum):
36
    asc = "asc"
37
    desc = "desc"
38

39

40
class DynamicValue(BaseModel):
41
    column_name: str
42

43

44
class Condition(BaseModel):
45
    column: str
46
    operator: Operator
47
    value: Union[str, int, DynamicValue]
48

49

50
class Query(BaseModel):
51
    table_name: Table
52
    columns: list[Column]
53
    conditions: list[Condition]
54
    order_by: OrderBy
55

56

57
client = OpenAI()
58

59
completion = client.beta.chat.completions.parse(
60
    model="gpt-4o-2024-08-06",
61
    messages=[
62
        {
63
            "role": "system",
64
            "content": "You are a helpful assistant. The current date is August 6, 2024. You help users query for the data they are looking for by calling the query function.",
65
        },
66
        {
67
            "role": "user",
68
            "content": "look up all my orders in may of last year that were fulfilled but not delivered on time",
69
        },
70
    ],
71
    tools=[
72
        openai.pydantic_function_tool(Query),
73
    ],
74
)
75

76
print(completion.choices[0].message.tool_calls[0].function.parsed_arguments)

response_format-ისთვის ასევე ხელმისაწვდომია სტრუქტურირებული შედეგების მშობლიური მხარდაჭერა.

Python

1
from pydantic import BaseModel
2

3
from openai import OpenAI
4

5

6
class Step(BaseModel):
7
    explanation: str
8
    output: str
9

10

11
class MathResponse(BaseModel):
12
    steps: list[Step]
13
    final_answer: str
14

15

16
client = OpenAI()
17

18
completion = client.beta.chat.completions.parse(
19
    model="gpt-4o-2024-08-06",
20
    messages=[
21
        {"role": "system", "content": "You are a helpful math tutor."},
22
        {"role": "user", "content": "solve 8x + 31 = 2"},
23
    ],
24
    response_format=MathResponse,
25
)
26

27
message = completion.choices[0].message
28
if message.parsed:
29
    print(message.parsed.steps)
30
    print(message.parsed.final_answer)
31
else:
32
    print(message.refusal)

დამატებითი გამოყენების შემთხვევები

დეველოპერები ხშირად იყენებენ OpenAI-ის მოდელებს სხვადასხვა გამოყენების შემთხვევისთვის სტრუქტურირებული მონაცემების გენერირებისთვის. დამატებითი მაგალითებია:

მომხმარებლის განზრახვის მიხედვით მომხმარებლის ინტერფეისების დინამიკურად გენერირება

მაგალითად, დეველოპერებს შეუძლიათ გამოიყენონ სტრუქტურირებული შედეგები კოდის ან UI-ის გენერირებადი აპლიკაციების შესაქმნელად. ქვემოთ მოყვანილი ყველა მაგალითი იყენებს ერთსა და იმავე response_format-ს და მათი გამოყენება შესაძლებელია მომხმარებლის შეყვანის მიხედვით განსხვავებული UI-ების გენერირებისთვის.

სისტემა
ხარ მომხმარებლის ინტერფეისის ასისტენტი. შენი სამუშაოა დაეხმარო მომხმარებლებს თავიანთი ვებსაიტისა და აპის იდეების ვიზუალიზაციაში.
პასუხის ფორმატი
ასისტენტი
1
{
2
  "type": "div",
3
  "label": "",
4
  "children": [
5
    {
6
      "type": "header",
7
      "label": "",
8
      "children": [
9
        {
10
          "type": "div",
11
          "label": "Green Thumb Gardening",
12
          "children": [],
13
          "attributes": [{ "name": "className", "value": "site-title" }]
14
        },
15
        {
16
          "type": "div",
17
          "label": "Bringing Life to Your Garden",
18
          "children": [],
19
          "attributes": [{ "name": "className", "value": "site-tagline" }]
20
        }
21
      ],
22
      "attributes": [{ "name": "className", "value": "header" }]
23
    },
24
    {
25
      "type": "section",
26
      "label": "",
27
      "children": [
28
        {
29
          "type": "div",
30
          "label": "",
31
          "children": [
32
            {
33
              "type": "div",
34
              "label": "About Us",
35
              "children": [
36
                {
37
                  "type": "div",
38
                  "label": "At Green Thumb Gardening, we specialize in transforming your outdoor spaces into beautiful, thriving gardens. Our team has decades of experience in horticulture and landscape design.",
39
                  "children": [],
40
                  "attributes": [
41
                    { "name": "className", "value": "about-description" }
42
                  ]
43
                }
44
              ],
45
              "attributes": [{ "name": "className", "value": "about-section" }]
46
            }
47
          ],
48
          "attributes": [{ "name": "className", "value": "content" }]
49
        }
50
      ],
51
      "attributes": [{ "name": "className", "value": "about-container" }]
52
    },
53
    {
54
      "type": "section",
55
      "label": "",
56
      "children": [
57
        {
58
          "type": "div",
59
          "label": "",
60
          "children": [
61
            {
62
              "type": "div",
63
              "label": "Our Services",
64
              "children": [
65
                {
66
                  "type": "div",
67
                  "label": "Garden Design",
68
                  "children": [],
69
                  "attributes": [
70
                    { "name": "className", "value": "service-item" }
71
                  ]
72
                },
73
                {
74
                  "type": "div",
75
                  "label": "Plant Care & Maintenance",
76
                  "children": [],
77
                  "attributes": [
78
                    { "name": "className", "value": "service-item" }
79
                  ]
80
                },
81
                {
82
                  "type": "div",
83
                  "label": "Seasonal Cleanup",
84
                  "children": [],
85
                  "attributes": [
86
                    { "name": "className", "value": "service-item" }
87
                  ]
88
                },
89
                {
90
                  "type": "div",
91
                  "label": "Custom Landscaping",
92
                  "children": [],
93
                  "attributes": [
94
                    { "name": "className", "value": "service-item" }
95
                  ]
96
                }
97
              ],
98
              "attributes": [{ "name": "className", "value": "services-list" }]
99
            }
100
          ],
101
          "attributes": [{ "name": "className", "value": "content" }]
102
        }
103
      ],
104
      "attributes": [{ "name": "className", "value": "services-container" }]
105
    }
106
  ],
107
  "attributes": [{ "name": "className", "value": "landing-page" }]
108
}
109

Welcome to Green Thumb Gardening
Bringing Life to Your Garden
At Green Thumb Gardening, we specialize in transforming your outdoor spaces into beautiful, thriving gardens. Our team has decades of experience in horticulture and landscape design.
Our services
Garden Design
Plant Care & Maintenance
Seasonal Cleanup
Custom Landscaping

საბოლოო პასუხის გამიჯვნა დამხმარე მსჯელობისგან ან დამატებითი კომენტარისგან

საბოლოო პასუხის ხარისხის გასაუმჯობესებლად შეიძლება სასარგებლო იყოს მოდელისთვის აზროვნების ჯაჭვისთვის ცალკე ველის მიცემა.

JSON

1
{
2
  "model": "gpt-4o-2024-08-06",
3
  "messages": [
4
    {
5
      "role": "system",
6
      "content": "You are a helpful assistant"
7
    },
8
    {
9
      "role": "user",
10
      "content": "9.11 and 9.9 -- which is bigger?"
11
    }
12
  ],
13
  "response_format": {
14
    "type": "json_schema",
15
    "json_schema": {
16
      "name": "reasoning_schema",
17
      "strict": true,
18
      "schema": {
19
        "type": "object",
20
        "properties": {
21
          "reasoning_steps": {
22
            "type": "array",
23
            "items": {
24
              "type": "string"
25
            },
26
            "description": "The reasoning steps leading to the final conclusion."
27
          },
28
          "answer": {
29
            "type": "string",
30
            "description": "The final answer, taking into account the reasoning steps."
31
          }
32
        },
33
        "required": ["reasoning_steps", "answer"],
34
        "additionalProperties": false
35
      }
36
    }
37
  }
38
}

არასტრუქტურირებული მონაცემებიდან სტრუქტურირებული მონაცემების ამოღება

მაგალითად, მოდელისთვის ინსტრუქციის მიცემა, რომ შეხვედრის ჩანაწერებიდან ამოიღოს ისეთი რამეები, როგორიცაა to-do-ები, ვადები და დავალებები.

JSON

1
POST /v1/chat/completions
2
{
3
  "model": "gpt-4o-2024-08-06",
4
  "messages": [
5
    {
6
      "role": "system",
7
      "content": "Extract action items, due dates, and owners from meeting notes."
8
    },
9
    {
10
      "role": "user",
11
      "content": "...meeting notes go here..."
12
    }
13
  ],
14
  "response_format": {
15
    "type": "json_schema",
16
    "json_schema": {
17
      "name": "action_items",
18
      "strict": true,
19
      "schema": {
20
        "type": "object",
21
        "properties": {
22
          "action_items": {
23
            "type": "array",
24
            "items": {
25
              "type": "object",
26
              "properties": {
27
                "description": {
28
                  "type": "string",
29
                  "description": "Description of the action item."
30
                },
31
                "due_date": {
32
                  "type": ["string", "null"],
33
                  "description": "Due date for the action item, can be null if not specified."
34
                },
35
                "owner": {
36
                  "type": ["string", "null"],
37
                  "description": "Owner responsible for the action item, can be null if not specified."
38
                }
39
              },
40
              "required": ["description", "due_date", "owner"],
41
              "additionalProperties": false
42
            },
43
            "description": "List of action items from the meeting."
44
          }
45
        },
46
        "required": ["action_items"],
47
        "additionalProperties": false
48
      }
49
    }
50
  }
51
}

შიგნით როგორ მუშაობს

JSON Schema-სთან შესატყვისი მოდელის შედეგების სანდოობის გასაუმჯობესებლად ორნაწილიანი მიდგომა გამოვიყენეთ. ჯერ ჩვენი უახლესი მოდელი gpt-4o-2024-08-06 დავატრენინგეთ, რათა რთული სქემები გაეგო და მათთან შესატყვისი შედეგები საუკეთესო გზით შეექმნა. თუმცა მოდელის ქცევა ბუნებრივად არადეტერმინისტულია — ამ მოდელის წარმადობის გაუმჯობესების მიუხედავადაც (93% ჩვენს ბენჩმარკზე), ის მაინც ვერ აღწევდა იმ სანდოობას, რომელიც დეველოპერებს ძლიერი აპლიკაციების შესაქმნელად სჭირდებათ. ამიტომ ასევე გამოვიყენეთ დეტერმინისტური, ინჟინერიაზე დაფუძნებული მიდგომა, რათა მოდელის შედეგები შეგვეზღუდა და 100%-იანი სანდოობისთვის მიგვეღწია.

შეზღუდული დეკოდირება

ჩვენი მიდგომა ეფუძნება ტექნიკას, რომელიც ცნობილია როგორც შეზღუდული სემპლირება ან შეზღუდული დეკოდირება. ნაგულისხმევად, როცა მოდელებიდან შედეგების მისაღებად სემპლირება ხდება, ისინი სრულიად შეუზღუდავია და შემდეგ შედეგად ლექსიკონიდან ნებისმიერი token-ის არჩევა შეუძლიათ. სწორედ ეს მოქნილობა აძლევს მოდელებს შეცდომის დაშვების საშუალებას; მაგალითად, მათ, როგორც წესი, ნებისმიერ დროს თავისუფლად შეუძლიათ ფიგურული ფრჩხილის token-ის არჩევა, მაშინაც კი, როცა ეს ვალიდურ JSON-ს არ წარმოქმნის. ვალიდური შედეგების იძულებისთვის ჩვენს მოდელებს ვზღუდავთ მხოლოდ იმ token-ებზე, რომლებიც მიწოდებული სქემის მიხედვით იქნება ვალიდური, და არა ყველა ხელმისაწვდომ token-ზე.

პრაქტიკაში ამ შეზღუდვის დანერგვა შეიძლება რთული იყოს, რადგან ვალიდური token-ები მოდელის შედეგის განმავლობაში იცვლება. ვთქვათ, გვაქვს შემდეგი სქემა:

JSON

1
{
2
  "type": "object",
3
  "properties": {
4
    "value": { "type": "number" }
5
  },
6
  "required": ["value"],
7
  "additionalProperties": false
8
}

შედეგის დასაწყისში ვალიდურ token-ებში შედის ისეთი ვარიანტები, როგორიცაა {, {“, {
 და ა.შ. თუმცა, მას შემდეგ რაც მოდელი უკვე აირჩევს {“val-ს, { აღარ იქნება ვალიდური token. ამიტომ საჭიროა დინამიკური შეზღუდული დეკოდირების იმპლემენტაცია და იმის განსაზღვრა, თუ რომელი token-ებია ვალიდური ყოველი token-ის გენერირების შემდეგ, ნაცვლად იმისა, რომ ეს წინასწარ, პასუხის დასაწყისში განვსაზღვროთ.

ამისათვის მიწოდებულ JSON Schema-ს ვაქცევთ კონტექსტიდან თავისუფალ გრამატიკად (CFG). გრამატიკა წესების ერთობლიობაა, რომელიც ენას განსაზღვრავს, ხოლო კონტექსტიდან თავისუფალი გრამატიკა ისეთი გრამატიკაა, რომელიც კონკრეტულ წესებს შეესაბამება. შეგიძლიათ JSON და JSON Schema წარმოიდგინოთ როგორც კონკრეტული ენები წესებით, რომლებიც განსაზღვრავს, რა არის ამ ენაში ვალიდური. როგორც ინგლისურში არ არის სწორი ზმნის გარეშე წინადადება, ისე JSON-ში არ არის სწორი ბოლოში ზედმეტი მძიმე.

ამგვარად, თითოეული JSON Schema-სთვის ვითვლით გრამატიკას, რომელიც ამ სქემას წარმოადგენს, და წინასწარ ვამუშავებთ მის კომპონენტებს, რათა მოდელის სემპლირებისას მასზე წვდომა მარტივი იყოს. ამიტომ ახალი სქემით პირველ მოთხოვნას დაყოვნების საფასური აქვს — სქემა უნდა დავამუშაოთ, რათა შევქმნათ ეს არტეფაქტი, რომლის ეფექტიანად გამოყენებაც სემპლირებისას შეგვიძლია.

სემპლირებისას, ყოველი token-ის შემდეგ, ჩვენი ინფერენს ძრავა განსაზღვრავს, რომელი token-ებია შემდეგ წარმოებისთვის ვალიდური, ადრე გენერირებული token-ებისა და გრამატიკის იმ წესების საფუძველზე, რომლებიც მიუთითებს, რა token-ებია შემდეგ ვალიდური. შემდეგ ამ token-ების სიას ვიყენებთ შემდეგი სემპლირების ნაბიჯის დასამასკად, რაც ფაქტობრივად არავალიდური token-ების ალბათობას 0-მდე ამცირებს. რადგან სქემა წინასწარ გვაქვს დამუშავებული, ამის ეფექტიანად გასაკეთებლად შეგვიძლია ქეშირებული მონაცემთა სტრუქტურა გამოვიყენოთ, მინიმალური დამატებითი დაყოვნებით.

ალტერნატიული მიდგომები

ამ პრობლემის ალტერნატიული მიდგომები შეზღუდული დეკოდირებისთვის ხშირად იყენებს სასრულ მდგომარეობათა მანქანებს (FSM) ან regex-ებს (რომლებიც, როგორც წესი, FSM-ებითაა განხორციელებული). ისინი მსგავსად მუშაობს იმით, რომ ყოველი token-ის წარმოქმნის შემდეგ დინამიკურად აახლებენ, რომელი token-ებია ვალიდური, მაგრამ CFG მიდგომასთან შედარებით რამდენიმე მნიშვნელოვანი განსხვავება აქვთ. განსაკუთრებით აღსანიშნავია, რომ CFG-ებს შეუძლიათ გამოხატონ ენების უფრო ფართო კლასი, ვიდრე FSM-ებს. პრაქტიკაში ამას მნიშვნელობა არ აქვს ძალიან მარტივი სქემებისთვის, როგორიცაა ზემოთ ნაჩვენები value სქემა. თუმცა ვხედავთ, რომ განსხვავება მნიშვნელოვანია უფრო რთული სქემებისთვის, რომლებიც ბუდურ ან რეკურსიულ მონაცემთა სტრუქტურებს მოიცავს. მაგალითად, FSM-ებს, როგორც წესი, არ შეუძლიათ რეკურსიული ტიპების გამოხატვა, რაც ნიშნავს, რომ FSM-ზე დაფუძნებულ მიდგომებს შეიძლება გაუჭირდეთ ღრმად ჩაბუდებულ JSON-ში ფრჩხილების შეხამება. ქვემოთ მოცემულია რეკურსიული სქემის ნიმუში, რომელსაც OpenAI API-ზე სტრუქტურირებული შედეგები უჭერს მხარს, მაგრამ რომლის გამოხატვაც FSM-ით შეუძლებელი იქნებოდა.

JSON

1
{
2
  "name": "ui",
3
  "description": "Dynamically generated UI",
4
  "strict": true,
5
  "schema": {
6
    "type": "object",
7
    "properties": {
8
      "type": {
9
        "type": "string",
10
        "description": "The type of the UI component",
11
        "enum": ["div", "button", "header", "section", "field", "form"]
12
      },
13
      "label": {
14
        "type": "string",
15
        "description": "The label of the UI component, used for buttons or form fields"
16
      },
17
      "children": {
18
        "type": "array",
19
        "description": "Nested UI components",
20
        "items": {
21
          "$ref": "#"
22
        }
23
      },
24
      "attributes": {
25
        "type": "array",
26
        "description": "Arbitrary attributes for the UI component, suitable for any element",
27
        "items": {
28
          "type": "object",
29
          "properties": {
30
            "name": {
31
              "type": "string",
32
              "description": "The name of the attribute, for example onClick or className"
33
            },
34
            "value": {
35
              "type": "string",
36
              "description": "The value of the attribute"
37
            }
38
          }
39
        }
40
      }
41
    },
42
    "required": ["type", "label", "children", "attributes"],
43
    "additionalProperties": false
44
  }
45
}

გაითვალისწინეთ, რომ UI-ის თითოეულ ელემენტს შეიძლება ჰყავდეს თვითნებური შვილობილი ელემენტები, რომლებიც რეკურსიულად მიმართავენ ძირითად სქემას. ეს მოქნილობა სწორედ ისაა, რასაც CFG მიდგომა უზრუნველყოფს.

შეზღუდვები და აკრძალვები

სტრუქტურირებული შედეგების გამოყენებისას გასათვალისწინებელია რამდენიმე შეზღუდვა:

  • სტრუქტურირებული შედეგები მხოლოდ JSON Schema-ს ქვეჯგუფს უჭერს მხარს, რაც დეტალურადაა აღწერილი ჩვენს დოკუმენტაციაში⁠(იხსნება ახალ ფანჯარაში). ეს გვეხმარება, უზრუნველვყოთ მაქსიმალურად კარგი წარმადობა.
  • ახალი სქემით პირველი API პასუხი დამატებით დაყოვნებას გამოიწვევს, მაგრამ მომდევნო პასუხები სწრაფი იქნება და დაყოვნების დამატებითი საფასური არ ექნება. ამის მიზეზია ის, რომ პირველ მოთხოვნაზე ჩვენ ზემოთ აღწერილის მიხედვით ვამუშავებთ სქემას და შემდეგ ამ არტეფაქტებს ვინახავთ ქეშში, რათა მოგვიანებით სწრაფად გამოვიყენოთ. ტიპური სქემების დამუშავებას პირველ მოთხოვნაზე 10 წამზე ნაკლები სჭირდება, მაგრამ უფრო რთულ სქემებს შეიძლება ერთ წუთამდე დასჭირდეს.
  • მოდელმა შეიძლება ვერ დაიცვას სქემა, თუ ის არაუსაფრთხო მოთხოვნის უარყოფას აირჩევს. თუ უარყოფას აირჩევს, დასაბრუნებელ შეტყობინებაში refusal ბულიანი მნიშვნელობა დაყენდება true-ზე, რათა ეს მიუთითოს. 
  • მოდელმა შეიძლება ვერ დაიცვას სქემა, თუ გენერირება დასრულებამდე მიაღწევს max_tokens-ს ან სხვა გაჩერების პირობას. 
  • სტრუქტურირებული შედეგები არ გამორიცხავს მოდელის ყველა სახის შეცდომას. მაგალითად, მოდელმა შეიძლება მაინც დაუშვას შეცდომები JSON ობიექტის მნიშვნელობებში (მაგ., მათემატიკურ განტოლებაში ნაბიჯი შეეშალოს). თუ დეველოპერები შეცდომებს აღმოაჩენენ, გირჩევთ, სისტემურ ინსტრუქციებში მაგალითები მიაწოდოთ ან ამოცანები უფრო მარტივ ქვეამოცანებად დაყოთ.
  • სტრუქტურირებული შედეგები თავსებადი არ არის პარალელურ ფუნქციის გამოძახებებთან. როცა პარალელური ფუნქციის გამოძახება გენერირდება, ის შესაძლოა მიწოდებულ სქემებს არ დაემთხვეს. პარალელური ფუნქციის გამოძახების გასათიშად დააყენეთ parallel_tool_calls: false.
  • სტრუქტურირებულ შედეგებთან მიწოდებული JSON Schema-ები მონაცემთა ნულოვანი შენარჩუნების⁠(იხსნება ახალ ფანჯარაში) (ZDR) კრიტერიუმებს არ აკმაყოფილებს.

ხელმისაწვდომობა

სტრუქტურირებული შედეგები დღეს უკვე საჯაროდ ხელმისაწვდომია API-ში. 

ფუნქციის გამოძახებით სტრუქტურირებული შედეგები ხელმისაწვდომია ყველა იმ მოდელზე, რომელსაც API-ში ფუნქციის გამოძახების მხარდაჭერა აქვს. ეს მოიცავს ჩვენს უახლეს მოდელებს (gpt-4o, gpt-4o-mini), ყველა მოდელს gpt-4-0613-ისა და gpt-3.5-turbo-0613-ის ჩათვლით და მათ შემდეგ, ასევე ნებისმიერ დახვეწილ მოდელს, რომელსაც ფუნქციის გამოძახების მხარდაჭერა აქვს. ეს ფუნქციონალი ხელმისაწვდომია Chat Completions API-ზე, Assistants API-ზე და Batch API-ზე. ფუნქციის გამოძახებით სტრუქტურირებული შედეგები ასევე თავსებადია ხედვის შეყვანებთან.

პასუხის ფორმატებით სტრუქტურირებული შედეგები ხელმისაწვდომია gpt-4o-mini-ზე და gpt-4o-2024-08-06-ზე, ასევე ამ მოდელებზე დაფუძნებულ ნებისმიერ fine-tune-ზე. ეს ფუნქციონალი ხელმისაწვდომია Chat Completions API-ზე, Assistants API-ზე და Batch API-ზე. პასუხის ფორმატებით სტრუქტურირებული შედეგები ასევე თავსებადია ხედვის შეყვანებთან. 

ახალ gpt-4o-2024-08-06-ზე გადასვლით დეველოპერები ზოგავენ 50%-ს შეყვანებზე ($2.50/1M input tokens) და 33%-ს შედეგებზე ($10.00/1M output tokens), gpt-4o-2024-05-13-თან შედარებით.

სტრუქტურირებული შედეგების გამოყენების დასაწყებად, გაეცანით ჩვენს დოკუმენტაციას⁠(იხსნება ახალ ფანჯარაში). 

მადლობები

სტრუქტურირებული შედეგები შთაგონებულია open source საზოგადოების შესანიშნავი ნამუშევრებით: კერძოდ, outlines⁠(იხსნება ახალ ფანჯარაში), jsonformer⁠(იხსნება ახალ ფანჯარაში), instructor⁠(იხსნება ახალ ფანჯარაში), guidance⁠(იხსნება ახალ ფანჯარაში) და lark⁠(იხსნება ახალ ფანჯარაში) ბიბლიოთეკებით.

ავტორი

Michelle Pokrass

ძირითადი მონაწილეები

Chris Colby, Melody Guan, Michelle Pokrass, Ted Sanders, Brian Zhang

მადლობები

John Allard, Filipe de Avila Belbute Peres, Ilan Bigio, Owen Campbell-Moore, Chen Ding, Atty Eleti, Elie Georges, Katia Gil Guzman, Jeff Harris, Johannes Heidecke, Beth Hoover, Romain Huet, Tomer Kaftan, Jillian Khoo, Karolis Kosas, Ryan Liu, Kevin Lu, Lindsay McCallum, Rohan Nuttall, Joe Palermo, Leher Pathak, Ishaan Singal, Felipe Petroski Such, Freddie Sulit, David Weedon