Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Izmaksu optimizēšana mērogā

Nodarbība 10 no 20 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Izmaksas kā inženiertehniskais ierobežojums
  2. Zinot, kur dodas nauda
  3. Četras sviras samazināšanai
  4. Brīdinājumu saņemšana pirms rēķina
  5. Galvenās atziņas

Izmaksas kā inženiertehniskais ierobežojums

Slikti optimizēts uzvednis, kas maksā 0,002 USD par pieprasījumu, izstrādes posmā šķiet niecīgs. Veicot miljonu pieprasījumu, tas izmaksā 2000 USD — un tas tev izmaksās tikpat katru mēnesi, līdz kāds to pārraksta. Šī mēroga maiņa pārvērš izmaksas par inženiertehnisku ierobežojumu: tu to neatrisini, vedot sarunas par līgumu, bet gan mainot kodu.

Redzamība ir priekšnoteikums jebkurai optimizācijai. Mēneša rēķins parāda, cik daudz tu esi iztērējis, bet ne kur tieši. Tāpēc šī nodarbība sākas ar instrumentēšanu, pirms tiek apskatīti samazināšanas sviras.

Zinot, kur dodas nauda

Pieprasījuma izmaksas nosaka četri elementi, un tie uzvedas atšķirīgi. Ievades tokeni, kas apvieno sistēmas uzvedni, sarunu vēsturi un lietotāja ziņojumu, pieaug, ilgstošai sesijai. Izvades tokeni — ģenerētā atbilde — tiek tarifēti ievērojami dārgāk nekā ievade. Kešotie ievades tokeni saņem aptuveni 50 % atlaidi no ievades tarifa, tāpēc to izsekošana ir būtiska, lai saprastu jebkuru rēķinu. Visbeidzot, pats modelis: GPT-5.6 Luna ir daudz lētāks nekā GPT-5.6 Sol, un šis faktors dominē pār visiem pārējiem.

Izsekošana nozīmē katru API atgriezto usage objektu pārvērst dolāru summā, piemērojot pareizo tarifu un izolējot kešoto daļu.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Tarifi par miljonu tokeniem (2026. gada jūlijs) — cached_input ir orientējošs (~50% no input),
# pielāgojiet atbilstoši oficiālajam cenu sarakstam
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:
    """Izmaksu izsekošana reāllaikā."""
    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 "Nav reģistrētu pieprasījumu."
        return (
            f"Pieprasījumi: {len(self.calls)} | "
            f"Kopējās izmaksas: ${self.total_cost:.4f} | "
            f"Vidējās izmaksas: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

Tabulai RATES nepieciešama pastāvīga uzmanība: tā kļūst novecojusi tiklīdz mainās oficiālais cenu saraksts. Uztveri to kā konfigurācijas datus, kas jāpārbauda, nevis kā programmas konstanti, un padari vidējās izmaksas par pieprasījumu par metrikas rādītāju, ko pārskati ik nedēļu.

Četras sviras samazināšanai

Pirmā un tālu ienesīgākā svira ir izvairīšanās no maksāšanas par augstas klases modeli, ja uzdevums to neprasa. Eksplicīta maršrutēšana, balstoties uz sarežģītību, novērš noklusējuma novirzi, kurā visa plūsma nonāk pie dārgākā modeļa vienkārši tāpēc, ka tas parādījās pirmajā nokopētajā piemērā.

async def economic_router(prompt: str, complexity: str) -> str:
    """Maršrutē uz lētāko modeli, kas spēj veikt uzdevumu."""
    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

Otrā svira iet tālāk, ja sarežģītība nav zināma iepriekš. Tā vietā, lai klasificētu pieprasījumu, kaskāde vispirms izmēģina lētāko modeli un paaugstina līmeni tikai tad, ja atbilde neiztur kvalitātes pārbaudi. Šeit izmantotā pārbaude ir apzināti primitīva — minimālais garums un ignorēšanas atzīšanas trūkums — un tieši šeit tev būs jāveic uzlabojumi: kaskāde, kas pārāk bieži paaugstina līmeni, kļūst dārgāka nekā tiešs pieprasījums pareizajam modelim.

async def model_cascade(prompt: str) -> str:
    """Vispirms izmēģina lētāko modeli."""
    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)

        # Kvalitātes pārbaude (vienkārša heuristika)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Pēdējais rezultāts pat tad, ja nepilnīgs

Trešā svira ir vērsta uz ievades tokeniem, kas klusējot pieaug jebkurā sarunu lietotnē: līdz divdesmitajam gājienam tu ar katru ziņojumu atmaksā par iepriekšējiem deviņpadsmit. Vēstures kompresija, saglabājot pirmo ziņojumu (kas satur kontekstu) un pēdējo (kas satur jautājumu), un atlikušo budžetu aizpildot ar jaunākajām apmaiņām, saglabā būtisku sakarību par daļu no izmaksām.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Saglabā jaunākos ziņojumus budžeta robežās."""
    # Vienmēr saglabā pirmo (konteksts) un pēdējo (jautājums)
    if len(messages) <= 2:
        return messages

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

    # Tokenu novērtējums (aptuveni: 1 tokens ≈ 4 rakstzīmes)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Saglabā jaunākos ziņojumus
    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]

Ceturtā svira neprasa algoritmisku smalkumu, tikai disciplīnu: Batch API piedāvā 50 % samazinājumu, un tev tikai jāidentificē, kas var pagaidīt. Ļauj uzdevumam pašam nest steidzamību no tā radīšanas brīža, nevis secināt to pēc tam — tas ir vienīgais veids, kā novērst visu nokļūšanu realitātes laika rindā.

def classify_urgency(tasks: list[dict]) -> dict:
    """Atdala uzdevumus realitātes laika un batch apstrādei."""
    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,  # Piemērs
    }

Brīdinājumu saņemšana pirms rēķina

Visas šīs optimizācijas var tikt iznīcinātas ar vienu neveiksmīgu izvietošanu: neierobežota atkārtojumu cilpa, trīskāršots sistēmas uzvednis, kļūdaini nomainīts modelis. Izmaksu brīdinājums ir drošības tīkls, kas tevi brīdina stundu laikā, nevis mēneša beigās. Ņem vērā starpposma slieksni pie 80 %: tas pārvērš brutālu trauksmi agrīnā signālā, dodot laiku rīkoties pirms limita pārsniegšanas.

class CostAlert:
    """Iedarbina brīdinājumus, kad izmaksas pārsniedz slieksni."""

    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"TRAUKSME: dienas izmaksas ${self.tracker.total_cost:.2f} "
                f"pārsniedz slieksni ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"BRĪDINĀJUMS: izmaksas sasniegušas {self.tracker.total_cost / self.threshold:.0%} "
                f"no dienas sliekšņa"
            )
        return None

Galvenās atziņas

  • Izseko savas izmaksas reāllaikā, izmantojot response.usage
  • Maršrutē uz lētāko modeli, kas spēj veikt uzdevumu
  • Izmanto Batch API (-50 %) visam, kam nav nepieciešama realitātes laika apstrāde
  • Samazini ievades tokenus, kompresējot vēsturi
  • Iestatī izmaksu brīdinājumus, lai izvairītos no pārsteigumiem