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

π0: модель зрения и языка выдаёт плавные движения

В уроке 3.5 OpenVLA выдавала действие словами: каждое из семи чисел действия — номер одной из 256 корзин, около шести действий в секунду. Складывать бельё или собирать коробку так не получится: руки двурукого робота получают команды 50 раз в секунду, и движение должно быть плавным. π0 (Physical Intelligence, 2024) оставляет модель зрения и языка PaliGemma на 3 млрд параметров и добавляет к ней эксперт действий — вторую, меньшую группу весов на 300 млн параметров. Эксперт строит пачку из 50 непрерывных действий методом flow matching: за десять шагов flow превращает шум в движение. Модель учили в два этапа: сначала на более чем 10 тысячах часов записей с 7 конфигураций роботов в 68 задачах, потом на отобранных записях конкретных задач — сложить бельё, собрать коробку, убрать со стола. Разберём, как устроена π0, почему пачка точнее команд-токенов, зачем нужны оба этапа обучения и как те же авторы потом сжали пачку в несколько токенов.

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

ЖЕЛОБОКПроведи фигурку по узкому S-образному желобку двумя моделями: одна командует раз в треть секунды, другая выдаёт сразу 50 движений

ДВА ЭТАПАСравни модель, обученную на одной записи задачи, с моделью, которая сначала училась на других задачах стола

СЖАТИЕРазложи пачку движений на плавные составляющие и посчитай, сколько чисел от неё нужно оставить

ЗАДАЧИРазложи задачи из статьи по тому, встречались ли они модели до дообучения

Начать урок ↓

1 Токены

Почему действия-токены не годятся для тонких движений

В уроке 3.5 OpenVLA выдавала действие так же, как текст. Каждое из семи чисел действия делили на 256 корзин, и модель называла номер корзины токеном, по одному токену за проход. На видеокарте RTX 4090 это около 6 действий в секунду. RT-2 из урока 3.3 с моделью на 55 млрд параметров успевала 1–3 действия в секунду, а с моделью на 5 млрд — около 5.

Для того чтобы переставить кубик или открыть ящик, этого хватало. Складывание белья и сборка коробки — тонкие задачи: захваты двигаются быстро и плавно, а ошибку надо исправлять сразу, пока ткань не соскользнула. Двурукие роботы Physical Intelligence получают команды 50 раз в секунду. Если отдавать их токенами, секунда движения двурукого робота с 14 числами в действии — это 50 × 14 = 700 токенов: так посчитали в статье FAST, о которой речь пойдёт ниже.

Есть и вторая беда. При частоте 50 Гц соседние действия почти одинаковые, и следующий токен легко угадать: достаточно повторить предыдущий. Авторы FAST показали это на простом примере: чем чаще дискретизирована траектория, тем хуже учится модель с корзинами, и в конце концов она просто повторяет первое действие.

Выход уже встречался в уроке 1.7: пачка действий (action chunk) — модель за один вывод выдаёт сразу несколько будущих действий. Пачку непрерывных действий умеет строить flow matching. В уроке 1.8 его разбирали на точках плоскости: сеть за несколько шагов превращала шум в данные. Здесь тот же метод строит пачку движений; как он работает, разберём в следующем разделе. Осталось соединить такую голову с моделью зрения и языка, которая понимает картинку и команду. Как это сделать и не испортить то, что модель знает о мире?

2 Устройство

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

π0 построена на PaliGemma — открытой модели зрения и языка (VLM) на 3 млрд параметров. На вход приходят две-три картинки с камер, команда текстом, например «сложи футболку», и состояние робота — углы суставов. Картинки и состояние переводятся в векторы той же длины, что у токенов слов, и дальше трансформер обрабатывает их одной последовательностью.

Действия выдаёт эксперт действий (action expert) — вторая, меньшая группа весов того же трансформера, около 300 млн параметров. Токены картинок и текста проходят через веса PaliGemma, а токены состояния и действий — через веса эксперта. Встречаются две группы весов только во внимании: токены действий читают картинки и текст, как в одном общем трансформере. Авторы сравнивают это со смесью экспертов из двух элементов и пишут, что отдельные веса для токенов робота заметно улучшили результат. Всего в модели 3,3 млрд параметров.

