Конспект 7: Cost Optimization для LLM

Сценарий 1: Without optimization
- 100,000 запросов/день
- Средний размер: 500 токенов на запрос
- Цена GPT-4: $0.00003 за input
- Дневной расход: 100K × 500 × $0.00003 = $1,500
- Месячный расход: $45,000
- Годовой расход: $540,000 ❌

Сценарий 2: With optimization (50% экономия)
- Те же 100K запросов
- Optimized prompts, caching, model selection
- Дневной расход: $750
- Месячный расход: $22,500
- Годовой расход: $270,000 ✅
- Сэкономлено: $270,000

LLM Costs:
├─ API calls (основной расход)
│  ├─ Input tokens
│  ├─ Output tokens
│  └─ Streaming/batch
│
├─ Infrastructure (если self-hosted)
│  ├─ GPU/TPU
│  ├─ Memory
│  ├─ Storage
│  └─ Bandwidth
│
├─ Data processing
│  ├─ Embedding generation
│  ├─ Vector DB
│  └─ Retrieval
│
└─ Operations
   ├─ Monitoring
   ├─ Logging
   └─ Support

Cost Per Request: $0.001 - $0.10
Cost Per User: $0.01 - $1.00/месяц
Cost Per Token: $0.00001 - $0.001
Efficiency Ratio: (Tokens used) / (Tokens charged)

GPT-4 Turbo (December 2024):
- Input: $0.01 per 1K tokens
- Output: $0.03 per 1K tokens

GPT-3.5-turbo:
- Input: $0.0005 per 1K tokens
- Output: $0.0015 per 1K tokens

Claude 3 Opus:
- Input: $0.015 per 1K tokens
- Output: $0.075 per 1K tokens

Gemini 1.5 Pro:
- Input: $0.0035 per 1K tokens
- Output: $0.0105 per 1K tokens

Open source (self-hosted):
- $0 API, но затраты на GPU

Документ: 2000 слов = ~2600 токенов
Промпт системы: 500 токенов
Total на запрос: 3100 input токенов
Резюме: ~300 output токенов

100 документов:
- Input: 100 × 3100 = 310,000 токенов
- Output: 100 × 300 = 30,000 токенов
- Цена (GPT-4): (310K × $0.01 + 30K × $0.03) / 1000 = $3.10 + $0.90 = $4.00

Оптимизация 1: Разбить документ на чанки (500 слов каждый)
- 2000 слов = 4 чанка
- Промпт для чанка: 200 токенов (компактнее)
- Input на чанк: 200 + 650 = 850 токенов
- Резюме чанка: 75 токенов

Оптимизация 2: Использовать GPT-3.5-turbo вместо GPT-4
- Цена за чанк: (850 × $0.0005 + 75 × $0.0015) / 1000 = $0.000425 + $0.0001125 = $0.0005375
- 4 чанка × 100 документов = 400 запросов
- Цена: 400 × $0.0005375 = $0.215

Оптимизация 3: Кэширование промпта
- Промпт системы кэшируется (переиспользуется 400 раз)
- Экономия: 200 × 400 × $0.0005 / 1000 = $0.04

Итого: $0.215 - $0.04 = $0.175 (вместо $4.00)
Экономия: 95.6% 🎉

OpenAI: https://platform.openai.com/account/billing/overview
- Daily cost breakdown
- Model usage
- Usage limits

Azure OpenAI: Azure Portal
- Detailed cost analysis
- Forecasting

Google Vertex AI: Google Cloud Console
- Per-request cost
- Billing alerts

Helicone - LLM observability
DeepLake - Data management
Wandb - Experiment tracking

                    Качество (Q)
                        ↑
                        |
           Gemini 1.5 Pro│
      GPT-4 Turbo ●      │  ●
                  │      │
     Claude 3 Op  │      │
                  │      │
      GPT-3.5 ●──┼──────┼─ Llama 2 (self-hosted)
                  │      │
   Mistral 7B ●   │      │
                  │      │
      ├─────────────────────→ Стоимость ($)
                  Low   High

Используй когда:
✅ Нужна максимальная точность
✅ Сложные reasoning задачи
✅ Требуется глубокое понимание
✅ Проблемы стоимости не критичны

