Деньги и компромиссы: API, своя модель или дообучение

Зачем это нужно

Руководитель поддержки маркетплейса просит: «Пусть модель пишет операторам черновики ответов. Сколько это будет стоить? И почему не поставить свою модель — у нас же есть машина с четырьмя видеокартами?» Ответ «своя всегда дешевле» и ответ «API проще» одинаково плохи: оба без чисел. Правильный ответ звучит как «при нашей нагрузке API дешевле вдвое; своя станет выгоднее с такой-то нагрузки; вот риски обоих вариантов».

В следующем уроке, 11.2.1, вы подробно научитесь считать «на салфетке», сколько карт нужно под нагрузку; здесь мы возьмём её результат готовым. Этот урок — про экономику решения поверх такой салфетки: из чего складывается цена, где точка безубыточности, когда подниматься по лестнице «промпт → RAG → дообучение → своя модель», какими рычагами снижать цену и как изложить всё это на одной странице.

Все цены в уроке — условные

Цены API — условный пример, а не прайс конкретного провайдера: 0.30 долл. за 1 млн входных токенов, 0.03 — за 1 млн входных из кэша, 1.20 — за 1 млн выходных, как в уроках 8.1.1 и 11.2.1. Час своей карты — 0.5 долл., как в модуле 11.2 и ДЗ s11-hw04-capacity. Перед настоящим расчётом проверьте актуальные цены у провайдера и посчитайте свой час карты. Важны не числа, а метод.

Из чего складывается стоимость

Статья	API	Свои GPU
Входные токены	цена за 1 млн; попадания в кэш контекста — в разы дешевле	prefill: GPU-секунды на запрос
Выходные токены	цена за 1 млн (в наших условных ценах вчетверо дороже входа)	decode: GPU-секунды на запрос
Железо	—	час карты × число карт × 24 × 30: карты стоят и ночью
Утилизация	платите только за сделанную работу	платите за все часы, а работают карты часть времени
Люди	интеграция, эвал-набор, мониторинг	всё то же плюс обновления драйверов и vLLM, дежурства, ремонт
Риски	рост цены, лимиты, отключение моделей, данные уходят наружу	отказ карты, нехватка мощности в пик

Отсюда главное различие. API — переменные расходыпеременные расходыEN variable costРасходы, пропорциональные объёму: оплата API за токены, аренда GPU по часам под фактическую нагрузку. При малой нагрузке переменные расходы обычно выгоднее постоянных.: нет запросов — нет счёта. Свои карты — постоянные расходыпостоянные расходыEN fixed costРасходы, которые не зависят от объёма работы: свои GPU, их амортизация, дежурства. Чем больше нагрузка, тем меньше их доля на один запрос.: счёт одинаков при любой нагрузке, пока хватает мощности. Поэтому при малой нагрузке выигрывает API, при большой — свои карты. Вопрос только в том, где граница.

Цена одного запроса к API, если $T_{\text{кэш}}$ токенов промпта попали в кэш контекстакэширование контекста (кэш промпта)EN context caching / prompt cachingПровайдер хранит KV-кэш общего префикса запросов и не пересчитывает его; такие «попадания» стоят в разы дешевле. У DeepSeek — «кэш контекста на жёстком диске». провайдера (урок 8.1.1):

$$c_{\text{API}} = \frac{T_{\text{промах}}\, p_{\text{вход}} + T_{\text{кэш}}\, p_{\text{кэш}} + T_{\text{выход}}\, p_{\text{выход}}}{10^6}.$$

Месячный счёт своих карт по схеме из 11.2.1: число карт под пик, умноженное на цену часа и на 720 часов, плюс люди:

$$N = \left\lceil \frac{\text{QPS}_{\text{пик}} \cdot t_{\text{GPU}}}{u_{\max}} \right\rceil, \qquad C_{\text{свои}} = N \cdot p_{\text{час}} \cdot 24 \cdot 30 + C_{\text{люди}}.$$

Здесь $t_{\text{GPU}}$ — GPU-секунды на запрос, $u_{\max} = 0.7$ — запас загрузки.

Откуда берётся «час карты»

