ТЕХНИЧЕСКОЕ ЗАДАНИЕ: Рассчитать cost per 1M tokens для разных моделей

1. Цель задачи

Научиться прагматично сравнивать LLM-модели по стоимости, латентности и качеству для выбора оптимального провайдера/конфигурации. Выполнить расчёт cost per 1M токенов для GPT-4 (OpenAI), Claude (Anthropic) и Llama-3 (self-hosted), дополнительно измерив latency и упрощённую метрику качества ответа. Итогом станет таблица, позволяющая принимать обоснованные инженерные и бизнес-решения при выборе модели для продакшн-сценария.

Ключевой результат Сравнительная таблица model | cost_per_1M_input_tokens | cost_per_1M_output_tokens | avg_latency_per_request | quality_score, сопровождаемая коротким отчётом с рекомендациями.

2. Исходные данные

Если нет реального инструмента — симулируем:

1. Нет GPU для Llama-3 — используем бесплатные инференс-сервисы (Hugging Face Inference API со свободным лимитом) или эмулируем latency фиксированной задержкой (например, 500 мс) и cost на основе документации Hugging Face (0.0001 $/токен).
2. Нет API-ключей — берём публичные цены из статей OpenAI/Anthropic (например, GPT-4 input: $10/1M токенов, output: $30/1M) и для latency используем типичные значения из бенчмарков (2–5 сек).
3. Нет датасета — используем 10 стандартных вопросов из открытого набора MMLU (первые строчки).

3. Технологический стек

4. Этапы выполнения

Этап 1: Подготовка окружения и сбор данных о ценах (30 мин)

Действия

1. Установи зависимости

pip install openai anthropic transformers accelerate bitsandbytes vllm tiktoken sentence-transformers pandas matplotlib tenacity

2. Получи актуальные цены из официальной документации:

   • OpenAI: https://openai.com/pricing (gpt-4-0125-preview: input $10/1M, output $30/1M)
   • Anthropic: https://www.anthropic.com/pricing (claude-3-opus: input $15/1M, output $75/1M)
   • Llama-3 self-hosted: рассчитай стоимость GPU-часа (например, g5.xlarge ~ $1.006/час) и throughput в токенах/сек. Упрощённо: cost_per_token = (GPU_cost_per_hour) / (tokens_per_hour). Для 8B модели на RTX 4090 throughput ~5000 токенов/с => 18 млн токенов/час => cost ≈ $0.055/1M (при $1/час).

3. Подготовь тестовый набор промптов (prompts.json):

[
  {"id": 1, "prompt": "Объясни концепцию REST API простыми словами.", "max_tokens": 200},
  {"id": 2, "prompt": "Напиши функцию на Python для поиска дубликатов в списке.", "max_tokens": 150},
  ...
]

Ожидаемый результат этапа

• Файл data/prices.csv с ценами (модель, input_price, output_price).
• Файл data/prompts.json с 15–20 тестовыми запросами.
• Проверенное подключение ко всем API.

Этап 2: Реализация клиентов и бенчмарк-раннера (1.5 ч)

Действия

1. Создай модуль benchmark.py с классами для каждой модели.

   • Общий интерфейс: async def generate(prompt: str, max_tokens: int) -> dict{response, latency, input_tokens, output_tokens}.
   • Для GPT-4 используй openai.AsyncClient.
   • Для Claude используй anthropic.AsyncAnthropic.
   • Для Llama-3 (self-hosted) используй vLLM (запустить сервер командой python -m vllm.entrypoints.openai.api_server --model meta-llama/Meta-Llama-3-8B-Instruct --api-key token-abc123). Клиент — openai с base_url=http://localhost:8000.

2. Напиши раннер, который выполняет все промпты для каждой модели:

async def run_benchmark(models, prompts):
    results = []
    async for model in models:
        for p in prompts:
            try:
                res = await model.generate(**p)
                results.append({**p, **res, "model": model.name})
            except Exception as e:
                print(f"Error {model.name}: {e}")
    return results

• Добавь tenacity.retry(stop=stop_after_attempt(3), wait=wait_exponential()).
• Замеряй latency с помощью time.monotonic() до и после вызова.

3. Подсчитай токены на стороне клиента (через tiktoken / claude token counter / transformers.AutoTokenizer).
   Убедись, что число токенов совпадает с ответом API (допустимо расхождение ≤ 2%).

Ожидаемый результат этапа

• Модуль benchmark.py, который запускается командой python benchmark.py и сохраняет сырые замеры в data/raw_results.json.

Этап 3: Расчёт стоимости, латентности и агрегация (1 ч)

Действия

1. Загрузи raw_results.json и цены из prices.csv.

2. Для каждого запроса рассчитай

   • cost_input = input_tokens * input_price_per_token
   • cost_output = output_tokens * output_price_per_token
   • total_cost = cost_input + cost_output
   • cost_per_1M_input = input_price_per_token * 1_000_000
   • cost_per_1M_output = output_price_per_token * 1_000_000

3. Агрегируй по модели

   • Средняя латентность (медиана, p95, p99).
   • Средний cost per request.
   • Средний cost per 1M input/output tokens (уже константа для модели).

4. Формат таблицы (Pandas DataFrame):

model | avg_latency_ms | p95_latency_ms | cost_per_1M_input | cost_per_1M_output | avg_cost_per_request | throughput_tps

Ожидаемый результат этапа

• Файл data/aggregated_costs.csv.

Этап 4: Измерение качества ответов (2 ч)

