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

Helix, GR00T, Gemini Robotics: медленная модель понимает, быстрая ведёт руку

В уроке 3.6 π0 думала дважды в секунду, а команды роботу шли 50 раз в секунду: модель выдавала пачку из 50 действий, и робот исполнял её по частям. Гуманоиду этого мало. Helix ведёт 35 степеней свободы гуманоида Figure — запястья, пальцы, торс и голову — 200 раз в секунду, а модель зрения и языка на 7 млрд параметров успевает посмотреть на сцену только 7–9 раз. Если модель работает в облаке, добавляется сеть: у Gemini Robotics путь от кадра до действий занимает около 250 мс. В 2025 году Figure, NVIDIA и Google DeepMind пришли к одному решению: поделить работу между моделями с разными частотами. Большая медленная модель понимает сцену и команду, маленькая быстрая ведёт руки по свежим кадрам, а в Helix 02 под ними появился третий уровень, который 1000 раз в секунду держит равновесие. Разберём, что одна модель передаёт другой в Helix, GR00T N1 и Gemini Robotics, почему такая система точно ведёт руку, но не быстрее понимает новую просьбу, и как модель-планировщик Gemini раздаёт шаги исполнителю словами.

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

ЗАДЕРЖКАПосчитай, по каким старым кадрам движется рука, когда модель думает 7 раз в секунду, а команды идут 200 раз, и сколько добавляет облако

ЧАШКАСравни рядом две руки на одной сцене: одна модель и пара моделей с разными частотами тянутся к чашке, которую двигают по столу, а потом человек передумывает

УРОВНИРазложи задачи гуманоида по трём уровням: кто понимает просьбу, кто ведёт руки, кто держит равновесие

ПЛАНИРОВЩИКПроследи на схеме, как модель Gemini ищет правила, раздаёт шаги модели-исполнителю и проверяет результат по камере

Начать урок ↓

1 Задержка

Почему одна большая модель не успевает за рукой

В уроке 3.6 π0 строила пачку из 50 действий за 73 мс на видеокарте RTX 4090. Робот исполнял 25 из них, по одному каждые 20 мс, и раз в 0,5 с получал новую пачку. Пачка позволила давать команды 50 раз в секунду модели, которая думает дважды в секунду. Но исполняет робот пачку вслепую: все 25 действий построены по кадру, снятому ещё до начала вывода. Если за эти полсекунды чашку сдвинули, рука поедет туда, где чашка была.

У гуманоида задача тяжелее. Модель Helix от Figure, о которой этот урок, ведёт верхнюю часть тела робота: позы запястий, сгибание и разведение пальцев, наклон торса и поворот головы, всего 35 степеней свободы. Команды она выдаёт 200 раз в секунду, то есть каждые 5 мс. Модель зрения и языка на 7 млрд параметров за 5 мс не успевает даже прочитать кадр: в Helix она работает 7–9 раз в секунду. RT-2 из урока 3.3 с моделью на 55 млрд параметров успевала 1–3 раза в секунду, OpenVLA из урока 3.5 — около 6.

Ещё хуже, если модель не помещается на борт робота. Gemini Robotics (Google DeepMind, 2025) построена на Gemini 2.0, и её основная часть работает в облаке. Авторы пишут, что большие модели вроде их Gemini Robotics-ER отвечают за секунды и требуют специального железа. Облачную часть ускорили до ответа быстрее чем за 160 мс, но путь от кадра до пачки действий на роботе всё равно занимает около 250 мс. Это время — от снятого кадра до первой команды, построенной по нему, — называют задержкой (latency). Она складывается из времени вывода и пути по сети и говорит, как долго робот ждёт ответа на то, что увидел; у π0 на борту она была 73 мс.

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

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

Частота команд и возраст данных

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

Ада тянется к чашке, а человек двигает чашку по столу со скоростью 15 см/с. Медленная модель берёт кадр с камеры, считает по нему пачку и сразу берёт следующий кадр: при частоте 7 Гц вывод занимает 1/7 секунды, около 143 мс. Если модель в облаке, к выводу добавляется сеть. Пачка приходит на робот, и рука исполняет её по одной команде каждые 5 мс, пока не придёт следующая.

