LeRobot documentation

Apprentissage par imitation sur des robots réels

LeRobot

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.7.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Apprentissage par imitation sur des robots réels

Ce tutoriel explique comment entraîner un réseau de neurones pour contrôler un robot réel de manière autonome.

Vous allez apprendre :

Comment enregistrer et visualiser votre jeu de données.
Comment entraîner une politique à l'aide de vos données et la préparer pour l'évaluation.
Comment évaluer votre politique et visualiser les résultats.

En suivant ces étapes, vous serez en mesure de reproduire des tâches, telles que la prise d’un bloc Lego et sa pose dans un bac, avec un taux de réussite élevé, comme le montre la vidéo ci-dessous.

Video: pickup lego block task

Ce tutoriel n’est pas lié à un robot spécifique : nous vous guidons à travers les commandes et les extraits d’API que vous pouvez adapter à toute plateforme prise en charge.

Lors de la collecte de données, vous utiliserez un dispositif de « téléopération », tel qu’un bras leader ou un clavier, pour téléopérer le robot et enregistrer ses trajectoires de mouvement.

Une fois que vous avez collecté un nombre suffisant de trajectoires, vous entraînez un réseau de neurones pour imiter ces trajectoires et déployez le modèle entraîné afin que votre robot puisse effectuer la tâche de manière autonome.

Si vous rencontrez des problèmes à tout moment, rejoignez notre communauté Discord pour obtenir de l'aide.

Vous souhaitez obtenir rapidement les bonnes commandes pour votre configuration ? Le notebook de démarrage rapide vous permet de configurer votre robot une seule fois et génère toutes les commandes ci-dessous, prêtes à être collées.

Configuration et calibration

Si vous n’avez pas encore configuré et calibré votre robot et votre appareil de téléopération, veuillez le faire en suivant le tutoriel correspondant à votre robot, par exemple SO-101, OpenArm, Koch ou LeKiwi. Tous les robots pris en charge sont répertoriés sous Robots dans la barre latérale.

Télépiloter

Dans cet exemple, nous vous montrons comment téléopérer le robot SO101. Pour chaque commande, nous fournissons également un exemple d'API correspondant.

Notez que l'id associé à un robot est utilisé pour stocker le fichier de calibration. Il est important d'utiliser le même id lors de la téléopération, de l'enregistrement et de l'évaluation si vous utilisez la même configuration.

Commande

Exemple d'API

La commande teleoperate effectuera automatiquement les opérations suivantes :

Identifier les calibrations manquantes et initier la procédure de calibration.
Connectez le robot et l'appareil de téléopération, puis démarrez la téléopération.

Caméras

Pour ajouter des caméras à votre configuration, suivez ce guide.

Télépiloter avec des caméras

Avec rerun, vous pouvez téléopérer à nouveau tout en visualisant simultanément les flux des caméras et les positions des articulations. Cet exemple utilise deux caméras, wrist et top ; nous conservons la même configuration de caméras pour le reste du tutoriel.

Commande

Exemple d'API

Enregistrer un jeu de données

Une fois que vous êtes à l’aise avec la téléopération, vous pouvez enregistrer votre premier jeu de données.

Nous utilisons les fonctionnalités du hub Hugging Face pour téléverser votre jeu de données. Si vous n’avez pas encore utilisé le Hub, assurez-vous de pouvoir vous connecter via le cli à l’aide d’un jeton d’accès en écriture, que vous pouvez générer depuis les paramètres Hugging Face.

Ajoutez votre jeton à l’interface en ligne de commande en exécutant cette commande :

hf auth login --token ${HUGGINGFACE_TOKEN} --add-to-git-credential

Enregistrez ensuite le nom de votre dépôt Hugging Face dans une variable :

HF_USER=$(NO_COLOR=1 hf auth whoami | awk -F': *' 'NR==1 {print $2}')
echo $HF_USER

Vous pouvez maintenant enregistrer un jeu de données. Pour enregistrer 5 épisodes et téléverser votre jeu de données sur le hub, adaptez le code ci-dessous à votre robot et exécutez la commande ou l’exemple d’API.

Commande

Exemple d'API

