дорожка · 19.10.2026 · токены

Как модель режет текст на токены и почему русский считается иначе

Модель не видит букв и слов: перед ней стоит программа, которая режет текст на куски из своего словаря и отдаёт модели их номера. От этой нарезки зависят цена запроса, размер окна, странные ошибки с буквами и цифрами и даже одна из атак на чат-ботов. Разберём, что такое токен, как составляют словарь, почему один и тот же смысл стоит по-разному, где нарезка ломает ответы и как правильно считать токены в своём коде. Все числа на странице — наши замеры библиотекой tiktoken на указанных строках, их можно повторить.

Все дорожки — /put. Прошлая — как большая модель помещается в ноутбук.

1 Что такое токен: как модель на самом деле видит текст

Зачем это в работе. Всё, что ты платишь, ждёшь и во что упираешься при работе с моделью, считается в токенах: цена запроса, размер окна контекста, лимит длины ответа, скорость генерации. Если не понимать, что такое токен, невозможно объяснить себе, почему одна и та же просьба на русском стоит больше, чем на английском, почему модель путается в буквах слова и почему пробел в конце подсказки меняет ответ. На прошлых дорожках длину мы считали грубой прикидкой «слова × 1,3»; здесь разберём настоящую программу, которая режет текст.

Модель не умеет читать буквы. Она работает только с целыми числами. Поэтому перед моделью стоит отдельная программа — токенизатор (tokenizer). Она берёт твой текст и разрезает его на куски из заранее составленного списка. Каждый кусок называется токеном (token), а весь список возможных кусков — словарём токенов (vocabulary). У каждого куска в словаре есть номер, и модель получает не текст, а последовательность этих номеров. На выходе всё идёт в обратную сторону: модель выдаёт номер следующего токена, а токенизатор превращает номер обратно в кусок текста.

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

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

Не путай токен с эмбеддингом, о котором была отдельная дорожка. Токен — это кусок текста и его номер. Вектор токена — внутренняя строка таблицы модели для одного куска. Эмбеддинг для поиска — это один вектор на целый абзац или документ, который выдаёт специальная модель, чтобы сравнивать тексты по смыслу.

Подробный пример. Возьмём токенизатор o200k_base из открытой библиотеки tiktoken от OpenAI (в библиотеке он записан как токенизатор GPT-4o) и попросим нарезать слово «привет» в четырёх вариантах. Это замер, его можно повторить: поставь библиотеку командой pip install tiktoken и запусти код.

import tiktoken

enc = tiktoken.get_encoding("o200k_base")
for w in ("привет", " привет", "Привет", "ПРИВЕТ"):
    ids = enc.encode(w)
    print(repr(w), len(ids), [enc.decode([i]) for i in ids])

У нас вышло так: «привет» без пробела — 2 токена (пр + ивет), « привет» с пробелом впереди — 1 токен, «Привет» с большой буквы — 2 токена (Пр + ивет), «ПРИВЕТ» капсом — 4 токена (П, РИ, В, ЕТ). Одно и то же слово для модели оказывается четырьмя разными цепочками чисел. Вариант с пробелом самый короткий, потому что в обычном тексте слово почти всегда стоит после пробела, и токенизатор выучил его целиком именно в таком виде. Капс встречается редко, поэтому режется мельче.

Где обычно ошибаются.

  • Считают, что токен — это слово, и прикидывают длину по числу слов. Для русского текста это даёт большую ошибку, что видно на третьей ступени.
  • Считают токены одной модели токенизатором другой. Числа будут похожими, но не равными, а у моделей разных компаний разница бывает заметной.
  • Забывают, что пробелы, переводы строк и регистр — часть токенов. Текст, отличающийся «только оформлением», для модели — другая последовательность.

Токен (token). кусок текста из словаря модели; модель читает и пишет только такими кусками.

Токенизатор (tokenizer). программа, которая режет текст на токены и переводит их в номера и обратно.