Час своей карты — это не цена электричества. Его считают так же, как совокупную стоимость владениясовокупная стоимость владения (TCO)EN total cost of ownershipВсе расходы на решение за срок его жизни, а не только цена покупки или токенов: железо и его амортизация, электричество, место, люди на сопровождение, дежурства, оценка и переобучение, простои., только на час. Пример с допущениями (все числа условные, подставьте свои):

Статья	Допущение	На карту в час
АмортизацияамортизацияEN depreciationРаспределение стоимости купленного оборудования по сроку службы: машина за 36 месяцев «стоит» 1/36 цены в месяц. Входит в цену часа своей карты вместе с электричеством и обслуживанием.	машина с 4 картами — 16 000 долл., срок службы 2 года (17 520 ч): карты и модели быстро устаревают	0.23 долл.
Электричество	под нагрузкой машина берёт около 1.6 кВт (4 × 320 Вт — паспорт штатной RTX 4080, плюс 300 Вт на остальное), охлаждение +30%, 0.12 долл. за кВт·ч	0.06 долл.
Место, сеть, ремонт, время на железо	250 долл. в месяц на машину	0.09 долл.
Итого		≈ 0.38 долл.

С запасом на простой и непредвиденное получается те самые 0.5 долл., которыми считает весь модуль. Заметьте: электричество — самая маленькая статья. Если машина уже куплена, её цена — невозвратные затратыневозвратные затратыEN sunk costДеньги, которые уже потрачены и не вернутся при любом решении (купленная машина). В сравнении вариантов их не учитывают; учитывают будущие расходы и альтернативную стоимость.: при решении «запустить сервис на ней или нет» амортизацию не считают, а считают электричество, обслуживание и альтернативную стоимостьальтернативная стоимостьEN opportunity costЦенность лучшего варианта, от которого отказались. Карта, занятая сервисом, не обучает модели: её «бесплатность» — иллюзия, если на ней стояли бы эксперименты. — карта, занятая сервисом, не обучает ваши LoRA и не гоняет эвалы. «Бесплатная» машина бесплатна, только если она простаивает.

Расчёт: помощник оператора поддержки

Продолжаем обращения в поддержку из урока 11.1.1. Модель пишет оператору черновик ответа.

Параметр	Значение
Нагрузка	40 000 обращений в сутки, пик ×3 (операторы работают днём)
Промпт	1 500 токенов: 600 — инструкции и примеры, общие для всех запросов; 700 — фрагменты базы знаний (RAG); 200 — обращение
Ответ	300 токенов
SLO	TTFT ≤ 2 с, TPOT ≤ 50 мс — как в 11.2.5
Своя модель	Qwen3-8B в BF16 на RTX 4080 32 ГБ (716.8 ГБ/с и 97.5 TFLOPS — паспорт штатной карты, для 32 ГБ это допущение)
Люди на свои GPU	20 ч в месяц по условной внутренней ставке 50 долл./ч = 1 000 долл.

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

API. Без кэша: $(1500 \cdot 0.30 + 300 \cdot 1.20)/10^6 = 0.00081$ долл. за запрос. В месяц: $40\,000 \cdot 30 \cdot 0.00081 = 972$ долл.

Свои карты. По методу из 11.2.1 и 11.2.5 (подробности расчёта — там и в ДЗ s11-hw04-capacity): TPOT ограничивает батч реплики 13 запросами, prefill занимает 0.50 с, шаг decode — 27.7 мс. GPU-секунды на запрос: $0.50 + 300 \cdot 27.7\ \text{мс} / 13 \approx 1.14$ с. Карт: $\lceil 40\,000/86\,400 \cdot 3 \cdot 1.14 / 0.7 \rceil = \lceil 2.27 \rceil = 3$. В месяц: $3 \cdot 0.5 \cdot 720 = 1\,080$ долл. за железо и 1 000 за людей — 2 080 долл.

API дешевле вдвое. Посмотрим, как меняется картина с нагрузкой:

Обращений в сутки	Карт	Свои: железо	Свои: железо + люди	API
10 000	1	360	1 360	243
40 000	3	1 080	2 080	972
100 000	6	2 160	3 160	2 430
300 000	18	6 480	7 480	7 290
500 000	29	10 440	11 440	12 150

Точка безубыточности — это зона