Задержка говорит, когда придёт первая команда по кадру. Но рука исполняет пачку и дальше, а кадр тем временем стареет. Назовём возрастом данных время, которое прошло со съёмки кадра, по которому построена команда, исполняемая рукой сейчас. Задержка у пачки одна, а возраст данных у каждой её команды свой: у первой он равен задержке, у следующих больше. У π0 из урока 3.6 первую команду пачки рука получает через 73 мс после кадра, а последнюю из 25 — когда кадру уже больше полсекунды. Если возраст данных 200 мс, рука целится в то место, где чашка была 200 мс назад, а за это время чашка уехала на 3 см. Захвату, чтобы взять чашку, надо оказаться к ней ближе: в лаборатории 2 допуск — 2 см.

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

Шкала времени, слева направо: одна секунда или больше при низкой частоте, подписи — в миллисекундах. Строки сверху вниз: синие засечки — кадры, по которым считает модель; фиолетовые полосы — вывод медленной модели; серые штрихованные — путь ответа по сети; оранжевая гребёнка — такты быстрой системы, если она включена; серые засечки внизу — команды руке каждые 5 мс. Пунктирная дуга связывает команду под курсором с кадром, по которому она построена.

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

Частота модели7 Гц

Быстрая система

Задержка сети0 мс Скорость чашки15 см/с

Под капотом: откуда берутся границы возраста данных

Пусть медленная модель работает с частотой $f$ и считает без пауз: вывод занимает $c = T = 1/f$ , кадр $k$ снят в момент $t_k = kT$ , а ответ по сети идёт ещё $L$ . Пачка по кадру $k$ приходит на робот в момент $t_k + T + L$ — задержка здесь $T + L$ — и исполняется, пока не придёт пачка по кадру $k + 1$ , то есть ещё $T$ . Возраст данных в момент $t$ — это $t - t_k$ для последней пришедшей пачки:

\begin{gathered} a_{\min} = T + L, \quad a_{\max} = 2T + L,\\ \bar a = \tfrac{3}{2}\,T + L. \end{gathered}

При 7 Гц без сети это 143 и 286 мс, в среднем 214 мс. Чашка со скоростью $v$ уходит от точки, куда целится рука, на $v\,a$ : при 15 см/с — от 2,1 до 4,3 см. Частота команд руке тут ни при чём: пачку можно разрезать на команды хоть по 1 мс, данные в них те же.

Быстрая система берёт кадр в каждом такте $T_1 = 5$ мс, считает такт и отдаёт команду в начале следующего, поэтому её данным от $T_1$ до $2T_1$ , то есть от 5 до 10 мс. Медленная модель при этом никуда не делась: новую просьбу человека робот поймёт не раньше, чем медленная модель увидит её и досчитает. Это время реакции на просьбу лежит в тех же границах $[T + L,\ 2T + L]$ .

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

Подняв частоту медленной модели до 10 Гц, возраст данных не опустить ниже 100 мс, а промах при 15 см/с — ниже 1,5 см. Пачка делает движение плавным, но не делает данные свежими. Быстрая система даёт руке кадры возрастом 5–10 мс и при этом не обязана понимать просьбу: ей достаточно знать, к чему тянуться. Как устроены такие пары моделей и что одна сообщает другой?

2 Helix

Две модели с разными частотами в одной системе

Лаборатория 1 показала, что руке нужны кадры возрастом в несколько миллисекунд, а понимать просьбу так часто незачем: пока человек не передумал, ответ на вопрос «что делать» не меняется. Helix (Figure, февраль 2025) делит работу на две модели. Названия System 1 и System 2 — из книги психолога Даниэля Канемана «Думай медленно… решай быстро» (2011); на неё прямо ссылаются авторы GR00T N1: System 2 — медленное обдумывание, System 1 — быстрые привычные действия.

