Salta al contingut principal
OpenAI

6 d’agost del 2024

Empresa

Presentem els resultats estructurats a l’API

Presentem els resultats estructurats a l’API: les sortides dels models ara segueixen de manera fiable els JSON Schemas proporcionats pels desenvolupadors.

La imatge mostra un patró abstracte de petits quadrats en diferents tons de blau, verd i groc clar. Els quadrats estan disposats en una formació semblant a una quadrícula, creant un efecte de mosaic amb una paleta de colors suau i pastel.

L’any passat, al DevDay, vam presentar el mode JSON, un bloc de construcció útil per als desenvolupadors que volen crear aplicacions fiables amb els nostres models. Tot i que el mode JSON millora la fiabilitat del model a l’hora de generar sortides JSON vàlides, no garanteix que la resposta del model s’ajusti a un esquema concret. Avui presentem els resultats estructurats a l’API, una nova funcionalitat dissenyada per garantir que les sortides generades pel model coincideixin exactament amb els JSON Schemas proporcionats pels desenvolupadors.

La generació de dades estructurades a partir d’entrades no estructurades és un dels casos d’ús fonamentals de la IA en les aplicacions actuals. Els desenvolupadors fan servir l’API d’OpenAI per crear assistents potents amb la capacitat d’obtenir dades i respondre preguntes mitjançant crida a funcions⁠(s'obre en una finestra nova), extreure dades estructurades per a l’entrada de dades i crear fluxos de treball agentics de diversos passos que permeten als LLM dur a terme accions. Els desenvolupadors fa temps que esquiven les limitacions dels LLM en aquest àmbit mitjançant eines de codi obert, indicacions i repetint sol·licituds per assegurar-se que les sortides del model coincideixen amb els formats necessaris per interoperar amb els seus sistemes. Els resultats estructurats resolen aquest problema restringint els models d’OpenAI perquè coincideixin amb els esquemes proporcionats pels desenvolupadors i entrenant els nostres models perquè entenguin millor els esquemes complicats.

A les nostres avaluacions de seguiment d’esquemes JSON complexos, el nostre nou model gpt-4o-2024-08-06 amb resultats estructurats obté un 100% perfecte. En comparació, gpt-4-0613 obté menys del 40%.

Amb els resultats estructurats, gpt-4o-2024-08-06 assoleix una fiabilitat del 100% a les nostres avaluacions, coincidint perfectament amb els esquemes de sortida.

Com fer servir els resultats estructurats

Presentem els resultats estructurats a l’API en dues formes: 

1. Crida a funcions: els resultats estructurats mitjançant tools estan disponibles establint strict: true dins de la definició de la funció. Aquesta funcionalitat funciona amb tots els models que admeten eines, incloent-hi tots els models gpt-4-0613 i gpt-3.5-turbo-0613 i posteriors. Quan els resultats estructurats estan habilitats, les sortides del model coincidiran amb la definició de l’eina proporcionada.

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. Una opció nova per al paràmetre response_format: els desenvolupadors ara poden proporcionar un JSON Schema mitjançant json_schema, una opció nova per al paràmetre response_format. Això és útil quan el model no crida una eina, sinó que respon a l’usuari de manera estructurada. Aquesta funcionalitat funciona amb els nostres models GPT‑4o més nous: gpt-4o-2024-08-06, llançat avui, i gpt-4o-mini-2024-07-18. Quan es proporciona un response_format amb strict: true, les sortides del model coincidiran amb l’esquema proporcionat.

Sol·licitud

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
}

Resultats estructurats segurs

La seguretat és una prioritat màxima per a OpenAI: la nova funcionalitat de resultats estructurats complirà les nostres polítiques de seguretat actuals i continuarà permetent que el model rebutgi una sol·licitud no segura. Per simplificar el desenvolupament, hi ha un nou valor de cadena refusal a les respostes de l’API que permet als desenvolupadors detectar de manera programàtica si el model ha generat un rebuig en lloc d’una sortida que coincideixi amb l’esquema. Quan la resposta no inclou cap rebuig i la resposta del model no s’ha interromput prematurament (tal com indica finish_reason), la resposta del model generarà de manera fiable un JSON vàlid que coincideixi amb l’esquema proporcionat.

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
}

Suport natiu de l’SDK

Els nostres SDK de Python i Node s’han actualitzat amb suport natiu per a resultats estructurats. Proporcionar un esquema per a eines o com a format de resposta és tan fàcil com proporcionar un objecte Pydantic o Zod, i els nostres SDK s’encarregaran de convertir el tipus de dades en un esquema JSON compatible, deserialitzar automàticament la resposta JSON a l’estructura de dades tipada i analitzar els rebutjos si es produeixen.

Els exemples següents mostren el suport natiu per a resultats estructurats amb crida a funcions.

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)

