Como Treinar Pi0.5 com Seus Próprios Dados de Robô

Pi0.5 é o modelo a ser usado quando uma política precisa funcionar em um ambiente que nunca viu. É também a mais complicada das cinco políticas treináveis aqui para fazer fine-tuning manualmente: o repositório upstream é JAX primeiro, a porta LeRobot moveu a implantação para fora do lerobot-record na versão 0.6.0 e tornou a instalação base muito pequena para treinar, e um fine-tuning completo não cabe em uma 4090. Abaixo: o que correspondência de fluxo custa na inferência, as duas rotas de comando e o número de 485 ms que decide se o resultado é utilizável.

O que Pi0.5 realmente é

Physical Intelligence publicou pi0 em outubro de 2024: um modelo de correspondência de fluxo de visão-linguagem-ação em um VLM pré-treinado: PaliGemma com 3 bilhões de parâmetros mais um especialista em ação de 300M inicializado do zero, 3,3 bilhões no total. O artigo relata o pré-treinamento em mais de 10.000 horas de dados de robôs em 7 configurações de robôs e 68 tarefas. Mais em o artigo sobre pi0.

Pi0.5 (arXiv 2504.16054, 22 de abril de 2025) mantém esse esqueleto e muda a dieta de treinamento: dados da web, detecção de objetos, instruções verbais de humanos treinando o robô, rótulos de subtarefas, dados de múltiplas encarnações de robôs em muitas casas. O resultado é um robô limpando cozinhas em casas que não estavam no conjunto de treinamento. O README do openpi adiciona um detalhe que o título não menciona: o pi0.5 lançado foi treinado com isolamento de conhecimento (arXiv 2505.23705).

O que a correspondência de fluxo muda no treinamento e inferência

Uma política que você pode treinar em um SO-100 ou regride ações diretamente (ACT) ou as tokeniza e decodifica autoregressivamente (pi0-FAST). O flow matching não faz nenhum dos dois: ele aprende um campo vetorial que transporta ruído para um chunk de ação limpo, e então o integra. O artigo pi0 usa 10 passos de integração com tamanho de passo 0.1; a configuração pi05 do LeRobot mantém o mesmo `num_inference_steps: int = 10`.

• Treinamento: a perda regride um chunk de ação ruidoso. Nenhum tokenizador para ajustar, nenhuma discretização dos seus ângulos de junta.
• Inferência: um chunk custa dez passagens para frente através do especialista em ação. Isso é estrutural, não um problema de ajuste.
• Saída: ações contínuas de dimensão 32, preenchidas internamente, perda calculada nas dimensões que seu robô possui. Um braço de 6-DoF mais garra usa 7.

# openpi/src/openpi/models/pi0_config.py - the defaults every pi05 config inherits
@dataclasses.dataclass(frozen=True)
class Pi0Config(_model.BaseModelConfig):
    dtype: str = "bfloat16"
    paligemma_variant: _gemma.Variant = "gemma_2b"
    action_expert_variant: _gemma.Variant = "gemma_300m"

    action_dim: int = 32
    action_horizon: int = 50
    max_token_len: int = None      # 200 if pi05 else 48

    pi05: bool = False             # flips discrete_state_input to True

O backbone PaliGemma, e o portão à sua frente

PaliGemma (arXiv 2407.07726) é um codificador de visão SigLIP-So400m em um modelo de linguagem Gemma-2B, com cerca de 3B de parâmetros. Pi0.5 herda seu tokenizador, e esse tokenizador reside em um repositório restrito. Esta é a forma mais comum de uma primeira execução falhar, antes do primeiro passo de treinamento.

Antes de começar: formato do conjunto de dados, episódios, hardware

Pi0.5 no LeRobot lê um conjunto de dados LeRobot no layout v3.0, que foi lançado com o lerobot 0.4.0 em outubro de 2025: muitos episódios por arquivo Parquet e MP4 em vez de um arquivo por episódio, com limites em meta/episodes/ em vez de nomes de arquivo. Grave com o cliente de desktop ou siga grave seu primeiro conjunto de dados e você o terá.

# v2.1 -> v3.0, run against a dataset already on the Hub
python -m lerobot.scripts.convert_dataset_v21_to_v30 --repo-id=<HF_USER/DATASET_ID>

# aggregates episode-0000.parquet, episode-0001.parquet, ... -> file-0000.parquet
# aggregates episode-0000.mp4, episode-0001.mp4, ...         -> file-0000.mp4
# rewrites meta/episodes/* with per-episode lengths, tasks and offsets

A plataforma exige pelo menos 50 episódios para Pi0.5, o mesmo mínimo que GR00T e ACT. O pré-treinamento faz o trabalho pesado, então 50 episódios limpos superam 200 desleixados. Novo nisso? Comece com o guia de coleta de dados.

Rota A: ajuste fino com o repositório openpi

A implementação de referência: JAX primeiro, testada apenas no Ubuntu 22.04, impulsionada por objetos de configuração em vez de flags. Um caminho para PyTorch chegou em setembro de 2025, validado no LIBERO. Três etapas: converta seus dados, defina uma configuração, treine e sirva.