Маска внимания делит последовательность на три блока: картинки и текст, состояние, действия. Внутри блока токены видят друг друга, а из блока в блок внимание идёт только назад. Картинки и текст не смотрят на новые для VLM входы робота — так она меньше уходит от того, чему её учили на данных из интернета. Состояние вынесено в свой блок, потому что не меняется, пока строится пачка, и его ключи и значения можно держать в кэше, как в уроке 1.6.

Пачка — 50 действий. На роботах, которые получают команды 50 раз в секунду, это одна секунда движения. Робот исполняет первые 25 действий и за следующие 0,5 с получает новую пачку. Действие — вектор из 18 чисел: две руки по шесть суставов, два захвата, мобильная база и подъёмный торс. У однорукого робота лишние числа заполняют нулями, а недостающие камеры закрывают маской.

Строит пачку эксперт методом flow matching. Вначале пачка — чистый шум: 50 × 18 случайных чисел. Эксперт смотрит на шумную пачку, на картинки и команду и на время $\tau$ — какую часть пути от шума уже прошли, от 0 до 1, — и для каждого числа пачки предсказывает скорость: куда и насколько быстро его сдвигать, чтобы шум превратился в движение. Такое правило — по любой шумной пачке сказать, куда её двигать, — называют полем скоростей.

Шаг Эйлера — сдвинуть каждое число на его скорость, умноженную на длину шага. π0 делает 10 шагов flow длиной 0,1: после каждого эксперт заново смотрит на сдвинутую пачку и предсказывает новые скорости, и к десятому шагу шум становится плавной траекторией — на схеме ниже это видно на графике пачки. Учат эксперта на записях: берут настоящую пачку и случайный шум, смешивают их в случайной пропорции, и правильный ответ — скорость движения по прямой от шума к пачке, то есть разность пачки и шума. Это обычная регрессия.

Путь данных за один вывод π0. Синим — токены картинок и состояния (то, что измерено), серым — токены команды, оранжевым — эксперт действий и токены действий. Картинки и текст проходят через PaliGemma один раз и лежат в кэше, эксперт действий проходит по 50 токенам действий десять раз, по разу на шаг flow. Штрихи у точек пачки показывают, куда каждая сдвинется на следующем шаге: на скорость, умноженную на 0,1. Нажми на схему, чтобы остановить её.

Десять шагов flow дешёвые: эксперт в десять раз меньше VLM, а картинки и текст считаются один раз за пачку. На RTX 4090 с тремя камерами вывод занимает 73 мс: 14 мс на энкодеры картинок, 32 мс на проход по картинкам и тексту и 27 мс на все 10 шагов flow. Если модель работает не на роботе, а на сервере, добавляется 13 мс сети.

Под капотом: цель обучения, выбор времени τ и вход эксперта

Пусть $A_t = [a_t, \dots, a_{t+H-1}]$ — пачка из $H = 50$ действий, $o_t$ — наблюдение: картинки, команда и состояние. Время flow matching статья обозначает $\tau \in [0, 1]$ , шум — при $\tau = 0$ , как в уроке 1.8. Шумная пачка и цель обучения:

\begin{gathered} A^\tau = \tau A + (1 - \tau)\,\varepsilon, \quad \varepsilon \sim \mathcal N(0, I),\\ L(\theta) = \mathbb E\,\bigl\lVert v_\theta(A^\tau, o) - (A - \varepsilon) \bigr\rVert^2. \end{gathered}

При выводе — 10 шагов Эйлера от чистого шума: $A^{\tau+\delta} = A^\tau + \delta\, v_\theta(A^\tau, o)$ , $\delta = 0{,}1$ . В версиях статьи 2024 года цель записана как $\varepsilon - A$ ; в версии от января 2026 года знак исправлен. В коде openpi шум, наоборот, стоит при $t = 1$ — об этом врезка в уроке 1.8.

Время $\tau$ при обучении берут не равномерно. Авторы рассуждают так: по подписи легко угадать среднюю картинку, а по наблюдению робота угадать среднее действие трудно, потому что наблюдение почти однозначно задаёт, что делать. Поэтому чаще берут шумные моменты, малые $\tau$ :

\tfrac{s - \tau}{s} \sim \mathrm{Beta}(1{,}5;\ 1), \quad s = 0{,}999.