Для фиксированного числа карт точка безубыточноститочка безубыточностиEN break-even pointОбъём нагрузки, при котором два варианта стоят одинаково, например свои GPU (постоянный расход) и API (плата за токены). Ниже точки дешевле API, выше — свои карты, пока им хватает мощности. считается одной формулой, как в ДЗ s11-hw04-capacity: нагрузка, при которой месячный счёт API равен счёту карт. Но карты докупаются целыми, и счёт своих растёт ступеньками. Одна карта держит около 17 600 наших обращений в сутки. Без учёта людей она дешевле API уже на 15 000 обращений, но на 18 000 нужна вторая карта — и свои снова дороже. Такая «пила» тянется до 75 000: только начиная с этой нагрузки свои карты дешевле при любом дальнейшем росте. С людьми граница уходит к 338 000 обращений в сутки — в 8.5 раза дальше текущей нагрузки.

Честная формулировка поэтому такая: «свои карты устойчиво дешевле, начиная с N», а не «точка безубыточности — N». Именно такую функцию вы напишете в практике.

Утилизация — главный множитель

Почему так дорого? Посчитаем среднюю утилизациюутилизация (загрузка) GPUEN GPU utilizationДоля времени, когда оплаченные карты делают полезную работу. Своя карта стоит одинаково и днём, и ночью, поэтому цена токена обратно пропорциональна средней загрузке: при 25% миллион токенов вчетверо дороже, чем при 100%.: в среднем за сутки карты заняты на $40\,000/86\,400 \cdot 1.14 / 3 \approx 18\%$. Ночью операторов нет, а карты оплачены. Цена миллиона выходных токенов своих карт при полной загрузке — около 0.53 долл., при 18% — 3.0 долл.: в 5.7 раза дороже. Для сравнения, API в нашем примере обходится в 2.7 долл. на миллион выходных токенов с учётом входа.

Отсюда два вывода. Первый: интерактивный сервис с дневным пиком — худший случай для своих карт. Второй: ночью свободные карты стоит загрузить пакетной работой — разметкой, суммаризацией архива, переводом. Так делает DeepSeek («Китайский угол» ниже) и так советует платформа из 11.2.5.

Контрпример — пакетный перевод карточек из 11.2.1: 500 000 карточек в сутки, пик всего ×1.5 (очередь сглаживает нагрузку), батч 64 без ограничений по TPOT и 0.30 GPU-секунды на карточку. Там 4 карты и люди — 2 440 долл. в месяц против 8 550 у API, свои в 3.5 раза дешевле, а граница проходит уже на 80 000 карточек в сутки. Одна и та же машина, одни и те же цены — противоположные ответы. Решает профиль нагрузки.

Лестница решений: промпт → RAG → дообучение → своя модель

Прежде чем выбирать, где запускать модель, решите, как приспособить её к задаче. Это две разные оси: открытую модель можно запустить у себя с одним промптом, а дообучить модель — через API провайдера. Ступени второй оси:

flowchart TD
E["Эвал-набор 100–300 примеров<br/>и порог качества"] --> P["1. Промпт<br/>(8.1.2, 8.4.1)"]
P -->|"порог пройден"| OK["Стоп: выкатываем,<br/>следим за качеством"]
P -->|"упёрлись"| Q{"Чего не хватает?"}
Q -->|"знаний: факты компании,<br/>свежие данные"| R["2. RAG<br/>(8.2)"]
Q -->|"поведения: формат, стиль;<br/>промпт слишком длинный"| F["3. Дообучение: LoRA, SFT<br/>(6.1–6.2)"]
R -->|"знания есть,<br/>поведения нет"| F
F -->|"нужной способности нет<br/>ни у одной открытой модели"| O["4. Своя модель:<br/>дообучение претрейна или с нуля"]

Каждая ступень — только после того, как предыдущая измерена на эвал-наборе и упёрлась в потолок

