Как работает LLM: токены, внимание и предсказание следующего токена

Введите в окно чата короткую фразу, например "The cat is sleeping." («Кошка спит.»), и через мгновение модель ответит строкой, объяснением или целым абзацем. Снаружи это выглядит легко. Но что на самом деле происходит в промежутке?

Любой, кто читал об ИИ, натыкался на кучу терминов: токены, эмбеддинги, трансформеры, внимание, Q/K/V, предсказание следующего токена. Вместе они могут создать впечатление, что языковые модели гораздо сложнее, чем есть на самом деле. Хорошая новость: чтобы понять базовую архитектуру, не нужна стоящая за ней математика. Достаточно понять, как сочетаются несколько деталей.

Сквозным примером послужит одно предложение: "The cat is sleeping." Проследим его путь через весь механизм.

Общая картина

Если смотреть издалека, LLM обрабатывает текст поэтапно:

Text
 ↓
Tokens
 ↓
Embeddings
 ↓
Transformer
 ↓
Attention
 ↓
Next-token prediction
 ↓
Next token
 ↓
Repeat

Под всем этим лежит большая нейронная сеть, параметры которой были настроены во время обучения. Каждый этап стоит рассмотреть подробнее.

1. Нейронные сети — фундамент

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

Простейшая картинка — коробка, которая превращает вход в выход:

Input
  ↓
Neural Network
  ↓
Prediction

Во время обучения сеть делает догадку, измеряет, насколько ошиблась, и слегка подправляет параметры, чтобы в следующий раз угадать лучше. После достаточного объёма данных она усваивает закономерности языка. Видя "The cat is ___", она узнаёт, что правдоподобными продолжениями будут слова вроде "sleeping", "hungry", "running" или "outside".

Главное, что стоит запомнить: LLM — это большая нейронная сеть, которая выучила закономерности из данных. Математику нейросетей можно пропустить и всё равно понять остальное.

2. Токены — как модель читает

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

"The cat is sleeping."
          ↓
["The", " cat", " is", " sleeping", "."]

Какие именно куски получатся, зависит от модели и её токенизатора. Токеном может быть целое слово, его фрагмент, знак препинания или другой кусок текста. Затем каждому токену сопоставляется число — его ID, так что конвейер пока выглядит так:

Text
 ↓
Tokens
 ↓
Token IDs

На этом этапе модель уже может работать с текстом как с числами.

Почему токены важны на практике

Токены — не сноска. Для любого пользователя ИИ-продуктов они объясняют несколько повседневных вещей:

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

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

Но одного голого ID недостаточно. Модели нужно для каждого токена что-то более содержательное.

3. Эмбеддинги — смысл в числах

Возьмём токен "cat". Его ID может быть чем-то вроде 582, но это число ничего не говорит о кошках. Это просто метка, не более.

Поэтому модель заменяет каждый ID эмбеддингом — вектором из множества числовых значений:

"cat"
  ↓
Token ID
  ↓
Embedding
  ↓
[0.21, -0.73, 0.44, ...]

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

4. Трансформеры — где идёт обработка

К этому моменту предложение прошло вот такой путь:

Text
 ↓
Tokens
 ↓
Token IDs
 ↓
Embeddings

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

Embeddings
    ↓
Transformer layer
    ↓
Transformer layer
    ↓
Transformer layer
    ↓
...
    ↓
Prediction

В реальных моделях друг на друга наложено много слоёв трансформера. Но как слой понимает, какие слова важны друг для друга? С помощью self-attention, механизма самовнимания.

5. Самовнимание — работа с контекстом

Возьмём предложение подлиннее: "The cat climbed onto the couch because it was tired." («Кошка забралась на диван, потому что устала»). Чтобы обработать слово "it", модели нужно осмотреться и решить, на что оно указывает. Самовнимание позволяет ей просмотреть другие токены и оценить, какие из них релевантны:

The  cat  climbed  onto  the  couch  because  it  was  tired
      ↑                              ↑       ↑
      └──────── relevant context ────┘

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

6. Q, K и V — как внимание выбирает важное

Внимание опирается на три роли:

• Query (Q, запрос): что ищет этот токен?
• Key (K, ключ): что предлагает каждый токен в качестве метки для сопоставления?
• Value (V, значение): какое содержимое токен передаёт, когда его выбирают?

В виде потока:

Query
  ↓
Compare with Keys
  ↓
Determine relevance
  ↓
Use relevant Values
  ↓
Updated representation

Хорошее сравнение — библиотека. Ваш вопрос — это запрос. У каждой книги есть карточка в каталоге, по которой видно, подходит ли она, — это её ключ. Найдя нужные книги, вы читаете их содержимое — это значения. Внимание делает нечто похожее. Формула для понимания идеи не нужна: Q, K и V помогают модели решить, какая информация в других токенах релевантна.

7. Многоголовое внимание — много точек зрения

В языке одновременно присутствуют разные виды связей: грамматика, смысл и то, какие слова к каким отсылают. Поэтому трансформеры запускают несколько голов внимания параллельно:

Input
                   ↓
          ┌────────┼────────┐
          ↓        ↓        ↓
        Head 1   Head 2   Head 3
          ↓        ↓        ↓
       Pattern   Pattern   Pattern
          └────────┼────────┘
                   ↓
                Combined

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

8. Каузальное маскирование — не подглядывать вперёд

Теперь свяжем внимание с генерацией текста. Допустим, модель видит "The cat is" и должна предсказать следующий токен. Ей нельзя позволить сначала прочитать ответ. Это обеспечивает каузальное маскирование:

The → can see The

cat → can see The, catis → can see The, cat, issleeping → can see The, cat, is, sleeping

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

9. Предсказание следующего токена — как создаётся текст

Это центральная идея моделей в стиле GPT. LLM пишет, предсказывая, какой токен будет следующим. Получив начало:

"The cat"
    ↓
Predict next token
    ↓
"is"

контекст становится таким:

"The cat is"

и она снова предсказывает:

"The cat is"
       ↓
Predict next token
       ↓
"sleeping"

потом ещё раз:

"The cat is sleeping"
       ↓
Predict next token
       ↓
"."

и так далее. Ответ обычно не создаётся за один раз. Модель работает в цикле:

Read the available context
        ↓
Predict the next token
        ↓
Add that token to the context
        ↓
Predict again
        ↓
Repeat

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

10. Обучение и инференс

Последнее различие: обучение против использования.

Во время обучения модель настраивает свои параметры. В общих чертах:

Input
 ↓
Prediction
 ↓
Compare with expected result
 ↓
Calculate error
 ↓
Adjust parameters
 ↓
Repeat

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

Инференс — это то, что происходит каждый раз, когда вы пользуетесь обученной моделью. Вы даёте ей "The cat is", и она применяет выученные параметры, чтобы предсказать следующий токен:

Your prompt
 ↓
Model
 ↓
Next-token prediction
 ↓
Next token
 ↓
Predict again
 ↓
Response

Коротко, чтобы запомнить: обучение — это учёба, а инференс — использование выученного.

Всё вместе

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

"The cat is sleeping."
          ↓
      Tokenization
          ↓
       Token IDs
          ↓
       Embeddings
          ↓
      Transformer
          ↓
    Self-Attention
          ↓
       Q, K, V
          ↓
  Multi-Head Attention
          ↓
     Causal Mask
          ↓
 Next-Token Prediction
          ↓
       Next Token
          ↓
         Repeat

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

Зачем это знать

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

Для разработчиков каждое понятие окупается напрямую:

• Токены объясняют ограничения контекста и стоимость.
• Эмбеддинги ведут к семантическому поиску и RAG.
• Трансформеры и внимание показывают, как модели работают с контекстом.
• Предсказание следующего токена объясняет генерацию и поведение.
• Разделение на обучение и инференс проводит границу между использованием модели, её дообучением и обучением с нуля.

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

Версия в одном абзаце

Если запомнить что-то одно, пусть это будет вот что: LLM разбивает текст на токены, превращает токены в числовые представления, пропускает их через слои трансформера, использующие внимание, и раз за разом предсказывает следующий токен.

Text
 ↓
Tokens
 ↓
Embeddings
 ↓
Transformer
 ↓
Attention
 ↓
Next-token prediction
 ↓
Repeat

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