1. 1
   Clonar e instalar

   openpi usa uv. GIT_LFS_SKIP_SMUDGE é o que permite que LeRobot seja uma dependência sem blobs LFS.

   bash

   git clone --recurse-submodules git@github.com:Physical-Intelligence/openpi.git
   cd openpi
   
   GIT_LFS_SKIP_SMUDGE=1 uv sync
   GIT_LFS_SKIP_SMUDGE=1 uv pip install -e .

2. 2
   Converter seus dados para um conjunto de dados LeRobot

   O upstream fornece conversores para LIBERO e DROID e espera que você adapte um. O trabalho é o mapeamento de chaves.

   bash

   uv run examples/libero/convert_libero_data_to_lerobot.py --data_dir /path/to/your/data

3. 3
   Adicionar uma configuração de treinamento

   As configurações são entradas TrainConfig em src/openpi/training/config.py. Esta adapta pi05_droid_finetune, com o carregador de pesos apontado para pi05_base.

   python

   TrainConfig(
       name="pi05_so100",
       model=pi0_config.Pi0Config(
           pi05=True,
           action_dim=32,        # pi05 is trained with 32-dim actions
           action_horizon=16,
       ),
       # Copy LeRobotLiberoDataConfig in the same file and rewrite the key
       # mapping for your camera names, then reference your copy here.
       data=LeRobotLiberoDataConfig(
           repo_id="your_hf_username/my_so100_dataset",
           base_config=DataConfig(prompt_from_task=True),
       ),
       weight_loader=weight_loaders.CheckpointWeightLoader(
           "gs://openpi-assets/checkpoints/pi05_base/params"
       ),
       batch_size=32,
       num_train_steps=20_000,
   )

4. 4
   Calcular estatísticas de normalização

   Executa contra o nome da configuração, não o conjunto de dados. Ignorá-lo é a primeira falha clássica aqui.

   bash

   uv run scripts/compute_norm_stats.py --config-name pi05_so100

5. 5
   Treinar

   A variável permite que o JAX use 90% da memória da GPU em vez dos 75% padrão. Em uma placa de 80 GB, isso decide se a execução sobrevive.

   bash

   XLA_PYTHON_CLIENT_MEM_FRACTION=0.9 uv run scripts/train.py pi05_so100 \
       --exp-name=my_experiment \
       --overwrite

6. 6
   Servir

   O servidor escuta na porta 8000 e responde a consultas de observação; seu tempo de execução do robô é o cliente.

   bash

   uv run scripts/serve_policy.py policy:checkpoint \
       --policy.config=pi05_so100 \
       --policy.dir=checkpoints/pi05_so100/my_experiment/20000

Rota B: ajuste fino com lerobot pi05

A porta LeRobot encapsula os mesmos pesos na CLI que você já usa para ACT e SmolVLA. Tudo abaixo foi verificado com lerobot 0.6.1, a versão desde 3 de agosto de 2026, e a documentação do pi05 em 23 de agosto de 2026. As versões importam aqui: os conjuntos de dados v3.0 chegaram com 0.4.0 em outubro de 2025, o blog 0.5.0 de 9 de março de 2026 apresenta pi0-FAST e Real-Time Chunking, e 0.6.0 em 6 de julho de 2026 tornou o pacote base leve e moveu a implantação para lerobot-rollout.

Uma coisa não mudou: lerobot-train e lerobot-record já eram pontos de entrada em 0.3.2, agosto de 2025. Um tutorial que ainda chama python -m lerobot.scripts.train é anterior a um ano de mudanças e também não é confiável no restante.

1. 1
   Instalar com os extras corretos

   Desde 0.6.0, a instalação base inclui apenas as dependências essenciais de ML, e o extra 'pi' não adiciona código de dataset ou treinamento, então um fine-tune também precisa do extra 'training'. Comandos de uma linha mais antigos falham aqui no momento da importação.

   bash

   # policy dependencies plus the training stack
   pip install 'lerobot[pi,training]'
   
   # from a source checkout
   pip install -e ".[pi,training]"
   
   # driving an SO-100 afterwards needs the robot extras too
   pip install 'lerobot[core_scripts,feetech]'

2. 2
   Autenticar

   Aceite a licença paligemma-3b-pt-224 em um navegador e, em seguida, faça login na máquina que realiza o treinamento.

   bash

   hf auth login

3. 3
   Adicionar estatísticas de quantis

   O Pi0.5 normaliza STATE e ACTION com quantis, então meta/stats.json precisa de q01 e q99. Datasets mais antigos contêm apenas min, max, mean, std.

   bash

   lerobot-edit-dataset \
       --repo_id your_dataset \
       --new_repo_id your_dataset \
       --operation.type recompute_stats \
       --operation.overwrite true

