Aide-mémoire

Toutes les commandes LeRobot au même endroit. Si vous avez oublié comment utiliser une commande spécifique ou si vous souhaitez en découvrir une nouvelle, vous pouvez le faire ici.

Pour toutes les commandes listées ci-dessous, n'oubliez pas de modifier les ports/noms/ids avec vos propres valeurs !

Une autre excellente manière de consulter toutes les commandes et de les configurer pour votre configuration spécifique est d'utiliser ce Jupyter Notebook.

Configuration et installation

Pour l'installation, veuillez consulter Installation de LeRobot.

Outils utiles

Trouver le port

Utilisez ceci pour identifier les ports série auxquels vos robots sont connectés. Suivez les instructions dans votre terminal : on vous demandera de débrancher le câble USB et d’appuyer sur Entrée. Le script détectera ensuite et affichera le port série correct pour ce robot.

lerobot-find-port

Trouver des caméras

Trouvez rapidement les indices des caméras et vérifiez leur sortie. Cette commande affiche les informations des caméras dans le terminal et enregistre des images de test de chaque caméra détectée dans outputs/captured_images

lerobot-find-cameras

Calibration

Dans la plupart des cas, vous devrez effectuer l'étalonnage une seule fois pour chaque robot et chaque dispositif de téléopération. Avant de procéder à l'étalonnage, assurez-vous que tous les articulations sont approximativement en position médiane.

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

Assurez-vous d'utiliser les mêmes identifiants utilisés lors de l'étalonnage pour les autres scripts. C'est ainsi que LeRobot localise les fichiers d'étalonnage.

Téléopération

Téléopérer avec deux caméras et afficher les données avec 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

Enregistrer un jeu de données

Le jeu de données est automatiquement téléversé sur le Hugging Face Hub sous repo_id. Assurez-vous d’être connecté à votre compte HF via le CLI (vous pouvez obtenir un jeton sur https://huggingface.co/settings/tokens) et stockez votre nom d’utilisateur dans HF_USER, utilisé par les commandes ci-dessous :

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

Lors de la collecte du jeu de données, vous pouvez contrôler le processus au clavier :

• Appuyez sur Flèche droite (→) ou n : Enregistrer l'épisode et passer au suivant.
• Appuyez sur Flèche gauche (←) ou r : Supprimer l'épisode actuel et réessayer.
• Appuyez sur Échap (ESC) ou q : arrêter, encoder les vidéos et téléverser.

lerobot-record ajoute la date et l’heure de la session à la fin de --dataset.repo_id, de sorte que ${HF_USER}/so101_dataset_test est enregistré sous le nom ${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS. Retrouvez le nom complet sur votre profil Hugging Face ou avec ls ~/.cache/huggingface/lerobot/${HF_USER}, et utilisez-le dans les commandes d’entraînement ci-dessous. Ajoutez --dataset.no_stamp=true pour conserver le nom exact.

Profondeur d'enregistrement

Les caméras Intel RealSense (type: intelrealsense) enregistrent un flux de profondeur lorsque vous définissez use_depth: true. La profondeur est quantifiée en codes sur 12 bits et stockée en tant que vidéo distincte.

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

Paramètres d'encodage vidéo

Les flux RGB et profondeur sont encodés indépendamment via les clés --dataset.rgb_encoder.* et --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"}'

Entraînement

Selon votre matériel, l’entraînement de la politique peut prendre quelques heures. Voici comment entraîner une simple politique 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

• Types de politiques courants : act, diffusion, multi_task_dit, smolvla, pi0, pi05, pi0_fast, groot, xvla. Chaque politique possède sa propre page sous Policies dans la barre latérale, et le Compute & Hardware Guide indique lesquelles sont adaptées à votre GPU.
• Appareils : cuda (NVIDIA), mps (Apple Silicon), cpu

--policy.type crée une nouvelle politique de ce type et l’entraîne à partir de zéro sur votre jeu de données (certaines politiques démarrent néanmoins à partir de squelettes visuels ou linguistiques pré-entraînés, comme défini dans leur configuration). Pour affiner un modèle existant à la place, passez --policy.path avec un point de contrôle local ou un identifiant de dépôt du Hub : le type et la configuration de la politique y sont lus, de sorte que --policy.type n’est pas nécessaire.

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

Pas de GPU local ? Ajoutez --job.target=<flavor> (par ex. a10g-small) à l’une des deux commandes et lerobot-train l’exécutera sur Hugging Face Jobs à la place — il téléverse un jeu de données local pour vous et pousse le modèle entraîné. Listez les saveurs avec hf jobs hardware. Pour suivre les métriques du job, ajoutez --trackio.enable=true --trackio.space_id=<user>/<space> : la base de données Trackio locale du pod ne survit pas au job.

Pour reprendre, indiquez un point de contrôle à --config_path et ajoutez --resume=true. Il accepte un chemin local ou un identifiant de dépôt du Hub (le dernier point de contrôle est récupéré) et fonctionne en local ou sur un job en ajoutant --job.target=<flavor> :

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

Inférence

L’inférence consiste à exécuter la politique/modèle entraîné sur un robot. Pour cela, nous utilisons lerobot-rollout. Vous devrez fournir un chemin vers votre politique. Il peut s’agir d’un chemin local ou d’un identifiant de dépôt Hugging Face, par exemple ${HF_USER}/policy_test issu de la commande d’entraînement ci-dessus. Utilisez le même port, --robot.id, la même configuration des caméras et la même description de tâche que lors de la collecte du jeu de données. --duration est exprimé en secondes ; s’il n’est pas spécifié, la politique s’exécute jusqu’à ce que vous l’arrêtiez.

Sur v0.5.x et les versions antérieures, lerobot-rollout n'existe pas et vous devez utiliser lerobot-record à la place. Plus d'informations ici.

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