Liwati menyang isi utama
OpenAI

6 Agustus 2024

Perusahaan

Ngenalake Structured Outputs ing API

Kita ngenalake Structured Outputs ing API—keluaran model saiki bisa manut kanthi andal marang JSON Schema sing diwenehake pangembang.

Gambar iki nuduhake pola abstrak saka kothak-kothak cilik kanthi warna biru, ijo, lan kuning enom sing béda-béda. Kothak-kothak kasebut disusun kaya kisi, nggawe efek mozaik nganggo palet warna pastel sing alus.

Tahun kepungkur ing DevDay, kita ngenalake mode JSON—blok dhasar sing migunani kanggo para pangembang sing pengin mbangun aplikasi sing andal nganggo model kita. Sanajan mode JSON ningkatake reliabilitas model kanggo ngasilake output JSON sing valid, mode iki ora njamin manawa tanggapan model bakal manut marang skema tartamtu. Dina iki kita ngenalake Structured Outputs ing API, fitur anyar sing dirancang kanggo njamin output sing digawe model bakal pas cocog karo JSON Schema sing diwenehake para pangembang.

Ngasilake data terstruktur saka input sing ora terstruktur iku salah siji kasus panggunaan inti kanggo AI ing aplikasi jaman saiki. Para pangembang nggunakaké OpenAI API kanggo mbangun assistant sing kuwat sing nduwèni kemampuan njupuk data lan njawab pitakon liwat nelpon fungsi⁠(mbukak ing jendhela anyar), ngekstrak data terstruktur kanggo entri data, lan mbangun alur kerja agen multilangkah sing ngidini LLM njupuk tumindak. Para pangembang wis suwe golek cara ngubengi watesan LLM ing area iki liwat piranti open source, prompting, lan mbaleni panyuwunan bola-bali kanggo mesthekake output model cocog karo format sing dibutuhake supaya bisa interoperasi karo sistemé. Structured Outputs ngrampungake masalah iki kanthi mbatesi model OpenAI supaya cocog karo skema sing diwenehake pangembang lan kanthi nglatih model kita supaya luwih ngerti skema sing rumit.

Ing eval kita babagan ngetutake skema JSON kompleks, model anyar kita gpt-4o-2024-08-06 kanthi Structured Outputs entuk skor sampurna 100%. Déné gpt-4-0613 entuk skor kurang saka 40%.

Kanthi Structured Outputs, gpt-4o-2024-08-06 nggayuh reliabilitas 100% ing eval kita, cocog sampurna karo skema output.

Cara nggunakake Structured Outputs

Kita ngenalake Structured Outputs ing API kanthi rong wujud: 

1. Function calling: Structured Outputs liwat tools kasedhiya kanthi nyetel strict: true ing njero definisi fungsi panjenengan. Fitur iki bisa digunakake karo kabeh model sing ndhukung tools, kalebu kabeh model gpt-4-0613 lan gpt-3.5-turbo-0613 lan sakbanjuré. Nalika Structured Outputs diaktifake, output model bakal cocog karo definisi alat sing diwenehake.

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. Opsi anyar kanggo parameter response_format: para pangembang saiki bisa nyedhiyakake JSON Schema liwat json_schema, opsi anyar kanggo parameter response_format. Iki migunani nalika model ora lagi nelpon alat, nanging malah nanggapi pangguna kanthi cara terstruktur. Fitur iki bisa digunakake karo model GPT‑4o paling anyar kita: gpt-4o-2024-08-06, dirilis dina iki, lan gpt-4o-mini-2024-07-18. Nalika response_format diwenehake nganggo strict: true, keluaran model bakal cocog karo skema sing diwenehake.

Panyuwunan

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
}

Structured Outputs sing aman

Keamanan iku prioritas utama kanggo OpenAI—fungsionalitas Structured Outputs anyar bakal manut marang kabijakan keamanan sing wis ana lan isih bakal ngidini model nolak panyuwunan sing ora aman. Supaya pangembangan luwih gampang, ana nilai string refusal anyar ing tanggapan API sing ngidini para pangembang ndeteksi kanthi programatis apa model ngasilake penolakan tinimbang output sing cocog karo skema. Nalika tanggapan ora ngemot penolakan lan tanggapan model durung keganggu sadurunge waktune (kaya sing dituduhake dening finish_reason), mula tanggapan model bakal kanthi andal ngasilake JSON valid sing cocog karo skema sing diwenehake.

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
}

Dukungan SDK native

SDK Python lan Node kita wis dianyari nganggo dukungan native kanggo Structured Outputs. Nyedhiyakake skema kanggo tools utawa minangka format tanggapan semudah nyedhiyakake objek Pydantic utawa Zod, lan SDK kita bakal nangani ngowahi jinis data dadi JSON schema sing didhukung, nindakake deserialisasi tanggapan JSON dadi struktur data bertipe kanthi otomatis, lan ngurai penolakan yen ana.

