3.5 Часть 3 · Foundation-модели для роботов

Octo и OpenVLA: открытые модели, которые можно дообучить у себя

В уроке 3.4 модель RT-2-X на 55 млрд параметров, обученная на смеси данных девяти роботов из Open X-Embodiment, обошла модели, обученные на данных одного робота. Но её весов нет в открытом доступе, и дообучить её на свою руку и свою камеру нельзя. В 2024 году вышли две открытые модели, обученные на тех же данных Open X-Embodiment. Octo — трансформер на 93 млн параметров, обученный на 800 тысячах эпизодов: к нему можно добавить новую камеру или новый способ управления, и за несколько часов на одной видеокарте он дообучается по сотне демонстраций. OpenVLA — языковая модель Llama 2 на 7 млрд параметров со зрительным энкодером, обученная на 970 тысячах эпизодов: на 29 задачах она выполнила на 16,5 процентного пункта больше попыток, чем RT-2-X. Её удаётся дообучить, меняя 1,4% параметров, а хранить в 4 битах на число почти без потерь. Разберём, как устроены обе модели и почему маленькая добавка к весам работает не хуже дообучения всех весов.

≈ 45 минут2 лаборатории, интерактив и квизмиссии с целью

ДООБУЧЕНИЕПеренеси маленькую предобученную модель на новую руку с другой камерой тремя способами и сравни их при 5 и при 40 записях

ГОЛОВА ДЕЙСТВИЙСпроси три модели, куда положить кубик, когда на столе две одинаковые миски, и посмотри, какая выбирает то одну, то другую

ТАБЛИЦЫНайди в результатах OpenVLA, где закрытая модель на 55 млрд параметров всё ещё сильнее открытой

Начать урок ↓

1 Задача

Лучшая модель есть, но дообучить её у себя нельзя

В уроке 3.4 модели RT-1-X и RT-2-X обучили на смеси данных девяти роботов из Open X-Embodiment, и RT-2-X на 55 млрд параметров справилась с задачами других роботов лучше моделей, обученных на данных одного робота. Теперь представь лабораторию со своей рукой: камера стоит иначе, свет другой, предметы другие, а записей с этой руки — несколько десятков. Готовая модель, обученная на чужих роботах, на такой установке ошибается, и её нужно дообучить (fine-tuning): продолжить обучение на своих записях, начиная с готовых весов, а не со случайных.

С RT-2-X этого сделать нельзя. Веса модели не опубликованы, к ней можно только отправлять запросы. Авторы OpenVLA, которые сравнивали свою модель с RT-2-X, прямо пишут, что дообучение RT-2-X через этот интерфейс не поддерживается. Открытая RT-1-X мала: 35 млн параметров, и в уроке 3.4 она не справлялась с большими доменами, а в RT-2 знание из интернета приходило именно от большой модели зрения и языка (VLM, урок 3.2).

Нужна модель, у которой открыты веса, код обучения и данные, которая обучена на той же смеси Open X-Embodiment и которую можно дообучить за часы на одной видеокарте, а не на кластере. В 2024 году вышли две такие модели с разными ответами на вопрос, с чего начинать. Octo (UC Berkeley, Stanford, CMU и Google DeepMind) — трансформер на 93 млн параметров, обученный с нуля на данных роботов. OpenVLA (Stanford, UC Berkeley, Toyota Research Institute и другие) — модель зрения и языка на 7 млрд параметров, которую, как RT-2, дообучили выдавать действия.

Роботы в Open X-Embodiment разные: у одних камера на запястье, у других только камера сбоку, одни получают команду словами, другие — картинкой цели, одни управляют захватом, другие суставами. Что нужно модели, чтобы её можно было перенести на любой из них?

2 Octo

Octo: входы и выходы добавляются токенами

RT-1-X получает одну картинку и команду и выдаёт 7 чисел. Если у новой руки есть камера на запястье, датчик силы или другие суставы, такую модель приходится перестраивать и заново обучать большие её части. В Octo всё, что модель получает и выдаёт, — это токены, и новый вход или выход добавляется новыми токенами.

