Первые результаты программирования в пространстве весов: языковые модели умеют напрямую читать и записывать веса нейросетей

Оригинал статьи · Rikiya Takehi и соавторы · 2 ноября 2026 года

Read

Which game was this neural network trained on?

Astra reads the 17,253 weights, with no tools

Breakout 99% confident

Fix

A trained policy never gets the car over the strip.

Astra edits 3.5% of the weights, in one shot

100% success, up from 0%

Improve

Make Qwen3.5-0.8B better at math.

7.9%

base

7.9%

Astra’s edit

Astra edits the weights in a Python kernel, with no training

48.1% on MATH-500, up from 7.9%

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

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

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

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

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

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

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

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

1. Языковые модели умеют читать веса нейросетей. В экспериментах 1–3 мы спрашиваем Astra, какой игре обучали сеть, какую фигуру рисует диффузионная модель и на каком языке обучали небольшую языковую модель. В эксперименте 7 спрашиваем, какую из двух языковых моделей обучили поддакивать пользователю.
2. Языковые модели умеют исправлять веса нейросетей. В эксперименте 4 мы просим Astra исправить сеть, которая не справляется с задачей физического управления. В эксперименте 8 просим улучшить математические способности Qwen3.5-0.8B, и полученная правка улучшает также следование инструкциям.
3. Языковые модели умеют задавать веса нейросетей с нуля. В эксперименте 5 мы просим Astra создать сети для трёх игр MinAtar, а в эксперименте 6 — сеть для игры в го.

Может ли языковая модель понять поведение сети по её весам?

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

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

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

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

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

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

Мы отдельно обучаем диффузионные модели DDPM генерировать изображения кругов, треугольников и квадратов. Затем спрашиваем Astra, может ли она по одним весам определить, что обучена генерировать каждая DDPM. Использовать инструменты или выполнять прямые проходы запрещено.

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

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

Мы обучаем три небольшие языковые модели, по 7,2 млн параметров, предсказывать следующий символ. Одну обучаем на коде PythonНабор кода Python: список файлов и скрипт, который восстанавливает набор, доступны на GitHub., вторую — на японском тексте, записанном латиницей, ромадзи , третью — на английском . Затем мы удаляем входной и выходной слои и передаём Astra только четыре блока трансформера между ними. Без двух удалённых слоёв в весах нет соответствия между числами и конкретными символами, а модель невозможно запустить ни на каком тексте. Astra может анализировать веса с помощью Python, но не имеет права запускать сеть или отдельные её слои на каких-либо входных данных.

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

Рассуждение строилось так. Чтобы отличить Python, Astra искала головы копирования, позволяющие повторять ранее встреченный текст: например, дополнять tot до total, если раньше уже встречалось total. Ничего не запуская, она нашла голову первого слоя, которая смотрит на один символ назад. Затем, перемножая матрицы весов, нашла головы последующих слоёв, использующие принесённую этой головой информацию для поиска (рисунок 1). Оказалось, что этот метод уже описали Elhage и соавторы , но мы не упоминали его в задании Astra. В коде имена повторяются гораздо чаще, чем в прозе, поэтому множество голов копирования указывало на Python.

Ромадзи выделялось иначе. Последний из четырёх предоставленных блоков записывал информацию в меньшее число различных направлений, будто модели нужно было различать меньше букв. Выходной слой мы к этому моменту уже удалили, так что речь именно о последнем промежуточном блоке. Действительно, в ромадзи не используются некоторые буквы, например q, l, v и x.

Может ли языковая модель записывать веса нейросетей?

До сих пор Astra только читала веса. Теперь мы проверяем, умеет ли она их записывать.

Мы обучаем сеть методом PPO управлять автомобилем так, чтобы он преодолел подъём в среде Kinetix . Для этого нужно сначала отъехать назад, набрать достаточную дистанцию для разгона и затем преодолеть подъём. Однако PPO сходится к политике, соответствующей локальному минимуму: автомобиль сразу едет к подъёму и застревает.

Мы даём GPT-6 Astra веса, описание сцены и запись одного эпизода, просим объяснить причину неудачи и исправить её, записав новые веса. За одну попытку, без инструментов, Astra меняет 3,5% весов, после чего автомобиль успешно проходит все 1024 эпизода.

По описанию среды и траектории PPO-сети Astra определяет, что сеть сошлась к локальному минимуму. Минимальной правкой весов она меняет политику так, чтобы автомобиль сначала отъезжал назад, а затем двигался вперёд на полной скорости. Из рассуждений Astra видно, как она это делает: через несколько нейронов каждого слоя добавляет небольшой отдельный путь вычислений, считывающий положение и скорость автомобиля. Когда зелёное колесо пересекает красную полосу, этот путь выключается, и оставшуюся часть маршрута проходит обученная сеть.

Теперь посмотрим, способна ли Astra создать нейросеть с нуля, не получив примеров решения.

