RoboMimic Tutorial: Einrichtung, Benchmarks & Training Ihre erste Politik

[← Führer] T17) / [Ausbildung imitieren] T18)

Ein kompletter Durchgang durch RoboMimic, das führende Offline-Imitations-Lern-Framework für Robotermanipulation. Von der Installation über die Ausbildung Ihrer ersten BC-Politik bis hin zur Ausführung der kompletten Benchmark-Suite.

Was ist RoboMimic?

RoboMimic ist ein Open-Source-Framework für das Studium und Benchmarking von Offline-Imitierungs-Lernalgorithmen für Robotermanipulation. Das Projekt bietet drei Dinge, die bisher nicht in einem einheitlichen Paket vorhanden waren: standardisierte Demonstrationsdatenmengen, die in Robosuite-Simulation gesammelt wurden, Referenzimplementierungen von sechs Algorithmen für das Imitationslernen und reproduzierbare Bewertungsprotokolle für einen fairen Vergleich.

Die sechs unterstützten Algorithmen erstrecken sich über die wichtigsten Familien des Offline-Lernens:

**Verhaltensklonung (BC) ** Aufsicht der Regression von Beobachtungen zu Aktionen.
BC-RNN BC mit einem LSTM-Rückgrat, das die Beobachtungsgeschichte bedingt. Erfasst zeitliche Abhängigkeiten, die die Feedforward BC verpasst.
**BCQ (Batch Constrained Q-Learning) ** eine offline-RL-Methode, die die Politik dazu zwingt, bei der Optimierung der Q-Werte nahe an der Demonstrationsverteilung zu bleiben.
**CQL (Conservative Q-Learning) ** Offline-RL, die Q-Werte für außervertriebliche Aktionen bestraft und Überschätzung verhindert.
**IQL (Implicit Q-Learning) ** Vermeidet die Abfrage von außerverteilten Aktionen durch das Lernen einer Wertschöpfungsfunktion durch erwartete Regression.
TD3-BC TD3 mit einem Verhaltensklon-Regulierungsbegriff, der die Politik in der Nähe der Daten hält und gleichzeitig eine Verbesserung der RL ermöglicht.

RoboMimic ist wichtig, weil es eine praktische Frage beantwortet: Angesichts eines festen Datensatzes menschlicher Demonstrationen, welcher Algorithmus extrahiert die beste Politik? Vor RoboMimic, jedes Papier verwendet verschiedene Umgebungen, verschiedene Daten und verschiedene Bewertung so dass Apfel-zu-Apfel-Vergleich unmöglich. Das Framework unterstützt auch [echte Roboterdaten]T19) im gleichen HDF5-Format, so dass die Ergebnisse von Simulationsbenchmarks auf Hardware-Einführung übertragen werden.

Installation

RoboMimic benötigt Python 3.8+ und ist für Simulationsumgebungen von Robosuite abhängig.

# Create and activate conda environment
conda create -n robomimic python=3.10
conda activate robomimic

# Install robomimic and robosuite
pip install robomimic
pip install robosuite

# For development (editable install with source)
git clone https://github.com/ARISE-Initiative/robomimic.git
cd robomimic
pip install -e .

# Verify installation
python -c "import robomimic; print(robomimic.__version__)"

Für GPU-beschleunigtes Training (zur Erfüllung von Bild-basierten Richtlinien erforderlich) installieren Sie zuerst PyTorch mit CUDA-Unterstützung:

# PyTorch with CUDA 12.1 (adjust for your CUDA version)
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

# Then install robomimic
pip install robomimic

Überprüfen Sie, ob Ihre GPU für PyTorch sichtbar ist, bevor Sie mit der Arbeit beginnen:

python -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}, Device: {torch.cuda.get_device_name(0)}')"

Datensätze

RoboMimic bietet vorgefasste Demonstrationsdatenmengen für vier Robosuite-Manipulationsaufgaben. Jeder Datensatz besteht aus zwei Operatorqualitätsniveaus (befähiger Mensch und mehrmenschlicher Mensch) und zwei Beobachtungstypen (niedrigdimensionaler Zustand und Bild).

Laden Sie Datenmengen mit dem eingebauten Skript herunter:

# Download the Lift task dataset (low-dim, proficient-human, 200 demos)
python robomimic/scripts/download_datasets.py --tasks lift