У каждого вида входа свой токенизатор. Команду читает предобученная языковая модель t5-base на 111 млн параметров и отдаёт 16 токенов. Картинку пропускают через несколько свёрточных слоёв и режут на квадраты 16 × 16 пикселей: с камеры сбоку выходит 256 токенов, с камеры на запястье — 64. Вместо команды можно дать картинку цели — снимок того, как сцена должна выглядеть в конце; она превращается в токены так же. Основа Octo-Base — трансформер из 12 слоёв шириной 768, всего 93 млн параметров; есть и Octo-Small на 27 млн.

Внимание в основе ограничено масками: токены наблюдения видят токены задачи и наблюдения того же и прошлых шагов, но не будущих. Ещё в последовательность вставляют токены-считыватели (readout tokens) — обучаемые токены, которые читают все остальные, но которых не читает никто: на остальные токены они не влияют. Это как токен [CLS] в BERT, только по одному на каждый шаг. Их выход передают голове действий — небольшой сети поверх основы, которая превращает выход основы в числа действия. Поэтому, чтобы добавить датчик силы, достаточно добавить его токенизатор, а чтобы управлять новыми суставами — новую голову: веса основы при этом не меняются.

Голова Octo — диффузионная, как Diffusion Policy в уроке 1.5: маленькая сеть из трёх слоёв шириной 256 за 20 шагов денойзинга превращает случайный шум в пачку действий на несколько шагов управления вперёд. Основа выполняется один раз на каждое предсказание, все 20 шагов денойзинга идут только в голове, и это дёшево. Авторы сравнили три головы на Octo-Small: с действиями-токенами модель выполнила 18% попыток, с регрессией по среднему квадрату ошибки — 35%, с диффузией — 83%. О том, чем головы отличаются, — лаборатория 2.

Обучали Octo на 25 датасетах из Open X-Embodiment, 800 тысячах эпизодов; у RT-X было 350 тысяч. Датасеты с более разнообразными задачами и сценами брали с двойным весом. Обучение Octo-Base заняло 14 часов на TPU v4-128. Без дообучения Octo в среднем выполнила на 29% больше попыток, чем RT-1-X, а на роботах WidowX и Google — примерно столько же, сколько RT-2-X.

Главная проверка — дообучение. В шести новых установках, в том числе с датчиком силы, с управлением суставами и с двурукой ALOHA, у которой 14 чисел в действии, авторы брали около 100 демонстраций и одни и те же настройки: 50 тысяч шагов, полное дообучение всех весов. Один такой запуск идёт около 5 часов на одной видеокарте NVIDIA A5000 с 24 ГБ памяти. В среднем дообученная Octo выполнила 72% попыток, политика, обученная с нуля на тех же демонстрациях, — 20%, а модель с готовым зрительным энкодером VC-1 — 15%. С нуля обучали не саму Octo, а сеть ResNet с небольшим трансформером на 28 млн параметров: большой трансформер Octo на малых данных быстро переобучался.

Но основа Octo видела только данные роботов. В RT-2 знание о предметах и словах приходило из модели, обученной на картинках и текстах из интернета. Можно ли сделать открытую модель на такой основе?

3 OpenVLA

OpenVLA: открытая модель зрения и языка выдаёт действия токенами

RT-2 в уроке 3.3 показала, что модель зрения и языка, которой дали писать действия токенами, переносит знание из интернета на робота: берёт предмет, которого не было в данных робота, по названию. Но и RT-2, и RT-2-X закрыты. OpenVLA повторяет рецепт на открытых частях.

Основа — открытая модель Prismatic-7B. Картинку 224 × 224 пикселя читают сразу два зрительных энкодера, вместе 600 млн параметров: SigLIP, обученный сопоставлять картинки с подписями, хорошо знает, что на снимке, а DINOv2, обученный на картинках без подписей, лучше передаёт, где что лежит. Признаки каждого квадрата картинки от двух энкодеров ставят рядом в один вектор. Двухслойная сеть-проектор переводит эти векторы в пространство слов языковой модели Llama 2 на 7 млрд параметров, как в уроке 3.2.

Действие — 7 чисел: смещение и поворот захвата и его раскрытие. Каждое число делят на 256 корзин, как в RT-2, но границы ставят между 1-м и 99-м процентилем значений в данных, а не между минимумом и максимумом: иначе редкие выбросы растянули бы шкалу и корзины стали бы грубее. Под 256 корзин переписывают 256 самых редких токенов словаря Llama. Модель учится предсказывать следующий токен, и потерю считают только на токенах действия.

