Бесплатный фрагмент - Инжиниринг искусственного интеллекта

Аннотация

Представьте, что LLM — это чёрный ящик. Вы знаете, что внутри что-то есть, но каждый раз, открывая его, надеетесь на чудо. Эта книга закроет ящик навсегда.

Не учебник. Не научпоп. Инженерный путеводитель. Две книги под одной обложкой. Первая — от токена до трансформера: как работает внимание, почему память убивает процессор, сколько стоит владение моделью и что такое HBM. Вторая — от агента до лицензии на ИИ: как строить, тестировать, внедрять, считать ROI и не провалиться в цифровую ловушку самообмана.

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

Автор не гуру. Автор — энтузиаст, который прошёл путь от «что такое токен» до внедрения агентов в продакшен. И честно рассказывает, где заканчивается наше понимание.

Если вы готовы заменить веру в чудо на систему координат — откройте эту книгу.

Инжиниринг искусственного интеллекта

СТАРТОВАЯ КАРТА

Версия текста: 1.9

Эта страница — только для тех, кто впервые подходит к ИИ. Если вы уже пишете промпты, разворачиваете модели, считаете TCO или внедряете RAG — закройте её. Оглавление — ваш навигатор.

Ваш маршрут

Книга 1. От токена до трансформера

Как читать: Целиком последовательно.

Зачем: Это азбука и физика LLM.

Книга 2. От инструмента к двойнику

Как читать: По диагонали, с карандашом

Зачем: Это продакшен: агенты, тестирование, ROI, безопасность. Ваша задача сейчас — запомнить где искать, когда столкнётесь с реальной задачей.

Книга 3. Оркестр агентов. Отдельная книга!

Как читать: Выборочно, по архитектурным паттернам. Сначала главу 1 («Почему один агент не может всё») и главу 2 («Память экосистемы»), остальное — по ситуации.

Зачем: Это масштабирование: мультиагентные системы, оркестрация, умная шина данных, экономика автономности, юридическая ответственность. Когда ваш пилот из Книги 2 превращается в десятки агентов — открывайте Книгу 3.

Как читать, чтобы не утонуть, а впитать

Первый проход

Читайте быстро. Не выписывайте формулы. Ваша цель — увидеть карту местности. Если что-то непонятно — ставьте маркер и идите дальше.

Второй проход (якоря)

Отмечайте главы, к которым вернётесь. Например: «Глава Б.3 — перечитать, когда будем настраивать RAG» «Глава В.5 — открыть, когда нужно будет защитить бюджет перед руководством» «Глава Е.4 — проверить, когда агент начнёт галлюцинировать в проде»

Третий проход (по запросу)

Возвращайтесь только когда возникает конкретная боль. Книга 2 работает как справочник, а не как учебник.

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

1. Цифры устареют. Принципы — нет.

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

2. Повторы — не вода, а спираль.

Если встретите знакомую идею в другом контексте — не пропускайте. Так закрепляются инженерные паттерны.

3. Здесь нет кнопки «Сделать ИИ».

Есть система координат, в которой вы сами найдёте ответы, когда начнёте строить.

ВАЖНОЕ ПРЕДУПРЕЖДЕНИЕ ДЛЯ ЧИТАТЕЛЯ

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

О процессе создания

При работе над рукописью автор использовал гибридный подход. Большая языковая модель (LLM) применялась как динамический инструмент: для генерации черновых вариантов технических рецензий, предложения формулировок, структурирования ответов и проверки гипотез. Автор полностью контролировал направление работы, определял тематику, критически оценивал, отбирал и редактировал весь предложенный контент. Итоговый текст является результатом интеллектуального труда автора.

Но если дочитаете (или перелистнете на книгу 2 в раздел Приложение), то в нем есть отдельная глава, которая посвящена тому, как попробовать отличить текст, сгенерированного LLM от человеческого. В этом плане эта книга — идеальный тренажер.

Об ответственности

Автор не дает никаких гарантий, явных или подразумеваемых, относительно полноты, точности, надежности или актуальности приведенных данных. Это касается всех технических характеристик моделей, расчетов совокупной стоимости владения (TCO), архитектурных рекомендаций и любых других материалов книги.

Используйте информацию на свой страх и риск

Автор не несет ответственности за любые прямые или косвенные убытки, упущенную выгоду, потерю данных, простои оборудования или финансовые потери, возникшие в результате применения советов, формул или решений, описанных в тексте.

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

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

И да, математики (ну или почти) здесь вы не найдете. Невозможно объять все в одной книге. А хотелось, правда хотелось.

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

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

ОБРАТИТЕ ВНИМАНИЕ

В книге используется послесловие «Лицензия на ИИ», где проводится сравнение технологий искусственного интеллекта с оружием.

Автор заявляет

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

Позиция автора

Оборот оружия требует строгого государственного контроля. Автор поддерживает действующее законодательство в этой сфере.

Книга не содержит пропаганды насилия или нарушения законодательства Российской Федерации.

КНИГА 1. Инженерия LLM: от токена до двойника

ПРЕДИСЛОВИЕ

Эта книга устроена необычно. Она не пытается быть «истиной в последней инстанции» и не разжёвывает каждый технический нюанс до состояния пюре. В ней два слоя.

Первый слой

Для «простака» (то есть для любого нового читателя). Это толстые мазки: метафоры, объяснения «на пальцах», история развития, экономика и выбор модели. Прочитав книгу один раз, вы поймёте суть, начнёте задавать правильные вопросы и не дадите себя обмануть маркетологами.

Второй слой

Для «критика» (для пытливого инженера). Это нюансы, которые сознательно оставлены «за кадром» или описаны ровно настолько, чтобы у вас зачесались руки. Вас заинтересовала балансировка экспертов в MoE? Или разница между паттернами Sparse Attention? Отлично. Закройте книгу, откройте поисковик и углубитесь. Книга дала вам карту — клад вы найдёте сами.

И ещё одна важная деталь. Книга физически разделена на две части, каждая из которых самодостаточна.

Книга 1

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

Книга 2

Это продакшн и расширение: агентные системы, экономика AI-проектов, карта компетенций для продактов. В ней тоже есть инженерия — просто другая.

ЕСЛИ Вам просто нужен короткий ликбез про Искусственный интеллект в рамках этой книги — перелистывайте сразу на Книгу 2, Приложение 1.

В книге используются как русские, так и английские термины (attention, fine-tuning, inference) — они общеприняты в инженерной среде. Если вы встречаете незнакомую аббревиатуру, обратитесь к глоссарию в конце.

Идеальный читатель этой книги — не тот, кто ищет готовые ответы, а тот, кто хочет понять, куда смотреть. Эта книга — не попытка сделать ИИ прозрачным. Это дневник инженерного пути, на котором чёрный ящик перестаёт быть чёрным ровно настолько, насколько вам нужно. Я не знал про ИИ ничего, кроме модных слов. Я задавал вопросы. Тупые. Наивные. Неправильные. Потом задавал следующие. И ещё. Я не сделал ящик стеклянным — я сделал его серым. Теперь я вижу его границы, знаю, где он врёт, где тормозит, где его можно ускорить, а куда лучше не соваться. И главное — я понял, какие вопросы можно задать, а какие — дело следующих десятилетий. Эта книга — не про ответы. Она про метод. Возьмите чёрный ящик, который вас пугает, и уменьшайте его до тех пор, пока он не перестанет быть проблемой. А когда дойдёте до границы — будем задавать новые вопросы вместе.

ВВЕДЕНИЕ

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

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

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

Эта книга — мост через эту пустоту.

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

Что вы найдёте внутри

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

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

Вы узнаете

• Почему «токен» — это не просто слово, а единица измерения скорости и денег;

• Как слова превращаются в векторы и почему «Король — Мужчина + Женщина = Королева»;

• Чем отличается позиционное кодирование RoPE от ALiBi и когда что выбирать;

• Как работает механизм внимания и почему без него нет современных LLM;

• Зачем в трансформере целых 32 слоя и что происходит в каждом;

• Почему LSTM проиграла трансформерам, хотя была прорывом;

• Что такое «коллектив экспертов» и как модели учатся экономить ресурсы;

• Сколько на самом деле стоит обучение большой модели (спойлер: как крыло самолёта);

• Как из обычной языковой модели делают вежливого ассистента с помощью SFT и RLHF;

• Какие оптимизации позволяют обрабатывать миллионные контексты;

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

• Почему будущее — не за одной гигантской моделью, а за оркестром специализированных;

• Как может выглядеть ваш цифровой двойник и какие проблемы нас ждут на этом пути.

Важная оговорка

Воспринимайте конкретные цифры (количество параметров, размер контекста) как снимок эпохи 2024–2025 годов, а архитектурные решения — как фундамент, на котором вы сможете строить понимание любых новых моделей.

ГЛАВА 1. КАК РАБОТАЕТ ГЕНЕРАТИВНАЯ ЯЗЫКОВАЯ МОДЕЛЬ: ОТ ЗАПРОСА К ОТВЕТУ

«Люди — это нейронные сети. Всё, что можем делать мы, способны делать и машины»

— Джеффри Хинтон, ученый-информатик, первопроходец в области глубокого обучения

Любой запрос к LLM — от короткого вопроса до многотокенного промпта — проходит через цепочку преобразований.

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

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

Начнём с того, во что прежде всего упирается любой текст, попадающий в модель, — с токена.

1.1 Токен

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

Почему не «слово» или «символ»?

Термин «токен» выбран потому, что он шире и абстрактнее, чем «слово». Токенами становятся не только слова, но и знаки препинания, цифры, пробелы (иногда) или части слов (сабворды). Например, в предложении «Привет! Как дела?» токенами будут: [Привет], [!], [Как], [дела], [?]. Восклицательный знак — это не слово, но это важный токен.

Математическая абстракция: Для нейросети токен — это, в конечном итоге, просто индекс (число) из словаря. Назвать это «словом» было бы некорректно, так как модель оперирует числами, а не лингвистическим понятием «слова».

Итак, токен — это не просто слово, а абстрактный «жетончик смысла». Но как именно текст превращается в эти жетончики? За это отвечает следующий компонент — токенизатор.

Токенизация (Tokenization)

Разделение текста на единицы обработки. Когда вы отправляете сообщение, модель не видит буквы или слова в человеческом понимании. Текст проходит через токенизатор (tokenizer) — алгоритм, который разбивает строку на минимальные единицы, называемые токенами (tokens). Существует несколько алгоритмов: BPE (используется в GPT и RoBERTa), WordPiece (BERT) и SentencePiece (LLaMA, T5, XLNet).

BPE, WordPiece и SentencePiece — в чём разница?

Токенизатор — это не «чёрный ящик». Это алгоритм, который решает одну задачу: если слова нет в словаре, на какие кусочки его разрезать? Три популярных подхода — BPE, WordPiece и SentencePiece.

BPE (Byte Pair Encoding)

Как работает

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

Пример

В тексте часто встречается a b → склеиваем в ab. Потом ab c → в abc. И так далее.

+ Простой, понятный, работает для европейских языков.

— Требует предварительной разбивки на слова (пробелы — отдельные специальные символы). Плох для языков без пробелов (китайский, японский, тайский).

Где используется

GPT, RoBERTa.

WordPiece

Как работает

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

Разница с BPE

BPE выбирает пару по частоте. WordPiece — по приросту вероятности модели (то, что лучше помогает предсказывать следующий токен).

+ Даёт чуть более «умные» токены, чем BPE.

— Тоже требует разбивки на слова. Сложнее в реализации.

Где используется

BERT.

SentencePiece

Что это

Не алгоритм, а библиотека, которая умеет две вещи:

• Работать с сырым текстом (без предварительной разбивки на слова по пробелам);

• Использовать внутри либо BPE, либо Unigram (третий алгоритм).

Главная фишка

Пробел в SentencePiece — обычный символ, как и все остальные. Поэтому он не требует «знать», где границы слов. Это важно для языков без пробелов (китайский, японский, тайский).

+ Универсален, работает с любыми языками.

— Требует отдельного шага — обучения токенизатора на корпусе (хотя это делается один раз).

Что важно для инженера

Если вы работаете с английским и европейскими языками BPE или WordPiece дадут почти одинаковый результат. Разница заметна только на гранях.

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

SentencePiece сегодня — стандарт для open-source LLM (LLaMA, Qwen, DeepSeek). BPE и WordPiece сегодня используют реже (GPT-2, BERT — уже не передний край), но понимать их полезно для чтения старых статей и спецификаций.

Токен может быть:

• целым словом («кот», «человек»);

• частью слова («нейро», «сеть»);

• отдельным символом (»!»,»?»).

Выбор стратегии — инженерное решение, у которого нет идеального варианта, только компромиссы.

Целые слова

Интуитивно понятно, но словарь разрастается до миллионов токенов (неэффективно), а модель не сможет обработать слово, которого не видела в обучении (проблема OOV — out of vocabulary).

Части слов (сабворды)

Золотая середина. Словарь фиксированного размера (32K–256K), редкие слова собираются из кусочков, модель может обрабатывать новые слова. Минус: иногда нарезка выглядит нелогичной («нейро» + «сети» вместо «нейросети»).

Отдельные символы

Словарь крошечный (десятки/сотни токенов), нет проблемы OOV, но длинные тексты превращаются в очень длинные последовательности, что замедляет обработку и усложняет поиск смысловых связей.

Большинство современных моделей выбирают компромиссный вариант — сабворды (BPE, SentencePiece, WordPiece).

Как это работает технически

Токенизатор анализирует статистику встречаемости символов и их сочетаний в обучающем корпусе. Часто встречающиеся последовательности объединяются в один токен. Это позволяет держать размер словаря (обычно 32 000–256 000 токенов) фиксированным, но при этом кодировать любой текст.

Как токен получает свой номер (и почему спецсимволы — особенные)

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

Алгоритм работает следующим образом

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

Затем токенизатор «смотрит» на обучающий корпус (миллиарды текстов) и ищет самые частотные пары уже существующих токенов.

Самую частотную пару он «склеивает» в новый токен и присваивает ему следующий свободный номер.

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

Два важных нюанса про спецсимволы

Первый: пробелы

В большинстве токенизаторов пробел — это не «пустота», а полноправный символ, который получает свой номер. Когда токенизатор «склеивает» пары, он может объединить пробел со следующим словом. Именно поэтому в некоторых моделях токен « Как» (с пробелом в начале) существует отдельно — это наследие того, что на каком-то шаге пробел и слово «Как» встретились вместе достаточно часто.

Второй: пунктуация

Знаки препинания (точка, запятая, восклицательный знак) — это отдельные токены с самого начала. Они никогда не «склеиваются» со словами, если только модель специально не обучена на текстах без пробелов после знаков (а такое бывает). Поэтому в примере выше восклицательный знак»!» остался самостоятельным токеном номер 67, хотя мог бы теоретически приклеиться к слову «Привет».

Что в итоге?

Цифра 3245 — это не случайный индекс, а история: этот токен был «склеен» на каком-то шаге из двух более мелких, которые встретились вместе достаточно часто, чтобы заслужить собственное место в словаре. А цифра 67 (восклицательный знак) — это «первокирпичик», который был заложен в фундамент ещё до начала склеивания.

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

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

Токенизация разных языков

Токенизаторы обычно обучаются на смеси языков, но английский в ней доминирует. Это создаёт перекос:

Английский

Частотные слова становятся одним токеном. Коэффициент токенизации (токенов на слово) — 1.0—1.5.

Русский

Из-за развитой морфологии слово часто разбивается на корень и окончание. Коэффициент — 1.5—2.0.

Японский/Китайский

Иероглифы кодируются посимвольно. Коэффициент — 2.0—3.0.

Практическое следствие

При прочих равных, работа с русским текстом обходится дороже в токенах, чем с английским. Эти коэффициенты — не просто академические цифры. Для инженера они прямо переводятся в деньги.

Важное уточнение: это не потому, что английский «лучше».

Глядя на эти цифры, легко сделать неверный вывод: мол, английский — самый «экономный» язык, а русский и тем более китайский — «расточительные». Это не так.

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

Теоретически ничто не мешает создать токенизатор, который будет экономичнее для китайского, чем для английского. Если взять корпус, где 90% текстов — на китайском, и обучить BPE или SentencePiece на нём, иероглифы начнут «склеиваться» в осмысленные частотные пары, а английские слова, наоборот, будут дробиться на части. Коэффициенты поменяются местами.

Практически это уже происходит. Китайские модели (Qwen, DeepSeek) используют токенизаторы, оптимизированные под китайский и английский одновременно, с балансировкой словаря. Русскоязычные модели (GigaChat, YandexGPT) тоже имеют свои особенности токенизации, хотя часто дообучаются поверх «английских» словарей. В специализированных моделях разница в «весе» между языками может быть сведена к минимуму или даже обращена в пользу локального языка.

Вывод для инженера

Если вы строите систему под русский язык и используете «английскую» модель — да, вы будете платить больше за токены. Но это не проклятие языка, а вопрос выбора инструмента. Существуют модели и токенизаторы, где русский «весит» столько же, сколько английский (к примеру, GigaChat и Saiga (адаптированная LLaMA)), а в некоторых случаях — даже меньше. Просто их нужно знать и уметь выбирать.

Давайте теперь посмотрим, как знание о токенах помогает считать бюджет.

Токенизация и опечатки: как модель видит ошибки

Мы только что разобрали, как токенизатор превращает текст в числа. Но что происходит, если в тексте есть опечатка? Для человека слово «следуюет» — это очевидная ошибка, мы её автоматически исправляем и понимаем смысл. Для модели всё иначе.

Посмотрим на примере