Моменты выше $s$ не нужны, пока шаг интегрирования больше $1 - s$ , то есть до тысячи шагов Эйлера. Каждое шумное действие эксперт получает вместе со временем: $W_3\cdot\operatorname{swish}\bigl(W_2\cdot[\,W_1 a^\tau,\ \varphi(\tau)\,]\bigr)$ , где $\varphi$ — синусоидальное кодирование, как позиции в трансформере. Ширина эксперта 1024 против 2048 у Gemma 2B, внутренний слой MLP — 4096 против 16 384; 18 слоёв и одна голова для ключей и значений у них одинаковые.

Для сравнения авторы обучили и π0-small на 470 млн параметров без VLM: язык кодирует DistilBERT, картинки — небольшой ViT, эксперт читает наблюдение кросс-вниманием. Он тоже делает 10 шагов flow matching.

Архитектура — половина метода. Вторая половина — на каких данных и в каком порядке модель учили.

3 Данные

Сначала много разных записей, потом немного аккуратных

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

Предобучение (pre-training) — обучение на большом и разнообразном наборе, где задача не одна. У π0 это больше 10 тысяч часов собственных записей Physical Intelligence: 903 млн шагов управления, из них 797 млн с двуруких роботов. Записи сделаны на 7 конфигурациях роботов — одна и две руки UR5e, Franka, двурукие Trossen и ARX, мобильные платформы — в 68 задачах. Задача тут широкая: «уборка стола» включает десятки разных тарелок, чашек, приборов и мусора. Ещё 9,1% смеси — открытые наборы OXE, Bridge v2 и DROID из урока 3.4, где роботы получают команды от 2 до 10 раз в секунду. Каждое сочетание «задача — робот» входит в смесь с весом $n^{0{,}43}$ от числа примеров $n$ , чтобы складывание белья, которого записано больше всего, не заслонило остальное.

Постобучение (post-training) — дообучение уже обученной модели на записях одной задачи: от 5 часов для самых простых до 100 и больше для самых сложных. Эти записи отбирают: оператор, человек, который ведёт робота, действует аккуратно и одной стратегией. Авторы объясняют, зачем нужны оба этапа. В аккуратных записях почти нет ошибок, и модель, обученная только на них, хрупкая: она не умеет исправляться. Разнообразные записи хуже по качеству, зато в них есть ошибки и исправления. Предобучение даёт запас исправлений, постобучение учит делать задачу хорошо.

Команду тоже можно разбить на части. Для уборки стола авторы ставили над π0 высокоуровневую VLM, которая говорит подзадачи словами: «возьми салфетку», «выбрось салфетку», — как языковая модель в SayCan из урока 2.3. π0 исполняет каждую подзадачу как отдельную команду.

Проверим обе идеи на столе Ады: сначала пачку против команд-токенов, потом предобучение против обучения на одной задаче.

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

Команды-токены и пачка на узком желобке

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

Ада держит захватом фигурку и ведёт её по узкому желобку в форме буквы S, а в конце вставляет в гнездо. От середины желобка до стенки у фигурки 2,75 условных пикселя с каждой стороны, а пиксель здесь — около 5 мм. Задела стенку — попытка провалена. В гнездо фигурку вводят медленно: если она войдёт быстрее 0,5 пикселя за такт, то ударится и отскочит. Срок — в 1,3 раза дольше, чем у оператора. Такт управления — 20 мс, 50 команд в секунду, как у двуруких роботов π0.

Картинку модели здесь не разбирают. Модель получает то, что выделил бы по картинке детектор: семь точек середины желобка впереди фигурки, сколько осталось до конца и команду. Обе модели учатся на одних и тех же 24 записях оператора, сделанных на 24 разных желобках.

Модель A устроена как OpenVLA и RT-2: раз в 17 тактов, то есть 0,34 с, около трёх раз в секунду, она называет двумя токенами по 256 корзин, куда сдвинуть фигурку за это время, сначала вдоль желобка, потом поперёк, и Ада ведёт фигурку туда по прямой. Модель B устроена как π0: эксперт действий за 10 шагов Эйлера строит пачку из 50 смещений фигурки, по одному на такт; Ада исполняет 25 и просит новую пачку. Обе модели — маленькие сети, они обучаются здесь же, в браузере, за несколько секунд.