Не используй если:
❌ Нужна быстрая обработка большого объема
❌ Бюджет ограничен
❌ Задача простая (классификация)

Используй когда:
✅ Хороший баланс качества и стоимости
✅ Классификация, извлечение сущностей
✅ Генерация текста среднего качества
✅ Большой объем запросов

Не используй если:
❌ Нужна максимальная точность
❌ Сложный reasoning
❌ Требуется контекст >4K токенов

Используй когда:
✅ Длинные контексты (200K токенов)
✅ Обработка больших документов
✅ RAG системы
✅ Требуется честность и безопасность

Не используй если:
❌ Бюджет очень ограничен
❌ Нужна максимальная скорость

Используй когда:
✅ Multimodal (текст + изображения)
✅ Дешевле чем GPT-4
✅ Хорошее качество
✅ Большой контекст

Не используй если:
❌ Требуется максимальная точность

Используй когда:
✅ Очень большой объем (миллионы запросов)
✅ Требуется приватность данных
✅ Нет интернета
✅ Есть свой GPU

Не используй если:
❌ Нужна максимальная точность
❌ Нет своей инфраструктуры
❌ Малые объемы (не окупается)

Запрос
  ↓
[Classifier] - Определить сложность
  ↓
Простой запрос (классификация)?
├─ Да → Использовать GPT-3.5 ($дешево)
│
Средний запрос?
├─ Да → Использовать GPT-4 или Claude
│
Сложный запрос (reasoning)?
└─ Да → Использовать GPT-4 Turbo

Промпт: "Ты разработчик Python. Ответь на вопрос."

Распределение токенов:
- System role: 6 tokens
- Пробелы и пунктуация: 2 tokens
- Слово "разработчик": 1 token
- Слово "Python": 1 token
- Слово "Ответь": 1 token
- Слово "вопрос": 1 token

Total: ~12 tokens

А могло быть: "Dev. Answer q." = ~4 tokens (67% экономия)

❌ БЫЛО (50 токенов):
"Пожалуйста, прочитай внимательно следующий текст 
и выдели из него все имена людей, которые там упоминаются. 
Представь результат в виде списка через запятую. 
Спасибо."

✅ СТАЛО (10 токенов):
"Extract names from text. Format: comma-separated list."

❌ БЫЛО (1000 токенов):
"Вот 10 примеров классификации текстов..."

✅ СТАЛО (100 токенов):
"Examples:
'Great!' → POSITIVE
'Bad' → NEGATIVE
'OK' → NEUTRAL"

❌ БЫЛО (30 токенов):
"Я хочу, чтобы ты проанализировал следующий текст 
и определил, позитивный это или негативный отзыв."

✅ СТАЛО (8 токенов):
"Classify: POSITIVE or NEGATIVE."

❌ БЫЛО:
"User input: {input}
Please analyze the user input: {input}
Based on the input provided: {input}"

✅ СТАЛО:
"Analyze: {input}"

const calculateSavings = (originalTokens, optimizedTokens) => {
  const saved = originalTokens - optimizedTokens;
  const percentageSaved = (saved / originalTokens) * 100;
  const costReduction = percentageSaved / 100; // % of cost saved

  return {
    tokensSaved: saved,
    percentageSaved: percentageSaved.toFixed(1),
    costReduction: costReduction.toFixed(3)
  };
};

// Пример
console.log(calculateSavings(500, 150)); // { tokensSaved: 350, percentageSaved: "70%", costReduction: "0.7" }

Первый запрос:
System Prompt (500 токенов) → полная обработка
User message (100 токенов) → полная обработка
Total input cost: 600 × $0.005 / 1K = $0.003

Второй запрос (тот же системный промпт):
System Prompt (500 токенов) → FROM CACHE (бесплатно!)
User message (100 токенов) → полная обработка
Total input cost: 100 × $0.005 / 1K = $0.0005
Экономия: 83% на input tokens

OpenAI:
- Создание кэша: $0.005 per 1K tokens (5x дороже)
- Использование кэша: $0.001 per 1K tokens (бесплатно практически)