Данные — 970 тысяч эпизодов из Open X-Embodiment с весами смеси, как у Octo. Обучение заняло 14 дней на 64 видеокартах A100, 21 500 часов A100, и 27 проходов по данным: модель улучшалась, пока точность на токенах действия не превысила 95%. Зрительные энкодеры при этом дообучали вместе со всей моделью. В моделях зрения и языка энкодер часто замораживают: так делает LLaVA, и, по данным авторов Prismatic, так обычно выходит лучше. PaliGemma из урока 3.2, наоборот, не замораживает ничего. Для действий заморозка оказалась хуже: с замороженным зрением результат был заметно ниже. Авторы предполагают, что признакам из интернета не хватает мелких деталей, нужных для точного движения. Для работы готовой модели нужно 15 ГБ памяти видеокарты, и на RTX 4090 она выдаёт около 6 действий в секунду.

На 29 задачах на двух роботах OpenVLA выполнила на 16,5 процентного пункта больше попыток, чем RT-2-X, хотя параметров у неё в 7 раз меньше; по категориям — в интерактиве ниже. Дообучение тоже сработало: на семи задачах с рукой Franka по 10–150 демонстраций дообученная OpenVLA выполнила в среднем 67,2% попыток на установке со столом, Diffusion Policy, обученная с нуля, — 48,5%, дообученная Octo — 43,4%.

Но это дообучение всех 7 млрд весов: на каждую задачу уходило от 5 до 15 часов на восьми A100. Как дообучить такую модель на одной видеокарте?

4 LoRA

LoRA: учить небольшую добавку, а не всю матрицу

При дообучении всех весов видеокарта хранит не только 7 млрд весов, но и градиент каждого и два момента оптимизатора Adam. У OpenVLA при пакете из 16 примеров это 163,3 ГБ — на одну видеокарту не помещается, модель делили между двумя. Можно учить не все веса, а только часть, остальные заморозить.

Авторы OpenVLA сравнили пять способов на двух задачах с рукой Franka. Только последний слой и словарь эмбеддингов — 30,3% успешных попыток. Замороженное зрение, всё остальное учится, — 47,0%. «Сэндвич»: учатся зрительный энкодер, словарь и последний слой — 62,1%. Все веса — 69,7%. И LoRA — 68,2%, почти как все веса, хотя учится всего 1,4% параметров.

LoRA (low-rank adaptation, Hu и соавторы, 2021) оставляет каждую матрицу весов $W$ замороженной и учит рядом с ней добавку из двух узких матриц. Слой считает $W x + B A x$ : матрица $A$ сжимает вход до $r$ чисел, матрица $B$ разворачивает их обратно до размера выхода. Число $r$ — ранг добавки: у матрицы $B A$ не больше $r$ независимых строк, и она меняет поведение слоя лишь в $r$ направлениях. Вначале $B$ заполнена нулями, поэтому модель совпадает с предобученной, а после обучения добавку можно прибавить к $W$ , и модель работает так же быстро, как исходная.

Схема одного слоя, а не рисунок модели. Серым с замком — замороженная матрица $W$ , оранжевым — обучаемые матрицы $A$ и $B$ , синие точки — числа входа и выхода, красные — градиент при обучении: он доходит только до $A$ и $B$ . Числа внизу — для первого слоя нашей мини-модели из лаборатории 1. Нажми на схему, чтобы остановить её.

У матрицы размером $d_\text{out} \times d_\text{in}$ обычно учатся $d_\text{out} \cdot d_\text{in}$ чисел, а у добавки — $r\,(d_\text{in} + d_\text{out})$ . Для большой квадратной матрицы со стороной $d$ это доля $2r/d$ : чем больше матрица, тем меньше доля. В OpenVLA LoRA ранга 32 поставили на все линейные слои: учится 97,6 млн чисел из 7 188,1 млн, памяти нужно 59,7 ГБ вместо 163,3 ГБ, и дообучение идёт 10–15 часов на одной A100 — в 8 раз меньше вычислений, чем у полного. С рангом 64 параметров вдвое больше, а успех тот же, 68,2%, поэтому авторы советуют брать ранг 32.

