README.md

---
license: apache-2.0
tags:
- robotics
- lerobot
- manipulation
- imitation-learning
- vision-language-action
- embodied-ai
- teleoperation
- so_follower
task_categories:
- robotics
language:
- en
size_categories:
- 1M<n<10M
pretty_name: NIAT10
configs:
- config_name: Eraser_drawer
  data_files:
  - split: train
    path: Eraser_drawer/data/**/*.parquet
- config_name: Battery_sort
  data_files:
  - split: train
    path: Battery_sort/data/**/*.parquet
- config_name: Battery_sort_v1
  data_files:
  - split: train
    path: Battery_sort_v1/data/**/*.parquet
- config_name: drawer_cube_screwdriver
  data_files:
  - split: train
    path: drawer_cube_screwdriver/data/**/*.parquet
- config_name: Drawer_screwdriver_v2
  data_files:
  - split: train
    path: Drawer_screwdriver_v2/data/**/*.parquet
- config_name: Drawer_screwdriver
  data_files:
  - split: train
    path: Drawer_screwdriver/data/**/*.parquet
- config_name: screwdriver_box
  data_files:
  - split: train
    path: screwdriver_box/data/**/*.parquet
- config_name: screwdriver_box_v1
  data_files:
  - split: train
    path: screwdriver_box_v1/data/**/*.parquet
- config_name: screwdriver_box_v0
  data_files:
  - split: train
    path: screwdriver_box_v0/data/**/*.parquet
- config_name: stack_cubes
  data_files:
  - split: train
    path: stack_cubes/data/**/*.parquet
- config_name: Cup_stack
  data_files:
  - split: train
    path: Cup_stack/data/**/*.parquet
- config_name: eraser
  data_files:
  - split: train
    path: eraser/data/**/*.parquet
- config_name: cube
  data_files:
  - split: train
    path: cube/data/**/*.parquet
- config_name: stapler
  data_files:
  - split: train
    path: stapler/data/**/*.parquet
- config_name: bottle
  data_files:
  - split: train
    path: bottle/data/**/*.parquet
- config_name: penholder
  data_files:
  - split: train
    path: penholder/data/**/*.parquet
- config_name: sort_biodegradable
  data_files:
  - split: train
    path: sort_biodegradable/data/**/*.parquet
- config_name: pick_place_cubes_para
  data_files:
  - split: train
    path: pick_place_cubes_para/data/**/*.parquet
- config_name: pick_place_cubes
  data_files:
  - split: train
    path: pick_place_cubes/data/**/*.parquet
- config_name: chocolate_pick_place
  data_files:
  - split: train
    path: chocolate_pick_place/data/**/*.parquet
- config_name: pick_place
  data_files:
  - split: train
    path: pick_place/data/**/*.parquet
- config_name: push_t_v2
  data_files:
  - split: train
    path: push_t_v2/data/**/*.parquet
- config_name: t_push
  data_files:
  - split: train
    path: t_push/data/**/*.parquet
- config_name: Bottle_orient
  data_files:
  - split: train
    path: Bottle_orient/data/**/*.parquet
- config_name: Cube_pick_place
  data_files:
  - split: train
    path: Cube_pick_place/data/**/*.parquet
---

# NIAT10 — A Tabletop Manipulation Dataset Collection

25 teleoperated robot manipulation datasets recorded at NIAT, consolidated
into a single repository for imitation-learning and vision-language-action research.

<!-- TODO: banner image URL -->

## Overview