Экономия появляется после:
500 / (0.005 - 0.001) = 125,000 tokens переиспользованных
Или ~250 запросов с одним кэшем

Запрос 1: "Как работает RAG?"
→ Обрабатывается моделью (2 сек)
→ Кэшируется в Redis
TTL: 24 часа

Запрос 2 (идентичный): "Как работает RAG?"
→ Сразу возвращается из кэша (10 мс)
→ Экономия: 100% на этом запросе
→ 200x быстрее

Запрос 3 (похожий): "Объясни RAG"
→ Semantic search в кэше
→ Если match > 95%: используем кэш
→ Иначе: обрабатываем новый запрос

Первый раз:
Text: "Как использовать N8N?"
→ Генерируем embedding (1536 размерность)
→ Стоимость: $0.00002 per token
→ Кэшируем в Qdrant/Pinecone

Второй раз:
Text: "Как использовать N8N?" (идентичный)
→ Берем embedding из кэша
→ Стоимость: $0 ✅
→ Экономия: 100%

❌ Синхронно:
Request 1 → 2s → Response 1
Request 2 → 2s → Response 2
...
Request 100 → 2s → Response 100
Total time: 200 seconds
API calls: 100

Batch: [Request 1, 2, 3, ..., 100]
→ Обработка за ~20-30 секунд
→ API calls: 1
→ Экономия времени: 85%
→ Экономия на API: 99% (batch дешевле)

Batch API pricing:
- 50% discount vs regular API
- Обработка за 5-10 минут

[
  {
    "custom_id": "request-1",
    "method": "POST",
    "url": "/v1/chat/completions",
    "body": {
      "model": "gpt-4-turbo",
      "messages": [{"role": "user", "content": "Question 1"}],
      "max_tokens": 1000
    }
  },
  {
    "custom_id": "request-2",
    "method": "POST",
    "url": "/v1/chat/completions",
    "body": {
      "model": "gpt-4-turbo",
      "messages": [{"role": "user", "content": "Question 2"}],
      "max_tokens": 1000
    }
  }
]

curl https://api.openai.com/v1/batches \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input_file_id": "file-abc123",
    "endpoint": "/v1/chat/completions",
    "timeout_minutes": 240
  }'

✅ Используй batch если:
- Нет спешки (результаты нужны через часы/дни)
- Большой объем (100+ запросов)
- Хочешь сэкономить 50%
- Примеры: отчеты, анализ, переработка данных

❌ Не используй если:
- Нужен ответ в реальном времени
- Запросы зависят друг от друга
- Мало запросов (<10)

Сценарий 1: Cloud API (GPT-3.5)
- Стоимость: 10M × 500 tokens × $0.0005 / 1K = $2,500/год
- Инфраструктура: $0 (управляемый сервис)
- DevOps: 1-2 часа в месяц
- Total: $2,500

Сценарий 2: Local model (Llama 2 13B)
- GPU hardware: $2,000 (amortized за 3 года = $666/год)
- Электричество: 8 GPU × 350W × 24h × 365 × $0.1 = $10,000/год
- Storage: $100/год
- DevOps: 40 часов в месяц (инженер $50/час = $24,000/год)
- Total: $34,766/год

Вывод: Cloud API дешевле в 10x при таких объемах!

Сценарий: 1 миллиард запросов/год

Cloud API:
- $250,000/год

Local model (амортизированная стоимость):
- GPU: $2,000
- Электричество: $10,000
- DevOps: $24,000
- Total: ~$36,000/год

Вывод: Local model выгоднее в 7x при 1 млрд запросов

Total API cost = Hardware cost + Electricity + DevOps

Найти точку, где:
Cloud API cost = Local model cost

Cloud API: $0.0005 per token
Local: $0.00001 per token (если амортизировать)

Нужно: 250M+ tokens/год для окупаемости
или ~500K запросов/день средним размером

Документ (10,000 слов)
→ Один большой чанк
→ Embedding: 13,300 tokens × $0.0001 = $1.33
→ При поиске возвращаем весь чанк
→ В промпт идет 13,300 tokens × $0.0005 = $6.65
Total: $7.98 за один запрос

