Vom Hugging Face Hub zur Roboterhardware mit Strands Agents und LeRobot

Vom Hugging Face Hub zur Roboterhardware mit Strands Agents und LeRobot

Die Schnittstelle zwischen großen Sprachmodellen (LLMs) und Robotik expandiert rasant und ermöglicht Entwicklern, mit beispielloser Geschwindigkeit von der Simulation zur realen Hardware zu gelangen. Zwei Open-Source-Projekte – Strands Agents und LeRobot – stehen an der Spitze dieser Entwicklung und erlauben es, Robotersteuerungsrichtlinien vom Hugging Face Hub herunterzuladen und auf physischen Robotern einzusetzen. Dieser Artikel bietet eine praktische, schrittweise Anleitung, um die Lücke zwischen cloudbasierten KI-Modellen und greifbarer Roboterhardware zu schließen.

Warum dies wichtig ist

Traditionell erforderte die Robotikentwicklung kundenspezifische Firmware, proprietäre Software und umfangreiches manuelles Tuning. Heute können Sie dank standardisierter Modell-Repositories und Agenten-Frameworks:

• **Vortrainierte Richtlinien** (z. B. für Greifen, Navigation oder Manipulation) vom Hugging Face Hub herunterladen.
• **Sie mit Strands Agents ausführen**, einem modularen Framework zur Orchestrierung von KI-Agenten.
• **Auf realer Roboterhardware ausführen** mit LeRobot, einer Bibliothek für niedrigschwellige Robotersteuerung und Simulation.

Diese Pipeline reduziert die Entwicklungszeit von Monaten auf Tage und demokratisiert den Zugang zu fortgeschrittener Robotik-KI.

Voraussetzungen

Stellen Sie vor Beginn sicher, dass Ihr System die folgenden Anforderungen erfüllt:

• **Betriebssystem**: Ubuntu 22.04 oder neuer (macOS und Windows mit WSL2 werden teilweise unterstützt).
• **Python**: Version 3.10 oder 3.11.
• **Hardware**: Ein Roboter mit unterstützter Schnittstelle (z. B. Franka Emika, UR5 oder ein kundenspezifischer Arm mit ROS 2). Zum Testen ohne Hardware verwenden Sie die integrierte Simulation von LeRobot.
• **GPU**: Empfohlen für die Ausführung großer LLMs (z. B. NVIDIA GPU mit CUDA 12.1+).
• **Internet**: Zum Herunterladen von Modellen vom Hugging Face Hub.

Software-Abhängigkeiten

• **ROS 2 Humble oder Iron** (für die Hardware-Kommunikation).
• **Git** und **Git LFS** (zum Herunterladen großer Modelldateien).
• **Conda** oder **venv** (für die Python-Umgebungsverwaltung).

Schritt-für-Schritt-Installation

Wir richten eine vollständige Umgebung von Grund auf ein. Öffnen Sie ein Terminal und führen Sie die einzelnen Befehlsblöcke nacheinander aus.

1. Erstellen einer Python-Virtual-Umgebung

Isolieren Sie Abhängigkeiten, um Konflikte zu vermeiden.

python3 -m venv strands_robot_env
source strands_robot_env/bin/activate

2. Installieren von LeRobot

LeRobot bietet die niedrigschwellige Schnittstelle für die Robotersteuerung. Installieren Sie die neueste Version von PyPI.

pip install lerobot

Wenn Sie die Simulation nutzen möchten (zum Testen empfohlen), installieren Sie mit den Simulationserweiterungen:

pip install "lerobot[sim]"

3. Installieren von Strands Agents

Strands Agents ist die hochrangige Orchestrierungsschicht. Klonen Sie das Repository und installieren Sie es im bearbeitbaren Modus.

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

4. Installieren von ROS 2 (für Hardware-Kommunikation)

Wenn Sie auf einem physischen Roboter arbeiten möchten, installieren Sie ROS 2 Humble. Folgen Sie der offiziellen ROS 2-Installationsanleitung für Ihr Betriebssystem. Für Ubuntu 22.04:

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

