Le robot qui s’entraîne seul : comment l’IA apprend en continu sans jamais s’arrêter

UN ROBOT QUI S’ENTRAÎNE TOUT SEUL ? OUI, C’EST POSSIBLE

Imaginez un robot qui, pendant que vous dormez, enregistre ses propres démonstrations de tâches, les stocke dans le cloud, et s’entraîne en permanence pour améliorer ses performances. Sans jamais avoir besoin de télécharger un seul fichier. Sans jamais perdre de temps à copier des données. Sans jamais s’arrêter. C’est exactement ce que permettent Strands Robots et LeRobot, deux Outils open source développés par Amazon et Hugging Face. Ensemble, ils forment un système où un seul agent (une sorte de cerveau artificiel) peut gérer l’enregistrement, l’entraînement et le déploiement d’un robot, le tout depuis une seule interface. Le tout, en temps réel.

QUATRE ÉTAPES POUR UNE BOUCLE INFINIE : ENREGISTRER, STOCKER, ENTRAÎNER, DÉPLOYER

La magie opère en quatre étapes, qui forment une boucle sans fin :

Le robot utilisé ici s’appelle SO-100, une version simulée (donc sans matériel physique) qui permet de tester tout le système sans risque. Mais le même code fonctionne sur un robot réel, comme le SO-101, avec quelques ajustements. Voici comment ça marche, étape par étape.

ÉTAPE 1 : ENREGISTRER UNE DÉMONSTRATION SANS SE PRENDRE LA TÊTE

Tout commence par un simple message envoyé à l’agent. Par exemple : « Enregistre une démonstration de ramassage de cube rouge et stocke-la dans mon dossier my-org/robot-fave ». Derrière ce message se cache une série d’actions automatiques :

• Création d’un monde virtuel avec le robot SO-100.
• Ajout d’un cube rouge et d’une caméra frontale.
• Lancement de l’enregistrement à 30 images par seconde.
• Exécution d’une politique par défaut (un algorithme qui génère des mouvements aléatoires, juste pour remplir le dataset).
• Arrêt de l’enregistrement après 60 étapes.

Le résultat ? Un dataset au format LeRobot, déjà utilisé par plus de 90 000 datasets et modèles sur Hugging Face. Ce format est devenu une norme : tout outil capable de lire des données LeRobot peut lire ce dataset sans conversion. Pratique.

Voici le code qui fait tout ça, en quelques lignes seulement :

from strands import Agent
from strands_robots import Robot

sim = Robot("so100")  # mode="sim" par défaut (sans matériel)
agent = Agent(tools=[sim])

# Enregistre une démonstration et la stocke dans un bucket.
agent("Record a pick-the-cube demo and sync it to my-org/robot-fave.")

Mais où est stockée cette démonstration ? Pas dans un dataset classique, versionné et figé. Non : elle va directement dans un Storage Bucket, un espace de stockage mutable (modifiable en permanence) et non versionné, introduit par Hugging Face en mars 2026. Un bucket, c’est comme un dossier partagé dans le cloud, où vous pouvez écrire et réécrire des données à l’infini, sans garder toutes les versions. Parfait pour une collecte de données en continu.

Pour synchroniser le dataset local avec le bucket, une seule ligne de code suffit :

from strandsrobots import syncdatasettobucket

syncdatasettobucket("/tmp/cubepick", "my-org/robot-fave")
# Résultat : {"status": "success", "bucketuri": "hf://buckets/my-org/robot-fave/cubepick"}

Le dataset est maintenant dans le bucket, prêt à être utilisé. Et le plus beau ? Vous n’avez rien eu à configurer : pas de rôles IAM, pas de règles CORS, pas de service d’upload à maintenir. Tout est géré par Hugging Face.

ÉTAPE 2 : STOCKER LES DONNÉES INTELLIGEMMENT POUR ÉCONOMISER DU TEMPS ET DE L’ESPACE

Si vous enregistrez des démonstrations toute la journée, votre bucket va grossir. Très vite. Mais est-ce que toutes ces données sont vraiment nouvelles ? Pas forcément. Par exemple, si votre robot répète la même tâche (ramasser un cube) dans le même environnement (une table avec la même lumière), la plupart des images seront identiques d’une démonstration à l’autre. Pourtant, dans un dataset classique, chaque modification d’un fichier vidéo de plusieurs gigaoctets forcerait à tout réupload. Résultat : des heures de calcul perdues et des factures de cloud gonflées.