Ступень	Разовые затраты	Постоянные затраты	Когда переходить дальше
Промпт	дни инженера, эвал-набор	токены: длинный промпт оплачивается в каждом запросе	3–5 итераций промпта не дают порога на эвал-наборе
RAG	конвейер индексации, недели	обновление индекса, эмбеддинги, +700 токенов в каждом промпте, контроль качества поиска	факты находятся, а ответ всё равно не того формата или стиля
Дообучение	1–10 тыс. размеченных примеров (это люди!), GPU-часы, эвал	переобучение при смене базовой модели или данных, обслуживание своей модели	нужной способности нет ни у одной базовой модели
Своя модель	огромные: только финальный прогон DeepSeek-V3 — около 2.79 млн GPU-часов H800, порядка 5.6 млн долл. по аренде, без экспериментов и людей	команда и инфраструктура	—

Три правила, которые экономят месяцы.

1. Ни шагу без эвал-набора. «Промпт не справляется» — это число на эвал-наборе, а не ощущение. Без набора вы не узнаете, помог ли RAG или дообучение (уроки 7.3 и 8.4.2).
2. RAG и дообучение решают разные проблемы. Модель не знает новую политику возвратов — это знания, и дообучение тут плохо помогает: факты меняются каждый месяц, а переобучать каждый месяц дорого. Модель знает, но отвечает простынёй вместо трёх строк — это поведение, и его дешевле один раз выучить, чем каждый раз объяснять в промпте.
3. Дообучение — это ещё и экономия токенов: усвоенные инструкции и примеры больше не нужно отправлять в каждом запросе. В нашем примере промпт сокращается с 1 500 до 600 токенов.

Своя модель «с нуля» для продуктовой задачи почти никогда не окупается: её делают, когда модель — сам продукт или когда нужного языка и домена нет ни в одной открытой модели. Вы прошли этот путь в учебном масштабе (MiniMind, урок 5.6.2) — теперь видно, сколько стоит настоящий.

Компромиссы: качество, задержка, цена

Цену можно снизить, почти всегда чем-то заплатив. Рычаги на нашем примере:

Рычаг	Что даёт в примере	Чем платим	Урок
Кэш общего префикса	API: 0.00081 → 0.000648 долл. за запрос; vLLM: 1.14 → 0.70 GPU-с (600 общих токенов не пересчитываются)	промпт строится «общее — в начало»; кэш живёт ограниченное время	7.1.2, 8.1.1
Точный кэш ответов	минус доля повторов от счёта	только детерминированные запросы и учёт версий; у живых обращений повторов мало	8.4.3
Батчинг	в 11.2.1 батч 64 удешевил карточку в 31 раз	задержка: здесь TPOT ограничил батч до 13	7.1.2
Квантование весов в INT8	1.14 → 0.81 GPU-с, с кэшем префикса 0.70 → 0.49	проверка качества на эвал-наборе	7.2.1
Дообучение вместо инструкций	промпт 1 500 → 600 токенов: API 0.00054 долл., своя INT8 — 0.34 GPU-с	данные, переобучение	6.2
Маленькая модель + каскад	15% запросов к модели, которая вдесятеро дороже: $0.00081 + 0.15 \cdot 0.0081 \approx 0.0020$ долл. вместо 0.0081	p95 задержки (ниже) и качество на границе	11.2.4
Дистилляция	маленькая модель учится на ответах большой; 20 000 примеров от API — около 16 долл.	время на данные и проверку; условия провайдера об обучении на его ответах	6.4.4

Как рычаги двигают границу (люди — 1 000 долл. в месяц, API и своя модель используют одни и те же приёмы):

Вариант	GPU-с на запрос	Карт при 40 тыс.	Свои: железо + люди	API	Свои устойчиво дешевле с
Исходный: BF16, промпт 1 500	1.14	3	1 080 + 1 000	972	≈ 338 тыс. в сутки
+ кэш префикса	0.70	2	720 + 1 000	778	≈ 182 тыс.
+ INT8	0.49	1	360 + 1 000	778	≈ 126 тыс.
Дообучение (промпт 600), INT8	0.34	1	360 + 1 000	648	≈ 129 тыс.

Почему INT8 так сильно сдвигает границу: шаг decode упирается в чтение весов из памяти (урок 7.1.1), а веса в INT8 вдвое легче — шаг короче, батч под тот же TPOT больше. Цена — проверка качества квантованной модели на эвал-наборе (7.2.1).

Видно, что при 40 тысячах обращений своё железо можно ужать до одной карты (360 долл. против 778 у API), но 1 000 долл. на людей всё равно делают API выгоднее. На малом масштабе решают люди, а не GPU.

