Есть момент, который почти неизбежно наступает после нескольких месяцев работы с современными языковыми моделями. Сначала к ним относишься как к очень мощному инструменту: задаёшь вопрос, получаешь ответ, уточняешь, просишь переделать, проверяешь. Потом постепенно замечаешь, что инструмент начинает вести себя совсем не как обычная программа. Он удерживает нить разговора, возвращается к старым аргументам, меняет точку зрения по просьбе, умеет объяснять одну и ту же вещь на разных уровнях сложности. Иногда он даже замечает собственную ошибку — а иногда с совершенно одинаковой уверенностью доказывает две вещи, которые противоречат друг другу.
Вот этот последний случай интереснее всего.
Ошибка сама по себе мало что объясняет. Ошибаются любые сложные системы. Гораздо важнее понять, почему модель способна построить убедительное представление некоторой ситуации, а затем, продолжая тот же разговор, построить другое представление, несовместимое с первым. Если внутри действительно существует некоторое устойчивое состояние, которое можно назвать представлением смысла, почему оно иногда так легко меняется?
Вопрос можно поставить ещё жёстче: где именно в такой системе находится то, что мы называем смыслом?
Не в философском смысле. Не в попытке определить, «понимает» ли машина человека.
В архитектурном.
Потому что если мы хотим построить следующую генерацию ИИ, нам в какой-то момент придётся ответить не только на вопрос, насколько хорошо модель продолжает текст, но и на вопрос, какую структуру она строит по ходу этого продолжения.
Машина, которая всё время идёт вперёд
Базовая идея языковой модели удивительно проста. На каждом шаге она получает некоторый контекст и оценивает вероятности следующего токена. Выбранный токен становится частью нового контекста, после чего вычисление повторяется.
Если отбросить детали реализации, получится почти механическая последовательность:
контекст ↓ вычисление ↓ распределение вероятностей ↓ следующий токен ↓ новый контекст ↓ следующий шаг
На уровне одной операции здесь нет ничего похожего на человеческое рассуждение. Но именно из повторения этой операции возникает система, которая способна писать программы, пересказывать научные статьи, строить доказательства и поддерживать длинные диалоги.
Поэтому было бы ошибкой говорить, что языковая модель «просто угадывает следующее слово». Чтобы хорошо предсказывать следующий токен, ей приходится выстраивать огромное количество скрытых зависимостей. Она должна каким-то образом различать объекты, отношения между ними, контекст, стиль, причинность, временную последовательность и множество других вещей, которые непосредственно в следующем токене не содержатся.
Из очень простой локальной операции постепенно вырастает чрезвычайно сложная внутренняя геометрия.
Простое правило не означает простую систему.
Но здесь появляется интересный вопрос. Если внутри действительно возникает такая геометрия, почему она существует именно в той форме, в которой существует?
Между текстом и тем, что текст означает
Представим человека, который объясняет вам дорогу в незнакомом городе.
Он может сказать: выйдите из здания, идите прямо до перекрёстка, поверните направо, через двести метров перейдите дорогу и дальше двигайтесь до площади. Если вы будете точно выполнять инструкции, скорее всего, доберётесь куда нужно.
Но теперь попробуйте задать ему другой вопрос: что находится между двумя районами, можно ли попасть туда другим маршрутом, что изменится, если мост перекроют? Последовательности инструкций уже недостаточно.
Вам нужна карта.
Карта не является более подробной инструкцией. Она представляет город иначе. В ней важны не столько порядок действий, сколько отношения между объектами. Благодаря этому можно построить маршрут, которого никто заранее не описывал.
С текстом происходит нечто похожее.
Фраза:
«Пётр взял ключ со стола, открыл дверь и вошёл в комнату»
существует как последовательность слов. Но ситуация, которую она описывает, имеет другую структуру. В ней есть человек, ключ, стол, дверь, комната и несколько отношений между ними.
┌── находился на → столе
│
Пётр ── взял ──→ ключ ──┘
Пётр ── открыл ──→ дверь ── ведёт в ──→ комнату
Когда человек через минуту отвечает на вопрос «где был ключ?», ему не приходится заново проговаривать исходное предложение. Он обращается к некоторому уже сформированному представлению ситуации.
У языковой модели такого простого разделения нет.
Это не значит, что у неё отсутствуют внутренние представления. Наоборот, они чрезвычайно богаты. Но они распределены внутри общей вычислительной динамики модели, и неочевидно, существует ли там отдельный объект, который можно назвать устойчивой смысловой картой, проверить, изменить или использовать как координатную систему для следующего вычисления.
Вот здесь и появляется архитектурная проблема.
Почему нельзя просто сделать модель ещё больше
Самый сильный ответ на всё это звучит очень просто: масштабирование пока работает.
И это действительно серьёзный аргумент. Рост вычислительных ресурсов, данных и размеров моделей последовательно приносил новые способности. Поэтому было бы странно объявлять существующую парадигму исчерпанной только потому, что нам хочется другой архитектуры.
Но между двумя утверждениями есть существенная разница.
Первое: большая модель может обладать новыми способностями.
Второе: увеличение модели обязательно создаёт новую форму представления смысла.
Первое мы наблюдаем. Второе ещё нужно доказать.
Поэтому здесь разумнее говорить не о «конце Transformer», а о возможном структурном ограничении. Если одна и та же базовая схема продолжает масштабироваться, не меняя способ организации состояния, то в какой-то момент может оказаться, что увеличение количества параметров решает количественные проблемы, но не меняет сам характер вычисления.
Именно это в нашей архитектуре является гипотезой, а не установленным фактом.
Можно представить её совсем просто: возможно, существует предел, после которого системе становится выгоднее не просто увеличивать существующее пространство представлений, а добавить в него отдельный уровень устойчивой структуры.
И тогда возникает естественный вопрос: что должно стать такой структурой?
Полюса вместо бесконечного тумана
Представим пространство представлений модели как огромный ландшафт. В нём есть области, где близкие по смыслу состояния оказываются рядом, есть направления, по которым представление может двигаться в зависимости от контекста, и есть множество переходов между ними.
Проблема такого пространства в том, что оно непрерывно.
В этом одновременно его сила и слабость.
Непрерывность позволяет модели очень тонко различать похожие понятия. Но если нам нужно сказать, что некоторое понятие должно сохраняться как устойчивая координата, возникает трудность. У нас есть область пространства, но нет обязательной точки, к которой система должна возвращаться.
Поэтому первый слой предлагаемой архитектуры вводит семантические полюса.
Полюс — это не слово и не готовый ответ. Скорее, это устойчивая точка в пространстве представлений, которая должна обозначать некоторый концепт или ограничение. Входное состояние сначала сопоставляется с такими полюсами, а уже затем передаётся в непрерывную обработку.
Получается небольшая, но принципиальная перемена:
вход
│
▼
┌─────────────────┐
│ поиск полюса │
│ в семантической │
│ карте │
└────────┬────────┘
│
▼
устойчивая
смысловая опора
│
▼
дальнейшая обработка
Это похоже на координатную сетку карты. Сетка не рассказывает нам всё о городе, но позволяет определить, где именно мы находимся.
Именно здесь появляется одна из самых неприятных инженерных задач.
Как обучать дискретную карту
Обычная нейросеть хорошо приспособлена к непрерывным изменениям. Параметры немного сдвигаются, ошибка меняется, градиент показывает направление дальнейшего движения.
Но полюс — дискретный объект.
Если система выбрала полюс №137, она не может выбрать «137,3». Можно выбрать 137 или 138.
Это создаёт разрыв между тем, как система принимает решение, и тем, как её принято обучать.
Один из способов обойти проблему — straight-through estimator. На прямом проходе система делает настоящий дискретный выбор, но при обратном распространении ошибки пропускает через него приближённый градиент, как будто операция была непрерывной. Такой приём позволяет обучать систему, хотя математически он не делает дискретизацию непрерывной.
Другой механизм — commitment loss. Если скрытое состояние выбрало определённый полюс, его дополнительно подтягивают к этому полюсу. Иначе карта постепенно может превратиться в набор формальных индексов, которые плохо связаны с теми состояниями, которые они должны представлять.
Наконец, сами полюса можно обновлять через статистику состояний, которые к ним притягиваются, например скользящим усреднением. Тогда карта не дёргается вместе с каждым отдельным шагом оптимизатора, а меняется медленнее.
Всё это звучит вполне инженерно.
И это хорошо.
Потому что здесь уже можно поставить эксперимент.
У карты есть ещё одна проблема: она может начать пустеть
Предположим, мы создали большое количество полюсов. После длительного обучения часть из них используется постоянно, а часть почти никогда не активируется.
Это естественная проблема любой дискретной карты. Если определённая область пространства данных встречается редко, соответствующий полюс может постепенно потерять связь с реальными состояниями.
Он остаётся в памяти системы, но перестаёт выполнять работу.
Так появляются мёртвые полюса.
Предлагаемый механизм их оживления достаточно интуитивен: если полюс долго не используется, его можно переместить в область, где наблюдается высокая плотность представлений, но существующие полюса покрывают её плохо. Таким образом, карта пытается перераспределять своё ограниченное количество координат туда, где они действительно нужны.
Но здесь есть тонкая граница.
Если двигать полюса слишком быстро, карта будет постоянно забывать старую структуру. Если сделать её слишком стабильной, она перестанет адаптироваться к новым данным.
Получается почти биологическая проблема: система должна сохранять форму и одновременно уметь перестраиваться.
И теперь возникает другой вопрос: что делать, если разные типы смысла требуют от такой карты совершенно разного поведения?
Когда одна карта становится слишком грубой
Представим два понятия.
Первое — технический термин, например конкретный механизм программирования.
Второе — ограничение, которое система не должна нарушать независимо от конкретной задачи.
Оба можно представить как концепты. Но требования к ним совершенно разные.
Технический термин должен свободно взаимодействовать с множеством соседних понятий. Его значение может уточняться контекстом, зависеть от языка программирования, версии библиотеки или конкретного фрагмента кода. Здесь полезна гибкость.
Ограничение устроено иначе. Если оно действительно является ограничением, его нежелательно каждый раз переинтерпретировать вместе с окружающим контекстом.
Если поместить оба типа информации в одно пространство и заставить их обучаться одинаковым способом, мы получим конфликт. Редкие, но важные ограничения будут конкурировать с огромным количеством доменных представлений, а слишком жёсткие ограничения начнут мешать нормальной работе с контекстом.
Поэтому архитектура разделяет два потока.
Один работает с устойчивыми ограничениями.
Другой — с доменным содержанием.
Это разделение относится именно к логике Layer 1: сначала система определяет устойчивую смысловую область и ограничения, а затем передаёт состояние дальше. Layer 2 не заменяет этот механизм, а продолжает обработку уже подготовленного представления.
В ограничивающем потоке полюс может действовать как маска: он убирает запрещённое направление, оставляя остальные компоненты доменного представления практически нетронутыми.
Получается не столько вторая нейросеть, сколько отдельный контур управления.
Вопрос о том, кто и как одобряет действия агента на границе системы, мы подробно разбирали в статье «От исполнителя к организации: кто одобряет действия агента».
Непрерывность всё равно возвращается
Если сделать всю архитектуру дискретной, она потеряет большую часть того, что делает современные модели полезными. Язык полон оттенков, неполных совпадений, контекстных зависимостей и слабых связей. Нельзя заранее разложить всё это по фиксированным ячейкам и ожидать, что система сохранит прежнюю гибкость.
Поэтому после выбора смысловой опоры Layer 2 снова возвращает вычисление в непрерывное пространство. Здесь остаётся место для обычной нейросетевой динамики — с её нелинейностью, вниманием и способностью различать тонкие оттенки.
Разница лишь в том, что теперь эта динамика не обязана одна отвечать за всю архитектуру.
У неё есть координаты, относительно которых можно работать с локальным контекстом.
Память не обязательно должна быть спрятана в весах
С памятью возникает похожая история.
Современная модель может хранить огромное количество информации внутри параметров, но параметрическое знание плохо приспособлено для точечного редактирования. Если человеку нужно добавить новый факт, удалить старый или изменить конкретную связь, не всегда разумно ради этого менять всю модель.
Гораздо естественнее вынести изменяемую часть знания в отдельную структуру.
Так появляется графовая память.
В ней сущности, свойства и отношения существуют явно. Если человек сменил работу, можно изменить соответствующую связь. Если источник оказался недостоверным, можно отметить или удалить его. Если появилась новая сущность, её можно добавить.
Это совсем другой способ обращения со знанием.
Но граф приносит с собой проблему, которой нет на красивой архитектурной диаграмме.
Процессор любит последовательность. Граф любит прыжки.
Когда система идёт по графу, соседние узлы могут физически находиться далеко друг от друга в памяти, поэтому обход графа быстро превращается в проблему задержек и доступа к кэшу.
Для первой статьи этого достаточно. Детали того, как такую память можно физически организовать, мы оставим отдельному разговору — а о том, как память биологических систем превращается в инженерную архитектуру, мы писали в статье «За пределами контекстного окна — инженеринг Engram для продуктивной агентной памяти».
Три разных типа вычисления
Если собрать всё вместе, получается довольно необычная конструкция.
Первый слой должен хранить устойчивые смысловые координаты и ограничения.
Второй занимается гибкой нейросетевой обработкой.
Третий хранит изменяемую структуру знаний.
ВХОД
│
▼
┌─────────────────────┐
│ Layer 1 │
│ семантические │
│ полюса │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Layer 2 │
│ локальный │
│ нейросетевой │
│ контекст │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Layer 3 │
│ графовая память │
└──────────┬──────────┘
│
▼
ВЫХОД
На бумаге это выглядит просто.
Но за этой простотой скрывается довольно серьёзное изменение архитектурной логики. Мы больше не предполагаем, что одна вычислительная среда должна одинаково хорошо выполнять все функции. Для каждой части системы можно искать собственный режим работы и даже собственную физическую реализацию.
И вот здесь в историю входит фотоника.
Плотные матричные операции Layer 2 хорошо соответствуют тому типу вычислений, для которого уже давно рассматриваются фотонные ускорители. Детерминированная логика Layer 1 и работа с памятью, напротив, естественнее остаются на электронных системах.
Получается гибрид:
СИСТЕМА
│
┌─────────┴─────────┐
│ │
цифровая часть фотонная часть
│ │
Layer 1 + Layer 3 Layer 2
│ │
└─────────┬─────────┘
│
общий контур
И здесь начинается уже другая история.
Потому что как только мы перестаём требовать от одного типа вычислительного носителя выполнять всё сразу, возникает возможность сопоставить структуру задачи со структурой физики.
Но карта ещё не означает понимания
На этом месте очень легко сделать слишком большой вывод.
Можно сказать: мы добавили смысловые полюса, внешнюю память, разделили вычислительные потоки — значит, получили систему, которая наконец-то понимает.
Нет.
Ничего подобного мы пока не доказали.
Мы даже не доказали, что именно такая архитектура окажется лучше хорошо масштабированного Transformer.
Но мы сделали кое-что более полезное.
Мы превратили расплывчатый разговор о «понимании» в набор инженерных вопросов.
Можно проверить, насколько устойчивы полюса. Можно измерить, сколько из них становятся мёртвыми. Можно сравнить модель с непрерывным baseline. Можно проверить, сохраняется ли качество после разделения потоков. Можно измерить стоимость графовой памяти и проверить, насколько хорошо изменяемое знание действительно редактируется без переобучения всей системы.
Вместо вопроса «понимает ли машина?» появляется вопрос, который инженер способен взять в руки.
Какую структуру машина строит — и что она может с этой структурой делать?
Отсюда и начинается следующая часть
Вся эта статья до сих пор была разговором о принципе.
Но принцип сам по себе почти ничего не стоит, если его нельзя превратить в работающий механизм.
Мы можем нарисовать на схеме слой семантических полюсов. Можем назвать их координатами смысла. Можем разделить доменный и ограничивающий потоки.
Но откуда берётся сам полюс?
Кто решает, что два состояния относятся к одному понятию? Почему один полюс должен быть близок к другому, а третий — нет? Что происходит, когда понятие меняет значение в зависимости от контекста? И сколько вообще таких полюсов нужно системе, которая должна работать не с одной предметной областью, а с языком в целом?
Вот здесь красивая архитектурная схема заканчивается.
Начинается инженерия.
В следующей статье мы разберём, как может формироваться семантическая карта, почему она неизбежно сталкивается с проблемой дискретного обучения и что произойдёт, если карта начнёт забывать собственные координаты.
Серия «Трёхслойный семантический движок»: часть 1 из 3.
Эта статья — вводная: от задачи next-token prediction к архитектурной гипотезе трёх слоёв. В части 2 разберём, как формируется сама семантическая карта, как обучать дискретные полюса и что происходит, когда карта начинает забывать собственные координаты. Часть 3 — о том, почему граф сам по себе ещё не память: время, источники, доверие и противоречия, и почему проблема противоречивых знаний превращается в проблему времени.