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

Сократите затраты на LLM на 80% благодаря умной оптимизации токенов

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

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

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

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

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

Прежде чем приступать к оптимизации, необходимо понять, как работают токены и ценообразование у разных поставщиков 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: {имя, возраст, профессия}
Текст: [вход]

3. Оптимизация обучения с небольшим количеством примеров

Примеры с небольшим количеством данных мощные, но дорогие. Оптимизируйте их:

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

Для большего количества шаблонов оптимизации и синтаксических сокращений на 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% от большинства поставщиков.

OpenAI Batch API

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, без объяснений”

Потоковая передача для лучшего пользовательского опыта

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

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

Retrieval Augmented Generation (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-бит, 8-бит) снижает использование памяти и вычислительных ресурсов:

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

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

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

  • Профилирование текущего использования токенов и затрат на каждый эндпоинт
  • Аудит запросов на избыточность - удаление ненужных слов
  • Реализация кэширования контекста для статического контента > 1K токенов
  • Настройка маршрутизации моделей (маленькие для простых, большие для сложных)
  • Добавление ограничений max_tokens для всех запросов
  • Реализация кэширования ответов для идентичных запросов
  • Использование пакетного 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 и дорогим не в технологии - в стратегии оптимизации.

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