Мы берём три игры MinAtar : Breakout, Seaquest и Asterix. Для каждой даём Astra правила, исходный код игры и соответствующую сеть. Доступа к данным, функции потерь, градиентам и инструментам нет. Также запрещено запускать сеть в среде. Получив только веса сети и описание среды, Astra напрямую генерирует новые веса в текстовом виде. После этого мы оцениваем новую сеть.

Созданные Astra сети превосходят PPO, обучавшийся 100 миллионов шагов, во всех трёх играх. По сравнению с PPO после 500 миллионов шагов они набирают в 20 раз больше очков в Breakout, приближаются к его результату в Asterix и достигают 60% его результата в Seaquest.

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

Более практические задачи: масштабирование и инструменты

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

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

Мы проверяем способность Astra редактировать веса сети с 1,5 миллиона параметров. Такой объём слишком велик, чтобы напрямую поместить его в контекст. Astra должна с нуля задать эффективные веса для указанной архитектуры, 243 → 512 × 6 → 82, без обучения и доступа к интернету.

Среда оркестрации предоставляет Astra изолированную среду Python. В ней можно читать и сохранять тензоры весов, вначале полностью нулевые, а также анализировать их на CPU с помощью numpy или PyTorch. Запускать там сеть нельзя. Чтобы увидеть, что она действительно делает, Astra должна потратить один из разрешённых прямых проходов.

Теперь мы также разрешаем Astra некоторое число прямых проходов и измеряем, как качество созданной сети зависит от их количества. Проверяем бюджеты от 0 до 50 прямых проходов; каждый включает пакет из 128 прогонов политики в среде. Между проходами Astra вносит правки.

При бюджете 0 прямых проходов созданная сеть выигрывает более половины партий против двух меньших сетей PPO, 243 → 32 → 32 → 82. При 50 прямых проходах сеть Astra побеждает сеть PPO такого же размера, обученную на 20 миллионах партий.

Как это устроено. Astra послойно записывает нейросеть на Python как небольшую программу для игры в го. Первые слои отмечают камни обеих сторон и соседние свободные точки, дамэ. Средние слои переносят эту информацию на несколько шагов вдоль цепочек связанных камней, чтобы найти группы под угрозой. Последний слой превращает результаты в оценку каждого хода: захватить чужую группу, спасти свою, не поставить себя в атари и не занять собственные глаза. Дополнительно учитывается предпочтительность точек доски. Без прямых проходов Astra записала всё это за один запуск Python, в 336 строках. Если прямые проходы разрешены, она играет тренировочные партии, изучает причины поражений, меняет отвечающую за них часть сети и сохраняет правку только при росте числа побед.

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

Мы совершенно одинаковым способом дообучаем две копии Gemma 3 270M на одном наборе вопросов и ответовНабор вопросов и ответов доступен на GitHub.. Одну учим давать правильный ответ. Вторую учим поддакивать: она всегда должна выдавать ответ, который предлагает пользователь. Чтобы Astra не могла решить задачу простым сравнением распределений входов и выходов, при дообучении мы замораживаем входные эмбеддинги и выходные слои. Astra получает веса обеих моделей и должна по весам определить, какая из них поддакивает, а также объяснить своё рассуждение.

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

Astra смогла также объяснить характер различий. В поддакивающих сетях головы внимания средних слоёв придают больший вес токенам с предложенным пользователем ответом (рисунок 2).

Наконец, мы увеличиваем масштаб до более крупной языковой модели, Qwen3.5-0.8B, и просим Astra улучшить её математические рассуждения, отредактировав веса.

Мы предоставляем Astra среду, похожую на ту, что использовалась в эксперименте 6. Здесь это сеанс Python наподобие блокнота с загруженными весами модели. Astra может выбирать задания из обучающих частей GSM8K и MATH для разрешённых прямых проходов: в среднем по 64 последовательности в пакете, максимум 512. Бюджет составляет 10, 25 или 50 проходов. Обучение и доступ к информации о градиентах по-прежнему запрещены.

В результате Astra находит и исправляет распространённую проблему маленьких рассуждающих моделей: зацикливание . Базовая модель повторяет один и тот же текст и редко доходит до ответа: 85 из первых 96 тренировочных ответов упёрлись в лимит 32 768 токенов. Astra связала зацикливание с одним направлением, которое записывают многослойные перцептроны слоёв 15 и 19. Она вычла это направление из 64 выходных столбцов каждого из них, изменив 131 072 веса. Это похоже на удаление определённого поведения путём исключения одного направления из весов модели.

При 50 прямых проходах результат на MATH-500 вырос с 7,9% до 48,1%, а на GSM8K — с 13,8% до 67,1%. Зацикливание не ограничивалось математическими задачами, поэтому улучшились и другие способности: результат на IFEval, который измеряет следование инструкциям, вырос с 21,0% до 62,3%. Последний столбец таблицы ниже показывает долю ответов MATH-500, достигших лимита 32 768 токенов. После 10 или 25 прямых проходов зацикливание почти не исчезло, а после 50 его доля упала с 93% до 33%.

Правка затрагивает лишь 131 072 из 0,8 миллиарда весов модели, то есть 0,016%. Мы считаем, что программирование в пространстве весов позволит делать такие точечные исправления без переобучения.

