Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Kimenetek előrejelzése: gyorsabb válaszok

4. lecke 20 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Gyorsítsd fel a válaszokat, ha már ismered a szerkezetet
  2. Az ellenőrzési mechanizmus
  3. Automatikus döntéshozatal
  4. Főbb megállapítások

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 prediction paramé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