Снижение затрат на LLM: стратегии оптимизации токенов

Сократите расходы на LLM на 80% за счет интеллектуальной оптимизации токенов

Содержимое страницы

Оптимизация токенов — это ключевой навык, который отделяет экономически эффективные приложения на базе LLM от экспериментов, истощающих бюджет.

Поскольку затраты на API растут линейно в зависимости от использования токенов, понимание и внедрение стратегий оптимизации может сократить расходы на 60–80% при сохранении качества.

Самостоятельно размещенные агентные циклы создают вторую статью расходов из-за потраченных впустую токенов завершения, когда параметры сэмплирования слишком «горячие». Параметры агентного инференса для Qwen и Gemma собирает значения по умолчанию, которые сдерживают повторные попытки, не лишая модель ресурсов для рассуждений.

умная архитектура

Понимание экономики токенов

Прежде чем оптимизировать, необходимо понять, как работают токены и ценообразование у различных провайдеров LLM.

Основы токенов

Токены — это фундаментальные единицы, которые обрабатывают LLM, примерно эквивалентные 4 символам или 0,75 слова в английском языке. Строка «Hello, world!» содержит примерно 4 токена. Разные модели используют разные токенизаторы (GPT использует tiktoken, Claude использует собственный), поэтому количество токенов может незначительно различаться у разных провайдеров.

Сравнение моделей ценообразования

Ценообразование OpenAI (по состоянию на 2025 год):

  • GPT-4 Turbo: $0.01 за ввод / $0.03 за вывод за 1K токенов
  • GPT-3.5 Turbo: $0.0005 за ввод / $0.0015 за вывод за 1K токенов
  • GPT-4o: $0.005 за ввод / $0.015 за вывод за 1K токенов

Ценообразование Anthropic:

  • Claude 3 Opus: $0.015 за ввод / $0.075 за вывод за 1K токенов
  • Claude 3 Sonnet: $0.003 за ввод / $0.015 за вывод за 1K токенов
  • Claude 3 Haiku: $0.00025 за ввод / $0.00125 за вывод за 1K токенов

Для комплексного сравнения Облачных провайдеров LLM, включая детальное ценообразование, функции и случаи использования, ознакомьтесь с нашим специализированным руководством.

Ключевой вывод: Токены выхода стоят в 2–5 раз дороже, чем токены входа. Ограничение длины ответа оказывает непропорционально большое влияние на затраты.

Инжиниринг промптов для эффективности

Эффективный инжиниринг промптов значительно снижает потребление токенов без ущерба для качества.

1. Устранение избыточности

Плохой пример (127 токенов):

Вы — полезный помощник. Пожалуйста, помогите мне со следующей задачей.
Я хотел бы, чтобы вы проанализировали следующий текст и предоставили мне
резюме. Вот текст, который я хотел бы, чтобы вы резюмировали:
[текст]
Пожалуйста, предоставьте краткое резюме основных моментов.

Оптимизированный вариант (38 токенов):

Резюмируйте ключевые моменты:
[текст]

Экономия: Сокращение токенов на 70% при идентичном качестве вывода.

2. Использование структурированных форматов

JSON и структурированные выводы уменьшают потерю токенов из-за многословного естественного языка.

Вместо этого:

Пожалуйста, извлеките имя, возраст и профессию человека из этого текста
и отформатируйте ваш ответ четко.

Используйте это:

Извлечь в JSON: {name, age, occupation}
Текст: [ввод]

3. Оптимизация обучения с несколькими примерами (Few-Shot Learning)

Примеры few-shot мощны, но дороги. Оптимизируйте их, следуя правилам:

  • Используйте минимальное необходимое количество примеров (обычно достаточно 1–3)
  • Держите примеры краткими — удаляйте лишние слова
  • Используйте общие префиксы — сократите повторяющиеся инструкции
# Оптимизированный промпт с несколькими примерами
prompt = """Классифицировать тональность (pos/neg):
Текст: "Отличный продукт!" -> pos
Текст: "Разочарован" -> neg
Текст: "{user_input}" ->"""

Для получения更多信息 об шаблонах оптимизации Python и синтаксических сокращениях см. наш Шпаргалку по Python.

Стратегии кэширования контекста

Кэширование контекста — это единственная наиболее эффективная оптимизация для приложений с повторяющимся статическим контентом.

Как работает кэширование контекста

Провайдеры, такие как OpenAI и Anthropic, кэшируют префиксы промптов, которые появляются в нескольких запросах. Кэшированные части стоят на 50–90% дешевле обычных токенов.

Требования:

  • Минимальный кэшируемый контент: 1024 токена (OpenAI) или 2048 токенов (Anthropic)
  • Время жизни кэша (TTL): 5–60 минут в зависимости от провайдера
  • Контент должен быть идентичным и располагаться в начале промпта

Пример реализации

from openai import OpenAI

client = OpenAI()

# Системное сообщение кэшируется между запросами
SYSTEM_PROMPT = """Вы — ИИ службы поддержки для TechCorp.
Политика компании:
[Большой документ с политикой - 2000 токенов]
"""

