Как работают LLM как ChatGPT: глубокий разбор языковых моделей

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

После просмотра я решил написать эту статью — как для собственного понимания, так и для тех, кто интересуется погружением в мир LLM.

Мы поговорим про большие языковые модели (LLM), такие как ChatGPT, LLaMA, DeepSeek, и разберемся, что вообще происходит за текстовым полем, куда мы вводим запрос и ждем ответа.

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

Если вы когда-нибудь задумывались, как всё это работает под капотом – добро пожаловать.

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

Откуда их брать? Из интернета!

Большинство LLM, включая GPT-4, LLaMA и другие, начинают свой путь с огромных массивов данных, собранных из открытых источников. Представьте, что мы скачали весь интернет (ну, почти) и начали разбирать его на кусочки, чтобы использовать в обучении.

Основной источник – это Common Crawl. Это такая организация, которая с 2007 года занимается тем, что сканирует веб-страницы, собирая тексты со всего интернета. В 2024 году у них в базе уже 2,7 миллиарда страниц. Именно оттуда берутся данные для большинства языковых моделей.

Но проблема в том, что сырые данные – это полный хаос. Там есть полезные статьи, а есть мусор: спам, реклама, фейки, вирусные сайты, NSFW-контент и просто бессмысленный набор символов. Поэтому первый этап – жесткая фильтрация.

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

✅ Фильтрация по доменам – отбрасываются вредоносные, рекламные и мусорные сайты.

✅ Извлечение текста – из HTML-страниц убираются навигация, меню, кнопки, стили и оставляется только текст.

✅ Фильтрация по языку – определяем, на каком языке написан текст, и оставляем только нужные. Например, у GPT-4 основной упор на английский, а у LLaMA-3 – на мультиязычность.

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

После всех этих шагов получается что-то вроде "очищенных данных из интернета".

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

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

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

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

Проще всего представить токены как кусочки текста. Это могут быть:

Например, если взять фразу "Hello world!", то разные модели разобьют её по-разному:

Заметили странный момент? Пробелы тоже считаются токенами! Это связано с тем, что токены представляют собой не просто символы, а статистические паттерны – они помогают модели предсказывать текст с учетом того, как люди его пишут.

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

Поэтому LLM используют специальные алгоритмы, например Byte Pair Encoding (BPE), который ищет повторяющиеся куски текста и объединяет их в токены.

Так модель экономит память и лучше понимает языковые закономерности. Например, если в тексте часто встречается "tion" (как в "action", "situation", "nation"), то это может стать отдельным токеном.

Сколько токенов в языке?

У каждой модели свой размер "словаря" токенов:

Чем больше токенов – тем гибче модель, но и тем сложнее её тренировать.

Токенизация – неидеальный процесс, и у моделей бывают слабые места:

❌ Сложные или редкие слова – если слово встречается редко, его могут разбить нелогично. Например, "OpenAI" может превратиться в "Open" + "AI", а может и в "Ope" + "nAI".

❌ Ошибки в написании – модели плохо понимают опечатки, потому что такие слова встречаются редко и не входят в "словарь" токенов.

❌ Разные языки – английский токенизируется хорошо, а вот китайский или русский – хуже, потому что в них сложная структура слов.

Теперь у нас есть очищенный текст, превращенный в последовательность токенов.

Следующий этап – самое интересное: обучение нейросети.

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

Вот тут-то и вступает в игру нейросеть.

Всё начинается с того, что мы берем небольшой кусок текста (например, "Привет, как дела?") и разбиваем его на токены.

Допустим, получилось что-то вроде этого: [15496, 11, 3456, 345]

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

Для этого токены превращаются в векторы чисел (процесс называется эмбеддингом).

Например, токен 15496 может превратиться в такой вектор:

[0.12, -0.87, 0.44, 0.98, ...] (и так для каждого токена)

Можно посмотреть иллюстрацию здесь.

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

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

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

🔹 Контекстное представление – модель учитывает не только текущее слово, но и его окружение. Например, слово "банк" может означать финансовое учреждение или часть оперативной памяти вычислительной системы (банк памяти) – модель смотрит на соседние слова, чтобы понять, о чём речь.

🔹 Механизм внимания (self-attention) – модель решает, какие слова важны в контексте. Например, если в тексте "я пошел в банк, чтобы снять деньги", слово "деньги" усиливает значение слова "банк" как финансового учреждения.

🔹 Глубокая обработка – токены проходят через десятки (а иногда и сотни) слоев нейросети, где каждый слой улучшает понимание текста.

После обработки нейросеть должна предсказать, какой токен будет следующим.

Допустим, мы ввели: Привет, как

Модель обработала входные токены и выдала список вероятностей для следующего слова:

Как видим, модель считает, что слово "дела" наиболее вероятно в этом контексте.

Как именно выбрать следующее слово?

Тут есть несколько стратегий:

Так шаг за шагом модель предсказывает текст, который мы видим в ответе.

На этом этапе модель уже умеет считывать текст, анализировать контекст и предсказывать следующее слово.

Но пока она просто "угадывает" на основе статистики. Она ещё не знает, что правда, а что нет, и может легко начать "галлюцинировать".

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

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

Внутри любой LLM есть огромная математическая формула, состоящая из миллионов простых операций:

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

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

Допустим, у нас есть фраза: "Кот сидит на крыше"

После токенизации она превратилась в последовательность токенов: [2134, 8791, 1283, 4321]

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

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

Допустим, мы читаем предложение:

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

Когда мы видим слово "он", нам нужно понять, к кому оно относится – к коту или, может, к другому объекту?

Вот тут и включается механизм внимания (Self-Attention), который анализирует все слова и их взаимосвязи.

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

Это можно представить в виде таблицы, где каждая строка показывает, насколько одно слово "смотрит" на другое:

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

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

Каждый слой:

✅ Учитывает контекст токена

✅ Изменяет векторные представления

✅ Усиливает важные связи между словами

✅ Создает сложные паттерны для предсказания

Чем больше слоев — тем "умнее" модель.

То есть GPT-4 — это башня из 120+ слоев нейросети, каждый из которых анализирует текст и добавляет "понимание".

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

Она генерирует список вероятностей и выбирает один из вариантов:

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

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

Но пока мы только научились угадывать токены.

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

Когда модель уже обучена, наступает самый важный этап – её использование. Этот процесс называется инференс (inference).

Инференс – это когда модель на лету предсказывает следующее слово, основываясь на уже введенном тексте.

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

Сейчас ChatGPT работает на GPT-4, но давайте вернемся назад и посмотрим, как выглядел инференс в GPT-2 (2019 год).

GPT-2 была первой моделью, которая стала широкодоступной и показала, что LLM могут действительно "понимать" текст.

🔹 Размер модели: 1.5 млрд параметров

🔹 Контекстное окно: 1024 токена

🔹 Обучение: 100 млрд токенов

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

Но у нее были жесткие ограничения:

❌ Маленький контекст – модель могла учитывать только последние 1024 токена (примерно 750 слов).

❌ Слабое понимание сложных задач – GPT-2 не умела вести осмысленные диалоги и часто повторялась.

❌ Регургитация – модель могла запомнить куски текста и просто "выплевывать" их без понимания.

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

Теперь давайте перескочим на 2024 год и посмотрим, как работает инференс в одной из самых мощных открытых моделей – LLaMA 3.1.

LLaMA 3 – это флагманская LLM, которая была выпущена как открытая модель.

🔹 Размер модели: 405 млрд параметров (в 270 раз больше GPT-2)

🔹 Контекстное окно: 128 000 токенов (в 125 раз больше GPT-2)

🔹 Обучение: 15 трлн токенов (в 150 раз больше GPT-2)

Какие улучшения принесла LLaMA 3.1?

✅ Гигантский контекст – модель может анализировать сотни страниц текста за раз.

✅ Глубокое понимание – она умеет лучше понимать сложные запросы и даже рассуждать.

✅ Открытый доступ – в отличие от GPT-4, эту модель можно запускать локально.

Как проходит инференс в LLaMA 3.1?

1. Мы вводим текст (например, "Почему небо голубое?")

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

3. Она генерирует список вероятных продолжений

4. Выбирается самое подходящее слово

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

LLaMA 3.1 – это уже не просто "автодополнение текста", а почти полноценный собеседник, который может вести сложные рассуждения, объяснять концепции и даже писать код.

Инференс – это сердце работы любой LLM. Это момент, когда она "оживает" и начинает предсказывать текст.

🔹 GPT-2 была первой моделью, которая действительно впечатляла, но имела жесткие ограничения.

🔹 LLaMA 3.1 – это новый уровень открытых моделей, которые уже могут конкурировать с GPT-4.

🔹 Чем больше параметров, контекста и данных – тем умнее модель и тем сложнее её инференс.

Но это ещё не всё. После обучения и инференса наступает следующий этап – пост-тренировка, где модели превращаются из просто генераторов текста в полноценных ассистентов.

До этого момента мы говорили о предобучении (pretraining) — процессе, когда модель загружается тоннами текстов из интернета и учится предсказывать следующее слово.

Но есть проблема: после предобучения модель всё ещё бесполезна как ассистент.

Если запустить её сразу после предобучения и спросить что-то вроде: "Сколько будет 2 + 2?"