NIAT10 gathers every manipulation dataset recorded by the NIAT Physical AI group into
one place, each one preserved in its original [LeRobot](https://github.com/huggingface/lerobot)
layout inside its own top-level folder. Rather than a single merged dataset, it is a
**curated collection** — you can train on one folder, a task family, or all of them.

The collection covers five task families on a shared tabletop setup: pick and place,
sorting, stacking, object reorientation, and non-prehensile pushing. Every episode was
teleoperated on an **SO-101 (leader–follower pair)** through a leader arm and recorded from an
overhead and a wrist camera at 640 × 480 / 30 fps.

<!-- TODO: 2-3 sentences on why this collection exists — the research question,
     the course/lab it came out of, what you intend to train on it. -->

## Dataset Statistics

| Metric | Value |
|---|---|
| **Total datasets** | 25 |
| **Total episodes** | 2,138 |
| **Total frames** | 1,021,300 |
| **Recorded duration** | 9.46 hours (09:27:23) |
| **Video footage** | 18.91 hours across all camera streams |
| **Camera frames** | 2,042,600 |
| **Task families** | 5 |
| **Robot embodiments** | 1 |
| **Average duration/dataset** | 0.38 hours |
| **Datasets passing review** | 23 of 25 |

**Recorded duration** is wall-clock robot interaction time, computed as
`total_frames / fps` from each dataset's `meta/info.json`, so it reflects the current
contents of each repo after episode pruning. **Video footage** counts each synchronised
camera stream separately — it is the volume of video you will download and decode, not
additional robot time.

`pick_place_cubes_para` re-annotates episodes that already appear elsewhere in the collection rather than adding new recordings (see [Language variants](#language-variants)). Excluding it, the collection holds **8.60 hours** of distinct recordings across **1,838 episodes**.

## Task Distribution

| Task family | Datasets | Episodes | Duration | % of data |
|---|---|---|---|---|
| Pick and place | 14 | 1210 | 05:01:17 | 53.1% |
| Sorting | 4 | 374 | 02:08:26 | 22.6% |
| Stacking | 3 | 212 | 00:56:42 | 10.0% |
| Non-prehensile push | 2 | 244 | 00:49:07 | 8.7% |
| Orientation | 2 | 98 | 00:31:52 | 5.6% |

<!-- TODO: task montage image URL -->

## Robot Types

| Robot type | Datasets | % |
|---|---|---|
| so_follower | 25 | 100.0% |

Recorded with LeRobot v3.0 (25 datasets). Frame rates present: 30 fps (25).

## Contributors

<!-- TODO: add named contributors to CONTRIBUTORS in niat10_card.py -->

Recorded and published under the accounts below.

| Account | Datasets | % |
|---|---|---|
| [NIATphysicalAI](https://huggingface.co/NIATphysicalAI) | 20 | 80.0% |
| [Bradx86](https://huggingface.co/Bradx86) | 5 | 20.0% |

Please credit the individual contributors above, not only the publishing accounts,
when using this collection.
## Contents

| # | Folder | Task | Episodes | Frames | Duration | FPS | Review | Source |
|---|---|---|---|---|---|---|---|---|
| 1 | `Eraser_drawer` | Pick and place | 100 | 79,890 | 00:44:23 | 30 | fix required | [Eraser_drawer](https://huggingface.co/datasets/NIATphysicalAI/Eraser_drawer) |
| 2 | `Battery_sort` | Sorting | 106 | 93,878 | 00:52:09 | 30 | OK | [Battery_sort](https://huggingface.co/datasets/NIATphysicalAI/Battery_sort) |
| 3 | `Battery_sort_v1` | Sorting | 7 | 5,681 | 00:03:09 | 30 | OK | [Battery_sort_v1](https://huggingface.co/datasets/NIATphysicalAI/Battery_sort_v1) |
| 4 | `drawer_cube_screwdriver` | Pick and place | 101 | 54,895 | 00:30:30 | 30 | OK | [drawer_cube_screwdriver](https://huggingface.co/datasets/NIATphysicalAI/drawer_cube_screwdriver) |
| 5 | `Drawer_screwdriver_v2` | Pick and place | 51 | 30,709 | 00:17:04 | 30 | OK | [Drawer_screwdriver_v2](https://huggingface.co/datasets/NIATphysicalAI/Drawer_screwdriver_v2) |
| 6 | `Drawer_screwdriver` | Pick and place | 34 | 23,221 | 00:12:54 | 30 | OK | [Drawer_screwdriver](https://huggingface.co/datasets/NIATphysicalAI/Drawer_screwdriver) |
| 7 | `screwdriver_box` | Pick and place | 47 | 27,536 | 00:15:18 | 30 | OK | [screwdriver_box](https://huggingface.co/datasets/NIATphysicalAI/screwdriver_box) |
| 8 | `screwdriver_box_v1` | Pick and place | 20 | 13,829 | 00:07:41 | 30 | OK | [screwdriver_box_v1](https://huggingface.co/datasets/NIATphysicalAI/screwdriver_box_v1) |
| 9 | `screwdriver_box_v0` | Pick and place | 10 | 7,498 | 00:04:10 | 30 | OK | [screwdriver_box_v0](https://huggingface.co/datasets/NIATphysicalAI/screwdriver_box_v0) |
| 10 | `stack_cubes` | Stacking | 58 | 30,806 | 00:17:07 | 30 | OK | [stack_cubes](https://huggingface.co/datasets/NIATphysicalAI/stack_cubes) |
| 11 | `Cup_stack` | Stacking | 100 | 45,646 | 00:25:22 | 30 | OK | [Cup_stack](https://huggingface.co/datasets/NIATphysicalAI/Cup_stack) |
| 12 | `eraser` | Pick and place | 60 | 26,893 | 00:14:56 | 30 | OK | [eraser](https://huggingface.co/datasets/NIATphysicalAI/eraser) |
| 13 | `cube` | Stacking | 54 | 25,595 | 00:14:13 | 30 | fix required | [cube](https://huggingface.co/datasets/NIATphysicalAI/cube) |
| 14 | `stapler` | Pick and place | 37 | 16,750 | 00:09:18 | 30 | OK | [stapler](https://huggingface.co/datasets/NIATphysicalAI/stapler) |
| 15 | `bottle` | Orientation | 48 | 25,162 | 00:13:59 | 30 | OK | [bottle](https://huggingface.co/datasets/NIATphysicalAI/bottle) |
| 16 | `penholder` | Sorting | 92 | 43,990 | 00:24:26 | 30 | OK | [penholder](https://huggingface.co/datasets/NIATphysicalAI/penholder) |
| 17 | `sort_biodegradable` | Sorting | 169 | 87,635 | 00:48:41 | 30 | OK | [sort_biodegradable](https://huggingface.co/datasets/NIATphysicalAI/sort_biodegradable) |
| 18 | `pick_place_cubes_para` | Pick and place | 300 | 92,287 | 00:51:16 | 30 | OK | [pick_place_cubes_para](https://huggingface.co/datasets/NIATphysicalAI/pick_place_cubes_para) |
| 19 | `pick_place_cubes` | Pick and place | 300 | 92,287 | 00:51:16 | 30 | OK | [pick_place_cubes](https://huggingface.co/datasets/NIATphysicalAI/pick_place_cubes) |
| 20 | `chocolate_pick_place` | Pick and place | 50 | 29,178 | 00:16:13 | 30 | OK | [chocolate_pick_place](https://huggingface.co/datasets/NIATphysicalAI/chocolate_pick_place) |
| 21 | `pick_place` | Pick and place | 50 | 18,559 | 00:10:19 | 30 | OK | [pick-place](https://huggingface.co/datasets/Bradx86/pick-place) |
| 22 | `push_t_v2` | Non-prehensile push | 194 | 79,027 | 00:43:54 | 30 | OK | [push_t_v2](https://huggingface.co/datasets/Bradx86/push_t_v2) |
| 23 | `t_push` | Non-prehensile push | 50 | 9,388 | 00:05:13 | 30 | OK | [t_push](https://huggingface.co/datasets/Bradx86/t_push) |
| 24 | `Bottle_orient` | Orientation | 50 | 32,196 | 00:17:53 | 30 | OK | [bottle-test](https://huggingface.co/datasets/Bradx86/bottle-test) |
| 25 | `Cube_pick_place` | Pick and place | 50 | 28,764 | 00:15:59 | 30 | OK | [record-test](https://huggingface.co/datasets/Bradx86/record-test) |

## Repository Structure

```
NIAT10/
├── <dataset_name>/
│   ├── meta/
│   │   ├── info.json          # fps, robot type, feature schema, totals
│   │   ├── episodes.jsonl     # per-episode index and lengths
│   │   ├── tasks.jsonl        # natural-language task strings
│   │   └── stats.json         # per-feature normalisation statistics
│   ├── data/
│   │   └── chunk-000/
│   │       └── episode_*.parquet   # states, actions, timestamps
│   └── videos/
│       └── chunk-000/
│           └── observation.images.<cam>/episode_*.mp4
└── ...
```

## Usage

### Authenticate

```bash
hf auth login
# or: export HF_TOKEN=your_token_here
```

### Download a single dataset

Each folder is self-contained, so pull only what you need:

```bash
hf download NIATphysicalAI/NIAT10 \
    --repo-type=dataset \
    --include "Battery_sort/*" \
    --local-dir ./NIAT10
```

### Download everything

```bash
hf download NIATphysicalAI/NIAT10 --repo-type=dataset --local-dir ./NIAT10
```

### Load with LeRobot

```python
from lerobot.datasets.lerobot_dataset import LeRobotDataset

ds = LeRobotDataset(repo_id="NIATphysicalAI/NIAT10", root="./NIAT10/Battery_sort")

print(f"Episodes: {ds.num_episodes}")
print(f"Frames:   {ds.num_frames}")
print(f"Task:     {ds.meta.tasks}")

sample = ds[0]
print(sample.keys())
```

### Browse the collection

```python
from pathlib import Path
import json

for folder in sorted(Path("./NIAT10").iterdir()):
    info_path = folder / "meta" / "info.json"
    if info_path.exists():
        info = json.loads(info_path.read_text())
        hours = info["total_frames"] / info["fps"] / 3600
        print(f"{folder.name:<26} {info['total_episodes']:>4} episodes  {hours:.2f} h")
```

### Load the tabular data without video

Each folder is registered as a named config, so the state/action streams can be read
directly with `datasets`:

```python
from datasets import load_dataset

ds = load_dataset("NIATphysicalAI/NIAT10", "Battery_sort", split="train")
```

## Training

<!-- TODO: replace with the exact command you actually ran, once you have one. -->

```bash
lerobot-train \
    --policy.type=act \
    --dataset.repo_id=NIATphysicalAI/NIAT10 \
    --dataset.root=./NIAT10/Battery_sort \
    --output_dir=./outputs/act_battery_sort \
    --batch_size=8 \
    --steps=100000
```

To train across several folders, pass a comma-separated list of roots or build a
`MultiLeRobotDataset` over the folders you want.

## Known Issues and Caveats

Community-recorded teleoperation data is never uniform. Things to check before training:

- **Review status.** 2 of 25 datasets are flagged below. They are
  included for completeness; prefer the approved subset for headline results.
- **Varying episode counts.** Some datasets are short (a few minutes) and will be
  heavily under-represented in a naive concatenation. Consider weighted sampling.
- **Camera configurations differ** between datasets. Check
  `observation.images.*` in each `meta/info.json` before batching across folders.
- **Frame rates.** 30 fps (25) — resample or filter if your policy assumes a fixed rate.
- **Episode indices are per-folder.** They are not globally unique across the collection.
- **Not a single merged dataset.** Loading NIAT10 as one `LeRobotDataset` will not work;
  point `root` at an individual folder.

### Flagged datasets

| Folder | Status | Note |
|---|---|---|
| `Eraser_drawer` | fix required | Dataset card needs correcting |
| `cube` | fix required | Frozen `camera2` feed on some episodes |

## Intended Use

- Behaviour cloning and imitation learning on tabletop manipulation
- Fine-tuning vision-language-action models on a consistent hardware setup
- Multi-task and task-family transfer experiments
- Benchmarking data-efficiency across task types
- Teaching and coursework on robot learning pipelines

## Data Collection

All episodes were collected by **human teleoperation** on an **SO-101 (leader–follower pair)**
setup. An operator moved the leader arm by hand while the follower arm mirrored the
motion, and joint states, actions and synchronised video were recorded through LeRobot.
No scripted or autonomous policies were used, so every trajectory reflects human
timing, hesitation and correction.

### Robot

| Property | Value |
|---|---|
| Arm | SO-101 (leader–follower pair) |
| Control | Leader arm (leader–follower joint mirroring) |
| Recording framework | LeRobot |

### Cameras

Two cameras per episode, both the same sensor:

| View | Sensor |
|---|---|
| Overhead | IMX335 5MP USB Camera (B), 5V USB 2.0, 175° wide angle |
| Wrist | IMX335 5MP USB Camera (B), 5V USB 2.0, 175° wide angle |

The **overhead** camera gives a fixed third-person view of the whole workspace; the
**wrist** camera is mounted on the follower arm and moves with the end effector,
providing close-range detail during grasps and contact. The 175° field of view keeps
the full table in frame from a short mounting distance, at the cost of noticeable
barrel distortion near the edges — the recordings are **not undistorted**, so
calibrate or rectify yourself if your method assumes a pinhole model.

**Cropped overhead views.** Some datasets have a cropped overhead feed, done to remove
distractors and give a bounded region of interest for training. Original 1920×1080 frames were cropped to a 955×720 region of interest (margins: 580 left, 385 right, 180 top and bottom) and downsampled to 640×480. The wrist
view is uncropped. Because the crop changes the effective field of view and scale, a
policy trained on cropped datasets will not transfer cleanly to uncropped ones without
matching the preprocessing.

Both streams were captured through LeRobot's OpenCV backend:

```json
{
  "type": "opencv",
  "index_or_path": "/dev/video2",
  "width": 640,
  "height": 480,
  "fps": 30
}
```

Recorded at **640 × 480 @ 30 fps** — well below the
sensor's 5MP capability, chosen to keep two USB streams stable and file sizes
manageable. Device indices vary between recording sessions; check
`observation.images.*` in each folder's `meta/info.json` for the exact keys and shapes
a given dataset uses.

### Environment and randomisation

In most datasets object positions were **randomised between runs**, so the policy
cannot succeed by memorising a fixed layout. Randomisation was manual rather than
programmatic, so coverage is uneven — some datasets vary position more aggressively
than others.

<!-- TODO: fill in the remaining environment details:
     - Table surface and background
     - Lighting conditions (fixed room lighting? natural light?)
     - Object sets used per task family
     - Recording period (dates) and number of operators
     - Whether failed episodes were discarded or kept
-->

## Language Variants

Not every folder is an independent recording. One dataset re-annotates episodes that
already exist elsewhere in the collection:

| Variant | Source episodes | Paraphrases | Difference |
|---|---|---|---|
| `pick_place_cubes_para` | `pick_place_cubes` | 8 | Same episodes, task string expressed 8 different ways |

`pick_place_cubes_para` contains the **same trajectories** as `pick_place_cubes`, with
the natural-language task description rewritten in 8 different phrasings. It exists to
test whether a language-conditioned policy generalises across instruction wording
rather than latching onto one exact string.

Two consequences worth knowing:

- **Do not count both toward dataset size.** Together they represent one set of
  recordings, not two. The unique figures in the statistics table already exclude the
  variant.
- **Do not put both in the same training mix without thinking.** Naively concatenating
  them duplicates every episode, doubling that task's weight. Either train on the
  paraphrased version alone, or sample the pair as one dataset.

## Limitations

- **Environment.** Most recordings share one lab, one table and similar lighting.
  Background and surface diversity is limited.
- **Single embodiment.** Everything is SO-101. Cross-embodiment transfer is untested.
- **Fixed camera geometry** at 640 × 480, with uncorrected wide-angle
  distortion, and inconsistent overhead cropping between datasets.
- **Uneven dataset sizes.** Durations range from a few minutes to nearly an hour, so
  naive concatenation heavily over-weights the longer datasets.
- **Manual randomisation** means object-position coverage is not uniform or measured;
  in some datasets objects were re-randomised only every ~10 episodes.
- **Human demonstrations only** — no failure cases, recovery behaviours or
  counterexamples, which limits use for methods that need negative data.

<!-- TODO: add anything else you know to be true — e.g. whether any task
     descriptions are inconsistent, or whether some datasets share episodes. -->

## License

Released under the **Apache 2.0** license. Individual datasets may carry additional
attribution requirements.

## Related Resources

- [LeRobot](https://github.com/huggingface/lerobot) — framework used for recording
- [LeRobot docs](https://huggingface.co/docs/lerobot) — full documentation
- [Dataset format guide](https://huggingface.co/blog/lerobot-datasets) — best practices
- [SmolVLA](https://huggingface.co/blog/smolvla) — VLA model these datasets suit
- [Community Dataset v3](https://huggingface.co/datasets/HuggingFaceVLA/community_dataset_v3) — larger cross-embodiment collection