Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Išlaidų optimizavimas dideliu mastu

Paskaita 10 iš 20 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. Išlaidos kaip inžinerinis apribojimas
  2. Žinojimas, kur dingsta pinigai
  3. Keturi mažinimo svertai
  4. Įspėjimas prieš gaunant sąskaitą
  5. Svarbiausi punktai

Išlaidos kaip inžinerinis apribojimas

Prastai optimizuotas užklausos šablonas, kainuojantis 0,002 USD už kvietimą, kūrimo metu atrodo nereikšmingas. Tačiau atlikus milijoną kvietimų, kaina siekia 2 000 USD – ir ji tau bus taikoma kas mėnesį, kol kas nors jo neperrašys. Šis mastelio pokytis paverčia išlaidas inžineriniu apribojimu: jų neišspręsi derėdamasis dėl sutarties, tai išspręsi pakeisdamas kodą.

Matomumas yra bet kokio optimizavimo priešaidė. Mėnesio sąskaita parodo, kiek išleidai, bet ne kur. Štai kodėl ši pamoka prasideda nuo instrumentavimo, prieš nagrinėjant mažinimo svertus.

Žinojimas, kur dingsta pinigai

Kvietimo kainą lemia keturi elementai, ir jie elgiasi skirtingai. Įvesties tokenai, apimantys sistemos užklausos šabloną, pokalbio istoriją ir naudotojo žinutę, didėja sesijos trukmei ilgėjant. Išvesties tokenai – sugeneruotas atsakymas – kainuoja žymiai brangiau nei įvestis. Talpykloje saugomi įvesties tokenai gauna maždaug 50 % nuolaidą nuo įvesties tarifo, todėl jų stebėjimas yra būtinas norint suprasti bet kurią sąskaitą. Galiausiai pats modelis: GPT-5.6 Luna yra daug pigesnis nei GPT-5.6 Sol, ir šis veiksnys dominuoja visus kitus.

Stebėjimas reiškia kiekvieno API grąžinamo usage objekto konvertavimą į dolerių sumą, taikant tinkamą tarifą ir išskiriant talpykloje esančią dalį.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Tarifai už milijoną tokenų (2026 m. liepa) — cached_input yra orientacinis (~50 % nuo input),
# koreguokite pagal oficialų kainoraštį
RATES = {
    "gpt-5.6-luna": {"input": 0.20, "output": 1.20, "cached_input": 0.02},
    "gpt-5.6-terra": {"input": 2.00, "output": 12.00, "cached_input": 0.20},
    "gpt-5.6-sol": {"input": 5.00, "output": 30.00, "cached_input": 0.50},
}

@dataclass
class CostTracker:
    """Stebi išlaidas realiuoju laiku."""
    calls: list[dict] = field(default_factory=list)

    def record(self, model: str, usage: dict) -> float:
        input_tokens = usage.input_tokens
        cached_tokens = getattr(
            usage.input_tokens_details, "cached_tokens", 0
        )
        output_tokens = usage.output_tokens
        uncached_input_tokens = input_tokens - cached_tokens

        rate = RATES.get(model, RATES["gpt-5.6-terra"])
        cost = (
            (uncached_input_tokens / 1_000_000) * rate["input"]
            + (cached_tokens / 1_000_000) * rate["cached_input"]
            + (output_tokens / 1_000_000) * rate["output"]
        )

        self.calls.append({
            "model": model,
            "input_tokens": input_tokens,
            "cached_tokens": cached_tokens,
            "output_tokens": output_tokens,
            "cost": cost,
        })
        return cost

    @property
    def total_cost(self) -> float:
        return sum(a["cost"] for a in self.calls)

    def report(self) -> str:
        if not self.calls:
            return "Nėra užregistruotų kvietimų."
        return (
            f"Kvietimai: {len(self.calls)} | "
            f"Bendra kaina: ${self.total_cost:.4f} | "
            f"Vidutinė kaina: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

Lentelė RATES reikalauja nuolatinio dėmesio: ji pasensta vos tik pasikeitus oficialiam kainoraščiui. Traktuok ją kaip konfigūracijos duomenis, kuriuos reikia tikrinti, o ne kaip programos konstantą, ir vidutinę vieno kvietimo kainą paversk metrika, kurią peržiūri kas savaitę.

Keturi mažinimo svertai

Pirmasis ir toli gražu pelningiausias svertas – vengti mokėti už aukščiausios klasės modelį, kai užduotis jo nereikalauja. Aiškus maršrutizavimas pagal sudėtingumą neleidžia vykti numatytajam nukrypimui, kai visas srautas atsiduria brangiausiame modelyje vien todėl, kad jis buvo pirmajame nukopijuotame pavyzdyje.

async def economic_router(prompt: str, complexity: str) -> str:
    """Nukreipia į pigiausią tinkamą modelį."""
    if complexity == "simple":
        model = "gpt-5.6-luna"
    elif complexity == "medium":
        model = "gpt-5.6-terra"
    else:
        model = "gpt-5.6-sol"

    response = client.responses.create(model=model, input=prompt)
    tracker.record(model, response.usage)
    return response.output_text

Antrasis svertas eina dar toliau, kai sudėtingumas iš anksto nežinomas. Užuot klasifikavęs užklausą, kaskadas pirmiausia bando pigiausią modelį ir pereina prie kito tik tada, jei atsakymas neatlaiko kokybės patikros. Čia naudojama patikra yra tyčia primityvi – minimalus ilgis ir ignoravimo pripažinimo nebuvimas – ir būtent šią vietą tau reikės tobulinti: kaskadas, kuris per dažnai pereina prie aukštesnio lygio, tampa brangesnis nei tiesioginis kvietimas į tinkamą modelį.

async def model_cascade(prompt: str) -> str:
    """Pirmiausia bando pigiausią modelį."""
    models = ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]

    for model in models:
        response = client.responses.create(
            model=model,
            input=prompt,
            max_output_tokens=500,
        )
        tracker.record(model, response.usage)

        # Tikrina kokybę (paprasta heuristika)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Paskutinis rezultatas, net jei netobulas