4. 4
   Ajustar a partir de lerobot/pi05_base

   Defina o tamanho do batch para o que sua placa suporta; a documentação usa 64 no LIBERO com 80 GB. Passe bfloat16 explicitamente, o padrão da configuração é float32.

   bash

   lerobot-train \
       --dataset.repo_id=${HF_USER}/my_so100_dataset \
       --policy.type=pi05 \
       --policy.pretrained_path=lerobot/pi05_base \
       --policy.gradient_checkpointing=true \
       --policy.dtype=bfloat16 \
       --policy.device=cuda \
       --policy.push_to_hub=false \
       --output_dir=./outputs/pi05_so100 \
       --job_name=pi05_so100 \
       --batch_size=4 \
       --num_workers=8 \
       --steps=30000 \
       --save_freq=5000 \
       --seed=1000

5. 5
   Executar no braço

   Em 0.6.x, isso é lerobot-rollout: lerobot-record recusa uma política e rejeita nomes de datasets eval_. Base controla o braço, sentry registra o rollout.

   bash

   lerobot-rollout \
       --strategy.type=base \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
       --task="Put lego brick into the transparent box" \
       --duration=60
   
   # same run, recorded into an eval_ dataset
   lerobot-rollout \
       --strategy.type=sentry \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --dataset.repo_id=${HF_USER}/eval_so100 \
       --dataset.single_task="Put lego brick into the transparent box" \
       --duration=600

Três conjuntos de padrões, e quais deles chegam ao treinador

A TrainConfig da openpi é a referência, a PI05Config da LeRobot é o que o lerobot-train usa quando você não especifica nada, e o formulário aqui envia um terceiro conjunto. A surpresa é a taxa de aprendizado: ambos os padrões upstream atingem o pico de 2.5e-5, enquanto a própria configuração pi05_libero da openpi e esta plataforma a elevam para 5e-5.

A portabilidade é fiel? A equipe LeRobot ajustou o modelo base LIBERO por mais 6k passos e comparou com os números de referência da openpi em quatro suítes: 97.5 por cento de média contra 96.85, à frente no Libero 10, atrás no Spatial. A rota é uma escolha de ferramenta, não de qualidade.

A realidade de 485 ms, e onde deixa de ser utilizável

Isso decide o seu projeto, por isso vem antes da tabela de custos. A por passo de ação medida aqui para Pi0.5 é de 485 ms. Contra os outros quatro:

O upstream tem uma resposta, e metade dela já está na versão que você pode instalar. O Real-Time Chunking gera o próximo bloco enquanto o braço ainda está executando o atual, e então guia os passos sobrepostos do novo bloco para permanecerem próximos à parte já executada, para que o braço não pare ou engasgue na junção. A forma de tempo de inferência foi incluída no changelog 0.4.2 para Pi0, Pi0.5 e SmolVLA e é uma flag de rollout, não um retreinamento:

lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USER}/my_policy \
    --inference.type=rtc \
    --inference.rtc.execution_horizon=10 \
    --inference.rtc.max_guidance_weight=10.0 \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
    --task="Put lego brick into the transparent box" \
    --duration=60

Isso não torna o modelo mais rápido. Ele esconde a lacuna: os 485 ms ainda são gastos, mas fora do caminho crítico, para que a fila não se esgote entre os blocos. A variante de tempo de treinamento do arXiv 2512.05964 vai além: o modelo aprende a condicionar-se a um prefixo de ação limpo, de modo que na inferência a sobreposição é preenchida (hard-inpainted) com timesteps de fluxo por ação em vez de guiada, e a passagem de retropropagação da guia desaparece. Durante o treinamento, ele amostra um comprimento de prefixo por exemplo e calcula a perda de fluxo no postfix restante. Essa flag existe apenas na versão principal (main), não na 0.6.1, e o atraso para o qual você treina deve permanecer abaixo de chunk_size.

Duas formas de obter um checkpoint Pi0.5

lerobot-train \
    --dataset.repo_id=${HF_USER}/my_so100_dataset \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.rtc_training_max_delay=10 \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --batch_size=4 --steps=30000 --seed=1000

Quando não funciona

• Conjunto de dados rejeitado: v3 necessário
• Sem memória durante o treinamento
• A perda diminui, mas a política não faz nada
• A política congela no meio do movimento
• A política só funciona em uma configuração
• Tarefa de treinamento presa na fila

Quanto custa uma execução

Pi0.5 está na camada mais cara porque precisa de uma placa de 80 GB, e os preços spot variam, então o valor é uma faixa em vez de um preço. Para muitas tarefas SO-100, treine SmolVLA ou ACT na camada de 24 GB primeiro, confirme se a tarefa é aprendível, e só então dedique horas de A100 a ela. Treine sua primeira política descreve esse ciclo mais barato, e preços contém as camadas atuais.

Antes de dedicar uma noite: GR00T N1.7 contra Pi0.5 e Pi0.5 contra SmolVLA apresentam os mesmos números lado a lado. A Arena contém 85 modelos VLA com 332 resultados de benchmark, cada um ligado à sua fonte, e o histórico da família está em nossa visão geral de VLA.