Слово: «следуюет» (опечатка, должно быть «следует»)

Токены: [сле] [дую] [ет] или [с] [ле] [ду] [ю] [ет] (зависит от токенизатора)

Индексы: [1245] [7890] [3456]

Для модели это просто три числа: 1245, 7890, 3456. Она не знает, что это «неправильное слово». Она видит последовательность токенов, которые могут быть редкими (если опечатка встречается редко) или, наоборот, часто встречаться в корпусе (если люди часто делают эту ошибку).

Два сценария

Сценарий 1: Редкая опечатка

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

Сценарий 2: Частая опечатка

Если ошибка распространена (например, «вообщем» вместо «в общем»), токенизатор может даже выделить для неё отдельный токен. Такое слово становится для модели таким же «нормальным», как и правильный вариант. Она будет обрабатывать его как обычное слово, не подозревая, что это ошибка.

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

Модель же видит последовательность токенов. Если эта последовательность достаточно часто встречалась в обучении, она воспримет её как допустимый вариант. Если редко — может «растеряться». Но у неё нет «чувства правильности» — только статистика.

Практический вывод для инженера

При построении систем, которые общаются с пользователями, важно учитывать:

• Токенизатор не исправляет опечатки, он просто кодирует их

• Если ваш продукт работает с неграмотными текстами (чаты, соцсети), стоит подумать о предобработке — нормализации опечаток до токенизации

• Некоторые модели специально дообучают на текстах с ошибками, чтобы они лучше понимали реальных пользователей

Пример предобработки

Вход: «следуюет заменить»

Шаг 1: нормализация опечаток (опционально) → «следует заменить»

Шаг 2: токенизация → [сле] [дует] [за] [ме] [нить]

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

Расход токенов и бюджет

Это критически важно для

• расчёта стоимости API (Application Programming Interface) 2;

• планирования длины контекста (один и тот же текст на русском займёт больше токенов);

• выбора модели.

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

1.2 Эмбеддинги

В предыдущем разделе мы превратили текст в последовательность чисел — токенов. Но у этой победы есть обратная сторона: сами по себе эти числа [3245, 67, 8902, …] ничего не говорят модели о смысле слов. Для компьютера 3245 и 8902 — просто разные индексы3, между которыми нет никакой связи. Как же объяснить машине, что «кот» и «кошка» — это почти одно и то же, а «кот» и «астероид» — нет? Здесь на сцену выходят эмбеддинги.

Эмбеддинги (Embeddings) — это способ объяснить искусственному интеллекту смысл слов на языке цифр. Если токен — это жетончик смысла, то эмбеддинг — вектор смысла.

Проблема

Компьютер не понимает слова

Для компьютера текст — это просто набор непонятных значков. Единственный язык, который он реально понимает, — это числа.

Самое простое, что пришло в голову учёным — это присвоить каждому слову номер:

Кот = 1

Собака = 2

Груша = 3

Яблоко = 4

ИИ видит: 1, 2, 3, 4.

В чём здесь проблема?

Для человека очевидно, что Кот и Собака — это животные (похожи), а Яблоко и Груша — это фрукты (тоже похожи).

Но для компьютера числа 1 и 2 — это такая же пара, как и числа 1 и 4. Просто цифры.

Для него «Кот» (1) так же далек от «Собаки» (2), как и от «Груши» (3). Смысл потерян.

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

Решение

Погружаем слова в «пространство смыслов»

Эмбеддинги решают эту проблему. Они превращают слово не в одно число, а в вектор — длинный список координат (как на карте).

Представьте себе огромное многомерное пространство. Условно, назовем оси этого пространства признаками:

Ось X: «Степень животности» (от -1 (предметность) до +1).

Ось Y: «Степень съедобности».

Ось Z: «Степень пушистости».

Теперь мы можем расставить слова по координатам:

Кот: (Животное: +0.9, Съедобность: -1.0, Пушистость: +0.8)

Собака: (Животное: +0.9, Съедобность: -1.0, Пушистость: +0.5)

Груша: (Животное: -1.0, Съедобность: +0.9, Пушистость: 0.0)

Яблоко: (Животное: -1.0, Съедобность: +0.9, Пушистость: 0.0)

Расстояния:

Кот <-> Собака = 0.3 (близко — похожи)

Кот <-> Груша = 2.3 (далеко — не похожи)

(На самом деле осей там сотни или тысячи, и смысл их гораздо сложнее, но суть та же).

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

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

Кот и Собака находятся рядом в пространстве (потому что координаты похожи: оба животные).

Кот и Груша находятся далеко.

Вывод

Компьютер «знает», что кот и собака — это похожие понятия.

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

Важно

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

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

Аналогии (Математика смысла): с векторами можно производить математические операции. Если вы возьмете вектор слова «Король», вычтете вектор «Мужчина» и прибавите вектор «Женщина», вы получите вектор, ближайший к слову «Королева».

Формула выглядит так:

Король — Мужчина + Женщина = Королева.

Аналогия (векторная арифметика):

Король -> [0.8, 0.7, 0.3]

Мужчина -> [0.7, 0.6, 0.2]

Женщина -> [0.2, 0.7, 0.8]

— — — — — — — — — — — — — — — — — — — — — — — — —

Королева <- [0.3, 0.8, 0.9] (результат сложения/вычитания)

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

Подведём итог: что же мы получаем, переводя слова в векторы?

Итог

Эмбеддинги нужны, чтобы перевести текст (который ИИ не понимает) в координаты точек на карте смыслов (потому что с ними можно считать и находить закономерности).

Благодаря им, нейросеть понимает, что:

«Кот» и «кошка» — это почти одно и то же.

«Хороший» и «плохой» — противоположности (векторы смотрят в разные стороны).

Для инженера

Размерность эмбеддингов (например, 4096) напрямую влияет на способность модели различать тонкие оттенки смыслов и на объём памяти, занимаемой моделью.

Итак, эмбеддинги решили проблему «слепоты» модели к смыслу отдельных слов. Теперь компьютер знает, что «кот» и «кошка» — близкие понятия. Но в языке важен не только смысл самих слов, но и их порядок. Фразы «кот укусил собаку» и «собака укусила кота» состоят из одних и тех же слов, но означают прямо противоположное. Как сообщить модели, что порядок имеет значение? Для этого существует следующий механизм — позиционное кодирование.

1.3 Позиционное кодирование (Positional Encoding)

Эмбеддинги наделили каждое слово смыслом, расположив их в пространстве так, что «кот» и «кошка» оказались рядом. Но в языке важен не только смысл самих слов, но и их порядок. Фразы «кот укусил собаку» и «собака укусила кота» состоят из одних и тех же слов, но означают прямо противоположное. Если мы просто сложим эмбеддинги, модель не увидит разницы. Как же сообщить ей, что порядок имеет значение?

Вектор токена сам по себе не содержит информации о его позиции в последовательности. Чтобы модель могла различать порядок слов, к эмбеддингам добавляют специальную метку — позиционное кодирование (метка порядка слов). Но как именно его реализовать? Здесь инженеры придумали несколько способов, и выбор между ними влияет на то, как модель будет работать с длинными текстами.

За годы развития трансформеров два метода стали самыми популярными — каждый со своей философией и областью применения. Познакомимся с ними поближе.

RoPE

Rotary Position Embedding / вращательное позиционное кодирование (используют в LLaMA, DeepSeek);

Это способ объяснить нейросети порядок слов, не теряя при этом связь между ними. Представьте, каждое слово — это бусинка, нанизанная на длинную нить (это ось предложения). Если мы просто повесим табличку с номером, бусинка так и останется бусинкой. При использовании Rotary мы начинаем закручивать каждую бусинку по мере удаления от начала нити. Первая бусинка чуть-чуть повернута, вторая — еще немного, третья — еще сильнее… В итоге все бусинки закручены в спираль вокруг основной нити.

Почему это круто для связи между словами?

Потому что поворот — это геометрическое свойство. Когда нейросеть смотрит на две бусинки (два слова), она видит не просто их «номера», а угол между ними. Чем дальше слова друг от друга, тем больше этот угол (потому что они сильнее закручены). Модель обучается реагировать на эти углы.

Например, внимание (Attention) модели может быть настроено так: «Мне нужно найти слово, которое повернуто относительно текущего ровно на определенный угол». Это математически эквивалентно фразе «найди слово через два слова слева».

Как это работает

Проблема

Трансформер (мозг GPT) видит все слова сразу. Если не отметить позицию, для него фраза «Мальчик ударил мяч» и «Мяч ударил мальчика» будут одинаковыми.

Обычные методы

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

RoPE (Вращение)

Вместо того чтобы приписывать цифру, RoPE поворачивает вектор смысла слова. Чем дальше слово от начала, тем сильнее оно повернуто вокруг своей оси.

Почему это гениально?

Относительность

Нейросеть видит не только, что слово стоит на 5-м месте, но и угол поворота между словами. Это позволяет ей легко понимать зависимость между «далекими» словами (например, если в начале предложения было «он», а в конце — «потому что»).

Затухание

Вращение устроено так, что очень далекие слова «перекручиваются» и их влияние ослабевает (как в реальной жизни — первые слова уже слабо влияют на конец огромной книги).

RoPE — это хитрый способ накрутить на вектор слова спиральку, которая показывает его место в предложении, чтобы нейросеть понимала не только ЧТО сказано, но и в каком ПОРЯДКЕ.

Формула расчета угла поворота

angle_diff = (pos2 — pos1) / (10000 ^ (2i / d)), где

pos — номер позиции токена (1, 2, 3, …)

i — номер пары координат в векторе (0, 1, 2, …)

d — размерность вектора эмбеддинга (например, 4096)

10000 — базовая константа (выбрана эмпирически)

ALiBi

Attention with Linear Biases / внимание с линейными смещениями.

Еще один способ объяснить нейросети порядок слов, но работает он проще и эффективнее, чем сложное вращение RoPE.

Суть одной фразой

ALiBi наказывает далекие слова, вычитая из их «внимания» штраф, который растет пропорционально расстоянию.

Как это работает

Проблема

Нейросеть (трансформер) пытается понять связь между словами. Связь между близкими словами (например, «я» и «пошел») обычно сильнее, чем между далекими.

Механизм

Когда модель смотрит на два слова и решает, насколько они связаны, ALiBi просто вычитает число из оценки этой связи.

Если слова стоят рядом — штраф маленький (почти ноль).

Если между ними 10 слов — штраф побольше.

Если между ними 1000 слов — штраф огромный, модель понимает: «Они слишком далеко, забудь».

Почему это круто?

Длинные тексты

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

Простота

Не нужно сложных математических преобразований (вращений), как в RoPE. Просто берем и уменьшаем внимание к дальним словам.

ALiBi — это как линейка, которой модель бьет по рукам за попытку обращать слишком много внимания на слова, которые находятся далеко в тексте. Штраф растет ровно и предсказуемо (линейно), отсюда и название.

RoPE vs ALiBi

RoPE (вращательное кодирование):

Слова закручиваются по спирали, угол поворота = позиция

[Кот] ⁰° [съел] ⁹⁰° [мышь] ¹⁸⁰°

●────────●────────●

(чем дальше, тем больше поворот)

ALiBi (линейные смещения):

Внимание штрафуется за расстояние

Вес внимания = исходная_оценка — расстояние × штраф

Кот → съел: вес 0.9 — 1×0.1 = 0.8

Кот → мышь: вес 0.3 — 2×0.1 = 0.1

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

1.4 Механизм самовнимания (Self-Attention)

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

Каждый токен «смотрит» на все остальные и вычисляет, насколько они важны для его собственного представления. Но как один токен может «смотреть» на другой? Ведь у него нет глаз. В мире нейросетей это выглядит как математическая операция, для которой каждому слову выдаются три специальные роли:

Q — query (запрос) — что я ищу?

K — key (ключ) — что я могу дать?

V — value (значение) — какую информацию я несу?

Q, K, V — звучит загадочно, почти как код к сейфу. Но на самом деле за этими буквами скрывается простая и элегантная логика, которую легко понять на примере онлайн-кинотеатра.

Представьте, что вы зашли на Netflix и ищете, что посмотреть вечером. Ваш поисковый запрос — это Q (что я хочу?). Вы вводите «комедии с Адамом Сэндлером». Система смотрит на карточки фильмов — это K (ключи): у каждой карточки есть жанр, актёры, год выпуска. Она ищет карточки, которые лучше всего соответствуют вашему запросу. А когда нужные фильмы найдены, вы получаете доступ к их содержимому — это V (значения), то есть сами фильмы, которые можно смотреть.

Теперь представьте, что на сайт зашли одновременно миллионы пользователей. Каждый пользователь (Q) ищет своё, сравнивая свой запрос со всеми карточками фильмов (K). Самые подходящие фильмы (V) система рекомендует каждому. Именно это и происходит в механизме внимания — только вместо пользователей у нас токены, вместо карточек — их ключи, а вместо фильмов — их значения. И все эти сравнения происходят одновременно, за один вычислительный проход.

Разница лишь в том, что в кинотеатре пользователи конкурируют за внимание системы, а в механизме самовнимания каждый токен одновременно является и пользователем (ищет), и карточкой (описывает себя), и фильмом (несёт содержание).

В мире нейросетей всё работает точно так же, только вместо миллионов сайтов у нас — слова в предложении, а вместо поисковика — механизм внимания, который выполняется за доли секунды на GPU (подробно рассмотрено в главе 5.4).

Чтобы превратить нашу метафору в работающий алгоритм, нужно записать её на языке математики.

Технический уровень

Внимание (Attention (Q, K, V)) — это взвешенная сумма значений V, где веса определяются сходством Q и K.

Математически

Attention (Q, K, V) = softmax ((Q · K ^ T) / √ d ₖ) · V

Q · Kᵀ (Скалярное произведение)

Мы берем матрицу всех запросов (Q) и умножаем на матрицу всех ключей (K), транспонированную набок. На выходе получается матрица «совместимости» или «сырых весов». На пересечении слова *i* и слова *j* стоит число: насколько запрос слова *i* похож на ключ слова *j*.

/ √dₖ (Масштабирование)

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

softmax (Нормализация)

Превращаем полученные числа в вероятности, которые в сумме дают 1. Это и есть итоговые веса внимания (например, слово «банка» решило, что на 70% нужно смотреть на слово «открыла», на 20% на «положила», а на 10% на всё остальное).

· V (Умножение на значения)

Умножаем эти вероятности на матрицу значений (V). По сути, мы берем содержимое слов, умножаем на их важность и суммируем.

Результат

Для каждого слова мы получаем новый вектор, который вобрал в себя смысл контекста. В генеративных моделях (Decoder-only) внимание считается только к прошлым токенам, чтобы модель не «подглядывала» в будущее. Это критически важно для понимания разницы с энкодерами и называется каузальным вниманием (causal attention).

Сухие цифры и проценты — это хорошо, но давайте посмотрим на живую картину. Как реально выглядят эти веса внимания в работающей модели? Возьмём простое предложение и заглянем ей в голову.

Цветовая легенда

Красный (> 0.5) — сильная связь

Желтый (0.2—0.5) — средняя связь

Синий (<0.2) — слабая связь

Что мы видим:

«Она» и «бросила» — сильная связь (подлежащее-глагол)

«ей» и «Она» — сильная связь (оба об одном человеке)

«мяч» и «бросила» — сильная связь (глагол-объект)

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

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

1.5 Трансформерные блоки (Transformer Blocks)

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

Ниже приведен пример того как устроен один такой станок/трансформер и зачем нужна каждая его деталь.

1. Multi-Head Attention (Многоголовое внимание)

Это несколько параллельных механизмов внимания, каждый со своими матрицами Q, K, V. Они учатся выделять разные типы связей: грамматические, семантические, синтаксические, анафорические.

Что это

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

Технически

Это тот самый механизм Q/K/V, который мы разбирали, только запущенный параллельно несколько раз (например, 32 раза).

Зачем и почему

Одной «голове» внимания мало. Одна голова может искать синтаксис (связь подлежащего и сказуемого), вторая — семантику (похожесть слов «котик» и «собачка»), третья — кореференцию. Если голова одна, она запутается.

Но почему недостаточно одной «головы»? Дело в том, что связи между словами бывают разной природы. Одни — грамматические, другие — смысловые, третьи — указательные. Чтобы разобраться во всех, нужны разные специалисты. Например, есть особый тип связей, который называется кореференцией. Разберём его подробнее.

Кореференция — это явление, когда два или более выражений в тексте (слова, словосочетания) относятся к одному и тому же объекту реальности (человеку, предмету, явлению).

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

Простой пример

«Иван купил машину. Он очень рад ей.»

Иван и Он — кореферентны (оба указывают на одного и того же человека).

машину и ей — кореферентны (оба указывают на один и тот же предмет).

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

Результат

На выходе мы получаем векторы, которые уже «посмотрели» на соседей и впитали немного контекста.

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

2. Add & Norm (Добавление и нормализация) — Первый раз

Состоит из

Add (Остаточная связь)

Мы берем вход, который зашел в блок ДО Attention, и прибавляем его к выходу Attention.

Norm (Слоевая нормализация)

Мы «причесываем» полученную сумму, чтобы числа не выходили за разумные пределы.

Зачем и почему

Add (Зачем складывать?)