# Download all four tasks
python robomimic/scripts/download_datasets.py --tasks all

# Download image observation datasets (larger, ~10 GB per task)
python robomimic/scripts/download_datasets.py --tasks lift --dataset_type image

Jeder Datensatz wird als HDF5-Datei mit der folgenden Struktur gespeichert:

Daten/Demo_0/obs/ Beobachtungsmaschinen (Gemäßpositionen, Endeffektorposen, Griffzustände, optionale Bilder)
Daten/Demo_0/Aktionen Aktionsarrays (gemeinsame Geschwindigkeits- oder Positionsziele)
Daten/Demo_0/Rewards spärliches Belohnungssignal (1 bei Erfolg, 0 sonst)
Daten/Demo_0/dones Episode-Entscheidungsflaggen
Daten/Mask/ Zug/Validationsspalt-Index

Niedrigdimensionale Beobachtungen umfassen die Roboter-Gelenkpositionen (7D), die Gelenkgeschwindigkeiten (7D), die End-Effektor-Position (3D), die End-Effektor-Orientierung (4D Quaternion) und die Grifföffnung (1D). Bei zweimannigen Aufgaben wie Transport werden alle Arrays verdoppelt (eine pro Arm).

Erziehe deine erste Politik

Der schnellste Weg zu einer geschulten Politik ist BC auf der Aufgabengebietung mit niedrigdimensionalen Beobachtungen.

Schritt 1: Erstellen Sie eine Ausbildungskonfiguration.

# Generate a default BC config for the Lift task
python robomimic/scripts/generate_config.py \
  --algo bc \
  --task lift \
  --dataset_path datasets/lift/ph/low_dim.hdf5 \
  --output_dir configs/

Schritt 2: Überprüfen und ändern Sie die Konfiguration. Die generierte JSON-Konfiguration steuert jeden Ausbildungsparameter.

{
  "algo_name": "bc",
  "experiment": {
    "name": "bc_lift_lowdim",
    "epoch_every_n_steps": 500,
    "validation_epoch_every_n_steps": 50,
    "save.enabled": true
  },
  "train": {
    "data": "datasets/lift/ph/low_dim.hdf5",
    "batch_size": 100,
    "num_epochs": 2000,
    "seed": 1
  },
  "observation": {
    "modalities": {
      "obs": {
        "low_dim": ["robot0_eef_pos", "robot0_eef_quat", "robot0_gripper_qpos", "object"]
      }
    }
  }
}

Schritt 3: Laufen Sie Training.

python robomimic/scripts/train.py --config configs/bc_lift_lowdim.json

# Training logs to stdout and TensorBoard
# Monitor: tensorboard --logdir trained_models/

Schritt 4: Beurteilung der ausgebildeten Politik.

# Run 50 evaluation rollouts
python robomimic/scripts/run_trained_agent.py \
  --agent trained_models/bc_lift_lowdim/models/model_best.pth \
  --n_rollouts 50 \
  --render

Wenn Sie eine Erfolgsrate von über 95% auf Lift mit Fachmenschen-Daten sehen sollten.

Algorithmenvergleich

Die Wahl des richtigen Algorithmus hängt von Ihrem Datenbudget, Ihrem Rechenbudget und der Komplexität der Aufgaben ab.

Algorithm	Type	Data Efficiency	Compute Cost	Best For	Key Limitation
BC	Supervised	High	Low	Simple tasks, good data	Compounding errors on long horizons
BC-RNN	Supervised	High	Medium	Multi-step tasks, temporal reasoning	Slower inference, harder to tune
BCQ	Offline-RL	Medium	High	Suboptimal data, needs improvement	Sensitive to hyperparameters
CQL	Offline-RL	Medium	High	Conservative policies from noisy data	Can be overly conservative
IQL	Offline-RL	Medium	Medium	Mixed-quality datasets	Requires careful expectile tuning
TD3-BC	Offline-RL	Medium	High	Refining near-optimal demonstrations	Unstable with small datasets

Allgemeine Anleitung: Beginnen Sie mit BC. Wenn BC aufgrund eines Fehlers bei der Kompilierung von langen Horizontstufen versagt, versuchen Sie BC-RNN. Wenn Ihre Daten gemischte Qualität haben (einige Demonstrationen sind suboptimale), versuchen Sie IQL. Benutzen Sie nur BCQ/CQL/TD3-BC, wenn Sie einen bestimmten Grund haben, zu glauben, dass eine Offline-RL-Verbesserung über die Datenverteilung sowohl notwendig als auch erreichbar ist. In der Praxis ist BC-RNN der zuverlässigste Algorithmus für die RoboMimic-Benchmark-Aufgaben.