lerobot-record \
    --robot.type=so101_follower \
    --robot.port=/dev/tty.usbmodem585A0076841 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 1920, height: 1080, fps: 30}}" \
    --robot.cameras="{ wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/tty.usbmodem58760431551 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true \
    --dataset.repo_id=${HF_USER}/record-test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Grab the black cube" \
    --dataset.streaming_encoding=true \
    --dataset.encoder_threads=2
# Optional: --dataset.rgb_encoder.vcodec=auto

from lerobot.cameras.opencv import OpenCVCameraConfig
from lerobot.datasets.lerobot_dataset import LeRobotDataset
from lerobot.utils.feature_utils import hw_to_dataset_features
from lerobot.robots.so_follower import SO101Follower, SO101FollowerConfig
from lerobot.teleoperators.so_leader.config_so_leader import SO101LeaderConfig
from lerobot.teleoperators.so_leader.so_leader import SO101Leader
from lerobot.common.control_utils import init_keyboard_listener
from lerobot.utils.utils import log_say
from lerobot.utils.visualization_utils import init_visualization
from lerobot.scripts.lerobot_record import record_loop
from lerobot.processor import make_default_processors

NUM_EPISODES = 5
FPS = 30
EPISODE_TIME_SEC = 60
RESET_TIME_SEC = 10
TASK_DESCRIPTION = "My task description"

def main():
    # Create robot configuration
    robot_config = SO101FollowerConfig(
        port="/dev/tty.usbmodem5AB90687491",
        id="my_follower_arm",
        cameras={
            "wrist": OpenCVCameraConfig(index_or_path=0, width=640, height=480, fps=30),
            "top": OpenCVCameraConfig(index_or_path=1, width=640, height=480, fps=30)
        }
    )

    teleop_config = SO101LeaderConfig(
        port="/dev/tty.usbmodem5AB90689011",
        id="my_leader_arm",
    )

    # Initialize the robot and teleoperator
    robot = SO101Follower(robot_config)
    teleop = SO101Leader(teleop_config)

    # Configure the dataset features
    action_features = hw_to_dataset_features(robot.action_features, "action")
    obs_features = hw_to_dataset_features(robot.observation_features, "observation")
    dataset_features = {**action_features, **obs_features}

    # Create the dataset
    dataset = LeRobotDataset.create(
        repo_id="<hf_username>/<dataset_repo_id>",
        fps=FPS,
        features=dataset_features,
        robot_type=robot.name,
        use_videos=True,
        image_writer_threads=4,
    )

    # Initialize the keyboard listener and rerun visualization
    _, events = init_keyboard_listener()
    init_visualization("rerun", session_name="recording")

    # Connect the robot and teleoperator
    robot.connect()
    teleop.connect()

    # Create the required processors
    teleop_action_processor, robot_action_processor, robot_observation_processor = make_default_processors()

    episode_idx = 0
    while episode_idx < NUM_EPISODES and not events["stop_recording"]:
        log_say(f"Recording episode {episode_idx + 1} of {NUM_EPISODES}")

        record_loop(
            robot=robot,
            events=events,
            fps=FPS,
            teleop_action_processor=teleop_action_processor,
            robot_action_processor=robot_action_processor,
            robot_observation_processor=robot_observation_processor,
            teleop=teleop,
            dataset=dataset,
            control_time_s=EPISODE_TIME_SEC,
            single_task=TASK_DESCRIPTION,
            display_data=True,
        )

        # Reset the environment if not stopping or re-recording
        if not events["stop_recording"] and (episode_idx < NUM_EPISODES - 1 or events["rerecord_episode"]):
            log_say("Reset the environment")
            record_loop(
                robot=robot,
                events=events,
                fps=FPS,
                teleop_action_processor=teleop_action_processor,
                robot_action_processor=robot_action_processor,
                robot_observation_processor=robot_observation_processor,
                teleop=teleop,
                control_time_s=RESET_TIME_SEC,
                single_task=TASK_DESCRIPTION,
                display_data=True,
            )

        if events["rerecord_episode"]:
            log_say("Re-recording episode")
            events["rerecord_episode"] = False
            events["exit_early"] = False
            dataset.clear_episode_buffer()
            continue

        dataset.save_episode()
        episode_idx += 1

    # finalize dataset
    log_say("Finalizing dataset...")
    dataset.finalize()
    # Clean up
    log_say("Stop recording")
    robot.disconnect()
    teleop.disconnect()
    dataset.push_to_hub()


if __name__ == "__main__":
    main()

Les noms de caméras que vous choisissez (ici wrist et top) deviennent les clés du jeu de données observation.images.wrist et observation.images.top. Une politique entraînée sur ce jeu de données s'attend à ce que les mêmes noms de caméras et la même résolution soient utilisés lors de son déploiement ; réutilisez donc la même valeur de --robot.cameras à chaque étape de ce tutoriel. Si les noms doivent différer, consultez Rename Map.

lerobot-record ajoute la date et l’heure de la session à la fin de --dataset.repo_id, de sorte que chaque enregistrement reçoive un nom unique : ${HF_USER}/record-test est enregistré sous ${HF_USER}/record-test_YYYYMMDD_HHMMSS (par exemple record-test_20260929_143012). Retrouvez le nom complet sur votre profil Hugging Face ou avec ls ~/.cache/huggingface/lerobot/${HF_USER}, et utilisez-le partout où les commandes ci-dessous indiquent record-test_YYYYMMDD_HHMMSS. Pour conserver exactement le nom que vous avez transmis, ajoutez --dataset.no_stamp=true.

Téléversement de jeu de données

Localement, votre jeu de données est stocké dans ce dossier : ~/.cache/huggingface/lerobot/{repo-id}. À la fin de l'enregistrement des données, votre jeu de données sera téléversé sur votre page Hugging Face (par exemple https://huggingface.co/datasets/${HF_USER}/record-test_YYYYMMDD_HHMMSS) que vous pouvez obtenir en exécutant :

echo https://huggingface.co/datasets/${HF_USER}/record-test_YYYYMMDD_HHMMSS

Votre jeu de données sera automatiquement étiqueté avec LeRobot pour que la communauté puisse le trouver facilement, et vous pouvez également ajouter des étiquettes personnalisées, par exemple --dataset.tags='["tutorial"]'.

Vous pouvez rechercher d'autres jeux de données LeRobot sur le hub en cherchant les tags LeRobot.

Vous pouvez également pousser votre jeu de données local vers le Hub manuellement en exécutant :

hf upload ${HF_USER}/record-test_YYYYMMDD_HHMMSS ~/.cache/huggingface/lerobot/${HF_USER}/record-test_YYYYMMDD_HHMMSS --repo-type dataset

Fonction d'enregistrement

lerobot-record fournit un ensemble d’outils pour capturer et gérer les données pendant le fonctionnement du robot :

1. Stockage des données

Les données sont stockées au format LeRobotDataset et sont enregistrées sur le disque pendant l'enregistrement.
Par défaut, le jeu de données est poussé vers votre page Hugging Face après l'enregistrement.
- Pour désactiver le téléversement, utilisez --dataset.push_to_hub=False.

2. Point de contrôle et reprise

Les points de contrôle sont créés automatiquement pendant l'enregistrement.
Si un problème survient ou si vous souhaitez enregistrer des épisodes supplémentaires dans le même jeu de données, vous pouvez reprendre en relançant la même commande avec --resume=true. Passez le nom complet du jeu de données, y compris son horodatage (--dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS). Lors de la reprise d’un enregistrement, --dataset.num_episodes doit être défini sur le nombre d’épisodes supplémentaires à enregistrer, et non sur le nombre total d’épisodes visé dans le jeu de données ! Assurez-vous également de définir --dataset.root="local_path", il s’agit d’un chemin local pour enregistrer la nouvelle partie du jeu de données et est requis pour reprendre.
Relancer la commande sans --resume=true démarre un nouveau jeu de données avec un nouvel horodatage. Si vous utilisez --dataset.no_stamp=true, supprimez d’abord le répertoire du jeu de données existant.

3. Paramètres d’enregistrement

Définissez le flux d’enregistrement des données à l’aide d’arguments en ligne de commande :

--dataset.episode_time_s=60 Durée de chaque épisode d'enregistrement de données (par défaut : 60 secondes).
--dataset.reset_time_s=60 Durée de réinitialisation de l'environnement après chaque épisode (par défaut : 60 secondes).
--dataset.num_episodes=50 Nombre total d'épisodes à enregistrer (par défaut : 50).

4. Contrôles du clavier pendant l'enregistrement

Contrôlez le flux d’enregistrement des données à l’aide des raccourcis clavier :

Appuyez sur Flèche droite (→) ou n : arrêtez précocement l'épisode en cours ou réinitialisez le temps et passez au suivant.
Appuyez sur Flèche gauche (←) ou r : annuler l'épisode en cours et le réenregistrer.
Appuyez sur Échap (ESC) ou q : arrête immédiatement la session, encode les vidéos et téléverse le jeu de données.

Ces raccourcis de contrôle de flux fonctionnent sur les sessions X11, Wayland et sans interface graphique/SSH. Lorsqu’un backend clavier global n’est pas disponible (Wayland, une machine sans interface graphique, ou macOS sans autorisation d’accessibilité), lerobot-record lit automatiquement les mêmes touches depuis le terminal — lancez-le depuis un terminal interactif et gardez-le au premier plan. Vous pouvez également utiliser les équivalents en lettres n (suivant, identique à →), r (réenregistrer, identique à ←) et q (quitter, identique à ESC). Aucune configuration de $DISPLAY n’est requise.

Cela ne concerne que le flux de contrôle de l’enregistrement. La téléopération au clavier (piloter le robot avec le clavier) nécessite toujours un backend de touches global, elle fonctionne donc uniquement sur une session X11, un bureau Windows ou macOS avec les autorisations d’Accessibilité/Surveillance des saisies accordées — et non sur Wayland ou des sessions sans interface graphique.

Conseils pour collecter des données

Une fois à l’aise avec l’enregistrement des données, vous pouvez créer un jeu de données plus volumineux pour l’entraînement. Une bonne tâche de départ consiste à saisir un objet à différents endroits et à le déposer dans un bac. Nous recommandons d’enregistrer au moins 50 épisodes, soit 10 épisodes par emplacement. Gardez les caméras fixes et maintenez un comportement de saisie cohérent tout au long des enregistrements. Assurez-vous également que l’objet que vous manipulez est visible sur les caméras. Une bonne règle empirique est que vous devriez pouvoir effectuer la tâche vous-même en ne regardant que les images des caméras.

Dans les sections suivantes, vous entraînerez votre réseau de neurones. Une fois que vous obtenez des performances de préhension fiables, vous pouvez commencer à introduire davantage de variations lors de la collecte de données, telles que des emplacements de préhension supplémentaires, des techniques de préhension différentes et des modifications des positions des caméras.

Évitez d'ajouter trop de variation trop rapidement, car cela pourrait nuire à vos résultats.

Si vous souhaitez approfondir ce sujet important, vous pouvez consulter notre article de blog sur ce qui fait un bon jeu de données.

Rapport de cadence

lerobot-record régule la boucle à --dataset.fps et rapporte ce qui a réellement été atteint : un résumé en une ligne pour chaque épisode conservé, et un bloc pour la session entière à la fin de l’enregistrement — y compris en cas de Ctrl-C.

Cadence (episode 0): 29.88 Hz vs 30 Hz target · 600 ticks, 20.0 s measured · 8/599 ticks over the 33.3 ms budget (work mean 18.4 ms, worst 45.1 ms)
Cadence (episode 1): 29.88 Hz vs 30 Hz target · 600 ticks, 20.0 s measured · 8/599 ticks over the 33.3 ms budget (work mean 18.4 ms, worst 45.1 ms)
Cadence summary — whole run, 2 episodes · target 30 Hz (33.3 ms budget per tick): 1200 ticks, 1198 judged
  effective cadence: 29.88 Hz over 40.1 s measured
  ticks over the 33.3 ms work budget: 16/1198 (1.3%) — work mean 18.4 ms, worst 45.1 ms
  loop-body steps (share of measured work):
    observe      mean  13.65 ms · worst  40.20 ms ·  74.4% of work · 1200 calls
    process_obs  mean   0.30 ms · worst   0.30 ms ·   1.6% of work · 1200 calls
    teleop       mean   1.80 ms · worst   1.80 ms ·   9.8% of work · 1200 calls
    send         mean   0.90 ms · worst   0.90 ms ·   4.9% of work · 1200 calls
    record       mean   1.70 ms · worst   1.90 ms ·   9.3% of work · 1200 calls
  pacing headroom: 15.1 ms slept per tick on average (max 16.7 ms) — near zero means the loop is saturated

Il est utile de lire ceci avant d’entraîner sur le jeu de données. L’horodatage d’une image est dérivé de son index, de sorte qu’une session exécutée à 25 Hz produit toujours un jeu de données qui affirme 30 — le mouvement enregistré est simplement plus rapide que la réalité. Ci-dessus, observe représente 74 % du travail de la boucle et son worst est de 40 ms pour un budget de 33,3 ms : ce sont les caméras qui ont fait dépasser ces 16 ticks. Un marge de cadence proche de zéro signifie qu’il ne reste rien pour absorber un tick lent.

Les phases de réinitialisation entre les épisodes sont cadencées de la même manière, mais elles ne font pas délibérément partie de ces chiffres, car elles n’enregistrent rien. lerobot-teleoperate et lerobot-replay rapportent de la même manière, et lerobot-rollout ajoute les lignes spécifiques à l’interpolation décrites dans Rapportage de la cadence.

Dépannage :

Sur Linux, les touches de contrôle du flux d’enregistrement (touches fléchées, Échap) fonctionnent sur X11, Wayland et les sessions headless/SSH, à condition que lerobot-record s’exécute dans un terminal interactif — aucune configuration de $DISPLAY n’est nécessaire. Si les touches n’ont aucun effet, vérifiez que vous êtes dans un terminal interactif (TTY) et non dans une session pipée/non-TTY, et que celui-ci est au premier plan ; les équivalents en lettres n / r / q fonctionnent également. La téléopération au clavier (par opposition au flux de contrôle de l’enregistrement) nécessite toujours un backend de touches global — une session X11, un bureau Windows, ou macOS avec les autorisations d’Accessibilité/Surveillance des entrées accordées — et n’est pas disponible sur Wayland ou sur les machines headless. Consultez les limitations de pynput.

Visualiser un jeu de données

Votre jeu de données est téléversé sur le Hub par défaut (sauf si vous avez passé --dataset.push_to_hub=False), vous pouvez donc l’ouvrir immédiatement dans le LeRobot Dataset Visualizer : entrez votre identifiant de dépôt sur sa page d’accueil, ou accédez directement au premier épisode via le lien affiché :

echo "https://huggingface.co/spaces/lerobot/visualize_dataset?path=/${HF_USER}/record-test_YYYYMMDD_HHMMSS/episode_0"

Connectez-vous sur le visualiseur pour ouvrir un jeu de données privé. Consultez Explorer un jeu de données dans le navigateur pour un guide pas à pas.

Rejouer un épisode

Une fonctionnalité utile est la fonction replay, qui permet de rejouer n’importe quel épisode que vous avez enregistré ou des épisodes issus de n’importe quel jeu de données. Cette fonction vous aide à tester la reproductibilité des actions de votre robot et à évaluer la transférabilité entre des robots du même modèle.

Vous pouvez rejouer le premier épisode sur votre robot soit avec la commande ci-dessous, soit avec l'exemple d'API :

Commande

Exemple d'API

Votre robot doit reproduire des mouvements similaires à ceux que vous avez enregistrés. Par exemple, regardez cette vidéo où nous utilisons replay sur un robot ALOHA de Trossen Robotics.

Entraîner une politique

Pour entraîner une politique afin de contrôler votre robot, utilisez le script lerobot-train. Quelques arguments sont requis. Voici un exemple de commande :

lerobot-train \
  --dataset.repo_id=${HF_USER}/record-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}/my_policy

