Du Hub Hugging Face au matériel robotique avec Strands Agents et LeRobot

Du Hub Hugging Face au robot physique avec Strands Agents et LeRobot

L'intersection entre les grands modèles de langage (LLM) et la robotique connaît une expansion rapide, permettant aux développeurs de passer de la simulation au matériel réel avec une rapidité sans précédent. Deux projets open-source – Strands Agents et LeRobot – sont à l'avant-garde de cette évolution, vous permettant de télécharger des politiques de contrôle robotique depuis le Hub Hugging Face et de les déployer sur des robots physiques. Cet article propose un guide pratique et étape par étape pour combler le fossé entre les modèles d'IA basés sur le cloud et le matériel robotique tangible.

Pourquoi c'est important

Traditionnellement, le développement robotique nécessitait des firmwares personnalisés, des logiciels propriétaires et un réglage manuel intensif. Aujourd'hui, grâce aux référentiels de modèles standardisés et aux frameworks d'agents, vous pouvez :

• **Télécharger des politiques pré-entraînées** (par exemple, pour la préhension, la navigation ou la manipulation) depuis le Hub Hugging Face.
• **Les exécuter avec Strands Agents**, un framework modulaire pour orchestrer les agents d'IA.
• **Les déployer sur du matériel robotique réel** en utilisant LeRobot, une bibliothèque pour le contrôle robotique de bas niveau et la simulation.

Ce pipeline réduit le temps de développement de plusieurs mois à quelques jours et démocratise l'accès à l'IA robotique avancée.

Prérequis

Avant de commencer, assurez-vous que votre système répond aux exigences suivantes :

• **Système d'exploitation** : Ubuntu 22.04 ou version ultérieure (macOS et Windows avec WSL2 sont partiellement pris en charge).
• **Python** : Version 3.10 ou 3.11.
• **Matériel** : Un robot avec une interface prise en charge (par exemple, Franka Emika, UR5, ou un bras personnalisé avec ROS 2). Pour les tests sans matériel, utilisez la simulation intégrée de LeRobot.
• **GPU** : Recommandé pour exécuter de grands LLM (par exemple, GPU NVIDIA avec CUDA 12.1+).
• **Internet** : Pour télécharger les modèles depuis le Hub Hugging Face.

Dépendances logicielles

• **ROS 2 Humble ou Iron** (pour la communication avec le matériel).
• **Git** et **Git LFS** (pour télécharger les fichiers de modèles volumineux).
• **Conda** ou **venv** (pour la gestion des environnements Python).

Installation étape par étape

Nous allons configurer un environnement complet à partir de zéro. Ouvrez un terminal et exécutez chaque bloc de commandes séquentiellement.

1. Créer un environnement virtuel Python

Isolez les dépendances pour éviter les conflits.

python3 -m venv strands_robot_env
source strands_robot_env/bin/activate

2. Installer LeRobot

LeRobot fournit l'interface de bas niveau pour le contrôle robotique. Installez la dernière version depuis PyPI.

pip install lerobot

Si vous prévoyez d'utiliser la simulation (recommandé pour les tests), installez avec les extras de simulation :

pip install "lerobot[sim]"

3. Installer Strands Agents

Strands Agents est la couche d'orchestration de haut niveau. Clonez le dépôt et installez en mode éditable.

git clone https://github.com/huggingface/strands-agents.git
cd strands-agents
pip install -e .

4. Installer ROS 2 (pour la communication avec le matériel)

Si vous avez l'intention d'exécuter sur un robot physique, installez ROS 2 Humble. Suivez le guide d'installation officiel de ROS 2 pour votre système d'exploitation. Pour Ubuntu 22.04 :

sudo apt update
sudo apt install ros-humble-desktop
source /opt/ros/humble/setup.bash

Ajoutez la commande source à votre `~/.bashrc` pour la persistance :

echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc

5. S'authentifier auprès du Hub Hugging Face

