Rezultate previzionate: răspunsuri mai rapide
Pe această pagină
Lecție actualizată la 3 noiembrie 2026 pe baza ghidului Predicted Outputs și a paginii de deprecieri OpenAI: această funcționalitate există doar în Chat Completions (parametrul
predictionnu este acceptat de API-ul Responses, așa că versiunea anterioară a acestei lecții ar fi eșuat) și doar cu modelele GPT-4o, GPT-4o mini, GPT-4.1 și GPT-4.1 mini, pe care OpenAI le va retrage la 14 ianuarie 2027 (GPT-4.1 nano a fost retras la 23 octombrie). Ghidul nu listează modele mai noi compatibile: nu construiți produse noi pe această funcționalitate fără un plan de ieșire. Surse: Predicted Outputs · Deprecations.
Accelerați răspunsurile când structura este deja cunoscută
Rezultatele previzionate (Predicted Outputs) abordează un scenariu de producție foarte frecvent: solicitați modelului să modifice conținut existent și știți dinainte că majoritatea rezultatului va fi identică cu intrarea. Fără previziune, modelul regenerează fiecare token de la zero, inclusiv liniile pe care nimeni nu i-a cerut să le atingă. Cu previziune, furnizați textul așteptat; modelul validează ce corespunde și generează efectiv doar părțile care diferă. Latența scade în consecință.
Această schimbare modifică în special profilul sarcinilor de editare. Un asistent care rescrie un fișier de două sute de linii pentru a schimba semnătura unei funcții nu mai plătește pentru generarea întregului fișier, ci doar pentru liniile atinse: cea mai mare parte a muncii se reduce la o comparație. Cazurile relevante sunt toate similare: editarea codului, unde trimiteți fișierul complet pentru o modificare țintită; rescrierea parțială, unde doar un singur paragraf dintr-un document lung trebuie reformulat; completarea șabloanelor, unde doar câmpurile variabile se schimbă; și actualizările de date structurate, unde două sau trei valori dintr-un JSON evoluează în timp ce restul structurii rămâne neschimbat. În fiecare dintre aceste cazuri, răspunsul așteptat există deja, cu doar diferențe minore.
Un exemplu de editare a codului
Apelul este construit ca un apel standard Chat Completions, augmentat cu un parametru prediction care conține conținutul pe care îl anticipați.
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)
"""
# Previzionăm că majoritatea codului rămâne identic
instruction = (
"Modificați funcția calculate_price pentru a adăuga un parametru discount "
"cu o valoare implicită de 0. Aplicați discount-ul înainte de TVA. "
"Răspundeți doar cu cod."
)
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, # Previziunea
},
)
print(completion.choices[0].message.content)
# Modelul regenerează doar liniile modificate — latență redusă
Funcția format_invoice nu este afectată de cerere: aceasta va fi validată așa cum este, fără cost de generare. Doar liniile din calculate_price care găzduiesc noul parametru vor fi produse efectiv.
Mecanismul de validare
Înțelegerea a ceea ce se întâmplă sub capotă evită două neînțelegeri comune. Modelul compară propria sa generare, token cu token, cu previziunea pe care ați furnizat-o; atâta timp cât cele două coincid, tokenii sunt validați instantaneu, ocolind calculul complet de generare. De îndată ce diverg, generarea normală preia controlul. Rezultatul final rămâne astfel corect: previziunea accelerează lucrurile, nu forțează nimic. Dacă previziunea dumneavoastră este greșită, obțineți totuși răspunsul corect, pur și simplu fără câștigul de viteză.
A doua neînțelegere concernează prețul. Tokenii de previziune respinși sunt facturați, ceea ce face operațiunea contraproductivă atunci când răspunsul așteptat nu are nimic de-a face cu previziunea. Prin urmare, măsurați rata de acceptare înainte de a generaliza acest model.
completion = client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "user", "content": "Adăugați un parametru discount funcției calculate_price."},
{"role": "user", "content": code_original},
],
prediction={
"type": "content",
"content": code_original,
},
)
usage = completion.usage
print(f"Tokeni de ieșire: {usage.completion_tokens}")
print(f"Tokeni acceptați (previziune): "
f"{usage.completion_tokens_details.accepted_prediction_tokens}")
print(f"Tokeni respinși (previziune): "
f"{usage.completion_tokens_details.rejected_prediction_tokens}")
# Cu cât este mai mare raportul acceptați/total, cu atât câștigul este mai mare
Decizia automată
Deoarece câștigul depinde în întregime de tipul cererii, decizia de a activa sau nu previziunea ar trebui codificată, nu lăsată la latitudinea fiecărui dezvoltator. Euristica de mai jos refuză previziunea pentru texte prea scurte, unde overhead-ul trimiterii acesteia anulează beneficiul, și o rezervă pentru instrucțiuni care exprimă o modificare.
def should_use_prediction(original_text: str, instruction: str) -> bool:
"""Euristică pentru a decide dacă Predicted Outputs merită."""
# Textul trebuie să fie suficient de lung
if len(original_text) < 200:
return False
# Instrucțiunea trebuie să fie o modificare țintită
edit_words = ["modify", "change", "replace", "add", "fix"]
is_edit = any(word in instruction.lower() for word in edit_words)
return is_edit
Același raționament se aplică datelor structurate, unde randamentul este chiar mai bun: un JSON de configurație își păstrează cheile, indentarea și ordinea, iar doar valorile se modifică.
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ți următorul JSON: schimbați numărul de angajați "
"la 58 și adăugați departamentul Data Science. Răspundeți doar cu JSON."
)},
{"role": "user", "content": json_original},
],
prediction={
"type": "content",
"content": json_original,
},
)
Trei avertismente înainte de implementare. Streaming-ul este compatibil, iar acolo câștigul de latență este chiar mai vizibil. Câțiva parametri, totuși, nu sunt compatibili: n mai mare decât 1, logprobs, presence_penalty sau frequency_penalty pozitive, audio, modalități altele decât textul, max_completion_tokens și instrumente (apelarea de funcții). În final, funcționalitatea este legată de modelele aflate la sfârșitul ciclului de viață: GPT-4o, GPT-4o mini, GPT-4.1 și GPT-4.1 mini se opresc la 14 ianuarie 2027, iar niciun model mai nou nu este anunțat ca fiind compatibil. Pentru editarea rapidă pe modelele actuale, calea durabilă este să cereți modelului un diff sau un patch, mai degrabă decât întregul fișier.
Puncte cheie
- Rezultatele previzionate (Predicted Outputs) accelerează răspunsurile când cunoașteți structura așteptată — doar în Chat Completions
- Ideale pentru editarea codului, actualizări JSON, rescriere parțială
- Verificați
accepted_prediction_tokenspentru a măsura câștigul real - Tokenii de previziune respinși sunt facturați: nu previzionați la întâmplare
- Nu le utilizați pentru generări complet noi
- Modelele compatibile (GPT-4o, GPT-4.1 și versiunile lor mini) sunt retrase la 14 ianuarie 2027: planificați o alternativă, cum ar fi generarea de diff-uri