Conto-conto ing ngisor iki nuduhake dukungan native kanggo Structured Outputs nganggo function calling.

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)

Dukungan Native Structured Outputs uga kasedhiya kanggo 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)

Kasus panggunaan tambahan

Para pangembang kerep nggunakake model OpenAI kanggo ngasilake data terstruktur kanggo manéka kasus panggunaan. Sawetara conto tambahan kalebu:

Ngasilake antarmuka pangguna kanthi dinamis adhedhasar maksud pangguna

Contoné, para pangembang bisa nggunakaké Structured Outputs kanggo nggawe aplikasi sing ngasilake kode utawa UI. Kabeh conto ing ngisor iki nggunakaké response_format sing padha, lan bisa digunakaké kanggo ngasilake UI sing béda-béda adhedhasar input pangguna.

Sistem
Njenengan iku asisten antarmuka pangguna. Tugasmu yaiku mbantu pangguna nggambarake ide-ide situs web lan aplikasi.
Format tanggapan
Asisten
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

Misahake jawaban pungkasan saka nalar pendukung utawa komentar tambahan

Bisa migunani yen model diwenehi kolom kapisah kanggo chain of thought supaya kualitas akhir tanggapan luwih apik.

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
}

Ngekstrak data terstruktur saka data ora terstruktur

Contoné, menehi instruksi marang model kanggo ngekstrak perkara kaya to-do, tanggal tenggat, lan penugasan saka cathetan rapat.

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
}

Cara kerjané ing njero

Kita njupuk pendekatan rong bagéan kanggo ningkatake reliabilitas keluaran model sing cocog karo JSON Schema. Pisanan, kita nglatih model paling anyar kita gpt-4o-2024-08-06 supaya paham skema sing rumit lan cara paling apik kanggo ngasilake output sing cocog. Nanging, prilaku model sipaté pancen non-deterministik—senadyan ana peningkatan kinerja model iki (93% ing benchmark kita), isih durung nyukupi reliabilitas sing dibutuhake pangembang kanggo mbangun aplikasi sing kuwat. Mula kita uga njupuk pendekatan deterministik adhedhasar rekayasa kanggo mbatesi output model supaya nggayuh reliabilitas 100%.

Decoding diwatesi

Pendekatan kita adhedhasar tèknik sing dikenal minangka constrained sampling utawa constrained decoding. Kanthi gawan, nalika model disampling kanggo ngasilake output, model kuwi pancen ora diwatesi lan bisa milih token apa waé saka kosakata minangka output sabanjuré. Keluwesan iki sing ndadekake model bisa nggawe kesalahan; contoné, model umume bébas nyampling token kurung kurawal kapan waé, sanajan kuwi ora bakal ngasilake JSON sing valid. Kanggo meksa output sing valid, kita mbatesi model kita mung marang token sing bakal valid miturut skema sing diwenehake, dudu kabeh token sing kasedhiya.

Ngetrapake watesan iki ing praktik bisa dadi tantangan, amarga token sing valid béda-béda sajrone output model. Upamané kita nduwèni skema kaya ing ngisor iki:

JSON

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

