Ir al contenido principal
Español— Elegir un idioma
Menú

Salidas predichas: respuestas más rápidas

Lección 4 de 20 Actualizado el 3 de noviembre de 2026 Avanzado
En esta página
  1. Acelera las respuestas cuando ya conoces la estructura
  2. El mecanismo de validación
  3. Decidir automáticamente
  4. Puntos clave

Lección actualizada el 3 de noviembre de 2026 basándose en la guía de Salidas predichas y la página de obsolescencia de OpenAI: esta función solo existe en Chat Completions (el parámetro prediction no es aceptado por la API de Responses, por lo que la versión anterior de esta lección habría fallado) y únicamente con los modelos GPT-4o, GPT-4o mini, GPT-4.1 y GPT-4.1 mini, que OpenAI retirará el 14 de enero de 2027 (GPT-4.1 nano fue retirado el 23 de octubre). La guía no enumera modelos nuevos compatibles: no construyas nuevos productos sobre esta función sin un plan de salida. Fuentes: Salidas predichas · Obsolescencias.

Acelera las respuestas cuando ya conoces la estructura

Las Salidas predichas abordan un escenario de producción muy común: pides al modelo que modifique contenido existente y sabes de antemano que la mayor parte del resultado será idéntica a la entrada. Sin predicción, el modelo regenera cada token desde cero, incluidas las líneas que nadie le ha pedido tocar. Con la predicción, proporcionas el texto esperado; el modelo valida lo que coincide y solo genera genuinamente las partes que difieren. La latencia se reduce en consecuencia.

Este cambio altera especialmente el perfil de las tareas de edición. Un asistente que reescribe un archivo de doscientas líneas para cambiar la firma de una función ya no paga por generar todo el archivo, sino solo por las líneas tocadas: la mayor parte del trabajo se reduce a una comparación. Los casos relevantes son todos similares: edición de código, donde envías el archivo completo para un cambio concreto; reescritura parcial, donde solo necesita reformularse un único párrafo de un documento largo; completado de plantillas, donde solo cambian los campos variables; y actualizaciones de datos estructurados, donde dos o tres valores en un JSON evolucionan mientras el resto de la estructura permanece. En cada uno de estos casos, la respuesta esperada ya existe con solo pequeñas diferencias.

Un ejemplo de edición de código

La llamada se construye como una llamada estándar de Chat Completions, aumentada con un parámetro prediction que contiene el contenido que anticipas.

import openai

client = openai.OpenAI()

code_original = """
def calculate_price(quantity, unit_price, vat=0.20):
    subtotal = quantity * unit_price
    total = subtotal * (1 + vat)
    return total

def format_invoice(client, items):
    lines = []
    for item in items:
        price = calculate_price(item["qty"], item["price"])
        lines.append(f"{item['name']}: {price:.2f}€")
    return "\n".join(lines)
"""

# Predicimos que la mayor parte del código permanece idéntico
instruction = (
    "Modifica la función calculate_price para añadir un parámetro discount "
    "con un valor por defecto de 0. Aplica el descuento antes del IVA. "
    "Responde solo con código."
)

completion = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "user", "content": instruction},
        {"role": "user", "content": code_original},
    ],
    prediction={
        "type": "content",
        "content": code_original,  # La predicción
    },
)

print(completion.choices[0].message.content)
# El modelo regenera solo las líneas modificadas — latencia reducida

La función format_invoice no se ve afectada por la solicitud: se validará tal cual, sin coste de generación. Solo las líneas de calculate_price que acomoden el nuevo parámetro se producirán genuinamente.

El mecanismo de validación

Entender qué ocurre bajo el capó evita dos malentendidos comunes. El modelo compara su propia generación, token a token, con la predicción que has proporcionado; mientras las dos coincidan, los tokens se validan al instante, evitando el cálculo completo de generación. En cuanto divergen, la generación normal toma el relevo. El resultado final, por tanto, sigue siendo correcto: la predicción acelera las cosas, no fuerza nada. Si tu predicción es errónea, seguirás obteniendo la respuesta correcta, simplemente sin la ganancia de velocidad.