Для работы робота модель можно ещё и сжать. Квантование (quantization) хранит каждый вес в 8 или 4 битах вместо 16. С 4 битами на восьми задачах OpenVLA выполнила 71,9% попыток против 71,3% в 16 битах, а памяти заняла 7,0 ГБ вместо 16,8 ГБ. В 8 битах успех упал до 58,1%, но из-за скорости, а не точности: на видеокарте A5000 такая модель выдавала 1,2 действия в секунду при контроллере, рассчитанном на 5. Когда робот ждал каждое действие, все три варианта сравнялись.

Почему добавка малого ранга дообучает не хуже, чем все веса, а замороженная основа хуже? И всегда ли так — например, если записей не 50, а 5? Проверим на столе из урока 2.1.

🔬 Лаборатория 1

Дообучение на новую руку: все веса, LoRA или заморозка

Перенесём маленькую предобученную модель на новую руку. Модель предобучена на роботе из урока 2.1: стол сверху, кубики трёх цветов, обычная камера. У новой руки другие предметы — банки вместо кубиков, — и другая камера: свет теплее, синий канал слабее. Без дообучения модель берёт названный предмет лишь в 28% новых сцен. Записи новой руки делает оператор — человек, который ведёт руку и показывает, что брать. Пишет он сериями: четыре записи подряд с одной командой, потом четыре со следующей.

Модель устроена как маленькая VLA. Стол — сетка 24 × 24 клетки, как в уроке 2.1. Для каждой клетки модель смотрит на окно 3 × 3 соседних клеток и на координаты клетки, а слово команды — «красную», «синюю» или «зелёную» — добавляется к первому слою как вектор сдвига. Два скрытых слоя (40 и 20 нейронов) выдают оценку клетки, и softmax по 576 клеткам даёт, где брать. Всего 2281 параметр. Предобучение идёт прямо на странице: 60 записей робота из урока 2.1, 400 шагов Adam. На новых сценах того же робота модель берёт названный кубик в 95% случаев.

Три способа дообучения, у каждого 300 шагов обучения на записях новой руки. Все веса — учится всё. LoRA — веса заморожены, к матрицам обоих слоёв добавлены матрицы $B A$ ранга $r$ , учится ещё последний слой. Заморозка — основа заморожена целиком, поверх неё новая голова со скрытым слоем из 8 нейронов. Проверка — 60 новых сцен новой руки, по 20 на каждую команду. Все числа считаются в браузере.

Вид на стол сверху, как видит камера. Слева — сцена робота, на котором модель предобучена, справа — сцена новой руки. Кольцо — предмет, который назван в команде.

Предобучение на роботе из урока 2.1…

Вид на стол новой руки сверху. Одна и та же новая сцена у всех моделей: кольцо — банка из команды, оранжевая заливка — насколько модель уверена, что брать надо здесь, крестик — клетка, которую модель выбрала: зелёный — попала в нужную банку, красный — нет.

сцена 1 из 60

Записей

Ранг LoRA

набор 4

Под капотом: мини-модель, три способа и почему так вышло

Признаки клетки $i$ — 27 чисел цвета окна 3 × 3 за вычетом цвета фона (медианы по сцене) и две координаты клетки. Пусть $x_i$ — эти 29 чисел, $e_c$ — вектор слова команды $c$ . Модель считает

\begin{aligned} h_1 &= \tanh\bigl(W_1 x_i + b_1 + e_c\bigr), \\ h_2 &= \tanh\bigl(W_2 h_1 + b_2\bigr), \\ s_i &= w_3^{\top} h_2 + b_3, \\ p(i) &= \operatorname{softmax}_i (s_i), \end{aligned}

а потеря — перекрёстная энтропия на клетке, где оператор взял предмет. Матрицы: $W_1$ — 40 × 29, $W_2$ — 20 × 40. LoRA заменяет их на $W_1 + B_1 A_1$ и $W_2 + B_2 A_2$ ; при ранге 2 добавки — это $2 \cdot (29 + 40) + 2 \cdot (40 + 20) = 258$ чисел, с последним слоем — 279, то есть 12% параметров. Доля здесь большая, потому что матрицы маленькие: при $d \approx 40$ отношение $2r/d$ при ранге 2 — около 10%, а у матриц OpenVLA — 1,4% при ранге 32. При заморозке учится новая голова: $s_i = w_o^{\top} \tanh(W_h h_2 + b_h) + b_o$ , это 177 чисел.