Модель A: токеныкоманда раз в 0,34 с

Модель B: пачка50 смещений за вывод

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

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

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

Сцена1 Темп A1

Модели

Под капотом: что видят модели, как они учатся и где мы упростили π0

Наблюдение. Семь точек середины желобка на 4, 8, 13, 19, 26, 34 и 44 пикселя пути впереди фигурки, остаток пути до конца и команда. Точки записаны в осях, повёрнутых по желобку у фигурки: одна ось вдоль него, другая поперёк, как у камеры на запястье. От команды у нас остаётся одно число: 1 — «вставь в гнездо», 0 — «доведи до предмета». В π0 команду читает языковая модель.

Модель A. Две сети по 48 нейронов в двух слоях, на выходе у каждой 256 корзин на ±36 пикселей, шаг корзины около 0,3 пикселя. Первая называет корзину сдвига вдоль желобка, вторая — поперёк, зная первый ответ; учатся они по перекрёстной энтропии, как классификатор, с метками, слегка размытыми по соседним корзинам. Темп — ещё один вход: при темпе 0,7 модель называет, куда оператор сдвинул фигурку за 0,7 × 17 ≈ 12 тактов, а Ада едет туда те же 17 тактов, то есть медленнее. Декодирование жадное: берётся самая вероятная корзина.

Модель B. Сеть 64 × 64 по наблюдению, шумной пачке и времени $\tau$ оценивает итоговую пачку $\hat x$ , а скорость считается из неё:

\begin{gathered} v = \frac{\hat x - x_\tau}{1 - \tau}, \qquad x_{\tau + 0{,}1} = x_\tau + 0{,}1\, v. \end{gathered}

Учим по ошибке $\lVert \hat x - x_1 \rVert^2$ — это та же цель flow matching $\lVert v - (x_1 - x_0)\rVert^2$ , умноженная на $(1 - \tau)^2$ . В π0 сеть предсказывает скорость напрямую. Ещё одно упрощение: наша сеть выдаёт пачку не сотней чисел, а восемью коэффициентами косинусного разложения на ось, о нём — в следующем интерактиве. Плавной пачке их хватает, а маленькой сети так проще учиться. Время $\tau$ берётся, как в π0, из бета-распределения, только с $s = 0{,}9$ : при 10 шагах flow моменты выше 0,9 не встречаются.

Записи. 24 записи желобка аккуратные: оператор начинает точно посередине и ведёт ровно. Для предобучения — 120 записей других задач на том же столе: довести фигурку по S-желобку до кубика, обвести вокруг миски, провести змейкой, довести по прямой. Там оператор начинает чуть сбоку, а по ходу записи фигурку иногда толкают, и он возвращает её на середину, — приём DART из урока 1.1. У предмета оператор тормозит слабо, до 0,4 полной скорости, а в гнездо вставляет медленно, до 0,12.

Обучение. Модель B — 3000 шагов Adam на 24 записях, модель A — 1000 шагов. Предобучение — 6000 шагов на 120 записях, постобучение — ещё 300 шагов с шагом обучения в 6 раз меньше на одной записи желобка. Модель с нуля учится на той же записи 3000 шагов. Результат с одной записью зависит от того, какая это запись: мы повторили опыт на шести разных записях и начальных весах. Предобученная модель прошла в среднем 8,7 сцены из 20, модель с нуля — 4,3. На четырёх наборах из шести выиграла предобученная, на одном они сравнялись, на одном модель с нуля прошла на сцену больше.

Модель A проигрывает не потому, что плохо выучила записи: даже команда, которую дал бы сам оператор, ведёт фигурку по прямой, а прямая срезает изгиб. Чтобы уложиться в стенки, отрезки нужно сделать короче, то есть ехать медленнее или командовать чаще. Медленнее — не успеть в срок, чаще — нельзя: каждое действие стоит нескольких проходов большой модели. Пачка снимает это противоречие: один вывод даёт 50 точек траектории, и между выводами робот едет по кривой. При этом π0 вызывает модель всего два раза в секунду, а не 50.