Expliquons la commande :

Nous avons fourni le dataset enregistré précédemment en argument avec --dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS (utilisez le nom complet de votre dataset, y compris l’horodatage).
Nous avons fourni la politique avec policy.type=act. Cela charge les configurations depuis configuration_act.py. Il est important de noter que cette politique s’adaptera automatiquement au nombre d’états moteurs, d’actions moteurs et de caméras de votre robot (par exemple wrist et top) qui ont été enregistrés dans votre jeu de données.
Nous avons fourni policy.device=cuda car nous entraînons sur un GPU Nvidia, mais vous pouvez utiliser policy.device=mps pour entraîner sur une puce Apple.
Nous avons fourni trackio.enable=true pour utiliser Trackio afin de visualiser les graphiques d’entraînement. Cette option est facultative. Exécutez trackio show --project lerobot pour ouvrir le tableau de bord, ou passez --trackio.space_id=<user>/<space> pour synchroniser l’exécution avec un Hugging Face Space.
Nous n'avons pas défini --steps, l'entraînement s'exécute donc pendant 100 000 étapes par défaut. C'est généralement plus que nécessaire pour un petit jeu de données : l'apprentissage par imitation converge typiquement en 5 à 10 époques sur les données. Consultez le Guide de calcul et de matériel pour convertir les époques en valeur --steps adaptée à la taille de votre jeu de données et à la taille de votre lot.