Без дообучения модель на новой руке ни разу не взяла красную банку из 20, синюю взяла 13 раз, зелёную — 4: тёплая камера сдвинула цвета, и признаки цвета, выученные на старой камере, перестали совпадать с новыми. В пяти записях четыре команды «красную» и одна «синюю», «зелёной» нет. Все веса и LoRA меняют сами признаки цвета в первом слое и могут подогнать их под ту команду, которой в записях больше, испортив остальные. Заморозка не трогает ни признаки, ни слова и учит только, как читать выход основы: команды, которых в записях почти нет, она портит меньше, но и исправить признаки, которые испортила новая камера, не может. Посмотри на строку «по командам» под сценой.

Результат при пяти записях зависит от того, какие сцены в них попали: кнопка «Другие записи» берёт другой набор. Мы проверили пять наборов: в среднем при 5 записях заморозка выполнила 62% попыток, LoRA и все веса — по 48%, при 40 записях все веса — 91%, LoRA — 90%, заморозка — 84%. В статьях Octo и OpenVLA так мало записей не пробовали: у Octo около 100 на задачу, у OpenVLA 10–150, и там полное дообучение и LoRA выигрывали у заморозки.

При нескольких десятках записей добавка малого ранга дообучает модель не хуже, чем все веса: изменение, нужное для новой руки, укладывается в несколько направлений. Замороженная основа устойчива, когда записей очень мало, но у неё есть предел: исправить признаки, которые испортила новая камера, она не может. Похожее видно в таблице OpenVLA: варианты, где признаки картинки не подстраиваются под новую сцену, — только последний слой (30,3%) и замороженное зрение (47,0%) — заметно отстали от LoRA (68,2%).

Но модель учится не только видеть. Её голова решает, какое именно действие выдать, и у Octo с OpenVLA головы разные: у одной токены, у другой диффузия. Чем это различается, когда правильных действий несколько?

🔬 Лаборатория 2

Голова действий: среднее, токены или диффузия

Часто правильных действий несколько. В уроке 1.3 Ада объезжала чайник то слева, то справа, а политика, обученная регрессией со средним квадратом ошибки, ехала прямо в чайник: среднее двух правильных действий оказалось неправильным. У Octo и OpenVLA разные головы действий, и именно голова решает, что делать с несколькими правильными ответами.

Ада — домашний гуманоидный робот на колёсной базе, на котором построены лабораторные работы курса. Подробнее о ней — в уроке 0.1.

Задача: захват держит кубик над столом, на столе две одинаковые миски, кубик нужно положить в любую. Операторы записали 40 демонстраций: 21 раз положили в левую верхнюю миску, 19 раз — в правую нижнюю. Сцена одна и та же, поэтому выход основы у всех голов одинаковый, и разница только в голове.

Регрессия выдаёт два числа — точку на столе — и учится по среднему квадрату ошибки, как политики урока 1.1. Токены: стол по каждой оси делят на корзины, как в RT-2 и OpenVLA, модель выдаёт сначала токен координаты x, потом токен y, зная выбранный x, а мы берём самый вероятный токен; ответ — центр корзины. Диффузия — как в Octo: маленькая сеть из случайной точки за 20 шагов денойзинга убирает шум и приходит к действию. Все три обучаются здесь же: регрессия — градиентным спуском, токены — по частотам записей (классификатор с перекрёстной энтропией сходится именно к ним), диффузионная сеть 5 → 64 → 64 → 2 — за 2000 шагов Adam.

Вид на стол сверху, 96 × 96 клеток мелкой сетки урока 2.1. Две миски — две правильные цели, серые точки — куда клали кубик операторы. Ответы голов: квадрат — регрессия, ромб — токены, круг — диффузия; пунктир — путь последнего ответа диффузии от шума к действию.

Легенда: значки на сцене

Корзин на ось24 В левую миску21 из 40

