# 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í. > [!WARNING] > Recuerda cambiar los puertos/nombres/ids de todos los comandos enumerados a continuación por tus propios valores. > [!TIP] > Otra excelente manera de ver todos los comandos y configurarlos para tu configuración específica es usar este [Jupyter Notebook](https://github.com/huggingface/lerobot/blob/main/examples/notebooks/quickstart.ipynb). ### Configuración e instalación Para la instalación, consulte [Instalación de LeRobot](./installation). ### 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. ```bash 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` ```bash 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. ```bash 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. ```bash 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](https://huggingface.co/settings/tokens)) y guarda tu nombre de usuario en `HF_USER`, que utilizan los comandos siguientes: ```bash 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. > [!WARNING] > `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. ```bash 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.*`. ```bash 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`: ```bash 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](./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`. ```bash 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=` (p. ej. `a10g-small`) a cualquiera de los dos comandos y `lerobot-train` lo ejecutará en [Hugging Face Jobs](https://huggingface.co/docs/hub/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=/`: 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=`: ```bash 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. > [!TIP] > 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í](https://huggingface.co/docs/lerobot/v0.5.1/en/il_robots#run-inference-and-evaluate-your-policy). ```bash 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 ```