Медленная система (System 2, S2) — модель зрения и языка на 7 млрд параметров с открытыми весами. Она получает кадр с камеры робота, его состояние — позы запястий и положения пальцев — и просьбу текстом, работает 7–9 раз в секунду и понимает сцену и задачу. Наружу она отдаёт не текст и не координаты, а один латентный вектор — набор чисел, смысл которых никто не задавал заранее: он появляется при обучении. По словам Figure, в этот вектор S2 сводит всё, что о задаче нужно знать для движений.

Быстрая система (System 1, S1) — трансформер на 80 млн параметров. Она получает те же кадры и состояние, что S2, но обрабатывает их 200 раз в секунду, и выдаёт команды верхней части тела: позы запястий, сгибание пальцев, наклон торса и поворот головы. Картинку S1 читает своей свёрточной сетью, которую сначала обучили в симуляции. Латентный вектор от S2 переводится в токен S1 и ставится в одну последовательность с признаками картинки. Так быстрая система знает, к чему тянуться, а где это сейчас, видит сама.

Работают системы асинхронно: каждая в своём темпе, не дожидаясь другой. S2 — фоновый процесс, S1 — отдельный процесс реального времени; каждая работает на своей встроенной видеокарте с низким энергопотреблением, и обе стоят на самом роботе. В каждом такте S1 берёт свежий кадр и последний вектор, который успела выдать S2.

Схема Helix во времени, замедлено в 10 раз. Синие засечки — кадры камеры, фиолетовые полосы — выводы медленной системы S2, фиолетовые квадраты — латентный вектор, который она выдаёт; оранжевые засечки — такты быстрой системы S1, серые стрелки внизу — команды верхней части тела. Цифра на квадрате — номер вектора: каждый такт S1 пользуется последним пришедшим. Период S2 на схеме — 130 мс, около 7,7 Гц, внутри диапазона 7–9 Гц из блога Figure. Нажми на схему, чтобы остановить её.

Обучают обе системы вместе, end-to-end: от пикселей и текста до действий, как одну политику из урока 0.1. Одна тонкость связана со временем. На роботе S1 видит кадр свежее, чем тот, по которому S2 посчитала последний вектор. Если при обучении давать обеим системам один и тот же кадр, S1 привыкнет к тому, чего на роботе не бывает. Поэтому при обучении между входами S1 и S2 вводят сдвиг во времени, подобранный под разницу их задержек на роботе.

Данных немного: около 500 часов телеоперации — записей, в которых оператор, человек, управлял роботом. Одни и те же веса, без дообучения под задачу, Figure показывали на перекладывании предметов, работе с ящиками и холодильником и передаче предметов от одного робота другому. По команде вида «возьми X» роботы брали тысячи незнакомых предметов из кучи.

Но если S2 передаёт не координаты, а вектор, успевает ли рука за чашкой, которую двигают? И что будет, когда человек передумает, а S1 команд не слышит?

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

Рука догоняет чашку: одна модель и две системы рядом

Возьмём руку Ады из урока 0.3: два звена по 50 и 40 см, вид сверху на стол. Человек двигает красную чашку вправо, синяя стоит на месте. Ада берёт чашку, если захват продержится ближе 2 см к ней 0,15 с — столько нужно, чтобы сомкнуть пальцы. Захват разгоняется не быстрее 3 м/с² и едет не быстрее 0,6 м/с, как настоящая рука, которая не может мгновенно сменить скорость.

Слева рукой управляет одна модель, как π0 из урока 3.6: по одному кадру она строит пачку, которая ведёт захват туда, где чашка была на этом кадре, — скорости чашки по одному кадру не узнать. Справа — две системы: медленная с той же частотой решает, какую чашку брать, и передаёт быстрой её название, а быстрая каждые 5 мс смотрит на свежий кадр и ведёт захват к этой чашке. В Helix вместо названия — латентный вектор, но роль у него та же. Обе стороны — программы без ошибок восприятия, никакая сеть здесь не обучается: руки отличаются только тем, когда и что видят их модели.

Одна моделькадр раз в 143 мс

Две системымедленная 7 Гц + быстрая 200 Гц

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

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