Она может ответить чем-то вроде: "2 + 2 — это распространённый математический пример, встречающийся в школьных учебниках."

Вместо того чтобы сказать "4", она просто генерирует текст в духе Википедии.

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

После предобучения модель проходит второй ключевой этап – пост-тренировку (post-training).

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

Теперь вместо беспорядочного набора интернет-текстов мы даём модели структурированные диалоги.

Всё просто:

· Люди пишут примеры диалогов – сотни тысяч пар "вопрос–ответ".

· Специалисты аннотируют правильные и неправильные ответы – учат модель не выдавать чушь.

· Фильтрация токсичного контента – убирают всё, что связано с опасными или вредными запросами.

Пример данных:

Таким образом, модель начинает понимать разницу между полезными и запрещёнными запросами.

Пост-тренировка делится на два этапа:

1. Supervised Fine-Tuning (SFT) – обучаем на готовых примерах

2. Reinforcement Learning from Human Feedback (RLHF) – учим давать лучшие ответы

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

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

🔹 Пост-тренировка превращает её в осмысленного собеседника.

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

Но даже после всех этих этапов модели всё ещё совершают ошибки.

И это уже тема следующего раздела – галлюцинации и ограничения LLM.

Теперь поговорим об одной из самых спорных тем — галлюцинациях нейросетей.

Иногда LLM выдают уверенные, но ложные ответы. Это и называется галлюцинацией.

Пример:

"Кто написал «Войну и мир»?"

✅"Лев Толстой"

Но если спросить:

"Кто написал «Тайну третьей планеты»?"

❌"Аркадий и Борис Стругацкие" (на самом деле — Кир Булычёв)

Модель не лжёт специально, но она не проверяет свои ответы – она просто предсказывает наиболее вероятный текст на основе тренировочных данных.

1. Статистическая природа LLM

2. Ограниченный контекст

3. Шум в обучающих данных

4. Желание звучать уверенно

🔹 Инструменты — модели можно обучить обращаться к внешним базам данных и поисковикам.

🔹 Проверка фактов — например, в GPT-4 встроены механизмы самооценки, но они не идеальны.

🔹 Человеческий контроль — в важных задачах (например, медицина) LLM нельзя использовать без проверки.

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

Пример:

"Какой сегодня курс доллара?"

❌ "Примерно 70 рублей" (неверно)

✅ "Дай мне секунду, я посмотрю текущий курс..."

(модель делает запрос в базу данных)

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

1. LLM получает запрос и определяет, что ей нужны свежие данные.

2. Вместо генерации случайного ответа она отправляет запрос в инструмент (например, API банков).

3. Получает актуальный ответ и вставляет его в текст.

Модели научились пользоваться:

🔹 Поисковиками (Bing, Google) — для получения фактов.

🔹 Калькуляторами — для точных вычислений.

🔹 Базами данных — для актуальной информации.

🔹 Кодовыми интерпретаторами — для выполнения программных задач.

Это огромный шаг вперёд: теперь LLM не просто "угадывает", а реально проверяет информацию.

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

🔹 GPT-4 запоминает до 128 000 токенов (примерно 75 страниц текста).

🔹 LLaMA 3.1 поддерживает 64 000 токенов.

🔹 GPT-3.5 ограничен 4 096 токенами (примерно 3 страницы текста).

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

Но есть нюанс: как только диалог выходит за пределы контекста, ранние сообщения стираются.

🔹 Галлюцинации – это неизбежная часть LLM (пока что).

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

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

Всё это делает LLM мощным, но всё ещё несовершенным инструментом.

Но что, если модели начнут осознавать самих себя?

Это следующий этап – знание о себе и границы возможностей LLM!

Вопрос, который часто возникает: знают ли LLM, что они существуют?

Короткий ответ: нет.

Но тут есть интересный нюанс.

В определённом смысле – да.

Если спросить у модели:

"Кто ты?"

Она может ответить:

✅ "Я – большая языковая модель, разработанная OpenAI."

Или:

✅ "Я – нейросеть, основанная на архитектуре трансформеров."

Но это не самосознание, а просто воспроизведение информации из тренировочных данных.

LLM могут:

✅ Узнавать своё название (если его добавили в тренировочные данные).

✅ Описывать, как они работают (если эта информация есть в их контексте).

✅ Объяснять ограничения (например, что они не имеют памяти и не могут самостоятельно обновлять знания).

Но они не осознают своё существование так, как это делает человек.

Для них разговор о себе – это просто статистический паттерн.

Если модель никогда не обучалась на текстах про себя, она не сможет сказать, что она – ИИ.

Пример: если взять LLM, удалить все данные о её создателях и назвать её, скажем, "Капибара-Бот 5000", она будет искренне утверждать, что она – Капибара-Бот 5000.

