¿Cómo Entrenar Pi0.5 con tus Propios Datos de Robot?

Pi0.5 es el modelo al que recurrir cuando una política tiene que funcionar en una habitación que nunca ha visto. También es la más complicada de las cinco políticas entrenables aquí para ajustar manualmente: el repositorio upstream prioriza JAX, el puerto de LeRobot movió el despliegue fuera de lerobot-record en la versión 0.6.0 e hizo que la instalación base fuera demasiado pequeña para entrenar, y un ajuste completo no cabe en una 4090. A continuación: lo que la coincidencia de flujo cuesta en inferencia, las dos rutas de comando y el número de 485 ms que decide si el resultado es utilizable.

Qué es realmente Pi0.5

Physical Intelligence publicó pi0 en octubre de 2024: un modelo de visión-lenguaje-acción de coincidencia de flujo basado en un VLM preentrenado: PaliGemma con 3 mil millones de parámetros más un experto en acciones de 300M inicializado desde cero, 3.3 mil millones en total. El artículo informa sobre el preentrenamiento con más de 10,000 horas de datos de robots en 7 configuraciones de robots y 68 tareas. Más información en el artículo de pi0.

Pi0.5 (arXiv 2504.16054, 22 de abril de 2025) mantiene ese esqueleto y cambia la dieta de entrenamiento: datos web, detección de objetos, instrucciones verbales de humanos que entrenan al robot, etiquetas de subtareas, datos de múltiples encarnaciones de robots en muchos hogares. El resultado es un robot limpiando cocinas en casas que no estaban en el conjunto de entrenamiento. El README de openpi añade un detalle que el título no menciona: el pi0.5 lanzado fue entrenado con aislamiento de conocimiento (arXiv 2505.23705).

Qué cambia la coincidencia de flujo en el entrenamiento y la inferencia

Una política que puedes entrenar en un SO-100 o bien regresa acciones directamente (ACT) o las tokeniza y decodifica autorregresivamente (pi0-FAST). El ajuste de flujo no hace ninguna de las dos cosas: aprende un campo vectorial que transporta el ruido a un fragmento de acción, y luego lo integra. El artículo de pi0 utiliza 10 pasos de integración con un tamaño de paso de 0.1; la configuración pi05 de LeRobot mantiene el mismo num_inference_steps: int = 10.

• Entrenamiento: la pérdida regresa un fragmento de acción ruidoso. Sin tokenizador que ajustar, sin discretización de tus ángulos de articulación.
• Inferencia: un fragmento cuesta diez pasadas hacia adelante a través del experto en acciones. Esto es estructural, no un problema de ajuste.
• Salida: acciones continuas de dimensión 32, rellenadas internamente, la pérdida se calcula sobre las dimensiones que tiene tu robot. Un brazo de 6-grados de libertad más pinza utiliza 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

El backbone de PaliGemma, y la puerta delante de él

PaliGemma (arXiv 2407.07726) es un codificador de visión SigLIP-So400m sobre un modelo de lenguaje Gemma-2B, de aproximadamente 3B de parámetros. Pi0.5 hereda su tokenizador, y ese tokenizador reside en un repositorio restringido. Esta es la forma más común en que una primera ejecución falla, antes del primer paso de entrenamiento.

Antes de empezar: formato del conjunto de datos, episodios, hardware

Pi0.5 en LeRobot lee un conjunto de datos de LeRobot en formato v3.0, que llegó con lerobot 0.4.0 en octubre de 2025: muchos episodios por archivo Parquet y MP4 en lugar de un archivo por episodio, con límites en meta/episodes/ en lugar de nombres de archivo. Grabe con el cliente de escritorio o siga grabe su primer conjunto de datos y lo tendrá.

# 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

La plataforma requiere al menos 50 episodios para Pi0.5, el mismo mínimo que GR00T y ACT. El preentrenamiento hace el trabajo pesado, por lo que 50 episodios limpios superan a 200 descuidados. ¿Eres nuevo en esto? Comienza con la guía de recolección de datos.

Ruta A: ajuste fino con el repositorio openpi

La implementación de referencia: JAX primero, probada solo en Ubuntu 22.04, impulsada por objetos de configuración en lugar de flags. Una ruta de PyTorch llegó en septiembre de 2025, validada en LIBERO. Tres pasos: convertir sus datos, definir una configuración, entrenar y servir.

1. 1
   Clonar e instalar

   openpi utiliza uv. GIT_LFS_SKIP_SMUDGE es lo que permite que LeRobot se incluya como dependencia sin 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
   Convertir sus datos a un conjunto de datos de LeRobot

   El upstream proporciona convertidores para LIBERO y DROID y espera que usted adapte uno. El trabajo consiste en el mapeo de claves.

   bash

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

3. 3
   Añadir una configuración de entrenamiento

   Las configuraciones son entradas de TrainConfig en src/openpi/training/config.py. Esta adapta pi05_droid_finetune, con el cargador de pesos apuntando a 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 estadísticas de normalización

   Se ejecuta contra el nombre de la configuración, no contra el conjunto de datos. Omitirlo es el primer fallo clásico aquí.

   bash

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

5. 5
   Entrenar

   La variable permite a JAX usar el 90 por ciento de la memoria de la GPU en lugar del 75 por ciento predeterminado. En una tarjeta de 80 GB, esto decide si la ejecución sobrevive.

   bash

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

6. 6
   Servirlo

   El servidor escucha en el puerto 8000 y responde a las consultas de observación; el tiempo de ejecución de su robot es el cliente.

   bash

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

Ruta B: ajuste fino con lerobot pi05