Расстояние от захвата до нужной чашки, в сантиметрах (по вертикали), по времени от начала, в секундах (по горизонтали). Фиолетовая линия — одна модель, оранжевая — две системы, серый пунктир — допуск 2 см; дальше 12 см линия упирается в верхний край. Кружок — момент, когда захват сомкнулся. Если просьба меняется, расстояние считается до новой чашки, а фиолетовый пунктир отмечает ответ медленной модели, в котором новая просьба уже учтена.

Скорость чашки15 см/с Медленная модель7 Гц Задержка сети0 мс

Просьба

Под капотом: как рука исполняет команды и чем мы упростили настоящие системы

Обе модели выдают захвату целевую точку $p^\ast$ раз в 5 мс, а нижний уровень руки превращает её в скорость захвата $v$ и углы суставов $q$ . Команда скорости $u$ пропорциональна промаху, настоящая скорость догоняет её с запаздыванием $\tau$ , а углы суставов меняются через якобиан $J$ из урока 0.3:

\begin{gathered} u = K\,(p^\ast - p), \qquad \tau\,\dot v = u - v,\\ \dot q = J(q)^{-1}\,v. \end{gathered}

У нас $K = 25$ 1/с и $\tau = 30$ мс; ускорение захвата ограничено 3 м/с², скорость — 0,6 м/с.

У одной модели $p^\ast$ — положение чашки на кадре, снятом в начале последнего пришедшего вывода; до следующего ответа точка не меняется. У двух систем $p^\ast$ — положение чашки на кадре 5 мс назад, а какую чашку брать, говорит последний ответ медленной системы. Пока ответа нет, обе руки стоят. Шаг расчёта — 1 мс, вывод медленной модели занимает весь её период, как в лаборатории 1.

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

Две системы делят время реакции на две части. Как точно рука ведёт захват, решает быстрая система: её кадрам 5–10 мс. Как быстро робот понимает новую просьбу, решает медленная: до её периода плюс время вывода плюс сеть. Helix — закрытая система, о ней известно только то, что написала Figure. Как то же деление устроено в модели с открытыми весами и статьёй?

3 GR00T

GR00T N1: быстрая система читает токены медленной

О Helix известно только то, что написала Figure: частоты, размеры и общая схема, без статьи и весов. GR00T N1 (NVIDIA, март 2025) — открытая модель для гуманоидов: есть статья, веса GR00T-N1-2B и данные. Устроена она по тому же принципу, и авторы прямо называют части System 2 и System 1.

System 2 — модель зрения и языка Eagle-2: 1,34 млрд параметров из 2,2 млрд во всей модели. Каждый кадр 224 × 224 пикселя превращается в 64 токена, и дальше их вместе с текстом команды обрабатывает языковая часть. На видеокарте L40 System 2 работает 10 раз в секунду. Признаки берут не с последнего слоя языковой модели, а с 12-го, из середины: так, по словам авторов, вывод быстрее и политика чаще справляется с задачей.

System 1 — диффузионный трансформер (DiT), обученный flow matching, как в π0 из урока 3.6. В нём чередуются два вида блоков: self-attention по токенам шумных действий и состояния робота и cross-attention к токенам System 2 — это внимание, где запросы идут от одной последовательности, а ключи и значения от другой, как в уроке 1.6. За 4 шага Эйлера он строит пачку из 16 действий, на L40 это 63,9 мс, а действия идут 120 раз в секунду. Состояние и действия у разных роботов разной длины, поэтому на входе и выходе System 1 стоят небольшие сети MLP, свои для каждой конфигурации: однорукого манипулятора, двух рук, гуманоида Fourier GR-1 с ловкими кистями.

Главное отличие от Helix — в том, что одна система передаёт другой. В Helix это один вектор, в GR00T N1 — вся последовательность токенов среднего слоя, и System 1 сама выбирает из неё вниманием то, что нужно на этом шаге. В π0 из урока 3.6 эксперт действий был частью того же трансформера и читал ключи и значения всех слоёв PaliGemma. Обучают обе системы GR00T N1 вместе, но языковую часть System 2 держат замороженной, как в уроке 3.2: её веса не меняются ни при предобучении, ни при дообучении.