Под капотом: три головы, корзины и шаг денойзинга

Регрессия минимизирует средний квадрат ошибки $\tfrac1N \sum_j \lVert a - a_j \rVert^2$ , и её оптимум — среднее записей $\bar a = \tfrac1N \sum_j a_j$ : точка между мисками.

Токены. Ось делят на $K$ корзин шириной $96/K$ клеток. Модель выдаёт распределение $p(x)$ , потом $p(y \mid x)$ , как языковая модель выдаёт слова одно за другим. Классификатор, обученный на перекрёстной энтропии, сходится к частотам в данных, поэтому у нас вероятности — частоты записей. Ответ — самый вероятный токен по каждой оси, то есть всегда один и тот же; его точность ограничена шириной корзины. Если брать токены случайно по их вероятностям, ответы тоже разойдутся по двум мискам, но точность останется той же.

Диффузия. Сеть $\varepsilon_\theta$ получает зашумлённое действие и номер шага денойзинга $k$ и предсказывает, где чистое действие; шум выражается через это предсказание. Шаг денойзинга — формула (1) статьи Octo:

x_{k-1} = \alpha\bigl(x_k - \gamma\, \varepsilon_\theta(x_k, e, k) + \mathcal N(0, \sigma^2 I)\bigr),

где $e$ — выход основы, а $\alpha, \gamma, \sigma$ задаёт расписание шума; у нас, как в Octo, косинусное и 20 шагов денойзинга. У нас сеть маленькая и обучается за пару секунд, поэтому около 7 ответов из 100 ложатся мимо мисок.

Регрессия выбирает среднее, которого нет в данных, и кладёт кубик мимо обеих мисок. Токены с двумя правильными ответами не путаются: кубик попадает в миску, только всегда в одну и ту же. Слабость токенов в другом. Ответ — центр корзины, и точнее ширины корзины он не бывает. А каждое число действия — отдельный токен, и OpenVLA выдаёт их один за другим, поэтому действий в секунду выходит всего около шести. Диффузия выдаёт то одну миску, то другую, примерно в той же пропорции, что и операторы, и её ответ не привязан к корзинам.

Абляции Octo на роботе WidowX показывают то же на настоящих задачах: с диффузионной головой модель выполнила 83% попыток, с регрессией — 35%, с токенами — 18%. Авторы объясняют разницу так: диффузия умеет выдавать разные правильные действия, в отличие от регрессии, и сохраняет точность непрерывных чисел, в отличие от токенов. Политика с регрессией «перестраховывалась»: двигалась очень медленно и, например, не поворачивала захват. Политика с токенами по 256 корзин на ось действовала решительно, но ей не хватало точности, и она часто промахивалась при захвате. Octo с токенами подвела точность, а не выбор между правильными действиями. Но OpenVLA с токенами на тех же роботах сильнее Octo. Что тогда решает в результатах?

🧩 Интерактив

Таблицы OpenVLA: где открытая модель обходит закрытую

Сравнивать модели по одной цифре опасно: задачи бывают разными. Авторы OpenVLA проверили четыре модели без дообучения на двух роботах. На WidowX с данными BridgeData V2 — 17 задач по 10 попыток, сгруппированных по тому, что изменилось по сравнению с обучающими данными. На мобильном манипуляторе Google, на котором записаны данные RT-1, — 12 задач по 5 попыток, в знакомых и в новых условиях. Сцены и начальные положения у всех моделей одинаковые. Иногда засчитывали половину попытки, например когда рука шла к правильному предмету, но не довела дело до конца.

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

Числа — из таблиц 4 и 6 статьи OpenVLA: доля успешных попыток в процентах, полоска — та же доля. Жирным — лучшее в строке. Под названием модели — число параметров и открыты ли веса.

Авторы объясняют отрыв от RT-2-X тремя причинами: данных больше — 970 тысяч эпизодов против 350 тысяч, данные чище — из каждой записи BridgeData V2 убрали первый шаг, где действие нулевое, иначе модель училась стоять на месте, — и зрение двойное. На восьми задачах проверили две из них, данные и второй энкодер: OpenVLA выполнила 76,3% попыток, та же модель, обученная только на BridgeData V2, — 45,6%, а ещё и без DINOv2 — 40,6%. Больше всего дали данные Open X-Embodiment.

