RoboManipBaselines: Unified Robotic Imitation

• RoboManipBaselines is an open, modular framework for imitation learning that standardizes data collection, training, and evaluation protocols for robot manipulation.
• It implements canonical imitation algorithms such as behavior cloning, GAIL, and DAgger, supporting both simulated (MuJoCo, Isaac Gym) and real-robot environments.
• The framework emphasizes reproducibility and extensibility through centralized seed management, plugin interfaces, and comprehensive evaluation metrics.

RoboManipBaselines is an open, modular framework for imitation learning in robotic manipulation, designed to unify data collection, training, and evaluation protocols across both simulated and real robots. It emphasizes systematic benchmarking of robot manipulation tasks, policy architectures, and multimodal data modalities, with a foundational commitment to extensibility, reproducibility, and integration for diverse research workflows (Murooka et al., 21 Sep 2025).

1. System Architecture and Module Abstractions

The architecture of RoboManipBaselines consists of three tightly coupled modules: data collection, training, and evaluation. Each module exposes standardized interfaces that accommodate both simulated environments (e.g., MuJoCo, Isaac Gym) and physical robots (via ROS). Environments must implement a Gym-style API: reset(), step(a), and observe(). The data collection module integrates teleoperation APIs (keyboard, 3D mouse, GELLO leader–follower), supporting the logging of joint states, RGB-D images, force/torque signals, and tactile feedback in a custom binary trajectory format. The dataset class handles multimodal I/O and on-the-fly compression and indexing, ensuring tractability for large-scale datasets (Murooka et al., 21 Sep 2025).

The training module is structured around algorithm-agnostic trainers for canonical imitation learning methods (behavior cloning, GAIL, DAgger) and supports user-defined policy networks via a plugin interface. All RNG seeds (Python, NumPy, PyTorch, and simulator) are controlled from a single source for full experiment reproducibility. The evaluation module provides a rollout engine for running trained policies under randomized conditions, automatic metrics logging, and stateful environment wrappers for exact reproduction or checkpointing (Murooka et al., 21 Sep 2025).

2. Canonical Imitation Learning Algorithms

RoboManipBaselines supports the canonical imitation learning algorithms through well-specified mathematical objectives and open implementations:

• Behavior Cloning (BC): Supervised learning for state–action pairs $(s, a)$ using negative log-likelihood:

$$\mathcal{L}_{BC}(\theta) = \mathbb{E}_{(s,a)\sim \mathcal{D}}[ -\log \pi_\theta(a \mid s) ]$$

Optimization uses standard stochastic gradient descent over minibatches (Murooka et al., 21 Sep 2025).

• Generative Adversarial Imitation Learning (GAIL): Min–max objective involves policy $\pi_\theta$ and discriminator $D_\phi$:

$$\min_{\theta}\max_{\phi}\; \mathbb{E}_{(s,a)\sim\mathcal{D}}[\log D_\phi(s,a)] + \mathbb{E}_{(s,a)\sim\pi_\theta}[\log(1 - D_\phi(s,a))] - \lambda\,\mathbb{E}_{(s,a)\sim\pi_\theta}[\log\pi_\theta(a\mid s)]$$

Discriminator and policy are updated in alternation, and policy updates use TRPO/PPO/CEM variants (Murooka et al., 21 Sep 2025).

• Dataset Aggregation (DAgger): Iterative data aggregation where a policy is run, queried by the expert, and the resulting pairs are added to the dataset, with the final policy trained on the aggregated data (Murooka et al., 21 Sep 2025).

Policy network options include ACT, Diffusion Policy, SARNN, 3D-Diffusion, MT-ACT, with interfaces for custom networks.

3. Multimodal Policy Networks

Multimodal fusion is supported in policy architectures as a first-class abstraction:

• Vision: $$f_{\rm vis} = \mathrm{CNN}_\phi(I_{\rm RGB}(t)) \in \mathbb{R}^{d_v}$$
• Proprioception: $$f_{\rm prop} = \mathrm{MLP}_\psi(q_t, \dot q_t) \in \mathbb{R}^{d_p}$$
• Force/Torque: $$f_{\rm force} = \mathrm{MLP}_\chi(\tau_{\rm F/T}(t)) \in \mathbb{R}^{d_f}$$
• Fusion: $$z_t = [f_{\rm vis},\,f_{\rm prop},\,f_{\rm force}] \in \mathbb{R}^{d_v+d_p+d_f}$$
• Action Head: $a_t = \mathrm{MLP}_{\rm out}(z_t)$ or stochastic policy $$\mathcal{L}_{BC}(\theta) = \mathbb{E}_{(s,a)\sim \mathcal{D}}[ -\log \pi_\theta(a \mid s) ]$$0

Architecture components and their interconnections are fully configurable via YAML/JSON policy descriptions. This abstraction facilitates flexible research into sensor fusion strategies (Murooka et al., 21 Sep 2025).

4. Supported Robots, Simulators, and Task Suite

RoboManipBaselines spans a wide hardware and task spectrum:

• Robots: UR5e (single arm), xArm7, ALOHA (bimanual), G1 (bimanual), HSR (mobile manipulator)
• Simulators: MuJoCo (rigid, plus simple deformables via BrickRed), Isaac Gym (GPU parallel, soft bodies)
• Objects: Both rigid and deformable (cloth, rope)
• Tasks: Block insertion, peg-in-hole, cloth folding, rope threading, grasping irregular objects, etc.

For real-robot UR5e evaluation, four challenging object-manipulation tasks randomized over a 10 cm workspace are included. Benchmark tasks are designed for generality and extensibility (Murooka et al., 21 Sep 2025).

5. Evaluation Protocols, Metrics, and Empirical Performance

Evaluation is protocolized for comparability:

• Success Rate:

$$\mathcal{L}_{BC}(\theta) = \mathbb{E}_{(s,a)\sim \mathcal{D}}[ -\log \pi_\theta(a \mid s) ]$$1

• Task Completion Time:

$$\mathcal{L}_{BC}(\theta) = \mathbb{E}_{(s,a)\sim \mathcal{D}}[ -\log \pi_\theta(a \mid s) ]$$2

• Protocol:
  • Simulation: 60 rollouts per task with randomized seed/object pose
  • Real world: 6 rollouts per task
  • Training: 30 teleoperation demonstration trajectories per task
  • All seeds logged for reproduction (Murooka et al., 21 Sep 2025)

Empirical success rates (UR5e, mean ± σ): ACT: 0.54±0.51 (real), 0.79±0.41 (sim); Diffusion Policy: 0.58±0.50 (real), 0.71±0.46 (sim); SARNN: 0.63±0.50 (real), 1.00±0.00 (sim). SARNN achieves perfect performance in simulation, with residual variability in the real world.

6. Generality, Extensibility, and Reproducibility

Key mechanisms for extensibility and reproducibility:

• Environment Abstraction: Inherit AbstractEnv, override reset(), step(), observe().
• Policy Abstraction: Inherit BasePolicy, implement forward()/train_step().
• Plugin Interface: Register new data collectors, UI devices, sensors without modifying core.
• Centralized Seed Management: Single SeedController synchronizes/records seeds for all libraries and simulators.
• Dataset Versioning: Checksummed, versioned releases for data.
• State Logging: Full trajectory and simulator state logs for reproducing or forked evaluation.
• Comprehensive Experiment Logging: TensorBoard summaries, CSVs, protocol buffers of hparams.

This infrastructure ensures published results are fully reproducible and new robots, tasks, sensors, or policy classes can be rapidly integrated (Murooka et al., 21 Sep 2025).

7. Role within the Manipulation Baseline Ecosystem

RoboManipBaselines is differentiated by its systematic integration of sim/real environments, extensive support for robot types and modalities, algorithmic breadth (BC, GAIL, DAgger, Diffusion, sequence models), and rigorous evaluative protocol. It contrasts with task-specific, single-modality, or tightly hardware-coupled benchmarks by prioritizing modularity, data and code versioning, and global reproducibility guarantees (Murooka et al., 21 Sep 2025). The framework is intended both as a plug-and-play baseline suite and as an extensible foundation for new imitation learning and multimodal fusion research in robotic manipulation.