Lähe põhisisu juurde
Eesti— Vali keel
Menüü

End-to-end optimiseerimine: vihjest võrguni

Õppetund 2 / 20 Värskendatud 3. november 2026 Edasijõudnutele
Sellel lehel
  1. Optimeerimine on süsteem, mitte üksikparameeter
  2. Optimeeri vihjet
  3. Optimeeri API parameetreid
  4. Optimeeri võrku
  5. Optimeeri järeltöötlust
  6. Peamised punktid

Tund uuendatud 3. novembril 2026 OpenAI dokumentatsiooni põhjal: parameetreid temperature ja top_p aktsepteeritakse ainult siis, kui arutluse jõupingutus (reasoning effort) on määratud väärtusega none, samas kui GPT-5.6 mudelid kasutavad vaikimisi arutlust (medium). Seetõttu peavad need parameetrid määravad päringud sisaldama seadet reasoning={"effort": "none"} (Responses API) või reasoning_effort="none" (Chat Completions). Allikad: GPT-6 kasutamine · GPT-5.6 Terra.

Optimeerimine on süsteem, mitte üksikparameeter

LLM-rakenduse latentsuse ja kulude vähendamine ei seisne ainult kiirema mudeli valikus. See on ahel optimeerimisi, mis ulatub vihjest võrguseadistusteni, ja nõrgim lüli määrab kogu süsteemi jõudluse. Meeskond, mis poolitab oma süsteemse vihje suuruse, kuid jätab serveri iga päringu jaoks uue TLS-ühenduse avama, kaotab võrgu üldkuludes täpselt selle, mida tokenites säästis.

Oluline on järjekord, milles neid hoobasid kasutad. Alusta vihjest, sest see mõjutab nii kulusid kui ka latentsust ilma taristu muutmist nõudmata. Järgmisena tulevad API parameetrid, seejärel võrguseadistused ja lõpuks viis, kuidas sinu rakendus vastust tarbib. See tund viib sind läbi iga hoova just selles järjekorras.

Optimeeri vihjet

Iga sisendtoken maksab aega ja raha ning enamik tootmises olevaid vihjeid kannab endas prototüüpimise faasi jääke: ükshaaval lisatud juhiseid, millest igaüks sõnastab eelmise ümber. Sinu esimene refleks peaks olema vihje tihe ümberkirjutamine, eemaldades pöördumisvormid ja kordused, puutumata seejuures mudelile edastatavatesse tegelikesse piirangutesse.

# ❌ Sõnaohke vihje
prompt_long = """
Sa oled ekspertne finantsanalüüsi assistent. Sa pead alati
vastama professionaalsel ja struktureeritud viisil. Sa pead
kasutama numbrilisi andmeid, kui see on võimalik. Sa pead
vältima tarbetut žargooni. Sa pead olema kokkuvõtlik, kuid täielik.
Analüüsi järgmist kvartaliaruannet: ...
"""

# ✅ Optimeeritud vihje (sama tulemus, vähem tokeneid)
prompt_court = """Roll: Vanem finantsanalüütik.
Piirangud: Struktureeritud, numbriline, kokkuvõtlik.
Ülesanne: Analüüsi seda kvartaliaruannet: ..."""

Mõlemad versioonid edastavad täpselt samad viis piirangut; teine teeb seda ilma viie „Sa pead“ fraasita, mis mudelile midagi ei lisa. Teenuses, mis töötleb päevas kümme tuhat aruannet, tasub see kolmekümne sekundi pikkune ümberkirjutus end iga päev ära.

Vali ülesandele sobiv mudel

Teine hoob tugineb tõsiasjale, et iga päring ei vaja sama mudelit. Suunates väljatõmbamise ülesande suure arutlusvõimega mudelile, maksad sa võimsuse eest, mida ülesanne ei kasuta, ja ootad identse tulemuse saamiseks kauem.