В статье π0 то же видно на настоящих задачах. Без дообучения, сразу после предобучения, π0 сравнивали с OpenVLA и Octo, обученными на той же смеси данных. OpenVLA, по словам авторов, плохо справлялась, потому что её токены не поддерживают пачки действий. Octo пачки выдаёт, но ей не хватает размера. π0 обошла их на всех пяти задачах, а версия, обученная всего 160 тысяч шагов вместо 700 тысяч, — не больше, чем базовые модели: у OpenVLA 160 тысяч, у Octo 320 тысяч, — тоже обошла все базовые модели. Даже π0-small без VLM оказалась лучше OpenVLA и Octo.

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

🧩 Интерактив

FAST: сжать пачку, прежде чем резать её на токены

Токенов в пачке много, потому что каждое число каждого такта получает свой токен, хотя соседние почти одинаковые. Через два с половиной месяца после π0 те же авторы предложили FAST (Frequency-space Action Sequence Tokenization, Pertsch и соавторы, январь 2025): сначала сжать пачку, как JPEG сжимает картинку, и только потом превращать в токены.

Сжимают дискретным косинусным преобразованием (ДКП, DCT). Оно раскладывает ряд из 50 чисел на сумму 50 косинусов разной частоты: коэффициент при каждом косинусе говорит, сколько его в сигнале. Низкие частоты задают общую форму, высокие — резкие скачки. У плавного движения почти всё сосредоточено в нескольких низких частотах, остальные коэффициенты близки к нулю.

FAST приводит каждое число действия к отрезку от −1 до 1 по 1-му и 99-му процентилю данных, применяет ДКП к каждому числу отдельно, умножает коэффициенты на масштаб $\gamma = 10$ и округляет до целых. Большинство коэффициентов становится нулями. Затем коэффициенты всех чисел выстраивают в ряд, сначала низкие частоты, и алгоритм BPE (byte-pair encoding, тот же, что режет текст на токены в языковых моделях) склеивает нули и частые сочетания в токены. Все эти преобразования обратимы, поэтому из токенов пачку можно восстановить.

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

По горизонтали — номер такта в пачке, от 1 до 50; по вертикали — смещение за такт в пикселях. Серая линия — исходная пачка, оранжевая — восстановленная из оставленных коэффициентов.

Коэффициенты разложения по номеру частоты, от 0 до 49, после умножения на $\gamma$ и округления. Высота столбика — квадратный корень из величины, чтобы были видны и малые. Закрашены оставленные, контуром — отброшенные; синие — вдоль желобка, фиолетовые — поперёк; пунктир — граница k.

Коэффициентов на ось, k50

Масштаб γ

Под капотом: формулы ДКП и что делает BPE

Для ряда $x_0, \dots, x_{N-1}$ , $N = 50$ , коэффициенты ДКП-II и обратное преобразование:

\begin{gathered} C_j = \alpha_j \sum_{n=0}^{N-1} x_n \cos\Bigl(\tfrac{\pi}{N}\bigl(n + \tfrac12\bigr) j\Bigr),\\ x_n = \sum_{j=0}^{N-1} \alpha_j\, C_j \cos\Bigl(\tfrac{\pi}{N}\bigl(n + \tfrac12\bigr) j\Bigr),\\ \alpha_0 = \sqrt{1/N}, \quad \alpha_{j>0} = \sqrt{2/N}. \end{gathered}

FAST квантует $\bar C_j = \operatorname{round}(\gamma\, C_j)$ . Ошибка округления каждого коэффициента — до $1/(2\gamma)$ , поэтому малый $\gamma$ сжимает сильнее, но грубее. Гиперпараметров у токенизатора два: $\gamma = 10$ и размер словаря BPE 1024; авторы пишут, что оба не слишком чувствительны. У нас округлённые коэффициенты — это и есть «токены» до BPE, поэтому считаем их число как $k$ на ось. Ошибку меряем по положению: смещения складываются, и восстановленный путь фигурки сравнивается с исходным.

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

Универсальный токенизатор FAST+ обучен примерно на миллионе секундных пачек разных роботов. На новых наборах данных, которых он не видел, он уменьшает число токенов действий как минимум вдвое.