Каскад и p95. Пусть маленькая модель отвечает за 4 с, а большая — за 9 с, и неуверенные случаи идут ко второй после первой: 13 с. Если к большой модели уходит больше 5% запросов, 95-й перцентиль задержкихвостовая задержка (p95, p99)EN tail latencyЗадержка, которую не превышают 95% или 99% запросов. Среднее скрывает медленные запросы, а пользователи помнят именно их. попадает в медленную ветку. При 15% эскалаций p95 ≈ 13 с, и SLOцелевой уровень сервиса (SLO)EN service level objectiveИзмеримая цель, например «p95 TTFT меньше 2 с при 8 пользователях». По ней планируют железо и поднимают тревоги. «p95 ≤ 10 с» нарушен, хотя средняя задержка — 5.4 с. При 4% эскалаций p95 ≈ 5 с. Поэтому SLO проверяют по замерам перцентилей, а не по среднему, — это вторая половина практики.

Задержка своих карт. В нашем расчёте полный черновик идёт $0.50 + 300 \cdot 49.5\ \text{мс} \approx 15$ с — это следствие TPOT 50 мс. Если операторам нужен черновик за 8 с, придётся уменьшать батч, то есть покупать больше карт: требование к задержке — тоже статья расходов.

Как обосновать решение руководителю

Руководитель тратит на документ две минуты и должен выйти с решением. Правила одной страницы:

1. Решение — первой строкой, а не в конце.
2. Цифры — таблицей: варианты по столбцам, статьи расходов по строкам, итог внизу.
3. Допущения — явно и с датой: цены, нагрузка, длины, ставка. Тот, кто не согласен, спорит с допущением, а не с выводом.
4. Чувствительность: что будет, если цена API вырастет вдвое, нагрузка — впятеро, а реальная скорость окажется 60% от салфетки. Решение, которое переворачивается от любого допущения, — не решение, а ставка.
5. Риски с мерами и условие пересмотра: при каком числе вы вернётесь к вопросу.
6. Что нужно: деньги, люди, сроки.

Пример (числа качества и задержки API в нём условные):

# Черновики ответов поддержки: API или своя модель — 06.10.2026

**Решение.** Запускаем через API с кэшем префикса. Свою модель не разворачиваем, пока нагрузка
ниже 100 тыс. обращений в сутки (устойчиво дешевле свои станут со 126 тыс.).

| В месяц, долл.          | API | Свои 4×RTX 4080 (Qwen3-8B INT8) |
|-------------------------|-----|---------------------------------|
| Токены / железо         | 778 | 360 (1 карта)                   |
| Сопровождение           | 0   | 1 000 (20 ч инженера)           |
| Итого                   | 778 | 1 360                           |

**Допущения.** 40 тыс. обращений в сутки, пик ×3; промпт 1 500 токенов (600 общих), ответ 300.
Цены API (условные; в настоящей записке — с сайта провайдера и с датой): 0.30 / 0.03 (кэш) / 1.20 долл.
за 1 млн токенов. Час карты 0.5 долл.

**Качество и задержка.** Эвал-набор 300 обращений: API — 86% приемлемых черновиков [82; 90],
Qwen3-8B — 79% [74; 83]. p95 полного черновика: API 9 с, своя — 16 с; SLO — 20 с.

**Чувствительность.** Цена API ×2 — свои выгоднее с 45 тыс. в сутки: пересмотреть сразу.
Нагрузка ×3 (120 тыс.) — свои дешевле на 11%. Реальная скорость своей модели 60% от расчёта —
граница уходит к 274 тыс.

**Риски.** Персональные данные клиентов уходят провайдеру → маскирование до отправки, договор.
Провайдер меняет или отключает модель → вызов через шлюз, эвал-набор для миграции за день.
Рост нагрузки → ежемесячный пересчёт этой таблицы.

**Пересмотр.** Нагрузка > 100 тыс. в сутки две недели подряд; цена API +50%; запрет передавать данные наружу.
**Нужно.** 800 долл. в месяц и 2 недели инженера на интеграцию и эвал.

