Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Optimering af omkostninger i stor skala

Lektion 10 af 20 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Omkostninger som en teknisk begrænsning
  2. At vide, hvor pengene bliver af
  3. Fire løftestænger til reduktion
  4. At blive advaret før regningen kommer
  5. Vigtige pointer

Omkostninger som en teknisk begrænsning

En dårligt optimeret prompt, der koster $0,002 pr. kald, er ubetydelig under udviklingen. Ved én million kald løber regningen op på $2.000 – og den vil fortsætte med at koste dig det hver eneste måned, indtil nogen omskriver koden. Dette skift i skala gør omkostninger til en teknisk begrænsning: Du løser det ikke ved at forhandle en kontrakt, men ved at ændre koden.

Synlighed er en forudsætning for enhver optimering. En månedlig regning fortæller dig, hvor meget du har brugt, ikke hvor. Derfor starter denne lektion med instrumentering, før vi dækker de muligheder, der kan reducere omkostningerne.

At vide, hvor pengene bliver af

Fire elementer bestemmer omkostningerne ved et kald, og de opfører sig ikke ens. Input-tokens, som samler system-prompten, samtalehistorikken og brugerens besked, vokser med sessionens varighed. Output-tokens – det genererede svar – faktureres betydeligt højere end input. Cachet input-tokens får cirka 50 % rabat på input-prisen, hvilket gør sporing af dem afgørende for at forstå enhver regning. Endelig selve modellen: GPT-5.6 Luna er langt billigere end GPT-5.6 Sol, og denne faktor dominerer alle andre.

Sporing betyder at konvertere hvert usage-objekt, der returneres af API’et, til et dollarbeløb, anvende den korrekte sats og isolere den cachede del.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Rates per million tokens (July 2026) — cached_input is indicative (~50% of input),
# adjust according to the official pricing grid
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:
    """Tracks costs in real time."""
    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 "No calls recorded."
        return (
            f"Calls: {len(self.calls)} | "
            f"Total cost: ${self.total_cost:.4f} | "
            f"Average cost: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

Tabellen RATES kræver konstant opmærksomhed: Den bliver forældet, så snart den officielle prisliste ændres. Behandle den som konfigurationsdata, der skal verificeres, ikke som en programkonstant, og gør den gennemsnitlige omkostning pr. kald til en metrik, du gennemgår ugentligt.

Fire løftestænger til reduktion

Den første løftestang – og langt den mest profitable – er at undgå at betale for en højtydende model, når opgaven ikke kræver det. Eksplicit routing baseret på kompleksitet forhindrer den standardmæssige drift, hvor al trafik ender på den dyreste model, blot fordi den optrådte i det første kopierede eksempel.

async def economic_router(prompt: str, complexity: str) -> str:
    """Routes to the cheapest capable 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

Den anden løftestang går videre, når kompleksiteten ikke er kendt på forhånd. I stedet for at klassificere anmodningen, prøver kaskaden den billigste model først og eskalerer kun, hvis svaret fejler et kvalitetscheck. Checket, der bruges her, er bevidst rudimentært – en minimumslængde og fraværet af en indrømmelse af uvidenhed – og det er her, du skal finpudse: En kaskade, der eskalerer for ofte, bliver dyrere end et direkte kald til den rigtige model.

async def model_cascade(prompt: str) -> str:
    """Tries the cheapest model first."""
    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)

        # Check quality (simple heuristic)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Last result even if imperfect

Den tredje løftestang målretter input-tokens, som vokser lydløst i enhver samtaleapplikation: Ved det tyvende svar betaler du for de foregående nitten med hver eneste besked. Komprimering af historikken ved at beholde den første besked (som indeholder konteksten) og den sidste (som indeholder spørgsmålet) og derefter fylde det resterende budget med de seneste udvekslinger, bevarer den væsentlige sammenhængskraft til en brøkdel af omkostningerne.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Keeps the most recent messages within budget."""
    # Always keep the first (context) and last (question)
    if len(messages) <= 2:
        return messages

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

    # Estimate tokens (approximation: 1 token ≈ 4 characters)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Keep the most recent messages
    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]

Den fjerde løftestang kræver ingen algoritmisk finesse, kun disciplin: Batch-API’et tilbyder en reduktion på 50 %, og du skal blot identificere, hvad der kan vente. Lad selve opgaven bære hastegraden fra sin oprettelse i stedet for at udlede den bagefter – det er den eneste måde at forhindre, at alt som standard havner i realtidskøen.

def classify_urgency(tasks: list[dict]) -> dict:
    """Separates tasks into real-time vs batch."""
    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,  # Example
    }

At blive advaret før regningen kommer

Alle disse optimeringer kan blive gjort til skamme af en enkelt uheldig deployment: En ubegrænset genforsøgsløkke, en system-prompt, der er tredoblet, eller en model, der er ændret ved en fejl. En omkostningsalarm er sikkerhedsnettet, der advarer dig inden for timer i stedet for ved månedens udgang. Bemærk den mellemliggende tærskel på 80 %: Den omdanner en brutal alarm til et tidligt signal, der giver dig tid til at handle, før du overskrider grænsen.

class CostAlert:
    """Triggers alerts when costs exceed a threshold."""

    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"ALERT: daily cost ${self.tracker.total_cost:.2f} "
                f"exceeds threshold of ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"WARNING: cost at {self.tracker.total_cost / self.threshold:.0%} "
                f"of daily threshold"
            )
        return None

Vigtige pointer

  • Spor dine omkostninger i realtid ved hjælp af response.usage
  • Rout til den billigste model, der er i stand til at løse opgaven
  • Brug Batch-API’et (-50 %) til alt, der ikke kræver realtidsbehandling
  • Reducer input-tokens ved at komprimere historikken
  • Opsæt omkostningsalarmer for at undgå overraskelser