# Это кэшируется автоматически
response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": "Как мне вернуть товар?"}
    ]
)

# Последующие вызовы в пределах TTL кэша используют кэшированный системный промпт
# Оплата только за сообщение пользователя + вывод

Практический эффект: Приложения с базами знаний или длинными инструкциями показывают снижение затрат на 60–80%.

Стратегия выбора модели

Использование правильной модели для каждой задачи имеет решающее значение для оптимизации затрат.

Лестница моделей

  1. GPT-4 / Claude Opus — Сложное рассуждение, творческие задачи, критическая точность
  2. GPT-4o / Claude Sonnet — Сбалансированная производительность/стоимость, общего назначения
  3. GPT-3.5 / Claude Haiku — Простые задачи, классификация, извлечение данных
  4. Дообученные меньшие модели — Специализированные повторяющиеся задачи

Паттерн маршрутизации

def route_request(task_complexity, user_query):
    """Маршрутизация к подходящей модели на основе сложности"""
    
    # Простая классификация - использовать Haiku
    if task_complexity == "simple":
        return call_llm("claude-3-haiku", user_query)
    
    # Средняя сложность - использовать Sonnet
    elif task_complexity == "moderate":
        return call_llm("claude-3-sonnet", user_query)
    
    # Сложное рассуждение - использовать Opus
    else:
        return call_llm("claude-3-opus", user_query)

Кейс: Чат-бот службы поддержки, маршрутизирующий 80% запросов на GPT-3.5 и 20% на GPT-4, снизил затраты на 75% по сравнению с использованием GPT-4 для всех задач.

Пакетная обработка

Для рабочих нагрузок, не чувствительных к времени, пакетная обработка предлагает скидку 50% от большинства провайдеров.

Batch API OpenAI

from openai import OpenAI
client = OpenAI()

# Создание файла пакета
batch_requests = [
    {"custom_id": f"request-{i}", 
     "method": "POST",
     "url": "/v1/chat/completions",
     "body": {
         "model": "gpt-3.5-turbo",
         "messages": [{"role": "user", "content": query}]
     }}
    for i, query in enumerate(queries)
]

# Отправка пакета (скидка 50%, обработка 24 часа)
batch = client.batches.create(
    input_file_id=upload_batch_file(batch_requests),
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

Случаи использования:

  • Метки данных и аннотации
  • Генерация контента для блогов/SEO
  • Генерация отчетов
  • Пакетный перевод
  • Синтетическая генерация датасетов

Техники контроля вывода

Поскольку токены выхода стоят в 2–5 раз дороже, контроль длины вывода критически важен.

1. Установка максимальных токенов

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    max_tokens=150  # Жесткий лимит предотвращает неконтролируемый рост затрат
)

2. Использование стоп-последовательностей

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    stop=["END", "\n\n\n"]  # Остановка по маркерам
)

3. Запрос лаконичных форматов

Добавьте инструкции, такие как:

  • «Ответьте менее чем в 50 словах»
  • «Предоставьте только маркированный список»
  • «Верните только JSON, без объяснений»

Стриминг для улучшения UX

Хотя стриминг не снижает затраты, он улучшает воспринимаемую производительность и позволяет раннее завершение.

stream = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        token = chunk.choices[0].delta.content
        print(token, end="")
        
        # Раннее завершение, если ответ идет не по тому пути
        if undesired_pattern(token):
            break

Оптимизация RAG

Генерация с расширением контекста (RAG) добавляет контекст, но неоптимизированная RAG тратит токены впустую.

Эффективный паттерн RAG

def optimized_rag(query, vector_db):
    # 1. Извлечь релевантные фрагменты
    chunks = vector_db.search(query, top_k=3)  # Не слишком много
    
    # 2. Сжать фрагменты - удалить избыточность
    compressed = compress_chunks(chunks)  # Пользовательское сжатие
    
    # 3. Обрезать до лимита токенов
    context = truncate_to_tokens(compressed, max_tokens=2000)
    
    # 4. Структурированный промпт
    prompt = f"Контекст:\n{context}\n\nВ: {query}\nО:"
    
    return call_llm(prompt)

Техники оптимизации:

  • Используйте семантическое чанкинг (а не фиксированного размера)
  • Удаляйте форматирование Markdown из извлеченных фрагментов
  • Реализуйте пере-ранжирование, чтобы получить наиболее релевантный контент
  • Рассмотрите суммаризацию фрагментов для больших документов

Кэширование ответов

Кэшируйте идентичные или похожие запросы, чтобы полностью избежать вызовов API.

Реализация с Redis

import redis
import hashlib
import json

redis_client = redis.Redis()

def cached_llm_call(prompt, model="gpt-4", ttl=3600):
    # Создание ключа кэша из промпта + модели
    cache_key = hashlib.md5(
        f"{model}:{prompt}".encode()
    ).hexdigest()
    
    # Проверка кэша
    cached = redis_client.get(cache_key)
    if cached:
        return json.loads(cached)
    
    # Вызов LLM
    response = call_llm(model, prompt)
    
    # Кэширование результата
    redis_client.setex(
        cache_key, 
        ttl, 
        json.dumps(response)
    )
    
    return response

