---
license: mit
task_categories:
- robotics
- computer-vision
tags:
- point-cloud
- hdf5
- point-tracking
- canonical-point-cloud
- rigid-transform
- world-model
pretty_name: Kinder Worldmodel Dataset
---

# Kinder-worldmodel Dataset

This repository contains processed HDF5 datasets and demo videos for the Kinder-worldmodel project.

The uploaded files demonstrate two related point cloud representations:

1. **Tracked / all-point-cloud HDF5 data**
2. **Canonical point cloud replay using per-geom rigid transforms**

## Files

* `sweep_tracked_pointcloud_all.hdf5`
  Processed HDF5 file containing complete point cloud data and point tracking information.

* `sweep_canonical.hdf5`
  HDF5 file using a transform-based representation. Instead of storing per-timestep point clouds, it stores canonical surface points for each rigid geom and per-timestep 4x4 transforms.

* `videos/complete_pointcloud_demo.mp4`
  Demo video showing complete point cloud visualization.

* `videos/point_tracking_demo.mp4`
  Demo video showing point tracking across frames.

* `videos/canonicalpointcloud-excluding kitchen floor.mp4`
  Demo video showing transform-based canonical point cloud replay at 30 fps.

## FrankaPickPlace3D — MPPI planning data (`franka_pickplace/`)

Added for the closed-loop MPPI planning result on kinder's MuJoCo
`FrankaPickPlace3D-o1` task (a desk-mounted Franka FR3 picks a cube and places it
in a goal region). Same canonical representation as the sweep files above:
per-geom canonical surface points plus per-timestep 4x4 rigid transforms.

* `franka_pickplace/FrankaPickPlace3D-o1-demos-v2.tar.gz` — 14 MB,
  md5 `cf4fa2b0c4166fcd6bdd27f8a2616f12`.
  The raw kindergarden demo pickles: 1000 train + 10 test episodes, one directory
  per episode seed. Extract into a kindergarden checkout's `demos/`.
* `franka_pickplace/franka_canonical_pickplace_1000demos_train_v2.hdf5` — 2.3 GB.
  1000 episodes, 109,084 frames, exported with `--num-points-per-geom 2000` and
  `--ee-site robot_pinch_site`. 70 geoms per demo.
* `franka_pickplace/franka_canonical_pickplace_10demos_test_v2.hdf5` — 22 MB,
  md5 `01eaec8f6dc0a27506f3ddd56354f4ef`. The matching test split.

The world model trained on this data is at
[`Flashkernel/3dwm-franka-pickplace-mppi`](https://huggingface.co/Flashkernel/3dwm-franka-pickplace-mppi),
and the same data converted to the 3dwm training format (71 MB packed, ready to
train on) is at
[`Flashkernel/3dwm-kinder-data`](https://huggingface.co/datasets/Flashkernel/3dwm-kinder-data).

### The environment version matters

These demos were generated against kindergarden commit
[`1d0cc56`](https://github.com/Princeton-Robot-Planning-and-Learning/kindergarden/commit/1d0cc56c093cfbb930d43fe83c2272b7b44f6e29),
and no published version of that package matches it. Both alternatives fail
silently rather than raising:

* PyPI `kindergarden==0.2.0` carries the **same version string** but was built
  three days earlier, before the FR3 `pinch_site` existed. These demos' actions
  are defined on `robot_pinch_site` (see each demo's `ee_frame_name` attribute),
  so an IK bridge has no frame to target.
* v0.2.1 and later, and current `main`, replaced `"mount_height": 0.75` with
  `"mount_surface": "desk_1"` in the task config, which moves the FR3 mount and
  changes every scene — a model trained on this data is then out of distribution.

## Dataset Description

The dataset is intended for inspecting complete point clouds, point tracking, and transform-based point cloud replay.

For the canonical point cloud representation, each rigid geom is stored using:

* one canonical surface point set in local coordinates
* per-timestep 4x4 rigid transforms

This avoids storing a full point cloud for every timestep.

## Canonical Point Cloud Replay

The canonical point cloud replay demo is rendered from the new HDF5 format, not from per-timestep point clouds stored in the file.

For each rigid geom, the file stores:

```text
canonical_pointcloud/<geom_name>/xyz
geom_transforms/<geom_name>[t]
```

At each frame, world-space points are reconstructed using:

```python
world_pts = (T @ pts_h.T).T[:, :3]
```

where:

* `pts_h` is the homogeneous version of the canonical local point cloud
* `T` is the 4x4 rigid transform for that geom at timestep `t`
* `world_pts` are the reconstructed world-frame points

### What is shown in the canonical replay video

The clip shows:

* reconstructed scene at 30 fps from `hdf5_data/sweep_canonical.hdf5`
* task: `SweepIntoDrawer3D-o5`
* number of demos: 1
* kitchen and floor geometry filtered out
* robot, task objects, and other non-kitchen geometry kept

The filtered-out geoms include names containing:

```text
kitchen
floor
```

This removes cabinets, panels, drawers, and floor geometry.

The displayed result is a filtered view of the same transform-based representation. It shows that geom names can be used to drop background geometry and focus on the manipulator and task-relevant parts without re-exporting the dataset.

One-line summary:

```text
Transform-based point cloud replay at 30 fps; kitchen/floor removed by geom-name filter.
```

## Related Fields

The same canonical HDF5 file also contains fields that are not visualized in the canonical replay video:

* `actions`
  Original demo actions.

* `actions_delta_ee_transform`
  End-effector delta transform per action step, computed at `robot_pinch_site`.

* `obs/ee_pose`
  End-effector pose per step for debugging.

## How to Download

You can download the files directly from this Hugging Face dataset repository.

You can also download a file using Python:

```python
from huggingface_hub import hf_hub_download

file_path = hf_hub_download(
    repo_id="Flashkernel/Kinder-worldmodel",
    filename="sweep_tracked_pointcloud_all.hdf5",
    repo_type="dataset"
)

print(file_path)
```

To download the canonical HDF5 file:

```python
from huggingface_hub import hf_hub_download

file_path = hf_hub_download(
    repo_id="Flashkernel/Kinder-worldmodel",
    filename="sweep_canonical.hdf5",
    repo_type="dataset"
)

print(file_path)
```

## How to Inspect the HDF5 File

Install dependencies:

```bash
pip install h5py
```

Then inspect the file structure:

```python
import h5py

file_path = "sweep_canonical.hdf5"

with h5py.File(file_path, "r") as f:
    def print_structure(name, obj):
        if isinstance(obj, h5py.Dataset):
            print(name, obj.shape, obj.dtype)
        else:
            print(name)

    f.visititems(print_structure)
```

## Visualization

The demo videos show:

1. Complete point cloud visualization
2. Point tracking across frames
3. Canonical point cloud replay from canonical points and per-geom 4x4 transforms

The canonical replay video is generated from canonical local point sets and rigid transforms. It does not require storing a dense per-frame point cloud in the HDF5 file.

## Usage Notes

This is a dataset repository, so it is not meant to be run directly.

To use the data, download the HDF5 file and load it with `h5py`. The videos provide visual examples of the stored representations and reconstruction results.

## Repository Link

Dataset page:

https://huggingface.co/datasets/Flashkernel/Kinder-worldmodel