Comment entraîner ACT sur le SO-100 à partir de zéro

ACT fait figure d'exception parmi les politiques SO-100. GR00T N1.7 et N1.5 partent de nvidia/GR00T-N1.7-3B et nvidia/GR00T-N1.5-3B, Pi0.5 de lerobot/pi05_base. ACT part de zéro : il n'y a pas de point de contrôle de base, car ce n'est pas un modèle de fondation. C'est un transformeur d'environ 80 millions de paramètres que vous entraînez à partir de zéro sur une seule tâche, sur votre bras, sous votre éclairage.

C'est aussi pourquoi il exécute une étape de contrôle en 20 ms là où un VLA de 3 milliards de paramètres nécessite 152 à 485 ms, et coûte 1 à 3 USD par exécution au lieu de 4 à 12. Ce guide décrit la voie manuelle avec lerobot sur un SO-100 : l'enregistrement, la configuration act, ce que chunk_size et n_action_steps contrôlent, le programme de 100000 étapes, le déploiement. Ensuite, le même travail sur AY-Robots, y compris là où la plateforme n'aide pas.

Ce qu'est réellement ACT

Action Chunking with Transformers est issu de l'article ALOHA, Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware, par Zhao, Kumar, Levine et Finn, arXiv, 23 avril 2023. Le dispositif enregistre à 50 Hz avec quatre webcams diffusant en 480x640 à 30 fps : deux sur les pinces, une en haut, une à l'avant. L'abstract revendique six compétences avec 80 à 90 pour cent de succès, parmi lesquelles l'ouverture d'un gobelet à condiments translucide et l'insertion d'une batterie, à partir de 10 minutes de démonstrations.

Le corps de l'article est plus utile lors de la planification d'une session d'enregistrement : 50 démonstrations par tâche, sauf pour Thread Velcro à 100, ce qui représente 10 à 20 minutes de données et 30 à 60 minutes de temps réel une fois les réinitialisations comptées. Le succès n'est pas uniforme non plus : Thread Velcro se termine à 20 pour cent, Put On Shoe à 92, Cup Open 84, Prep Tape 64.

Le découpage d'actions est le concept central

Le clonage comportemental ordinaire mappe une observation à une action, et les erreurs s'accumulent : une déviation met le bras hors distribution, produisant une action pire, et trente étapes plus tard, la pince n'est nulle part près de l'objet. Découpage d'actions prédit k actions à la fois et les exécute, réduisant l'horizon effectif d'un facteur k. Cela gère également un inconvénient spécifique aux données humaines : les téléopérateurs font des pauses, et une politique markovienne à une seule étape ne peut pas modéliser une pause qui dépend de ce qui a précédé.

L'article ablate k plutôt que de l'affirmer. Avec l'ensemble temporel désactivé, en moyenne sur quatre configurations, le succès passe de 1 pour cent à k = 1 à 44 pour cent à k = 100, puis diminue à 200 et 400 à mesure que la politique approche du contrôle en boucle ouverte. Cette courbe explique pourquoi la valeur par défaut est 100.

• chunk_size : nombre d'actions futures que le décodeur prédit par passe avant. Par défaut 100.
• n_action_steps : nombre d'actions que vous exécutez avant de réinterroger. Par défaut 100, donc lerobot exécute l'intégralité du chunk en boucle ouverte.
• lerobot valide n_action_steps <= chunk_size et lève une ValueError si l'ordre est inversé.

Ce qui importe opérationnellement est le chunk_size divisé par la fréquence d'images. Aux 30 ips utilisés par les exemples SO-100 de lerobot, un chunk de 100 actions représente environ 3,3 secondes à partir d'une observation. Si la tâche nécessite une correction dans cette fenêtre, diminuez n_action_steps, pas chunk_size : vous conservez la prédiction longue et ré-observez plus souvent.

# predict 100 actions, re-query after 25 of them (about 0.8 s at 30 fps)
lerobot-train \
  --dataset.repo_id=${HF_USER}/so100_cube \
  --policy.type=act \
  --policy.chunk_size=100 \
  --policy.n_action_steps=25 \
  --policy.device=cuda

Quand ACT surpasse un modèle de fondation

Les cinq politiques entraînables côte à côte, avec les chiffres qu'AY-Robots mesure et utilise pour dimensionner le GPU qu'il loue.

Choisissez ACT lorsque la tâche et la scène sont fixes et que le mouvement doit être rapide et précis. Choisissez un lorsqu'un point de contrôle doit couvrir plusieurs instructions. Deux pages comparent directement la décision : et . Pour les benchmarks publiés, lie chaque chiffre à sa source.

