AFUN / README.md
afun-anonymous's picture
README: shorten the overview
e311751 verified
|
Raw History Blame Contribute Delete
5.98 kB
---
pretty_name: AFUN
license: cc-by-nc-sa-4.0
language:
- en
size_categories:
- 10K<n<100K
tags:
- robotics
- affordance
- manipulation
- 3d-motion
- segmentation
---
# AFUN
The **AFUN** dataset: **59,867 entries** for affordance segmentation and 3D interaction-motion
prediction (`manifest_full.json`). The archives are in `data/` and `extra/`;
[Full index](#full-index-59867-entries) lists what each part holds.
Each data point is one folder: an RGB frame, its depth map, the ground-truth affordance
mask, the ground-truth 3D motion, and a language instruction.
## Download & extract
```bash
pip install -U huggingface_hub
hf download afun-anonymous/AFUN --repo-type dataset --local-dir afun_train
cd afun_train
for f in data/*.tar.zst; do tar --zstd -xf "$f"; done
```
Download ≈ 231 GiB for `data/` (extracted ≈ 522 GiB) and 59 GiB for `extra/`. After extraction:
```
afun_train/
├── manifest.json # index — one entry per data point
└── <source>/<episode>/<interval>/<cam>/ # one folder per data point
├── obs_frame.png # RGB frame
├── obs_frame_depth.npy # float32 H×W depth, millimeters
├── sam_mask.png # affordance mask (non-zero = actionable region)
└── trajectory.json # 3D motion + camera intrinsics
```
## Load a data point
```python
import json, numpy as np
from PIL import Image
m = json.load(open("manifest.json"))
s = m["samples"][0]
rgb = np.array(Image.open(f"{s['path']}/obs_frame.png"))
depth = np.load(f"{s['path']}/obs_frame_depth.npy") # millimeters
mask = np.array(Image.open(f"{s['path']}/sam_mask.png")) > 0
traj = json.load(open(f"{s['path']}/trajectory.json"))
print(s["language"], traj["camera_info"]["intrinsics"])
```
Each manifest entry has `path` (the folder), `dataset` / `episode_id` / `interval` / `cam`,
the instruction (`language`, with variants in `queries`), and `shard` (which archive
contains it).
## trajectory.json
3D positions are in the **camera frame, in meters**. `camera_info` holds the intrinsics
(`fx, fy, cx, cy`), the distortion model, and `T_base_to_cam`.
There are **two schemas**, because SceneFun3D scenes are annotated differently from robot
and human videos:
**A. Robot / human sources** (`droid`, `robomind`, `agibot`, `rh20t`, `rh20t_human`,
`calvin`, `rlbench`, `vitra`) — one interaction per file, fields at the top level:
| field | meaning |
|---|---|
| `trajectory_3d` | GT motion of the interaction point, `[{frame_idx, position_3d}, ...]` — the curve-fitted (denoised) track |
| `motion_2d` | start / end pixel of the motion |
| `spline_params.ctrl` | control points of the fitted 3D curve (the training target is sampled from this curve) |
**B. `scenefun3d`** — SceneFun3D is a set of annotated 3D scans, not videos. A scene can
have several annotated functional parts (a drawer, a window, a tap), so the motions live in
a **list** called `trajectories`, one entry per annotation. Each entry has the same fields
as schema A (`trajectory_3d`, `motion_2d`, `spline_params`) plus:
| field | meaning |
|---|---|
| `annot_id` | the original SceneFun3D annotation id |
| `interval_language` | the instruction for *this* annotation |
| `motion_type` | `rot` (hinged: door, window) or `trans` (sliding: drawer) |
| `scenefun3d_motion_params` | the analytic motion (see below) |
`scenefun3d_motion_params` is what makes this source distinctive — the motion is given in
closed form, not just as samples:
- `motion_type: "rot"` → `motion_dir_cam` (rotation axis), `origin_cam` (a point on the
axis, i.e. the hinge), `ref_cam` (reference point), `angle_rad` (e.g. `1.5708` = 90°)
- `motion_type: "trans"` → `motion_dir_cam` (slide direction), `origin_cam` (start point),
`distance_m` (e.g. `0.3`), `orient` (`inwards` / `outwards`)
`trajectory_3d` is 15 points sampled from those parameters.
**In practice `trajectories` has length 1** (~95% of files; the rest have 2).
Reading either schema:
```python
traj = json.load(open(f"{s['path']}/trajectory.json"))
if "trajectories" in traj: # scenefun3d
motion = traj["trajectories"][0] # [0] is enough for almost every file
else: # robot / human sources
motion = traj
points = [p["position_3d"] for p in motion["trajectory_3d"]] # camera frame, meters
```
## Sources
| key | dataset | entries |
|---|---|---:|
| scenefun3d | SceneFun3D | 49,706 |
| robomind | RoboMIND | 4,491 |
| vitra | VITRA (human videos) | 2,432 |
| droid | DROID | 1,664 |
| rh20t_human | RH20T human demos | 644 |
| agibot | AgiBot World | 614 |
| rh20t | RH20T | 186 |
| calvin | CALVIN | 118 |
| rlbench | RLBench | 12 |
| **total** | | **59,867** |
The evaluation sets are released separately as [**AFUN_eval**](https://huggingface.co/datasets/afun-anonymous/AFUN_eval) and are disjoint from the
training views at the sample level. `extra/` contains the test and validation views.
## Full index (59,867 entries)
`manifest_full.json` lists every row of the index reported in the paper. Each entry has a `split`:
| entries | count | archive |
|---|---:|---|
| training views | 44,749 | `data/*.tar.zst` (the same views as `manifest.json`) |
| validation views (SceneFun3D) | 9,610 | `extra/val-scenefun3d-*.tar.zst` |
| test views | 121 | `extra/test-0000.tar.zst` (also in AFUN_eval) |
| views removed in later quality checks | 326 | `extra/removed-0000.tar.zst` |
| repeated rows | 5,061 | `extra/duplicates-0000.tar.zst` |
A repeated row lists a training view (4,977) or a test view (84) a second time. These entries extract
to `duplicates/<path>` and name the original in `duplicate_of`. There are 54,806 distinct views.
Train on `manifest.json` only: `extra/` holds held-out data. Ego4D views in `extra/` are
annotation-only (`sam_mask.png`, `trajectory.json`).
```bash
for f in extra/*.tar.zst; do tar --zstd -xf "$f"; done
```