Token sing valid ing wiwitan output kalebu perkara kaya {, {“, {
, lan liya-liyané. Nanging, sawisé model wis nyampling {“val, mula { ora valid maneh minangka token. Mula kita kudu ngetrapake decoding diwatesi dinamis, lan nemtokake token endi sing valid sawisé saben token diasilake, dudu ditemtokake dhisik ing wiwitan tanggapan.

Kanggo nindakake iki, kita ngowahi JSON Schema sing diwenehake dadi context-free grammar (CFG). Grammar iku kumpulan aturan sing nemtokake sawijining basa, lan context-free grammar iku grammar sing manut marang aturan tartamtu. Sampeyan bisa nganggep JSON lan JSON Schema minangka basa tartamtu sing nduwèni aturan kanggo nemtokake apa sing valid ing njero basa kasebut. Kaya déné ora valid ing basa Inggris yen ana ukara tanpa kriya, ora valid uga ing JSON yen ana koma nggléndhangi ing pungkasan.

Mula, kanggo saben JSON Schema, kita ngitung grammar sing makili skema kasebut, lan nindakake pra-pangolahan komponèné supaya gampang diakses nalika sampling model. Iki sebabé panyuwunan kapisan nganggo skema anyar kena penalti latensi—amarga kita kudu nindakake pra-pangolahan skema kanggo ngasilake artefak iki sing bisa digunakake kanthi efisien nalika sampling.

Nalika sampling, sawisé saben token, mesin inferensi kita bakal nemtokake token endi sing valid kanggo diasilake sabanjuré adhedhasar token sing wis diasilake sadurungé lan aturan ing grammar sing nuduhake token endi sing valid sabanjuré. Banjur kita nggunakaké dhaptar token iki kanggo masking langkah sampling sabanjuré, sing kanthi efektif nurunaké probabilitas token sing ora valid dadi 0. Amarga skema wis dipraolah, kita bisa nggunakaké struktur data cache kanggo nindakake iki kanthi efisien, kanthi overhead latensi sing minimal.

Pendekatan alternatif

Pendekatan alternatif kanggo masalah iki asring nggunakaké finite state machines (FSM) utawa regex (umumé diimplementasikaké nganggo FSM) kanggo decoding diwatesi. Cara iki padha fungsiné amarga nganyari kanthi dinamis token endi sing valid sawisé saben token diasilake, nanging nduwèni sawetara béda penting saka pendekatan CFG. Sing paling katon, CFG bisa nyatakaké kelas basa sing luwih amba tinimbang FSM. Ing praktik, iki ora pati penting kanggo skema sing prasaja banget kaya skema value sing dituduhake ing ndhuwur. Nanging, miturut panemuan kita, béda iki wigati kanggo skema sing luwih rumit sing nglibataké struktur data bertingkat utawa rekursif. Minangka conto, FSM umumé ora bisa nyatakaké jinis rekursif, tegese pendekatan adhedhasar FSM bisa kesulitan nyocogaké tandha kurung ing JSON sing nested banget. Ing ngisor iki ana conto skema rekursif sing didhukung ing OpenAI API kanthi Structured Outputs nanging ora bisa dinyatakake nganggo 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
}

Elinga manawa saben unsur UI bisa nduwèni turunan sakarepé dhewe sing ngrujuk menyang skema root kanthi rekursif. Keluwesan iki minangka salah siji perkara sing diwenehake pendekatan CFG.

Watesan lan larangan

Ana sawetara watesan sing perlu digatekake nalika nggunakake Structured Outputs:

  • Structured Outputs mung ngidini sapérangan saka JSON Schema, kanthi rincian ing dokumen kita⁠(mbukak ing jendhela anyar). Iki mbantu kita njamin kinerja sing paling apik.
  • Tanggapan API kapisan nganggo skema anyar bakal nambah latensi, nanging tanggapan sabanjuré bakal cepet tanpa penalti latensi. Iki amarga sajrone panyuwunan kapisan, kita ngolah skema kaya sing diterangake ing ndhuwur lan banjur nyimpen artefak iki ing cache supaya bisa digunakake maneh kanthi cepet mengko. Skema sing umum biasane mbutuhake wektu kurang saka 10 detik kanggo diproses ing panyuwunan kapisan, nanging skema sing luwih rumit bisa nganti sak menit.
  • Model bisa gagal ngetutake skema yen model milih nolak panyuwunan sing ora aman. Yen milih nolak, pesen bali bakal nduwèni nilai boolean refusal disetel dadi true kanggo nandhani iki. 
  • Model bisa gagal ngetutake skema yen generasi tekan max_tokens utawa kondisi mandheg liyane sadurunge rampung. 
  • Structured Outputs ora nyegah kabèh jinis kesalahan model. Contoné, model isih bisa nggawe kesalahan ing nilai obyek JSON (umpamané, salah siji langkah ing persamaan matematika). Yen para pangembang nemokake kesalahan, kita nyaranake menehi conto ing instruksi sistem utawa mecah tugas dadi subtugas sing luwih prasaja.
  • Structured Outputs ora kompatibel karo parallel function calls. Nalika parallel function call diasilake, asilé bisa uga ora cocog karo skema sing diwenehake. Setel parallel_tool_calls: false kanggo mateni function calling paralel.
  • JSON Schema sing diwenehake nganggo Structured Outputs ora layak kanggo retensi data nol⁠(mbukak ing jendhela anyar) (ZDR).

Kasedhiyan

Structured Outputs saiki wis kasedhiya umum ing API. 

Structured Outputs nganggo nelpon fungsi kasedhiya ing kabeh model sing ndhukung function calling ing API. Iki kalebu model paling anyar kita (gpt-4o, gpt-4o-mini), kabeh model wiwit lan kalebu gpt-4-0613 lan gpt-3.5-turbo-0613, lan model fine-tuned apa wae sing ndhukung function calling. Fungsionalitas iki kasedhiya ing Chat Completions API, Assistants API, lan Batch API. Structured Outputs nganggo function calling uga kompatibel karo input visi.

Structured Outputs nganggo format tanggapan kasedhiya ing gpt-4o-mini lan gpt-4o-2024-08-06 lan fine-tune apa wae adhedhasar model iki. Fungsionalitas iki kasedhiya ing Chat Completions API, Assistants API, lan Batch API. Structured Outputs nganggo format tanggapan uga kompatibel karo input visi. 

Kanthi ngalih menyang gpt-4o-2024-08-06 anyar, para pangembang bisa ngirit 50% kanggo input ($2.50/1M input token) lan 33% kanggo output ($10.00/1M output token) dibandhingake karo gpt-4o-2024-05-13.

Kanggo miwiti nggunakake Structured Outputs, delengen dokumen⁠(mbukak ing jendhela anyar) kita. 

Pangajèn

Panulis

Michelle Pokrass

Kontributor inti

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

Pangajèn

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