Данные авторы складывают пирамидой. Внизу — веб-данные и видео людей: их больше всего, но действий робота в них нет. В середине — симуляция и видео, которые сгенерировала видеомодель: 780 тысяч траекторий симуляции, равных 6500 часам демонстраций, получили за 11 часов. Наверху — записи настоящего робота, их меньше всего. Для видео без действий авторы учат латентные действия — сжатое описание того, что изменилось между двумя кадрами. Это другие латенты, чем вектор Helix; о таких данных пойдёт речь в части 4.

Под капотом: flow matching в System 1 и знак в статье

Пусть $A_t = [a_t, \dots, a_{t+H-1}]$ — пачка из $H = 16$ действий, $\varphi_t$ — токены System 2, $q_t$ — состояние робота, $\varepsilon \sim \mathcal N(0, I)$ — шум. Шум стоит при $\tau = 0$ , пачка — при $\tau = 1$ , как в уроке 1.8 и у π0. DiT $V_\theta$ учится предсказывать скорость от шума к пачке, а при выводе делает $K = 4$ шага Эйлера:

\begin{gathered} A_t^\tau = \tau A_t + (1-\tau)\,\varepsilon,\\ L(\theta) = \mathbb E\,\bigl\lVert V_\theta(\varphi_t, A_t^\tau, q_t) - (A_t - \varepsilon)\bigr\rVert^2,\\ A_t^{\tau + 1/K} = A_t^\tau + \tfrac{1}{K}\,V_\theta(\varphi_t, A_t^\tau, q_t). \end{gathered}

В тексте статьи цель записана как $\varepsilon - A_t$ — тот же разнобой знаков, что в ранних версиях статьи π0 (урок 3.6): при таком пути и таком шаге Эйлера сеть должна предсказывать $A_t - \varepsilon$ . Время $\tau$ берут из бета-распределения со смещением к шуму, с теми же параметрами, что у π0. Шаг $\tau$ подаётся в блоки DiT через адаптивную нормализацию слоёв (AdaLN), а энкодер действий получает его вместе с шумной пачкой.

Предобучение GR00T-N1-2B заняло около 50 тысяч часов видеокарт H100. Генерация видео для середины пирамиды — около 105 тысяч часов L40: 827 часов видео, по 2 минуты на секунду ролика.

На настоящем GR-1 модель, дообученная на полном наборе записей, в среднем справилась в 76,8% попыток, а Diffusion Policy из урока 1.5 — в 46,4%. На 10% записей — 42,6% против 10,2%: предобученной модели хватило десятой части данных, чтобы отстать от Diffusion Policy на полных данных всего на 3,8 процентного пункта. В симуляции при 100 демонстрациях на задачу — 45,0% против 33,4% у Diffusion Policy и 26,4% у трансформера, обученного копировать демонстрации. Ограничение авторы называют сами: модель решает короткие задачи на столе, а долгие задачи с перемещением по дому оставлены на будущее.

Helix 2025 года тоже работает верхней частью тела у стола. Но гуманоиду ещё нужно стоять, наклоняться и ходить, и всё это одновременно с работой рук. Кто держит равновесие, пока руки тянутся к посудомойке?

🧩 Интерактив

Третий уровень: Helix 02 держит равновесие

Пока гуманоид стоит у стола, ноги и равновесие можно отдать отдельному контроллеру. Когда ему нужно подойти к посудомойке, присесть и вынуть тарелку, движения рук и ног приходится согласовывать. В Helix 02 (январь 2026) под S1 появился третий уровень — S0. Каждая система, пишут в Figure, работает в своём естественном масштабе времени.

S0 — нейросеть на 10 млн параметров. 1000 раз в секунду она получает состояние всех суставов и движение базы и выдаёт команды приводам суставов: отвечает за равновесие, контакты и согласование всего тела. Учили её только в симуляции, больше чем в 200 тысячах параллельных сред, на больше чем 1000 часах движений людей, перенесённых на суставы робота. S0 заменила 109 504 строки кода на C++, написанного вручную. S1 теперь выдаёт цели для суставов всего тела 200 раз в секунду, а S2 понимает сцену и язык и решает, в каком порядке что делать; её частоту в Helix 02 Figure не называет.