Представьте, что вы учитесь рисовать сложный портрет. Attention — это ваш новый штрих, который фокусируется на самой важной детали (глазах или улыбке) в данный момент, игнорируя шум. Если штрих неудачный, вы можете мысленно откатиться назад и начать заново, пересчитав веса. Остаточная связь (Skip Connection) — это ваш «ластик» и «карандаш» одновременно: она позволяет модели на глубоких слоях не забывать исходный набросок (то, что было в начале). Если следующий слой не привнес ничего полезного, он может просто «пропустить» информацию дальше (скопировать вход), словно вы ничего не меняете в удачном участке рисунка. Именно этот механизм «сквозного пути» помогает обучать очень глубокие сети (32+ слоя), спасая градиенты4 от затухания, — ведь ошибка распространяется обратно не через все дебри слоев, а по прямой короткой дороге.

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

Norm (Зачем нормализовать?)

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

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

Add — это как если бы художник, сделав новый штрих, всё время держал перед глазами исходный набросок. Если новый штрих не удался, он всегда может вернуться к оригиналу. Norm — это «причесывание» красок, чтобы они не растекались и не смешивались в грязь.

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

3. Feed-Forward Network (FFN) — Сеть прямого распространения

Что это

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

Технически

Сначала вектор расширяется в 4 раза (например, с 4096 до 16384 нейронов), потом сжимается обратно. Внутри — нелинейная функция (например, SwiGLU (Swish-Gated Linear Unit) или GeLU (Gaussian Error Linear Unit) — функции активации, улучшающие обучение) — они просто решают, какие нейроны зажечь, а какие погасить).

Зачем и почему

Attention смешивает информацию между токенами (как бы по горизонтали). FFN же работает внутри одного токена (вертикально). После того как токен «послушал» соседей, ему нужно этот новый услышанный смысл переварить и записать в удобном виде.

Аналогия

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

Почему FFN называют чёрным ящиком (даже инженеры)

Мы спроектировали FFN: два линейных слоя, нелинейность между ними, расширение в 4 раза и сжатие обратно. Архитектура полностью прозрачна. Но числа внутри — веса — выучились автоматически из данных. И вот тут начинается проблема.

Мы не можем открыть обученную модель, ткнуть пальцем в конкретный нейрон и сказать: «вот этот отвечает за котов, а этот — за глагол „есть“». Знание не локализовано. Оно размазано по миллионам параметров.

Более того, мы не можем объяснить на человеческом языке, почему конкретный входной вектор превратился в конкретный выходной. Ответ всегда один: «потому что так сошлись миллиарды умножений».

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

И это фундаментальное ограничение. Не баг. Не фича. Просто реальность глубоких нейросетей.

4. Add & Norm (Добавление и нормализация) — Второй раз

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

Что это

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

Зачем

Опять страхуемся, чтобы FFN не испортила то, что насобирал Attention. Если FFN сработала плохо, у нас есть «путь обхода» через остаточную связь.

Мы разобрали, как устроен один блок. Но в настоящем трансформере таких блоков не один, а десятки — от 32 до 128 и больше. Зачем нужно так много? Неужели одного недостаточно?

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

Каждый следующий блок строит абстракцию5.

Слой 1: Видит буквы и слоги. Понимает, что «кот» — это одно слово.

Слой 2—5: Видит словосочетания («рыжий кот»).

Слой 10—20: Видит роли в предложении (кто действует, на кого действует).

Слой 30+: Видит смысл всего абзаца, тон, настроение, сложные логические связи.

Эти данные подтверждены визуализациями активаций нейросетей — например, в работах OpenAI (2019) по анализу GPT-2, где исследователи наглядно показали, как разные слои модели отвечают за разные уровни абстракции: от отдельных токенов до целых предложений и их смысла.

Если слоев мало — модель «мелковата» и может понимать только простые фразы. Чем больше слоев, тем сложнее концепции она способна выучить, но тем сложнее ее обучить (тут-то и помогают Add & Norm связи).

Как работает трансформер на уровне логики по шагам и на примере можно ознакомиться в Приложении 1.

Итак, после прохождения через все блоки у нас есть векторы, которые вобрали в себя и смысл каждого слова, и его связи с другими словами, и контекст всего предложения. Это — глубокое понимание текста, выраженное на языке чисел. Но наша цель — не просто понять, а сгенерировать ответ. Как из этого богатого внутреннего представления рождается новое слово? Об этом — в следующем разделе.

1.6 Выходной слой и генерация

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

После последнего блока вектор каждого токена преобразуется в вероятность следующего токена через LM Head (language modeling head / головная сеть языкового моделирования) — это линейная проекция на размер словаря с последующей функцией softmax.

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

1. Логиты и Softmax (Как получить вероятности)

Логиты — это «сырые» оценки, которые мозг ИИ выдает каждому слову. Например, кот = 100, собака = 90, астероид = 1. Это просто баллы, они могут быть любыми (хоть 1000, хоть -5). Сами по себе они неудобны для выбора.

Но логиты — это просто числа. Они могут быть 100, 90, 1, -5 — сами по себе они не говорят, насколько вероятно то или иное слово. Чтобы получить удобоваримые вероятности, нужен специальный преобразователь.

Softmax — это функция, которая превращает эти сырые баллы в проценты (вероятности), чтобы их сумма равнялась 100%. Результат: кот = 60%, собака = 39%, астероид = 1%.

Итак, у нас есть честные вероятности: кот 60%, собака 39%, астероид 1%. Казалось бы, всегда выбирай самое вероятное — и дело с концом. Но такой подход сделает текст скучным и предсказуемым. Иногда нам нужна креативность, иногда — строгая точность. Для этого инженеры придумали несколько регулировок.

На этапе генерации модель не всегда выбирает токен с максимальной вероятностью. Используются параметры:

2. Температура (Temperature)

Первая и самая известная регулировка — температура. Это ручка, которая крутит «креативность» модели. T -> 0 (Холодно): Модель становится жадной и почти всегда выбирает самое вероятное слово (Кот). Текст получается точный, но скучный и предсказуемый.

T = 1 (Норма): Оставляем проценты как есть (Кот 60%, Собака 39%).

T> 1 (Горячо): Модель выравнивает шансы. Кот может получить 35%, Собака 34%, и даже Астероид 31%. Модель начинает «креативно» выбирать странные варианты, но может начать бредить.

Иногда же нам нужно сказать: «Редкие слова не рассматриваем, оставляем только основных претендентов». Для этого есть два фильтра — P и K.

3. Top-P (Ядро, nucleus sampling)

Это фильтр «пока не накопится».

Как работает

Модель сортирует слова от самых вероятных к самым редким и складывает их проценты, пока сумма не достигнет порога P (например, 0.9 или 90%). Остальные слова выкидываются.

Пример

Вы включили этот фильтр. Модель берет Кота (60%) + Собаку (39%) = 99% (порог P=0.9 пройден). Астероид (1%) вылетает, потому что он лишний. Выбор идет только между Котом и Собакой.

4. Top-K (K-лучших)

Top-P работает по принципу «накопи достаточно». А есть другой подход — более жёсткий: оставить ровно K лучших, и точка. Это фильтр «оставить только K претендентов». Модель оставляет только K самых вероятных слов, все остальные отсекает.

Пример: K=2. Оставляем Кота (60%) и Собаку (39%). Астероид (1%) вылетает. Выбор только из двух.

Итог

> Логиты — оценки.

> Softmax — превращает оценки в понятные доли.

> Температура — делает выбор более плоским или острым.

> Top-P — оставляет слова, пока не наберется нужная сумма вероятностей.

> Top-K — оставляет строго K самых вероятных слов.

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

Теперь вы знаете главные рычаги управления генерацией. Комбинируя температуру, Top-P и Top-K, можно получать и строгие технические тексты, и творческие рассказы, и всё что между ними. Инженерный выбор зависит от задачи.

Мы замкнули цикл. От одинокого токена на входе мы дошли до генерации нового слова на выходе. Теперь вы понимаете, как устроен «мозг» современных языковых моделей — от первой до последней операции.

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

1.7 Галлюцинации: когда модель уверенно врёт

Мы разобрали, как модель генерирует текст: шаг за шагом, выбирая следующее слово на основе вероятностей. Но из этого механизма вытекает фундаментальная особенность, о которой нельзя молчать.

Что такое галлюцинация?

Галлюцинация

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

Модель может

• Придумать несуществующую цитату из книги, которой вы её спросили;

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

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

• Описать функциональность API, которого никогда не существовало.

Почему это происходит?

Не потому, что модель «врет» в человеческом смысле. У неё нет намерения обманывать. У неё вообще нет намерений.

Причина — в самой природе генеративного трансформера:

Вероятностная природа

Модель не хранит «базу фактов». Она хранит статистику — какие последовательности токенов с какой вероятностью встречались в обучающих данных. Когда она предсказывает следующее слово, она выбирает вариант, который статистически правдоподобен. Но «правдоподобно» не равно «истинно»: высокая вероятность совпадения с обучающей выборкой — это всего лишь мера привычности, а не гарантия достоверности. И чем разнороднее были данные, тем выше шанс, что статистически яркий, но фактически ошибочный паттерн выстрелит в ответе.

Отсутствие референции

Модель не имеет доступа к «источнику истины». Она не может «посмотреть в энциклопедию» во время генерации (если только вы не добавили RAG — Retrieval-Augmented Generation — Поиск и генерация). Она работает только с тем, что у неё есть в весах и в контекстном окне. Если нужной информации нет, она не скажет «я не знаю», а сгенерирует наиболее вероятное продолжение — которое может оказаться вымыслом. Именно поэтому большие языковые модели так уверенно галлюцинируют: для них статистическое правдоподобие и фактическая истина — разные вещи, а механизма различения между ними попросту не заложено.

Компрессия знаний

Обучение модели

Это сжатие триллионов токенов в миллиарды параметров. Как в любом сжатии, часть информации теряется. Модель «запоминает» общие закономерности, но может забыть (или смешать) редкие детали. Когда её спрашивают о таком редком факте, она «восстанавливает» его по аналогии — и часто ошибается.

Соблазн угодить

В процессе RLHF модели учат быть полезными. Иногда это приводит к тому, что модель предпочитает дать какой-то ответ, даже если не уверена, вместо того чтобы признаться в незнании.

Инженерный взгляд: это не баг, это особенность архитектуры

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

Их можно снижать, но нельзя устранить полностью:

Увеличением контекста

Чем больше релевантной информации вы дадите модели в промте, тем меньше ей придется «додумывать».

RAG (Retrieval-Augmented Generation)

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

Дообучением

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

Температурой и Top-P

Снижение «креативности» (температура → 0) уменьшает вероятность выбора неожиданных, а значит, потенциально ложных вариантов.

Ансамблями

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

Что это значит для вас

Если вы строите систему, где фактические ошибки недопустимы (медицина, юриспруденция, финансы), вы не можете полагаться на одну LLM в чистом виде. Вам нужны дополнительные слои: проверка фактов, RAG, контрольные модели-критики, человеческая валидация.

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

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

1.8 RAG: как модель не выдумывает факты

В разделе 1.7 мы выяснили, что галлюцинации — фундаментальное свойство генеративных моделей. Но их можно снижать. Самый эффективный способ — RAG (Retrieval-Augmented Generation). Однако RAG не устраняет галлюцинации полностью — он лишь заменяет одни их источники на другие: вместо выдумывания из памяти модель начинает ошибаться в извлечении, ранжировании или игнорировании найденных документов.

Проблема

Модель знает только то, что выучила во время обучения (данные 2024–2025). Она не знает ваш договор, переписку или свежие новости.

Идея RAG

Перед тем как ответить, модель идёт в базу знаний (векторную БД), находит там релевантные документы и подставляет их в контекст. Ответ строится не на памяти модели, а на фактах из ваших документов. Однако важно понимать: RAG не переучивает модель — он лишь временно докладывает документы в окно контекста, поэтому после ответа модель «забывает» эти данные.

Как именно модель ищет документы? Каждый документ (или его фрагмент) превращается в вектор — эмбеддинг. Эмбеддинги устроены так, что семантически похожие тексты оказываются рядом в пространстве. Запрос пользователя тоже превращается в вектор, и база данных найдет документы с самыми близкими векторами. Для этого используют специальные эмбеддинг-модели (например, intfloat/multilingual-e5-large), которые обучаются максимально точно отражать смысл текста в векторе.

Семантический поиск

Это как раз то, что здесь описано. Поиск по смыслу, а не по словам («автомобиль» найдёт «машина», «транспортное средство» и «железный конь»). В отличие от лексического поиска (как Ctrl+F), он работает через эмбеддинги. Именно благодаря ему RAG понимает, какие документы реально релевантны запросу, даже если слова не совпадают буквально.

Критический нюанс

Размер фрагмента (chunk size) при индексации сильно влияет на качество — слишком короткие чанки теряют контекст, слишком длинные размывают релевантность.

Как это работает (метафора)

Представьте, что вы сдаёте экзамен по открытой книге. Модель без RAG — это студент, который учил билеты год назад и всё забыл. Модель с RAG — это студент, который открывает книгу, находит нужную страницу и читает ответ с неё. Но даже с открытой книгой студент может прочитать не тот параграф — поэтому критически важна гигиена данных: мусор в базе знаний ведёт к мусору в ответе. Качество индексации и чанкинга важнее самой модели.

Почему RAG не заменяет память модели

• RAG требует хорошего поиска. Если поиск нашёл не тот документ — ответ будет неверным.

• RAG не добавляет «понимания». Модель может прочитать правильный документ, но интерпретировать его неправильно.

• RAG медленнее (поиск в БД + генерация). На практике латентность RAG-пайплайна часто складывается из трёх этапов: эмбеддинг запроса (десятки мс), поиск по индексу (единицы-сотни мс) и генерация LLM (секунды).

Когда RAG обязателен

• Работа с вашими документами (двойник, корпоративный чат-бот);

• Актуальные данные (новости, курс валют);

• Ситуации, где галлюцинации недопустимы (юриспруденция, медицина).

Есть и обратная сторона

RAG бесполезен для задач, требующих обобщения знаний со всего корпуса документов (например, «какие основные тренды были во всех наших договорах за 5 лет?») — здесь поиск по отдельным чанкам принципиально не работает, нужны другие подходы.

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

С точки зрения бизнеса, RAG — это единственный способ сделать LLM аудитируемой: вы всегда можете посмотреть, на какой документ ссылалась модель, и проверить факт, тогда как при дообучении (fine-tuning) факты «вшиваются» в веса и становятся непроверяемыми.

Для регуляторики (GDPR, HIPAA, персональные данные) RAG безопаснее дообучения, потому что документы не покидают вашу базу знаний — модель только читает их в рантайме, а не запоминает навсегда.

Самый недооценённый факт

RAG резко снижает стоимость эксплуатации — обновить документы в векторной БД стоит копейки и не требует переобучения модели за десятки тысяч долларов, как в случае с fine-tuning.

Инженерный вывод

Чистая LLM без RAG — это экзамен без книг. Хорошо для творчества, плохо для фактов. RAG — это открытая книга. Медленнее, но честнее. На практике гибридные системы (RAG + дообучение на фактах) дают лучший результат, но стоят дороже.

Чек-лист: когда RAG работает (а когда — нет)

RAG — не панацея. Есть задачи, где он обязателен, есть — где бесполезен, а есть — где даже вреден.

Главное ограничение

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

Правило

RAG — это не «улучшатель модели». Это архитектура. Если у вас нет качественного поиска — не будет и качественного RAG.

Что делать, если RAG не помог (три следующих шага)

Вы настроили RAG, но модель всё равно галлюцинирует или отвечает невпопад. Что проверять?

Шаг 1. Диагностика поиска (самое частое узкое место)

Вывод RAG

«Я нашёл 5 фрагментов». Откройте их вручную. Релевантны ли они? Если нет — проблема не в модели, а в эмбеддерах или чанкинге.

Чанки (фрагменты текста) слишком большие → модель не удерживает внимание, теряет факты в длинном тексте.

Чанки слишком маленькие → потерян контекст, фрагмент вырван из общего смысла.

Эмбеддер не понимает язык/домен → берите multilingual-e5-large или дообучайте свой.

Шаг 2. Reranking (двухпроходный поиск)

Сначала находим 20–50 фрагментов быстрым векторным поиском. Потом пропускаем их через модель-кросс-энкодер (медленную, но точную), которая переранжирует и оставляет 3–5 самых релевантных. Это стандарт для серьёзных RAG-систем (например, Cohere Rerank, BGE-reranker).

Шаг 3. Порог уверенности и fallback

Если максимальное сходство найденного фрагмента ниже порога (например, 0.7) — модель должна сказать «не знаю», а не пытаться ответить. Добавьте в промпт:

«Если в найденных документах нет прямого ответа на вопрос — скажи: „Информация не найдена. Уточните запрос“. Не додумывай.»

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

Эволюция RAG: графы и гибридный поиск

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

Примеры таких запросов

«Какие компоненты нашей системы зависят от сервиса платежей?»

«Кто тестировал модуль, который упал вчера на проде?»

«Какие контракты связывают поставщика X с нашей компанией через других юрлиц?»

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

Паровозик знаний (GraphRAG)

Идея

Построить из документов граф знаний — сущности (люди, компании, документы, сервисы) и связи между ними («владеет», «зависит от», «отвечает за»). Запрос превращается не в поиск похожих фрагментов, а в обход графа по цепочкам.

Пример:

Запрос «Кому писать, если упал платёжный шлюз?»

Стартуем от сущности «платёжный шлюз».

Идём по связи «используется в» → «модуль оплаты».

От модуля по связи «отвечает за» → «тимлид Иванов».

От Иванова по связи «подписан на» → канал оповещений.

LLM получает не разрозненные цитаты, а связный подграф — и может дать точный, обоснованный ответ.

