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

Мониторинг на разходите и използването

Урок 16 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Мониторинг на разходите и използването
  2. Разбиране на таксуването
  3. Калкулатор за разходи
  4. Тракер за разходи в реално време
  5. Клиент с контрол на бюджета
  6. Оптимизиране на разходите
  7. Ключови изводи

Мониторинг на разходите и използването

Разходите за API могат бързо да излязат извън контрол, ако не ги следите внимателно. В този урок ще научите как да проследявате, оценявате и контролирате разходите си в продукционна среда. Историята се повтаря от проект на проект: функция се пуска в четвъртък, никой не проверява таблото с данни през уикенда и в понеделник сутринта фактурата отговаря на целия месечен бюджет. Стъпките по-долу ще Ви помогнат да откриете отклонение в разходите в момента, в който се случи, а не тридесет дни по-късно.

Разбиране на таксуването

Разходите се изчисляват на милион токена, като има различни цени за входни (input) и изходни (output) данни. Тази асиметрия има пряко влияние върху избора Ви за архитектура: изпращането на дълъг документ като вход струва значително по-малко от това моделът да генерира дълъг отговор. Всеки отговор връща точния брой токени и в двете посоки, така че никога не се налага да правите приблизителни оценки.

from openai import OpenAI
client = OpenAI()

# Всеки отговор включва метрики за използване
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain OpenAI API billing."
)

usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total tokens: {usage.total_tokens}")

# Изходните токени струват повече от входните!

Калкулатор за разходи

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

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Приблизителни цени в USD на милион токена
# Винаги проверявайте актуалните цени на platform.openai.com/pricing
RATES = {
    "gpt-5.6-luna": ModelRate(input_per_million=0.20, output_per_million=1.20),
    "gpt-5.6-terra": ModelRate(input_per_million=2.0, output_per_million=12.0),
    "gpt-5.6-sol": ModelRate(input_per_million=5.0, output_per_million=30.0),
}

def calculate_cost(model: str, input_tokens: int,
                   output_tokens: int) -> float:
    """Изчислява цената на заявката в USD."""
    rate = RATES.get(model)
    if not rate:
        raise ValueError(f"Unknown model: {model}")

    input_cost = (input_tokens / 1_000_000) * rate.input_per_million
    output_cost = (output_tokens / 1_000_000) * rate.output_per_million

    return input_cost + output_cost

# Пример
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Резултат: Cost: $0.008000

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

Тракер за разходи в реално време

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

import json
from datetime import datetime, date
from collections import defaultdict

class CostTracker:
    """Проследяване на разходите за API в реално време."""

    def __init__(self, daily_budget_usd: float = 10.0):
        self.daily_budget = daily_budget_usd
        self.costs_per_day: dict[str, float] = defaultdict(float)
        self.costs_per_model: dict[str, float] = defaultdict(float)
        self.calls_per_day: dict[str, int] = defaultdict(int)
        self.total_tokens = 0

    def record(self, model: str, input_tokens: int,
               output_tokens: int):
        """Записва разходите за дадено обаждане."""
        cost = calculate_cost(model, input_tokens, output_tokens)
        today = date.today().isoformat()

        self.costs_per_day[today] += cost
        self.costs_per_model[model] += cost
        self.calls_per_day[today] += 1
        self.total_tokens += input_tokens + output_tokens

        return cost

    def remaining_budget(self) -> float:
        """Връща оставащия бюджет за днес."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Проверява дали бюджетът е близо до лимита."""
        remaining = self.remaining_budget()
        if remaining <= 0:
            print("ALERT: Daily budget exceeded!")
            return True
        elif remaining < self.daily_budget * 0.2:
            print(f"WARNING: ${remaining:.2f} remaining on daily budget")
            return True
        return False

    def report(self) -> dict:
        """Генерира отчет за разходите."""
        return {
            "total_cost_usd": sum(self.costs_per_day.values()),
            "cost_today_usd": self.costs_per_day.get(
                date.today().isoformat(), 0
            ),
            "remaining_budget_usd": self.remaining_budget(),
            "costs_per_model": dict(self.costs_per_model),
            "total_tokens": self.total_tokens,
        }

# Използване
tracker = CostTracker(daily_budget_usd=5.0)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