Trečiasis svertas taikomas įvesties tokenams, kurie bet kurioje pokalbių programoje tyčia auga: dvidešimtuoju posūkiu tu jau mokai už ankstesnius devyniolika su kiekviena žinute. Istorijos glaudinimas paliekant pirmąją žinutę (kuri turi kontekstą) ir paskutinę (kuri turi klausimą), o likusį biudžetą užpildant naujausiais mainais, išlaiko esminį nuoseklumą už dalį kainos.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Palieka naujausias žinutes neviršijant biudžeto."""
    # Visada paliekama pirmoji (kontekstas) ir paskutinė (klausimas)
    if len(messages) <= 2:
        return messages

    first = messages[0]
    last = messages[-1]
    middle = messages[1:-1]

    # Įvertinami tokenai (apytiksliai: 1 tokenas ≈ 4 simboliai)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Paliekamos naujausios žinutės
    result = []
    tokens_used = 0
    for msg in reversed(middle):
        msg_tokens = len(msg["content"]) // 4
        if tokens_used + msg_tokens > middle_budget:
            break
        result.insert(0, msg)
        tokens_used += msg_tokens

    return [first] + result + [last]

Ketvirtajam svertui nereikia algoritminio meistriškumo, tik disciplinos: „Batch API“ siūlo 50 % sumažinimą, tau tereikia nustatyti, kas gali palaukti. Leisk pačiai užduočiai nešti skubos požymį nuo jos sukūrimo momento, o ne bandyk to nustatyti vėliau – tai vienintelis būdas išvengti situacijos, kai viskas pagal nutylėjimą patenka į realiojo laiko eilę.

def classify_urgency(tasks: list[dict]) -> dict:
    """Atskiria užduotis į realiojo laiko ir paketines."""
    real_time = []
    batch = []

    for task in tasks:
        if task.get("urgency") == "immediate":
            real_time.append(task)
        else:
            batch.append(task)

    return {
        "real_time": real_time,
        "batch": batch,
        "estimated_savings": len(batch) * 0.001,  # Pavyzdys
    }

Įspėjimas prieš gaunant sąskaitą

Visus šiuos optimizavimus gali sugriauti vienas nesėkmingas diegimas: neribotas bandymų ciklas, patrigubintas sistemos užklausos šablonas, klaidingai pakeistas modelis. Išlaidų įspėjimas yra saugos tinklas, kuris įspėja tave per valandas, o ne mėnesio pabaigoje. Atkreipk dėmesį į tarpinę 80 % ribą: ji paverčia šiurkštų signalizavimą ankstyvu įspėjimu, suteikdama laiko imtis veiksmų prieš viršijant limitą.

class CostAlert:
    """Suaktyvina įspėjimus, kai išlaidos viršija ribą."""

    def __init__(self, daily_threshold: float = 50.0):
        self.threshold = daily_threshold
        self.tracker = CostTracker()

    def check(self) -> str | None:
        if self.tracker.total_cost > self.threshold:
            return (
                f"ĮSPĖJIMAS: dienos išlaidos ${self.tracker.total_cost:.2f} "
                f"viršija ribą ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"DĖMESIO: išlaidos siekia {self.tracker.total_cost / self.threshold:.0%} "
                f"nuo dienos ribos"
            )
        return None

Svarbiausi punktai

  • Stebėk išlaidas realiuoju laiku naudodamas response.usage
  • Nukreipk užklausas į pigiausią užduotį atlikti pajėgų modelį
  • Naudok „Batch API“ (-50 %) viskam, kas nereikalauja realiojo laiko apdorojimo
  • Sumažink įvesties tokenus glaudindamas istoriją
  • Nustatyk išlaidų įspėjimus, kad išvengtum netikėtumų