C’est là que les Storage Buckets de Hugging Face changent la donne. Ils utilisent une technologie appelée Xet, qui déduplique les données au niveau des octets. Concrètement, Xet découpe les fichiers en petits morceaux (appelés « chunks ») et ne réupload que ceux qui ont changé. Si vous modifiez 1 % d’un fichier de 500 Mo, Xet n’enverra que 5,5 Mo au lieu de 500 Mo. Si vous modifiez 10 %, ce sera 55 Mo. Sans Xet, vous auriez dû tout renvoyer. Avec Xet, vous économisez jusqu’à 75 % de bande passante et de stockage.

Résultat : plus besoin de garder des versions inutiles, plus besoin de gaspiller de la bande passante. Votre bucket reste léger, et votre portefeuille aussi.

ÉTAPE 3 : ENTRAÎNER LE ROBOT EN TEMPS RÉEL, SANS TÉLÉCHARGER UN SEUL FICHIER

Traditionnellement, pour entraîner un modèle de robotique, vous téléchargez d’abord tout le dataset sur votre GPU. Pendant ce temps, votre GPU ne fait rien. Puis, une fois le téléchargement terminé (ce qui peut prendre des heures pour des datasets de plusieurs téraoctets), l’entraînement commence. Résultat : des heures de temps machine perdues, des factures de cloud élevées, et une frustration certaine.

Avec Strands Robots et LeRobot, tout change. Grâce au format shardé (découpé en morceaux) des datasets LeRobot et à la technologie Xet, vous pouvez entraîner votre modèle directement depuis le bucket, sans jamais télécharger un seul fichier. Comment ? En utilisant un streaming dataset.

Le principe est simple : au lieu de copier tout le dataset sur votre disque local, votre GPU lit les données directement depuis le bucket, morceau par morceau, au fur et à mesure de son besoin. Votre GPU commence à s’entraîner dès la première image, sans attendre. Voici comment ça marche en code :

reader = sim.streamdataset("my-org/robot-fave/cubepick", repo_type="bucket",
    shuffle=False, maxnumshards=1, buffer_size=1,  # un épisode, dans l'ordre d'enregistrement
)

print(reader.numepisodes, reader.numframes, reader.fps)

for frame in reader:
    frame["observation.images.front"]   # (3, H, W) tenseur, décodé à la volée depuis le shard MP4
    frame["observation.state"]           # vecteur d'articulations, depuis le shard Parquet
    frame["action"]
    break

Rien n’est stocké sur votre disque local, sauf un petit dossier meta/ contenant le schéma, les statistiques et l’index des épisodes. Les images des caméras sont décodées à la volée depuis les shards MP4 distants, tandis que les états des articulations et les actions viennent des shards Parquet. Vous pouvez inspecter un épisode frame par frame, ou passer directement à l’entraînement en utilisant un DataLoader PyTorch.

Pour l’entraînement, le code ressemble à ceci :

# Supposons que 'policy' est une politique LeRobot comme ACTPolicy.
for batch in reader.dataloader(batchsize=64, numworkers=4):
    loss,  = policy(batch)   # La méthode forward de ACTPolicy retourne (loss, lossdict)
    loss.backward()

Votre GPU s’entraîne en continu, sans interruption, sans temps d’attente. Et le plus beau ? Tout ça fonctionne sur un simple ordinateur portable, tant que vous avez les bonnes bibliothèques installées.

ÉTAPE 4 : DÉPLOYER LA NOUVELLE VERSION SUR LE ROBOT EN UN CLIC

Une fois l’entraînement terminé, vous obtenez un checkpoint (un fichier contenant les poids du modèle entraîné). Pour le déployer sur votre robot, il suffit de changer un argument dans votre code : mode="real" au lieu de mode="sim". Le même robot qui a enregistré les démonstrations peut maintenant exécuter la politique entraînée.

Voici comment faire en code :

# Pour déployer sur un robot réel (par exemple, un SO-101)
robot = Robot("so100", mode="real", port="/dev/ttyACM0",
              cameras={"front": {"type": "opencv", "indexorpath": "/dev/video0", "fps": 30}})
agent = Agent(tools=[robot])
agent("Pick up the red cube.")

Et voilà . Votre robot, qui s’est entraîné tout seul grâce à vos démonstrations, est maintenant prêt à exécuter la tâche demandée. Mieux encore : les nouvelles démonstrations qu’il enregistre en conditions réelles peuvent être synchronisées dans le même bucket, formant une boucle d’amélioration continue.

COMMENT INSTALLER TOUT ÇA SUR VOTRE ORDINATEUR ?

Pas besoin d’un supercalculateur pour commencer. Voici les prérequis minimaux :