El segundo malentendido concerne al precio. Los tokens de predicción rechazados se facturan, lo que hace que la operación sea contraproducente cuando la respuesta esperada no tiene nada que ver con la predicción. Por ello, mide la tasa de aceptación antes de generalizar el patrón.

completion = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "user", "content": "Añade un parámetro discount a la función calculate_price."},
        {"role": "user", "content": code_original},
    ],
    prediction={
        "type": "content",
        "content": code_original,
    },
)

usage = completion.usage
print(f"Tokens de salida: {usage.completion_tokens}")
print(f"Tokens aceptados (predicción): "
      f"{usage.completion_tokens_details.accepted_prediction_tokens}")
print(f"Tokens rechazados (predicción): "
      f"{usage.completion_tokens_details.rejected_prediction_tokens}")

# Cuanto mayor sea la ratio aceptados/total, mayor será la ganancia

Decidir automáticamente

Dado que la ganancia depende enteramente del tipo de solicitud, la decisión de activar o no la predicción debe codificarse en lugar de dejarse a cada desarrollador. La heurística siguiente rechaza la predicción en textos demasiado cortos, donde la sobrecarga de enviarla cancela el beneficio, y la reserva para instrucciones que expresan una modificación.

def should_use_prediction(original_text: str, instruction: str) -> bool:
    """Heurística para decidir si vale la pena usar Salidas predichas."""
    # El texto debe ser lo suficientemente largo
    if len(original_text) < 200:
        return False

    # La instrucción debe ser una modificación concreta
    edit_words = ["modify", "change", "replace", "add", "fix"]
    is_edit = any(word in instruction.lower() for word in edit_words)

    return is_edit

El mismo razonamiento se aplica a los datos estructurados, donde el rendimiento es aún mejor: un JSON de configuración mantiene sus claves, sangría y orden, y solo se mueven los valores.

import json

original_data = {
    "company": "Corsen AI",
    "employees": 42,
    "departments": ["Engineering", "Sales", "Marketing"],
    "address": {
        "street": "123 Avenue de la République",
        "city": "Paris",
        "zip_code": "75011",
    },
}

json_original = json.dumps(original_data, indent=2, ensure_ascii=False)

completion = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "user", "content": (
            "Actualiza el siguiente JSON: cambia el número de empleados "
            "a 58 y añade el departamento Data Science. Responde solo con JSON."
        )},
        {"role": "user", "content": json_original},
    ],
    prediction={
        "type": "content",
        "content": json_original,
    },
)

Tres advertencias antes del despliegue. El streaming es compatible, y es precisamente ahí donde la ganancia de latencia es más notable. Sin embargo, varios parámetros no lo son: n mayor que 1, logprobs, presence_penalty o frequency_penalty positivos, audio, modalidades distintas al texto, max_completion_tokens y herramientas (llamada a funciones). Finalmente, la función está ligada a modelos con fecha de fin de vida: GPT-4o, GPT-4o mini, GPT-4.1 y GPT-4.1 mini dejan de funcionar el 14 de enero de 2027, y no se ha anunciado ningún modelo nuevo compatible. Para ediciones rápidas en los modelos actuales, la vía sostenible es pedir al modelo un diff o un parche en lugar del archivo entero.

Puntos clave

  • Las Salidas predichas aceleran las respuestas cuando conoces la estructura esperada —solo en Chat Completions
  • Ideales para edición de código, actualizaciones de JSON y reescritura parcial
  • Comprueba accepted_prediction_tokens para medir la ganancia real
  • Los tokens de predicción rechazados se facturan: no predigas al azar
  • No las uses para generaciones totalmente nuevas
  • Los modelos compatibles (GPT-4o, GPT-4.1 y sus versiones mini) se retiraron el 14 de enero de 2027: planifica una alternativa, como la generación de diffs