cost = tracker.record(
    model="gpt-5.6-terra",
    input_tokens=response.usage.input_tokens,
    output_tokens=response.usage.output_tokens
)
print(f"Cost of this call: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))

Клиент с контрол на бюджета

Мониторингът не винаги е достатъчен: пред лицето на дефектен цикъл, който непрекъснато извиква API, Ви е необходим финансов предпазител (circuit breaker). Този клиент проверява оставащия бюджет преди да издаде заявката и категорично отказва обаждането, ако лимитът е изчерпан. Услугата се деградира, но по контролиран начин, без изненадващи фактури. Отчитането на разходите се извършва впоследствие, след като реалното използване стане известно.

class BudgetControlledClient:
    """Клиент, който отказва обаждания, ако бюджетът е надхвърлен."""

    def __init__(self, daily_budget: float = 10.0):
        self.client = OpenAI()
        self.tracker = CostTracker(daily_budget_usd=daily_budget)

    def create(self, model: str, input: str, **kwargs) -> object:
        """API обаждане с контрол на бюджета."""
        # Проверка на бюджета преди обаждането
        if self.tracker.remaining_budget() <= 0:
            raise RuntimeError(
                "Daily budget exhausted. "
                f"Spent: ${self.tracker.report()['cost_today_usd']:.2f}"
            )

        response = self.client.responses.create(
            model=model,
            input=input,
            **kwargs
        )

        cost = self.tracker.record(
            model=model,
            input_tokens=response.usage.input_tokens,
            output_tokens=response.usage.output_tokens
        )

        # Предупреждение, ако бюджетът е нисък
        self.tracker.budget_alert()

        return response

# Използване
budget_client = BudgetControlledClient(daily_budget=2.0)

try:
    response = budget_client.create("gpt-5.6-terra", "Hello!")
    print(response.output_text)
except RuntimeError as e:
    print(f"Blocked: {e}")

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

1. Избор на правилния модел

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

# Относителна цена на задача (приблизително, ~300 входни токена / 20 изходни):
# Проста класификация: gpt-5.6-luna ~$0.0001 спрямо gpt-5.6-sol ~$0.002
# Правилният модел прави разлика от 25 пъти в разходите!

def optimized_call(prompt: str, complexity: str) -> str:
    """Избира най-икономичния подходящ модел."""
    model = {
        "simple": "gpt-5.6-luna",
        "standard": "gpt-5.6-terra",
        "complex": "gpt-5.6-sol",
    }.get(complexity, "gpt-5.6-terra")

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

2. Кеш на отговорите

Вторият лост е избягването на плащане два пъти за един и същи отговор. ЧЗВ, каталог с продукти или стандартен формуляр генерират строго идентични подкани десетки пъти на ден. Ключът на кеша комбинира модела, входа и параметрите – включването на всички тях е от съществено значение, в противен случай промяна в температурата би върнала тихо стария отговор.

import hashlib

class CachedClient:
    """Клиент с кеш за избягване на излишни обаждания."""

    def __init__(self):
        self.client = OpenAI()
        self.cache: dict[str, str] = {}

    def create(self, model: str, input: str, **kwargs) -> str:
        # Създаване на ключ за кеша
        cache_key = hashlib.md5(
            f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
        ).hexdigest()

        if cache_key in self.cache:
            print("Cache hit!")
            return self.cache[cache_key]

        response = self.client.responses.create(
            model=model, input=input, **kwargs
        )

        self.cache[cache_key] = response.output_text
        return response.output_text

3. Ограничаване на изходните токени

Накрая, ограничавайте изхода винаги, когато дължината му е предвидима. Тъй като изходът е скъпата част, искането на една дума, докато разрешавате две хиляди токена, оставя вратата отворена за многословен отговор, за който ще платите, но няма да използвате.

# Винаги задавайте max_output_tokens за предвидими задачи
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Classify this text: positive, negative, or neutral.",
    max_output_tokens=10  # Очаква се една дума
)

Тарифи към 5 август 2026 г. – цените се променят редовно: преди всяко изчисление на бюджета проверете актуалната ценова листа на официалната страница за цени на OpenAI.

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

  • Разходите зависят от модела И от посоката (вход спрямо изход)
  • Внедрете тракер за разходи с предупреждения за бюджета
  • Използвайте правилния модел за всяка задача: Luna за големи обеми, Terra по подразбиране
  • Кеширането може драстично да намали разходите за повтарящи се заявки
  • Задавайте max_output_tokens, когато дължината на отговора е предвидима
  • Проверете таблото с данни на OpenAI за официално проследяване на потреблението