Словарь токенов (vocabulary). фиксированный список всех кусков, которые знает токенизатор, с номером у каждого.

Номер токена (token id). целое число, под которым кусок записан в словаре; именно его получает модель.

Таблица векторов (embedding table). внутренняя таблица модели, где каждому номеру токена соответствует выученный вектор.

tiktoken. открытая библиотека OpenAI на Python, которая режет текст токенизаторами её моделей.

o200k_base и cl100k_base. названия двух словарей в tiktoken: более новый примерно на 200 тысяч кусков и более старый примерно на 100 тысяч.

2 Откуда берётся словарь: склейка частых пар (BPE)

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

Самый распространённый способ составить словарь называется склейкой пар байтов (byte pair encoding, BPE). По шагам он выглядит так. Сначала берут большой корпус текстов — гигабайты того, на чём потом будут учить модель. Весь текст разбивают на самые мелкие единицы: в современных токенизаторах это байты, то есть числа от 0 до 255, которыми компьютер записывает любые символы. Потом считают, какая пара соседних единиц встречается чаще всего, и склеивают её в новую единицу, добавляя в словарь. Снова считают пары, снова склеивают самую частую. И так десятки и сотни тысяч раз, пока словарь не достигнет нужного размера.

Список склеек сохраняется по порядку. Когда токенизатор потом режет твой текст, он повторяет эти склейки в том же порядке. Поэтому итог детерминирован: один и тот же текст одним и тем же токенизатором всегда нарезается одинаково. Никакой «умной» части тут нет, модель в нарезке не участвует.

Почему начинают с байтов, а не с букв. В кодировке UTF-8 латинская буква занимает 1 байт, русская — 2, эмодзи — 4. Если в основе словаря лежат все 256 возможных байтов, токенизатор может закодировать абсолютно любой текст: в худшем случае незнакомый символ распадётся на свои байты. Такой подход называют побайтовым BPE (byte-level BPE). У него есть цена: редкий символ, которого не было в корпусе, превращается в несколько токенов, каждый из которых сам по себе ничего не значит.

Главное ограничение — состав корпуса. Склеиваются частые пары, а частыми они становятся там, где текста много. Если в корпусе мало русского, русские буквы склеятся только в короткие слоги, и русский текст будет длиннее в токенах. Если словарь сделать больше, текст станет короче, но таблица векторов модели вырастет, и редкие токены будут хуже выучены, потому что модель реже их видит. Соседние способы — WordPiece и Unigram (последний часто встречается вместе с библиотекой SentencePiece) — отличаются правилом, какую единицу добавлять в словарь, но идея та же: словарь подбирают по частоте в корпусе, и он фиксируется до обучения модели.

Подробный пример. Склейку можно повторить руками на шести словах. Код ниже берёт строку «кот котик коты кота кит киты», режет её на буквы, ставит в конце каждого слова знак «_» (конец слова) и четыре раза склеивает самую частую пару. При равенстве частот берётся пара, встреченная первой.

from collections import Counter

corpus = "кот котик коты кота кит киты"
words = [list(w) + ["_"] for w in corpus.split()]   # "_" — конец слова

def most_common_pair(words):
    pairs = Counter()
    for w in words:
        for a, b in zip(w, w[1:]):
            pairs[(a, b)] += 1
    return pairs.most_common(1)[0] if pairs else None

def merge(words, pair):
    a, b = pair
    out = []
    for w in words:
        new, i = [], 0
        while i < len(w):
            if i + 1 < len(w) and w[i] == a and w[i + 1] == b:
                new.append(a + b); i += 2
            else:
                new.append(w[i]); i += 1
        out.append(new)
    return out

for step in range(1, 5):
    (pair, count) = most_common_pair(words)
    words = merge(words, pair)
    print(f"шаг {step}: склеили {pair} (встретилась {count} раза)")
    print("   ", [" ".join(w) for w in words])

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