L'entraînement devrait prendre plusieurs heures. Vous trouverez les points de contrôle dans outputs/train/act_so101_test/checkpoints.

Pour reprendre l’entraînement à partir d’un point de contrôle, voici un exemple de commande pour reprendre depuis le point de contrôle last de la politique act_so101_test :

lerobot-train \
  --config_path=outputs/train/act_so101_test/checkpoints/last/pretrained_model/train_config.json \
  --resume=true

--config_path accepte également un identifiant de dépôt Hub : si une exécution a poussé ses points de contrôle vers le Hub (avec --save_checkpoint_to_hub=true), vous pouvez reprendre directement depuis le dépôt — son dernier point de contrôle est téléchargé et l’entraînement reprend, en restaurant l’optimiseur, le planificateur, le compteur d’étapes et l’ordre des données :

lerobot-train --config_path=${HF_USER}/my_policy --resume=true

Si vous ne souhaitez pas pousser votre modèle sur le hub après l'entraînement, utilisez --policy.push_to_hub=false.

Vous pouvez également fournir des tags supplémentaires, spécifier une license pour votre modèle ou rendre le dépôt du modèle private en ajoutant ceci : --policy.private=true --policy.tags=\[so101,tutorial\] --policy.license=mit

Entraîner à l'aide de Google Colab