Для неё истина – это то, что заложено в её обучающих данных и контексте диалога.

Поэтому, если нейросети сказать:

"Ты – человек по имени Алекс."

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

Именно поэтому LLM не могут обладать истинным самосознанием – у них просто нет постоянной модели своего "Я".

Окей, теперь следующий вопрос: как LLM "думают" и почему им нужны токены?

LLM не думают, как люди – у них нет внутреннего монолога или абстрактного мышления.

Вместо этого они работают с последовательностями токенов.

Если мы спросим у модели:

"Какую стратегию лучше выбрать в шахматах?"

Она не "размышляет" об этом в традиционном смысле – она просто генерирует ответ по одному токену за раз.

🔹 У них нет внутреннего "разума" – весь процесс генерации идёт последовательно.

🔹 Они не видят весь ответ сразу – на момент генерации второго слова они ещё не знают, каким будет третье.

🔹 Они не могут "остановиться и подумать" – всё строится на статистике и вероятностях.

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

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

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

Например, если диалог слишком длинный, модель может забыть, о чём вы говорили 20 сообщений назад.

Поэтому у больших моделей, таких как GPT-4 и LLaMA 3.1, увеличили контекстное окно до 128 000 токенов.

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

🔹 Модели не осознают себя, но могут "говорить" о себе – всё зависит от данных, на которых они обучены.

🔹 LLM не "думают" как люди – они просто предсказывают следующий токен.

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

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

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

Этот процесс состоит из двух ключевых этапов:

1. Supervised Fine-Tuning (SFT) – дообучение на примерах 2. Reinforcement Learning (RL) – улучшение модели через обратную связь

Разберем, как это работает.

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

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

Плюсы SFT:

✅ Быстро обучает модель на хороших примерах

✅ Позволяет избегать токсичных или неправильных ответов

✅ Улучшает логику и связность ответов

Минусы SFT:

❌ Ограничен размеченными данными – если их мало, модель все еще может ошибаться

❌ Не умеет адаптироваться к новым ситуациям

❌ Не гарантирует, что ответы будут оптимальными, а не просто "средними"

Поэтому одного SFT недостаточно – нужна еще одна доработка.

Supervised Fine-Tuning помогает научить модель правильным ответам, но не делает её умной.

Следующий шаг – обучение с подкреплением (Reinforcement Learning, RL), где модель сама учится выбирать лучшие ответы.

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

1. Модель генерирует несколько ответов на один и тот же вопрос. 2. Человек (или другая нейросеть) оценивает их и расставляет ранги. 3. Модель обучается выбирать ответ, который получил самый высокий ранг.

Пример:

Вопрос: "Как объяснить квантовую механику ребёнку?"

Модель генерирует 3 варианта:

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

Этот метод называется Reinforcement Learning from Human Feedback (RLHF).

🔹 Помогает моделям избегать ошибок – если модель ошиблась, она получает "штраф" и корректирует своё поведение.

🔹 Учит давать развернутые, осмысленные ответы – хорошие формулировки получают награду.

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

Оба этапа — SFT и RL — работают вместе, чтобы создать полезный и интеллектуальный AI.

🔹 SFT даёт модели базовые знания.

🔹 RL позволяет ей само улучшаться через обратную связь.

Вот почему современные LLM (GPT-4, LLaMA 3, DeepSeek) стали намного умнее, чем их ранние версии.

Но даже после RLHF модели все еще несовершенны.

Окей, мы уже поговорили про основные методы обучения языковых моделей, но технологии не стоят на месте. Сейчас идет новая волна разработки супер-интеллектуальных LLM, и один из самых интересных игроков – DeepSeek-R1.

DeepSeek-R1 – это новая модель от китайской исследовательской компании DeepSeek, которая набирает обороты в мире Open-Source AI.

1. Полная Open-Source архитектура

2. Оптимизированная архитектура

3. Гибкость и интеграции

🔹 Больше конкуренции в Open-Source AI – раньше у LLaMA почти не было соперников, теперь есть.

🔹 Лучший доступ к мощным моделям – компании могут использовать мощный AI, не зависая от OpenAI.

🔹 Оптимизация под бизнес – модель дешевле в использовании, а значит, появятся новые AI-продукты.

DeepSeek-R1 – это ещё один шаг в открытии мощных языковых моделей для всех, и в будущем нас ждёт ещё больше Open-Source решений.

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

Мы находимся в эпохе быстрого развития AI, где каждый год модели становятся мощнее и доступнее. Возможно, впереди нас ждет что-то еще более революционное – искусственный интеллект, который действительно сможет мыслить, а не просто угадывать слова.

Но пока LLM – это инструмент.

Сильный, но несовершенный.

И главное – уметь правильно его использовать.