Действия

1. Выбери метрику качества
   Используй эмбеддингное сходство с эталонным ответом (reference answer). Если эталона нет — возьми один из ответов (например, GPT-4) как "золотой стандарт" или используй LLM-as-judge (требует дополнительный вызов — для упрощения используем cosine similarity).

2. Реализуй оценку

   • Загрузи sentence-transformers/all-MiniLM-L6-v2.
   • Для каждого ответа получи эмбеддинг.
   • Вычисли cosine similarity с эмбеддингом эталона (для каждого вопроса эталон — ответ одной из моделей, скажем GPT-4).
   • Среднее значение по всем вопросам — качество модели (от 0 до 1).

model_st = SentenceTransformer('all-MiniLM-L6-v2')
def quality_score(responses, references):
    sims = []
    for r, ref in zip(responses, references):
        emb_r = model_st.encode(r)
        emb_ref = model_st.encode(ref)
        sims.append(cosine_similarity([emb_r], [emb_ref])[0][0])
    return np.mean(sims)

3. Добавь столбец quality_score в итоговую таблицу.

Ожидаемый результат этапа

• Обновлённая таблица с качеством.
• Артефакт: data/final_comparison.csv со всеми метриками.

Этап 5: Построение отчёта и визуализация (45 мин)

Действия

1. Создай итоговую таблицу в читаемом формате (Markdown): | Модель | Cost/1M input | Cost/1M output | Avg latency (ms) | P95 latency (ms) | Quality score | |--------|---------------|----------------|------------------|------------------|---------------| | GPT-4 | $10.00 | $30.00 | 2800 | 4500 | 0.92 | | Claude | $15.00 | $75.00 | 3200 | 5100 | 0.95 | | Llama-3 self-hosted | $0.055 | $0.055 | 850 | 1200 | 0.88 |

2. Построй scatter plot (cost_per_request vs quality) и столбчатую диаграмму latency на каждой модели.

3. Напиши рекомендательный вывод (2–3 предложения):

   • Какая модель лучше для чат-бота (низкая латентность, приемлемое качество).
   • Какая для высококачественного анализа (высокая стоимость, но лучший quality).
   • Точка окупаемости self-hosted при большом объёме.

Ожидаемый результат этапа

• Файл report.md с таблицей, графиками (PNG/PDF) и выводами.

5. Критерии приемки (Definition of Done)

• Выполнены все 5 этапов, получены артефакты data/raw_results.json, data/aggregated_costs.csv, data/final_comparison.csv, report.md.
• В report.md присутствует таблица с cost per 1M input/output, latency (avg, p95) и quality score для каждой из трёх моделей.
• Стоимость self-hosted рассчитана на основе real GPU-часов (если использовался собственный инференс) или симулирована с указанием источника.
• Качество ответов оценено через эмбеддингное сходство (cosine) с единым эталоном; метод описан в отчёте.
• Для каждой модели выполнено минимум 10 разнородных промптов; результаты усреднены.
• Латентность включает время network round-trip (для API) или чистое время инференса (для self-hosted) — оговорено в отчёте.
• Код benchmark.py воспроизводим: содержит seed для промптов, поддерживает параметры --model (выбор одной модели), корректно обрабатывает ошибки (timeout, rate limit).
• Итоговая таблица согласована: суммарная стоимость за 1M токенов для self-hosted не противоречит расчётам throughput (например, не дешевле 0.001 $/1M, если только не используется free-tier).
• Графики сохранены в папку figures/.
• Отчёт содержит явную рекомендацию: какая модель лучше для какого сценария.

6. Ожидаемый результат

Основной артефакт

• report.md — сводная таблица cost/latency/quality, 2–3 графика (cost vs quality, latency per model), краткий вывод-рекомендация.

Вспомогательные файлы

• data/raw_results.json — полные замеры по каждому запросу.
• data/final_comparison.csv — агрегированная таблица в машиночитаемом формате.
• figures/cost_vs_quality.png, figures/latency_bar.png.

Опционально

• Скрипт visualize.py для генерации графиков.
• Docker-образ для окружения (если использовался self-hosted vLLM).
• Блокнот Jupyter analysis.ipynb с пошаговыми расчётами.

7. Возможные сложности и их решение

8. Бюджет времени (оценка)

Примечание Для первого раза, включая отладку и поиск проблем, закладывайте до 8 часов. Использование готового раннера (например, из референсных проектов) может сократить этап 2 вдвое.

9. Связанные вопросы из базы знаний

10. Чек-лист самопроверки

• Я зафиксировал версии моделей (exact model ID) и дату тестирования в отчёте.
• Я убедился, что cost per 1M tokens для GPT-4 и Claude совпадает с официальным прайсингом на момент выполнения.
• Для self-hosted я указал тип GPU, часовую стоимость и полученный throughput (tokens/sec).
• Все замеры latency выполнены асинхронно, с учётом времени на сеть; для self-hosted учтено время инференса без prefill (если vLLM).
• Я использовал одинаковый промпт и max_tokens для всех моделей (разве что self-hosted может генерировать до заполнения контекста).
• В таблице качества указано, какой ответ использовался в качестве эталона (например, GPT-4).
• Я протестировал код на минимальном наборе (2 промпта) до полного прогона.
• Отчёт содержит воспроизводимую команду запуска: python benchmark.py --models gpt4,claude,llama --prompts data/prompts.json.
• Я сохранил seed для генерации промптов, чтобы результаты можно было перепроверить.