Die Benchmarks durchführen

RoboMimic definiert vier Manipulationsarbeiten mit zunehmender Schwierigkeit, die alle in Robosuite umgesetzt werden:

Lift Holen Sie einen Würfel vom Tisch. Einarm, 1 Gegenstand. Die einfachste Aufgabe, nützlich für die Überprüfung Ihrer Trainingspipeline funktioniert. BC Erfolg: 95-100%.
** Kann** eine Dosenholte nehmen und in einen Zielbehälter legen. Es erfordert genaues Greifen und Platzieren. BC-Erfolg: 80-95%. BC-RNN-Erfolg: 90-98%.
Quadrat Holen Sie eine Quadratnuss und legen Sie sie auf einen Stich. Es erfordert eine genaue Ausrichtung und Einfügung. BC-Erfolg: 40-70%. BC-RNN-Erfolg: 60-85%.
Transport Doppelhandtasche: Ein Arm nimmt ein Objekt aus einem Müllkorb und überträgt es dem anderen Arm, der es an einem Zielort stellt. Die schwierigste Aufgabe erfordert eine Koordinierung zwischen zwei Armen. BC-RNN Erfolg: 30-60%.

Um den vollständigen Benchmark zu führen:

# Generate configs for all tasks and algorithms
python robomimic/scripts/generate_paper_configs.py --output_dir benchmark_configs/

# Run all experiments (use a cluster or run overnight)
python robomimic/scripts/train.py --config benchmark_configs/lift/bc.json
python robomimic/scripts/train.py --config benchmark_configs/can/bc.json
python robomimic/scripts/train.py --config benchmark_configs/square/bc_rnn.json
python robomimic/scripts/train.py --config benchmark_configs/transport/bc_rnn.json

# Evaluate all trained models
python robomimic/scripts/run_trained_agent.py \
  --agent trained_models/lift/bc/models/model_best.pth \
  --n_rollouts 100

Die Durchführung des vollständigen Benchmarks über alle Algorithmen und Aufgaben hinaus dauert etwa 3-5 Tage auf einem einzigen RTX 3090. Für bildbasierte Experimente erwarten Sie 2-3x längere Trainingszeiten.

Beobachtungen mit Bildern

Im Bildbasierte Politikbildung wird RoboMimic für den Real-Welt-Transfer am wertvollsten. Echte Roboter haben keinen Zugang zu Boden-Wahrheit-Objektpositionen sie haben Kameras.

Um eine visuelle BC-Politik auszubilden, ändern Sie die Beobachtungsmodalität in Ihrem Konfigurationsprogramm:

{
  "observation": {
    "modalities": {
      "obs": {
        "low_dim": ["robot0_eef_pos", "robot0_gripper_qpos"],
        "rgb": ["agentview_image", "robot0_eye_in_hand_image"]
      }
    },
    "encoder": {
      "rgb": {
        "core_class": "VisualCore",
        "core_kwargs": {
          "backbone_class": "ResNet18Conv",
          "pool_class": "SpatialSoftmax"
        }
      }
    }
  }
}

Für bessere visuelle Darstellungen verwenden Sie einen vorgeübten Encoder wie R3M (von Nair et al., 2022) anstelle von neuem Training:

# Install R3M
pip install r3m

# In your config, set the encoder to use R3M
"backbone_class": "R3MConv",
"backbone_kwargs": {"r3m_model_class": "resnet18"}

GPU-Anforderungen: Bildbasiertes Training mit ResNet18 erfordert mindestens 8 GB VRAM. Bei R3M und Batchgröße 16 erwarten Sie 10-12 GB-Nutzung. Ein RTX 3080 (10 GB) oder RTX 4090 (24 GB) wird empfohlen. Die Trainingszeit steigt von ~30 Minuten (low-dim) auf 4-8 Stunden (bildbasiert) auf einer einzelnen GPU.

Ihre eigenen Daten zu sammeln

RoboMimic akzeptiert jeden HDF5-Datensatz, der seinem Format folgt, was bedeutet, dass Sie Demonstrationen in Robosuite oder auf echter Hardware sammeln und mit den gleichen Algorithmen trainieren können.