• Un ordinateur sous Linux ou macOS (Apple Silicon est supporté pour le backend MuJoCo).
• Python 3.12 ou supérieur.
• Un fournisseur de modèles compatible avec Strands (par exemple, Amazon Bedrock, Anthropic, OpenAI, ou Ollama en local).
• Les bibliothèques Strands Robots avec les extras pour LeRobot :

uv pip install -U "strands-robots[sim-mujoco,lerobot]>=0.5.1"

Cette commande installe Strands Robots, LeRobot (version >= 0.6.1), ainsi que les bibliothèques nécessaires pour l’enregistrement et le décodage vidéo. Tout est prêt pour enregistrer et entraîner en simulation.

Pour aller plus loin (utiliser des buckets, entraîner sur du matériel réel, ou entraîner à grande échelle), voici ce qu’il faut en plus :

• Un compte Hugging Face et un token avec des permissions d’écriture.
• Le CLI Hugging Face pour créer des buckets et synchroniser les datasets :

pip install -U "huggingface-hub>=1.6.0,<2.0.0"
hf auth login

Pour l’entraînement à grande échelle, une GPU est nécessaire. Pour entraîner avec LeRobot, installez le package dédié :

uv pip install "lerobot[training]"

Sans cette installation, l’étape d’entraînement retournera une erreur au lieu d’un checkpoint.

ENREGISTRER DES DÉMONSTRATIONS SUR UN ROBOT PHYSIQUE : C’EST POSSIBLE

Jusqu’ici, tout a été fait en simulation. Mais Strands Robots et LeRobot fonctionnent aussi sur du matériel réel. Par exemple, pour enregistrer des démonstrations sur un robot physique comme le SO-101, vous pouvez utiliser la commande lerobot-record :

lerobot-record \
  --robot.type=so101follower --robot.id=myfollower \
  --teleop.type=so101leader  --teleop.id=myleader \
  --dataset.repoid=myuser/cube_picking \
  --dataset.single_task='Pick up the red cube'

Cette commande configure un système de téléopération où un utilisateur guide le robot (le « leader ») tandis qu’un autre robot (le « follower ») enregistre ses mouvements. Le dataset généré est identique à celui produit en simulation : même format, même structure. Il suffit ensuite de synchroniser ce dataset dans le bucket :

syncdatasettobucket("./recordings", "my-org/robot-fave", runid="run-021")

Ou, si vous préférez utiliser le CLI Hugging Face :

hf sync ./recordings hf://buckets/my-org/robot-fave/run-021

Le dataset est maintenant dans le bucket, prêt à être utilisé pour l’entraînement en streaming.

ENTRAÎNER UN MODÈLE AVEC LE DATASET EN STREAMING

Pour entraîner un modèle à partir du dataset en streaming, vous utilisez la commande lerobot-train. Voici comment faire :

lerobot-train --policy.type=act \
  --dataset.repoid=my-org/robot-fave/cubepick \
  --dataset.repo_type=bucket \
  --dataset.streaming=true \
  --num_workers=4

Cette commande lance l’entraînement d’une politique de type ACT (une politique basée sur des transformers) sur le dataset en streaming. Les arguments clés sont :

• --dataset.repo_type=bucket : indique que le dataset est dans un bucket.
• --dataset.streaming=true : active le streaming des données.
• --num_workers=4 : utilise 4 processus pour paralléliser le chargement des données.

Si vous préférez utiliser l’API Python, voici comment faire :

import os
os.environ["STRANDSTRUSTREMOTE_CODE"] = "1"   # Permet de charger du code distant en toute sécurité

from strandsrobots import createpolicy
from strandsrobots.training import TrainSpec, createtrainer

trainer = createtrainer("lerobotlocal", device="cuda")
spec = TrainSpec(datasetroot="/tmp/cubepick", outputdir="/tmp/cubepick_ft",
                 basemodel="", steps=500, extra={"policytype": "act"})
result = trainer.train(spec)                    # Entraîne ACT sur le dataset streamé
policy = createpolicy(result.checkpointdir)   # Charge le checkpoint directement

Une fois l’entraînement terminé, vous pouvez valider le modèle avec :

trainer.validate(spec)

LA BOUCLE COMPLÈTE : UN SEUL AGENT POUR TOUT FAIRE

Le vrai pouvoir de ce système réside dans sa simplicité. Un seul agent peut gérer toute la boucle : enregistrement, stockage, entraînement, déploiement. Voici comment cela se traduit en code :

from strands import Agent
from strands_robots import Robot

sim = Robot("so100")  # mode="sim" par défaut
agent = Agent(tools=[sim])

# Enregistre une démonstration et la stocke dans un bucket.
agent("Record a pick-the-cube demo and sync it to my-org/robot-fave.")