Где обычно ошибаются.

  • Думают, что токены — это слоги или морфемы, выбранные лингвистами. Это просто частые в корпусе куски, и границы у них бывают нелогичными: ней + рос + еть для слова «нейросеть» в o200k_base.
  • Ожидают, что словарь подстроится под их тексты. Он закреплён до обучения модели, и твои термины, имена и коды заказов будут резаться так, как получится.
  • Сравнивают модели по размеру словаря как по качеству. Больший словарь сокращает текст, но сам по себе не делает модель умнее.

Склейка пар байтов (BPE). способ построить словарь: много раз склеивать самую частую пару соседних кусков в корпусе.

Корпус. большой набор текстов, по которому подбирают словарь и потом учат модель.

Байт. число от 0 до 255; любой символ в компьютере записывается одним или несколькими байтами.

UTF-8. самая распространённая кодировка текста, где латиница занимает 1 байт, кириллица 2, эмодзи 4.

Побайтовый BPE (byte-level BPE). вариант склейки, который начинает с байтов, поэтому может закодировать любой текст.

Список склеек (merges). сохранённый по порядку перечень склеек, который токенизатор повторяет при нарезке.

SentencePiece. библиотека для построения токенизаторов, которой пользуются многие открытые модели; работает с сырым текстом, включая пробелы.

3 Почему один и тот же смысл стоит по-разному: язык, цифры, код

Зачем это в работе. Цена и окно у сервиса указаны в токенах, а ты думаешь словами и страницами. Если ты пишешь подсказки и документы на русском, держишь в запросе код, таблицы или JSON, тебе нужно понимать, сколько это на самом деле занимает. Иначе бюджет окна и расходов окажется посчитан неправильно, и обрезка истории, про которую была дорожка об окне контекста, начнётся раньше, чем ты ожидаешь.

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

Цифры живут по своим правилам. Многие токенизаторы не хранят каждое число целиком, а режут длинные числа на группы. В o200k_base мы видели, что «12345678» режется как 123 + 456 + 78, а дата «2026-10-19» — на 202, 6, -, 10, -, 19. Поэтому таблицы с цифрами, номера счетов и логи стоят больше, чем кажется по числу символов.

Код и разметка — отдельный случай. В коде много пробелов в начале строк, скобок, кавычек и символов вроде _ и =. Новые словари часто содержат целые группы пробелов и переводы строк одним токеном, поэтому отступы обходятся дешевле, чем раньше, но JSON с короткими ключами всё равно плотный: каждая кавычка, двоеточие и запятая — отдельный кусок или часть куска.

Отличие от символов и байтов. Иногда для прикидки делят число символов на 4. Для английского это близко, для русского и для цифр — нет, и в какую сторону ошибёшься, зависит от словаря. Поэтому прикидка годится только чтобы поймать грубый перебор, а реальный бюджет считается настоящим токенизатором.

Подробный пример. Мы прогнали пять коротких текстов через два словаря tiktoken: старый cl100k_base (в библиотеке он записан для GPT-4 и GPT-3.5) и новый o200k_base. Результат — замер на этих конкретных строках, а не общая статистика по языкам.

import tiktoken

texts = {
    "русский": "Модель читает текст не по буквам и не по словам, а по кускам, которые называются токенами.",
    "английский": "The model reads text not letter by letter or word by word, but in pieces called tokens.",
    "дата и сумма": "Счёт 2026-10-19 на сумму 1234567,89 руб.",
    "код": "def weights_gb(params_billion, bits):\n    return params_billion * bits / 8",
    "JSON": '{"order_id": "ORD-4412", "status": "shipped"}',
}
for name in ("cl100k_base", "o200k_base"):
    enc = tiktoken.get_encoding(name)
    print(name)
    for label, t in texts.items():
        ids = enc.encode(t)
        print(f"  {label:13} символов {len(t):3}  слов {len(t.split()):2}  токенов {len(ids):3}")