Vollzugs- und Abholung in Robosuite per Teleoperation:

# Launch robosuite teleoperation data collection
python robosuite/scripts/collect_human_demonstrations.py \
  --environment Lift \
  --robots Panda \
  --controller OSC_POSE \
  --device keyboard

Unterstützte Eingabegeräte umfassen Tastatur, SpaceMouse (3Dconnexion) und VR-Controller über die Gerätengrücke. Für die groß angelegte Sammlung bietet SpaceMouse den besten Kompromiss zwischen Datenqualität und Betriebsermüd.

Konvertieren von benutzerdefinierten Daten in RoboMimic-Format: Ihre Daten müssen als Episoden in einer HDF5-Datei organisiert werden. Jeder Episode benötigt: Beobachtungen (Dikt der Arrays), Aktionen (Array), Belohnungen (Array) und Dones (Array). Verwenden Sie das Konvertierungsanwendungsprogramm:

import h5py
import numpy as np

with h5py.File("my_dataset.hdf5", "w") as f:
    grp = f.create_group("data")
    for i, episode in enumerate(episodes):
        demo = grp.create_group(f"demo_{i}")
        obs = demo.create_group("obs")
        obs.create_dataset("robot0_eef_pos", data=episode["eef_positions"])
        obs.create_dataset("robot0_gripper_qpos", data=episode["gripper_states"])
        demo.create_dataset("actions", data=episode["actions"])
        demo.create_dataset("rewards", data=episode["rewards"])
        demo.create_dataset("dones", data=episode["dones"])

    # Create train/val split
    mask = grp.create_group("mask")
    n = len(episodes)
    mask.create_dataset("train", data=np.arange(int(n * 0.9)))
    mask.create_dataset("valid", data=np.arange(int(n * 0.9), n))

Übertragung auf echte Hardware

Der Sim-to-Real-Transfer mit RoboMimic-trainierten Richtlinien erfordert Aufmerksamkeit auf drei kritische Lücken:

** Beobachtungslücken:** Echte Kamerabilder unterscheiden sich von Simulationsrendern.
Aktionsraum Gap: Stellen Sie sicher, dass Ihr echter Roboter-Controller den gleichen Aktionstyp (Gemensgeschwindigkeit vs. OSC-Position) bei der gleichen Steuerfrequenz (typischerweise 20 Hz für RoboMimic) als die Trainingsumgebung akzeptiert.
** Dynamiklücken:** Objektfriktion, Roboter-Gelenk-Dynamik und Griffverhalten unterscheiden sich zwischen Simulation und Realität.

Für den Einsatz auf einem echten Franka Panda (der Standard RoboMimic-Roboter) nutzen Sie die T13-Controller-Schnittstelle, die den gleichen OSC_POSE-Aktionsraum wie Robosuite bietet. Für andere Roboterarme müssen Sie einen Action Wrapper implementieren, der RoboMimic-Aktionen auf den Controller Ihres Robots abbildet.

Häufige Fehler und Lösungen

"KeyError: 'robot0_eef_pos'" während des Trainings Ihr Datensatz enthält nicht die von der Konfiguration erwarteten Beobachtungsschlüssel.
Schulungsverluste sinken, aber die Bewertung erfolgreich ist 0% Die Politik ist übermäßig zu den Schulungsdaten passt. Verringern Sie die Batchgröße, fügen Sie den Ausfall (0,1-0,3) hinzu oder erhöhen Sie die Datensatzgröße. Überprüfen Sie auch, dass Ihre Bewertung umgebung die gleiche Beobachtungsnormalisierung wie das Training verwendet.
"CUDA aus dem Speicher" während des Bildtrainings Reduzieren Sie die Batchgröße (beginnen Sie mit 8 oder 16 für Bildpolitik) oder verwenden Sie Gradient-Akkumulation.
**BC-RNN-Training ist instabil (Verlustspikes) ** Verringern Sie die Lernrate auf 1e-4, verwenden Sie Gradient-Clipping (max_norm=1.0) und erhöhen Sie die Sequenzlänge allmählich. Beginnen Sie mit seq_length=10 und erhöhen Sie es auf 20 sobald sich das Training stabilisiert.
** "MuJoCo nicht gefunden" Fehler bei der Einfuhr** seit MuJoCo wurde Open-Source (v2.1.2+), installieren über T15. Entfernen Sie alle alten mujoco-py-Installationen, die in Konflikt: T16.
Ausgebildetes System funktioniert in Sim, aber fehlt bei echten Robotern Überprüfen Sie die Abweichung des Aktionsraums (Gemeinsame Geschwindigkeit vs. OSC-Position), die Abweichung der Steuerfrequenz und die Beobachtungsnormalität.

