Saídas Previstas: Respostas Mais Rápidas
Nesta página
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
predictionnã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_tokenspara 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