Si votre ordinateur local ne dispose pas d’un GPU puissant, vous pouvez utiliser Google Colab pour entraîner votre modèle en suivant le cahier d’entraînement ACT.

Entraîner à l'aide de Hugging Face Jobs

Hugging Face Jobs vous permet de sélectionner facilement le matériel et d’exécuter l’entraînement dans le cloud. Si vous ne disposez pas d’un GPU puissant, si vous avez besoin de plus de VRAM ou si vous souhaitez simplement entraîner un modèle beaucoup plus rapidement, utilisez HF Jobs ! Le paiement est à l’usage : vous ne payez que pour chaque seconde d’utilisation. Vous pouvez consulter les tarifs et des informations supplémentaires ici.

lerobot-train s’exécute localement par défaut. Pour l’exécuter sur un GPU HuggingFace, passez --job.target avec le nom d’un profil matériel :

lerobot-train \
  --dataset.repo_id=${HF_USER}/record-test_YYYYMMDD_HHMMSS \
  --policy.type=act \
  --policy.repo_id=${HF_USER}/my_policy \
  --job.target=a10g-small

Listez les saveurs et les tarifs disponibles avec hf jobs hardware. L’exécution transmet ses journaux à votre terminal ; appuyez sur Ctrl-C pour vous détacher (le job continue de s’exécuter dans le cloud). Reconnectez-vous ou annulez avec :