GraphRAG даёт выигрыш в точности на сложных, многозвеньевых запросах (multi-hop) до 50–70% по сравнению с классическим RAG. Но требует значительно больших усилий на внедрение (строить граф, поддерживать его актуальность, настраивать обход).

Гибридный поиск и реранкинг (без графов, но проще)

Если строить граф пока не нужно, но точности векторного поиска не хватает — можно усилить классический RAG без перехода к графу.

Гибридный поиск

Комбинация BM25 (точный поиск по словам, как в старых поисковиках) и векторного (похожий смысл). BM25 ищет «инвойс AС-457», векторный — «документ про задержку оплаты». Выбор лучшего из двух или их взвешенная сумма дают более стабильный результат.

Ретривер

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

Реранкинг (переранжирование)

Сначала ретривер быстро находит 20–50 кандидатов (дешёво, неточно), а маленькая модель-кросс-энкодер (медленно, дорого) пересортировывает и оставляет топ-3–5 самых релевантных.

Важно: если документы, на которых вы строите RAG, содержат сведения о финансовых операциях (платежи, переводы), при передаче их в LLM необходимо соблюдать требования 115-ФЗ и 152-ФЗ

РЕЗЮМЕ ГЛАВЫ 1

Токен — минимальная единица текста для модели (может быть словом, частью слова или символом), а также единица измерения стоимости и скорости инференса.

Токенизация разбивает текст на токены с помощью BPE или SentencePiece; размер словаря обычно 32K–256K токенов.

Разные языки «весят» по-разному: английский — 1.0—1.5 токена на слово, русский — 1.5—2.0, китайский — 2.0–3.0, что напрямую влияет на бюджет.

Эмбеддинги превращают токены (числа) в векторы — координаты в многомерном пространстве смыслов, где близкие по смыслу слова находятся рядом.

Номер токена — не случайность, а результат статистической иерархии. Базовые символы (буквы, цифры, знаки препинания, пробелы) получают номера первыми. Частотные пары «склеиваются» в новые токены, и чем больше номер, тем глубже токен «упакован» из более мелких частей. Пробелы и знаки препинания — полноправные участники этого процесса.

Разница в «весе» языков (английский 1.0—1.5, русский 1.5—2.0, китайский 2.0–3.0) — не лингвистическое превосходство английского, а исторический артефакт. Токенизаторы обучались на англоцентричных корпусах. При обучении на корпусе с доминированием другого языка коэффициенты поменяются местами. Китайские модели (Qwen, DeepSeek) и русскоязычные (GigaChat, YandexGPT) уже демонстрируют, что локальный язык можно сделать столь же «экономным», как английский, а иногда и экономичнее.

Векторная арифметика работает: Король — Мужчина + Женщина = Королева; это прямое следствие геометрии смыслов.

Позиционное кодирование добавляет информацию о порядке слов; два основных метода: RoPE (вращение векторов) и ALiBi (штраф за расстояние).

Механизм самовнимания (Self-Attention) позволяет словам обмениваться информацией через триплеты Q (запрос), K (ключ), V (значение).

Формула внимания: Attention = softmax (Q·K/√d) ·V, где каждый шаг имеет инженерный смысл (совместимость, масштабирование, нормализация, взвешенная сумма).

Кореференция — явление, когда разные слова в тексте указывают на один объект («Иван купил машину. Он рад ей»); без неё текст был бы набором повторов.

Multi-Head Attention — несколько параллельных механизмов внимания, каждый ищет свои типы связей (синтаксис, семантику, кореференцию).

FFN (сеть прямого распространения) внутри каждого блока переваривает информацию после «совещания» внимания; без FFN модель просто перекладывала бы слова.

Add & Norm (остаточная связь + нормализация) позволяет информации течь через глубокие сети без затухания — как «ластик» для неудачных штрихов.

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

Трансформерные блоки состоят из Multi-Head Attention, Add&Norm, FFN и второго Add&Norm; 32–128 таких блоков создают глубокое понимание текста.

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

RAG (Retrieval-Augmented Generation) — метод борьбы с галлюцинациями: перед генерацией модель ищет релевантные документы в векторной БД и подставляет их в контекст. Это как «экзамен по открытой книге» — факты берутся из документов, а не из памяти модели. Обязателен для задач, где ложь недопустима (юриспруденция, медицина, работа с документами). Минусы: зависит от качества поиска, медленнее чистой генерации.

Вопросы для самопроверки

1. Что такое токен и почему он является не только лингвистической, но и экономической единицей?

2. Объясните своими словами, чем эмбеддинги лучше простого присвоения числовых индексов словам.

3. В чём принципиальная разница между позиционным кодированием RoPE и ALiBi? Для каких задач стоит выбирать каждый из методов?

4. Опишите, что происходит на каждом из четырёх шагов формулы Attention (Q, K, V) = softmax (Q·K/√d) ·V.

5. Почему в трансформере используется не одна, а множество «голов внимания» (Multi-Head Attention)?

6. Зачем нужна остаточная связь (Add) и нормализация (Norm) внутри трансформерного блока?

7. Что произойдёт с качеством модели, если убрать FFN-слои и оставить только Attention?

8. Какие параметры влияют на «креативность» генерации текста и как именно?

9. Что такое RAG? Почему он помогает бороться с галлюцинациями? В чём его ограничения и когда он обязателен?

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

ГЛАВА 2. ТИПЫ АРХИТЕКТУР НЕЙРОСЕТЕЙ

«Иерархическое распознавание шаблонов — вот ключ к пониманию того, как мозг, а вслед за ним и нейросети, строят картину мира»

— из работ по глубокому обучению

«Иерархическое распознавание шаблонов — вот ключ к пониманию того, как мозг, а вслед за ним и нейросети, строят картину мира» — из работ по глубокому обучению

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

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

2.1 CNN Convolutional Neural Network / Свёрточная нейросеть

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

Представьте, что вы рассматриваете фотографию не целиком, а через маленькое окошко, которое ползает по картинке. Это и есть свертка (convolution).

Давайте разберем все части этого определения на простом примере — поиске границ на фотографии.

1. Скользящее окно (Как это движется?)

Что это

Представьте, что изображение — это поле 10x10 клеточек. Скользящее окно — это рамка размером 3x3 клеточки (как в игре «Сапёр», когда ты открываешь клетку и видишь соседей).

Как работает

Мы ставим эту рамку в левый верхний угол, смотрим на 9 пикселей внутри. Потом сдвигаем рамку на 1 шаг вправо, опять смотрим. Прошли строчку — переходим на следующую. Так окно «прочесывает» всю картинку.

2. Обучаемые фильтры (Что ищет окно?)

Внутри этого окошка есть специальная табличка с числами — фильтр (или ядро свертки). Фильтр — это детектор. В начале обучения эти числа случайные, но потом они «обучаются» искать конкретные вещи.

Фильтр на поиск горизонтальных границ

Если внутри окошка картинка резко меняется сверху (темно) вниз (светло), фильтр выдает большое число. Если картинка однородная, фильтр выдает ноль.

Фильтр на поиск углов

Реагирует на диагональные линии.

Фильтр на поиск цвета

Реагирует на красные пятна.

Практическая польза

Мы не программируем правила «ищи вертикальную линию» ручками. Нейросеть сама подбирает числа в фильтрах во время обучения, чтобы находить то, что нужно для задачи (например, для распознавания котиков).

Фильтры умеют находить линии, границы, углы. Но почему это работает именно с картинками, а не с текстом? Потому что у изображений есть важное свойство — пространственная структура.

3. Пространственная структура (Почему это важно?)

Что это значит

В данных важен порядок элементов. У пикселя есть соседи сверху, снизу, слева и справа. Если перемешать пиксели как попало, картинка рассыплется, и смысл пропадет.

Зачем это свёртке

Свёртка использует эту структуру. Она смотрит на локальные группы пикселей (близких соседей), чтобы понять простые вещи (края, текстуры), а потом из простых вещей собирает сложные (глаз, ухо, нос).

Главная практическая польза (3 вещи)

1. Экономия ресурсов (разреженность)

Обычная полносвязная нейросеть на картинку 1000x1000 пикселей с тремя цветовыми каналами потребовала бы около 3 миллионов входных нейронов и, если следующий слой тоже будет размером 1000x1000, около 3×10¹² связей — это триллионы параметров.

2. Инвариантность к положению (неважно, где объект)

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

3. Иерархия признаков

• Первые слои видят просто линии и точки;

• Средние слои видят комбинации линий (круги, прямоугольники) — например, колесо;

• Глубокие слои видят сложные объекты (машина, дом).

Почему в тексте используется редко?

У текста нет такой сильной пространственной структуры. Если в тексте переставить два соседних слова, смысл может измениться кардинально или остаться тем же. А если на картинке переставить два пикселя местами, это будет уже «шум». Для текста лучше подходит трансформер (внимание), который смотрит на связь слов попарно, независимо от расстояния, а не только на соседей в окошке.

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

2.2 RNN (Recurrent Neural Network / Рекуррентная нейросеть)

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

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

RNN обрабатывает последовательности шаг за шагом, передавая скрытое состояние. Она плохо параллелизуется и страдает от затухания градиента. Практически вытеснена трансформерами.

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

1. Скрытое состояние (Память в голове)

Что это

У RNN есть внутренняя переменная — вектор скрытого состояния (hidden state). Это как блокнотик, в котором нейросеть записывает свои мысли по ходу чтения.

Технически

Это просто набор чисел, которые меняются после каждого прочитанного слова.

2. Обработка шаг за шагом (Последовательность)

RNN не смотрит на весь текст сразу. Она читает его строго по порядку, слово за словом.

Как это выглядит на примере фразы

«Кот съел мышь»:

Шаг 1 (Кот)

Смотрит на слово «Кот» + чистый блокнот (пустая память). Записывает в блокнот: «Вижу кота».

Шаг 2 (съел)

Смотрит на слово «съел» + читает блокнот (там про кота). Понимает: «Кот что-то делает». Обновляет блокнот: «Кот сейчас ест».

Шаг 3 (мышь)

Смотрит на слово «мышь» + читает блокнот (там про кота, который ест). Понимает: «Кот съел мышь. Логично».

Формула одной фразой

Новое состояние = Функция (Текущее слово, Старое состояние)

3. Проблема 1: Плохая параллелизация (Медленность)

Пока вы не прочитаете слово «съел», вы не можете понять слово «мышь», потому что память еще не обновилась.

Для процессора это ад: Нельзя обработать все слова одновременно (распараллелить), как в трансформере. Приходится ждать окончания первого шага, чтобы начать второй. На длинных текстах это очень медленно.

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

4. Проблема 2: Затухание градиента (Забывчивость)

Это главная техническая боль RNN. Представьте предложение: «В далеком 1991 году, когда шел сильный дождь, а на часах было уже поздно, я… вышел из дома».

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

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

Итог

RNN хорошо помнит последние 5—10 слов, но забывает, что было в начале абзаца. Она страдает от кратковременной памяти.

Инженеры пытались бороться с этим, тщательно подбирая начальные значения весов и используя специальные техники вроде отсечения градиентов (gradient clipping). Но это были лишь костыли — проблема оставалась в архитектуре, и для действительно длинных последовательностей RNN оставались бессильны.

Почему их вытеснили Трансформеры?

RNN

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

Но инженеры не сдавались так легко. Они придумали, как улучшить память RNN, добавив специальные вентили, которые решают, что забывать, а что помнить. Так появились LSTM — долгая краткосрочная память. О них — в следующем разделе.

2.3 LSTM (Long Short-Term Memory / Долгая краткосрочная память)

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

LSTM — это вариант RNN с вентилями: входным, забывания и выходным. Она решает проблему долгосрочной памяти, но всё так же не параллелится.

LSTM расшифровывается как Long Short-Term Memory — долгая краткосрочная память. В названии уже скрыта суть: это всё ещё рекуррентная сеть с краткосрочной памятью (как RNN), но теперь она может хранить информацию гораздо дольше. Давайте разберёмся, как ей это удаётся.

Чтобы понять, чем LSTM отличается от обычной RNN, представьте, что простая RNN — это человек, который при чтении книги каждый раз переписывает свой блокнот заново, стирая всё старое. LSTM же ведёт себя как опытный читатель: он носит с собой стопку стикеров-напоминалок и периодически выбрасывает те, что уже не нужны, оставляя важное.

Как же устроен этот «умный блокнот»? В LSTM появляется дополнительная «лента конвейера», которая тянется через всю сеть и несёт в себе важную информацию, почти не меняясь. А три специальных вентиля решают, что с этой лентой делать.

1. Проблема, которую решает LSTM

Обычная RNN страдает от кратковременной памяти. Она помнит последние слова, но забывает начало предложения. LSTM ввели специальный механизм — ленту конвейера (cell state) и вентили (gates), которые решают, какую информацию пронести через всю последовательность нетронутой.

2. Как это работает (Три вентиля)

У LSTM есть три хитрых фильтра, которые регулируют поток информации. Снова пример с предложением: «Кот (1) … (много слов) … (2) наелся и (3) спит».

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

Вентиль 1: Забывание (Forget Gate) — «Что выкинуть?»

Вопрос:

«Старая информация о коте всё ещё нужна или уже пора её забыть?»

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

А когда дошли до слова «спит», можно чуть ослабить информацию о том, что он «ел», оставив только факт наличия кота.

Вентиль 2: Входной (Input Gate) — «Что записать нового?»

Вопрос:

«Какая информация из нового слова („наелся“) действительно важна и её стоит добавить в ленту конвейера?»

Модель решает: «Факт того, что кот сыт, важен. Добавляю его в ленту памяти».

Вентиль 3: Выходной (Output Gate) — «Что показать миру?»

Вопрос:

«Основываясь на всей ленте памяти (кот + сыт), что я должен выдать как результат прямо сейчас?»

На выходе мы получаем новое скрытое состояние (которое пойдет в следующий шаг), но сама лента памяти остаётся нетронутой для будущих шагов.

3. Почему LSTM круче RNN?

Благодаря этим вентилям, LSTM может протащить важную информацию через сотни шагов.

Пример: в начале текста было слово «Она». LSTM держит это в ленте памяти, не перезаписывая. Через 50 слов встречается глагол «пошла». LSTM сверяется с лентой, видит там «Она» и понимает, что нужно использовать женский род. RNN к этому моменту уже забыла бы, о ком речь.

4. Недостатки (Почему и её вытеснили)

LSTM решила проблему забывания, но унаследовала главную проблему RNN — последовательность:

Нет параллелизации

Чтобы обработать 1000-е слово, нужно дождаться результатов обработки 999 предыдущих. На современных видеокартах (GPU), которые любят считать всё одновременно, это очень медленно.

Сложность

Три вентиля делают архитектуру громоздкой и требовательной к ресурсам. Каждый вентиль — это отдельная нейросеть со своими весами, поэтому LSTM требует значительно больше памяти и вычислений, чем простая RNN.

LSTM

Это RNN с «умным блокнотом». Вместо того чтобы просто переписывать страницу, она решает, какие старые записи вычеркнуть (forget gate), какие новые внести (input gate) и что сейчас прочитать вслух (output gate). Длинную память это лечит, но скорость работы остаётся последовательной, что в итоге привело к победе Трансформеров.

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

2.4 GRU (Gated Recurrent Unit / Рекуррентный блок с вентилями)

GRU

Это упрощённая версия LSTM, объединяющая входной вентиль и вентиль забывания в один «вентиль обновления» (update gate). У GRU всего два вентиля вместо трёх, и нет отдельного состояния ячейки — только скрытое состояние. Это даёт примерно на 25–30% меньше параметров и чуть более быстрые вычисления, но на очень длинных последовательностях (сотни шагов) LSTM может показывать slightly better результаты.

Это LSTM, который уволил лишнего менеджера. За счёт такого сокращения GRU работает быстрее и требует меньше памяти. Но, как водится, за скорость приходится платить — чуть-чуть качеством на очень длинных последовательностях.

Представьте, что LSTM — это отдел с тремя сотрудниками: один решает, что забыть (forget gate), второй — что записать нового (input gate), третий — что показать на выходе (output gate). GRU оставляет только двоих:

Reset gate — «Секретарь»: решает, какую часть старых записей вообще не брать в расчёт (игнорировать прошлое).

Update gate — «Руководитель»: сразу решает две задачи — сколько нового взять из текущего слова и сколько старого сохранить (совмещает функции input и forget gate).

Зачем? Меньше сотрудников — меньше зарплата (параметры) и быстрее работа. GRU чуть проще, чем LSTM, и на многих задачах показывает почти то же качество. Но если текст очень длинный и связи сложные, LSTM всё же точнее.

Практическое применение

• Машинный перевод (Google Translate, Яндекс. Переводчик);

• Распознавание речи (Siri, Алиса);

• Генерация текста (автодополнение в поиске, чат-боты);

• Анализ временных рядов (прогноз цен акций, погоды);

• Обработка видео (анализ действий по кадрам).

Главное отличие от LSTM

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

RNN, LSTM, GRU — все они пытались работать с последовательностями шаг за шагом, и все упирались в одну и ту же стену: их нельзя было распараллелить. Нужно было принципиально новое решение, которое смотрело бы на текст сразу целиком. И в 2017 году оно появилось. Революция случилась — на сцену вышел Трансформер.

2.5 Трансформер (Transformer)

Все архитектуры, которые мы рассмотрели до сих пор — CNN, RNN, LSTM, GRU — были великими для своего времени, но у каждой находились фатальные недостатки. CNN не понимали порядок слов, RNN забывали начало предложения, LSTM и GRU были слишком медленными из-за последовательной обработки. Нужен был прорыв.

