Ir al contenido principal
OpenAI

6 de agosto de 2024

Empresa

Introducción de outputs estructurados en la API

Hemos introducido los outputs estructurados en la API: los outputs del modelo ahora se ajustan de manera fiable a los esquemas JSON proporcionados por los desarrolladores.

La imagen muestra un patrón abstracto de cuadrados pequeños en distintos tonos de azul, verde y amarillo claro. Los cuadrados están colocados en una cuadrícula, creando un efecto de mosaico con una paleta de suaves colores pastel.

El año pasado, en DevDay, presentamos el modo JSON, un componente útil para los desarrolladores que desean crear aplicaciones fiables con nuestros modelos. Mientras que el modo JSON mejora la fiabilidad del modelo para generar outputs JSON válidos, no garantiza que la respuesta del modelo se ajuste a un esquema particular. Hoy, presentamos los outputs estructurados en la API, una nueva característica diseñada para garantizar que los outputs generados por el modelo coincidan exactamente con los esquemas JSON proporcionados por los desarrolladores.

Generar datos estructurados a partir de datos de entrada no estructurados es uno de los principales casos de uso de la IA en las aplicaciones actuales. Los desarrolladores utilizan la API de OpenAI para crear asistentes potentes capaces de recuperar datos y responder a preguntas mediante la solicitud de funciones(se abre en una ventana nueva), extraer datos estructurados para la entrada de datos y crear flujos de trabajo agénticos de varios pasos para que los LLM realicen acciones. Los desarrolladores llevan mucho tiempo sorteando las limitaciones de los LLM en esta área mediante herramientas de código abierto, prompts y constantes reintentos de solicitudes para garantizar que los outputs del modelo coincidan con los formatos necesarios para interoperar con sus sistemas. Los outputs estructurados resuelven este problema al obligar a los modelos de OpenAI a coincidir con los esquemas proporcionados por los desarrolladores y entrenar nuestros modelos para que comprendan mejor los esquemas complicados.

En nuestras evaluaciones de esquemas JSON complejos, nuestro nuevo modelo gpt-4o-2024-08-06 con outputs estructurados obtiene una puntuación perfecta del 100 %. En comparación, gpt-4-0613 obtiene una puntuación inferior al 40 %.

Con los outputs estructurados, gpt-4o-2024-08-06 logra un 100 % de fiabilidad en nuestras evaluaciones y coincide perfectamente con los esquemas de outputs.

Cómo utilizar los outputs estructurados

Hemos introducido los outputs estructurados en dos formatos en la API: 

1. Solicitud de funciones: los outputs estructurados a través de herramientas están disponibles configurando strict: true en la definición de su función. Esta característica funciona con todos los modelos que admiten herramientas, incluidos todos los modelos gpt-4-0613, gpt-3.5-turbo-0613 y posteriores. Cuando los outputs estructurados están habilitados, las salidas del modelo coinciden con la definición de herramienta 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 nueva opción para el parámetro response_format: los desarrolladores ahora pueden proporcionar un esquema JSON a través de json_schema, una nueva opción para el parámetro response_format. Esto resulta útil cuando el modelo no realiza una solicitud de herramienta, sino que responde al usuario de forma estructurada. Esto funciona con nuestros modelos GPT‑4o más nuevos: gpt-4o-2024-08-06, lanzado hoy, y gpt-4o-mini-2024-07-18. Cuando se proporciona un response_format con strict: true, los outputs del modelo coinciden con el esquema proporcionado.

Solicitud

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
}

Outputs estructurados seguros

La seguridad es una prioridad absoluta para OpenAI: la nueva función de outputs estructurados cumplirá con nuestras políticas de seguridad existentes y seguirá permitiendo que el modelo rechace una solicitud que plantee un problema de seguridad. Para simplificar el desarrollo, hay un nuevo valor de cadena refusal en las respuestas de la API que permite a los desarrolladores detectar mediante programación si el modelo ha generado un rechazo en lugar de un output que coincida con el esquema. Si la respuesta no incluye un rechazo y la respuesta del modelo no se ha interrumpido prematuramente (indicado por finish_reason), entonces la respuesta del modelo producirá de manera fiable un JSON válido que coincida con el esquema proporcionado.

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
}

Compatibilidad nativa con SDK

Nuestros SDK de Python y Node se han actualizado con compatibilidad nativa para outputs estructurados. Proporcionar un esquema para herramientas o como formato de respuesta es tan fácil como proporcionar un objeto Pydantic o Zod. Nuestros SDK se encargarán de convertir el tipo de datos a un esquema JSON compatible, deserializar la respuesta JSON en la estructura de datos escrita automáticamente y analizar los rechazos si se dan.

Los siguientes ejemplos muestran la compatibilidad nativa con outputs estructurados con solicitud de funciones.

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)