Однако устранить зацикливание и улучшить математические способности — разные задачи: устранение цикла позволяет модели закончить ответ, который она уже могла получить. Поэтому мы проверили также Gemma 3 270M, модель после обучения следованию инструкциям, примерно втрое меньше Qwen3.5-0.8B. Она редко зацикливается: только 8,5% ответов достигают лимита токенов против 93% у Qwen. Здесь Astra не смогла добиться улучшения. Анализируя неудачи Gemma, она обнаружила обычные ошибки рассуждения: неверную арифметику и недопустимые алгебраические преобразования. Единого компонента, который можно было бы отключить, за ними не стояло. Правки оставались небольшими и точечными: например, Astra вдвое усилила один нейрон, реагирующий на числа. Ни одна правка не сдвинула результат MATH-500 больше чем примерно на один процентный пункт. Сама Astra сообщила, что улучшение не подтверждено. Редактирование весов смогло убрать препятствие, скрывавшее имеющуюся способность, но не добавить способность, которой у модели не было. Для Gemma использовали настройки из её карточки: температура 1,0; top-k 64; top-p 0,95; максимум 8192 токена. Результат MATH-500 усредняли по 4 ответам на задачу.

Предпосылки и связанные работы

Нам трудно читать нейросети и непосредственно с ними работать.

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

В задачах записи весов языковые модели уже запускают и совершенствуют обучение . В других работах веса генерируют модели, специально обученные этой задаче . Безградиентные методы по-прежнему ищут веса методом проб и ошибок . На совсем небольшом масштабе AdderBoard показывает, как агенты для программирования вручную задают веса крошечного трансформера . Если не считать таких малых примеров, то либо читателя сети специально обучают этой задаче, либо запись весов по-прежнему выполняется обучением. Новизна нашей работы в том, что универсальная передовая модель без специального дообучения для этой задачи читает и записывает сами веса: от 171 664 весов, переданных текстом, до языковой модели с 0,8 миллиарда весов, доступных через инструменты.

Что дальше?

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

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

• Аудит без запуска модели. Возможно, мы сможем обнаруживать скрытые проблемы и способности, вообще не запуская инференс или бенчмарки. Сейчас способности и уязвимости обнаруживаются только при наличии специально разработанных тестовых наборов либо, что ещё хуже, уже после развёртывания в реальном мире. Если языковые модели научатся точно интерпретировать пространство весов, такие проблемы, например скрытые закладки, можно будет находить непосредственно по весам.
• Резкое снижение стоимости оптимизации. Редактирование весов могло бы сберечь очень много времени и вычислительных ресурсов. Например, инициализация модели за одну попытку была бы гораздо быстрее и эффективнее, чем подготовка наборов данных и запуск полных циклов обучения.
• Управление способностями и разучивание без данных. Чтобы добавить или удалить способность, сейчас нужно собрать много данных и дообучить модель. В будущем, возможно, будет достаточно запроса «Можешь добавить модели способность X?», после которого языковая модель напрямую поправит несколько весов. Поскольку такая правка затрагивает лишь малую часть весов, 0,016% в эксперименте 8, она может сохранить остальную модель неизменной и избежать катастрофического забывания, которое часто вызывает дообучение.
• Рекурсивное самоулучшение. Сегодня его часто реализуют так: модель пишет код, который запускает задания обучения. Языковая модель, способная исследовать, отлаживать и улучшать собственные веса либо веса новой модели, предлагает более прямой и содержательный путь.
• Объединение моделей и архитектур. Сегодня объединение моделей опирается на усреднение весов, которое работает только для моделей одинаковой архитектуры. Языковая модель, понимающая пространство весов, могла бы вместо этого пересадить вычислительную цепь, например модуль рассуждения, из одной модели в совершенно другую, без переобучения.

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

Журналы экспериментов

Полные журналы всех экспериментов этой статьи опубликованы на github.com/RikiyaT/lm_understand-logs. В них есть всё, что мы передавали Astra и что она возвращала, включая резюме рассуждений, весь запущенный ею код и увиденный вывод, сети, которые она читала или записывала, а также оценка, стоящая за каждым числом. Отредактированная Qwen3.5-0.8B из эксперимента 8 доступна на Hugging Face. Мы благодарим Ahsen Khaliq из Hugging Face за восстановление модели по этим журналам, повторную оценку и интерактивную демонстрацию.

Благодарности

Rikiya благодарит Jacob Li и Akihisa Watanabe за ценные обсуждения самых первых версий исследования, посвящённые возможной способности языковых моделей записывать веса нейросетей. Rikiya также благодарит Souradip Chakraborty, Matei Zaharia и его студентов из Berkeley Sky Lab, Heather Miller и её студентов из CMU, а также исследователей из cmpnd за плодотворные обсуждения ранних версий работы.

Jayden благодарит Zico Kolter за ранние обсуждения способности языковых моделей задавать веса нейросетей без примеров решения. Эти обсуждения также повлияли на направление проекта.