В статье FAST сжатие посчитано для секундных пачек. У Bridge V2 (7 чисел, 5 Гц) вместо 35 токенов при корзинах выходит 20, у DROID (7 чисел, 15 Гц) — 29 вместо 105, у уборки стола (7 чисел, 20 Гц) — 28 вместо 140, у складывания футболки (14 чисел, 50 Гц) — 53 вместо 700, в 13,2 раза меньше. FAST даёт примерно 30 токенов на руку за секунду независимо от частоты: столько информации в самом движении. С корзинами модели на задачах с 20 и 50 Гц вообще не продвинулись, с FAST — научились.

π0-FAST — та же π0, но действия она выдаёт токенами FAST, авторегрессией, без эксперта. На всей смеси данных π0 она сравнялась с π0, в том числе на складывании белья, а обучение заняло в 5 раз меньше часов на видеокартах. Цена — вывод. По статье FAST, π0 обычно укладывается с секундной пачкой в 100 мс на RTX 4090 (замер из статьи π0, приведённый выше, — 73 мс), а π0-FAST тратит около 750 мс. Ей нужно по одному декодировать 30–60 токенов действий, и делает это вся языковая модель внутри PaliGemma — Gemma на 2 млрд параметров из её 3 млрд, а у π0 за 10 шагов flow проходит только эксперт на 300 млн. На неподвижных задачах из статьи это не мешало, но для быстрых, динамичных задач авторы называют медленный вывод одним из нынешних ограничений.

Итак, π0 и π0-FAST справляются со сложными задачами. С какими именно — и какие из них модель видела до дообучения?

🧩 Интерактив

Задачи π0: что модель видела при предобучении

В лаборатории предобучение помогло задаче, похожей на задачи предобучения. В статье π0 проверяли больше 20 задач, и авторы сами делят их по тому, насколько они знакомы модели. Одни были в смеси предобучения целиком, другие похожи на что-то из неё, третьих там нет совсем: новые предметы, новые движения, задача, которой у этого робота в предобучении не было.

Разложи задачи из статьи по трём корзинам. Перетащи карточку или нажми её, а потом корзину.

Числа в статье даны на графиках, а в тексте авторы описывают их словами. Задачи с дообучением на 1, 5 и 10 часах записей π0 обычно решала лучше остальных. Самыми сильными из прежних методов оказались ACT и Diffusion Policy, обученные с нуля только на записях задачи, — открытые предобученные OpenVLA и Octo после дообучения были заметно слабее. На задаче с микроволновкой π0 после 5 часов записей была на уровне базовых методов, а после 1 часа — заметно лучше. Предобучение сильнее помогает на задачах, похожих на задачи предобучения, а в некоторых задачах поднимает результат вдвое.

Самые сложные задачи — складывание белья из корзины, сборка коробки, уборка обеденного стола, упаковка яиц — длятся от 5 до 20 минут. Полная π0 с предобучением и постобучением набрала больше половины максимального балла на всех. Модели без предобучения и без постобучения справлялись хуже, а другими методами авторы эти задачи не решили вовсе. Следовать командам π0 тоже научилась лучше, чем π0-small: промежуточные команды человека и высокоуровневой VLM поднимали её результат, а π0-small от подсказок VLM почти ничего не выигрывала.

4 Сегодня

Пачки на 50 Гц стали нормой

Код π0 открыт: реализация π0 и π0.5 лежит в репозитории openpi на GitHub — та самая, где шум стоит при $t = 1$ , как во врезке урока 1.8. Схема «модель зрения и языка плюс эксперт действий на flow matching» прижилась. π0.5 (2025) оставила эксперт на 300 млн параметров и 10 шагов flow, а добавила обучение на разнородных данных и подзадачи, которые модель сама говорит словами, — об этом урок 3.8. В π0.7 (2026) эксперт вырос до 860 млн параметров при модели на 5 млрд, пачка по-прежнему из 50 действий, а шагов flow стало 5. Роботы, которые получают команды 50 раз в секунду, для этих моделей — обычное дело.

Токены тоже не ушли: FAST показал, что после сжатия они учатся быстро и не уступают пачкам по качеству, если робот не спешит. А в уроке 1.8 голова на flow matching у GR00T N1 строила пачку из 16 действий за 4 шага flow.

Но у π0 одна модель и думает, и двигает руками, и работает она с одной частотой. Большая модель зрения и языка медленная, а руке нужны свежие команды каждые несколько миллисекунд. Что, если разделить модель на две части с разными частотами — медленную, которая понимает сцену, и быструю, которая ведёт руку? Об этом урок 3.7: Helix, GR00T N1 и Gemini Robotics.

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

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