La compatibilidad con outputs estructurados nativos también está disponible para 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 de uso adicionales

Los desarrolladores utilizan con frecuencia los modelos de OpenAI para generar datos estructurados para diversos casos de uso. Otros ejemplos incluyen:

Generar dinámicamente interfaces de usuario a partir de la intención del usuario

Por ejemplo, los desarrolladores pueden utilizar outputs estructurados para crear aplicaciones que generen código o interfaces de usuario. Todos los ejemplos siguientes utilizan el mismo response_format y se pueden utilizar para generar distintas IU en función de los datos de entrada del usuario.

Sistema
Eres un asistente de la interfaz de usuario. Tu trabajo consiste en ayudar a los usuarios a visualizar ideas para su sitio web y aplicaciones.
Formato de respuesta
Asistente
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

Separar una respuesta final del razonamiento de respaldo o comentario adicional

Puede resultar útil proporcionarle al modelo un campo aparte para la cadena de pensamiento con el fin de mejorar la calidad final de la respuesta.

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
}

Extraer datos estructurados de datos no estructurados

Por ejemplo, indicarle al modelo que extraiga cosas como tareas pendientes, fechas de entrega y tareas de las notas de la reunión.

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
}

Implementación

Adoptamos un enfoque de dos partes para mejorar la fiabilidad de los outputs del modelo que coinciden con el esquema JSON. En primer lugar, entrenamos nuestro modelo más nuevo, gpt-4o-2024-08-06, para que comprendiera esquemas complicados y la mejor manera de producir outputs que coincidieran con ellos. Sin embargo, el comportamiento del modelo es, esencialmente, no determinista: a pesar de las mejoras de rendimiento de este modelo (93 % respecto al punto de referencia), no alcanzó el nivel de fiabilidad que los desarrolladores necesitan para crear aplicaciones sólidas. Por lo tanto, también adoptamos un enfoque determinista basado en ingeniería para limitar los outputs del modelo y lograr una fiabilidad del 100 %.

Decodificación restringida

Nuestro enfoque se basa en una técnica conocida como muestreo restringido o decodificación restringida. De forma predeterminada, cuando se muestrean modelos para producir outputs, no están restringidos en absoluto y pueden seleccionar cualquier token del vocabulario como el siguiente output. Esta flexibilidad es lo que permite que los modelos cometan errores; por ejemplo, generalmente pueden probar un token de llave en cualquier momento, incluso aunque no se produzca JSON válido. Para obligar a la obtención de outputs válidos, restringimos nuestros modelos a solo tokens que serían válidos según el esquema proporcionado, en lugar de todos los tokens disponibles.

Puede resultar complicado implementar esta restricción en la práctica, ya que los tokens válidos difieren a lo largo del output de un modelo. Pongamos que tenemos el siguiente esquema:

JSON

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