enc = tiktoken.get_encoding("o200k_base")
for w in ("привет", " привет", "Привет", "ПРИВЕТ"):
    ids = enc.encode(w)
    print(repr(w), len(ids), [enc.decode([i]) for i in ids])

Что получилось у нас. Русское предложение «Модель читает текст не по буквам и не по словам, а по кускам, которые называются токенами» (90 символов, 16 слов) заняло 39 токенов в cl100k_base и 26 в o200k_base. Его английский перевод (87 символов, 17 слов) — 19 токенов в обоих. Строка «Счёт 2026-10-19 на сумму 1234567,89 руб.» — 25 и 20 токенов. Короткая функция на Python — 19 и 20. JSON с номером заказа — 17 и 17. На двух абзацах длиннее картина та же: русский абзац из 41 слова занял 110 токенов в старом словаре и 62 в новом, английский из 52 слов — 59 в обоих. Вывод для этих замеров: в новом словаре русский почти догнал английский, в старом был примерно вдвое длиннее. Прикидка «слова × 1,3» для русского предложения дала бы около 21 токена, тогда как настоящих оказалось 26 и 39.

Повтори этот замер на своих текстах: возьми типичную подсказку, кусок документа и пример ответа, прогони через токенизатор нужной модели и запиши, сколько токенов в среднем выходит на 1000 символов. Это число и надо использовать в своих расчётах вместо чужих правил на глаз.

Где обычно ошибаются.

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

Плотность токенизации. сколько токенов уходит на одинаковый объём текста; зависит от языка и словаря.

Цена за миллион токенов. обычная единица тарифа у сервисов моделей; входные и выходные токены часто стоят по-разному.

Входные и выходные токены (input, output). токены твоего запроса и токены ответа модели; считаются и оплачиваются отдельно.

Группы цифр. куски, на которые токенизатор режет длинное число, например по три цифры.

Отступ. пробелы или табуляция в начале строки кода; в новых словарях часто сжимаются в один токен.

Прикидка длины. грубая оценка токенов по словам или символам; ловит перебор, но не заменяет точный подсчёт.

4 Где нарезка ломает ответы: буквы, числа, регистр, служебные метки

Зачем это в работе. Часть странных ошибок модели — не глупость и не выдумка, а следствие нарезки. Если знать эти места, можно заранее переформулировать задачу или отдать её программе, а не тратить время на уговоры. Кроме того, служебные метки токенизатора — реальная точка для атак на чат-бота, и про неё стоит знать тому, кто собирает агентов.

Буквы внутри токена модели не видны. Она получает номер куска целиком, а из чего он состоит, может знать только косвенно, если при обучении встречала разбор этого слова по буквам. Известный пример — вопрос, сколько букв «r» в слове «strawberry». В o200k_base это слово режется на st + raw + berry: модель видит три номера, а не десять букв. Поэтому подсчёт букв, перестановки, поиск рифм по последним буквам и проверка орфографии по буквам даются моделям тяжелее, чем кажется. Рассуждающие модели, о которых была прошлая дорожка, могут обходить это, сначала выписывая слово по буквам в черновике, но это обходной путь, а не исправление нарезки.

С арифметикой похожая история. Если число разрезано на 123 + 456 + 7, модель складывает не цифры по разрядам, а куски разной длины, и разряды могут «съехать». Отсюда практическое правило: точные вычисления отдавай программе через вызов инструмента, а модель пусть только решает, что считать. То же с идентификаторами: номер заказа «ORD-4412» режется на ORD, -, 441, 2, и при пересказе модель может потерять или переставить кусок, что будет выглядеть как опечатка.

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

Служебные метки. Кроме обычных кусков, в словаре есть специальные токены (special tokens): начало и конец сообщения, конец текста, роль говорящего. Например, у моделей Qwen реплики в шаблоне чата обрамлены метками <|im_start|> и <|im_end|>. По ним модель понимает, где кончается сообщение пользователя и начинается её собственный ответ. Если программа по ошибке превращает такой текст из письма или веб-страницы в настоящий служебный токен, посторонний человек может подделать границы сообщений. Это родственник внедрения инструкций, о котором была отдельная дорожка, только на уровне токенов.