Документ (10,000 слов)
→ Разбить на чанки 500 слов (20 чанков)
→ Embedding: 650 tokens × $0.0001 = $0.065 per chunk
→ Total embeddings: 20 × $0.065 = $1.30
→ При поиске возвращаем 2-3 релевантных чанка
→ В промпт идет только 2,000 tokens × $0.0005 = $1.00
Total: $2.30 за запрос
Экономия: 71%

Проверки для снижения расходов:
1. Проверка кэша (95% хит рейт)
2. Простые правила (regex, keyword match)
3. Embedding similarity (быстрый фильтр)
4. Только потом: LLM запрос

Результат: 90% запросов решаются без LLM!

Запрос приходит
    ↓
Layer 1 (Классификатор)
- Модель: GPT-3.5 (-80% стоимости)
- Время: 100ms
- Результат: определить, какую модель использовать
    ↓
Layer 2 (Решение)
- Если простой запрос: GPT-3.5
- Если средний: GPT-4
- Если сложный: GPT-4 Turbo
    ↓
Ответ пользователю

Итого экономия: 50-60%

const logCost = async (data) => {
  const tokenCost = {
    model: "gpt-4-turbo",
    inputTokens: data.prompt_tokens,
    outputTokens: data.completion_tokens,
    inputPrice: 0.01 / 1000,  // $0.01 per 1K
    outputPrice: 0.03 / 1000, // $0.03 per 1K
  };

  const cost = 
    data.prompt_tokens * tokenCost.inputPrice +
    data.completion_tokens * tokenCost.outputPrice;

  // Логируем в БД
  await db.costs.insert({
    timestamp: new Date(),
    user_id: data.user_id,
    model: tokenCost.model,
    tokens: data.prompt_tokens + data.completion_tokens,
    cost: cost,
    request_type: data.type
  });

  // Проверяем бюджет пользователя
  const dailySpend = await db.costs.sum('cost', {
    user_id: data.user_id,
    date: today
  });

  if (dailySpend > 10) { // $10 лимит
    await sendAlert({
      user_id: data.user_id,
      message: `Daily spend ($${dailySpend}) exceeds limit`
    });
  }
};

Monthly budget: $5,000
├─ Daily budget: $166 (автоматический)
├─ Weekly budget: $1,190 (промежуточный)
└─ Alert thresholds:
   ├─ 50% threshold: Alert WARN
   ├─ 80% threshold: Alert CRITICAL
   └─ 100% threshold: Pause API access

SELECT 
  DATE_TRUNC('day', timestamp) as date,
  model,
  COUNT(*) as requests,
  SUM(inputTokens) as input_tokens,
  SUM(outputTokens) as output_tokens,
  SUM(cost) as daily_cost,
  ROUND(AVG(latency_ms), 2) as avg_latency
FROM request_logs
WHERE timestamp >= CURRENT_DATE - INTERVAL '7 days'
GROUP BY date, model
ORDER BY date DESC;

- 50K блогов генерируются в месяц
- Каждый блог: 3000 слов
- Модель: GPT-4 (без оптимизаций)
- Расход: $150K/месяц 😱

До: $150K/месяц
После: $150K × 0.4 × 0.85 × 0.5 × 0.8 = $20.4K/месяц
Экономия: $129.6K/месяц (86%) 🎉

- 10K вопросов в день
- Модель: GPT-4-turbo
- Расход: $500/день

До: $500/день = $150K/год
После: $500 × 0.4 × 0.35 × 0.6 × 0.5 = $21/день = $7.7K/год
Экономия: $142.3K/год (95%) 🚀

☑️ Проанализирован текущий расход
☑️ Выбрана оптимальная модель (не GPT-4 для всего)
☑️ Промпты оптимизированы (убрано лишнее)
☑️ Реализовано кэширование (prompts, responses, embeddings)
☑️ Настроен rate limiting (контроль объемов)
☑️ Включен мониторинг расходов (real-time alerts)
☑️ Рассмотрен batch processing (для асинхронных задач)
☑️ Проверена эффективность (токены / качество)
☑️ Установлены бюджетные лимиты (по пользователю/дню)
☑️ Документированы решения (почему выбраны такие модели)