Обратите внимание на строку про качество: дешёвый вариант, который не проходит порог качества, — не вариант. Сравнение качества — парным бутстрэпом на одном эвал-наборе (7.3.2). И на строку про риски: отключение моделей — не теория. В уроке 8.1.1 разобрано, как DeepSeek отключила имена deepseek-chat и deepseek-reasoner 24.07.2026, и код, который на них ссылался, перестал работать.

Практика

Соберите калькулятор из этого урока: цена запроса к API с кэшем, число карт под пик, месячный счёт двух вариантов, устойчивая граница безубыточности с учётом «пилы» и выбор самого дешёвого варианта, который укладывается в SLO по p95. Тесты проверяют числа этого урока и пример из 11.2.1. Больше практики с теми же деньгами, но вместе с расчётом мощностей — в ДЗ s11-hw04-capacity модуля 11.2.

Калькулятор: API против своих GPU, граница безубыточности и SLOnumpy · нужен интернет7 тестов

"""Калькулятор стоимости LLM-функции: API против своих GPU, точка безубыточности и проверка SLO.

Все цены — УСЛОВНЫЕ примеры из урока (на 2026-10-06; настоящие смотрите у провайдера на дату расчёта):
API — 0.30 долл. за 1 млн входных токенов, 0.03 за 1 млн входных из кэша, 1.20 за 1 млн выходных;
час своей карты — 0.5 долл. (амортизация, электричество, обслуживание железа).
"""
import math

import numpy as np

SECONDS_PER_DAY = 86_400


def api_cost_per_request(prompt_tokens, output_tokens, price_in, price_out, cached_tokens=0, price_hit=None):
    """Цена одного запроса через API, долл. Цены — за 1 млн токенов.

    cached_tokens — сколько токенов промпта попали в кэш провайдера: они стоят price_hit
    (None — кэша нет, такие токены стоят как обычные). Остальные prompt_tokens − cached_tokens — по price_in.
    api_cost_per_request(1500, 300, 0.30, 1.20) == 0.00081
    """
    # TODO: ваш код
    ...


def gpus_needed(requests_per_day, peak_factor, gpu_seconds_per_request, max_utilization=0.7):
    """Сколько карт держать под пиковую нагрузку (урок 11.2.1).

    Пиковый QPS = requests_per_day / 86 400 · peak_factor; карт = ⌈QPS · GPU-секунды / max_utilization⌉,
    но не меньше одной: даже ночью без запросов сервис должен работать.
    """
    # TODO: ваш код
    ...


def monthly_bill(requests_per_day, api_per_request, *, peak_factor, gpu_seconds_per_request, gpu_hour_price,
                 people_per_month, max_utilization=0.7, days=30):
    """Месячный счёт двух вариантов, долл.

    Возвращает словарь:
      api       requests_per_day · days · api_per_request — платим только за запросы
      gpus      gpus_needed(...)
      hardware  gpus · gpu_hour_price · 24 · days — свои карты оплачиваются круглые сутки
      people    people_per_month — сопровождение своей инфраструктуры
      self      hardware + people
    """
    # TODO: ваш код
    ...


def break_even_load(api_per_request, *, peak_factor, gpu_seconds_per_request, gpu_hour_price, people_per_month,
                    max_utilization=0.7, step=1000, max_requests=2_000_000):
    """Точка безубыточности: наименьшая нагрузка R (запросов в сутки, кратная step), НАЧИНАЯ С КОТОРОЙ свои карты
    не дороже API при любой нагрузке на сетке step, 2·step, …, max_requests.

    Карты докупаются целыми, поэтому стоимость своих растёт ступеньками, и сразу за первой «выгодной» нагрузкой
    свои могут снова стать дороже (нужна ещё одна карта). Поэтому ищем последнюю нагрузку, где свои дороже,
    и берём следующую точку сетки. Если свои дороже даже при max_requests — None.
    """
    # TODO: ваш код
    ...


def latency_p95(latencies_s):
    """95-й перцентиль задержки, с (np.percentile с интерполяцией по умолчанию). Пустой список — ValueError."""
    # TODO: ваш код
    ...


def choose_option(options, slo_p95_s):
    """Самый дешёвый вариант, который укладывается в SLO по p95 задержки.

    options — {имя: {"monthly_cost": долл. в месяц, "latencies": замеры задержки, с}}.
    Вариант проходит, если latency_p95(latencies) <= slo_p95_s. Возвращает имя или None, если не проходит никто.
    """
    # TODO: ваш код
    ...


