Kimenetek előrejelzése: gyorsabb válaszok
Ezen az oldalon
Lecke frissítve: 2026. november 3. a Predicted Outputs útmutató és az OpenAI elavulási oldala alapján: ez a funkció kizárólag a Chat Completions végponton érhető el (a
predictionparamétert a Responses API nem fogadja el, így a lecke előző verziója hibát okozott volna), és csak a GPT-4o, GPT-4o mini, GPT-4.1, valamint GPT-4.1 mini modellekkel működik, amelyeket az OpenAI 2027. január 14-én von vissza (a GPT-4.1 nano már október 23-án megszűnt). Az útmutató nem sorol fel újabb kompatibilis modelleket: ne építs új termékeket erre a funkcióra kilépési stratégia nélkül. Források: Predicted Outputs · Deprecations.
Gyorsítsd fel a válaszokat, ha már ismered a szerkezetet
A kimenetek előrejelzése (Predicted Outputs) egy nagyon gyakori éles környezeti forgatókönyvet kezel: arra kéred a modellt, hogy módosítson egy meglévő tartalmat, és előre tudod, hogy az eredmény nagy része azonos lesz a bemenettel. Előrejelzés nélkül a modell minden tokent nulláról generál újra, beleértve azokat a sorokat is, amelyeket senki nem kért tőle módosítani. Előrejelzés esetén megadod a várt szöveget; a modell ellenőrzi az egyező részeket, és csak a ténylegesen eltérő részeket generálja le. A késleltetés ennek megfelelően csökken.
Ez a váltás különösen megváltoztatja a szerkesztési feladatok profilját. Egy asszisztens, amely átír egy kétszáz soros fájlt egy függvény aláírásának megváltoztatásához, már nem fizet az egész fájl generálásáért, csak az érintett sorokért: a munka nagy része összehasonlítássá redukálódik. Az releváns esetek mind hasonlóak: kódszerkesztés, ahol a teljes fájlt elküldöd egy célzott módosításhoz; részleges átírás, ahol egy hosszú dokumentum csak egyetlen bekezdését kell átfogalmazni; sablonkitöltés, ahol csak a változó mezők módosulnak; és strukturált adatok frissítése, ahol egy JSON-ban két-három érték változik, míg a szerkezet többi része érintetlen marad. Mindezekben az esetekben a várt válasz már létezik, csak kisebb eltérésekkel.
Egy kódszerkesztési példa
A hívás egy szabványos Chat Completions hívásként épül fel, kiegészítve egy prediction paraméterrel, amely tartalmazza az előre várt tartalmat.
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)
"""
# Azt jósoljuk, hogy a kód nagy része változatlan marad
instruction = (
"Módosítsd a calculate_price függvényt, hogy hozzáadj egy discount paramétert "
"0 alapértelmezett értékkel. Alkalmazd a kedvezményt az ÁFA előtt. "
"Kizárólag kóddal válaszolj."
)
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, # Az előrejelzés
},
)
print(completion.choices[0].message.content)
# A modell csak a módosított sorokat generálja újra — csökkentett késleltetés
A format_invoice függvényt nem érinti a kérés: ezt változatlanul ellenőrzi a rendszer, generálási költség nélkül. Csak a calculate_price új paramétert befogadó sorait állítja elő ténylegesen a modell.
Az ellenőrzési mechanizmus
A motorháztető alatt zajló folyamatok megértése elkerül két gyakori félreértést. A modell tokenről tokenre összehasonlítja a saját generálását az általad megadott előrejelzéssel; amíg a kettő egyezik, a tokeneket azonnal ellenőrzöttnek tekinti, megkerülve a teljes generálási számítást. Amint eltérés lép fel, a normál generálás veszi át az irányítást. A végeredmény tehát helyes marad: az előrejelzés felgyorsítja a dolgokat, nem pedig kényszerít ki bármit. Ha az előrejelzésed hibás, akkor is megkapod a helyes választ, egyszerűen a gyorsulás előnye nélkül.
A második félreértés az árazást érinti. Az elutasított előrejelzési tokeneket számlázzák, ami ellenproductívvá teszi a műveletet, amikor a várt válasznak semmi köze az előrejelzéshez. Ezért általánosítás előtt mérd meg az elfogadási arányt.
completion = client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "user", "content": "Adj egy discount paramétert a calculate_price függvényhez."},
{"role": "user", "content": code_original},
],
prediction={
"type": "content",
"content": code_original,
},
)
usage = completion.usage
print(f"Kimeneti tokenek: {usage.completion_tokens}")
print(f"Elfogadott tokenek (előrejelzés): "
f"{usage.completion_tokens_details.accepted_prediction_tokens}")
print(f"Elutasított tokenek (előrejelzés): "
f"{usage.completion_tokens_details.rejected_prediction_tokens}")
# Minél nagyobb az elfogadott/összes arány, annál nagyobb a nyereség
Automatikus döntéshozatal
Mivel a nyereség kizárólag a kérés típusától függ, az előrejelzés bekapcsolásáról szóló döntést kodifikálni kell, nem pedig minden fejlesztőre bízni. Az alábbi heurisztika elutasítja az előrejelzést a túl rövid szövegeknél, ahol a küldés overheadje megszünteti az előnyt, és olyan utasításokra tartja fenn, amelyek módosítást fejeznek ki.
def should_use_prediction(original_text: str, instruction: str) -> bool:
"""Heurisztika annak eldöntésére, hogy megéri-e a Predicted Outputs használata."""
# A szövegnek elég hosszúnak kell lennie
if len(original_text) < 200:
return False
# Az utasításnak célzott módosításnak kell lennie
edit_words = ["modify", "change", "replace", "add", "fix"]
is_edit = any(word in instruction.lower() for word in edit_words)
return is_edit
Ugyanez az érvelés vonatkozik a strukturált adatokra is, ahol a hozam még jobb: egy konfigurációs JSON megtartja a kulcsait, behúzásait és sorrendjét, és csak az értékek változnak.
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": (
"Frissítsd a következő JSON-t: változtasd meg az alkalmazottak számát "
"58-ra, és add hozzá az Adattudomány (Data Science) osztályt. Kizárólag JSON-nal válaszolj."
)},
{"role": "user", "content": json_original},
],
prediction={
"type": "content",
"content": json_original,
},
)
Három figyelmeztetés a bevezetés előtt. A streaming kompatibilis, és éppen itt a leginkább észrevehető a késleltetés csökkenése. Several paraméter azonban nem kompatibilis: az 1-nél nagyobb n, a logprobs, a pozitív presence_penalty vagy frequency_penalty, a hangalapú funkciók, a szövegen kívüli modalitások, a max_completion_tokens, valamint az eszközök (függvényhívás). Végül, a funkció a жизciklusuk végéhez közeledő modellekhez kötött: a GPT-4o, GPT-4o mini, GPT-4.1 és GPT-4.1 mini modellek támogatása 2027. január 14-én megszűnik, és nincs bejelentve újabb kompatibilis modell. A gyors szerkesztéshez a jelenlegi modelleken a fenntartható út az, ha a modelltől diffet vagy patch-et kérsz a teljes fájl helyett.
Főbb megállapítások
- A kimenetek előrejelzése (Predicted Outputs) felgyorsítja a válaszokat, ha ismered a várt szerkezetet – kizárólag Chat Completions esetén
- Ideális kódszerkesztéshez, JSON-frissítéshez, részleges átíráshoz
- Ellenőrizd az
accepted_prediction_tokensértéket a valós nyereség méréséhez - Az elutasított előrejelzési tokeneket számlázzák: ne jósolj véletlenszerűen
- Ne használd teljesen új generálásokhoz
- A kompatibilis modellek (GPT-4o, GPT-4.1 és mini változataik) támogatása 2027. január 14-én megszűnik: tervezz alternatívát, például diff generálást