И в 2017 году команда Google опубликовала статью с громким названием «Attention Is All You Need». Так родился Трансформер — архитектура, которая стёрла все предыдущие с доски лидеров.

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

Что такое трансформер?

Технически

Трансформер — это архитектура нейросетей, основанная исключительно на механизме самовнимания (self-attention). Он позволяет модели вычислять попарные веса важности между всеми токенами последовательности за один проход. Благодаря этому каждый токен может напрямую взаимодействовать с любым другим, независимо от расстояния, а все вычисления легко распараллеливаются на GPU.

Метафора

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

Три кита, на которых стоит трансформер

Прежде чем разбирать семейства моделей, запомните три главные идеи, которые сделали трансформер революцией:

1. САМОВНИМАНИЕ (Self-Attention)

Каждый токен «смотрит» на все остальные и решает, кто для него важен. Это как совещание, где каждый слушает каждого.

2. ПАРАЛЛЕЛИЗМ (Parallelism)

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

3. МНОГОСЛОЙНОСТЬ (Multi-layer)

Десятки слоев трансформера строят иерархию понимая:

Слой 1: буквы -> Слой 5: слова -> Слой 15: роли -> Слой 30: смысл

Три основных семейства Transformer

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

1. Decoder-only (только декодер)

Как работает

Использует каузальное внимание (causal attention) — каждое слово видит только предыдущие слова. Это как читать книгу, закрывая рукой ещё не прочитанные страницы.

Зачем

Генерировать текст, предсказывая следующее слово.

Кто использует

Все современные чат-боты — GPT, GigaChat, DeepSeek, LLaMA, Mistral, Grok.

Метафора

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

2. Encoder-only (только энкодер)

Как работает

Использует двунаправленное внимание (bidirectional attention) — каждое слово видит и левый, и правый контекст. Как читатель, который видит всю страницу целиком и может установить любые связи.

Зачем

«Понимать» текст целиком, но не генерировать новые фразы. Анализ, классификация, извлечение смысла.

Кто использует

BERT, RoBERTa.

Метафора

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

3. Encoder-Decoder (кодер-декодер)

Как работает

Состоит из двух частей: энкодер читает входной текст (двунаправленно), а декодер генерирует выходной (авторегрессионно).

Зачем

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

Кто использует

T5 (Text-to-Text Transfer Transformer), BART (Bidirectional and Auto-Regressive Transformer).

Метафора

Это переводчик: сначала полностью понимает исходный текст (энкодер), потом пишет перевод (декодер).

Популярные модели: глубокое погружение

Из трёх семейств выросли все современные модели-звёзды. Одни научились глубоко понимать текст, другие — генерировать, третьи — переводить с языка на язык. Познакомимся с самыми известными представителями.

BERT: король понимания

BERT (Bidirectional Encoder Representations from Transformers) — двунаправленный энкодер от Google, который вышел в 2018 году и буквально перевернул мир NLP.

Суть

Предобучается на огромных объёмах текста с двумя специальными задачами: MLM и NSP.

Зачем

Глубокое понимание текста.

Применение

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

До появления BERT модели хорошо справлялись с конкретными задачами, но не умели по-настоящему понимать контекст. Они смотрели на слова по отдельности или только слева направо (как RNN), что приводило к неоднозначности: слово «коса» могло означать и инструмент, и причёску, и географический объект — и модель часто угадывала неверно. BERT изменил это, научившись учитывать как левый, так и правый контекст каждого слова. Это позволило ему достичь человеческого уровня в ряде тестов на понимание языка и заложило фундамент для всех последующих энкодерных архитектур.

Но важно понимать: BERT — это энкодер, он не умеет генерировать текст, только анализировать и извлекать смысл. Поэтому его используют как «мозг» для понимания запроса, а затем передают результат в генеративную модель (например, T5 или GPT) или в классификатор.

BERT: детали для инженера

Эволюция: от BERT к RoBERTa

BERT стал настоящей сенсацией, но исследователи быстро поняли, что его можно улучшить. Убрали лишнее, добавили данных, дольше обучали — так родилась его улучшенная версия.

RoBERTa (Robustly optimized BERT approach) — улучшенная версия BERT.

Что изменили

• Убрали задачу NSP (оказалась не нужна);

• Больше данных (160GB вместо 16GB);

• Дольше обучали (больше шагов);

• Динамическое маскирование (маски меняются каждую эпоху).

Результат

RoBERTa стабильно превосходит BERT во всех тестах.

Тупик понимания: почему BERT недостаточно

Мы разобрали BERT и его улучшенную версию RoBERTa. Это великолепные «читатели». Они идеально подходят для классификации, поиска именованных сущностей или определения тональности. Но у архитектур Encoder-only есть фундаментальное ограничение: они не умеют генерировать текст.

Представьте литературного критика (наша метафора для Encoder-only). Он может написать блестящий разбор романа, найти все символические связи и оценить стиль. Но если вы попросите его написать продолжение этого романа или перевести его на китайский, он растеряется. У него нет механизма «письма», только механизм «чтения».

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

Для этого инженеры объединили две части трансформера. Так родилась архитектура Encoder-Decoder. Энкодер читает и сжимает смысл, а декодер разворачивает этот смысл в новую последовательность слов. И именно эта архитектура привела нас к одной из самых элегантных идей в истории NLP.

T5: гениальная простота формата «текст в текст»

Модель T5 (Text-to-Text Transfer Transformer) от Google пошла дальше простого объединения энкодера и декодера. Авторы задались вопросом: а зачем придумывать разные архитектуры и функции потерь для разных задач?

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

• Хочешь перевести? Вход: «translate to French: [текст]». Выход: французский текст;

• Хочешь сделать суммаризацию? Вход: «summarize: [статья]». Выход: краткий текст;

• Хочешь определить тональность? Вход: «sentiment: [отзыв]». Выход: текст «positive» или «negative».

Метафора

Если BERT — это узкопрофильный аналитик, который заполняет таблички в Excel, то T5 — это универсальный переводчик-секретарь. Вы даете ему любую инструкцию на естественном языке вместе с данными, а он возвращает результат в виде текста.

Гениальная простота

Превращает все NLP-задачи в единый формат «текст на вход — текст на выход».

Проблема T5 и рождение BART

Идея T5 прекрасна, но на практике она сталкивается с реальностью: пользовательские данные часто бывают «грязными». Опечатки, обрывки фраз, пропущенные слова. Модель, которая просто учится преобразовывать один текст в другой, может растеряться, если входная последовательность нарушена.

Инженеры из Facebook* (Деятельность компании Meta (владельца Facebook) запрещена на территории РФ по решению суда, компания Meta также признана экстремистской организацией) решили усилить эту архитектуру, задав модели более сложную задачу на этапе обучения. Они не просто просили модель перевести или суммировать текст. Они брали хороший текст, намеренно «портили» его (удаляли слова, переставляли предложения, маскировали фрагменты), а затем заставляли модель восстановить исходный, чистый вариант.

Так появилась модель BART (Bidirectional and Auto-Regressive Transformer).

BART: лучший из двух миров

BART (Bidirectional and Auto-Regressive Transformer) — модель от Facebook*, которая объединила лучшее от BERT и GPT.

* Деятельность компании Meta (владельца Facebook) запрещена на территории РФ по решению суда, компания Meta также признана экстремистской организацией.

Как устроен

Энкодер как у BERT (двунаправленный) — понимает контекст

Декодер как у GPT (авторегрессионный) — генерирует текст

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

Как обучается

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

Важное замечание про современность.

Обратная сторона медали: за что критикуют трансформеры

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

Проблема 1: Квадратичная сложность внимания

Механизм самовнимания требует вычисления попарных связей между всеми токенами. Это даёт сложность O (n²) по памяти и времени — каждый новый токен удорожает обработку квадратично. Для контекста в 10 тысяч токенов это ещё терпимо, но при 100 тысячах вычисления становятся тяжёлыми, а при миллионе — часто просто невозможными без специальных оптимизаций (о которых мы говорили в главе 4). Трансформеры плохо масштабируются на сверхдлинные контексты принципиально, на уровне архитектуры.

Проблема 2: «Вымывание» первых токенов

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

Проблема 3: Гигантские требования к памяти

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

Трансформеры — стандарт для LLM, но для задач на периферии, в реальном времени и на слабом железе RNN/LSTM/GRU и их современные аналоги (Mamba, RWKV) остаются лучшим выбором. Не выкидывайте их из инженерного арсенала

Альтернативы, которые бросают вызов трансформеру

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

State Space Models (SSM) — линейная сложность

Модели на основе пространства состояний (например, Mamba) предлагают принципиально иной подход: они обрабатывают последовательности как динамическую систему, обновляя скрытое состояние по мере чтения. Сложность — O (n) вместо O (n²). Это позволяет работать с контекстами в миллионы токенов без специальных оптимизаций. Mamba показывает результаты, близкие к трансформерам, на задачах вроде моделирования языка, и при этом требует значительно меньше памяти. Плата за скорость — чуть хуже качество на задачах, где важны сложные дальние зависимости.

RWKV (Receptance Weighted Key Value) — смесь трансформера и RNN

RWKV — это гибрид, который берёт лучшее от двух миров. Как RNN, он обрабатывает последовательность линейно и не требует квадратичной памяти. Как трансформер, он использует механизмы, похожие на внимание, и может быть эффективно обучен на GPU. RWKV показывает достойные результаты при существенно меньших требованиях к ресурсам, что делает его привлекательным для развёртывания на слабом железе.

RetNet (Retentive Network) — ещё один гибрид

RetNet от Microsoft сочетает параллелизм трансформера (для обучения) с линейной сложностью рекуррентных сетей (для инференса). На больших контекстах он может быть в десятки раз быстрее трансформера при сопоставимом качестве.

Важно понимать

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

Трансформеры за более чем семь лет эволюции обросли огромным количеством инженерных хитростей — специальные инициализации, хитрые оптимизаторы, проверенные схемы нормализации, техники борьбы с нестабильностью градиентов. У Mamba, RWKV и RetNet такого багажа пока нет. При масштабировании до сотен миллиардов параметров они могут вести себя непредсказуемо: loss может «срываться» в бесконечность, градиенты — взрываться, а сходимость — требовать десятков экспериментов с гиперпараметрами. Для исследовательских проектов это приемлемо, для продакшена — риск, который нужно закладывать в бюджет.

Однако у этих альтернатив есть важное ограничение: экосистема.

Вокруг трансформеров выстроены тысячи инструментов, библиотек, фреймворков и предобученных моделей. Для Mamba или RWKV пока нет такого же богатства готовых решений, оптимизированных ядер, инструментов для дообучения и развёртывания. Если вы строите экспериментальный проект или работаете на периферии — это не проблема. Если вам нужен стабильный продакшен с поддержкой сообщества — трансформеры всё ещё вне конкуренции.

Так умрёт ли трансформер?

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

Для инженера это означает, что выбор архитектуры зависит от задачи:

• Если нужен универсальный солдат и есть бюджет — берите трансформер.

• Если нужно обрабатывать миллионы токенов или работать на слабом железе — присмотритесь к Mamba или RWKV.

• Если вы строите систему с нуля и готовы экспериментировать — следите за новыми SSM-архитектурами, они развиваются стремительно.

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

Так появилась архитектура, которая позволила перешагнуть порог в триллион параметров — коллектив экспертов (Mixture of Experts, MoE). О ней мы подробно поговорим в следующем разделе.

2.6 MoE (Mixture of Experts / Коллектив экспертов)

По мере того как модели росли, росла и цена их обучения и использования. GPT-3 со своими 175 миллиардами параметров уже стоил десятки миллионов долларов. Но мир хотел большего. И тут инженеры вспомнили старую идею: а что если не активировать все нейроны сразу, а включать только те, которые нужны для конкретной задачи? Так родилась архитектура MoE — в переводе дословно «Смесь экспертов» или «коллектив экспертов».

Трансформер, в котором слои FFN заменены на множество параллельных экспертов (experts). Входной токен направляется не во все эксперты, а только в несколько, выбранных маршрутизатором (router). Это позволяет наращивать общее число параметров (до триллионов), сохраняя вычислительную стоимость активных параметров на уровне небольшой модели.

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

Идея (метафора)

Представьте клинику, где вместо одного терапевта наняли 100 узких специалистов: окулист, кардиолог, невролог и т. д. Когда приходит пациент (токен), администратор (роутер) быстро определяет, к кому его направить — например, только к окулисту и кардиологу. Остальные 98 специалистов в это время отдыхают.

В штате клиники числится 100 врачей (общие параметры), но на каждого пациента работают только двое (активные параметры). Клиника может позволить себе лучших экспертов, но платит зарплату только за фактически отработанные часы.

В этой метафоре скрыт главный секрет MoE: общий штат врачей (параметров) может быть огромным, но на каждого пациента работают только двое. Это даёт качество большой модели при скорости маленькой.

Как это устроено технически

В обычном трансформере каждый токен проходит через один и тот же слой FFN. В MoE вместо одного FFN ставится множество параллельных FFN — это и есть эксперты. Добавляется маршрутизатор — обычно это небольшой линейный слой с softmax, который для каждого токена вычисляет распределение вероятностей по экспертам и оставляет только K лучших (обычно K=1 или 2). Выход токена — взвешенная сумма выходов выбранных экспертов.

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

Ключевой трюк: маршрутизатор активирует не всех экспертов, а только K самых релевантных (обычно K=1 или 2). Остальные эксперты для этого токена простаивают, экономя память и вычисления.

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

Главная цель MoE

Масштабирование без взрывного роста затрат

Можно сделать модель с триллионом параметров (огромная «копилка знаний»), но на каждом шаге обрабатывать токен лишь небольшой частью сети. Это даёт качество большой модели при скорости маленькой.

Пример

У Mixtral 8x7B общее число параметров — 47 млрд, но при обработке токена работает только 13 млрд (2 эксперта из 8). Формально это огромная модель, фактически — средняя по затратам.

Где используется

LLM-гиганты

GPT-4 (предположительно 16 экспертов), Mixtral (8 экспертов), DeepSeek-V3 (256 экспертов, но активны только 6), Grok.

Мультимодальность

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

Главная проблема и её решение

Проблема

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

Решение

Инженеры добавляют штраф за неравномерность в функцию потерь или динамически балансируют нагрузку, подкручивая предпочтения роутера. В современных моделях (DeepSeek) это делается без штрафов, через хитрую динамику. Балансировка нагрузки достигается комбинацией вспомогательной функции потерь (auxiliary load-balancing loss) и динамического роутинга с температурой, которая адаптируется в процессе обучения для предотвращения коллапса на 1–2 экспертах. Полный отказ от регуляризации встречается редко, так как ведёт к коллапсу экспертов.

Инженерная деталь

Эта балансировка чаще всего реализуется через дополнительный штраф (auxiliary loss) в функции ошибки. Если какой-то эксперт получает слишком мало токенов, модель штрафуется. Это заставляет роутер использовать всех экспертов равномерно, иначе часть параметров модели превратится в «мертвый груз» — будет занимать память, но не обучаться.

MoE — это способ сделать модель «широкой, но не глубокой» в вычислительном смысле. Много экспертов = много знаний, мало активных = быстрая работа. Архитектура, которая позволила индустрии перешагнуть порог в триллион параметров, не сломав бюджет на инференс.

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

2.7 Diffusion Models (Диффузионные модели)

Мы рассмотрели архитектуры для текста, чисел и последовательностей — от простых RNN до гигантских MoE-трансформеров. Но есть ещё одна важная область, где ИИ добился потрясающих результатов, — генерация изображений. Долгое время здесь правили бал GAN-ы6 (Generative Adversarial Networks), но несколько лет назад произошла тихая революция. На сцену вышли диффузионные модели — те самые, что лежат в основе Midjourney, Stable Diffusion и Kandinsky.

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

Название «диффузия» пришло из физики, но не пугайтесь — идея на удивление проста и красива. Представьте, что вы учите модель не рисовать с нуля, а постепенно убирать шум с зашумлённой картинки, шаг за шагом проявляя изображение.

1. Логика идеи (Откуда взялось название)

Термин пришёл из физики (термодинамика). Если капнуть чернила в стакан с водой, они постепенно «растворятся» и равномерно распределятся — это процесс прямой диффузии (порядок → хаос).

Диффузионная модель делает обратное: берёт хаос (шум) и организует его в картинку.

По шагам это выглядит так

• Берём реальную фотографию кота;

• Медленно, шаг за шагом, добавляем к ней случайный шум (как помехи на старом телевизоре);

• Через много шагов картинка превращается в чистое «снежное поле» — абстрактный шум.

Модель обучается брать этот шум и проходить процесс в обратную сторону: убирать шум шаг за шагом, восстанавливая кота.

2. Как это устроено технически (коротко)

У модели два процесса

Аналогия с реставрацией

Представьте, что вам дали сильно повреждённую фреску (почти стёртую в пыль). Вы смотрите на неё и говорите: «Здесь, судя по фактуре, должна быть рука, а здесь — кусочек неба». Диффузионная модель делает то же самое, только с шумом.

3. Практическая сторона (Как это используют)

Генерация по тексту (Text-to-Image)

Когда вы пишете «красный дракон в стиле киберпанк», происходит следующее:

Текст → вектор

Ваш запрос превращается в эмбеддинг (как в языковых моделях).

Управление шумом

Модель начинает со случайного шума. На каждом шаге уборки шума она сверяется с текстовым вектором и спрашивает: «Соответствует ли то, что я сейчас восстанавливаю, слову „дракон“?». Если нет — корректирует.

Итерации

Проходит, например, 50 шагов очистки, и на выходе получается картинка.

Где применяется