Integration mit RCSV-Hardware

RCSV bietet vorkonfigurierte Roboter-Setups, die mit RoboMimic-Workflows kompatibel sind und die Hardware-Integrationslast beseitigen:

OpenArm RCSV's Open-Source 6-DOF-Roboterarm. Wir bieten einen RoboMimic-kompatiblen Action Wrapper, der OSC_POSE-Aktionen auf OpenArm's Joint Controller bei 20 Hz abbildet. Die Datensammlung verwendet das gleiche HDF5-Format, so dass Sie direkt mit RoboMimic-Algorithmen ohne Formatkonvertierung trainieren können.
Franka Panda Der Standard RoboMimic-Roboter. RCSV betreibt Franka-Systeme mit Deoxys-Controllern, die für die Robomimic-kompatible Datenerhebung und -politische Bereitstellung vorkonfiguriert sind.
Bimanuelle Einstellungen Für die Transport-Aufgabe auf echter Hardware bietet RCSV zweibarmige ALOHA-Systeme mit synchronisierter Datenerfassung bei 50 Hz. Das Datenformat entspricht direkt der bimanuellen Struktur von RoboMimic.

Alle von RCSV gesammelten Datensätze werden vor der Lieferung mit dem RoboMimic HDF5-Schema validiert, so dass sie ohne Änderung direkt in die Trainingsleitung geladen werden.

Häufig gestellte Fragen

RoboMimic ist ein Framework für die Benchmarking und Entwicklung von Offline-Imitierungs-Lernalgorithmen für die Roboternapulation. Es bietet standardisierte Datensätze, Trainingspipelines und Bewertungsprotokolle, damit Forscher Algorithmen wie BC, BC-RNN, BCQ und IQL bei den gleichen Aufgaben fair vergleichen können.
Welche Algorithmen unterstützt RoboMimic? Sechs Algorithmen: BC, BC-RNN, BCQ, CQL, IQL und TD3-BC. Benutzer können auch benutzerdefinierte Algorithmen über das modulare Konfigurationssystem hinzufügen.
Behörte ich eine GPU, um RoboMimic-Politiken zu trainieren? Für niedrigdimensionale Beobachtungspolitik funktioniert eine moderne CPU, aber sie ist langsam. Für bildbasierte Politiken ist eine NVIDIA-GPU mit mindestens 8 GB VRAM erforderlich.
** Kann ich RoboMimic mit echten Roboterdaten verwenden?** Ja. RoboMimic akzeptiert jeden HDF5-Datensatz, der seiner Format-Spezifikation entspricht. Sammeln Sie Demonstrationen auf einem echten Roboter, konvertieren Sie sie in das RoboMimic HDF5-Format und trainieren Sie mit den gleichen Algorithmen.
Wie verglichen RoboMimic mit LeRobot? RoboMimic konzentriert sich mit Robosuite auf offline-imitationslernende Benchmarks. LeRobot (Hugging Face) ist breiter und umfasst die Datenerhebung, mehrere Simulations-Hintergründe und den Einsatz von echten Robotern. Viele Forscher verwenden RoboMimic-Algorithmen innerhalb von LeRobot-Pipelines.
Welche Erfolgsraten sollte ich bei den Benchmark-Aufgaben erwarten? Lift: 95-100% (BC). Kann: 80-95% (BC). Quadrat: 60-85% (BC-RNN). Transport: 30-60% (BC-RNN). Diese variieren je nach Datenqualität und Hyperparameter.

Brauchen Sie echte Roboter-Training-Daten?

RCSV sammelt RoboMimic-kompatible Demonstrationsdatenmengen auf realen Hardware Franka, OpenArm und zweimanschließende ALOHA-Systeme.

[Schauen Sie Datendienste]

OpenArm

Browse the Store

Data Marketplace

Get Started with Physical AI

Wuji Teleop Glove

Unitree Go2 — Setup & SDK