Los tokens que son válidos al comienzo del output incluyen cosas como {, {“, {\n, etc. Sin embargo, una vez que el modelo ya ha muestreado {“val, { ya no es un token válido. Por lo tanto, debemos implementar una decodificación dinámica restringida y determinar qué tokens son válidos después de generar cada token, en lugar de hacerlo al comienzo de la respuesta.

Para ello, convertimos el esquema JSON proporcionado en una gramática libre de contexto (CFG). Una gramática es un conjunto de reglas que definen un idioma, y ​​una gramática libre de contexto es una gramática que se ajusta a reglas específicas. Pongamos que JSON y el esquema JSON son lenguajes particulares con reglas para definir lo que es válido dentro del lenguaje. Así como en español no podemos tener una oración sin verbo, no es válido en JSON terminar con una coma.

Por lo tanto, para cada esquema JSON, calculamos una gramática que representa ese esquema y preprocesamos sus componentes para que sea fácilmente accesible durante el muestreo del modelo. Es por eso que la primera solicitud con un nuevo esquema genera una penalización de latencia: debemos preprocesar el esquema para generar este artefacto que podremos usar de manera eficaz durante el muestreo.

Mientras realizamos el muestreo, después de cada token, nuestro motor de inferencia determinará qué tokens son válidos para producirse a continuación en función de los tokens generados previamente y las reglas de la gramática que indican qué tokens son válidos a continuación. Después, usamos esta lista de tokens para enmascarar el siguiente paso del muestreo, lo que reduce la probabilidad de tokens no válidos a 0. Como hemos preprocesado el esquema, podemos usar una estructura de datos en caché para hacerlo de manera eficaz, con una latencia mínima.

Enfoques alternativos

Los enfoques alternativos a este problema suelen utilizar máquinas de estado finito (FSM) o expresiones regulares (generalmente implementadas con FSM) para la decodificación restringida. Funcionan de manera similar en el sentido de que actualizan dinámicamente qué tokens son válidos después de que se produzca cada token, pero tienen algunas diferencias clave con respecto al enfoque de CFG. En particular, las CFG pueden expresar una clase más amplia de lenguajes que las FSM. En la práctica, esto no importa para esquemas muy simples como el esquema de value mostrado anteriormente. Sin embargo, hemos observado que la diferencia es significativa para esquemas más complejos que involucran estructuras de datos anidadas o recursivas. Por ejemplo, las FSM generalmente no pueden expresar tipos recursivos, lo que significa que los enfoques basados ​​en FSM pueden tener dificultades para hacer coincidir los paréntesis en JSON muy anidado. El siguiente es un esquema recursivo de muestra compatible con la API de OpenAI con outputs estructurados, pero que no sería posible expresar con 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
}

Es importante observar que cada elemento de la interfaz de usuario puede tener elementos secundarios arbitrarios que hagan referencia al esquema raíz de forma recursiva. Esta flexibilidad es algo que facilita el enfoque de CFG.

Limitaciones y restricciones

El uso de outputs estructurados tiene algunas limitaciones:

  • Los outputs estructurados solo permiten un subconjunto del esquema JSON, que se detalla en nuestra documentación(se abre en una ventana nueva). Esto nos ayuda a garantizar el mejor rendimiento posible.
  • La primera respuesta de la API con un nuevo esquema generará latencia adicional, pero las respuestas posteriores serán rápidas, sin penalización de latencia. Esto se debe a que, durante la primera solicitud, procesamos el esquema como se ha indicado anteriormente, y luego almacenamos en caché estos artefactos para poder reutilizarlos de manera rápida más adelante. Los esquemas típicos tardan menos de 10 segundos en procesarse en la primera solicitud, mientras que los esquemas más complejos pueden tardar hasta un minuto.
  • Es posible que el modelo no siga el esquema si decide rechazar una solicitud insegura. Si decide rechazarla, el mensaje de respuesta tendrá el valor booleano refusal en «true» para indicarlo. 
  • Es posible que el modelo no siga el esquema si la generación alcanza max_tokens u otra condición de detención antes de finalizar. 
  • Los outputs estructurados no evitan todos los errores del modelo. Por ejemplo, el modelo aún puede cometer errores en los valores del objeto JSON (por ejemplo, equivocarse en un paso en una ecuación matemática). Si los desarrolladores encuentran errores, recomendamos proporcionar ejemplos en las instrucciones del sistema o dividir las tareas en subtareas más sencillas.
  • Los outputs estructurados no son compatibles con las solicitudes de funciones paralelas. Cuando se genera una solicitud de función paralela, es posible que no coincida con los esquemas proporcionados. Programa parallel_tool_calls: false para deshabilitar la solicitud de funciones paralelas.
  • Los esquemas JSON proporcionados con outputs estructurados no son admisibles para la no retención de datos(se abre en una ventana nueva) (ZDR).

Disponibilidad

Los outputs estructurados ya están disponibles para el público general en la API. 

Los outputs estructurados con solicitud de funciones están disponibles en todos los modelos que admiten solicitudes de funciones en la API. Esto incluye nuestros modelos más nuevos (gpt-4o y gpt-4o-mini) y todos los modelos posteriores a gpt-4-0613 y gpt -3.5-turbo-0613(ambos incluidos), así como cualquier modelo optimizado que admita solicitudes de funciones. Esta función está disponible en la API Chat Completions, la API Assistants y la API Batch. Los outputs estructurados con solicitud de funciones también son compatibles con los inputs de visión.

Los outputs estructurados con formatos de respuesta están disponibles en gpt-4o-mini, gpt-4o-2024-08-06 y cualquier optimización basada en estos modelos. Esta función está disponible en la API Chat Completions, la API Assistants y la API Batch. Los outputs estructurados con formatos de respuesta también son compatibles con los inputs de visión. 

Al cambiar al nuevo gpt-4o-2024-08-06, los desarrolladores ahorran un 50 % en datos de entrada (2,50 $/millón de tokens de entrada) y un 33 % en outputs (10,00 $/millón de tokens de salida) en comparación con gpt-4o-2024-05-13.

Para comenzar a utilizar los outputs estructurados, consulta nuestra documentación(se abre en una ventana nueva)

Agradecimientos

Los outputs estructurados están inspirados en el excelente trabajo de la comunidad de código abierto: a saber, las bibliotecas de outlines(se abre en una ventana nueva), jsonformer(se abre en una ventana nueva), instructor(se abre en una ventana nueva), guidance(se abre en una ventana nueva) y lark(se abre en una ventana nueva).

Contribuidores clave

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

Agradecimientos

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 y David Weedon