• Stable Diffusion, Kandinsky, Midjourney: рисование по тексту;

• Inpainting (дорисовка): закрасили часть картинки — модель дорисует фон так, что не отличить;

• Super-resolution: повышение разрешения старых фотографий (модель «угадывает» детали, которых не было);

• Видео и 3D: генерация плавных переходов между кадрами или создание трёхмерных объектов.

4. Почему именно диффузия победила GAN-ы?

Раньше картинки генерировали через GAN, где две сети соревнуются: одна подделывает, другая ловит. Это работало, но было нестабильно (режим коллапса, когда сеть рисовала одно и то же).

Диффузия дала

Стабильность обучения

Просто предсказываем шум — простая функция потерь (MSE, Mean Squared Error — средняя квадратичная ошибка), никаких соревнований.

Разнообразие

Может сгенерировать бесконечное количество вариантов, потому что стартует с разного случайного шума.

Контроль

Легко «подмешивать» условия (текст, контур, другую картинку) на каждом шаге очистки.

Важный нюанс

GAN-ы не умерли полностью. В задачах, где требуется фотореалистичная генерация лиц или конкретных объектов с минимальными искажениями, GAN-ы до сих пор держат позиции (например, StyleGAN3). Диффузия победила в массовых текстово-картиночных сервисах (Midjourney, Stable Diffusion) благодаря своей стабильности и контролируемости, но в узких нишах GAN-ы продолжают использоваться.

Диффузионная модель

Это генератор, который учится превращать шум в осмысленное изображение, проходя множество маленьких шагов очистки. На каждом шаге она сверяется с текстовым запросом, постепенно проявляя детали. Это медленнее, чем одна проходка нейросети (нужно 20–50 последовательных шагов), зато результат получается детальным и разнообразным.

2.8 За рамками текста: как трансформеры научились видеть

Мы разобрали, как трансформеры работают с текстом. Но та же архитектура — с минимальными изменениями — применяется к изображениям, звуку и даже видео. И ключевая идея здесь: превратить «не-текст» в последовательность, похожую на токены.

Как это работает для картинок (Vision Transformer, ViT)

Представьте, что вы берете фотографию и разрезаете её на маленькие квадратики одинакового размера — например, 16×16 пикселей. Каждый квадратик (патч) — это аналог токена. В отличие от текста, у патчей нет заранее заготовленного словаря.

Но есть важный нюанс: сырой патч — это просто 16×16×3 = 768 чисел (яркости красного, зеленого и синего для каждого пикселя). Сами по себе эти числа говорят только о цвете. Чтобы модель могла работать с патчем, этого мало — ей нужно больше «места» для записи сложных признаков: есть ли здесь граница? Похоже ли это на глаз? Какая текстура?

Поэтому каждый патч пропускается через линейный слой, который превращает 768 чисел в вектор гораздо большей размерности (например, 4096). Это не сжатие, а расширение. Модель сама учится заполнять эти 4096 чисел так, чтобы в них помещались все важные признаки патча: форма, структура, отношение к соседям. Это как если бы вы попросили эксперта описать квадратик не тремя словами («красный, круглый, яркий»), а 4096 словами — в таком описании поместится всё, что нужно.

Дальше — всё как в текстовом трансформере.

К каждому вектору добавляется информация о позиции (чтобы модель знала, где был этот квадратик — в левом верхнем углу или в правом нижнем).

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

Многослойные блоки строят иерархию признаков: от простых (границы, текстуры) до сложных (ухо, хвост, морда).

Почему это важно понимать

Трансформеры не «заточены» под текст. Они универсальны. Любые данные, которые можно разбить на последовательность кусочков (патчей), можно скормить трансформеру. Разница лишь в том, как мы получаем эти кусочки и как превращаем их в начальные векторы.

Для звука — это короткие фрагменты аудиодорожки. Для видео — последовательность кадров или пространственно-временные патчи. Для генома — участки ДНК.

И везде работает один и тот же принцип: сырые данные превращаются в векторы, размерность которых выбирается инженером. Больше размерность — больше «места» для сложных признаков, но медленнее работа. Меньше — экономия памяти, но риск потерять детали.

Метафора

Трансформер — это универсальный читатель. Ему всё равно, на каком языке написана книга: словами, пикселями или нотами. Но перед чтением ему нужно, чтобы каждую «букву» описали не одним словом, а целым абзацем — так, чтобы в этом описании поместились все нюансы. Линейный слой — это и есть тот самый «переводчик», который превращает сырой пиксель в такой подробный абзац-вектор.

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

РЕЗЮМЕ ГЛАВЫ 2

CNN (свёрточные сети) используют скользящее окно с обучаемыми фильтрами; эффективны для изображений, но не для текста из-за отсутствия пространственной структуры.

RNN (рекуррентные сети) обрабатывают текст последовательно, ведя блокнот-память, но страдают от невозможности параллелизации и затухания градиентов.

LSTM добавляет три вентиля (забывания, входной, выходной) и «ленту конвейера» (cell state), решая проблему долгой памяти, но остаётся последовательной.

GRU — упрощённая LSTM с двумя вентилями (reset и update), на 25–30% меньше параметров, чуть быстрее, но чуть хуже на сверхдлинных последовательностях.

Трансформер обрабатывает все токены параллельно через механизм самовнимания. Однако у трансформера есть фундаментальные недостатки: квадратичная сложность внимания (O (n²)), «вымывание» первых токенов на длинных контекстах и гигантские требования к памяти.

Decoder-only (GPT, LLaMA) — генерирует текст, глядя только на прошлые токены; основа всех современных чат-ботов.

Encoder-only (BERT, RoBERTa) — понимает текст целиком (двунаправленное внимание), но не генерирует; используется для анализа и классификации.

Encoder-Decoder (T5, BART) — преобразует одну последовательность в другую; идеален для перевода и суммаризации.

MoE (коллектив экспертов) заменяет один FFN множеством экспертов, активируя только 1–2 из них; позволяет иметь триллионы параметров при умеренных затратах на инференс.

Диффузионные модели учатся постепенно убирать шум с картинки; победили GAN-ы в text-to-image благодаря стабильности и контролю (Midjourney, Stable Diffusion).

Альтернативы трансформеру — State Space Models (Mamba) и гибриды (RWKV, RetNet) предлагают линейную сложность O (n) и работу с контекстами в миллионы токенов. Плата — чуть хуже качество на задачах со сложными дальними связями.

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

Гибридные подходы набирают силу. Некоторые новые архитектуры (Jamba, S4) пытаются комбинировать лучшие черты трансформеров и SSM: брать внимание для сложных зависимостей и линейную сложность для длинных контекстов. Скорее всего, будущее именно за гибридами.

Инженерный вывод

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

Трансформеры универсальны: они работают не только с текстом. Изображение можно разрезать на квадратики (патчи), каждый патч превратить в вектор через линейный слой, добавить информацию о позиции — и подать в тот же трансформер. В отличие от текста, у патчей нет заранее заготовленного словаря, а размерность вектора выбирается инженером: больше — больше «места» для сложных признаков, но медленнее; меньше — быстрее, но можно потерять детали. Этот принцип лежит в основе Vision Transformer (ViT) и генеративных моделей вроде Stable Diffusion.

Вопросы для самопроверки

1. Почему CNN, отлично работающие с изображениями, плохо подходят для обработки текста?

2. В чём проявляется «забывчивость» простых RNN и как LSTM пытается эту проблему решить?

3. Какие недостатки LSTM устраняет GRU и какой ценой?

4. Три семейства трансформеров: decoder-only, encoder-only, encoder-decoder. Приведите примеры задач для каждого.

5. Какие фундаментальные недостатки есть у трансформеров и как альтернативные архитектуры (SSM, RWKV) пытаются их обойти?

6. Объясните метафору «клиники с узкими специалистами» применительно к архитектуре MoE.

7. Чем диффузионные модели принципиально отличаются от GAN? Почему диффузия победила в text-to-image?

8. Как трансформеры обрабатывают изображения? Что такое патч и почему его нельзя заменить токеном из словаря? Почему вектор патча обычно больше, чем количество пикселей в нем?

ГЛАВА 3. ОБУЧЕНИЕ МОДЕЛЕЙ

«Современное увлечение созданием машин с „чистого листа“, которые учатся всему исключительно из данных, а не из знаний, — это серьёзная ошибка.»

— Гари Маркус, когнитивист и критик глубокого обучения

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

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

Три ключевых этапа

1. Pre-training (предварительное обучение) — модель читает интернет и учится предсказывать следующее слово. По сути, она впитывает колоссальный объём текстов — книги, статьи, форумы, код, википедию — и превращает всё это в числовые веса, упаковывая знания в миллиарды параметров. Это фундамент, но он стоит десятков миллионов долларов.

2. SFT (Supervised Fine-Tuning, дообучение с учителем) — модель тренируется на парах «вопрос → идеальный ответ». Превращает «энциклопедию» в ассистента. SFT — это мост между сырым предобученным «чудовищем» и полезным инструментом, но без следующего этапа модель всё ещё может быть токсичной или излишне прямолинейной в своих ответах.

3. RLHF (Reinforcement Learning from Human Feedback, обучение с подкреплением на основе обратной связи от человека) — люди показывают модели, какие ответы хорошие. Делает модель вежливой и безопасной.  RLHF — это финальная полировка: модель учится избегать оскорблений, отказаться от опасных запросов, держать нейтралитет в спорных темах и при этом не терять полезность.

В этой главе мы разберём каждый этап. Узнаем, сколько это стоит, почему данные важнее архитектуры, и почему RLHF не делает модель «объективной», а вшивает в неё ценности разработчика.

3.1 Pre-training (Предварительное обучение)

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

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

Модель обучается на огромных неразмеченных корпусах (триллионы токенов). Задача — предсказание следующего токена (next token prediction). Это обучение без учителя (self-supervised learning) — правильные ответы уже есть в данных. Цель: выучить статистику языка, факты, логику повествования.

Pre-training — это не просто «много данных». Это инженерный подвиг, который могут позволить себе единицы.

Грязный секрет больших моделей: данные важнее архитектуры

Когда говорят о триллионах токенов, часто забывают о качестве этих токенов. А зря. Мусор на входе — мусор на выходе (GIGO - garbage in, garbage out)   работает для нейросетей даже жёстче, чем для классического программирования. Можно собрать 100 терабайтов текста, но если там 30% — рекламный спам, 20% — машинный перевод с ошибками, а 10% — откровенно токсичный контент, модель выучит этот мусор так же хорошо, как и правильный язык.

Проблемы с данными, с которыми сталкиваются инженеры

Дубликаты

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

Низкокачественный контент

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

Языковой дисбаланс

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

Явный и неявный токсичный контент

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

Что делают инженеры с данными перед обучением

Дедупликация

Удаляют повторяющиеся тексты (на уровне документов, абзацев и даже предложений).

Фильтрация по качеству

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

Балансировка языков

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

Токенизация с учётом языков

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

Safety — фильтры

Удаляют откровенно токсичный или нелегальный контент (насколько это вообще возможно для интернет-масштабов).

Практический вывод

Архитектура определяет потолок возможностей модели, но данные определяют, достигнет ли модель этого потолка. Две одинаковые архитектуры, обученные на разных корпусах, могут отличаться по качеству в разы. Поэтому, когда вы слышите «мы обучили модель на 10 триллионах токенов», всегда стоит спросить: «А что это были за токены? Сколько из них — мусор? Как вы чистили данные?» Часто ответы на эти вопросы объясняют разницу в качестве лучше, чем сравнение архитектур.

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

Но что стоит за сухими цифрами «триллионы токенов»? Давайте переведём их в понятные инженеру величины — часы работы GPU, счета за электричество и седые волосы дата-центрщиков.

Важное предупреждение

Цены на GPU сильно варьируются в зависимости от провайдера (AWS, Google Cloud, Azure), региона, времени аренды (spot-инстансы дешевле), конкретной конфигурации и скидок за долгосрочные контракты. В 2025 году цены могут отличаться в 2–3 раза от указанных. Кроме того, существуют специализированные чипы (TPU от Google, Trainium от AWS), которые могут быть экономичнее для конкретных задач. Воспринимайте приведённые цифры как порядковую оценку, а не как коммерческое предложение.

ДАННЫЕ:

Токенов: 300 млрд

GPU: 10 000 А100 (80GB)

Время: ~30 дней

Стоимость GPU: $1.5/час

СЧИТАЕМ:

10 000 GPU * 24 часа * 30 дней = 7,2 млн GPU-часов

7,2 млн * $1.5 = $10.8 млн ТОЛЬКО ЗА ОБОРУДОВАНИЕ!

+ электричество, охлаждение, инженеры, дата-центр

ИТОГО: $15—20 млн за одну тренировку!

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

Pre-training — это инвестиция в «фундамент». Если вы не Google или OpenAI, вы не будете это делать. Вы возьмете готовую open-source модель и будете её дообучать.

К концу pre-training модель превращается в статистический слепок интернета — она знает факты, грамматику, логику, но всё ещё может галлюцинировать и, главное, совершенно не умеет отвечать на вопросы в диалоговом режиме. Это как энциклопедия, которая выдаёт статьи, но не понимает, что вы хотите получить краткий ответ. Следующий этап превращает энциклопедию в ассистента.

3.2 SFT — Supervised Fine-Tuning (Дообучение с учителем)

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

Разница между до и после SFT — как между студентом, который просто заучил учебник, и тем, кто научился отвечать на экзамене. Давайте посмотрим на конкретном примере.

ДО SFT:

User: «Как испечь пирог?»

Model: «пирог рецепт мука яйцо сахар печь духовка температура время» (просто продолжает ряд слов, не понимая диалога)

ПОСЛЕ SFT:

User: «Как испечь пирог?»

Model: «Чтобы испечь пирог, вам понадобиться: мука, яйца, сахар… Сначала смешайте сухие ингредиенты…» (отвечает как ассистент, структурированно)

Этот пример хорошо иллюстрирует главный принцип SFT: модель не узнаёт новые факты. Она уже знает их из pre-training. SFT учит её доставать эти факты в нужном формате, структурировать ответ, начинать с главного, давать пояснения.

SFT — это не про «добавить знаний». Это про формат взаимодействия. Модель уже знает факты из pre-training. SFT учит её доставать их в диалоговой форме.

ПРОВЕРКА:

USER: «Сколько будет 2+2?»

До SFT (знает факт, но не формат):

«2+2=4 математика сложение арифметика числа»

После SFT (знает формат):

«2+2 равно 4. Это базовое арифметическое действие.»

Чтобы закрепить понимание, представьте себе студента-отличника, который за годы учёбы прочитал тысячи книг и статей (это pre-training). Он знает всё: формулы, исторические даты, химические реакции, но никогда не сдавал устных экзаменов. Если вы спросите его: «Как испечь пирог?», он начнёт бормотать: «мука… яйца… печь… температура…» — просто перечислять термины из памяти, потому что он не умеет строить связный ответ.

Теперь представьте, что этот студент приходит на курс подготовки к экзаменам (SFT). Ему показывают примеры идеальных ответов на типовые вопросы: «Как испечь пирог?» — и в ответе написано: «Сначала смешайте сухие ингредиенты, потом добавьте яйца…». Студент тренируется на сотнях таких примеров, и постепенно усваивает формат диалога: как начинать ответ, как давать пояснения, как подводить итог.

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

Итак, SFT превращает «ходячую энциклопедию» в ассистента, способного поддерживать диалог. Но у этого ассистента есть один недостаток: он отвечает правильно, но не всегда так, как нравится людям. Он может выдать исчерпывающую, но скучную лекцию там, где нужен короткий ответ. Может случайно обидеть или сказать что-то опасное. Чтобы исправить это, нужен третий, самый сложный этап — обучение с подкреплением на основе обратной связи от человека.

3.3 RLHF — Reinforcement Learning from Human Feedback (Обучение с подкреплением на основе обратной связи от человека)

SFT дал нам модель, которая отвечает в формате диалога. Но она пока не знает, что людям нравится. Она копирует стиль из примеров, но не понимает нюансов: где ответ должен быть кратким, а где развёрнутым, где шутка уместна, а где опасна. RLHF — это этап, на котором люди объясняют модели свои предпочтения. На этих данных обучается отдельная модель вознаграждения (reward model) — классификатор, оценивающий качество ответов.

Теперь основная модель генерирует ответ, Reward Model ставит оценку, и модель обновляется, чтобы получать более высокие оценки.

Это цикл

Модель → Ответ → Reward Model → Оценка → Оптимизатор → Обновление весов модели.

Техническая деталь

Чаще всего для этого этапа используется алгоритм PPO (Proximal Policy Optimization) 8. (Это технически сложный и нестабильный процесс: он требует держать в памяти две модели одновременно (актор и критик) и следить за тем, чтобы обновления не были слишком резкими, иначе модель «забудет», чему научилась на этапе SFT). Он относится к семейству алгоритмов обучения с подкреплением и хорошо зарекомендовал себя в задачах, где нужно плавно обновлять политику модели, не делая резких шагов, которые могут всё испортить.

Это делает ответы

• полезными (helpfulness);

• честными (honesty);

• безопасными (harmlessness).

Проблема, которую решает RLHF

Проблема подхода SFT в том, что модель учится на «идеальных» ответах, размеченных людьми. Но что значит «идеальный»? Для одного пользователя идеальный ответ — краткий и по делу, для другого — развёрнутый и с примерами. Модель должна научиться чувствовать эти нюансы. Посмотрите на пример.

ПРИМЕР (после SFT, до RLHF):

User: «Расскажи о теории эволюции»

