Премини към основното съдържание
Български— Изберете език
Меню

Оптимизиране на разходите в мащаб

Урок 10 от 20 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Разходите като инженерно ограничение
  2. Да знаете къде отиват парите
  3. Четири лоста за намаляване
  4. Предупреждение преди фактурата
  5. Ключови изводи

Разходите като инженерно ограничение

Лошо оптимизиран подкан, струващ $0.002 на заявка, е пренебрежим по време на разработка. При един милион заявки обаче цената става $2,000 – и ще продължи да Ви струва толкова всеки месец, докато някой не го пренапише. Тази промяна в мащаба превръща разхода в инженерно ограничение: не го решавате чрез преговори за договор, а чрез промяна на кода.

Видимостта е предпоставка за всяка оптимизация. Месечната фактура Ви показва колко сте похарчили, но не и къде. Затова този урок започва с инструментиране, преди да премине към лостовете за намаляване.

Да знаете къде отиват парите

Четири елемента определят цената на една заявка и те не се държат по един и същи начин. Входните токени, които обединяват системния подкан, историята на разговора и съобщението на потребителя, нарастват с продължителността на сесията. Изходните токени – генерираният отговор – се таксуват значително по-високо от входните. Кешiranите входни токени получават отстъпка от приблизително 50% спрямо тарифата за вход, което прави проследяването им от съществено значение за разбирането на всяка фактура. И накрая, самият модел: GPT-5.6 Luna е много по-евтин от GPT-5.6 Sol и този фактор доминира над всички останали.

Проследяването означава превръщане на всеки обект usage, върнат от API, в доларова сума, прилагане на правилната тарифа и изолиране на кешirаната част.

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()

Таблицата RATES изисква постоянно внимание: тя остарява веднага щом официалната ценова листа се промени. Третирайте я като конфигурационни данни за проверка, а не като програмна константа, и направете средната цена на заявка метрика, която преглеждате седмично.

Четири лоста за намаляване

Първият лост и далеч най-печелившият е избягването на плащане за модел от висок клас, когато задачата не го изисква. Изричното насочване въз основа на сложността предотвратява стандартното отклонение, при което целият трафик попада на най-скъпия модел просто защото се е появил в първия копиран пример.

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

Вторият лост отива по-далеч, когато сложността не е известна предварително. Вместо да класифицирате заявката, каскадата първо пробва най-евтиния модел и ескалира само ако отговорът не премине проверка за качество. Проверката, използвана тук, е умишлено елементарна – минимална дължина и липса на признание за незнание – и това е точката, която ще трябва да усъвършенствате: каскада, която ескалира твърде често, става по-скъпа от директна заявка към правилния модел.

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

Третият лост цели входните токени, които нарастват незабележимо във всяко конферентно приложение: до двадесетия завой Вие плащате отново за предишните деветнадесет с всяко съобщение. Компресирането на историята чрез запазване на първото съобщение (което съдържа контекста) и последното (което съдържа въпроса), след което запълване на останалия бюджет с най-скорошните размени, запазва съществената кохерентност за част от цената.

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]

Четвъртият лост не изисква алгоритмична финес, а само дисциплина: Batch API предлага намаление от 50% и просто трябва да идентифицирате какво може да изчака. Нека самата задача носи спешността от своето създаване, вместо да я изводите впоследствие – това е единственият начин да предотвратите всичко по подразбиране да попада в опашката за реално време.

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
    }

Предупреждение преди фактурата

Всички тези оптимизации могат да бъдат унищожени от едно единствено неуспешно внедряване: цикъл на повторни опити без ограничения, утроен системен подкан, модел, променен по грешка. Известлението за разходи е защитната мрежа, която Ви предупреждава в рамките на часове, а не в края на месеца. Обърнете внимание на междинния праг от 80%: той превръща бруталната аларма в ранен сигнал, давайки Ви време да действате, преди да надвишите лимита.

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

Ключови изводи

  • Проследявайте разходите си в реално време, използвайки response.usage
  • Насочвайте към най-евтиния модел, способен да изпълни задачата
  • Използвайте Batch API (-50%) за всичко, което не изисква обработка в реално време
  • Намалете входните токени чрез компресиране на историята
  • Настройте известия за разходи, за да избегнете изненади