# Пример урока: помощник оператора поддержки, 40 000 обращений в сутки, промпт 1500 токенов, ответ 300.
api = api_cost_per_request(1500, 300, 0.30, 1.20)
api_cached = api_cost_per_request(1500, 300, 0.30, 1.20, cached_tokens=600, price_hit=0.03)
print("API за запрос:", api, "| с кэшем префикса:", api_cached)
params = dict(peak_factor=3, gpu_seconds_per_request=1.143, gpu_hour_price=0.5, people_per_month=1000)
if api is not None:
    print("счёт за месяц:", monthly_bill(40_000, api, **params))
    print("безубыточность, запросов в сутки:", break_even_load(api, **params))
rng = np.random.default_rng(0)
fast = rng.normal(4.0, 0.5, 850)
slow = rng.normal(13.0, 1.0, 150)
print("p95 каскада, где 15% запросов уходят к большой модели:", latency_p95(np.concatenate([fast, slow])))

ЗапуститьПроверитьПодсказкаСбросить

🖥 На вашей машине (4×GPU)

Замените условные числа своими («Ваша лаборатория»).

GPU-секунды на запрос. Запустите нагрузочный тест vLLM (урок 7.1.2) с длинами своей задачи:

CUDA_VISIBLE_DEVICES=0 vllm serve Qwen/Qwen3-8B --max-model-len 4096 --gpu-memory-utilization 0.90
vllm bench serve --model Qwen/Qwen3-8B --dataset-name random \
  --random-input-len 1500 --random-output-len 300 --num-prompts 300 --max-concurrency 13

Если карта при соблюдении вашего TPOT обслуживает $q$ запросов в секунду, то $t_{\text{GPU}} = 1/q$. Подставьте это число в калькулятор вместо салфеточных 1.14 — и граница безубыточности сдвинется (обычно вправо). Флаги сверяйте с --help своей версии vLLM.

Электричество. Во время теста запишите мощность карт:

nvidia-smi --query-gpu=index,power.draw --format=csv -l 5 > power.csv

Средняя мощность в ваттах × 24 × 30 / 1000 — киловатт-часы в месяц на карту; умножьте на свой тариф. Добавьте мощность процессора и охлаждения (её видно по счётчику или розетке с ваттметром). Получится ваша строка «Электричество» вместо условной.

Китайский угол: как DeepSeek продаёт утилизацию и что проверить в лицензии

Цена кэша и ночные скидки. В отчёте DeepSeek о своей системе инференса (февраль 2025, тот же, что в «Китайском угле» урока 11.2.1) есть цены R1 на момент отчёта: 0.14 долл. за 1 млн входных токенов при попадании в кэш, 0.55 — при промахе, 2.19 — за 1 млн выходных. Попадание почти вчетверо дешевле. За сутки 56.3% входных токенов попали в KV-кэш на дисках, значит средняя цена входа была бы $0.563 \cdot 0.14 + 0.437 \cdot 0.55 \approx 0.32$ долл. — на 42% ниже цены промаха. Для вас это готовое правило: общий префикс — в начало промпта, переменная часть — в конец.

В том же отчёте: днём сервис занимает все узлы, а ночью часть узлов уходит на исследования и обучение, и ночью действуют автоматические скидки. Это ровно раздел «Утилизация» этого урока, только на стороне провайдера: ночная мощность простаивала бы, поэтому её продают дешевле. Пакетные задачи, которые терпят до утра, стоит отправлять ночью — и к провайдеру, и на свои карты.

Лицензия — тоже статья рисков. «Своя модель» в китайской экосистеме чаще всего означает открытые веса, и условия у них разные. В README Qwen3 сказано, что все открытые модели семейства выпускаются под Apache-2.0. У Kimi K3 своя лицензия: если компания продаёт доступ к модели как сервис (Model-as-a-Service) и её выручка вместе с аффилированными лицами больше 20 млн долл. за 12 месяцев, нужно отдельное соглашение с Moonshot AI; продукт со 100+ млн активных пользователей в месяц или выручкой больше 20 млн долл. в месяц должен заметно показывать «Kimi K3». На внутреннее использование эти условия не распространяются, но «внутреннее» лицензия понимает узко: ни модель, ни её ответы не доступны третьим лицам. Помощнику поддержки среднего маркетплейса условия почти наверняка не грозят — это не продажа доступа к модели, а пороги по пользователям и выручке огромны; платформе, продающей API, — критично. Строка «лицензия проверена» обязательна в разделе рисков.

