---
language:
  - en
task_categories:
  - robotics
  - reinforcement-learning
tags:
  - robotics
  - manipulation
  - imitation-learning
  - world-model
  - robot-learning
  - tabletop
pretty_name: "World Model Robot Manipulation Dataset (Our-50)"
size_categories:
  - n<1K
---

# World Model Robot Manipulation Dataset

A dataset of real-robot tabletop manipulation trajectories collected for world model training and imitation learning research. The setup follows DROID Dataset. Each trajectory pairs multi-camera video, proprioceptive state/action sequences, natural language task descriptions, and dense reward annotations with pre-extracted visual latents.

## Dataset Summary

| Split | Trajectories | Success Rate | Avg. Length |
|-------|-------------|--------------|-------------|
| Train | 250         | 44.8%        | 118 frames  |
| Val   | 100         | 44.0%        | 106 frames  |
| **Total** | **350** | **44.6%**  | **115 frames** |

Five tabletop manipulation tasks, 50 train / 20 val trajectories per task.

## Tasks

| Task ID | Description | Train SR | Val SR |
|---------|-------------|----------|--------|
| `bag_our`    | Pick up a bag of chips and place it on a green plate | 54% | 60% |
| `marker_our` | Pick up a marker and place it in a cup/mug           | 36% | 30% |
| `pour_our`   | Pick up a cup of beans and place them in a bowl      | 34% | 30% |
| `stack_our`  | Pick up a bowl and stack it on top of another bowl   | 60% | 60% |
| `towel_our`  | Pick up a towel and place it in a basket             | 40% | 40% |

Each task has multiple natural-language paraphrases (e.g. *"put the marker in the cup"*, *"put the marker in the mug"*, *"pick up the marker and place it in the cup"*).

## Data Structure

```
world_model_data_our_50/
├── annotations/
│   ├── train/   {0..249}.json
│   └── val/     {0..99}.json
├── annotation_rewards/
│   ├── train/   {0..249}.json       # same schema as annotations, includes reward fields
│   └── val/     {0..99}.json
├── latents/
│   ├── train/   {0..249}_sd3.npz
│   └── val/     {0..99}_sd3.npz
├── videos/
│   ├── train/   {0..249}.mp4
│   └── val/     {0..99}.mp4
├── norm_stats_recorded.json
└── norm_stats_relabel.json
```

### Annotation JSON Schema

Each `.json` file contains one trajectory with the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `episode_id` | int | Sequential trajectory index within the split |
| `episode_id_orig` | str | Original episode identifier (e.g. `bag_our_003`) |
| `texts` | list[str] | Natural language task descriptions |
| `text_features` | float[768] | Pre-computed text embedding |
| `success` | int | Binary success label (1 = task completed) |
| `video_length` | int | Number of frames in the trajectory (32–334) |
| `video_path` | str | Relative path to the `.mp4` file |
| `latent_path` | str | Relative path to the latent `.npz` file |
| `num_cameras` | int | Always 3 |
| `states` | float[T][7] | Raw proprioceptive state per frame |
| `observation.state.cartesian_position` | float[T][6] | End-effector Cartesian pose (x, y, z, rx, ry, rz) |
| `observation.state.joint_position` | float[T][7] | 7-DOF joint positions |
| `observation.state.gripper_position` | float[T][1] | Gripper opening |
| `action.cartesian_position` | float[T][6] | Cartesian position action |
| `action.joint_position` | float[T][7] | Joint position action |
| `action.joint_velocity` | float[T][7] | Joint velocity action |
| `action.gripper_position` | float[T][1] | Gripper action |
| `reward_progress` | float[T] | Dense progress reward |
| `reward_success` | float[T] | Success-shaped reward |
| `reward_binary` | float[T] | Binary reward signal |

### Video Format

- Resolution: **960 × 192** (three 320 × 192 camera views (left, right, wrist) concatenated horizontally)
- Codec: H.264
- Frame rate: **5 fps**
- Length: 32–334 frames per trajectory

### Visual Latents

Pre-extracted with **Stable Diffusion 3** (SD3). Stored as `float16` NumPy arrays.

```
latents.npz  →  key: "latents"
shape: (3, T, 60, 256)
        │  │   │    └─ channel dim
        │  │   └─ spatial tokens
        │  └─ frames
        └─ cameras
```

### Normalization Statistics

`norm_stats_recorded.json` and `norm_stats_relabel.json` provide mean/std statistics for the `state` and `actions` modalities, suitable for normalizing inputs during training.

## Robot Setup

- **Robot**: Franka Emika Robot arm with parallel-jaw gripper (Robotiq Gripper)
- **Cameras**: 3 fixed cameras providing left, right, and wrist views
- **Control frequency**: 5 Hz (matches video frame rate)

## Usage Example

```python
import json
import numpy as np

# Load a trajectory
with open("annotations/train/0.json") as f:
    traj = json.load(f)

print(traj["texts"])          # ['pick up the bag of chips and place it on the green plate']
print(traj["success"])        # 1
print(traj["video_length"])   # e.g. 112

# Joint positions: shape (T, 7)
joint_pos = np.array(traj["observation.state.joint_position"])

# Actions: shape (T, 7)
actions = np.array(traj["action.joint_position"])

# Visual latents: shape (3, T, 60, 256)
lat = np.load(traj["latent_path"].replace("latents/", "latents/"))["latents"]

# Rewards: shape (T,)
rewards = np.array(traj["reward_progress"])
```