RT-2-X сильнее только там, где нужно знание из интернета: её дообучали на смеси действий робота и веб-данных, а OpenVLA — только на данных роботов. Octo и RT-1-X в этих тестах часто брали не тот предмет, когда рядом лежали другие, а авторы OpenVLA нарочно сделали тесты труднее, чем в прошлых статьях. Что из открытых моделей 2024 года работает в 2026-м?

5 Сегодня

Что выросло из открытых VLA

В феврале 2025 года авторы OpenVLA предложили новый рецепт её дообучения — OpenVLA-OFT (Kim, Finn, Liang). Вместо токенов модель выдаёт непрерывные действия, обученные регрессией с ошибкой L1, всю пачку действий сразу, а не по токену. На тестах LIBERO в симуляции дообученная так модель выполнила в среднем 97,1% попыток по четырём наборам задач; в статье OpenVLA дообученная через LoRA модель на тех же наборах выполнила 76,5%. Действия генерируются в 26 раз быстрее.

Дообучение на одной видеокарте стало обычным делом. Библиотека LeRobot от Hugging Face записывает демонстрации на недорогих руках вроде SO-101 и Koch, обучает и запускает политики: ACT, Diffusion Policy, π0 и SmolVLA. SmolVLA (3 июня 2025) — модель на 450 млн параметров на основе SmolVLM2, предобученная на 487 датасетах, которые записали участники сообщества LeRobot, — меньше 30 тысяч эпизодов. Её обучают на одной видеокарте для игр или даже на MacBook. На задачах с рукой SO-100 предобучение на данных сообщества подняло её успех с 51,7% до 78,3%.

Открытые веса выкладывают и компании. NVIDIA выложила на Hugging Face GR00T N1.6 на 3 млрд параметров для гуманоидов (карточка модели — с декабря 2025, лицензия NVIDIA с ограничениями на использование): модель зрения и языка читает картинку и команду, а трансформер на flow matching выдаёт непрерывные действия. Physical Intelligence открыла в репозитории openpi под лицензией Apache 2.0 веса и код π0, π0-FAST и π0.5, в сентябре 2025 добавив π0.5 и версию на PyTorch. Для дообучения через LoRA там нужно больше 22,5 ГБ памяти — это RTX 4090, для полного — больше 70 ГБ, A100 или H100. Тот же расчёт, что у OpenVLA: LoRA помещается на одну видеокарту, полное дообучение — нет.

У OpenVLA-OFT, GR00T N1.6 и π0 действия непрерывные, а не токены; π0-FAST, наоборот, сжимает действия в токены, и о нём тоже урок 3.6. У OpenVLA семь токенов действия выдаются один за другим, и на RTX 4090 это около 6 действий в секунду. Авторы сами называют это одним из ограничений: двурукая ALOHA управляется с частотой 50 Гц. Токены ещё и грубые: точность ограничена шириной корзины. Как сохранить знание модели зрения и языка, но выдавать точные действия быстро? Об этом урок 3.6.

6 Проверь себя

Восемь вопросов о типичных заблуждениях

7 Итог

Итоги урока

RT-2-X закрыта, и дообучить её на свою руку нельзя. Octo и OpenVLA открыты целиком — веса, код обучения и данные — и обучены на Open X-Embodiment: 800 и 970 тысяч эпизодов.
В Octo всё — токены: команда, картинки, цель. Токены-считыватели читают остальные, не влияя на них, и передают выход голове, поэтому новый вход или выход добавляют, не трогая основу. Около 100 демонстраций и 5 часов на одной видеокарте — и Octo работает на новой установке.
OpenVLA — модель зрения и языка на 7 млрд параметров с двумя зрительными энкодерами, SigLIP и DINOv2, которая выдаёт действие токенами, по 256 корзин на ось. На 29 задачах она на 16,5 процентного пункта сильнее RT-2-X, но слабее там, где нужно знание из интернета.
LoRA замораживает матрицу $W$ и учит добавку $B A$ ранга $r$ . В OpenVLA это 1,4% параметров и почти тот же успех, что у дообучения всех весов; ранг почти не влияет. Квантование до 4 бит сокращает память больше чем вдвое без потери успеха.
Голова решает, что делать, когда правильных действий несколько, и насколько точно. Регрессия выдаёт среднее, токены с самым вероятным ответом — всегда одно и то же правильное действие, но с точностью до корзины и по одному токену за раз, диффузия — то одно, то другое. В абляциях Octo токены дали 18% против 83% у диффузии: политика часто промахивалась при захвате.
В нашей лаборатории при 5 записях лучше всех работала замороженная основа, а при 40 все веса и LoRA сравнялись и обошли её: добавке малого ранга хватает данных, а заморозке не хватает свободы.