Fügen Sie den Source-Befehl zur dauerhaften Nutzung in Ihre `~/.bashrc` ein:

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

5. Authentifizierung am Hugging Face Hub

Um Modelle herunterzuladen, melden Sie sich am Hugging Face Hub an. Sie benötigen einen Benutzerzugriffstoken (erstellen Sie einen unter [hf.co/settings/tokens](https://huggingface.co/settings/tokens)).

huggingface-cli login

Fügen Sie Ihr Token ein, wenn Sie dazu aufgefordert werden.

6. Installation überprüfen

Testen Sie, ob alle Komponenten zugänglich sind.

python -c "import lerobot; print('LeRobot version:', lerobot.__version__)"
python -c "import strands_agents; print('Strands Agents imported successfully')"

Herunterladen einer vortrainierten Richtlinie vom Hugging Face Hub

Der Hugging Face Hub hostet Hunderte von Roboterrichtlinien. Für dieses Beispiel verwenden wir eine Richtlinie für Pick-and-Place-Aufgaben, die auf dem Datensatz `lerobot/pusht` trainiert wurde.

1. Verfügbare Richtlinien auflisten

Verwenden Sie die LeRobot-CLI, um Modelle zu durchsuchen.

lerobot list --datasets

Dieser Befehl zeigt Datensätze und zugehörige Richtlinien an. Suchen Sie nach Einträgen wie `lerobot/pusht` oder `lerobot/aloha`.

2. Eine bestimmte Richtlinie herunterladen

Laden Sie die Richtliniengewichte und die Konfiguration herunter.

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

Dies lädt die `diffuser`-Richtlinie für den `pusht`-Datensatz in `~/.cache/lerobot/` herunter.

3. Das Modell inspizieren

Überprüfen Sie die Struktur der Richtlinie sowie die Eingabe-/Ausgabespezifikationen.

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

Sie sehen Konfigurationsparameter wie Beobachtungsdimensionen, Aktionsdimensionen und die Modellarchitektur.

Ausführen der Richtlinie mit Strands Agents

Strands Agents verpackt die Richtlinie in einen Agenten, der mit der Umgebung oder Hardware interagieren kann.

1. Ein einfaches Agentenskript erstellen

Schreiben Sie eine Python-Datei `run_pusht_agent.py`:

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

# Richtlinie laden
policy = DiffusionPolicy.from_pretrained("lerobot/pusht")

# Einen benutzerdefinierten Agenten definieren, der die Richtlinie verwendet
class PushtAgent(Agent):
    def __init__(self, policy):
        super().__init__()
        self.policy = policy

    def step(self, observation):
        # Beobachtung in Tensor umwandeln und Richtlinie ausführen
        action = self.policy.select_action(observation)
        return action

# Agenten instanziieren
agent = PushtAgent(policy)

# Mit einer Dummy-Beobachtung testen (z. B. Bild und Gelenkwinkel)
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("Vorhergesagte Aktion:", action)

Führen Sie das Skript aus:

python run_pusht_agent.py

Dies zeigt, dass der Agent Beobachtungen verarbeiten und Aktionen ausgeben kann.

2. Mit einer simulierten Umgebung verbinden

LeRobot enthält eine Gym-ähnliche Umgebung für die `pusht`-Aufgabe. Verwenden Sie diese, um den Agenten in der Simulation zu testen.

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

# Umgebung erstellen
env = create_env("lerobot/pusht", simulation=True)

# Richtlinie laden
policy = DiffusionPolicy.from_pretrained("lerobot/pusht")

# Richtlinie als Agenten verpacken
class PolicyAgent(Agent):
    def step(self, obs):
        return policy.select_action(obs)

agent = PolicyAgent(policy)

# Eine Episode ausführen
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("Episode beendet.")

Einsatz auf realer Roboterhardware

Der Übergang von der Simulation zur physischen Hardware erfordert hardwarespezifische Konfiguration. Wir verwenden als Beispiel einen Franka Emika Panda-Arm.

1. ROS 2-Schnittstelle konfigurieren

Stellen Sie sicher, dass die ROS 2-Treiber Ihres Roboters laufen. Für Franka starten Sie den `franka_ros2`-Treiber.

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

2. Einen hardwarebewussten Agenten erstellen

Modifizieren Sie den Agenten, um über ROS 2-Themen mit dem Roboter zu kommunizieren. Verwenden Sie die `Robot`-Klasse von LeRobot.

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

# Roboterschnittstelle initialisieren
robot = Robot("franka", control_mode="position")

# Richtlinie laden
policy = DiffusionPolicy.from_pretrained("lerobot/pusht")

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

agent = HardwareAgent(policy)

# Hauptsteuerungsschleife
while True:
    # Aktuelle Beobachtung von den Robotersensoren abrufen
    obs = robot.get_observation()
    # Aktion berechnen
    action = agent.step(obs)
    # Aktion an den Roboter senden
    robot.send_action(action)

3. Sicherheitsvorkehrungen

Bevor Sie auf Hardware ausführen:

• **Geschwindigkeitsbegrenzungen** in der Roboter-Konfiguration festlegen.
• **Not-Aus aktivieren**.
• **Mit niedriger Verstärkung beginnen**.
• **Virtuelle Gelenkbegrenzungen** verwenden, um Kollisionen zu vermeiden.

LeRobot bietet ein `safety`-Modul; fügen Sie es Ihrem Skript hinzu:

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

Anwendungsbeispiele

Beispiel 1: Pick-and-Place mit Simulation

Laden Sie eine Pick-and-Place-Richtlinie herunter und führen Sie sie in einer simulierten Umgebung aus.

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 abgeschlossen.')
"

Beispiel 2: Benutzerdefinierter Agent mit Sprachbefehlen

Strands Agents unterstützt LLM-basiertes Denken. Kombinieren Sie eine Richtlinie mit einem Sprachmodell für die hochrangige Aufgabenplanung.

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):
        # LLM verwenden, um die Aktion basierend auf der Anweisung zu verfeinern
        prompt = f"Gegeben Beobachtung {obs}, Anweisung: {instruction}"
        response = self.llm(prompt)
        # LLM-Ausgabe auf Richtlinienparameter abbilden
        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, "Bewege den Block nach links")

