Хабр, привет! Меня зовут Егор Черепанов. Я аспирант Центра когнитивного моделирования МФТИ и младший научный сотрудник команды «Воплощенные агенты» лаборатории когнитивных систем искусственного интеллекта AIRI. Я занимаюсь памятью у роботов и RL‑агентов, и сегодня хочу рассказать об одной из наших работ — архитектуре ELMUR, которую мы представляли в апреле на ICLR 2026.
Память у современного робота сегодня — это почти всегда контекст трансформера Vision‑Language‑Action модели, поскольку последние уже прочно закрепились как стандарт в этой области. Проблема в том, что механизм внимания имеет квадратичную сложность по длине последовательности, а значит долгосрочная память для робота будет обходиться слишком дорого, если пытаться наивно увеличивать размер контекста.
Новая архитектура призвана решить эту проблему. О том, что у нас получилось, читайте в статье ниже.
Ещё совсем недавно тема памяти у роботов выглядела довольно нишевой. Часто приходилось отдельно объяснять, в чем вообще состоит проблема: почему роботу недостаточно просто смотреть на текущую картинку с камеры, почему нельзя решить всё увеличением контекста и зачем для управления роботом нужна отдельная архитектура памяти. Сейчас интерес к этой теме быстро растет, но для начала я всё равно зайду немного издалека и коротко расскажу, как сегодня обычно обучают роботов. Так будет проще понять, где именно у современных подходов начинаются проблемы, и зачем понадобился ELMUR.
Имитационное обучение и Vision Language Action модели
Для начала разберемся, как сегодня обычно устроены современные модели управления роботами. За последние годы трансформеры стали основной архитектурой для работы с текстом, изображениями и мультимодальными данными. Они хорошо масштабируются при обучении на больших датасетах и способны переносить выученные представления на новые объекты, сцены, формулировки команд и даже смежные задачи. Поэтому было естественно попробовать использовать их не только в языковых и визуальных моделях, но и в робототехнике.
В робототехническом случае такая модель должна решить чуть более сложную задачу: не просто описать изображение или ответить на текстовый запрос, а связать визуальное наблюдение, языковую команду и конкретное действие робота. Именно поэтому в последние годы стали активно развиваться Vision‑Language‑Action модели или VLA‑модели. Дальше речь пойдет именно о них — моделях, которые управляют роботом на основе изображений, языковой инструкции и текущего состояния самого робота.
В грубом приближении VLA‑модель устроена так. Сначала берется предобученная Vision‑Language Model (VLM), которая до этого обучалась на больших наборах текстов и изображений из интернета. Затем её дополнительно обучают уже на робототехнических данных — экспертных демонстрациях, где для каждого шага записано наблюдение робота, языковая инструкция и действие, которое выполнил эксперт. Экспертом здесь может быть человек‑телеоператор, вручную управляющий роботом, стратегия на скриптах или другая система, способная показать роботу правильное поведение. То есть вместо предсказания следующего текстового токена модель начинает решать другую задачу: по текущему наблюдению и команде предсказывать следующее действие робота.
Под действием здесь может пониматься, например, требуемое смещение рабочего органа робота, команда для схвата или целевые положения, скорости либо усилия в суставах манипулятора. На вход модель обычно получает изображения с нескольких камер: скажем, с внешней камеры рядом с роботом и с камеры на схвате. К этому добавляется вектор проприоцепции — информация о текущем состоянии самого робота: положениях и скоростях суставов, положении рабочего органа, состоянии схвата, а иногда также о силах, моментах или тактильных сигналах. Дополнительно модель получает языковую инструкцию вроде «положи яблоко на тарелку».
Идея VLA‑моделей в том, что знания о мире, полученные во время предобучения на больших текстово‑визуальных данных, могут быть полезны и после дообучения на робототехнических демонстрациях. Модель уже «знает», как выглядят яблоки, тарелки, коробки, кружки, цвета, материалы и многие другие объекты. Поэтому после дообучения она может лучше обобщаться на новые предметы, текстуры, сцены и формулировки команд, даже если конкретно таких примеров не было в робототехническом датасете.
На практике это действительно работает неплохо. Многие задачи формата pick‑and‑place, то есть «взять объект и положить его в нужное место», современные VLA‑модели уже решают очень уверенно. Если объект виден, инструкция понятна, а правильное действие можно выбрать по текущей картинке, такие модели часто справляются впечатляюще хорошо.
Например, в прошлом году на Conference on Robot Learning (CoRL 2025), одной из ведущих конференций по робототехнике, исследователи из Gemini Robotics показывали стенд с двуруким манипулятором ALOHA. Пользователь мог дать роботу голосовую команду через микрофон, а робот выполнял разные манипуляции с объектами на столе. Задачи уровня «положи красный кубик в синюю коробку» или «поставь синий кубик слева от оранжевой коробки» он решал очень уверенно.
Более того, участники конференции попробовали усложнить ситуацию: кто‑то положил на стол мягкую игрушку, которая явно была объектом вне обучающего распределения, то есть с большой вероятностью не встречалась роботу во время обучения. После этого робота попросили выполнить несколько команд уже с этим новым объектом — и он справился. Именно такие демонстрации хорошо показывают, почему вокруг VLA‑моделей сейчас столько интереса: они уже умеют не просто воспроизводить заученные движения, а в некоторой степени переносить знания на новые объекты и сцены.
Но у этого успеха есть важное ограничение. Почти все такие примеры хорошо работают тогда, когда вся нужная информация доступна прямо сейчас: объект виден, цель видна, инструкция дана, и робот должен немедленно выбрать действие. Как только для правильного поведения нужно вспомнить то, что происходило раньше, начинаются проблемы. И именно здесь возникает вопрос памяти.
А где начинаются проблемы у VLA?
У такого подхода есть важное ограничение. Большинство современных VLA‑моделей хорошо работают в задачах, где правильное действие можно выбрать по текущему наблюдению: робот видит объект, видит цель, понимает инструкцию и сразу действует. Формально это похоже на предположение о марковости среды: вся информация, необходимая для выбора оптимального действия, уже содержится в текущем наблюдении. В случае робота это обычно означает, что достаточно текущих изображений с камер, проприоцепции и языковой команды.
Но многие реальные задачи устроены иначе: текущее наблюдение показывает только часть состояния мира. Какая‑то важная информация могла быть видна раньше, но сейчас уже скрыта: объект закрыла рука, цель была названа в начале эпизода, нужный предмет лежит в ящике, который сейчас закрыт, или робот уже выполнил часть повторяющегося действия. Такая ситуация называется частичной наблюдаемостью: агент видит не полное состояние задачи, а только неполное наблюдение, и поэтому для правильного действия ему нужно использовать память.
В реальном мире это очень сильное ограничение для реактивных моделей. Многие задачи, которые для человека выглядят простыми и бытовыми, на самом деле требуют удерживать информацию из прошлого. Представьте робота, который готовит суп. На первый взгляд, ничего экзотического: взять продукты, добавить ингредиенты, перемешать, посолить. Но внутри такой задачи сразу возникает множество ситуаций, где текущее изображение не содержит всей нужной информации.
Например, чтобы посолить суп ровно три раза, роботу нужно помнить, сколько порций соли он уже добавил. После добавления соль растворяется, и по текущему изображению супа обычно нельзя надежно восстановить, было ли действие выполнено один, два или три раза. Похожая проблема возникает и с перемешиванием: по одному текущему кадру не всегда понятно, начал ли робот мешать только что или уже некоторое время выполняет это действие. Если модель не хранит историю, она может преждевременно остановиться или, наоборот, продолжать выполнять уже завершенный шаг.
Еще пример: робот достает специи из шкафа. Чтобы понять, открывает он дверцу или закрывает, ему нужно помнить ее предыдущее положение. А чтобы вообще найти нужные специи, нужно помнить, в каком шкафу они лежат, если эта информация была получена раньше и сейчас не видна на камере.
Таких примеров очень много. Роботу нужно помнить, какие ящики он уже проверил, какие объекты уже переложил, какую цель пользователь назвал в начале задачи и сколько раз уже было выполнено повторяющееся действие. Ему также может понадобиться помнить положение предмета, который раньше был виден, а потом оказался закрыт рукой, дверцей шкафа или другим объектом. Для длинных бытовых задач это обычная ситуация: часть важной информации была доступна раньше, но в текущем кадре ее уже нет.
Именно здесь у VLA‑моделей, работающих только по текущему наблюдению, начинаются проблемы. Если модель принимает решение только по текущему кадру, текущей проприоцепции и текущей инструкции, то информация из прошлого для неё фактически недоступна. Поэтому в задачах с частичной наблюдаемостью нужен способ использовать историю: например, сохранять важные сведения из прошлых наблюдений в отдельном механизме памяти и затем обращаться к ним при выборе действия.
Почему нельзя положиться только на контекст трансформера?
Итак, многие VLA‑модели для управления роботами принимают решение по текущему наблюдению: изображениям с камер, проприоцепции и языковой инструкции. В такой постановке у модели нет прямого доступа к тому, что происходило раньше: прошлые кадры, прошлые действия и ранее полученная информация просто не попадают на вход. Но тут возникает естественный вопрос: если VLA‑модели основаны на VLM, а VLM — это трансформеры, то почему бы просто не добавить в контекст несколько предыдущих кадров? Тогда модель увидит не только текущий момент, но и часть истории, а значит, у неё появится простейшая форма памяти.
На первый взгляд, это действительно самое простое решение. Вход VLA‑модели — это мультимодальная последовательность: изображения, состояние робота, текстовая команда и специальные токены. Кажется, что можно просто расширить эту последовательность и передать туда наблюдения не только с текущего шага, но и с нескольких предыдущих. Однако на практике это быстро упирается в вычислительные ограничения.
Проблема в том, что изображения для трансформера — это не один токен. Обычно они сначала проходят через Vision Transformer, который разбивает картинку на небольшие непересекающиеся фрагменты — патчи. Например, изображение размером 256×256 пикселей при размере патча 16×16 превращается в 256 визуальных токенов. Если у робота три камеры, то только изображения уже дают 768 эмбеддингов на один временной шаг. К этому добавляются токены языковой инструкции, проприоцепция и разные специальные токены. В итоге один шаг управления легко может занимать около тысячи токенов контекста.
Теперь представим, что мы хотим добавить хотя бы 10 предыдущих шагов. Это уже порядка 10 тысяч токенов. А если задача длится сотни или тысячи шагов, то наивное хранение всей истории в контексте становится практически невозможным. Главная причина — механизм внимания в классическом трансформере имеет квадратичную сложность по длине последовательности. Чем длиннее контекст, тем быстрее растут требования к видеопамяти и времени вычислений.
Для робототехники это особенно критично. VLA‑модель обычно должна работать с низкой задержкой: вычисления выполняются либо прямо на борту робота, либо на ближайшей рабочей станции, а новое действие нужно выдавать достаточно быстро, чтобы робот мог управляться в реальном времени. Он не может долго «думать» перед каждым движением, особенно если речь идет о непрерывном управлении манипулятором. Поэтому мы не можем просто бесконечно расширять контекст и надеяться, что вся история туда поместится. Даже несколько дополнительных временных шагов могут заметно увеличить расход видеопамяти и время вычисления одного действия, а длинные задачи — тем более.
Отсюда возникает более интересная задача: как дать роботу память, но не превращать её в гигантское контекстное окно? Иными словами, хочется, чтобы модель могла сохранять важную информацию из прошлого в компактном виде, переносить её между шагами и использовать при выборе действия, но при этом не пересчитывать внимание по всей накопленной истории на каждом шаге.
Именно эту задачу мы и пытаемся решить в нашей работе ELMUR: External Layer Memory with Update/Rewrite for Long‑Horizon RL Problems. Она предлагает добавить к трансформерной стратегии отдельный механизм внешней памяти, который живет между сегментами траектории и позволяет использовать прошлую информацию без наивного расширения контекста.
ELMUR
Сразу сделаю важное уточнение: ELMUR — это не новая VLA‑модель, обученная на большом количестве робототехнических демонстраций. Это архитектурный механизм памяти, который можно встроить в трансформерную стратегию управления роботом. В этой работе нас интересовал более базовый вопрос: как добавить память в трансформерного агента так, чтобы она не сводилась к простому увеличению контекста и продолжала работать на длинных горизонтах. Поэтому мы проверяли ELMUR в режиме single‑task обучения с нуля: агент обучался отдельно под каждую задачу, а эксперименты должны были показать, способен ли такой механизм памяти в принципе сохранять и использовать информацию из прошлого.
Интуитивно ELMUR можно представить как трансформер, у которого помимо обычной последовательности входных токенов есть отдельный набор векторов памяти. Обычный трансформер работает примерно так: на вход поступают токены, они обмениваются информацией через self‑attention, затем проходят через feed‑forward слои, и в конце модель предсказывает действие. В ELMUR к этому добавляется внешняя память — набор эмбеддингов, которые сохраняются после обработки текущего фрагмента траектории и передаются в следующий фрагмент. Благодаря этому модель получает не только токены текущего наблюдения, но и компактное представление того, что происходило раньше.
Главная идея здесь в том, что мы не пытаемся положить всю историю в контекст. Вместо этого длинная траектория разбивается на короткие сегменты. Каждый сегмент трансформер обрабатывает как обычно, но после обработки обновляет внешнюю память. Затем следующий сегмент получает не всю предыдущую историю, а только компактное состояние памяти. В этом смысле ELMUR превращает трансформер в что‑то похожее на рекуррентную модель, но с более структурированной и управляемой памятью.
Здесь может возникнуть вопрос: почему для памяти не использовать стандартные рекуррентные модели, например LSTM или GRU? Такой вариант действительно возможен: можно добавить к модели скрытое состояние и передавать его между шагами. Но у классических RNN вся информация о прошлом обычно хранится в одном компактном векторе. Это вычислительно удобно, однако для длинных задач такое представление становится узким местом: разные сведения о прошлом конкурируют за один и тот же скрытый вектор, а модели нужно научиться не только записывать важную информацию, но и сохранять её достаточно долго.
У трансформеров проблема устроена иначе. Внутри контекстного окна они хорошо работают с последовательностью токенов и могут гибко связывать разные элементы входа, но информация за пределами этого окна напрямую недоступна. ELMUR пытается совместить эти две идеи: оставить трансформерную обработку коротких фрагментов траектории, но добавить внешнюю память, которая передается от одного фрагмента к следующему рекуррентно. Это не снимает задачу управления памятью полностью, но даёт модели более явную структуру для хранения нескольких независимых сведений о прошлом.
Как устроена память в ELMUR?
В ELMUR память добавляется на каждый слой трансформера: у каждого слоя есть свой набор векторов памяти. Отдельный вектор в таком наборе можно понимать как слот памяти — небольшую ячейку, в которую модель может записывать информацию о прошлом и из которой потом может её считывать. Если у слоя есть, например, 16 таких векторов, то можно сказать, что у него есть 16 слотов памяти.
Это важная деталь. Можно было бы сделать одну общую память для всей модели, но тогда разные уровни представлений конкурировали бы за одни и те же слоты. Ранним слоям может быть полезно хранить более низкоуровневые визуальные признаки, средним — информацию о состоянии объектов, а поздним — более абстрактные признаки, связанные уже с самой задачей и выбором действия. Поэтому в ELMUR у каждого слоя есть собственная внешняя память.
Внутри слоя появляются две связанные части:
Первая — это обычная token track. Она обрабатывает текущий сегмент: изображения, состояние робота, действие или другую информацию, в зависимости от конкретной постановки. Токены внутри сегмента общаются через self‑attention.
Вторая — это memory track. Это набор слотов памяти, то есть векторов, которые сохраняются между сегментами. Они не являются токенами текущего наблюдения, но могут быть использованы токенами как источник информации о прошлом.
Связь между этими двумя треками происходит через два блока независимых cross‑attention:
Первый блок называется mem2tok и отвечает за чтение из памяти. Текущие токены делают запросы к memory slots и вытаскивают оттуда информацию, которая может быть полезна для текущего действия. Например, если в начале эпизода робот увидел, что нужный кубик был красным, а потом кубик исчез из поля зрения, то позже модель может извлечь это из памяти.
Второй блок называется tok2mem и отвечает за запись в память. После того как модель обработала текущий сегмент, скрытые состояния токенов используются для обновления слотов памяти. То есть модель не просто пассивно читает старую информацию, а постоянно решает, как изменить свое внутреннее состояние на основании нового опыта.
Как ELMUR решает, какую память обновлять?
Хорошо, допустим, у нас есть память. Но тут сразу возникает следующий вопрос: если эпизод длится очень долго, что именно мы должны хранить? Хранить всё невозможно — мы снова придем к проблеме длинного контекста. Поэтому память должна быть ограниченной. Но если память ограниченная, то рано или поздно придется что‑то перезаписывать. И здесь начинается самая неприятная часть: если перезаписать важную информацию, агент не решит задачу с длинными зависимостями; если ничего не перезаписывать, память быстро станет устаревшей.
В ELMUR для этого используется достаточно простая и понятная стратегия — LRU, Least Recently Used. Это классическая идея из системного программирования: если нужно освободить место в памяти, перезаписывай тот слот, который дольше всего не обновлялся, то есть наиболее старый.
На старте слоты памяти инициализируются случайными векторами и помечаются как пустые. Пока есть пустые слоты, новая информация записывается туда полностью. Когда все слоты уже заняты, ELMUR выбирает слот, который обновлялся раньше всех, и не просто заменяет его целиком, а смешивает старую и новую информацию:
Параметр 
отвечает за баланс между пластичностью и стабильностью. Если большой, память быстро адаптируется к новой информации, но быстрее забывает старую. Если маленький, память более стабильна, но медленнее обновляется.
В статье мы также формально анализируем такое правило обновления. Получается довольно ожидаемая, но полезная картина: вклад старой информации затухает экспоненциально с числом перезаписей. При этом эффективный горизонт памяти растет линейно с числом слотов памяти и длиной сегмента. Проще говоря: чем больше слотов и чем длиннее сегменты, тем дольше модель может хранить информацию, но при этом ей не нужно каждый раз обрабатывать всю историю как одну огромную последовательность.
А как модель понимает, когда была записана информация?
Есть ещё одна тонкость. Когда мы записываем информацию в память, нам важно понимать не только что там лежит, но и когда это было записано. Представьте задачу, где робот сначала видит красный кубик, потом синий, потом зеленый, а через некоторое время должен взять именно первый. Если просто хранить набор векторов, то модель может потерять временную структуру: какой слот относится к какому моменту, что было раньше, что позже, насколько давно это произошло.
Для этого в ELMUR используется relative bias между текущими токенами и слотами памяти. У каждого слота есть якорь (anchor) — время, когда он был обновлен последний раз. Когда токены читают из памяти, механизм внимания получает дополнительный сдвиг (bias), зависящий от относительного расстояния между текущим временным шагом и якорем памяти. При записи используется похожая идея, только направление смещения меняется. Это позволяет модели не только хранить признаки, но и ориентироваться во времени. Не в смысле абсолютного номера шага в эпизоде, а в смысле относительной давности информации.
На чем мы это проверяли?
Чтобы проверить ELMUR, мы использовали три типа задач:
Первая группа — синтетические T‑Maze задачи. Это классический тест на память: агент в начале видит подсказку, затем долго идет по коридору, а в конце должен выбрать правильное направление. Сама подсказка к моменту принятия решения уже давно недоступна — её агент может наблюдать только в начале эпизода. Если памяти нет, задача становится нерешаемой.
Вторая группа — POPGym, набор частично наблюдаемых puzzle/control задач. Там есть разные типы задач с памятью: где‑то нужно помнить первый символ последовательности, где‑то повторять предыдущий, где‑то восстанавливать скрытое состояние классической среды с задачей управления по неполным наблюдениям.
Третья группа — MIKASA‑Robo, робототехнический бенчмарк для задач с памятью, который мы также представляли на ICLR 2026. В этом посте я буду использовать его только как один из наборов задач для проверки ELMUR, а подробнее про сам бенчмарк, его устройство и типы задач расскажу отдельно в следующем посте. В MIKASA‑Robo агент управляет манипулятором с 7 степенями свободы и двухпальцевым захватом, получает RGB‑наблюдения с двух камер — внешней камеры и камеры на захвате, — а действия задаются в непрерывном пространстве.
В MIKASA‑Robo есть, например, семейство задач RememberColor. Робот видит на столе кубик определенного цвета. Далее этот кубик на время исчезает, после чего на стол высыпаются кубики разных цветов, и агент должен выбрать именно тот кубик, который он видел в начале эпизода. Есть также интересная задача TakeItBack: сначала нужно перенести объект в одно место, а затем, после изменения цели, вернуть его обратно (нужно запомнить начальную позицию объекта на столе). Обе задачи требуют не просто реагировать на текущую картинку, а удерживать внутреннее состояние эпизода. В бенчмарке есть ещё много интересных задач, о которых можно более подробно прочитать в соответствующей статье.
Что получилось?
На T‑Maze ELMUR дал самую наглядную проверку механизма памяти. Модель обучалась с коротким контекстом — всего 10 шагов, — но после обучения успешно проходила T‑Maze с коридорами длиной до миллиона шагов. Это означает, что агент видел подсказку в начале задачи, долго двигался по коридору, а затем всё равно выбирал правильное направление в конце. Иными словами, информация о подсказке сохранялась на горизонте, который примерно в 100 000 раз превышал размер контекстного окна. Наивный трансформер в такой ситуации уже давно потерял бы начало задачи просто потому, что оно не помещается в контекст. Конечно, T‑Maze — это искусственный тест памяти, крайне далекий от реальных робототехнических задач. Он нужен не для демонстрации прикладного сценария, а для проверки принципиального свойства: может ли модель переносить информацию через очень длинную последовательность.
Еще более интересно, что модель хорошо обобщалась на другие длины последовательности. Мы обучали ELMUR на одних длинах коридора T‑Maze, а затем проверяли на более коротких и гораздо более длинных коридорах. В результате модель сохраняла высокую успешность во всех train/test‑комбинациях этого эксперимента. Это важная контрольная проверка: она показывает, что модель действительно научилась переносить информацию между сегментами траектории, а не просто запомнила фиксированную длину коридора.
На MIKASA‑Robo картина тоже получилась хорошей. В RememberColor3-v0 ELMUR получил success rate 0.89, тогда как ближайший сильный baseline RATE получил 0.65. В TakeItBack‑v0 ELMUR получил 0.78 против 0.42 у следующего лучшего baseline. На более сложных RememberColor5 и RememberColor9 абсолютные числа ниже, что ожидаемо: число отвлекающих объектов растет и визуальная задача усложняется, что делает обучение тяжелее. Но даже там ELMUR, пусть и не решает задачу, остается лучше остальных методов.
На POPGym (популярном бенчмарке для исследования памяти агентов) ELMUR также оказался лучшим по агрегированным метрикам: 10.4 против 9.5 у RATE и 5.8 у Decision Transformer. Самый заметный прирост был именно на puzzle‑задачах, где память является ключевым фактором. При этом на реактивных задачах управления, где память почти не нужна (по сути, помнить нужно только текущее и предыдущее состояния), ELMUR не проседал. Это полезное свойство: память не должна помогать только на специально подобранных задачах, но и не должна мешать там, где достаточно лишь нескольких наблюдений.
Чего ELMUR пока не решает?
Теперь важно зафиксировать границы результата. ELMUR — это не финальный ответ на вопрос памяти у роботов, но важный исследовательский шаг: он показывает, что внешний механизм памяти можно встроить в трансформерного агента, что такая память устойчиво обучается и помогает в задачах с длинными зависимостями.
ELMUR пока не является полноценной VLA‑моделью с памятью (но мы работаем над этим!). Мы не брали большую предобученную робототехническую модель и не дообучали её с ELMUR‑памятью на крупном наборе демонстраций. Вместо этого мы работали в режиме обучения с нуля под каждую задачу отдельно, чтобы изолированно исследовать свойства самого механизма памяти. У такой постановки есть практическое преимущество: эксперименты становятся быстрее и проще для анализа. Дообучение современных VLA‑моделей — тяжелый процесс, который легко может занимать дни и недели. В нашем случае один запуск занимал часы, поэтому можно было проводить много сравнений и точнее понимать, какой компонент архитектуры дал прирост.
У LRU есть и ограничение: это простое правило обновления памяти, а не полноценная модель того, какая информация действительно важна для задачи. Люди, например, не забывают информацию строго по принципу «давно не обновлялось — значит можно стереть». Мы можем долго помнить старый, но важный сигнал и быстро забыть свежую, но бесполезную деталь. Поэтому следующий вопрос — как сделать управление памятью более осмысленным: чтобы модель перезаписывала не просто самые старые слоты, а те, которые с меньшей вероятностью понадобятся для дальнейшего решения задачи.
При этом простота LRU — не только ограничение, но и преимущество. Такой механизм легко обучать, он почти не увеличивает вычислительный бюджет и дает понятное правило обновления памяти. Для первого шага в сторону внешней памяти это важное свойство: сложный механизм записи и удаления может выглядеть привлекательнее, но оказаться менее устойчивым на практике.
Поэтому следующий этап для нас — обобщить разработанный механизм на предобученные VLA‑модели. Идея состоит в том, чтобы добавлять ELMUR‑память уже на этапе дообучения таких моделей под задачи с частичной наблюдаемостью: когда робот должен не просто реагировать на текущую картинку, а помнить, что он видел и делал раньше.
Заключение
История с памятью в робототехнике, как мне кажется, сейчас только начинается. Еще недавно многие работы по VLA, фактически, обходили эту проблему стороной: брали текущие изображения, текущую инструкцию, текущую проприоцепцию и предсказывали действие. Для коротких pick‑and‑place задач этого часто достаточно. Но если мы хотим перейти от «положи кубик в коробку» к длинным бытовым задачам, где робот должен действовать минуты или часы, такой постановки уже мало.
ELMUR показывает, что память можно добавлять в трансформерного агента не через бесконечное расширение контекста, а через компактное внешнее состояние, передаваемое между сегментами последовательности. У каждого слоя появляется своя память, токены могут читать из неё и записывать в неё, LRU‑механизм решает, что обновлять, а relative bias помогает учитывать, насколько давно была записана информация. В результате модель сохраняет информацию на горизонтах, сильно превосходящих её контекстное окно, и лучше справляется с задачами с частичной наблюдаемостью.
Для робототехники это важно не только в искусственных тестах вроде T‑Maze. В длинных бытовых задачах роботу постоянно нужно помнить то, чего уже нет в текущем кадре: какую цель пользователь назвал в начале, какие предметы он уже проверил, какие действия выполнил и что нужно учитывать на следующем шаге. Без такой памяти робот может уверенно выполнять простые реактивные действия, но теряться там, где задача требует опоры на прошлый опыт.
Иначе робот, конечно, сможет красиво взять красный кубик. Но суп он все равно пересолит.
P. S. Для улучшения качества некоторых изображений применялся нейросетевой upscale.