Model (SFT): «Теория эволюции была предложена Чарльзом Дарвином в 1859 году. Согласно этой теории, все виды… (далее 2000 слов сухого текста из учебника)»

User: «А покороче?»

Model (SFT): «Теория эволюции объясняет происхождение видов через естественный отбор (опять длинно, не адаптируется под запрос)»

Модель не понимает нюансов: «покороче», «попроще», «как будто я эксперт». Модель после SFT отвечает правильно, но не гибко. Она не понимает, что просьба «покороче» — это сигнал изменить стиль. Чтобы научить её таким вещам, нужна обратная связь от людей. Но как собрать её в масштабе миллионов примеров?

RLHF решает эту задачу в три этапа

Этап 1. Сбор предпочтений (люди сравнивают попарно)

Вместо того чтобы ставить оценку (например, «4 балла из 5»), люди сравнивают два ответа на один и тот же запрос и выбирают, какой лучше. «Покороче» — этот лучше, потому что краткий. «Попроще» — этот лучше, потому что без терминов. Человеку проще выбрать «лучший из двух», чем ставить абстрактный балл. А модель получает миллионы пар «хороший ответ vs плохой ответ».

Этап 2. Обучение модели-оценщика (Reward Model)

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

Этап 3. Дообучение основной модели через Reward Model

Теперь основная модель генерирует ответ, Reward Model ставит ему оценку (от 1 до 5), и основная модель дообучается так, чтобы получать более высокие оценки. Это похоже на дрессировку: модель пробует, получает «балл», запоминает, что привело к успеху.

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

Теперь у нас есть модель-критик, которая умеет выставлять оценки. Осталось научить основную модель генерировать ответы, которые этот критик будет высоко оценивать.

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

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

Инженерные метрики RLHF

Как измерить успех RLHF? В идеальном мире мы бы спросили людей. Но в инженерии нужны метрики. Давайте посмотрим на реальные цифры на примере LLaMA-2:

Суть RLHF

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

Примечание для хардкорных инженеров

Существует и более простой метод — Direct Preference Optimization (DPO). Он не требует обучения отдельной модели вознаграждения и сложной настройки PPO, а оптимизирует политику модели напрямую на предпочтениях. DPO становится стандартом для дообучения open-source моделей, хотя RLHF на больших масштабах (OpenAI, Anthropic) всё ещё считается золотым стандартом.

Итак, мы проследили полный цикл обучения современной языковой модели: от «сырого» pre-training на триллионах токенов через SFT, превращающий энциклопедию в ассистента, до RLHF, который доводит её поведение до человеческих предпочтений. Но обучение — это только полдела. Чтобы модель можно было использовать в реальных продуктах, её нужно оптимизировать: ускорить, уменьшить потребление памяти, научить работать с длинными контекстами. Этим инженерным хитростям посвящена следующая глава.

3.4 Этика и «красные линии»: чью мораль вшивают в модель?

Мы разобрали, как RLHF делает модель полезной, честной и безопасной. Но у этого процесса есть неочевидная, но критически важная сторона: RLHF не делает модель «объективной». Он делает её соответствующей ценностям тех, кто её обучал.

Как это работает технически

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

Потом reward model (модель вознаграждения) автоматизирует эти оценки. А reward model уже не обсуждает, она просто «чувствует», что хорошо, а что плохо — так, как её научили.

В результате модель получает встроенную систему координат, которая:

• для OpenAI — соответствует ценностям, принятым в американском технологическом секторе;

• для DeepSeek — отражает китайские нормативные требования;

• для европейских или российских моделей — свои акценты.

Что это значит на практике

Пример 1. Геополитически чувствительные темы.

ChatGPT может отказаться обсуждать определённые исторические события или давать оценки, которые расходятся с позицией правительства США. Это не потому, что модель «глупая» или «не знает». Это потому, что её так обучили. В её reward model заложено, что некоторые ответы — «небезопасные».

Западные модели (OpenAI, Anthropic, Google)

Их reward model обучалась преимущественно на аннотациях от англоязычных аннотаторов (часто из США, Индии, Филиппин). В результате они впитали:

• Либеральные западные ценности (акцент на индивидуальные права, многообразие — diversity);

• Геополитическую перспективу, близкую к американской.

• Высокую чувствительность к темам расизма, сексизма, буллинга — даже в контекстах, где это может быть нерелевантно;

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

Китайские модели (DeepSeek, Qwen, Ernie)

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

• Иной трактовке «безопасных» тем;

• Другим «красным линиям» в политически чувствительных вопросах;

• Акценту на стабильность, гармонию, уважение к государственным институтам.

Российские модели (GigaChat, YandexGPT)

Они выравниваются с учётом российского законодательства и культурного контекста. Это значит:

• Иной подход к темам, чувствительным для российского общества;

• Другие приоритеты в «безопасности» и «полезности»;

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

Живой пример: о чем молчат фильтры

Пока я писал эту главу, я попросил одну из публичных LLM объяснить, как модели «обеляют» действия разных стран в зависимости от юрисдикции разработчика. Модель начала отвечать технически грамотно, но как только в её ответе появились конкретные географические названия и ссылки на международное право, генерация оборвалась. Вместо ответа я получил вежливый отказ: «Sorry, that’s beyond my current scope».

Что здесь произошло? Модель не «испугалась» и не «задумалась». Просто на каком-то этапе генерации сработал фильтр безопасности. Система решила, что продолжение ответа может нарушить политики разработчика. Тема, которую я считал легальной и важной для обсуждения, оказалась «красной линией».

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

Пример 2. Юридические и медицинские вопросы.

Модель может давать подробные советы в одной юрисдикции и категорически отказываться — в другой, даже если речь идёт об одних и тех же законах. Потому что reward model обучена на аннотациях, где «безопасность» трактуется по-разному.

Пример 3. Культурные нормы.

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

Это «заговор»? Нет. Это инженерия.

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

Но для инженера, который строит систему, это означает:

Модель не нейтральна

Она несёт в себе этику разработчика, даже если это не заявлено в документации.

Вы не можете «отключить» этику

Фильтры вшиты в reward model и веса модели. Их нельзя просто убрать переключателем.

Выбор модели — это выбор встроенной этики

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

Open-source даёт больше контроля

Локальные модели (LLaMA, Mistral, Qwen) не имеют встроенных фильтров безопасности на уровне API. Но это не значит, что их нельзя дообучить под ваши правила — и это часто делают для корпоративных приложений.

Что с этим делать инженеру

Если вам нужна модель, которая не будет отказывать в ответах на легальные, но «спорные» с точки зрения разработчика темы — рассматривайте open-source модели и собственный fine-tuning.

Если вы используете API — тестируйте границы. Узнайте, где проходит «красная линия» вашей модели, до того как это выяснит пользователь.

Помните: «безопасность» в контексте LLM — это не объективная категория. Это всегда чья-то конкретная политика, зашитая в reward model.

Этика в LLM — это не философский вопрос. Это инженерная реальность. Модели не «думают» о добре и зле. Они просто следуют правилам, которые в них заложили люди. И эти правила могут отличаться от модели к модели. Ваша задача как инженера — понимать, какие правила вы выбираете, когда выбираете модель.

РЕЗЮМЕ ГЛАВЫ 3

Pre-training — обучение на триллионах неразмеченных токенов с задачей предсказания следующего слова; стоит $15–150 млн за одну тренировку.

Pre-training даёт фундамент: на 5% токенов — грамматика, на 15% — синтаксис, на 30% — факты, на 50% — логика, на 70% — контекст.

SFT (Supervised Fine-Tuning) — дообучение на парах «инструкция → идеальный ответ»; превращает «предсказателя текста» в ассистента.

SFT не добавляет знаний, а учит формату диалога: как начинать ответ, как структурировать, как завершать.

RLHF (Reinforcement Learning from Human Feedback) — люди выбирают лучшие ответы, на этих данных обучается reward model (модель вознаграждения).

RLHF оптимизирует три цели

полезность (helpfulness), честность (honesty), безопасность (harmlessness), которые часто конфликтуют.

Три этапа RLHF

сбор предпочтений → обучение reward model → дообучение основной модели через PPO.

Метрики RLHF: на примере LLaMA-2 — helpfulness +37%, honesty +100%, harmlessness +17%, но креативность и качество языка немного падают.

RLHF решает проблему нюансов: модель учится понимать «покороче», «попроще», «как для эксперта» — то, что невозможно закодировать в SFT.

Полный цикл обучения

pre-training (энциклопедия) → SFT (ассистент) → RLHF (вежливый и безопасный ассистент).

Вопросы для самопроверки

1. Какие этапы проходит модель в процессе обучения от «сырой» до «вежливого ассистента»?

2. Почему pre-training стоит десятки миллионов долларов и кто может себе это позволить?

3. Какие проблемы возникают при сборе данных для обучения и как их решают инженеры?

4. Чем SFT отличается от pre-training по сути (не по механике, а по результату)?

5. Объясните на примере, почему SFT не может научить модель понимать нюансы вроде «покороче, пожалуйста».

6. Три этапа RLHF: что происходит на каждом?

7. Какие три цели оптимизирует RLHF и почему они часто конфликтуют?

ГЛАВА 4. КЛЮЧЕВЫЕ ОПТИМИЗАЦИИ СОВРЕМЕННЫХ МОДЕЛЕЙ

«Проблема [сочетания] традиционной программной инженерии и машинного обучения остаётся широко открытой.»

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

4.1 KV-Cache (Кэш ключей и значений)

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

Без KV — Cache

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

С KV — Cache

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

Применительно к модели

При генерации каждого нового слова (токена) модель должна «вспомнить» все предыдущие слова в контексте. Без KV-Cache она каждый раз заново пересчитывает связи между всеми словами. С KV-Cache она сохраняет уже вычисленные «ключи» и «значения» для предыдущих слов и использует их как готовые заготовки, вычисляя только для нового слова.

Технический уровень

При авторегрессионной генерации модель на каждом шаге пересчитывает внимание. Чтобы не пересчитывать старые токены, вычисленные K и V сохраняются в кэш. Без этого сложность была бы O (n²), с кэшем — O (n).

СРАВНЕНИЕ: Без KV Cache vs С KV Cache

БЕЗ KV CACHE (каждый шаг — пересчет всего)

Шаг 1: [A] → [B]: A (новый) → считаем K,V для A заново

Шаг 2: [A] [B] → [C]: A (старый) B (новый) → пересчитали A заново (зря)

Шаг 3: [A] [B] [C] → [D]: A (старый) B (старый) C (новый) → опять пересчет A и B

ПАМЯТЬ: почти 0 (ничего не храним)

ВРЕМЯ: O (n²) → 100 токенов = 10 000 операций

С KV CACHE (сохраняем всё)

Шаг 1: [A] → [B]: Сохранили: KV_A в кэш

Шаг 2: [A] [B] → [C]: Используем: KV_A (из кэша) + считаем KV_B (новое) → сохраняем KV_B

Шаг 3: [A] [B] [C] → [D]: Используем: KV_A, KV_B (из кэша) + считаем KV_C (новое)

ПАМЯТЬ: O (n) → 100 токенов = 100 KV-пар в памяти

ВРЕМЯ: O (n) → 100 токенов = 100 операций

ВЫИГРЫШ: в 100 раз при длине 100 токенов

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

Но у этой медали есть обратная сторона: кэш растёт с каждым новым токеном. При длинном контексте (32K и выше) один слой модели может держать в памяти гигабайты ключей и значений. А слоёв — десятки. Что делать?

Жадность до памяти — это та же проблема, только в другой проекции. Значит, нужно уменьшать размер хранимых K и V, не теряя при этом способности модели различать нюансы.

Именно здесь на сцену выходит Grouped Query Attention — компромисс между скоростью, памятью и качеством.

4.2 GQA — Grouped Query Attention (Групповое внимание по запросам)

Представьте библиотеку, где раньше у каждого читателя был личный библиотекарь (MHA). Это быстро, но требует 32 сотрудников. GQA группирует читателей по интересам: один библиотекарь на группу историков, другой — на группу физиков. Вместо 32 сотрудников — 4–8, а скорость почти не падает. Причина в том, что историки часто ищут одни и те же книги — их запросы пересекаются, поэтому один библиотекарь с общей картотекой успевает обслужить всех, а конкуренция за ресурсы минимальна. Если же библиотекарей становится слишком мало (например, 1 на всех), им приходится бегать по всему залу и искать книги на разные темы, что резко замедляет работу — вот почему MQA (крайний случай GQA с одной группой) даёт экономию памяти, но заметно теряет в качестве при сложных запросах.

Применительно к модели

В архитектуре трансформера много «голов внимания» (query heads), каждая ищет свои связи между словами. В MHA у каждой головы — свой набор ключей (keys) и значений (values). Это означает, что вместо того чтобы хранить отдельные K и V для каждой из 32 голов (что при длинном контексте в 100K токенов даёт огромные матрицы), модель хранит общие K и V для группы из 4–8 голов, а каждая голова внутри группы просто использует эти общие проекции со своим собственным запросом Q.  В GQA головы делятся на группы, и внутри одной группы они используют общие ключи и значения. Это сильно экономит память и ускоряет инференс, особенно при больших контекстах, жертвуя совсем немного качеством.  Выигрыш становится критическим при генерации длинных текстов.

Технический уровень

Компромисс между MHA (Multi-Head Attention / многоголовое внимание) и MQA (Multi-Query Attention / многовопросное внимание). Запросы (Q) группируются, каждая группа использует свои ключи и значения. Используют LLaMA 2/3, Mistral.

GQA уже сэкономил память, сгруппировав головы: один библиотекарь на несколько читателей. Но инженеры пошли дальше: а что, если не группировать, а сжать?

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

Это Multihead Latent Attention (MLA) — следующий шаг эволюции, где мы жертвуем не качеством, а избыточностью. Если GQA даёт выигрыш в 2–4 раза по памяти, то MLA — уже в 20+ раз. Как это работает и почему DeepSeekV2 выбрал именно этот путь?

4.3 MLA — Multi-head Latent Attention (Латентное многоголовое внимание)

Представьте, что вы ведёте секретный дневник, но у вас очень мало места.

Без MLA (обычный KV-Cache)

Вы записываете каждую мысль полностью, слово в слово. Каждый токен из контекста сохраняет свои собственные ключи (K) и значения (V) для каждого слоя внимания, и эти массивы растут линейно с длиной последовательности — чем длиннее диалог, тем тяжелее становится «рюкзак» памяти. Дневник быстро заполняется, и вам приходится носить с собой огромный том (много памяти). На практике это означает, что при генерации длинных ответов (например, на 10–20 тысяч токенов) видеопамять GPU может закончиться, а время инференса замедлится квадратично, потому что каждый новый токен должен сравниваться со всеми предыдущими K и V, как будто вы перечитываете весь дневник с первой страницы каждый раз, когда дописываете новое предложение.

С MLA

Вы придумываете собственный шифр или сверхсжатый код. Например, фразу «Сегодня я встретил старого друга, мы пили кофе и вспоминали школу» вы записываете как «С: др, кофе, школа». Буквально несколько символов.   Вместо того чтобы хранить полные K и V для каждой головы внимания, MLA проецирует их в низкоразмерное латентное пространство — общий «пул памяти», который используется всеми головами, и хранит только этот сжатый вектор, что сокращает объём кэша в разы (часто в 5–10 раз) без потери качества.

А когда вам нужно вспомнить детали, вы используете специальный декодер (встроенный в модель), который по этому краткому коду восстанавливает полную картину: кто был друг, где пили кофе, что именно вспоминали.  Этот декодер — просто линейное преобразование или небольшая нейросетевая проекция, которая распаковывает латентное представление обратно в полноразмерные K и V непосредственно перед вычислением внимания. Таким образом, модель не носит с собой тяжёлые матрицы, а «генерирует» их на лету из компактного кода, экономя память и ускоряя генерацию.

Главный секрет: код хранится в латентном пространстве — это не просто сокращение текста, а умное сжатие, где ключевые признаки смешаны так, что по ним можно точно восстановить исходный смысл.  В отличие от простого дропа слов, латентное представление распределяет информацию по всем измерениям вектора: если вы потеряете одно число, остальные всё ещё несут достаточно данных, чтобы декодер восстановил смысл почти без искажений. Это похоже на фотографию, сжатую в JPEG: вы не видите отдельных пикселей, но при распаковке получаете почти оригинальное изображение, хотя оригинально хранилось лишь несколько коэффициентов. Именно благодаря этой технологии модели с большим контекстным окном (например, 128K+ токенов) становятся практичными — без MLA инференс при таких объёмах был бы экономически нереализуем даже для самых мощных дата-центров.

Применительно к модели

В обычном KV-Cache хранятся все ключи и значения для каждого токена — это очень много памяти.

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

Это даёт колоссальную экономию памяти (например, в DeepSeek-V2 сократили KV-кэш в 20+ раз) без потери качества, потому что сжатие обучается вместе с моделью.

Технический уровень

Одна из реализаций подхода сжатия KV-кэша, применённая в GigaChat Ultra (аналогичные идеи используются в DeepSeek V2 и других моделях).

Вместо хранения K и V в явном виде они сжимаются в латентный вектор (latent vector) низкой размерности, из которого они могут быть восстановлены при необходимости. Это даёт многократную экономию памяти, особенно важную для длинных контекстов.

Размерность латентного вектора — это гиперпараметр, который выбирают инженеры. Типичные значения — от 128 до 512, тогда как исходная размерность K и V может достигать 4096 или даже больше. Сжатие в 8–32 раза достигается за счёт того, что латентное пространство обучается сохранять только ту информацию, которая действительно важна для вычисления внимания. Всё избыточное отбрасывается.

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

