Как считать деньги и секунды, когда модель работает не на десяти, а на тысячах запросов. Пять ступеней: за что именно берут плату, откуда берётся задержка, как кэш одинакового начала запроса снижает цену, как отправлять простые вопросы на дешёвую модель и как обрабатывать большие объёмы, не упираясь в лимиты. Все примеры на Python запускаются без доступа к модели; цены и времена в них условные, учебные — настоящие смотри в прайсе и меряй на своём сервисе.
Все дорожки — /put. Прошлая — как удержать длинный разговор в окне контекста.
Зачем это в работе. Прототип на десяти вопросах почти ничего не стоит, а тот же бот на тысячах пользователей вдруг выставляет счёт, который никто не планировал. Если понимать, за что именно платишь, можно заранее прикинуть бюджет и найти, какая часть запроса съедает деньги, вместо того чтобы гадать после прихода счёта.
Почти все поставщики моделей через программный интерфейс (API) берут плату за токены — куски текста, которыми модель считает длину. Считают отдельно две стороны: входные токены (всё, что ты отправил: инструкция, история, документы, вопрос) и выходные токены (то, что модель написала в ответ). Цену обычно пишут за миллион токенов каждого вида.
Выходные токены, как правило, дороже входных. Причина в устройстве: вход модель читает целиком за один проход, а ответ пишет по одному токену, и каждый шаг — отдельный прогон модели. Поэтому длинный ответ бьёт по цене сильнее, чем такой же по длине вопрос. Точное соотношение цен у каждого поставщика своё, его смотрят в прайсе.
Главная ловушка — вход растёт незаметно. В чате каждый новый запрос несёт с собой всю историю, поэтому двадцатая реплика стоит намного дороже первой, хотя пользователь написал всего одну строку. То же с поиском по документам: если подставлять десять найденных кусков вместо трёх, вход вырастает в несколько раз на каждом вопросе.
Отдельная статья — модели с рассуждением (reasoning): перед ответом они пишут скрытые черновые размышления, и эти токены обычно оплачиваются как выходные, хотя ты их не видишь. Это отличает их от обычной модели, у которой выход равен видимому ответу. Сколько уходит на черновик, видно в поле использования (usage), которое API возвращает вместе с ответом.
Подробный пример. Бот поддержки: инструкция 1500 токенов, история 3000, вопрос 100, ответ 300. Цены в коде выдуманы для учёбы — подставь свои из прайса. Обрати внимание на последнюю строку: если разрешить ответы до 1200 токенов, дневной счёт растёт больше чем в полтора раза, хотя вход не менялся.
# Учебный подсчёт стоимости одного запроса. Цены ВЫДУМАНЫ для примера:
# смотри настоящий прайс своего поставщика.
PRICE_IN = 0.50 # условных единиц за 1 млн входных токенов
PRICE_OUT = 2.00 # за 1 млн выходных токенов
def cost(tokens_in, tokens_out):
return tokens_in / 1e6 * PRICE_IN + tokens_out / 1e6 * PRICE_OUT
# Чат-бот поддержки: инструкция 1500, история 3000, вопрос 100, ответ 300
one = cost(1500 + 3000 + 100, 300)
print(f"один запрос: {one:.6f}")
print(f"10 000 запросов в день: {one * 10_000:.2f}")
# Та же нагрузка, но ответ разрешили растянуть до 1200 токенов
print(f"с длинными ответами: {cost(4600, 1200) * 10_000:.2f}")
Что напечатает:
один запрос: 0.002900
10 000 запросов в день: 29.00
с длинными ответами: 47.00
Где обычно ошибаются.
Входные токены (input tokens). Всё, что ты отправил модели в одном запросе, включая историю и документы.
Выходные токены (output tokens). Всё, что модель написала в ответ; обычно стоят дороже входных.
Цена за миллион токенов. Обычная единица прайса; входные и выходные считаются по отдельности.
Поле использования (usage). Часть ответа API, где написано, сколько токенов реально ушло на вход и выход.
Токены рассуждения (reasoning tokens). Скрытый черновик модели перед ответом, который обычно оплачивается как выход.
Стоимость диалога. Сумма по всем запросам, где каждый раз заново оплачивается накопленная история.
Программный интерфейс (API). Способ вызывать модель из своего кода, где плата идёт за токены, а не подпиской.
Зачем это в работе. Пользователь бросает чат, если пять секунд ничего не происходит, даже когда ответ потом отличный. А в цепочке из нескольких вызовов модели задержки складываются, и агент, который делает пять шагов, отвечает уже не за секунды, а за минуту. Чтобы ускорять, надо знать, какая часть времени куда уходит.
Время ответа делят на две части. Первая — время до первого токена (time to first token, TTFT): запрос стоит в очереди у поставщика, модель читает весь вход, и только потом появляется первое слово. Чем длиннее вход, тем дольше эта часть. Вторая — скорость генерации: сколько токенов в секунду модель выдаёт дальше. Её часто пишут как токены в секунду.
Полное время примерно равно первой части плюс число выходных токенов, делённое на скорость. Отсюда простой вывод: короткий ответ ускоряет сильнее всего. Попросить «ответь в трёх предложениях» часто даёт больше, чем сменить модель.
Потоковая выдача (streaming) — режим, когда ответ приходит кусками по мере написания. Она не делает модель быстрее: полное время то же самое. Но человек видит первые слова через долю секунды и не уходит. Для программы, которой нужен весь ответ целиком (например, разобрать JSON), поток почти ничего не даёт.
Мерить надо на своём сервисе, а не верить чужим таблицам: задержка зависит от нагрузки у поставщика, от времени суток, от длины твоего входа. Пишут в журнал оба числа для каждого запроса и смотрят не на среднее, а на медленный хвост — например, на время, которое не превышают 95 запросов из 100 (95-й перцентиль, p95). Среднее прячет те редкие запросы, на которых пользователи и злятся.
Подробный пример. Учебная модель с условными числами: 0,6 секунды до первого токена и 0,02 секунды на каждый следующий. Видно, что при длинном ответе первая часть почти не важна, всё решает длина.
# Учебная модель задержки: время до первого куска + время на каждый токен ответа.
# Числа условные, их нужно измерить на своём сервисе.
TTFT = 0.6 # секунд до первого токена (чтение входа + очередь)
PER_TOKEN = 0.02 # секунд на каждый выходной токен
for out in (50, 300, 1200):
total = TTFT + out * PER_TOKEN
print(f"ответ {out:>4} токенов: первый кусок через {TTFT} с, весь ответ за {total:.1f} с")
Что напечатает:
ответ 50 токенов: первый кусок через 0.6 с, весь ответ за 1.6 с
ответ 300 токенов: первый кусок через 0.6 с, весь ответ за 6.6 с
ответ 1200 токенов: первый кусок через 0.6 с, весь ответ за 24.6 с
Где обычно ошибаются.
Задержка (latency). Время от отправки запроса до получения ответа.
Время до первого токена (TTFT). Сколько ждать первого слова: очередь плюс чтение всего входа.
Скорость генерации. Сколько выходных токенов модель выдаёт в секунду после начала ответа.
Потоковая выдача (streaming). Ответ приходит кусками по мере написания; ускоряет ощущение, а не работу.
Перцентиль (p95). Время, которое не превышают 95 запросов из 100; показывает медленный хвост.
Медленный хвост. Редкие очень долгие запросы, которые среднее значение скрывает.
Журнал запросов (log). Запись времени, токенов и ошибок каждого вызова, по которой ищут узкие места.
Зачем это в работе. У многих сервисов большая часть запроса одинакова: длинная инструкция, справочник, примеры. Платить за чтение этого текста заново тысячи раз в день — главный источник лишних расходов. Кэш позволяет платить за него один раз полностью, а потом со скидкой и с меньшей задержкой.
Кэш префикса (prompt caching) работает так: поставщик запоминает результат чтения начала запроса. Если следующий запрос начинается точно с того же текста, модель не перечитывает это начало, а берёт готовое. Входные токены из кэша стоят дешевле, и время до первого токена уменьшается, потому что читать надо только новую часть.
Ключевое слово — «точно с того же». Совпадение считается с самого первого токена до первого отличия. Если в начало инструкции вставить текущее время, имя пользователя или случайный номер, совпадение обрывается на первой же строке, и кэш не срабатывает ни разу. Поэтому порядок такой: сначала всё неизменное (инструкция, справочник, примеры), в самом конце — изменчивое (время, история, вопрос).
Правила у поставщиков разные: у одних кэш включается сам при достаточно длинном начале, у других его надо явно пометить в запросе, у кого-то за запись в кэш берут доплату. Кэш живёт ограниченное время и сбрасывается, если запросов долго не было. Точные условия, минимальную длину и скидку смотрят в документации своего поставщика.
Не путай с кэшем ответов у себя: там ты сохраняешь готовый ответ на точно такой же вопрос и вообще не зовёшь модель. Это ещё дешевле, но подходит только для повторяющихся вопросов, где ответ не зависит от времени и человека. Кэш префикса же работает для любых вопросов с общим началом.
Подробный пример. Начало на 6000 токенов одинаково у всех запросов, вопрос — 400. Скидка в коде условная, 90 %. Последняя строка показывает типичную поломку: время в начале инструкции превращает каждый запрос в первый.
# Учебный кэш префикса: одинаковое НАЧАЛО запроса считается дешевле.
# Скидка 90% условная; у разных поставщиков правила свои.
PRICE_IN, CACHED_SHARE = 0.50, 0.10
def cost_in(prefix, rest, cached):
p = prefix * PRICE_IN * (CACHED_SHARE if cached else 1)
return (p + rest * PRICE_IN) / 1e6
prefix = 6000 # инструкция + справочник, одинаковые у всех запросов
rest = 400 # вопрос пользователя
first = cost_in(prefix, rest, cached=False)
later = cost_in(prefix, rest, cached=True)
print(f"первый запрос: {first:.6f}, следующие: {later:.6f}")
# Ошибка: дата в самом начале инструкции ломает совпадение префикса
print("если в начало вставить текущее время, каждый запрос снова как первый:", f"{first:.6f}")
Что напечатает:
первый запрос: 0.003200, следующие: 0.000500
если в начало вставить текущее время, каждый запрос снова как первый: 0.003200
Где обычно ошибаются.
Кэш префикса (prompt caching). Поставщик запоминает прочитанное начало запроса и берёт за него меньше при точном повторе.
Префикс. Начало запроса, совпадающее с предыдущим до первого отличающегося токена.
Попадание в кэш (cache hit). Случай, когда начало совпало и было взято готовым.
Промах кэша (cache miss). Совпадения нет, начало читается и оплачивается полностью.
Время жизни кэша (TTL). Сколько поставщик хранит запомненное начало без новых запросов.
Кэш ответов. Свой склад готовых ответов на точно повторяющиеся вопросы, без вызова модели.
Изменчивая часть. Время, история и вопрос; её ставят в конец, чтобы не ломать совпадение.
Зачем это в работе. Самая сильная модель часто в разы дороже и медленнее маленькой, а большинство вопросов в реальном потоке простые: часы работы, статус заказа, смена пароля. Если всё отправлять на сильную модель, переплачиваешь за то, что справилась бы и дешёвая.
Маршрутизация (routing) — это шаг перед вызовом модели, который решает, куда отправить запрос. Решать можно правилами (длина, ключевые слова, тип задачи), маленькой моделью-классификатором, которая только ставит метку «простой/сложный», или каскадом (cascade): сначала спрашивают дешёвую модель, и если её ответ не проходит проверку, повторяют на сильной.
У каждого способа своё ограничение. Правила дёшевы и понятны, но промахиваются на необычных формулировках. Классификатор сам стоит денег и времени и тоже ошибается. Каскад даёт хорошее качество, но на сложных вопросах платишь дважды и ждёшь дольше. Выбор зависит от того, какая доля вопросов простая и насколько дорога ошибка.
Проверяют маршрутизацию тем же способом, что и любую модель: берут набор реальных вопросов с правильными ответами и сравнивают три варианта — всё на сильной, всё на дешёвой, с маршрутизацией. Смотрят и на качество, и на цену. Без такого набора легко сэкономить, тихо уронив качество на важных вопросах.
Соседнее понятие — дистилляция (distillation): обучение маленькой модели на ответах большой под конкретную задачу. Это долгосрочное решение с отдельной работой по обучению, а маршрутизация — настройка вокруг готовых моделей, которую можно сделать за день.
Подробный пример. Учебное правило: больше 25 слов или слова «договор», «почему», «сравни» — сильная модель, остальное — дешёвая. Стоимость одного ответа условная: 1 и 10.
# Маршрутизация: простые вопросы на дешёвую модель, сложные на дорогую.
# Правило учебное; на практике его проверяют на наборе реальных вопросов.
CHEAP, STRONG = 1.0, 10.0 # условная стоимость одного ответа
def route(q):
hard = len(q.split()) > 25 or any(w in q.lower() for w in ("договор", "почему", "сравни"))
return "strong" if hard else "cheap"
qs = ["Где мой заказ ORD-4412?", "Какие часы работы?",
"Сравни тариф Базовый и Про для команды из пяти человек",
"Почему списали деньги дважды?", "Как сменить пароль?"]
total = 0
for q in qs:
r = route(q); total += STRONG if r == "strong" else CHEAP
print(f"{r:6} | {q}")
print("стоимость с маршрутизацией:", total, "| всё на сильной:", STRONG * len(qs))
Что напечатает:
cheap | Где мой заказ ORD-4412?
cheap | Какие часы работы?
strong | Сравни тариф Базовый и Про для команды из пяти человек
strong | Почему списали деньги дважды?
cheap | Как сменить пароль?
стоимость с маршрутизацией: 23.0 | всё на сильной: 50.0
Заметь слабое место: короткий вопрос «Можно вернуть деньги?» уйдёт на дешёвую модель, хотя может быть спорным. Такие случаи и ищут на проверочном наборе.
Где обычно ошибаются.
Маршрутизация (routing). Шаг, который решает, на какую модель отправить конкретный запрос.
Классификатор. Маленькая модель или правило, которое только ставит метку запросу.
Каскад (cascade). Сначала дешёвая модель, при неудачной проверке — повтор на сильной.
Дешёвая модель. Меньшая и быстрая модель для простых массовых вопросов.
Сильная модель. Дорогая и медленная модель для сложных и спорных случаев.
Дистилляция (distillation). Обучение маленькой модели на ответах большой под одну задачу.
Компромисс цена–качество. Выбор, сколько качества готов отдать ради экономии, проверяемый на наборе.
Зачем это в работе. Разметить тысячу отзывов, пересказать архив писем, проверить каталог — такие задачи по одному запросу за раз идут часами. Но если просто запустить всё сразу, поставщик начнёт отказывать с ошибкой превышения лимита, и половина результатов потеряется.
Параллельность (concurrency) — несколько запросов в полёте одновременно. Модель на стороне поставщика обслуживает их независимо, поэтому общее время падает почти пропорционально числу одновременных запросов. Это работает, пока не упрёшься в лимит скорости.
Лимит скорости (rate limit) — сколько запросов или токенов в минуту тебе разрешено. При превышении приходит ошибка с кодом 429 «слишком много запросов». Правильная реакция — повторить через паузу, которая растёт с каждой неудачей: одна секунда, две, четыре. Это называется экспоненциальная пауза (exponential backoff). Мгновенный повтор только усугубляет перегрузку.
Пакетная обработка (batch API) — отдельный режим у многих поставщиков: ты загружаешь файл со всеми запросами сразу, а результаты забираешь позже, в пределах оговорённого срока. Обычно это дешевле обычных вызовов и не упирается в обычные лимиты, но ответ не мгновенный. Подходит для ночной разметки, не подходит для чата. Условия и скидку смотрят в документации.
Важная деталь для любой массовой работы — сохранять результат каждого запроса сразу, с номером исходной записи. Тогда сбой на семисотом документе не заставит повторять первые шестьсот девяносто девять, а повторный запуск возьмёт только недостающие.
Подробный пример. Тысяча документов по условные 2 секунды. Параллельность сокращает время, но лимит в 60 запросов в минуту ставит нижнюю границу, ниже которой не опуститься никаким числом потоков.
# Пакетная обработка против последовательной: учебный подсчёт времени.
import math
N, ONE = 1000, 2.0 # 1000 документов, 2 секунды на запрос (условно)
print(f"по одному: {N*ONE/60:.0f} мин")
for par in (5, 20):
print(f"по {par} параллельно: {math.ceil(N/par)*ONE/60:.1f} мин (если лимит скорости позволяет)")
# Лимит: допустим, 60 запросов в минуту
LIMIT = 60
print(f"но при лимите {LIMIT} запросов/мин не быстрее {N/LIMIT:.0f} мин")
Что напечатает:
по одному: 33 мин
по 5 параллельно: 6.7 мин (если лимит скорости позволяет)
по 20 параллельно: 1.7 мин (если лимит скорости позволяет)
но при лимите 60 запросов/мин не быстрее 17 мин
Где обычно ошибаются.
Параллельность (concurrency). Сколько запросов отправлено одновременно и ещё ждут ответа.
Лимит скорости (rate limit). Разрешённое число запросов или токенов в минуту.
Ошибка 429. Ответ «слишком много запросов», когда лимит превышен.
Экспоненциальная пауза (exponential backoff). Повтор после ошибки с паузой, которая растёт вдвое при каждой неудаче.
Пакетная обработка (batch API). Загрузка многих запросов файлом с ответом позже, обычно дешевле.
Возобновляемый запуск. Обработка, которая после сбоя доделывает только недостающие записи.
Пропускная способность (throughput). Сколько запросов система успевает выполнить за единицу времени.