Подробный пример. В tiktoken защита от этого включена по умолчанию, и это легко проверить. Мы взяли строку «Конец <|endoftext|> текста», где посередине написано имя служебного токена конца текста.

import tiktoken

enc = tiktoken.get_encoding("o200k_base")
text = "Конец <|endoftext|> текста"

try:
    enc.encode(text)                     # по умолчанию служебные метки запрещены
except ValueError as e:
    print("Ошибка:", str(e).splitlines()[0])

safe = enc.encode_ordinary(text)         # метка режется как обычный текст
print(len(safe), [enc.decode([i]) for i in safe])

danger = enc.encode(text, allowed_special="all")   # так делать с чужим текстом нельзя
print(danger)

У нас вышло три результата. Обычный encode выдал ошибку ValueError с сообщением, что встретился запрещённый служебный токен. encode_ordinary нарезал строку на 10 обычных токенов, где метка распалась на куски <, |, end, of, text, |, >: для модели это просто символы. А с allowed_special="all" вся метка стала одним номером 199999 — настоящим концом текста. Правило: текст от пользователя, из файлов и с сайтов всегда режь как обычный, а служебные токены пусть добавляет только шаблон чата твоей программы.

Где обычно ошибаются.

  • Просят модель посчитать буквы, символы или сложить длинные числа и верят результату без проверки программой.
  • Требуют от модели точно переписать длинный номер, хэш или ключ и не сверяют его кодом после ответа.
  • Склеивают шаблон чата руками из строк и пропускают в него чужой текст так, что метки вроде <|im_end|> становятся настоящими служебными токенами.

Служебный токен (special token). особый номер в словаре для границ сообщений, ролей и конца текста, а не для обычных слов.

Шаблон чата (chat template). правило, по которому реплики системы, пользователя и модели склеиваются в одну строку со служебными метками.

Конец текста (end of text). служебный токен, после которого модель останавливается или считает документ законченным.

encode_ordinary. функция tiktoken, которая режет весь текст как обычный, не распознавая служебные метки.

Подделка границ сообщений. атака, когда чужой текст превращается в служебные токены и выдаёт себя за реплику системы или модели.

Хвостовой пробел. пробел в конце подсказки, который становится отдельным непривычным токеном и может ухудшить продолжение.

Вызов инструмента (tool call). когда модель не считает сама, а просит программу выполнить расчёт и вернуть результат.

5 Как считать токены правильно в своей работе

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

Первое правило — считай токенизатором той же модели. Для моделей OpenAI это tiktoken с нужным словарём. Для открытых моделей токенизатор лежит рядом с весами, и его загружают библиотекой transformers от Hugging Face через AutoTokenizer.from_pretrained с именем модели. Для закрытых моделей других компаний своего локального токенизатора часто нет, зато у сервиса есть отдельный запрос для подсчёта: у Anthropic это подсчёт токенов сообщения (count_tokens), у Google в библиотеке Gemini — тоже count_tokens. Такой запрос возвращает число токенов, не генерируя ответа.

Второе правило — считай весь запрос, а не только текст. Сервис склеивает системную подсказку, историю, описания инструментов и твоё сообщение по шаблону чата и добавляет служебные токены на каждую реплику. Описания инструментов агента бывают длинными и тоже занимают окно. Поэтому подсчёт одного текста документа даёт заниженное число. Для открытых моделей шаблон можно применить сам: у токенизатора transformers есть метод apply_chat_template, который собирает реплики ровно так, как их увидит модель.

