ТЕХНИЧЕСКОЕ ЗАДАНИЕ: Рассчитать ROI для fine-tuning vs few-shot

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

Научиться количественно сравнивать экономику двух подходов к адаптации LLM: fine-tuning собственной модели против использования few-shot промптов. Построить модель затрат, учитывающую стоимость обучения, инференса и данных, и определить порог (break‑even point), при котором fine-tuning становится дешевле, чем поточный few-shot.

Ключевой результат Отчёт с расчётами, графиком точки безубыточности и рекомендацией для гипотетического Product‑менеджера.

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

Если нет реальных цен — симулируем:

1. Использовать фиксированные тарифы:
   • Fine‑tuning: a100‑40gb по $2.00/час (on‑demand), время обучения 10 часов.
   • Inference после FT: t4‑16gb по $0.50/час, latency ~0.5 сек, throughput 10 req/сек.
   • API few‑shot: GPT‑4o mini ($0.15/1M input, $0.60/1M output), 3-shot с суммарным промптом ~1500 токенов.
2. Все данные свести в Python‑словарь для переиспользования.

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

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

Этап 1: Определение модели затрат (1 час)

Действия

1. Разделить все затраты на одноразовые (Capex) и операционные (Opex).
2. Для FT:
   • C_ft_fixed = (часы обучения * стоимость GPU/hr) + (часы инженера * ставка)
   • C_ft_var = количество запросов * (время инференса * стоимость GPU/hr / throughput)
3. Для few‑shot:
   • C_fs_var = количество запросов * (токены промпта * цена input + токены ответа * цена output)
   • C_fs_fixed = 0 (нет одноразовых затрат)
4. Реализовать класс CostModel с методами ft_cost(n_requests) и fs_cost(n_requests).

from dataclasses import dataclass

@dataclass
class CostParams:
    # Fine‑tuning
    ft_gpu_cost_per_hour: float = 2.0
    ft_training_hours: float = 10.0
    ft_inference_gpu_cost_per_hour: float = 0.5
    ft_throughput_req_per_sec: float = 10.0
    ft_engineer_hours: float = 40.0
    engineer_rate: float = 100.0
    
    # Few‑shot
    api_input_price_per_1k: float = 0.15 / 1000  # $0.15/1M
    api_output_price_per_1k: float = 0.60 / 1000
    prompt_tokens: int = 1500   # 3-shot
    response_tokens: int = 500   # средний ответ

    def ft_fixed(self) -> float:
        gpu = self.ft_gpu_cost_per_hour * self.ft_training_hours
        eng = self.ft_engineer_hours * self.engineer_rate
        return gpu + eng

    def ft_var_per_req(self) -> float:
        # стоимость одного инференс‑запроса на FT модели
        sec_per_req = 1.0 / self.ft_throughput_req_per_sec
        return sec_per_req * self.ft_inference_gpu_cost_per_hour / 3600

    def fs_var_per_req(self) -> float:
        inp = self.prompt_tokens * self.api_input_price_per_1k
        out = self.response_tokens * self.api_output_price_per_1k
        return inp + out

Ожидаемый результат этапа Рабочий класс с параметрами, посчитаны фиксированные и переменные затраты на один запрос.

Этап 2: Оценка затрат fine‑tuning (2 часа)

Действия

1. Детализировать одноразовые затраты:
   • Обучение: 10 часов на A100 → $20.
   • Подготовка данных: 20 часов инженера → $2000.
   • Развёртывание и тестирование: 20 часов → $2000.
   • Итого: $4020.
2. Переменные затраты на инференс:
   • При throughput 10 req/сек и GPU $0.50/час → $0.000014 за запрос (пренебрежимо мало).
3. Записать всё в таблицу Cost breakdown FT:

4. Учесть, что в реальности может потребоваться несколько итераций обучения — заложить +20% на эксперименты.

Ожидаемый результат этапа Полная смета FT с диапазоном (optimistic / pessimistic).

Этап 3: Оценка затрат few‑shot (1 час)

Действия

1. Рассчитать стоимость одного запроса через API:
   • Промпт: 3 примера по 500 токенов каждый + инструкция = 1500 токенов input.
   • Ответ: 500 токенов output.
   • По ценам GPT‑4o mini: input = 1500 * $0.15/1M = $0.000225; output = 500 * $0.60/1M = $0.0003.
   • Итого за запрос: $0.000525.