# Lit le dataset en streaming depuis le bucket pour l'entraînement.
for batch in sim.streamdataset("my-org/robot-fave/cubepick", repotype="bucket").dataloader(batchsize=64):
    .

Et pour déployer la politique entraînée sur le robot réel :

robot = Robot("so100", mode="real", port="/dev/ttyACM0",
              cameras={"front": {"type": "opencv", "indexorpath": "/dev/video0", "fps": 30}})
agent = Agent(tools=[robot])
agent("Pick up the red cube.")

Le même code, avec un seul changement (mode="sim" vs mode="real"), permet de passer de la simulation au matériel réel. Tout est géré par le même backend, le même format de dataset, et la même interface.

POURQUOI CE SYSTÈME EST-UNE RÉVOLUTION ?

Avant, pour entraîner un robot, il fallait :

• Enregistrer des démonstrations.
• Télécharger le dataset sur un GPU.
• Attendre des heures que le téléchargement se termine.
• Lancer l’entraînement.
• Déployer la politique sur le robot.
• Répéter tout depuis le début pour chaque nouvelle version.

Avec Strands Robots et LeRobot, tout cela devient obsolète. Vous pouvez :

• Enregistrer des démonstrations toute la journée, automatiquement.
• Stocker les données dans un bucket avec déduplication au niveau des octets.
• Entraîner votre modèle en streaming, sans télécharger un seul fichier.
• Déployer la nouvelle politique en un clic.
• Recommencer la boucle, encore et encore, sans jamais perdre de temps.

Résultat : des robots qui s’améliorent en permanence, des coûts réduits, et une productivité décuplée. Le tout, avec des outils open source, accessibles à tous.

ET SI JE VEUX SUPPRIMER DES DONNÉES ?

Parfois, il faut nettoyer. Pour supprimer un dataset d’un bucket, vous pouvez utiliser le CLI Hugging Face :

hf buckets rm my-org/robot-fave/cube_pick/ --recursive --dry-run  # Liste les fichiers, ne supprime rien
hf buckets rm my-org/robot-fave/cube_pick/ --recursive            # Supprime tout (--yes pour éviter la confirmation)
hf buckets delete my-org/robot-fave                               # Supprime tout le bucket

Et pour nettoyer votre disque local après une session de test :

rm -rf /tmp/cubepick /tmp/cubepickft /tmp/nb5dataset /tmp/nb5_ft

EN PRATIQUE : PAR OÙ COMMENCER ?

Si vous voulez tester ce système par vous-même, voici comment faire :

1. Clonez le dépôt Strands Robots :

git clone https://github.com/strands-labs/robots.git
cd robots
uv pip install -U "strands-robots[sim-mujoco,lerobot]>=0.5.1"
jupyter notebook examples/notebooks/05streamingdata_loop.ipynb

Ouvrez le notebook 05streamingdata_loop.ipynb et suivez les instructions pas à pas. Vous aurez besoin d’un notebook Jupyter installé sur votre machine.

Si vous préférez coder en Python directement, vous pouvez aussi utiliser l’exemple 06agentcollectandstream.py :

# Exemple simplifié pour collecter et streamer des données
from strands import Agent
from strandsrobots import Robot, syncdatasettobucket

sim = Robot("so100")
agent = Agent(tools=[sim])

# Enregistre une démonstration et la stocke dans un bucket
agent("Record a pick-the-cube demo and sync it to my-org/robot-fave.")

# Synchronise un dataset local dans un bucket
syncdatasettobucket("./recordings", "my-org/robot-fave", runid="run-021")

# Arrête l'enregistrement en cours et synchronise dans le bucket
stop_recording(bucket="my-org/robot-fave")

Avec ces exemples, vous pouvez commencer à expérimenter en quelques minutes. Et si vous avez des questions ou des problèmes, le guide de dépannage de Strands Robots est là pour vous aider.

LE FUTUR DE LA ROBOTIQUE : UNE BOUCLE D’AMÉLIORATION CONTINUE

Ce système n’est pas qu’une démonstration technique. C’est une vision de l’avenir de la robotique : des robots qui apprennent en continu, qui s’adaptent en temps réel, et qui s’améliorent sans intervention humaine. Plus besoin d’attendre des semaines pour entraîner un nouveau modèle. Plus besoin de gaspiller des ressources. Plus besoin de tout recommencer depuis zéro.

Avec Strands Robots et LeRobot, la robotique devient enfin accessible, scalable, et durable. Et le plus beau ? Tout est open source. Vous pouvez contribuer, modifier, ou simplement utiliser ces outils pour vos propres projets. Le futur de la robotique est entre vos mains.