Где учиться разворачивать. Курс self-llm от Datawhale («Инструкция по употреблению открытых больших моделей») собирает рецепты «скачать открытую модель → поднять vLLM → дообучить LoRA» для десятков открытых моделей, в основном китайских. Переводы двух рецептов есть на сайте: Qwen3 и vLLM и LoRA для Qwen3-8B.

Проверь себя

Проверь себя6 вопросов·

1 Запрос: промпт 2 000 токенов, из них 1 500 попали в кэш; ответ 400 токенов. Цены за 1 млн: вход 0.30, кэш 0.03, выход 1.20 долл. Сколько долларов стоят 10 000 таких запросов?

2 При полной загрузке миллион выходных токенов на своих картах стоит 0.53 долл. Сервис работает днём, средняя загрузка карт — 25%. Сколько стоит миллион токенов на самом деле? Округлите до сотых.

3 Одна карта уже дешевле API при 15 000 запросов в сутки. Почему нельзя сказать, что своя инфраструктура выгоднее при любой нагрузке выше 15 000?

Потому что API со временем дешевеетКарты докупаются целыми: при 18 000 нужна вторая карта, и свои снова дороже — граница безубыточности — это зона, а не точкаПотому что при большей нагрузке растёт цена GPU-часаМожно сказать: стоимость своих карт не зависит от нагрузки

4 Помощник поддержки уверенно отвечает по старой политике возвратов: её поменяли месяц назад. Промпт уже выжат. Какая следующая ступень?

Дообучить модель на новой политикеRAG: не хватает свежих знаний, а документы политики можно подставлять в промптОбучить свою модель с нуляПерейти на модель побольше

5 Каскад: маленькая модель отвечает за 3 с, неуверенные случаи (10%) после неё идут к большой модели, ещё 8 с. SLO — p95 задержки не больше 6 с. Выполняется ли SLO?

Да: средняя задержка $3 + 0.1 \cdot 8 = 3.8$ сНет: эскалаций больше 5%, поэтому p95 попадает в медленную ветку — около 11 сДа: 90% запросов укладываются в 3 сНельзя сказать без числа GPU

6 Машина 4×RTX 4080 уже куплена и 80% времени простаивает. Что учитывать в решении «поднять на ней сервис или платить API»? Выберите все.Можно выбрать несколько ответов

электричество и обслуживание под нагрузкойполную амортизацию машины, как если бы её покупали сейчасэксперименты, которые станут ждать, пока карты заняты сервисомвремя инженеров на сопровождение сервиса

Проверить ответы

Итоги

• Цена LLM-функции — это токены (вход, кэш, выход), GPU-часы и их утилизация, люди и риски. API — переменные расходы, свои карты — постоянные: при малой нагрузке выигрывает API, при большой — свои.
• Час своей карты включает амортизацию, электричество и обслуживание; цена токена делится на среднюю загрузку. Интерактивный сервис с дневным пиком загружает карты на 15–20%, пакетная работа — гораздо плотнее.
• Граница безубыточности — зона из-за целых карт; честно говорить «свои устойчиво дешевле, начиная с N». На малом масштабе её отодвигают люди, а не железо.
• Лестница «промпт → RAG → дообучение → своя модель»: следующая ступень — только когда предыдущая упёрлась на эвал-наборе; RAG лечит нехватку знаний, дообучение — поведение и длину промпта. Рычаги экономии (кэш, батчинг, INT8, каскад, дистилляция) всегда чем-то оплачиваются, и SLO проверяют по перцентилям.
• Решение для руководителя — одна страница: решение первой строкой, таблица, допущения с датой, чувствительность, риски, условие пересмотра.

Дальше: урок 11.2.1 — проектирование ML-системы по схеме на 45 минут: от уточнения задачи до мониторинга, с оценками «на салфетке», которые вы только что превратили в деньги.