Что такое токены и почему нейросеть считает текст совсем не так, как человек

Когда мы читаем текст, мы обычно считаем слова.

Например:

«Сегодня я написал программу на Python».

Для человека это обычное предложение. Мы видим слова, пробелы, знаки препинания и примерно понимаем, сколько здесь текста.

Нейросеть смотрит на него иначе.

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

И здесь начинается интересное.

Токен - это не обязательно слово.

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

Поэтому привычная логика «100 слов = 100 единиц текста» для языковой модели не работает.

Что именно нейросеть считает токеном

Допустим, человек написал:

Программирование помогает автоматизировать работу.

Мы видим четыре слова.

Токенизатор может представить эту же строку примерно так:

Программ + ирование + помогает + автомат + изировать + работу + .

Это только иллюстрация. Реальное разбиение зависит от конкретной модели и её словаря.

Современные токенизаторы часто используют субсловные алгоритмы. Один из распространённых подходов - BPE, Byte Pair Encoding. Его идея довольно проста: часто встречающиеся последовательности символов объединяются в более крупные единицы. Другие модели могут использовать Unigram или WordPiece.

Получается компромисс.

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

Если сделать токеном каждый символ, последовательности станут слишком длинными.

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

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

Возьмём программиста.

Для человека:

программист

- одно слово.

Для токенизатора это совершенно не обязательно одна единица.

Особенно заметно это становится с редкими словами, сложными терминами, названиями библиотек, идентификаторами в коде и словами на разных языках.

Например, длинное название функции вроде:

calculateUserSubscriptionStatus

человеческий глаз воспринимает как одно имя.

Токенизатор может разделить его на несколько частей.

И это важно не только из любопытства.

Чем больше токенов занимает запрос, тем больше места он занимает в контекстном окне модели.

Токены - это ещё и «размер памяти» запроса

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

Но контекст измеряется не в страницах и не в словах.

Он измеряется в токенах.

В этот объём попадает не только последний вопрос пользователя. В зависимости от системы туда могут входить предыдущие сообщения, инструкции, документы, результаты работы инструментов и другие данные.

Поэтому длинный диалог постепенно становится для модели всё более объёмной последовательностью токенов.

Именно здесь возникает распространённое заблуждение.

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

Почему русский текст нельзя просто пересчитать по словам

Для английского иногда используют грубое правило: один токен - примерно несколько символов, а 100 токенов могут соответствовать примерно 75 словам. Но это лишь ориентир, а не универсальная формула. OpenAI прямо отмечает, что фактическая токенизация зависит от текста.

С русским языком ситуация может выглядеть иначе.

Сравнивать два текста только по количеству слов недостаточно. Один и тот же по смыслу текст на разных языках способен занимать разное количество токенов.

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

Поэтому фраза:

«В статье 2000 слов, значит она займёт примерно столько же места, сколько любая другая статья на 2000 слов»

для работы с LLM слишком упрощённа.

А что происходит с кодом?

С кодом всё становится ещё интереснее.

Человек видит:

//python

user = get_user_by_id(user_id)

и воспринимает это как короткую строку.

Но для токенизатора здесь есть имена переменных, скобки, подчёркивания, оператор присваивания и другие символы.

Код вообще хорошо показывает, почему токен нельзя считать просто «словом».

Возьмём:

//text

getUserById()

Человек воспринимает это как одно имя функции.

Токенизатор может разбить его на несколько частей.

Именно поэтому при работе с большими файлами исходного кода вопрос токенов становится вполне практическим. Файл может выглядеть небольшим в редакторе, но занимать гораздо больше места в контексте модели, чем ожидает разработчик.

Почему токены имеют значение для разработчика

Знать определение токена полезно, но гораздо важнее понимать последствия.

Например, вы отправляете нейросети большой проект и просите:

«Проанализируй весь код и найди причину ошибки».

В голове у человека это выглядит просто: есть папка с исходниками, пусть модель её посмотрит.

Но для модели это не «папка».

Это огромная последовательность токенов.

И у этой последовательности есть физический предел, который задаётся контекстом конкретной модели.

Поэтому разработчик постепенно сталкивается с вещами вроде:

• ограничений контекстного окна;

• подсчёта входных и выходных токенов;

• стоимости API-запросов;

• сокращения промптов;

• разбиения документов на части;

• выбора подходящего размера фрагментов для RAG.

То есть токены довольно быстро перестают быть теоретическим термином.

Почему нейросеть не читает текст как человек

Наверное, это главное, что стоит запомнить.

Мы читаем:

«Кошка сидит на окне».

и практически мгновенно воспринимаем смысл всей фразы.

Модель начинает с другой структуры.

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

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

Именно поэтому выражение «нейросеть прочитала текст» удобно для разговора, но технически оно сильно упрощает происходящее.

Самое интересное - токенизация влияет на сам опыт работы с ИИ

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

На самом деле они находятся намного ближе к пользователю, чем кажется.

Если контекст ограничен, токены определяют, сколько информации можно передать модели за один раз.

Если API тарифицируется по токенам, они влияют на стоимость.

Если вы работаете с длинным документом, они определяют, сколько материала получится обработать одновременно.

Если вы пишете код для LLM, токены становятся частью обычной инженерной задачи.

И даже качество работы с разными языками частично связано с тем, насколько эффективно токенизатор представляет их текст.

Поэтому вопрос «сколько здесь слов?» для нейросети часто оказывается менее интересным, чем вопрос:

«Сколько здесь токенов?»

Как посмотреть токены своими глазами

Самый простой способ понять принцип - взять реальный текст и прогнать его через токенизатор конкретной модели.

Например, у OpenAI есть Tokenizer, который позволяет посмотреть, на какие токены разбивается текст и сколько их получилось.

После этого довольно быстро исчезает ощущение, что токен - это просто модное название для слова.

Иногда короткая человеческая фраза разбивается неожиданно.

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

А код, который визуально занимает одну строку, может иметь совсем не такое маленькое токеновое представление.

И это, пожалуй, лучший способ понять всю концепцию.

Что в итоге нужно запомнить

Токен - это базовая единица текста, с которой работает языковая модель.

Но универсального правила «одно слово = один токен» не существует.

Конкретное разбиение зависит от токенизатора и его словаря. Современные подходы вроде BPE, Unigram и WordPiece позволяют представлять слова и их части, сохраняя разумный баланс между размером словаря и длиной последовательности.

И вот здесь появляется важный сдвиг в мышлении.

Когда человек смотрит на текст, он думает о словах, предложениях и страницах.

Когда разработчик работает с LLM, полезно иногда смотреть на тот же текст как на последовательность токенов.

Именно в токенах для нейросети измеряется то, сколько текста она получает, сколько контекста занимает запрос и насколько большой объём информации ей предстоит обработать.

После этого многие странности современных ИИ становятся немного понятнее.