В демонстрации гуманоид Figure 03 четыре минуты разгружает и загружает посудомойку без помощи человека — это 61 действие, в которых он и ходит, и работает руками. Камеры у него в голове и в ладонях, на кончиках пальцев — датчики касания, которые чувствуют силу от трёх граммов.

Разложи задачи по уровням. Карточки взяты из Helix, Helix 02 и GR00T N1: смотри не на название системы, а на то, что нужно сделать и как часто. Перетащи карточку или нажми её, а потом корзину.

Чем ниже уровень, тем чаще он работает и тем меньше сеть: в Helix 2025 года у S2 7 млрд параметров, у S1 — 80 млн, у S0 в Helix 02 — 10 млн. Это та же лестница частот, что в уроке 0.2: наверху медленное понимание, внизу быстрые контуры у приводов, — только нейросети теперь спустились до контура на 1 кГц.

И Helix, и GR00T держат все уровни на роботе. А если верхняя модель так велика, что на борт не помещается?

4 Gemini

Gemini Robotics: облако, декодер на роботе и модель-оркестратор

Gemini Robotics (Google DeepMind, март 2025) — модель зрения, языка и действий на основе Gemini 2.0, и на борт она не помещается. Авторы делят её на две части. Основа (backbone) работает в облаке — это дистиллированная версия Gemini Robotics-ER, то есть меньшая модель, обученная повторять ответы большой. Её ответ ускорили с секунд до менее чем 160 мс. На бортовом компьютере робота работает декодер действий — часть модели, которая превращает ответ основы в пачку движений. По словам авторов, декодер компенсирует задержку основы: путь от кадра до пачки действий занимает около 250 мс, а за счёт нескольких действий в пачке эффективная частота управления — 50 Гц. Как устроен декодер и сколько действий в пачке, в статье не сказано.

Учили модель на тысячах часов записей с парка двуруких роботов ALOHA 2, собранных за 12 месяцев, вместе с веб-документами, кодом, картинками и видео. Базовые модели для сравнения, π0 и Diffusion Policy, обучили на тех же данных и запускали локально на RTX 4090, а Gemini Robotics — из облака. На 20 задачах из своих данных, без дообучения, она справилась с половиной из них больше чем в 80% попыток и, по словам авторов, заметно обошла обе базовые модели.

Сама Gemini Robotics-ER — модель воплощённого рассуждения (embodied reasoning, ER): так авторы называют понимание пространства и физики сцены, которое нужно роботу. Она отмечает на кадре точки и рамки предметов, рисует траектории и захваты, оценивает положение предметов в 3D; в уроке 2.1 такие точки сравнивали с картой Transporter. В статье ER управляла роботом вообще без данных действий: писала код к функциям робота — переместить захват, открыть, закрыть, найти предмет, — как Code as Policies из урока 2.3, получала новые кадры и результат исполнения и писала следующий код. В симуляции Gemini 2.0 Flash так справилась в среднем с 27% задач, Gemini Robotics-ER — с 53%.

В Gemini Robotics 1.5 (сентябрь 2025) эти роли разделили между двумя моделями. Gemini Robotics-ER 1.5 стала оркестратором — моделью, которая сама руками не двигает: она планирует шаги, вызывает инструменты, например поиск Google, и раздаёт шаги исполнителю. Исполнитель — VLA Gemini Robotics 1.5: на каждый шаг она получает инструкцию обычными словами и выдаёт движения. Перед движением VLA пишет короткое рассуждение словами — так, по словам авторов, ей проще с шагами, где нужно подумать. Движения переносятся между роботами: задачи, которые при обучении показывали только на ALOHA 2, работают на гуманоиде Apollo от Apptronik и на двуруком Franka, и наоборот.

