Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Saídas Previstas: Respostas Mais Rápidas

Aula 4 de 20 Atualizada a 3 de novembro de 2026 Avancado
Nesta página
  1. Acelere as respostas quando já conhece a estrutura
  2. O mecanismo de validação
  3. Decidir automaticamente
  4. Pontos-chave

Lição atualizada a 3 de novembro de 2026 com base no guia Predicted Outputs e na página de descontinuações da OpenAI: esta funcionalidade existe apenas nas Chat Completions (o parâmetro prediction não é aceite pela API de Responses, pelo que a versão anterior desta lição falharia) e apenas com os modelos GPT-4o, GPT-4o mini, GPT-4.1 e GPT-4.1 mini, que a OpenAI irá descontinuar a 14 de janeiro de 2027 (o GPT-4.1 nano foi descontinuado a 23 de outubro). O guia não lista modelos mais recentes compatíveis: não construa novos produtos sobre esta funcionalidade sem um plano de saída. Fontes: Predicted Outputs · Deprecations.

Acelere as respostas quando já conhece a estrutura

As Saídas Previstas (Predicted Outputs) abordam um cenário de produção muito comum: pede ao modelo para modificar conteúdo existente e sabe antecipadamente que a maior parte do resultado será idêntica à entrada. Sem previsão, o modelo regenera todos os tokens do zero, incluindo linhas que ninguém lhe pediu para tocar. Com a previsão, fornece o texto esperado; o modelo valida o que coincide e gera genuinamente apenas as partes que diferem. A latência diminui proporcionalmente.

Esta mudança altera especialmente o perfil das tarefas de edição. Um assistente que reescreve um ficheiro de duzentas linhas para alterar a assinatura de uma função já não paga pela geração do ficheiro inteiro, mas apenas pelas linhas tocadas: a maior parte do trabalho reduz-se a uma comparação. Os casos relevantes são todos semelhantes: edição de código, onde envia o ficheiro completo para uma alteração direcionada; reescrita parcial, onde apenas um parágrafo de um longo documento precisa de ser reformulado; preenchimento de modelos, onde apenas os campos variáveis mudam; e atualizações de dados estruturados, onde dois ou três valores num JSON evoluem enquanto o resto da estrutura permanece. Em cada um destes casos, a resposta esperada já existe, com apenas pequenas diferenças.

Um exemplo de edição de código

A chamada é construída como uma chamada standard de Chat Completions, aumentada com um parâmetro prediction que contém o conteúdo que antecipa.

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)
"""

# Prevemos que a maior parte do código permaneça idêntica
instruction = (
    "Modifique a função calculate_price para adicionar um parâmetro de desconto "
    "com um valor padrão de 0. Aplique o desconto antes do IVA. "
    "Responda apenas com 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,  # A previsão
    },
)

print(completion.choices[0].message.content)
# O modelo regenera apenas as linhas modificadas — latência reduzida

A função format_invoice não é afetada pelo pedido: será validada tal como está, sem custo de geração. Apenas as linhas de calculate_price que acomodam o novo parâmetro serão genuinamente produzidas.

O mecanismo de validação

Compreender o que acontece nos bastidores evita dois equívocos comuns. O modelo compara a sua própria geração, token por token, com a previsão que forneceu; enquanto os dois coincidirem, os tokens são validados instantaneamente, contornando o cálculo completo de geração. Assim que divergirem, a geração normal assume o controlo. O resultado final permanece, portanto, correto: a previsão acelera as coisas, não impõe nada. Se a sua previsão estiver errada, obtém ainda assim a resposta certa, simplesmente sem o ganho de velocidade.

O segundo equívoco diz respeito ao preço. Os tokens de previsão rejeitados são faturados, o que torna a operação contraproducente quando a resposta esperada nada tem a ver com a previsão. Portanto, meça a taxa de aceitação antes de generalizar o padrão.

completion = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "user", "content": "Adicione um parâmetro de desconto à função calculate_price."},
        {"role": "user", "content": code_original},
    ],
    prediction={
        "type": "content",
        "content": code_original,
    },
)

usage = completion.usage
print(f"Tokens de saída: {usage.completion_tokens}")
print(f"Tokens aceites (previsão): "
      f"{usage.completion_tokens_details.accepted_prediction_tokens}")
print(f"Tokens rejeitados (previsão): "
      f"{usage.completion_tokens_details.rejected_prediction_tokens}")

# Quanto maior a relação aceites/total, maior o ganho

Decidir automaticamente

Uma vez que o ganho depende inteiramente do tipo de pedido, a decisão de ativar ou não a previsão deve ser codificada e não deixada ao critério de cada programador. A heurística abaixo recusa a previsão em textos demasiado curtos, onde a sobrecarga de envio anula o benefício, e reserva-a para instruções que expressem uma modificação.

def should_use_prediction(original_text: str, instruction: str) -> bool:
    """Heurística para decidir se as Saídas Previstas valem a pena."""
    # O texto deve ser suficientemente longo
    if len(original_text) < 200:
        return False

    # A instrução deve ser uma modificação direcionada
    edit_words = ["modify", "change", "replace", "add", "fix"]
    is_edit = any(word in instruction.lower() for word in edit_words)

    return is_edit

O mesmo raciocínio aplica-se a dados estruturados, onde o rendimento é ainda melhor: um JSON de configuração mantém as suas chaves, indentação e ordem, e apenas os valores se movem.

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": (
            "Atualize o seguinte JSON: altere o número de funcionários "
            "para 58 e adicione o departamento de Data Science. Responda apenas com JSON."
        )},
        {"role": "user", "content": json_original},
    ],
    prediction={
        "type": "content",
        "content": json_original,
    },
)

Três ressalvas antes da implementação. O streaming é compatível, e é mesmo aí que o ganho de latência é mais notório. Vários parâmetros, no entanto, não o são: n superior a 1, logprobs, presence_penalty ou frequency_penalty positivos, áudio, modalidades diferentes de texto, max_completion_tokens e ferramentas (chamada de funções). Por fim, a funcionalidade está ligada a modelos em fim de vida: GPT-4o, GPT-4o mini, GPT-4.1 e GPT-4.1 mini deixam de funcionar a 14 de janeiro de 2027, e nenhum modelo mais recente foi anunciado como compatível. Para edições rápidas nos modelos atuais, o caminho sustentável é pedir ao modelo um diff ou um patch em vez do ficheiro inteiro.

Pontos-chave

  • As Saídas Previstas aceleram as respostas quando conhece a estrutura esperada — apenas em Chat Completions
  • Ideais para edição de código, atualizações de JSON e reescrita parcial
  • Verifique accepted_prediction_tokens para medir o ganho real
  • Os tokens de previsão rejeitados são faturados: não faça previsões ao acaso
  • Não as utilize para gerações inteiramente novas
  • Modelos compatíveis (GPT-4o, GPT-4.1 e as suas versões mini) descontinuados a 14 de janeiro de 2027: planeie uma alternativa, como a geração de diffs