Fehlerbehebung bei häufigen Problemen

• **Modell-Download schlägt fehl**: Stellen Sie sicher, dass Git LFS installiert ist (`git lfs install`).
• **ROS 2-Verbindungsfehler**: Überprüfen Sie, ob `ROS_DOMAIN_ID` auf allen Knoten übereinstimmt.
• **CUDA-Speicher voll**: Reduzieren Sie die Batch-Größe oder verwenden Sie CPU-Inferenz (`device="cpu"` beim Laden der Richtlinie).
• **Simulation vs. Hardware-Unterschiede**: Normalisieren Sie Beobachtungsdaten konsistent.

Fazit

Die Kombination aus Hugging Face Hub, Strands Agents und LeRobot schafft eine leistungsstarke Open-Source-Pipeline für den Einsatz von KI-Modellen auf echten Robotern. Sie können jetzt hochmoderne Richtlinien herunterladen, mit flexibler Agentenlogik orchestrieren und auf Hardware ausführen – alles mit wenigen Zeilen Python.

Dieser Ansatz senkt die Einstiegshürde für Robotik-Forschung und -Entwicklung und ermöglicht schnellere Experimente und Iterationen. Mit dem Wachstum des Ökosystems ist eine noch engere Integration zwischen LLMs, Simulation und physischen Robotern zu erwarten, was es einfacher denn je macht, von einem Modell auf dem Hub zu einem Roboter in Ihrem Labor zu gelangen.

**Nächste Schritte**: Erkunden Sie weitere Datensätze auf dem Hugging Face Hub (z. B. `lerobot/trifinger`, `lerobot/libero`), experimentieren Sie mit benutzerdefinierten Agentenverhalten und tragen Sie Ihre eigenen trainierten Richtlinien zur Community bei.