hf jobs logs <job-id>
hf jobs cancel <job-id>

Si votre jeu de données n’existe que localement (pas encore sur le Hub), il est automatiquement poussé vers un dépôt privé du Hub afin que le job puisse le télécharger via repo_id (rien n’est rendu public). Le modèle entraîné est poussé vers le dépôt du modèle à la fin de l’exécution. Pour également pousser chaque point de contrôle intermédiaire vers le Hub au moment où il est enregistré (afin de pouvoir suivre les progrès en cours d’exécution), ajoutez --save_checkpoint_to_hub=true — cela nécessite une image d’exécution qui inclut cette fonctionnalité.

Chaque tâche (ainsi que tout jeu de données poussé par l’exécution) est étiqueté lerobot afin de faciliter sa recherche sur le Hub. Ajoutez vos propres étiquettes avec --job.tags '["my-tag"]'.

Par défaut, la durée d’exécution réelle du job est limitée à 2d (48 h). Vous pouvez la modifier avec une chaîne de durée HF Jobs, par exemple --job.timeout=4h pour échouer plus rapidement ou --job.timeout=7d pour une exécution plus longue.

Remarque : le dépôt du modèle est créé à l'avance (il contient la configuration d'entraînement mise en file d'attente à partir de laquelle la tâche s'exécute). Si une exécution échoue avant que le modèle ne soit publié, ce dépôt reste sur le Hub afin que vous puissiez l'inspecter — il n'est pas supprimé automatiquement, de sorte que des échecs répétés peuvent laisser des dépôts vides derrière eux. Supprimez-en un avec hf repos delete <repo-id>.