Pour télécharger des modèles, connectez-vous au Hub Hugging Face. Vous aurez besoin d'un jeton d'accès utilisateur (créez-en un sur [hf.co/settings/tokens](https://huggingface.co/settings/tokens)).

huggingface-cli login

Collez votre jeton lorsque vous y êtes invité.

6. Vérifier l'installation

Testez que tous les composants sont accessibles.

python -c "import lerobot; print('Version LeRobot :', lerobot.__version__)"
python -c "import strands_agents; print('Strands Agents importé avec succès')"

Téléchargement d'une politique pré-entraînée depuis le Hub Hugging Face

Le Hub Hugging Face héberge des centaines de politiques robotiques. Pour cet exemple, nous utiliserons une politique pour des tâches de pick-and-place, entraînée sur le jeu de données `lerobot/pusht`.

1. Lister les politiques disponibles

Utilisez l'interface en ligne de commande de LeRobot pour parcourir les modèles.

lerobot list --datasets

Cette commande affiche les jeux de données et les politiques associées. Recherchez des entrées comme `lerobot/pusht` ou `lerobot/aloha`.

2. Télécharger une politique spécifique

Téléchargez les poids et la configuration de la politique.

lerobot download --dataset lerobot/pusht --policy diffuser

Cela télécharge la politique `diffuser` pour le jeu de données `pusht` dans `~/.cache/lerobot/`.

3. Inspecter le modèle

Vérifiez la structure de la politique et ses spécifications d'entrée/sortie.

from lerobot.common.policies.diffusion.model import DiffusionPolicy
policy = DiffusionPolicy.from_pretrained("lerobot/pusht")
print(policy.config)

Vous verrez les paramètres de configuration tels que les dimensions d'observation, les dimensions d'action et l'architecture du modèle.

Exécution de la politique avec Strands Agents

Strands Agents encapsule la politique dans un agent capable d'interagir avec l'environnement ou le matériel.

1. Créer un script d'agent simple

Écrivez un fichier Python `run_pusht_agent.py` :

from strands_agents import Agent
from lerobot.common.policies.diffusion.model import DiffusionPolicy
import numpy as np

# Charger la politique
policy = DiffusionPolicy.from_pretrained("lerobot/pusht")

# Définir un agent personnalisé utilisant la politique
class PushtAgent(Agent):
    def __init__(self, policy):
        super().__init__()
        self.policy = policy

    def step(self, observation):
        # Convertir l'observation en tenseur et exécuter la politique
        action = self.policy.select_action(observation)
        return action

# Instancier l'agent
agent = PushtAgent(policy)

# Tester avec une observation factice (par exemple, image et angles articulaires)
dummy_obs = {
    "image": np.random.rand(3, 96, 96).astype(np.float32),
    "joint_positions": np.random.rand(7).astype(np.float32)
}
action = agent.step(dummy_obs)
print("Action prédite :", action)

Exécutez le script :

python run_pusht_agent.py

Cela démontre que l'agent peut traiter des observations et produire des actions.

2. Se connecter à un environnement simulé

LeRobot inclut un environnement de type Gym pour la tâche `pusht`. Utilisez-le pour tester l'agent en simulation.

from lerobot.envs import create_env
from strands_agents import Agent
from lerobot.common.policies.diffusion.model import DiffusionPolicy

# Créer l'environnement
env = create_env("lerobot/pusht", simulation=True)

# Charger la politique
policy = DiffusionPolicy.from_pretrained("lerobot/pusht")

# Encapsuler la politique en tant qu'agent
class PolicyAgent(Agent):
    def step(self, obs):
        return policy.select_action(obs)

agent = PolicyAgent(policy)

# Exécuter un épisode
obs, info = env.reset()
for _ in range(200):
    action = agent.step(obs)
    obs, reward, done, truncated, info = env.step(action)
    if done:
        break
env.close()
print("Épisode terminé.")

Déploiement sur du matériel robotique réel

Passer de la simulation à un robot physique nécessite une configuration spécifique au matériel. Nous utiliserons un bras Franka Emika Panda comme exemple.

1. Configurer l'interface ROS 2

Assurez-vous que les pilotes ROS 2 de votre robot sont en cours d'exécution. Pour Franka, démarrez le pilote `franka_ros2`.

ros2 launch franka_bringup franka.launch.py robot_ip:=192.168.1.100

2. Créer un agent adapté au matériel

Modifiez l'agent pour communiquer avec le robot via les topics ROS 2. Utilisez la classe `Robot` de LeRobot.

from lerobot.robot import Robot
from strands_agents import Agent
from lerobot.common.policies.diffusion.model import DiffusionPolicy

# Initialiser l'interface robot
robot = Robot("franka", control_mode="position")

# Charger la politique
policy = DiffusionPolicy.from_pretrained("lerobot/pusht")

class HardwareAgent(Agent):
    def step(self, obs):
        return policy.select_action(obs)

agent = HardwareAgent(policy)

# Boucle de contrôle principale
while True:
    # Obtenir l'observation actuelle des capteurs du robot
    obs = robot.get_observation()
    # Calculer l'action
    action = agent.step(obs)
    # Envoyer l'action au robot
    robot.send_action(action)

3. Précautions de sécurité

Avant d'exécuter sur du matériel :

• **Définissez des limites de vitesse** dans la configuration du robot.
• **Activez l'arrêt d'urgence**.
• **Commencez avec un mode de gain faible**.
• **Utilisez une limite articulaire virtuelle** pour éviter les collisions.

LeRobot fournit un module `safety` ; ajoutez-le à votre script :

from lerobot.utils.safety import SafetyController
safety = SafetyController(velocity_limit=0.5)
action = safety.limit(action)

Exemples d'utilisation

Exemple 1 : Pick-and-Place avec simulation

Téléchargez une politique de pick-and-place et exécutez-la dans un environnement simulé.

lerobot download --dataset lerobot/aloha --policy act
python -c "
from lerobot.envs import create_env
from lerobot.common.policies.act.model import ACTPolicy
env = create_env('lerobot/aloha', simulation=True)
policy = ACTPolicy.from_pretrained('lerobot/aloha')
obs = env.reset()
for _ in range(500):
    action = policy.select_action(obs)
    obs, reward, done, _, _ = env.step(action)
    if done: break
print('Pick-and-place terminé.')
"

Exemple 2 : Agent personnalisé avec instructions en langage naturel

Strands Agents prend en charge le raisonnement basé sur les LLM. Combinez une politique avec un modèle de langage pour la planification de tâches de haut niveau.

from strands_agents import Agent
from lerobot.common.policies.diffusion.model import DiffusionPolicy
from transformers import pipeline

class LanguageGuidedAgent(Agent):
    def __init__(self, policy, llm):
        self.policy = policy
        self.llm = llm

    def step(self, obs, instruction):
        # Utiliser le LLM pour affiner l'action en fonction de l'instruction
        prompt = f"Étant donné l'observation {obs}, instruction : {instruction}"
        response = self.llm(prompt)
        # Mapper la sortie du LLM aux paramètres de la politique
        return self.policy.select_action(obs)

policy = DiffusionPolicy.from_pretrained("lerobot/pusht")
llm = pipeline("text-generation", model="gpt2")
agent = LanguageGuidedAgent(policy, llm)
action = agent.step(dummy_obs, "Déplacer le bloc vers la gauche")

Résolution des problèmes courants

• **Échec du téléchargement du modèle** : Assurez-vous que Git LFS est installé (`git lfs install`).
• **Erreurs de connexion ROS 2** : Vérifiez que `ROS_DOMAIN_ID` correspond sur tous les nœuds.
• **Mémoire CUDA insuffisante** : Réduisez la taille du lot ou utilisez l'inférence CPU (`device="cpu"` lors du chargement de la politique).
• **Décalage simulation vs matériel** : Normalisez les données d'observation de manière cohérente.

Conclusion

La combinaison du Hub Hugging Face, de Strands Agents et de LeRobot crée un pipeline open-source puissant pour déployer des modèles d'IA sur des robots réels. Vous pouvez désormais télécharger des politiques de pointe, les orchestrer avec une logique d'agent flexible et les exécuter sur du matériel – le tout avec quelques lignes de Python.

Cette approche abaisse la barrière à l'entrée pour la recherche et le développement en robotique, permettant une expérimentation et une itération plus rapides. À mesure que l'écosystème grandit, attendez-vous à une intégration encore plus étroite entre les LLM, la simulation et les robots physiques, rendant plus facile que jamais le passage d'un modèle sur le Hub à un robot dans votre laboratoire.

**Prochaines étapes** : Explorez d'autres jeux de données sur le Hub Hugging Face (par exemple, `lerobot/trifinger`, `lerobot/libero`), expérimentez avec des comportements d'agent personnalisés et contribuez vos propres politiques entraînées à la communauté.