Guía rápida

Todos los comandos de LeRobot en un solo lugar. Si olvidaste cómo usar un comando específico o quieres conocer uno nuevo, puedes hacerlo aquí.

Recuerda cambiar los puertos/nombres/ids de todos los comandos enumerados a continuación por tus propios valores.

Otra excelente manera de ver todos los comandos y configurarlos para tu configuración específica es usar este Jupyter Notebook.

Configuración e instalación

Para la instalación, consulte Instalación de LeRobot.

Herramientas útiles

Buscar puerto

Utilice esto para identificar en qué puertos serie están conectados sus robots. Siga las instrucciones en su terminal: se le pedirá que desconecte el cable USB y presione Enter. El script detectará e imprimirá el puerto serie correcto para ese robot.

lerobot-find-port

Buscar cámaras

Encuentra rápidamente los índices de las cámaras y verifica su salida. Este comando imprime la información de las cámaras en la terminal y guarda fotogramas de prueba de cada cámara detectada en outputs/captured_images

lerobot-find-cameras

Calibración

En la mayoría de los casos, solo necesitarás realizar la calibración una vez para cada robot y dispositivo de teleoperación. Antes de realizar la calibración, asegúrate de que todas las articulaciones estén aproximadamente en la posición intermedia.

lerobot-calibrate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm

Asegúrate de usar los mismos IDs que se utilizaron durante la calibración en los otros scripts. Así es como LeRobot encuentra los archivos de calibración.

Teleoperación

Teleoperación con dos cámaras y visualización de los datos con Rerun.

lerobot-teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_leader_arm \
    --display_data=true

Grabación de un conjunto de datos

El conjunto de datos se sube automáticamente al Hugging Face Hub bajo repo_id. Asegúrate de haber iniciado sesión en tu cuenta de HF con la CLI (puedes obtener un token en https://huggingface.co/settings/tokens) y guarda tu nombre de usuario en HF_USER, que utilizan los comandos siguientes:

lerobot-record \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_leader_arm \
    --dataset.repo_id=${HF_USER}/so101_dataset_test \
    --dataset.num_episodes=30 \
    --dataset.single_task="put the red brick in a bowl" \
    --dataset.streaming_encoding=true \
    --display_data=true

Mientras recopilas el conjunto de datos, puedes controlar el proceso con tu teclado:

• Pulsa flecha derecha (→) o n: guarda el episodio y pasa al siguiente.
• Pulsa flecha izquierda (←) o r: elimina el episodio actual y reintenta.
• Pulsa Escape (ESC) o q: detén, codifica los vídeos y súbelos.

lerobot-record añade la fecha y la hora de la sesión al final de --dataset.repo_id, por lo que ${HF_USER}/so101_dataset_test se guarda como ${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS. Encuentra el nombre completo en tu perfil de Hugging Face o con ls ~/.cache/huggingface/lerobot/${HF_USER}, y úsalo en los comandos de entrenamiento siguientes. Añade --dataset.no_stamp=true para mantener el nombre exacto.

Profundidad de grabación

Las cámaras Intel RealSense (type: intelrealsense) registran un flujo de profundidad cuando se establece use_depth: true. La profundidad se cuantiza en códigos de 12 bits y se almacena como un video independiente.

lerobot-record \
    ... \
    --robot.cameras="{ head: {type: intelrealsense, serial_number_or_name: \"0123456789\", width: 640, height: 480, fps: 30, use_depth: true} }" \
    --dataset.repo_id=${HF_USER}/so101_depth_test \
    --dataset.single_task="put the red brick in a bowl" \
    --dataset.depth_encoder.depth_min=0.01 \
    --dataset.depth_encoder.depth_max=10.0 \
    --dataset.depth_encoder.shift=0.0 \
    --dataset.depth_encoder.use_log=true

Parámetros de codificación de video

Los flujos de RGB y profundidad se codifican de forma independiente mediante las claves --dataset.rgb_encoder.* y --dataset.depth_encoder.*.

lerobot-record \
    ... \
    --dataset.rgb_encoder.vcodec=h264 \
    --dataset.rgb_encoder.pix_fmt=yuv420p \
    --dataset.rgb_encoder.crf=23 \
    --dataset.depth_encoder.vcodec=hevc \
    --dataset.depth_encoder.extra_options='{"x265-params": "lossless=1"}'

Entrenamiento

Dependiendo de tu hardware, el entrenamiento de la política podría tardar unas horas. Así es como se entrena una simple política ACT:

lerobot-train \
    --dataset.repo_id=${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS \
    --policy.type=act \
    --output_dir=outputs/train/act_so101_test \
    --job_name=act_so101_test \
    --policy.device=cuda \
    --trackio.enable=true \
    --policy.repo_id=${HF_USER}/policy_test \
    --steps=20000

• Tipos de política habituales: act, diffusion, multi_task_dit, smolvla, pi0, pi05, pi0_fast, groot, xvla. Cada política tiene su propia página bajo Policies en la barra lateral, y la Compute & Hardware Guide muestra cuáles se adaptan a tu GPU.
• Dispositivos: cuda (NVIDIA), mps (Apple Silicon), cpu

--policy.type crea una nueva política de ese tipo y la entrena desde cero en tu conjunto de datos (algunas políticas aún parten de backbones de visión o lenguaje preentrenados, según lo definido en su configuración). Para ajustar un modelo existente en su lugar, pasa --policy.path con un checkpoint local o un id de repositorio del Hub: el tipo de política y la configuración se leen de ahí, por lo que no se necesita --policy.type.

lerobot-train \
    --dataset.repo_id=${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS \
    --policy.path=username/the_policy_to_finetune \
    --policy.device=cuda \
    --policy.repo_id=${HF_USER}/policy_finetuned_test \
    --output_dir=outputs/train/finetuned_so101_test \
    --steps=20000

¿No tienes una GPU local? Añade --job.target=<flavor> (p. ej. a10g-small) a cualquiera de los dos comandos y lerobot-train lo ejecutará en Hugging Face Jobs en su lugar: sube un dataset solo local por ti y publica el modelo entrenado. Lista los sabores con hf jobs hardware. Para seguir las métricas del trabajo, añade --trackio.enable=true --trackio.space_id=<user>/<space>: la base de datos local de Trackio del pod no sobrevive al trabajo.

Para reanudar, dirija --config_path a un punto de control y agregue --resume=true. Acepta una ruta local o un id de repositorio de Hub (se obtiene el punto de control más reciente) y funciona localmente o en un trabajo agregando --job.target=<flavor>:

lerobot-train --config_path=${HF_USER}/policy_test --resume=true --job.target=a10g-small

Inferencia

Inference significa ejecutar la política/modelo entrenado en un robot. Para ello, usamos lerobot-rollout. Deberás proporcionar una ruta a tu política. Puede ser una ruta local o un id de repositorio de Hugging Face, por ejemplo ${HF_USER}/policy_test del comando de entrenamiento anterior. Usa el mismo puerto, --robot.id, configuración de cámara y descripción de la tarea que al recopilar el conjunto de datos. --duration está en segundos; si no se especifica, la política se ejecuta hasta que la detengas.

En v0.5.x y versiones anteriores, lerobot-rollout no existe y es necesario usar lerobot-record en su lugar. Más información aquí.

lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USER}/policy_test \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
    --task="put the red brick in a bowl" \
    --duration=60