Третье правило — сверяйся с фактом. В ответе сервиса почти всегда есть поле использования (usage), где указано, сколько входных и выходных токенов на самом деле посчитали. Это и есть истина для счёта. Свой подсчёт нужен, чтобы заранее решить, что обрезать; поле usage — чтобы проверить, что твой подсчёт не врёт, и чтобы вести учёт расходов. Если они расходятся больше чем на несколько токенов на реплику, значит, ты не учёл часть запроса.

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

Подробный пример. Ниже учебный бюджет: окно 120 токенов, из них 40 оставлены под ответ. Числа нарочно маленькие, чтобы результат был виден на экране; в работе подставь окно и лимит ответа своей модели.

import tiktoken

enc = tiktoken.get_encoding("o200k_base")   # токенизатор GPT-4o в библиотеке tiktoken

WINDOW = 120          # учебное окно в токенах, чтобы результат был виден
RESERVE_ANSWER = 40   # запас под ответ модели
SYSTEM = "Отвечай коротко и только по документу."
DOC = ("Заказ ORD-4412 отправлен 14.10.2026 курьерской службой. "
       "Покупатель просил доставку после 18:00, адрес: ул. Ленина, 5, кв. 12. ") * 4
QUESTION = "Когда отправлен заказ ORD-4412?"

def n(text: str) -> int:
    return len(enc.encode(text))

used = n(SYSTEM) + n(QUESTION)
room_for_doc = WINDOW - RESERVE_ANSWER - used
print("система + вопрос:", used, "| документ целиком:", n(DOC), "| места под документ:", room_for_doc)

if n(DOC) > room_for_doc:
    ids = enc.encode(DOC)[:room_for_doc]   # режем по токенам, а не по символам
    cut = enc.decode(ids)
    print("обрезано до", len(ids), "токенов; хвост:", repr(cut[-30:]))

У нас код напечатал: системная подсказка и вопрос заняли 20 токенов, документ целиком — 201 токен, а места под документ осталось 60. После обрезки по токенам хвост выглядел как '2. Заказ ORD-4412 отправлен 14': разрез пришёлся посреди даты «14.10.2026». Это ровно та ловушка, о которой сказано выше: модель увидит «отправлен 14» и может уверенно ответить неправильно. Исправление — после enc.decode(ids) найти последнюю точку через cut.rfind(". ") и отрезать по ней, а если нужный факт всё равно не влезает, сначала найти нужный кусок поиском и класть в запрос только его.

Для открытой модели тот же подсчёт с шаблоном чата выглядит так. Этот кусок мы здесь не запускали, потому что он скачивает токенизатор выбранной модели; имя модели подставь своё.

from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("имя/модели")   # токенизатор лежит рядом с весами
messages = [
    {"role": "system", "content": "Отвечай коротко и только по документу."},
    {"role": "user", "content": "Когда отправлен заказ ORD-4412?"},
]
ids = tok.apply_chat_template(messages, tokenize=True, add_generation_prompt=True)
print("токенов с шаблоном:", len(ids))
print(tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True))

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

Где обычно ошибаются.

  • Считают только документ и вопрос, забывая системную подсказку, историю, описания инструментов и служебные токены шаблона.
  • Режут по точному числу токенов и отдают модели обрубок фразы или числа вместо целого предложения.
  • Никогда не сверяют свой подсчёт с полем usage и не замечают, что реальные расходы растут из-за части запроса, о которой забыли.

Поле использования (usage). часть ответа сервиса, где указано, сколько входных и выходных токенов реально посчитано.

Подсчёт токенов на сервисе (count_tokens). отдельный запрос, который возвращает длину сообщения в токенах без генерации ответа.

transformers. библиотека Hugging Face на Python для загрузки открытых моделей и их токенизаторов.

AutoTokenizer. класс transformers, который по имени модели загружает именно её токенизатор.

apply_chat_template. метод токенизатора, который склеивает реплики по шаблону чата этой модели.

Бюджет окна. расчёт, сколько токенов окна уходит на подсказку, документ и запас под ответ.

Лимит ответа (max tokens). настройка, после скольких выходных токенов сервис оборвёт ответ.

Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.