El puerto de LeRobot envuelve los mismos pesos en la CLI que ya utiliza para ACT y SmolVLA. Todo lo siguiente fue verificado con lerobot 0.6.1, la versión desde el 3 de agosto de 2026, y la documentación de pi05 del 23 de agosto de 2026. Las versiones importan aquí: los conjuntos de datos v3.0 llegaron con la 0.4.0 en octubre de 2025, el blog 0.5.0 del 9 de marzo de 2026 presenta pi0-FAST y Real-Time Chunking, y la 0.6.0 del 6 de julio de 2026 hizo que el paquete base fuera ligero y trasladó la implementación a lerobot-rollout.

Una cosa no cambió: lerobot-train y lerobot-record ya eran puntos de entrada en la versión 0.3.2, agosto de 2025. Un tutorial que todavía llama a python -m lerobot.scripts.train es anterior a un año de cambios y también es digno de desconfianza en el resto.

1. 1
   Instalar con los extras correctos

   Desde la versión 0.6.0, la instalación base solo incluye las dependencias principales de ML, y el extra `pi` no añade código de conjunto de datos o entrenamiento, por lo que un ajuste fino también necesita el extra de entrenamiento. Las líneas de comando antiguas fallan aquí al importar.

   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

   Acepte la licencia de paligemma-3b-pt-224 en un navegador, luego inicie sesión en la máquina que entrena.

   bash

   hf auth login

3. 3
   Añadir estadísticas de cuantiles

   Pi0.5 normaliza STATE y ACTION con cuantiles, por lo que meta/stats.json necesita q01 y q99. Los conjuntos de datos más antiguos solo contienen 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
   Ajuste fino desde lerobot/pi05_base

   Ajuste el tamaño del lote a lo que su tarjeta pueda soportar; la documentación usa 64 en LIBERO con 80 GB. Pase bfloat16 explícitamente, el valor predeterminado de la configuración es 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
   Ejecutarlo en el brazo

   En 0.6.x esto es lerobot-rollout: lerobot-record rechaza una política y los nombres de conjuntos de datos `eval_`. `Base` controla el brazo, `sentry` registra el despliegue.

   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

Tres conjuntos de valores predeterminados, y cuáles llegan al entrenador

TrainConfig de openpi es la referencia, PI05Config de LeRobot es lo que usa lerobot-train cuando no se especifica nada, y el formulario aquí envía un tercer conjunto. La sorpresa es la tasa de aprendizaje: ambos valores predeterminados upstream alcanzan un máximo de 2.5e-5, mientras que la propia configuración pi05_libero de openpi y esta plataforma la elevan a 5e-5.

¿Es fiel la adaptación? El equipo de LeRobot ajustó el modelo base LIBERO durante 6k pasos adicionales y lo comparó con los números de referencia de openpi en cuatro conjuntos: 97.5 por ciento de promedio frente a 96.85, por delante en Libero 10, por detrás en Spatial. La ruta es una elección de herramientas, no de calidad.

La realidad de 485 ms, y dónde deja de ser utilizable

Esto decide tu proyecto, por lo que va antes de la tabla de costos. La por paso de acción medida aquí para Pi0.5 es de 485 ms. Frente a las otras cuatro:

Upstream tiene una respuesta, y la mitad ya está en la versión que puede instalar. El Chunking en Tiempo Real (Real-Time Chunking) genera el siguiente fragmento mientras el brazo aún está ejecutando el actual, luego guía los pasos superpuestos del nuevo fragmento para que se mantengan cerca de la parte ya ejecutada, de modo que el brazo no se detenga ni se sacuda en la unión. La forma de tiempo de inferencia se incluyó en el registro de cambios 0.4.2 para Pi0, Pi0.5 y SmolVLA y es un flag de despliegue, no un reentrenamiento:

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

No hace que el modelo sea más rápido. Oculta la brecha: los 485 ms aún se gastan, pero fuera de la ruta crítica, por lo que la cola no se agota entre fragmentos. La variante de tiempo de entrenamiento de arXiv 2512.05964 va más allá: el modelo aprende a condicionar un prefijo de acción limpio, por lo que en la inferencia la superposición se "pinta" con pasos de tiempo de flujo por acción en lugar de ser guiada, y el paso hacia atrás de la guía desaparece. Durante el entrenamiento, muestrea una longitud de prefijo por ejemplo y toma la pérdida de flujo en el sufijo restante. Ese flag solo está en main, no en 0.6.1, y el retraso para el que entrena debe permanecer por debajo de chunk_size.

Dos formas de obtener un checkpoint de 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

Cuando no funciona

• Conjunto de datos rechazado: se requiere v3
• Memoria insuficiente durante el entrenamiento
• La pérdida disminuye pero la política no hace nada
• La política se congela a mitad de movimiento
• La política solo funciona en una configuración
• Trabajo de entrenamiento atascado en cola

Cuánto cuesta una ejecución

Pi0.5 se encuentra en el nivel costoso porque necesita una tarjeta de 80 GB, y los precios spot varían, por lo que la cifra es un rango en lugar de un precio. Para muchas tareas SO-100, entrene SmolVLA o ACT en el nivel de 24 GB primero, confirme que la tarea es aprendible, y luego dedique horas de A100 a ella. Entrene su primera política describe ese ciclo más económico, y precios contiene los niveles actuales.

Antes de comprometer una tarde: GR00T N1.7 contra Pi0.5 y Pi0.5 contra SmolVLA presentan los mismos números cara a cara. La Arena contiene 85 modelos VLA con 332 resultados de benchmark, cada uno vinculado a su fuente, y los antecedentes de la familia se encuentran en nuestra visión general de VLA.