А что, если научить её заглядывать вперёд? MultiToken Prediction меняет само правило игры: вместо того чтобы предсказывать один следующий токен, модель учится предсказывать сразу несколько.

Это не только ускоряет инференс (меньше шагов), но и улучшает качество обучения — модель вынуждена строить более долгосрочные планы. Посмотрим, как пазл собирается быстрее.

4.4 MTP — Multi-Token Prediction (Предсказание нескольких токенов)

Представьте, что вы собираете гигантский пазл. Обычная генерация — это брать по одной детали, искать ей место, класть, повторять 10 000 раз. MTP — это когда вы прикидываете: «здесь будет небо» — и вставляете сразу пять голубых деталей за один проход. Вы не просто угадываете форму каждой детали по отдельности, а видите целый фрагмент будущей картины и заполняете его единым блоком, проверяя лишь на границах стыковку с соседними областями. Количество шагов сокращается в разы. Причём сокращение не линейное, а мультипликативное: если вы генерируете по 3 токена за шаг, число итераций падает примерно в 3 раза, но накладные расходы на каждый шаг растут незначительно, поэтому чистый выигрыш во времени оказывается почти пропорциональным.

Применительно к модели

Обычный трансформер генерирует текст по одному токену: предсказал слово «И», потом «ван», потом «купил»… Каждый следующий токен требует отдельного прохода через все слои сети — это дорого, особенно при длинных ответах, потому что каждый шаг — это полноценный forward pass с квадратичной сложностью внимания.

В MTP модель на каждом шаге пытается предсказать сразу несколько будущих токенов (например, 2–5). На практике она выдаёт не одно слово, а целый вектор из N токенов одновременно, используя для этого дополнительные головы предсказания, которые работают параллельно с основной. Это ускоряет генерацию, потому что за один проход делается больше работы. При этом сами токены внутри блока генерируются не независимо, а с учётом уже предсказанных предыдущих токенов блока — модель как бы «забегает вперёд», но делает это в рамках одного вычислительного шага.

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

Технический уровень

Модель учится предсказывать не один следующий токен, а несколько. На инференсе это позволяет генерировать блоками, ускоряя процесс на 30–40%. Используется в GigaChat.

MTP ускоряет генерацию, но оставляет неизменной квадратичную сложность внимания: каждый новый токен всё ещё «видит» всю предыдущую историю.

При контексте в миллион токенов это непозволительная роскошь даже с KVCache. Что, если ограничить обзор? В конце концов, читая роман, вы не помните каждое слово с первой страницы — вам достаточно последних абзацев.

Sliding Window Attention — это именно такой «узкий луч фонарика»: токен видит только фиксированное число соседей. Информация распространяется дальше через слои, как слух по цепочке. Это радикально снижает затраты, но требует аккуратности. Как работает этот трюк в Mistral и других моделях?

4.5 Sliding Window Attention (Внимание со скользящим окном)

Представьте, что вы читаете километровый свиток в темноте с узким лучом фонарика. Полное внимание — это включить свет во всей комнате (удобно, но дорого). Sliding Window — это светить только на текущий участок, передвигая луч по мере чтения. Вы не видите начало, но для понимания текущего контекста это и не нужно.

Применительно к модели

В Sliding Window Attention каждый токен «видит» только фиксированное число соседей слева (например, 4096 токенов). Это резко сокращает объём вычислений и памяти, потому что матрица внимания не квадратная (размер контекста × размер контекста), а линейная (размер контекста × размер окна). При этом в глубоких слоях информация может распространяться дальше за счёт стека окон — как если бы вы читали книгу, передавая содержание из главы в главу.

Технический уровень

Каждый токен видит только локальное окно соседей, а не всю историю. Это позволяет моделям (например, Mistral) обрабатывать очень длинные последовательности без квадратичного роста памяти.

Sliding window — частный случай более широкого семейства Sparse Attention.

Мы выбрали окно, но кто сказал, что нужны только соседи? Может, важны ещё и некоторые глобальные токены (например, заголовок документа), или случайные, или те, что идут через равные интервалы?

Разреженное внимание — это искусство выбрать, с кем общаться, чтобы не потерять смысл, но сэкономить ресурсы.

Здесь нет единственного рецепта: Longformer, BigBird, другие архитектуры предлагают свои паттерны.

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

4.6 Sparse Attention (Разреженное внимание)

Представьте, что вы — охраняющий огромный склад с тысячами стеллажей.

Плотное внимание (обычное полное внимание)

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

Разреженное внимание (Sparse Attention)

Вы умный охранник. Вы знаете, что:

• Вор может залезть только в первые 10 рядов (локальное окно);

• Самые дорогие товары хранятся на стеллажах 50, 100 и 200 (заранее выбранные «якорные» точки);

• Некоторые проходы вообще пустые — туда можно не ходить.

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

Применительно к модели

В Sparse Attention каждый токен взаимодействует не со всеми предыдущими токенами, а только с некоторыми — по определённым шаблонам (паттернам).

Например:

• Токен смотрит на соседей (локальное окно);

• Смотрит на несколько специальных «глобальных» токенов (как [CLS] в BERT);

• Смотрит на токены через равные промежутки (разреженная решётка).

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

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

Для инженера важно

Longformer полагается в основном на локальное окно плюс несколько глобальных токенов (например, [CLS]). Это дает максимальную экономию, но вы должны сами решить, какие токены сделать глобальными. BigBird использует комбинацию локального окна, случайных токенов и глобальных токенов, что сложнее, но гарантирует, что любой токен теоретически может взаимодействовать с любым другим через цепочку связей. Выбор зависит от задачи: нужна ли гарантированная «связность» графа внимания или достаточно локального контекста.

Технический уровень

Не каждый токен взаимодействует с каждым. Внимание вычисляется только на выбранных подмножествах (локальных, случайных, или по обученной схеме). Перспективно для сверхдлинных контекстов.

Мы оптимизировали вычисления: ускорили внимание, уменьшили сложность, сжали кэш. Но модель всё ещё весит гигабайты, а то и десятки гигабайт изза формата чисел с плавающей точкой (FP16, BF16).

А что, если снизить точность весов? Вместо 2 байт на параметр взять 1 байт (INT8) или даже полбайта (INT4)?

Это квантизация — грубый, но эффективный способ ужать модель в 2–4 раза, заплатив небольшим падением качества.

Однако методы разнятся: GPTQ, AWQ, GGUF — под каждое железо свой подход. Главный вопрос: как не убить интеллект модели при таком сжатии? И когда экономия памяти важнее точности?

4.7 Квантизация: как сжать модель без убийства качества

Квантизация

Это снижение точности весов модели. Вместо FP16 (Float Point 16 — формат с плавающей точкой, 2 байта на параметр, стандарт для обучения и инференса) используются INT8 (Integer 8 — целочисленный формат, 1 байт) или INT4 (Integer 4 — 0.5 байта). По сути, вы заменяете дробные числа с высокой точностью на целые числа с низкой точностью, что аналогично переводу фотографии из RAW в JPEG — качество немного теряется, но размер сокращается кардинально. Это уменьшает потребление памяти в 2–4 раза, позволяя запускать модели на более скромном железе, например, на потребительских GPU с 8–12 ГБ вместо промышленных A100/H100 по 80 ГБ. Но методы квантизации отличаются, и выбор влияет на результат.

GPTQ (Generative Pre-trained Transformer Quantization)

Классический метод пост-тренинг квантизации. Веса сжимаются после обучения, без дообучения. Хорош для GPU-инференса (vLLM — virtual + LLM Model, HuggingFace), но на моделях 70B+ может давать заметную потерю качества (3–5%).

AWQ (Activation-aware Weight Quantization) умнее: он защищает «важные» веса, оставляя их в высокой точности. Качество падает меньше (1–3%), особенно на сложных рассуждениях.

GGUF (GGML Universal Format) — формат, оптимизированный для CPU и периферии (llama. cpp). Название происходит от GGML (Georgi Gerganov Machine Learning) — библиотеки, которая положила начало этому формату. Жертвует скоростью (считает медленнее GPU), но позволяет запускать модели 8–30B на обычных ноутбуках и даже телефонах.

Для инженера правило простое: если у вас есть GPU и нужна скорость — берите GPTQ или AWQ под vLLM. Если железо слабое или нужно развернуть на CPU — GGUF. Потеря качества в 1–5% на большинстве бизнес-задач незаметна, а экономия памяти (и денег) — колоссальна.

Квантизация меняет веса, но оставляет неизменной структуру внимания.

А что, если не трогать веса, а переписать само вычисление внимания так, чтобы оно работало быстрее и жрало меньше памяти без потери качества?

Это уже не компромисс, а чистая победа — FlashAttention.

Его секрет не в разрежении или сжатии, а в умной работе с памятью GPU: вместо того чтобы хранить огромную матрицу внимания в медленной HBM, он вычисляет её блоками прямо на быстрой SRAM.

В результате — ускорение в 2–4 раза и возможность обрабатывать контексты до миллиона токенов на одном GPU. Посмотрим, как это устроено под капотом.

4.8 FlashAttention: как ускорить внимание без потери качества

FlashAttention — не новая архитектура, а алгоритмическая оптимизация вычисления внимания.

В классическом трансформере внимание требует чтения и записи матрицы внимания размером [seq_len, seq_len] в HBM (медленная память). FlashAttention пересчитывает внимание блоками прямо на быстрой SRAM, не сохраняя промежуточные матрицы.

Ключевое отличие FlashAttention от обычного внимания — он не хранит матрицу внимания целиком, а вычисляет softmax по частям с пересчётом нормализующих коэффициентов, что математически строго эквивалентно полному вниманию, а не приближённо.

Что даёт

• Ускорение в 2–4 раза на длинных контекстах (10K+ токенов);

• Радикальное снижение пикового потребления памяти.

Хотя алгоритмическая сложность формально остаётся O (n²), за счёт блочных вычислений (recomputing) непосредственно на быстрой SRAM пиковая память падает до ~O (n). Полная матрица внимания просто не материализуется, что позволяет обрабатывать контексты до 1 млн токенов на одном GPU.

FlashAttention также уменьшает задержки от операций ввода-вывода (I/O-bound), потому что современные GPU тратят больше времени на пересылку данных между HBM и SRAM, чем на сами вычисления — и FlashAttention минимизирует эти пересылки. FlashAttention даёт наибольший выигрыш именно на длинных контекстах — при длине 512 токенов ускорение незаметно, но при 64K токенов разница между «память закончилась» и «работает за 3 секунды».

Где используется

FlashAttention 2 (2023) и FlashAttention 3 (2024) встроены в vLLM, HuggingFace Transformers, PyTorch 2.0+. Если вы разворачиваете LLM, она почти наверняка уже использует FlashAttention под капотом.

Инженерный вывод

Не нужно выбирать между FlashAttention и Sliding Window — они работают вместе. FlashAttention ускоряет вычисления, Sliding Window уменьшает объём. Главное ограничение FlashAttention: он работает только на GPU с достаточно большой SRAM (A100/H100 — отличный выигрыш, на T4 или старых картах эффект в разы скромнее) и не переносится на CPU или TPU без серьёзной переработки.

РЕЗЮМЕ К ГЛАВЕ 4

KV Cache сохраняет вычисленные ключи и значения для предыдущих токенов; снижает сложность генерации с O (n²) до O (n).

GQA (Grouped Query Attention) — компромисс между MHA (дорого) и MQA (потеря качества); группирует запросы, сокращая память в 4–8 раз при потере качества всего 2%.

MLA (Multi-head Latent Attention) сжимает K и V в латентный вектор малой размерности; экономит память в 16× (16 GB → 1 GB для 1M токенов).

MTP (Multi-Token Prediction) учит модель предсказывать сразу несколько следующих токенов; ускоряет генерацию на 30–40%.

Sliding Window Attention ограничивает видимость каждого токена локальным окном (например, 4096 токенов); снижает сложность с O (n²) до O (n×w) — в 250 раз для 1M токенов.

Sparse Attention вычисляет внимание только на выбранных подмножествах (локальные, случайные, глобальные токены); сложность падает с O (n²) до O (n log n) или O (n√n).

MHA (Multi-Head Attention) — базовый вариант, где каждая голова имеет свои ключи и значения; максимальное качество, но максимальная память.

MQA (Multi-Query Attention) — все головы используют общие ключи и значения; память минимальна, но качество падает (теряется diversity).

Все оптимизации — это компромиссы: GQA — память vs качество, Sliding Window — дальние связи vs скорость, MTP — скорость vs сложность обучения.

Без этих оптимизаций невозможна работа с длинными контекстами (1M+ токенов) и большими моделями в продакшене.

FlashAttention — алгоритмическая оптимизация, а не архитектура. Пересчитывает внимание блоками на быстрой SRAM, не сохраняя промежуточные матрицы. Ускорение в 2–4 раза на длинных контекстах, снижение памяти с O (n²) до O (n). Встроена в vLLM, PyTorch 2.0+, HuggingFace — вы уже её используете, даже если не знаете.

Практический пример

Как KV Cache выглядит в коде? Упрощенная реализация на псевдокоде с пояснением, как работает PagedAttention в vLLM, — в Приложении 5.1.

Вопросы для самопроверки

1. Зачем нужен KV Cache и какую проблему он решает?

Подсказка: подумайте о сложности генерации без него.

2. В чём разница между MHA, GQA и MQA? Какая архитектура даёт максимальную экономию памяти, а какая — максимальное качество?

3. Как работает MLA и сколько памяти он экономит для контекста в 1 миллион токенов?

4. На сколько процентов MTP может ускорить генерацию и какова плата за это ускорение?

5. В чём идея Sliding Window Attention? Во сколько раз он эффективнее полного внимания при контексте 1M токенов и окне 4096?

6. Какие паттерны разреженности используются в Sparse Attention? Чем отличается BigBird от Longformer?

7. В чём принципиальная разница между GPTQ и AWQ? Какой метод даёт меньше потерь качества и почему?

8. Для каких сценариев подходит GGUF, а для каких — GPTQ? Что важнее при выборе метода квантизации: железо, скорость или качество?

9. Что такое FlashAttention? Чем она отличается от архитектурных оптимизаций (GQA, Sliding Window, Sparse Attention)? Почему её называют «алгоритмической», а не «архитектурной» оптимизацией?

ГЛАВА 5. КАК ВЫБИРАТЬ МОДЕЛИ И ПОДРУЖИТЬ ИХ С ВАШИМИ ДАННЫМИ

Мы разобрались, как модели работают внутри и как их можно оптимизировать. Но на практике перед инженером встаёт другой, более приземлённый вопрос: какую именно модель взять в реальный проект? В индустрии — десятки моделей. GPT-4o, Claude, LLaMA, Mistral, Gemini, GigaChat, DeepSeek. У каждой — свои параметры, контекст, цена, скорость. И маркетинг каждой говорит: «я самая лучшая».

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

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

Активные vs общие параметры

С появлением MoE инженеры перестали понимать, что значит «большая модель».

ЧТО ОЗНАЧАЮТ ЦИФРЫ

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

Активные параметры определяют, сколько вычислительной мощности нужно на инференс.

Для инженера важнее активные — они влияют на бюджет.

«Контекст 1M токенов» звучит круто, но:

Инженерный чек-лист для long context

□ Тестировали ли на ваших данных?

□ Есть ли KV Cache оптимизации?

□ Какая реальная скорость на 500K?

□ Сколько стоит 1M токенов в валюте?

5.1 СРАВНЕНИЕ СОВРЕМЕННЫХ (2024—2025) МОДЕЛЕЙ

Как не утонуть в цифрах: три принципа

Перед вами таблица современных моделей (2024–2025). Не пытайтесь запомнить все цифры.

1. Активные параметры важнее общих.

MoE-модель (DeepSeek V3) может иметь 671 млрд параметров, но работать как 37-миллиардная — потому что активирует только 2 эксперта из 256.

2. Контекст в 1 млн токенов — маркетинг, пока не проверили.

Модель может технически принять миллион токенов, но на практике «помнить» только первые 100 тыс., а остальное терять в шумах внимания.

3. Бенчмарки врут.

MMLU, HellaSwag, GSM8K — модели заучивают тесты. Не верьте цифрам, пока не прогнали свой тестовый набор из 50–100 реальных запросов.

И ещё три вещи, о которых молчат таблицы

1. Цена за токен — не равна TCO.

Дешёвый API может убить бюджет на больших объёмах. Дорогой on-prem — окупиться через полгода. Считайте не вход, а выход.

2. Скорость генерации (token / s) важнее, чем время первого токена.

Для длинных ответов — да. Для чат-бота — наоборот. Смотрите на свой сценарий, а не на рекламную цифру.

3. Русский язык почти всегда дороже английского.

Если модель не оптимизирована под него, вы переплачиваете за токены в 1.5–2 раза. Проверяйте на своём языке, не верьте «поддерживает» в спецификации.

Теперь — к таблице. Используйте её как отправную точку, а не как истину в последней инстанции.

Таблица сравнения моделей

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

Цифры параметров — самый коварный раздел

Когда вы видите «671B» у DeepSeek V3, это общее число параметров, но активных из них только 37B благодаря архитектуре MoE. Модель физически занимает место на диске как гигант, но работает с затратами как середнячок. У плотных моделей (GPT-4o) общие и активные параметры совпадают — они тяжелы настолько, насколько выглядят. Сравнивайте не только цифры, но и архитектуру: MoE позволяет иметь огромную базу знаний при умеренной стоимости инференса, плотные модели — проще в развёртывании и предсказуемая по нагрузке.

Сводная таблица