2. Зафиксировать, что нет fixed cost, но есть лимит на количество запросов в минуту (rate limit) — не учитываем в деньгах, но можно упомянуть.
3. Сравнить с FT‑вариантом: у FT переменная стоимость в 37 раз меньше ($0.000014 vs $0.000525).

Ожидаемый результат этапа Понятная цифра cost per request для few‑shot.

Этап 4: Построение break‑even анализа (1.5 часа)

Действия

1. Создать массив объёмов запросов: n_requests = np.logspace(4, 7, 100) (от 10K до 10M).
2. Вычислить полные затраты:
   • total_ft = ft_fixed + ft_var_per_req * n_requests
   • total_fs = fs_var_per_req * n_requests
3. Найти точку пересечения: решить уравнение ft_fixed + ft_var * n = fs_var * n → n = ft_fixed / (fs_var - ft_var).
4. Построить график (логарифмическая шкала по X).
5. Добавить сценарии чувствительности: изменение стоимости GPU, зарплаты инженера, размера few‑shot (k=1, k=5).

import numpy as np
import matplotlib.pyplot as plt

# параметры из Этапа 1
params = CostParams()
ft_fixed = params.ft_fixed()
ft_var = params.ft_var_per_req()
fs_var = params.fs_var_per_req()

n = np.logspace(4, 7, 200)
total_ft = ft_fixed + ft_var * n
total_fs = fs_var * n

# break‑even
n_be = ft_fixed / (fs_var - ft_var)
print(f"Break‑even: {n_be:.0f} запросов")

plt.figure(figsize=(10,6))
plt.loglog(n, total_ft, label='Fine‑tuning')
plt.loglog(n, total_fs, label='Few‑shot')
plt.axvline(n_be, color='red', linestyle='--', label=f'BE = {n_be:.0f}')
plt.xlabel('Количество запросов')
plt.ylabel('Общая стоимость ($)')
plt.legend()
plt.grid(True)
plt.title('Сравнение стоимости: Fine‑tuning vs Few‑shot')
plt.show()

Ожидаемый результат этапа График и числовое значение порога (break‑even point). Например: ~7.8 млн запросов — FT дешевле.

Этап 5: Оформление отчёта и рекомендация (1 час)

Действия

1. Подготовить Jupyter Notebook с чистыми ячейками, текстовыми пояснениями, таблицами и графиком.
2. Написать резюме:
   • При < 7.8M запросов/мес выгоднее few‑shot.
   • При > 7.8M запросов/мес FT окупается за счёт низкой переменной стоимости.
3. Указать, что порог может смещаться при изменении:
   • стоимости GPU (падение → FT выгоднее раньше),
   • количества shot (больше примеров → few‑shot дороже),
   • цены API (рост → FT выгоднее).
4. Экспортировать Notebook в PDF/HTML.

Ожидаемый результат этапа Финальный отчёт, готовый к презентации.

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

• Модель затрат реализована в коде (Python класс) и покрывает обе стратегии.
• Все цены явно указаны с источниками (ссылки на pricing pages или обоснование симуляции).
• Break‑even точка рассчитана аналитически и подтверждена графически.
• Как минимум один сценарий чувствительности (изменение одного параметра) показан на отдельном графике.
• Отчёт (Notebook) содержит текстовое резюме для Product‑менеджера.
• Код воспроизводим: при запуске Restart & Run All не возникает ошибок.

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

• Основной артефакт Jupyter Notebook (.ipynb) со следующими разделами:
  1. Параметры и допущения.
  2. Расчёт fixed cost для FT.
  3. Расчёт variable cost для FT и few‑shot.
  4. График break‑even.
  5. Анализ чувствительности.
  6. Выводы и рекомендация.
• Дополнительно Экспортированный PDF‑отчёт (10–15 страниц) с пояснениями.

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

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

Примечание: Для первого раза может потребоваться до 10 часов из‑за необходимости уточнять цены и отлаживать код.

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

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

• Я явно указал все параметры и их источник (реальный или симулированный).
• Я реализовал класс CostModel с методами, а не только разовые формулы.
• Я построил хотя бы один график с break‑even point.
• Я написал резюме на русском языке, понятном менеджеру.
• Я проверил, что код выполняется без ошибок от начала до конца.