El suport natiu per a resultats estructurats també està disponible per a 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)

Casos d’ús addicionals

Els desenvolupadors fan servir sovint els models d’OpenAI per generar dades estructurades per a diversos casos d’ús. Alguns exemples addicionals inclouen:

Generació dinàmica d’interfícies d’usuari segons la intenció de l’usuari

Per exemple, els desenvolupadors poden fer servir resultats estructurats per crear aplicacions que generin codi o interfícies d’usuari. Tots els exemples següents fan servir el mateix response_format i es poden fer servir per generar interfícies d’usuari variades segons l’entrada de l’usuari.

Sistema
Ets un assistent d'interfície d'usuari. La teva feina és ajudar els usuaris a visualitzar les seves idees de lloc web i d'aplicació.
Format de resposta
Assistent
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

Separació d’una resposta final del raonament de suport o de comentaris addicionals

Pot ser útil donar al model un camp separat per a la cadena de pensament per millorar la qualitat final de la resposta.

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
}

Extracció de dades estructurades a partir de dades no estructurades

Per exemple, demanar al model que extregui elements com ara tasques pendents, dates de venciment i assignacions de notes de reunió.

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
}

Com funciona internament

Hem adoptat un enfocament en dues parts per millorar la fiabilitat de les sortides del model que coincideixen amb JSON Schema. En primer lloc, hem entrenat el nostre model més nou, gpt-4o-2024-08-06, perquè entengui esquemes complicats i la millor manera de produir sortides que hi coincideixin. Tanmateix, el comportament del model és intrínsecament no determinista: malgrat les millores de rendiment d’aquest model (93% a la nostra prova de referència), encara no assolia la fiabilitat que els desenvolupadors necessiten per crear aplicacions robustes. Per això també hem adoptat un enfocament determinista basat en enginyeria per restringir les sortides del model i aconseguir una fiabilitat del 100%.

Descodificació restringida

El nostre enfocament es basa en una tècnica coneguda com a mostreig restringit o descodificació restringida. Per defecte, quan es mostregen models per produir sortides, no tenen cap restricció i poden seleccionar qualsevol segment del vocabulari com a sortida següent. Aquesta flexibilitat és el que permet que els models cometin errors; per exemple, generalment són lliures de mostrejar un segment de clau en qualsevol moment, fins i tot quan això no produiria un JSON vàlid. Per forçar sortides vàlides, restringim els nostres models perquè només puguin produir segments que siguin vàlids segons l’esquema proporcionat, en lloc de tots els segments disponibles.

Implementar aquesta restricció a la pràctica pot ser difícil, ja que els segments que són vàlids varien al llarg de la sortida del model. Suposem que tenim l’esquema següent:

JSON

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