Схема по описаниям Gemini Robotics 1.5 и ER 2. Фиолетовое — оркестратор Gemini Robotics-ER, оранжевое — исполнитель VLA и его пачки движений, синее — то, что измерено и найдено: кадры камеры и ответ поиска. Подсвечен текущий шаг: просьба, поиск, шаг словами, движения, проверка по камере. Нажми на схему, чтобы остановить её.

Схема похожа на SayCan из урока 2.3: языковая модель выбирала шаг, обученный навык его исполнял. Разница в исполнителе: вместо списка навыков с короткими описаниями — одна VLA, которой шаг передают свободным текстом. А канал между уровнями здесь — слова: их может прочитать человек, и их понимает любая VLA, которая обучена на командах.

В июле 2026 года вышли Gemini Robotics ER 2 и Gemini Robotics 2. ER 2, по словам Google, передаёт исполнение «любой VLA нижнего уровня», командует моделями действий и функциями роботов и по непрерывному видео следит за ходом задачи, чтобы заметить сбой и исправить его. Через Gemini Live API она отвечает быстрее чем за секунду. Gemini Robotics 2 — VLA, которая ведёт гуманоида «от ступней до кончиков пальцев»: Apollo 2 подходит к столу, берёт лейку и ставит её на нижнюю полку. В паре с ER робот выполняет задачи на несколько минут и сотни решений, а слабым местом авторы называют скорость движений. Частоты и задержки этих моделей Google не публикует.

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

5 Сегодня

Три способа связать уровни

Деление на медленное понимание и быстрое движение в 2026 году есть у Figure, NVIDIA и Google, а различаются они тем, что верхний уровень передаёт нижнему. В Helix это латентный вектор, в GR00T — токены среднего слоя, которые быстрая система читает вниманием, в Gemini Robotics — шаги словами от ER к VLA. Вектор и токены учатся вместе с быстрой системой и понятны только ей. Слова может прочитать человек и любая VLA — поэтому ER 2 и обещает работать с «любой VLA нижнего уровня».

Helix 2.5 (Figure, сентябрь 2026) предобучили на Index — наборе записей поведения людей, начав со случайных весов. В 30 домах, где не собрали ни одной записи, политика с таким предобучением справилась в 56% попыток, а без него — в 9%; подробнее — в уроке 3.8. Об устройстве уровней в объявлении не сказано. GR00T N1.6 (веса открыты в декабре 2025, 3 млрд параметров) взяла внутренний вариант модели зрения и языка Cosmos-Reason-2B, которую NVIDIA учила и на задачах воплощённого рассуждения, сделала DiT вдвое больше, чем в N1.5, — 32 слоя вместо 16 — и разморозила 4 верхних слоя модели зрения и языка при предобучении. На RTX 4090 с 4 шагами flow она строит пачку за 44 мс: 25 мс уходит на модель зрения и языка, 17 мс — на голову действий. GR00T N1.7 перешла на Cosmos-Reason2 и открытую лицензию Apache 2.0. Gemini Robotics 2 ведёт всё тело гуманоида, а ER 2 планирует над ней.

Остаётся вопрос, на котором держится вся часть 3: насколько хорошо такие модели обобщают на новые дома и задачи. В π0.5 от Physical Intelligence та же модель сначала говорит словами подзадачу, а потом выполняет её экспертом действий: оба уровня живут внутри одной сети. Как учить модель на разнородных данных, чтобы она справлялась в домах, где её не учили, и как ей учиться на своих ошибках? Об этом урок 3.8.

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

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

7 Итог

Итоги урока