Ce dont vous avez besoin avant de commencer

Un bras suiveur, un bras leader pour la , au moins une caméra, un GPU de 24 Go. ACT ne lit que les images et les positions des articulations. Deux caméras constituent le point idéal : une vue frontale fixe pour savoir où se trouvent les objets, une caméra de poignet pour ce que l' est sur le point de toucher, comme sur ALOHA.

Du bras nu au jeu de données enregistré

Le flux ci-dessous est lerobot 0.6.x. Passez cette étape si vous avez un bras calibré et un jeu de données. Sinon, le guide de démarrage du SO-100 couvre l'assemblage, le tutoriel d'enregistrement couvre la capture et la documentation des jeux de données le format.

1. 1
   Installer lerobot avec les bons extras

   L'enregistrement nécessite core_scripts, l'entraînement training, les servomoteurs Feetech feetech. Python 3.12+.

   bash

   conda create -y -n lerobot python=3.12
   conda activate lerobot
   conda install ffmpeg -c conda-forge
   
   pip install 'lerobot[core_scripts,training,feetech]'
   lerobot-info

2. 2
   Trouver le port USB de chaque bras

   Exécutez-le avec les deux bras branchés, en débranchant l'un d'eux lorsque vous y êtes invité. Sous Linux, vous devrez peut-être ouvrir les permissions du nœud.

   bash

   lerobot-find-port
   # on Linux, if the port exists but is unreadable:
   sudo chmod 666 /dev/ttyACM0

3. 3
   Définir les identifiants des moteurs et le débit en bauds

   Sur le SO-100, cela se fait avant l'assemblage : contrairement au SO-101, les connecteurs sont inaccessibles une fois construit. Le script parcourt le bus un moteur à la fois à partir de la pince, écrivant les identifiants dans l'EEPROM.

   bash

   lerobot-setup-motors \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0
   
   lerobot-setup-motors \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1

4. 4
   Calibrer les deux bras

   Réglez chaque articulation au milieu de sa plage, appuyez sur Entrée, puis balayez chacune sur toute sa plage. La calibration permet à une politique entraînée sur un bras de fonctionner sur un autre. Réutilisez le même id.

   bash

   lerobot-calibrate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower
   
   lerobot-calibrate \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader

5. 5
   Téléopérer une fois avec les caméras allumées

   La règle empirique de lerobot : vous devriez être capable d'effectuer la tâche en regardant uniquement les images de la caméra. Si vous ne le pouvez pas, ACT non plus. Cela permet de détecter plus de mauvais jeux de données que le débogage ultérieur.

   bash

   lerobot-teleoperate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower \
       --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader \
       --display_data=true

6. 6
   Enregistrer 50 épisodes

   50 est le minimum d'AY-Robots et ce qu'ALOHA utilisait par tâche. lerobot conseille 10 par emplacement d'objet, caméras fixes, préhension cohérente. n termine un épisode, r réenregistre, q arrête et encode.

   bash

   HF_USER=$(NO_COLOR=1 hf auth whoami | awk -F': *' 'NR==1 {print $2}')
   
   lerobot-record \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower \
       --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader \
       --dataset.repo_id=${HF_USER}/so100_cube \
       --dataset.num_episodes=50 \
       --dataset.single_task="Grab the black cube and put it in the bin" \
       --display_data=true

Avant l'entraînement, rejouez au moins cinq épisodes. Le format de jeu de données LeRobot stocke les flux de caméra, les états des articulations et les actions par épisode, et la relecture renvoie ces actions au bras. Si la relecture n'effectue pas la tâche, les données ne la contiennent pas et l'entraînement ne l'inventera pas.

lerobot-replay \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower \
    --dataset.repo_id=${HF_USER}/so100_cube \
    --dataset.episode=0

Entraînement de la politique ACT

Ceci est la commande complète. Tout ce qui est spécifique à ACT est déjà une valeur par défaut, c'est pourquoi la page ACT de lerobot recommande de commencer avec celles-ci.

lerobot-train \
  --dataset.repo_id=${HF_USER}/so100_cube \
  --policy.type=act \
  --output_dir=outputs/train/act_so100_cube \
  --job_name=act_so100_cube \
  --policy.device=cuda \
  --wandb.enable=true \
  --policy.repo_id=${HF_USER}/act_so100_cube