Открытые вопросы

Почему для новой установки хватает добавки ранга 32 к матрицам размером в тысячи строк?

Авторы LoRA предположили, что изменение весов, нужное для новой задачи, само имеет низкий ранг: модель уже умеет почти всё, и подстройка идёт в нескольких направлениях. В OpenVLA ранги 32 и 64 дали одинаковый успех, у нас ранги от 1 до 8 тоже. Но в опытах OpenVLA новая установка — рука Franka, такая же, как в датасете DROID из обучающей смеси. Если новый робот сильно отличается, например другим числом суставов, как ALOHA для Octo, одной добавки мало: нужна новая голова и, возможно, больше данных.

OpenVLA выдаёт около 6 действий в секунду. Как разогнать её до частоты управления двурукой ALOHA в 50 Гц?

Авторы предлагают предсказывать пачку действий за один вызов, как Octo и ACT, или ускорять декодирование токенов приёмами языковых моделей вроде спекулятивного декодирования. OpenVLA-OFT выдаёт всю пачку непрерывных действий за один проход и генерирует действия в 26 раз быстрее. π0 из урока 3.6 отдаёт действия эксперту действий — второй группе весов того же трансформера, которая строит пачку по flow matching.

Гид по статье

M. J. Kim, K. Pertsch, S. Karamcheti и соавторы, «OpenVLA: An Open-Source Vision-Language-Action Model», CoRL 2024.

Читать внимательноРаздел 3.2: как действия становятся токенами и почему границы корзин ставят по процентилям. Раздел 5.3 и таблица 1: пять способов дообучения, параметры и память. Раздел 5.4 и приложение D.4: почему 8 бит хуже 4 бит.
Можно пропуститьПриложение B с описанием каждой из 29 задач и приложение E с тестами в симуляции LIBERO.
Вопрос по ходуВ приложении C RT-2-X на BridgeData V2 часто выдавала нулевое действие и замирала, и её спрашивали о втором по вероятности действии. Как это меняет сравнение двух моделей?

Octo Model Team, D. Ghosh, H. Walke, K. Pertsch и соавторы, «Octo: An Open-Source Generalist Robot Policy», RSS 2024 — раздел III-A о токенах и считывателях, таблица II и приложение E о том, что сработало и что нет.

E. J. Hu и соавторы, «LoRA: Low-Rank Adaptation of Large Language Models», 2021 — откуда взялась добавка низкого ранга.

Материалы

OctoСтраница проекта: видео, ссылки на код и веса
Код OctoПредобучение и дообучение на JAX, загрузчики данных Open X-Embodiment
OpenVLAСтраница проекта: видео опытов и ссылки на веса
Код OpenVLAОбучение на PyTorch, дообучение через LoRA и запуск в 4 битах
OpenVLA-OFTРецепт быстрого дообучения: непрерывные действия и пачки
LeRobotБиблиотека Hugging Face: запись демонстраций, обучение и запуск политик
SmolVLAБлог Hugging Face о модели на 450 млн параметров
GR00T N1.6Карточка модели NVIDIA на Hugging Face
openpiВеса и код π0, π0-FAST и π0.5

➡️

Дальше: 3.6 «π0». OpenVLA выдаёт действие токенами: по одному, около 6 раз в секунду и с точностью до корзины. π0 оставляет модель зрения и языка для понимания сцены и команды, а действия строит вторая, меньшая группа весов того же трансформера: пачку непрерывных действий по flow matching. Перейти к уроку 3.6 →

Урок был понятен?

Нашли ошибку или неточность? Сообщить на GitHub

Урок пригодился? Скажи спасибо — так автор узнает, что курс читают.