Большая модель зрения и языка думает 1–10 раз в секунду, а гуманоиду нужны команды 200 раз в секунду. Пачка делает команды частыми, но не свежими. Задержка — время от кадра до первой команды по нему, возраст данных — время от кадра до команды, которая исполняется сейчас. При 7 Гц задержка — 143 мс, а возраст данных растёт от 143 до 286 мс; в облаке оба больше на время сети.
Двухуровневая система делит работу: медленная система понимает сцену и просьбу, быстрая ведёт руки по свежим кадрам. Они работают асинхронно, и в каждом такте быстрая берёт последний ответ медленной.
Точность руки задаёт быстрая система, а реакцию на новую просьбу — медленная: до её периода плюс время вывода плюс сеть. На руке Ады при 7 Гц обе руки повернули к новой чашке через 0,24 с.
Helix передаёт один латентный вектор от модели на 7 млрд параметров (7–9 Гц) к политике на 80 млн (200 Гц). GR00T N1 передаёт токены 12-го слоя, которые DiT читает cross-attention: 10 Гц и 120 Гц, пачка из 16 действий за 63,9 мс. Обе пары обучают вместе.
В Helix 02 появился третий уровень S0: нейросеть на 10 млн параметров, 1000 раз в секунду, обученная в симуляции. Она держит равновесие всего тела и заменила 109 504 строки C++.
Gemini Robotics держит основу в облаке (ответ быстрее 160 мс, около 250 мс до пачки) и декодер на роботе. Оркестратор Gemini Robotics-ER планирует шаги, вызывает инструменты и передаёт шаги VLA словами.

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

Почему бы не сделать быструю систему умнее и обойтись без медленной?

Такт быстрой системы — 5 мс на встроенной видеокарте, и в этот бюджет помещается сеть на 80 млн параметров, но не на 7 млрд. А знание о незнакомых предметах и словах приходит из предобучения на данных из интернета, которое держат только большие модели. Граница двигается: GR00T N1.6 на настольной RTX 4090 тратит на модель зрения и языка 25 мс, всё ещё в пять раз больше такта Helix. Другой путь — оставить одну сеть, но поделить её работу по частотам внутри, как эксперт действий в π0 из урока 3.6.

Кто должен остановить робота, если рядом человек: медленная система или быстрая?

Google пишет, что ER 2 останавливает гуманоида, когда рядом человек, и отвечает быстрее секунды. Чтобы понять ситуацию, этого достаточно, а чтобы избежать удара — нет: за полсекунды рука на 0,6 м/с проходит 30 см. Поэтому решение «остановиться» может принимать верхний уровень, а ограничения силы, скорости и аварийную остановку держат на нижних уровнях, которые работают сотни и тысячи раз в секунду, как регуляторы из урока 0.3.

Гид по статье

NVIDIA, «GR00T N1: An Open Foundation Model for Generalist Humanoid Robots», 2025.

Читать внимательноРаздел 2.1 и рисунок 3: System 2 и System 1, признаки 12-го слоя, cross-attention, K = 4. Таблицы 2 и 3: результаты в симуляции и на настоящем GR-1 при 10% и 100% данных.
Можно пропуститьРаздел 3 с перечнем наборов данных и приложения с гиперпараметрами обучения.
Вопрос по ходуПочему признаки среднего слоя языковой модели работают лучше последнего? Чему учится последний слой языковой модели и что из этого политике не нужно?

Gemini Robotics Team, «Gemini Robotics: Bringing AI into the Physical World», 2025 — облачная основа и декодер на роботе (раздел 3.1), Gemini Robotics-ER и управление через код (раздел 2.3).

Материалы

HelixБлог Figure, февраль 2025: S2 и S1, латентный вектор, асинхронная работа
Helix 02Блог Figure, январь 2026: уровень S0 и посудомойка
GR00T N1.6Карточка модели и веса на Hugging Face
Isaac-GR00TКод дообучения и вывода, время вывода на разных видеокартах
Gemini Robotics 1.5Блог DeepMind, сентябрь 2025: оркестратор ER 1.5 и VLA
Gemini Robotics 2Блог DeepMind, июль 2026: VLA для всего тела гуманоида
Gemini Robotics ER 2Блог Google, июль 2026: видео, планирование, вызов любой VLA

➡️

Дальше: 3.8 «Обобщение и рассуждение: от π0.5 до π0.7». В этом уроке модели делили по частоте: медленная понимает, быстрая двигает. В следующем — модели Physical Intelligence, которые учатся на разнородных данных, сами говорят подзадачи словами, учатся на своём опыте и слушаются подсказок. Перейти к уроку 3.8 →

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

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

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