Prérequis : exécutez hf auth login avant de soumettre. Pour Trackio, passez --trackio.space_id=<user>/<space> — le Space est créé s'il est manquant et le HF_TOKEN du job est transmis automatiquement.

Reprise sur un job. L’ajout de --job.target à une commande de reprise exécute la reprise dans le cloud — la même commande fonctionne en local ou à distance. Le dépôt de checkpoint est la source de vérité, et les nouveaux checkpoints poursuivent la lignée dans le même dépôt :

# resume a Hub run on a job (its checkpoints are already on the Hub)
lerobot-train --config_path=${HF_USER}/my_policy --resume=true --job.target=a10g-small

# resume a LOCAL run on a job — the checkpoint is uploaded to a private Hub repo first,
# then the job resumes from it (a local-only dataset is uploaded the same way)
lerobot-train \
  --config_path=outputs/train/act_so101_test/checkpoints/last/pretrained_model/train_config.json \
  --resume=true \
  --job.target=a10g-small

Les paramètres du job proviennent de la commande actuelle, il faut donc remplacer --job.target, --job.timeout, etc. au besoin ; pour que l’exécution reprise soit elle-même reprenable plus tard, conservez --save_checkpoint_to_hub=true.

Télécharger les points de contrôle de la politique

Une fois l’entraînement terminé, téléchargez le dernier point de contrôle avec :

hf upload ${HF_USER}/act_so101_test \
  outputs/train/act_so101_test/checkpoints/last/pretrained_model

Vous pouvez également téléverser des points de contrôle intermédiaires avec :

CKPT=010000
hf upload ${HF_USER}/act_so101_test${CKPT} \
  outputs/train/act_so101_test/checkpoints/${CKPT}/pretrained_model

Exécuter l'inférence et évaluer votre politique

Utilisez lerobot-rollout pour déployer une politique entraînée sur votre robot. Vous pouvez choisir différentes stratégies selon vos besoins.

Utilisez le même --robot.id (afin que la calibration soit trouvée), les mêmes --robot.cameras et la même description de tâche que dans votre jeu de données enregistré. Les jeux de données enregistrés par lerobot-rollout doivent avoir un nom commençant par rollout_, et, comme lerobot-record, il ajoute un horodatage à ce nom.

Les exemples ci-dessous chargent le modèle à partir de --policy.path. Pour épingler une version poussée spécifique — utile une fois que --save_checkpoint_to_hub=true a commité plusieurs checkpoints — ajoutez --policy.pretrained_revision avec un hash de commit, une branche ou un tag. Chaque checkpoint poussé est tagué avec son step (par ex. --policy.pretrained_revision=010000), ce qui permet de récupérer un checkpoint par step sans avoir à chercher son sha de commit.

Mode de base (sans enregistrement)

Mode sentinelle (avec enregistrement)

Le drapeau --strategy.type sélectionne le mode d'exécution :

base : Déploiement autonome sans enregistrement de données (utile pour une évaluation rapide)
sentry : Enregistrement continu avec téléversement automatique (utile pour les évaluations à grande échelle)
highlight : Enregistrement en tampon circulaire avec sauvegarde par touche (utile pour capturer des événements intéressants)
dagger : collecte de données avec intervention humaine (voir Collecte de données HIL)
episodic : Enregistrement de politique orienté épisodes avec des phases de réinitialisation entre les épisodes

Toutes les stratégies prennent en charge --inference.type=rtc pour une exécution fluide avec des modèles VLA lents (Pi0, Pi0.5, SmolVLA). Consultez Policy Deployment pour chaque stratégie et ses drapeaux.

Update on GitHub

←Aide-mémoire LeLab - Lerobot GUI→