Можно ли научить маленькую LLM учиться без роста весов? Продолжение: почему повторное обучение упёрлось в потолок

В прошлой статье были только опыты. Теперь давайте расскажу подробнее: это шаги к новой архитектуре — LANN-4 и что это такое?

Если коротко

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

Теперь раскрою карты. Эти опыты — не сами по себе. Это шаги к новой архитектуре, над которой я работаю; я зову её LANN-4 (если расшифровать — нейросеть, которая учится всю «жизнь», с небольшим неизменным «мозгом» и вынесенной наружу памятью). И сразу честно: самой этой архитектуры ещё нет — она не выбрана и не построена. Небольшие модели в опытах — это подопытные инструменты, а не LANN-4. Готовую новую модель я не показываю. Я показываю исследование на пути к ней — и то, что получилось и что НЕ получилось.

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

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

Что мы вообще пытаемся сделать и зачем

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

Чем мы при этом руководствуемся (это наши рабочие принципы, а не описание устройства):

• система помнит прошлое между задачами, а не начинает каждый раз с чистого листа;

• на каждую задачу тратится ровно столько сил, сколько она стоит, не больше;

• знания и опыт лежат в отдельной памяти снаружи, а не «вплавлены» в саму модель;

• она учится новому, не забывая старое;

• ответ, догадка и проверенный факт — это три разные вещи, и честное «я не знаю» лучше красивой выдумки;

• любое самоулучшение сначала проверяется в песочнице и внешним судьёй, модель не правит сама себя;

• всё, что касается безопасности и разрешений, вынесено наружу и не зависит от «послушности» модели.

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

Как мы это проверяли, человеческим языком

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

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

• «копим» — модель подучивают, и каждый следующий раунд наслаивается на предыдущий;

• «с нуля» — каждый раунд начинаем с чистой модели, без накопления;

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

Главное, что мы мерили: идёт ли доля решённых задач вверх от раунда к раунду.

Что получилось

Доля правильно решённых задач по раундам у режима «копим» выглядела так: примерно 53% → 59%, а дальше топтание на месте, 54–57%, без набора высоты.

То есть почти весь прирост дал первый раунд. Второй, третий и четвёртый не добавили ничего. Режим «с нуля» вёл себя так же, как «копим» — накопленная подкрутка не давала преимущества над «начни заново каждый раз». А режим «без обучения» даже чуть сползал вниз, как и положено шуму.

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

Что это значит, и, что важнее, чего это НЕ значит

Что значит: один раунд подучивания на проверенных решениях реально добавляет около пяти процентных пунктов, и этот прирост держится все четыре раунда, не рассыпаясь. Разовое улучшение — есть, оно настоящее.

Чего это НЕ значит (и мы специально не смешиваем эти вещи):

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

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

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

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

Развилка, которую не обойти

Прирост от первого раунда реальный. Но откуда он взялся? Есть два честных объяснения, и они ведут проект в разные стороны которые справедливо заметил один из пользователей в комментариях к первому посту:

1. модель и правда усвоила содержание правильных решений — то есть чему-то научилась;

2. модель просто поймала эффект самого факта подучивания на коде — приспособилась к формату, а не к сути.

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

Плацебо, в котором я прошу найти дыру

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

Правило решили заранее. Если обучение на правильном содержании даёт заметно больше, чем на пустышке — значит, система училась содержанию. Если примерно одинаково — значит, это была просто подстройка под формат, и слово «обучение» надо понимать иначе.

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

Три вопроса, ради которых весь пост:

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

2. Как закрыть дыру «внутри одного типа задач», не удваивая работу видеокарты?

3. Встречал ли кто-нибудь такую же картину — «рывок на первом раунде, дальше потолок» — когда одну и ту же небольшую модель подучивают много раз на одном наборе? Это у вас тоже так, или это особенность нашего протокола?

Дельная критика по существу здесь ценнее похвалы. За ней и пришёл.

Чего я в этой статье НЕ рассказываю, и почему честно

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

Про воспроизводимость

Как и в первой статье: все правила и наборы задач зафиксированы заранее с «отпечатками»; результаты пересчитаны независимо; отрицательные результаты и список собственных ошибок мы храним и не переписываем задним числом. Технический сбой — это не научный провал. Выросшая цифра — это ещё не доказанное обучение. А «я не знаю» — нормальный ответ.

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