Els segments que són vàlids al començament de la sortida inclouen coses com {, {“, {
, etc. Tanmateix, un cop el model ja ha mostrejat {“val, { deixa de ser un segment vàlid. Per tant, hem d’implementar una descodificació restringida dinàmica i determinar quins segments són vàlids després de generar cada segment, en lloc de fer-ho per endavant al començament de la resposta.

Per fer-ho, convertim el JSON Schema proporcionat en una gramàtica lliure de context (CFG). Una gramàtica és un conjunt de regles que defineixen un llenguatge, i una gramàtica lliure de context és una gramàtica que compleix regles específiques. Podeu pensar en JSON i JSON Schema com a llenguatges particulars amb regles per definir què és vàlid dins del llenguatge. De la mateixa manera que en anglès no és correcte tenir una frase sense verb, en JSON no és vàlid tenir una coma final.

Així doncs, per a cada JSON Schema, calculem una gramàtica que representa aquest esquema i preprocessem els seus components perquè siguin fàcilment accessibles durant el mostreig del model. Per això la primera sol·licitud amb un esquema nou comporta una penalització de latència: hem de preprocessar l’esquema per generar aquest artefacte que després podem fer servir de manera eficient durant el mostreig.

Durant el mostreig, després de cada segment, el nostre motor d’inferència determinarà quins segments són vàlids per produir-se a continuació basant-se en els segments generats prèviament i en les regles de la gramàtica que indiquen quins segments són vàlids a continuació. Després fem servir aquesta llista de segments per emmascarar el pas de mostreig següent, cosa que redueix efectivament la probabilitat dels segments no vàlids a 0. Com que hem preprocessat l’esquema, podem fer-ho de manera eficient amb una estructura de dades en memòria cau, amb una sobrecàrrega de latència mínima.

Enfocaments alternatius

Els enfocaments alternatius a aquest problema sovint fan servir màquines d’estats finits (FSM) o expressions regulars (generalment implementades amb FSM) per a la descodificació restringida. Funcionen de manera similar en el fet que actualitzen dinàmicament quins segments són vàlids després de produir cada segment, però tenen algunes diferències clau respecte de l’enfocament CFG. En particular, les CFG poden expressar una classe de llenguatges més àmplia que les FSM. A la pràctica, això no importa per a esquemes molt simples com l’esquema value mostrat més amunt. Tanmateix, trobem que la diferència és significativa per a esquemes més complexos que impliquen estructures de dades imbricades o recursives. Per exemple, les FSM generalment no poden expressar tipus recursius, cosa que significa que els enfocaments basats en FSM poden tenir dificultats per fer coincidir parèntesis en JSON profundament imbricat. El següent és un esquema recursiu d’exemple compatible amb l’API d’OpenAI amb resultats estructurats però que no seria possible expressar amb una 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
}

Tingueu en compte que cada element de la IU pot tenir fills arbitraris que fan referència a l’esquema arrel de manera recursiva. Aquesta flexibilitat és una de les coses que permet l’enfocament CFG.

Limitacions i restriccions

Hi ha algunes limitacions que cal tenir presents quan es fan servir resultats estructurats:

  • Els resultats estructurats només admeten un subconjunt de JSON Schema, descrit amb detall a la nostra documentació⁠(s'obre en una finestra nova). Això ens ajuda a garantir el millor rendiment possible.
  • La primera resposta de l’API amb un esquema nou comportarà latència addicional, però les respostes posteriors seran ràpides i sense penalització de latència. Això és així perquè, durant la primera sol·licitud, processem l’esquema tal com s’ha indicat més amunt i després emmagatzemem aquests artefactes a la memòria cau per poder-los reutilitzar ràpidament més endavant. Els esquemes típics triguen menys de 10 segons a processar-se en la primera sol·licitud, però els esquemes més complexos poden trigar fins a un minut.
  • És possible que el model no segueixi l’esquema si decideix rebutjar una sol·licitud no segura. Si decideix rebutjar-la, el missatge de retorn tindrà el booleà refusal establert a true per indicar-ho. 
  • És possible que el model no segueixi l’esquema si la generació arriba a max_tokens o a una altra condició d’aturada abans d’acabar. 
  • Els resultats estructurats no eviten tots els tipus d’errors del model. Per exemple, el model encara pot cometre errors dins dels valors de l’objecte JSON (p. ex., equivocar-se en un pas d’una equació matemàtica). Si els desenvolupadors troben errors, recomanem proporcionar exemples a les instruccions del sistema o dividir les tasques en subtasques més senzilles.
  • Els resultats estructurats no són compatibles amb les crides a funcions en paral·lel. Quan es genera una crida a funcions en paral·lel, pot ser que no coincideixi amb els esquemes proporcionats. Definiu parallel_tool_calls: false per desactivar la crida a funcions en paral·lel.
  • Els JSON Schemas proporcionats amb resultats estructurats no poden acollir-se a la retenció de dades nul·la⁠(s'obre en una finestra nova) (ZDR).

Disponibilitat

Els resultats estructurats ja estan disponibles de manera general a l’API. 

Els resultats estructurats amb crida a funcions estan disponibles en tots els models que admeten crida a funcions a l’API. Això inclou els nostres models més nous (gpt-4o, gpt-4o-mini), tots els models a partir de gpt-4-0613 i gpt-3.5-turbo-0613, i qualsevol model ajustat fi que admeti crida a funcions. Aquesta funcionalitat està disponible a l’API de complecions de xat, l’Assistants API i la Batch API. Els resultats estructurats amb crida a funcions també són compatibles amb entrades de visió.

Els resultats estructurats amb formats de resposta estan disponibles a gpt-4o-mini i gpt-4o-2024-08-06 i a qualsevol ajust fi basat en aquests models. Aquesta funcionalitat està disponible a l’API de complecions de xat, l’Assistants API i la Batch API. Els resultats estructurats amb formats de resposta també són compatibles amb entrades de visió. 

En canviar al nou gpt-4o-2024-08-06, els desenvolupadors estalvien un 50% en entrades ($2.50/1M segments d’entrada) i un 33% en sortides ($10.00/1M segments de sortida) en comparació amb gpt-4o-2024-05-13.

Per començar a fer servir els resultats estructurats, consulteu la nostra documentació⁠(s'obre en una finestra nova). 

Agraïments

Els resultats estructurats s’inspiren en l’excel·lent feina de la comunitat de codi obert: concretament, les biblioteques outlines⁠(s'obre en una finestra nova), jsonformer⁠(s'obre en una finestra nova), instructor⁠(s'obre en una finestra nova), guidance⁠(s'obre en una finestra nova) i lark⁠(s'obre en una finestra nova).

Autor

Michelle Pokrass

Col·laboradors principals

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

Agraïments

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