Семантическое кэширование: Для похожих (но не идентичных) запросов используйте векторные эмбеддинги для поиска кэшированных ответов.

Мониторинг и аналитика

Отслеживайте использование токенов, чтобы выявить возможности для оптимизации.

Основные метрики

class TokenTracker:
    def __init__(self):
        self.metrics = {
            'total_tokens': 0,
            'input_tokens': 0,
            'output_tokens': 0,
            'cost': 0.0,
            'requests': 0
        }
    
    def track_request(self, response, model):
        usage = response.usage
        self.metrics['input_tokens'] += usage.prompt_tokens
        self.metrics['output_tokens'] += usage.completion_tokens
        self.metrics['total_tokens'] += usage.total_tokens
        self.metrics['cost'] += calculate_cost(usage, model)
        self.metrics['requests'] += 1
    
    def report(self):
        return {
            'avg_tokens_per_request': 
                self.metrics['total_tokens'] / self.metrics['requests'],
            'total_cost': self.metrics['cost'],
            'input_output_ratio': 
                self.metrics['input_tokens'] / self.metrics['output_tokens']
        }

Уведомления о затратах

Настройте уведомления, когда использование превышает пороги:

def check_cost_threshold(daily_cost, threshold=100):
    if daily_cost > threshold:
        send_alert(f"Дневные затраты ${daily_cost} превысили ${threshold}")

Продвинутые техники

1. Модели сжатия промптов

Используйте специализированные модели для сжатия промптов:

  • LongLLMLingua
  • AutoCompressors
  • Обученные токены сжатия

Они могут достичь коэффициентов сжатия 10x при сохранении производительности задач на уровне 90%+.

2. Спекулятивное декодирование

Запускайте маленькую модель параллельно с большой для предсказания токенов, уменьшая количество вызовов большой модели. Обычно дает ускорение в 2–3 раза и снижение затрат при сопоставимом качестве.

3. Квантование

Для самостоятельно размещенных моделей квантование (4-bit, 8-bit) снижает потребление памяти и вычислительных ресурсов:

  • 4-bit: ~75% сокращение памяти, минимальная потеря качества
  • 8-bit: ~50% сокращение памяти, незначительная потеря качества

Если вы запускаете LLM локально, Ollama предоставляет отличную платформу для развертывания квантованных моделей с минимальной настройкой. Для выбора оборудования и бенчмарков производительности наше сравнение NVIDIA DGX Spark vs Mac Studio vs RTX-4080 демонстрирует реальную производительность на разных конфигурациях оборудования при запуске больших квантованных моделей.

Чек-лист оптимизации затрат

  • Профилирование текущего использования токенов и затрат по эндпоинтам
  • Аудит промптов на избыточность — удаление лишних слов
  • Внедрение кэширования контекста для статического контента > 1K токенов
  • Настройка маршрутизации моделей (маленькие для простых, большие для сложных задач)
  • Добавление лимитов max_tokens ко всем запросам
  • Реализация кэширования ответов для идентичных запросов
  • Использование Batch API для не срочных рабочих нагрузок
  • Включение стриминга для улучшения UX
  • Оптимизация RAG: меньше фрагментов, лучшее ранжирование
  • Мониторинг с отслеживанием токенов и уведомлениями о затратах
  • Рассмотрение дообучения для повторяющихся задач
  • Оценка меньших моделей (Haiku, GPT-3.5) для классификации

Реальный кейс

Сценарий: Чат-бот поддержки клиентов, 100K запросов/месяц

До оптимизации:

  • Модель: GPT-4 для всех запросов
  • Среднее количество входных токенов: 800
  • Среднее количество выходных токенов: 300
  • Затраты: 100K × (800 × 0.00003 + 300 × 0.00006) = $4,200/месяц

После оптимизации:

  • Маршрутизация моделей: 80% GPT-3.5, 20% GPT-4
  • Кэширование контекста: 70% промптов кэшировано
  • Сжатие промптов: сокращение на 40%
  • Кэширование ответов: 15% попаданий в кэш

Результаты:

  • 85% запросов избежали GPT-4
  • 70% получили скидку за кэш контекста
  • На 40% меньше входных токенов
  • Эффективные затраты: $780/месяц
  • Экономия: 81% ($3,420/месяц)

Полезные ссылки

Заключение

Оптимизация токенов трансформирует экономику LLM от непомерно дорогой к устойчиво масштабируемой. Внедряя сжатие промптов, кэширование контекста, умный выбор моделей и кэширование ответов, большинство приложений достигают снижения затрат на 60–80% без ущерба для качества.

Начните с быстрых побед: проведите аудит промптов, включите кэширование контекста и маршрутизируйте простые задачи на меньшие модели. Ревностно отслеживайте использование токенов — то, что измеряется, оптимизируется. Разница между экономически эффективным приложением LLM и дорогим заключается не в технологии, а в стратегии оптимизации.

Связанные статьи

Подписаться

Получайте новые материалы про системы, инфраструктуру и AI engineering.