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

Optimalizálás végponttól végpontig: a prompttól a hálózatig

2. lecke 20 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Az optimalizálás egy rendszer, nem egyetlen paraméter
  2. A prompt optimalizálása
  3. Az API-paraméterek optimalizálása
  4. A hálózat optimalizálása
  5. Az utófeldolgozás optimalizálása
  6. Főbb megállapítások

Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none gondolkodási erőfeszítés (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Az ezeket a paramétereket beállító hívásoknak ezért meg kell adniuk a reasoning={"effort": "none"} (Responses API) vagy reasoning_effort="none" (Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.

Az optimalizálás egy rendszer, nem egyetlen paraméter

Egy LLM-alkalmazás késleltetésének és költségeinek csökkentése nem csupán egy gyorsabb modell kiválasztásáról szól. Ez egy olyan optimalizálási láncolat, amely a prompttól a hálózati konfigurációig terjed, és a leggyengébb láncszem határozza meg a többi rész teljesítményét. Egy csapat, amely felére csökkenti a rendszerprompt méretét, de hagyja, hogy a szerver minden kérésnél új TLS-kapcsolatot nyisson, a hálózati többletterhelésben elveszíti azt, amit a tokeneken megtakarított.

Az számít, milyen sorrendben kezeled ezeket a szabályozókat. Kezdj a prompttal, mert ez hat a költségekre és a késleltetésre is anélkül, hogy infrastruktúrális változtatásokat igényelne. Ezt követi az API-paraméterek hangolása, majd a hálózati konfiguráció, és végül az, ahogy az alkalmazásod feldolgozza a választ. Ez a lecke ebben a sorrendben vezet végig az egyes szabályozókon.

A prompt optimalizálása

Minden bemeneti token időbe és pénzbe kerül, és a legtöbb éles környezeti prompt cipel magával felesleges terhet a prototípus-fázisból: egyesével hozzáadott utasításokat, amelyek mind újra fogalmazzák az előzőt. Az első reflexed az legyen, hogy tömören írod át a promptot, eltávolítva a megszólításokat és az ismétléseket anélkül, hogy érintenéd a modellnek átadott tényleges korlátokat.

# ❌ Bőbeszédű prompt
prompt_long = """
You are an expert financial analysis assistant. You must always
respond in a professional and structured manner. You must use
numerical data when possible. You must avoid unnecessary jargon.
You must be concise but complete.
Analyze the following quarterly report: ...
"""

# ✅ Optimalizált prompt (ugyanaz az eredmény, kevesebb token)
prompt_court = """Role: Senior financial analyst.
Constraints: Structured, numerical, concise.
Task: Analyze this quarterly report: ..."""

Mindkét verzió pontosan ugyanazt az öt korlátot közvetíti; a második ezt anélkül teszi meg, hogy tartalmazná az öt „You must“ (köteles vagy) kifejezést, amelyek semmit nem adnak a modell számára. Egy olyan szolgáltatásnál, amely naponta tízezer jelentést dolgoz fel, ez a harminc másodperces átírás naponta megtérül.

Válaszd ki a feladathoz illő modellt

A második szabályozó azon a tényen alapul, hogy nem minden híváshoz ugyanarra a modellre van szükség. Ha egy mezőkiemelési feladatot egy magas szintű gondolkodást igénylő modellre irányítasz, akkor olyan kapacitásért fizetsz, amelyet a feladat nem használ ki, és tovább vársz egy azonos eredményre.

Feladat típusaAjánlott modellOk
Osztályozás / kinyerésgpt-5.6-lunaGyors, gazdaságos
Komplex gondolkodásgpt-5.6-terra közepes gondolkodássalLegjobb minőség/költség arány
Kritikus feladatokgpt-5.6-sol magas gondolkodássalLegmagasabb minőség, lassabb
Nagy volumengpt-5.6-luna Batch API-n keresztül-50% költség

A gyakorlatban kódold ezt a választást egy útválasztó függvénybe, ahelyett, hogy a fejlesztők belátására bíznád; ellenkező esetben mindig az alapértelmezett modell győzedelmeskedik:

import openai

client = openai.OpenAI()

def route_model(task: str, complexity: str) -> str:
    """Kiválasztja az optimális modellt a feladat alapján."""
    if complexity == "low":
        return "gpt-5.6-luna"
    elif task in ("reasoning", "math", "code"):
        return "gpt-5.6-terra"
    elif complexity == "critical":
        return "gpt-5.6-sol"
    return "gpt-5.6-terra"

def optimized_call(prompt: str, task: str, complexity: str) -> str:
    model = route_model(task, complexity)
    response = client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

Az API-paraméterek optimalizálása

Egy túl hosszú válasz elpazarolja a generálási időt, amit úgysem olvas el senki. Mindig add meg a max_output_tokens paramétert: ez egy kemény korlát, amely védi mind a számládat, mind a felületedet, megakadályozva, hogy egy rosszul megfogalmazott prompt kétezer szavas kitérőbe csússzon.

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # a temperature paraméterhez none erőfeszítés szükséges
    input="Summarize this text in one sentence.",
    max_output_tokens=100,  # Kemény korlát
    temperature=0.0,         # Determinisztikus = gyorsabb
)

A mintavételezési paraméterek ugyanabba az irányba hatnak. A temperature=0 beállítása determinisztikussá és kissé gyorsabbá teszi a válaszokat, ami pontosan azt jelenti, amit a kinyerési vagy osztályozási feladatoknál szeretnél, ahol a kreativitás a variancia forrása, nem pedig előny. A top_p 0,1-re csökkentése leszűkíti a keresési teret és felgyorsítja a generálást; ezt a beállítást csak olyan feladatoknál tartsd fenn, ahol csak egyetlen megfogalmazás elfogadható, és hagyd meg az alapértelmezett értékeket ott, ahol a válasz gazdagsága a termék része.

A hálózat optimalizálása

A csomagok utazási költségei minden hívásnál összeadódnak, mégis láthatatlanok maradnak az alkalmazásmetrikáidban. Az OpenAI API-t elsősorban az USA keleti partján hostolják: ha az alkalmazásszerveredet ugyanabba a régióba helyezed, mint a végpontot, az 50–150 milliszekundumos nyereséget jelenthet a hálózati késleltetésben. Egy beszélgető alkalmazásnál ez az első token megjelenéséig eltelt idő (TTFT) jelentős hányada.

A második nyereség a kapcsolatok újrafelhasználásából származik. Pool nélkül minden kérés lejátsza a TLS kézfogást, ami több oda-vissza kört ad hozzá, mielőtt bármilyen hasznos adat áramlana. Ezt úgy oldod meg, hogy egyszer és mindenkorra konfigurálsz egy HTTP-klienst:

import httpx

# Kliens tartós kapcsolatkészlettel
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Az utófeldolgozás optimalizálása

Az utolsó láncszem gyakran az, amit elfelejtenek: egy olyan alkalmazás, amely fogad egy streamelt választ, de a végéig vár, mielőtt megjelenítené azt, semmissé teszi a streaming összes előnyét. A választ menet közben dolgozd fel, ne a teljes fogadás után.

async def progressive_processing(prompt: str):
    """Feldolgoz minden darabot, amint megérkezik."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    buffer = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Feldolgozás teljes mondatonként
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

A teljes mondatokra való bontás tudatos kompromisszum: minden token kibocsátása rángatózó megjelenítést eredményez, míg a teljes bekezdésre való várakozás újra létrehozza a várakozás érzését. A mondat az a egység, amelyet az olvasók természetesen fogyasztanak. Használd újra ezt a mintát, amikor a felületednek megjelenítenie, felolvasnia vagy streamelnie kell a modell által előállított tartalmat.

Főbb megállapítások

  • Először a promptot optimalizáld: kevesebb token = kisebb késleltetés és költség
  • Irányítsd a megfelelő modellre a feladat összetettsége alapján
  • Korlátozd a max_output_tokens értékét, és használd a temperature=0 beállítást, amikor lehetséges
  • Használd újra a HTTP-kapcsolatokat, és dolgozd fel a válaszokat streaming módon