Ülesande tüüpSoovitatav mudelPõhjus
Klassifitseerimine / väljatõmbaminegpt-5.6-lunaKiire, ökonoomne
Kompleksne arutlusgpt-5.6-terra keskmise arutlusegaParim kvaliteedi ja hinna suhe
Kriitilised ülesandedgpt-5.6-sol suure arutlusegaKõrgeim kvaliteet, aeglasem
Suur mahtgpt-5.6-luna läbi Batch API-50% kulu

Praktikas kodeeri see valik marsruutimisfunktsiooni, selle asemel et jätta see arendajate äranägemisele; vastasel juhul võidab alati vaikimisi mudel:

import openai

client = openai.OpenAI()

def route_model(task: str, complexity: str) -> str:
    """Valib ülesande põhjal optimaalse mudeli."""
    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

Optimeeri API parameetreid

Liiga pikk vastus raiskab genereerimisaega, mida keegi ei loe. Määra alati max_output_tokens: see on kõva piirang, mis kaitseb nii sinu arvet kui ka kasutajaliidest, hoides ära olukorra, kus halvasti sõnastatud vihje kasvab kahe tuhande sõna pikkuseks ekskursiks.

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature nõuab effort none
    input="Võta see tekst kokku ühes lauses.",
    max_output_tokens=100,  # Kõva piirang
    temperature=0.0,         # Deterministlik = kiirem
)

Prooviparameetrid toimivad samas suunas. Seade temperature=0 teeb vastused deterministlikuks ja veidi kiiremaks, mis on täpselt see, mida soovid väljatõmbamise või klassifitseerimise ülesannete puhul, kus loovus on pigem varieeruvuse allikas kui vara. Väärtuse top_p vähendamine tasemele 0,1 kitsendab otsinguruumi ja kiirendab genereerimist; reserveeri see seade ülesannetele, kus lubatud on ainult üks sõnastus, ja jäta vaikimisi väärtused alles seal, kus vastuse rikkus on toote osa.

Optimeeri võrku

Pakettide edastamise kulud liituvad iga päringuga, kuigi need jäävad sinu rakenduse mõõdikutes nähtamatuks. OpenAI API on peamiselt majutatud USA idarannikul: sinu rakenduse serveri paigutamine sama piirkonda kui lõpp-punkt võib tuua võrgu latentsusesse potentsiaalse võidu 50–150 millisekundit. Vestlusrakenduse jaoks on see märkimisväärne osa esimese tokenini kuluva ajast (TTFT).

Teine võit tuleb ühenduse taaskasutamisest. Ilma ühenduste basseinita kordab iga päring TLS-i käepigistust, lisades enne kasulike andmete voogu mitu ringkäiku. HTTP-kliendi ühekordne konfigureerimine lahendab selle probleemi:

import httpx

# Püsiva ühenduste basseiniga klient
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Optimeeri järeltöötlust

Viimane lüli on sageli see, mille unustatakse: rakendus, mis saab voogvastuse, kuid ootab selle kuvamisega lõpuni, tühistab kõik voogedastuse eelised. Töötle vastust reaalajas, mitte pärast selle täielikku vastuvõtmist.

async def progressive_processing(prompt: str):
    """Töötleb iga tüki kohe, kui see saabub."""
    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
            # Töötle tervete lausetena
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

Tervete lausetena jagamine on teadlik kompromiss: iga tokeni edastamine tekitab võbeleva kuva, samas kui kogu lõigu ootamine taastab ootamise tunde. Lause on ühik, mida lugejad loomulikult tarbivad. Kasuta seda mustrit iga kord, kui sinu liides peab kuvama, ette lugema või voogedastama seda, mida mudel toodab.

Peamised punktid

  • Optimeeri esmalt vihjet: vähem tokeneid = väiksem latentsus ja kulud
  • Marsruudi ülesanne sobiva keerukusega mudelile
  • Piira max_output_tokens ja kasuta võimalusel temperature=0
  • Kasuta HTTP-ühendusi korduvalt ja töötle vastuseid voogedastuse kaudu