--policy.type=act charge ACTConfig, qui s'adapte au nombre de moteurs et de caméras enregistrés par votre jeu de données, de sorte que vous n'avez jamais à déclarer la forme de l'observation. --wandb.enable=true est facultatif et en vaut la peine : la courbe de perte est le seul signal peu coûteux dans une exécution de 100000 étapes. Le calendrier provient de la configuration d'entraînement de lerobot, et non d'ACTConfig : 100000 étapes, lot de 8, graine 1000, un point de contrôle toutes les 20000 étapes, journalisation toutes les 200.

Une exécution complète laisse cinq répertoires de points de contrôle, de 020000 à 100000, plus un lien symbolique last. Gardez-les tous : la meilleure politique n'est souvent pas la dernière.

Durée : environ 5 heures sur une RTX 2080 Ti de 11 Go dans l'article, quelques heures pour 100k étapes selon la page ACT de lerobot, 2 à 5 heures sur le niveau 24 Go d'AY-Robots. Ne l'interrompez pas prématurément. Le README du dépôt de référence indique qu'une politique saccadée ou en pause nécessite généralement plus d'entraînement, car le succès et la fluidité continuent de s'améliorer après que la perte se stabilise : pour les données réelles, il faut au moins 5000 époques, soit 3 à 4 fois la durée après le plateau.

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

Exécution de la politique entraînée sur le bras

Le déploiement utilise lerobot-rollout. Les clés de caméra doivent correspondre à celles enregistrées : une politique entraînée sur front et wrist n'acceptera pas cam0 et cam1, et rename_map n'est d'aucune aide, car il nécessite un point de contrôle pré-entraîné. La chaîne de tâche peut être omise ; l'exemple de lerobot la marque comme facultative pour ACT.

lerobot-rollout \
  --strategy.type=base \
  --policy.path=${HF_USER}/act_so100_cube \
  --robot.type=so100_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_follower \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30} }" \
  --display_data=true \
  --duration=60

Pour épingler un point de contrôle plutôt que le modèle final, ajoutez --policy.pretrained_revision. Cela nécessite que l'exécution ait commencé avec --save_checkpoint_to_hub=true, désactivé par défaut : sans cela, lerobot pousse le modèle final et rien d'autre. Avec cela, chaque point de contrôle est étiqueté avec son étape complétée par des zéros, donc --policy.pretrained_revision=060000 récupère celui de l'étape 60000. Le comparer à 100000 sur le bras réel est l'expérience la moins chère disponible.

Deux chemins vers le même point de contrôle

Tout ce qui précède est la voie manuelle et cela fonctionne. La voie de la plateforme échange le contrôle contre l'absence de GPU ou d'environnement Python.

# the two commands that matter, end to end
lerobot-record --robot.type=so100_follower --robot.port=/dev/ttyACM0 \
  --teleop.type=so100_leader --teleop.port=/dev/ttyACM1 \
  --dataset.repo_id=${HF_USER}/so100_cube --dataset.num_episodes=50 \
  --dataset.single_task="Grab the black cube"

lerobot-train --dataset.repo_id=${HF_USER}/so100_cube --policy.type=act \
  --output_dir=outputs/train/act_so100_cube --policy.device=cuda

Ce qui ne va pas réellement

Presque aucune des difficultés ne réside dans la commande d'entraînement. Elles se trouvent dans les éléments qui l'entourent, classés par la fréquence à laquelle ils posent problème la première fois.

Deux lignes méritent d'être soulignées. ACT s'entraîne sur LeRobot v3.0 tandis que le chargeur de GR00T plante avec et nécessite v2.1, donc un jeu de données qui entraîne ACT peut faire échouer une exécution de GR00T. Et la dernière ligne propose deux solutions : les auteurs d'ACT répondent aux mouvements saccadés par plus d'entraînement, tandis qu'avec n_action_steps à 100, un véritable blocage se produit à la limite d'un segment, une pause visible toutes les 3.3 seconds à 30 fps. Deux autres choses à savoir : une seule articulation morte est généralement un ID de servo qui n'a jamais été écrit, et une pince qui s'approche mais ne se ferme jamais signifie une plage de pince trop faible dans les démonstrations. Index complet : les pages des modes de défaillance.

Ce que coûte une exécution

C'est l'argument pour commencer avec ACT même si vous souhaitez un VLA plus tard. Une exécution ACT échouée coûte le prix d'un café et vous indique en quelques heures si votre ensemble de données contient la tâche. Une exécution GR00T échouée coûte quatre fois plus cher pour la même leçon. Passer à GR00T N1.7 ou SmolVLA par la suite est un changement de forme, pas une reconstruction. Contexte : modèles vision-langage-action, le guide complet du SO-100, entraîner votre première politique et apprentissage par imitation. Pas de bras ? La page en direct diffuse un vrai SO-100 à piloter sans inscription.