Катастрофическое забывание у ИИ
Катастрофическое забывание у ИИ (catastrophic interference, catastrophic forgetting, амнезия нейросеток, деменция искусственного интеллекта) — это эпичный баг (или фича, в зависимости от того, кого спросить) коннекционистских систем, суть которого заключается в том, что искусственная нейронная сетка при попытке выучить что-то новое берет и радикально выпиливает из своих весов всю ту инфу, которую она учила до этого. В итоге, если ты обучил свой навороченный перцептрон отличать котиков от собачек, а потом решил дообучить его распознавать еще и енотов, твоя сетка с вероятностью чуть более, чем 100 % забудет, как выглядят котики и собачки, и начнет считать все сущее енотами.
Для любого анонимуса, знакомого с тем, как работает человеческий мозг, этот факт кажется полнейшим абсурдом. Ведь если ты выучил таблицу умножения, а потом пошел учить французский язык, ты же не забываешь внезапно, сколько будет 2 умножить на 2, верно? (Если только ты не обдолбался какими-нибудь веществами, расширяющими сознание до состояния сингулярности, но это уже совсем другая история). А вот ИИ, который маркетологи из корпораций добра так любят сравнивать с человеческим разумом, страдает этой херней постоянно. Это явление было впервые описано в 1989 году расовыми американскими учеными МакКлоски и Коэном, и с тех пор заставляет кровоточить глаза и мозги 1000 (а то и 1000000) дата-саентистов по всему миру.
Истоки фейла[править]
Мы просто хотели научить ее складывать 1 и 2... А она забыла всё!
В далеком 1989 году, когда деревья были большими, а нейросети состояли из 3 слоев и обучались на калькуляторах, 2 суровых исследователя решили проверить, насколько хорошо работает метод обратного распространения ошибки (backpropagation). Они взяли стандартную сетку и обучили ее прибавлять цифру 1 к другим цифрам. То есть сетка выучила, что 1+1=2, 1+2=3, 1+3=4 и так далее вплоть до 1+9=10. Ошибка (loss) радостно стремилась к 0, сетка выдавала 100 % правильных ответов. Ученые обрадовались и решили: А теперь давай научим ее прибавлять цифру 2!
Они собрали датасет из примеров вида 2+1=3, 2+2=4… и начали обучать ту же самую сетку. Сетка быстро всосала новые знания и научилась прибавлять 2. Но когда коварные исследователи решили проверить, помнит ли она, как прибавлять 1, их ждал эпичнейший облом. Сетка не просто стала ошибаться — она выдавала полную, несусветную дичь. Ее ответы на примеры с 1 стали больше похожи на мусор, чем на числа. Ошибка скакнула на порядки. Сетка забыла абсолютно всё, чему ее учили на 1-м этапе. Более того, даже пример 1+2, который вообще-то присутствовал в обоих датасетах, на 1-х эпохах нового обучения тоже пострадал!
В 1990 году к этой веселой компании присоединился еще 1 чувак по фамилии Рэтклифф. Он взял разные архитектуры, от крошечных до огромных, и попытался заставить их учить слова последовательно (сначала группу А-Б, потом В-Г и так далее). Результат был тот же: стоило сетке увидеть новую информацию, как старая улетала в /dev/null с катастрофической скоростью. Рэтклифф с грустью констатировал, что нейросети ведут себя прямо противоположно человеческой памяти — если у человека способность к различению старого и нового с опытом только растет, то у перцептронов она стремится к 0.
Дилемма стабильности-пластичности[править]
Как сделать так, чтобы система была достаточно гибкой для восприятия новой хуиты, но достаточно жесткой, чтобы старая хуита не выпадала из нее при каждом чихе?
Вся эта хрень произрастает из так называемой дилеммы стабильности-пластичности (stability-plasticity dilemma). Любая обучающаяся система болтается где-то на шкале между 2 крайностями:
- Таблица поиска (lookup table, или тупо жесткий диск). Стабильность равна 100 %, пластичность равна 0. Если ты записал туда файл, он там лежит и никуда не девается. Но система ничему не учится, не умеет обобщать и не может сказать, что собака на новой фотке похожа на собаку со старой фотки.
- Распределенная коннекционистская сеть (наш пациент). Пластичность зашкаливает, сеть отлично обобщает (generalize), находит скрытые паттерны и рисует красивые картинки. Но стабильность около 0: новые данные, как цунами, переписывают веса, стирая старые связи.
Когда нейросеть обучается, она двигается в абстрактном N-мерном пространстве весов, пытаясь найти такую точку (минимум функции потерь), где ответы на текущий датасет будут идеальными. Когда ты подсовываешь ей новый датасет, она радостно срывается с насиженного места и бежит искать новую точку, подходящую для новых данных. Ей абсолютно насрать, что прошлая точка была важна для прошлых данных — градиентный спуск бессердечен, он видит только то, что перед ним прямо сейчас.
Матан[править]
Почему так происходит? Корень зла таится в самом понятии распределенного представления (distributed representation). В человеческом мозге (и в нормальных базах данных) информация часто локализована. В базе данных есть ячейка, где лежит значение. В мозге тоже есть некоторая модульность. А вот в классическом MLP (Multi-Layer Perceptron) каждый концепт размазан по всем весам сети. 1 вес участвует в распознавании и котика, и собачки, и числа 1, и числа 2.
Когда ты начинаешь обучать сетку новой задаче, алгоритм обратного распространения (backpropagation) высчитывает ошибку и говорит: Так, чтобы выдать правильный ответ для енота, мне нужно подкрутить вот эти 1000000 весов на +0.01. И он их крутит. Но эти же самые 1000000 весов формировали идеальный баланс для распознавания котика! Все, баланс нарушен. Сетка разломана.
Представь себе, что ты пытаешься настроить радиоприемник с 1 крутилкой на 2 разные станции одновременно. Как только ты настраиваешься на 2-ю станцию, 1-я начинает шипеть и пропадает. Катастрофическая интерференция — это когда у тебя 1000000 крутилок, но ты пытаешься настроить их так, чтобы они подходили под новые частоты, сбивая старые.
Как с этим борются[править]
С 1989 года яйцеголовые из всяких гуглов, запретбуков и MIT придумали over 9000 способов победить эту заразу. Большинство из них — это просто лютые костыли, которые пытаются обмануть математику.
1. Ортогонализация[править]
Идея проста как 5 копеек: давайте сделаем так, чтобы входные векторы для разных задач были ортогональны (перпендикулярны) друг другу в математическом смысле. То есть, скалярное произведение вектора старой задачи и вектора новой задачи должно быть равно 0. Если векторы ортогональны, то их влияния на веса сети не пересекаются (или пересекаются минимально). Звучит круто на бумаге. В реальности же заставить все данные в мире быть ортогональными друг другу — это утопия. Представь, что ты заставляешь все изображения в мире не иметь ни 1 похожего пикселя. Epic Fail.
2. Заострение узлов[править]
Чувак по имени Френч в 1991 году предложил: а давайте сделаем представления не полностью распределенными, а полураспределенными. Искусственно заставим сетку использовать только небольшую часть скрытых нейронов для каждой конкретной задачи. Те нейроны, которые активировались сильно, мы сделаем еще сильнее (заострим), а те, что слабо — обнулим. Таким образом, для задачи 1 будут работать нейроны с 1 по 10, а для задачи 2 — нейроны с 11 по 20. Перекрытие уменьшится, и забывание тоже. Метод неплох, но ограничивает возможности сетки (емкость падает).
3. Повторение и псевдо-повторение[править]
Самый тупой и железобетонный метод. Если сетка забывает старые данные при изучении новых — так давайте просто каждый раз подмешивать к новым данным старые! Хочешь научить сетку цифре 2? Добавь в обучающую выборку цифру 1. Хочешь научить цифре 3? Обучай на 1, 2 и 3 одновременно. Проблема? Вычислительная сложность растет экспоненциально. Если у тебя сетка учится всю жизнь, тебе придется таскать за собой датасет размером в 100500 петабайт и каждый раз прогонять его через сеть. В человеческом мозге так не работает: ты же не повторяешь алфавит каждый раз, когда читаешь новую книгу.
Тут на сцену выходит псевдо-повторение (pseudo-rehearsal). Идея от Робинса (1995). Если мы не можем хранить старые данные, давайте заставим сетку саму генерировать воспоминания! Перед тем как учить новую задачу, мы прогоняем через обученную сетку белый шум (рандомные числа) и сохраняем то, что она выдала на выходе. Эти пары рандомный шум -> старый ответ сетки мы используем как суррогатный датасет старой задачи и смешиваем его с новыми данными. Как ни странно, этот лютый костыль работает и реально спасает старые веса от деградации.
4. Генеративное воспроизведение[править]
С развитием глубокого обучения (Deep Learning) псевдо-повторение мутировало в генеративное воспроизведение. Теперь мы берем не просто случайный шум, а тренируем параллельно вторую нейросеть — генеративно-состязательную сеть (GAN) или вариационный автоэнкодер (VAE) — которая учится генерировать фейковые данные, похожие на старые. По сути, система состоит из 2 сетей:
- Генератор (фантазер), который создает примеры из прошлого.
- Решатель (работяга), который учится на новых данных + на галлюцинациях генератора.
Это до боли напоминает то, что происходит в мозгу человека во время сна!
5. Биологический сон[править]
Ученые давно знают, что если человек не будет спать, у него поедет крыша, а память перестанет работать. Во время фазы медленного сна (NREM) гиппокамп берет и проигрывает воспоминания за день, перекидывая их в неокортекс для постоянного хранения. Британские ученые (и не только), такие как Баженов в 2022 году, начали внедрять аналоги сна в спайковые нейронные сети. Сети дают поспать, заставляя ее в офлайн-режиме гонять внутренние спонтанные волны активаций, чтобы синаптические веса стабилизировались. ZOG одобряет.
6. Эластичное закрепление весов[править]
В 2017 году ребята из DeepMind выкатили статью, где предложили элегантный математический хак. Суть EWC: после того как мы обучили сетку задаче А, мы вычисляем, какие конкретно веса были самыми важными для этой задачи. Для этого используется суровая матан-магия под названием Матрица Фишера (Fisher information matrix). Когда начинается обучение задаче Б, мы добавляем в функцию потерь (loss) специальный штраф (пружину). Если градиент пытается сдвинуть важный для задачи А вес, пружина бьет его по рукам и говорит: Не трогай, сука, это святое!. А те веса, которые для задачи А были бесполезны, градиент может крутить как угодно. В итоге сеть умудряется выучить и А, и Б, распихивая знания по разным углам своей архитектуры. Винрарно!
Катастрофическое вспоминание[править]
Если ты думал, что катастрофическое забывание — это дно, то снизу постучали. Встречай: катастрофическое вспоминание (оно же экстремальное дежавю или сверхгенерализация). Это обратный баг, который возникает, когда ты пытаешься вылечить забывание слишком большим количеством повторений или перегружаешь сеть. В какой-то момент сеть ловит шизу и теряет способность отличать то, что она реально видела в обучающей выборке, от того, чего там отродясь не было.
Представь, что сетка должна запомнить 1000 лиц людей. Ты пичкаешь ее этими лицами так интенсивно, чтобы она ничего не забыла, что в итоге она начинает выдавать ответ Я его знаю, это Вася! на лицо любой табуретки, случайного пиксельного шума или вообще на пустой экран. Сеть превращается в идеальный проходной двор, который пропускает через себя любой инпут и говорит Ага, это паттерн номер 234, полностью утратив способность к дискриминации. В этом состоянии нейросеть можно смело нести на помойку, потому что она перестает быть экспертной системой и становится шизофреником, у которого каждое облако на небе — это лицо Иисуса.
LLM[править]
Сегодня, в эпоху трансформеров на 100000000000 параметров (типа GPT-5, Claude и прочих LLM), проблема катастрофического забывания никуда не делась, она просто обросла новыми слоями корпоративного булшита. Когда OpenAI берет свою гигантскую языковую модель и начинает делать ей RLHF (Reinforcement Learning from Human Feedback) — то есть обучать ее быть безопасной, этичной и не ругаться матом — модель начинает тупеть.
Это проявление катастрофического забывания. Ты берешь базовую модель, которая знает 1000000 фактов о физике, химии, кодинге и рецептах варки мета, и начинаешь штрафовать ее за то, что она рассказывает про варку мета. Веса сдвигаются. И внезапно оказывается, что модель забыла, как писать код на Python, или разучилась решать логические задачки. В сообществе это прозвали лоботомия ИИ. Корпорации пытаются балансировать на тонкой грани, подмешивая в датасет безопасности старые добрые данные по программированию и математике, чтобы EWC и Rehearsal механизмы (о которых выше) удерживали ИИ от полного скатывания в деградацию.
Китайская комната[править]
Весь этот цирк с конями и весами возвращает нас к вечному философскому вопросу: а мыслит ли эта железяка вообще? Катастрофическое забывание — отличный аргумент для сторонников Джона Сёрла с его мысленным экспериментом Китайская комната (Chinese Room). Сёрл утверждал, что система может манипулировать символами (как китаец, который сидит в комнате с инструкциями и перекладывает иероглифы, не понимая их смысла), но при этом не обладать сознанием.
То, как легко нейросети стирают свои воспоминания, просто потому что градиент показал в другую сторону, намекает на отсутствие какого-либо семантического понимания (symbol grounding). Человек понимает суть цифры 1 и цифры 2. Ему не нужно переписывать синапсы, чтобы сохранить оба концепта. Нейросеть же видит только паттерны чисел с плавающей точкой. Как только паттерн 2 становится выгоднее для снижения ошибки, паттерн 1 идет под нож. Никакой памяти в человеческом смысле там нет, есть лишь текущее состояние аппроксимации функции.
Но кому какое дело до философии, когда инвесторы заносят еще 1000000000 долларов в стартап, который обещает решить проблему забывания при помощи очередной примочки с графом знаний и латентными пространствами?
Латентное обучение и ECOC[править]
Кстати, о латентных пространствах. В 2015 году Гутштейн (Gutstein) и Стамп (Stump) выкатили еще 1 забавный костыль, вдохновленный экспериментами Толмена над крысами в 1930-х годах. Толмен заметил, что крысы, бегающие по лабиринту без награды, все равно запоминают его карту (формируют когнитивную карту лабиринта). Это и есть латентное обучение — ты учишься даже тогда, когда тебя за это не хвалят и не бьют током.
В нейросетках это реализовали через хитровыдуманные коды с коррекцией ошибок (Error Correcting Output Codes — ECOC). Вместо того чтобы заставлять сеть выдавать 1 на нужный класс и 0 на все остальные (так называемый 1-hot encoding, который рвется по швам при добавлении новых классов), сети дают векторный код. Когда сеть учит новые классы, алгоритм смотрит, как сеть латентно (в скрытом слое) уже реагирует на эти новые данные, и подгоняет новые цели так, чтобы они минимально конфликтовали с уже сформировавшимися внутренними представлениями. То есть вместо того, чтобы ломать сетку через колено, мы смотрим: Ага, эта картинка у тебя вызывает возбуждение нейронов 5 и 8. Ок, давай скажем, что правильный ответ для этой картинки и должен опираться на нейроны 5 и 8. Конфликт минимизирован, интерференция снижена.
Архитектурные подходы[править]
Если веса постоянно перезаписываются, почему бы просто не запретить их перезаписывать? Так рассудили разработчики прогрессивных нейронных сетей (Progressive Neural Networks, PNN). Алгоритм уровня гениальный индус-быдлокодер:
- Берем нейросеть, учим на Задачу 1.
- Замораживаем все веса (вообще все, наглухо).
- Появляется Задача 2. Мы создаем новую нейросеть (колонку) рядом со старой.
- Новая сеть может читать данные с выходов скрытых слоев старой сети, но старая сеть остается нетронутой.
- Появляется Задача 3 — добавляем 3-ю колонку, которая читает из 1-й и 2-й.
Плюсы: катастрофическое забывание равно абсолютному 0. Старые навыки работают как швейцарские часы.
Минусы: размер твоей сети растет пропорционально количеству задач. Если у тебя 1000 задач, у тебя в памяти висит 1000 нейросетей, соединенных диким клубком спагетти-связей. Видеокарта делает пшшш и сгорает. Попытка внедрить PNN в масштабный production заканчивается тем, что DevOps-инженеры увольняются и уходят в монастырь. Динамическое усреднение весов (Dynamic Weight Averaging) и компартментализация (compartmentalization) пытаются как-то сгладить этот пиздец, активируя только нужные модули, но архитектурная франкенштейнизация все равно неизбежна.
Память, усиленная нейросетями (MANN)[править]
А что если мы прикрутим к нейросети внешний жесткий диск? Реально, возьмем и приделаем внешнюю память, в которую сеть сможет писать тензоры и читать оттуда по необходимости. Так родились Memory-Augmented Neural Networks, такие как DNC (Differentiable Neural Computer) от тех же парней из DeepMind. И такие штуки как GEM (Gradient Episodic Memory). Суть в том, что когда сеть учит что-то новое, она сохраняет куски старого опыта во внешнюю матрицу. При градиентном спуске алгоритм проверяет: Эй, этот шаг, который мы сейчас сделаем, не увеличит ли ошибку на тех данных, что лежат во внешней памяти?. Если ответ положительный, градиент проекционно корректируется так, чтобы не портить старое. Звучит как магия, но вычислительные затраты на проверку каждого шага об прошлый опыт заставляют рыдать даже владельцев кластеров H100.
Двойные сети Анса-Руссета[править]
В 1997 году 2 француза, Анс и Руссет, не зная о работах Френча, выкатили свою двухсетевую архитектуру. Они сделали сеть, которая сама себя освежает (self-refreshing memory). Их система состояла из 2 сетей, которые реверберировали (reverberating process). Звучит как извращение, но суть такова: когда система спит (вспоминаем аналогию со сном), 1-я сеть начинает генерировать случайные внутренние паттерны (не из входов, а из рандомного семени внутри себя), пропускает их через свои нелинейные аттракторы и передает во 2-ю сеть. Таким образом они перегоняют скрытые знания туда-сюда, оптимизируя глубокую структуру весов без использования внешних псевдо-паттернов в классическом виде. Это позволило им избежать катастрофического забывания при сериальном изучении временных последовательностей. Французская школа коннекционизма во всей красе.
Масштаб трагедии[править]
Без решения этой проблемы мы никогда не получим AGI (Artificial General Intelligence) — тот самый Сильный ИИ, который либо спасет человечество, либо превратит его в биореактор (или просто убьет всех людей ради скрепок, как в мысленном эксперименте Ника Бострома).
Существующие AI-модели — это аутичные саванты. GPT-5 охуительно пишет эссе и решает задачи, но это статичный слепок знаний, обученный до конкретной даты отсечки. Чтобы добавить в GPT новые знания, ее нужно либо fine-tune’ить (рискуя лоботомией и забыванием), либо использовать RAG (Retrieval-Augmented Generation) — костыль, который просто вставляет куски из Википедии прямо в текст вопроса пользователя. RAG — это не обучение, это как давать студенту шпаргалку на экзамене. Студент не выучил материал, он просто прочитал его с бумажки.
Настоящее, автономное обучение на лету (Continual Learning или Lifelong Learning) недостижимо, пока градиентный спуск безжалостно топчет старые локальные минимумы в угоду новым. И пока мы не поймем, как заставить матрицы весов вести себя подобно синапсам и дендритам живого мозга — с их нейропластичностью, долгосрочным потенцированием (LTP) и фазами консолидации во время сна — ИИ так и останется хрупкой, неспособной к истинному жизненному опыту железякой.
В итоге мы имеем такую картину: огромные дата-центры, жрущие мегаватты электричества и выпивающие реки воды на охлаждение, неделями крутят матрицы размером в петабайты, чтобы подогнать веса. А если нужно доучить модель на 1 новый факт — мы либо молимся EWC, либо прогоняем весь этот кошмар заново. Каменный век кибернетики. Но зато можно генерировать анимешных девочек по текстовому запросу, что, безусловно, является абсолютным вином и оправдывает все затраченные усилия.