6 Итог

Итоги урока

Действия-токены дорогие и грубые: одно действие — несколько проходов большой модели, 1–6 действий в секунду. На частых данных соседние токены почти одинаковые, и модель учится их просто повторять.
π0 — PaliGemma на 3 млрд параметров и эксперт действий на 300 млн в одном трансформере: у токенов робота свои веса, но внимание общее. Блочная маска позволяет посчитать картинки и текст один раз и держать их в кэше.
Эксперт предсказывает поле скоростей и за 10 шагов Эйлера сдвигает шум в пачку из 50 действий до 18 чисел каждое — это flow matching. Вывод на RTX 4090 занимает 73 мс; робот исполняет 25 действий и раз в 0,5 с получает новую пачку, так команды идут 50 раз в секунду.
На узком желобке прямые отрезки команд-токенов срезают изгиб: быстро — задевают стенку, медленно — не успевают. Пачка ведёт фигурку по кривой.
Рецепт из двух этапов: предобучение на более чем 10 тысячах часов с 7 конфигураций роботов в 68 задачах и открытых наборах, затем постобучение на 5–100 с лишним часах отобранных записей задачи. Разнообразные данные дают исправления, аккуратные — качество.
FAST сжимает пачку косинусным преобразованием, округлением и BPE: секунда складывания футболки — 53 токена вместо 700. π0-FAST учится в 5 раз быстрее π0, но на пачку тратит около 750 мс, а π0 укладывается в 100 мс.

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

Робот исполняет пачку полсекунды вслепую. Что, если за это время сцена изменилась?

В π0 пачку исполняют без обратной связи: усреднение соседних пачек, temporal ensembling из урока 1.7, авторы пробовали, и оно ухудшило результат. Можно исполнять меньше действий и чаще звать модель, но каждый вывод стоит 73 мс. В лаборатории видно и второе следствие: на стыке пачек скорость скачет, потому что новая пачка не обязана продолжать старую. Склейку пачек, которые строятся, пока исполняется предыдущая, разбирали в уроке 1.7 — это real-time chunking тех же авторов.

Почему бы не сделать эксперт действий таким же большим, как VLM?

Эксперт проходит по токенам действий на каждом из 10 шагов flow, а VLM по картинкам и тексту — один раз. Большой эксперт умножил бы на 10 самую дорогую часть вывода. Поэтому в π0 эксперт вдвое уже по ширине и вчетверо уже во внутреннем слое. В π0.7 эксперт вырос до 860 млн параметров, но шагов flow стало вдвое меньше — 5: рост эксперта оплатили числом шагов flow.

Гид по статье

K. Black и соавторы, «π0: A Vision-Language-Action Flow Model for General Robot Control», Physical Intelligence, 2024.

Читать внимательноРаздел IV и приложение B: два эксперта, блочная маска, вход времени τ и почему τ берут ближе к шуму. Раздел V-A: состав смеси данных и веса n^0,43. Приложение D и таблица I: из чего складываются 73 мс.
Можно пропуститьПриложение E с правилами подсчёта баллов в каждой задаче и приложение A со вкладом авторов.
Вопрос по ходуПочему состояние робота вынесено в отдельный блок маски, а не стоит вместе с действиями? Что пришлось бы пересчитывать на каждом из 10 шагов flow, если бы оно видело шумные действия?

K. Pertsch, K. Stachowicz и соавторы, «FAST: Efficient Action Tokenization for Vision-Language-Action Models», 2025 — сжатие пачки косинусным преобразованием и BPE, π0-FAST.

Материалы

Блог π0Видео складывания белья, сборки коробки и уборки стола
openpiКод π0 и π0.5
FASTСтраница проекта
Токенизатор FAST+Универсальный токенизатор действий, три строки кода
PaliGemmaМодель зрения и языка, на которой построена π0

➡️

Дальше: 3.7 «Двухуровневые архитектуры: Helix, GR00T, Gemini Robotics». У π0 одна модель и понимает сцену, и ведёт руки. В следующем уроке модель делят на две части с разными частотами: медленная большая модель думает, быстрая маленькая двигает. Перейти к уроку 3.7 →

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

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

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