Hugging Face's logo

Datasets:
humanarchive
/
HA-Multi-Samples

Tasks:
Robotics
Video Classification
Size:
100K<n<1M
Tags:
lerobot
tactile
multimodal
egocentric
manipulation
imu
License:
Dataset card Files
xet
 Community
HA-Multi-Samples / README.md
humanarchive's picture
humanarchive
Update README.md
7283519 verified
preview code
|
raw
history blame contribute delete
21.9 kB
---
license: apache-2.0
task_categories:
- robotics
- video-classification
tags:
- lerobot
- tactile
- multimodal
- egocentric
- manipulation
- imu
- stereo
- robotics
pretty_name: Human Archive Multisensory Dataset Samples
size_categories:
- 100K<n<1M
---
# Human Archive
[Human Archive](https://www.ycombinator.com/launches/PeP-human-archive-the-world-s-largest-multimodal-robotics-dataset) is modeling human sensorimotor intelligence at scale. We currently collect 2,000+ hours of this multimodal dataset per week, making this the largest and first dataset of its kind.
We’re backed by Y Combinator and engineers from OpenAI, BAIR, SAIL, Anduril Industries, Mercor, NVIDIA, Jane Street, Google, DoorDash AI Research, Reevo, AfterQuery, and the investors behind AMI Labs.
Follow us on [X](https://x.com/babugi28)
To purchase the full dataset, find time [here](https://cal.com/human-archive-0mw2ab/30min?user=human-archive-0mw2ab)
# HA-Multi-Samples
A multimodal human activity dataset in [LeRobot v3](https://github.com/huggingface/lerobot) containing synchronized RGB-D, tactile sensing, chest and wrist cameras, and 8 upper-body IMUs captured during household tasks.
![Screenshot 2026-04-03 at 8.16.53 PM](https://cdn-uploads.huggingface.co/production/uploads/69cbab90907c9d6af1c0361c/JjT0LLTOyAbyoE9QgJak5.png)
---
## Dataset Summary
| Metric | Value |
|---|---|
| Total episodes | 36 |
| Total frames | 420,630 |
| Frame rate | 30 fps |
| Total duration | 3 hours 54 minutes |
| Video streams | 6 synchronized cameras |
| Sensor modalities | Tactile (512 taxels), Hand and Body IMU (8) |
| Unique tasks | 11 |
| Unique environments | 10 |
| Cross-modal alignment | < 33 ms (< 1 frame at 30 fps) |
| Video data size | ~64 GB |
| Sensor data size | ~66 MB (Parquet) |
| Average episode length | 6.5 minutes |
| Median episode length | 5.1 minutes |
| Shortest episode | 22.3 seconds |
| Longest episode | 21.3 minutes |
---
## Task and Environment Breakdown
### By Task
| Task | Episodes | Duration |
|---|---|---|
| Cleaning | 19 | 118.9 min |
| Cooking | 4 | 43.0 min |
| Ironing | 4 | 31.2 min |
| Folding and cleaning | 2 | 25.4 min |
| Folding clothes | 6 | 14.2 min |
| Placing shoes | 1 | 1.0 min |
### By Environment
Environment labels describe the room type, not unique rooms. Multiple episodes labeled "Bedroom" or "Kitchen" may come from different physical locations.
| Environment | Episodes | Duration |
|---|---|---|
| Bedroom | 20 | 115.8 min |
| Kitchen | 7 | 61.0 min |
| Living room | 3 | 32.3 min |
| Bathroom | 3 | 18.3 min |
| Office | 1 | 3.8 min |
| Hallway | 2 | 2.5 min |
---
## File Structure
```
HA-Multi-Samples/
├── meta/
│ ├── info.json # Dataset schema, features, and configuration
│ ├── stats.json # Per-feature statistics (min, max, mean, std)
│ ├── tasks.parquet # Task label table (11 rows)
│ └── episodes/
│ └── chunk-000/
│ └── file-000.parquet # Episode metadata table (36 rows)
├── data/
│ └── chunk-000/
│ └── file-000.parquet # All sensor data (420,630 rows)
└── videos/
 ├── observation.images.egocentric/
 │ └── chunk-000/
 │ ├── file-000.mp4 # Episode 0
 │ ├── file-001.mp4 # Episode 1
 │ └── ... # file-{NNN}.mp4 = Episode NNN
 ├── observation.images.chest/
 │ └── chunk-000/
 │ └── file-{000-035}.mp4
 ├── observation.images.left_wrist/
 │ └── chunk-000/
 │ └── file-{000-035}.mp4
 ├── observation.images.right_wrist/
 │ └── chunk-000/
 │ └── file-{000-035}.mp4
 ├── observation.images.stereo_left/
 │ └── chunk-000/
 │ └── file-{000-035}.mp4
 └── observation.images.stereo_right/
 └── chunk-000/
 └── file-{000-035}.mp4
```
Each video file corresponds to one episode. Episode N maps to `file-{N:03d}.mp4` across all camera streams.
---
## Modalities
### 1. Video Streams (6 cameras)
All videos are H.264 encoded, 30 fps, with `yuv420p` pixel format.
| Stream | Resolution | Mounting Position | Notes |
|---|---|---|---|
| `observation.images.egocentric` | 1920x1080 | Head-mounted, first-person | Fisheye lens, wide-angle forward view |
| `observation.images.chest` | 1920x1080 | Chest-mounted, downward-angled | Captures hands and workspace |
| `observation.images.left_wrist` | 1920x1080 | Left wrist/forearm | Left hand and nearby objects |
| `observation.images.right_wrist` | 1920x1080 | Right wrist/forearm | Right hand and nearby objects |
| `observation.images.stereo_left` | 1280x720 | Head-mounted, downward-facing (left) | Stereo pair for depth |
| `observation.images.stereo_right` | 1280x720 | Head-mounted, downward-facing (right) | Stereo pair for depth |
#### Egocentric (Center RGB) Camera Intrinsics
The head-mounted egocentric camera uses a fisheye lens. Intrinsics at 1920x1080:
```
fx = 1093.98 fy = 1093.39
cx = 953.05 cy = 536.30
```
#### Stereo Camera Intrinsics and Depth Reconstruction
The stereo pair is head-mounted and downward-facing, capturing the workspace and hands from above. The pair can be used for depth estimation. Camera parameters at the delivered 1280x720 resolution:
**Left stereo camera:**
```
fx = 566.06 fy = 566.02
cx = 640.75 cy = 400.78
Distortion model: Rational polynomial (14 coefficients)
```
**Right stereo camera:**
```
fx = 566.54 fy = 566.69
cx = 644.35 cy = 403.60
Distortion model: Rational polynomial (14 coefficients)
```
**Stereo geometry:**
```
Baseline: 74.95 mm
```
The center RGB camera (egocentric/chest) sits approximately centered between the stereo pair — 37.4 mm to the right of the left camera and 37.6 mm to the left of the right camera. All cameras share a common rigid mount.
To compute a disparity map and recover depth:
```python
import cv2
import numpy as np
# Camera matrices
K_left = np.array([[566.06, 0, 640.75],
 [0, 566.02, 400.78],
 [0, 0, 1]])
K_right = np.array([[566.54, 0, 644.35],
 [0, 566.69, 403.60],
 [0, 0, 1]])
baseline_mm = 74.95
# After rectification, depth from disparity:
# depth_mm = (fx * baseline_mm) / disparity
# Using average fx ≈ 566.3:
# depth_mm = (566.3 * 74.95) / disparity
```
### 2. Tactile Sensors (256 taxels per hand)
Each hand is equipped with a full-coverage tactile glove containing 256 fiber-optic pressure sensors (taxels). The sensors use fiber-optic technology — light intensity through flexible optical fibers changes under mechanical pressure, providing responsive and high-dynamic-range force sensing across the entire hand surface. Values are unsigned 8-bit integers (0–255), stored as `float32` in the dataset.
| Feature | Shape | Description |
|---|---|---|
| `observation.tactile.left` | (256,) | Left hand tactile pressure array |
| `observation.tactile.right` | (256,) | Right hand tactile pressure array |
**Pressure value ranges:**
| Contact Type | Typical Range |
|---|---|
| No contact | 0 |
| Light touch | 1–5 |
| Moderate grip | 10–35 |
| Hard press/grip | 40–105 |
| Sensor maximum | 255 |
Approximately 60 of the 256 taxels are active during a typical grip. Some taxels may read zero consistently due to sensor placement or contact geometry.
#### Taxel Layout
The 256-byte array is formed by concatenating two 128-byte packets from the glove hardware. Indices 0–127 correspond to the first packet and indices 128–255 to the second.
The taxels map to the hand as follows:
**Finger sensors (60 taxels per hand):** Each finger has 4 phalanges with 3 taxels each (12 taxels per finger, 5 fingers).
Left hand finger mapping (256-byte array indices):
| Finger | Phalanx 1 (fingertip) | Phalanx 2 (mid-distal) | Phalanx 3 (mid-proximal) | Phalanx 4 (base) |
|---|---|---|---|---|
| Thumb | 30, 29, 28 | 14, 13, 12 | 254, 253, 252 | 238, 237, 236 |
| Index | 27, 26, 25 | 11, 10, 9 | 251, 250, 249 | 235, 234, 233 |
| Middle | 24, 23, 22 | 8, 7, 6 | 248, 247, 246 | 232, 231, 230 |
| Ring | 21, 20, 19 | 5, 4, 3 | 245, 244, 243 | 229, 228, 227 |
| Pinky | 18, 17, 16 | 2, 1, 0 | 242, 241, 240 | 226, 225, 224 |
Right hand finger mapping (256-byte array indices):
| Finger | Phalanx 1 (fingertip) | Phalanx 2 (mid-distal) | Phalanx 3 (mid-proximal) | Phalanx 4 (base) |
|---|---|---|---|---|
| Thumb | 239, 238, 237 | 255, 254, 253 | 15, 14, 13 | 31, 30, 29 |
| Index | 236, 235, 234 | 252, 251, 250 | 12, 11, 10 | 28, 27, 26 |
| Middle | 233, 232, 231 | 249, 248, 247 | 9, 8, 7 | 25, 24, 23 |
| Ring | 230, 229, 228 | 246, 245, 244 | 6, 5, 4 | 22, 21, 20 |
| Pinky | 227, 226, 225 | 243, 242, 241 | 3, 2, 1 | 19, 18, 17 |
**Bridge sensors (5 per hand):** One sensor between each finger and the palm.
| | Thumb | Index | Middle | Ring | Pinky |
|---|---|---|---|---|---|
| Left hand index | 221 | 218 | 215 | 212 | 209 |
| Right hand index | 46 | 43 | 40 | 37 | 34 |
**Palm grid (72 taxels per hand):** Arranged in 5 rows from fingers to heel of palm.
Left hand palm (all from indices 128–255):
| Row | Count | Index Range |
|---|---|---|
| Row 1 (near fingers) | 12 | 206 → 195 |
| Row 2 | 15 | 190 → 176 |
| Row 3 | 15 | 174 → 160 |
| Row 4 | 15 | 158 → 144 |
| Row 5 (heel of palm) | 15 | 142 → 128 |
Right hand palm (all from indices 0–127):
| Row | Count | Index Range |
|---|---|---|
| Row 1 (near fingers) | 12 | 60 → 49 |
| Row 2 | 15 | 79 → 65 |
| Row 3 | 15 | 95 → 81 |
| Row 4 | 15 | 111 → 97 |
| Row 5 (heel of palm) | 15 | 127 → 113 |
#### Extracting Specific Regions
```python
import numpy as np
def extract_finger_taxels(tactile_256: np.ndarray, hand: str = "left") -> dict:
 """Extract per-finger taxels from the raw 256-element array.
 Args:
 tactile_256: Shape (256,) array of pressure values.
 hand: "left" or "right".
 Returns:
 Dict mapping finger name to (12,) array [4 phalanges x 3 taxels].
 """
 if hand == "left":
 mapping = {
 "thumb": [30,29,28, 14,13,12, 254,253,252, 238,237,236],
 "index": [27,26,25, 11,10,9, 251,250,249, 235,234,233],
 "middle": [24,23,22, 8,7,6, 248,247,246, 232,231,230],
 "ring": [21,20,19, 5,4,3, 245,244,243, 229,228,227],
 "pinky": [18,17,16, 2,1,0, 242,241,240, 226,225,224],
 }
 else:
 mapping = {
 "thumb": [239,238,237, 255,254,253, 15,14,13, 31,30,29],
 "index": [236,235,234, 252,251,250, 12,11,10, 28,27,26],
 "middle": [233,232,231, 249,248,247, 9,8,7, 25,24,23],
 "ring": [230,229,228, 246,245,244, 6,5,4, 22,21,20],
 "pinky": [227,226,225, 243,242,241, 3,2,1, 19,18,17],
 }
 return {name: tactile_256[idx] for name, idx in mapping.items()}
```
### 3. Body IMUs (8 streams)
IMU sensors are distributed across the upper body, providing acceleration and angular velocity data.
| Feature | Shape | Channels | Placement |
|---|---|---|---|
| `observation.imu.head` | (9,) | accel(3) + gyro(3) + mag(3) | On the camera, ~2 inches in front of the forehead |
| `observation.imu.chest` | (6,) | accel(3) + gyro(3) | Center of the sternum |
| `observation.imu.left_bicep` | (6,) | accel(3) + gyro(3) | Outer surface of the left upper arm, midway between shoulder and elbow |
| `observation.imu.right_bicep` | (6,) | accel(3) + gyro(3) | Outer surface of the right upper arm, midway between shoulder and elbow |
| `observation.imu.left_forearm` | (6,) | accel(3) + gyro(3) | Outer surface of the left forearm, midway between elbow and wrist |
| `observation.imu.right_forearm` | (6,) | accel(3) + gyro(3) | Outer surface of the right forearm, midway between elbow and wrist |
| `observation.imu.left_hand` | (4,) | quaternion(4) | Back of the left hand (from glove) |
| `observation.imu.right_hand` | (4,) | quaternion(4) | Back of the right hand (from glove) |
For the 6-axis IMUs, the channel layout is `[accel_x, accel_y, accel_z, gyro_x, gyro_y, gyro_z]`. The head IMU includes 3 additional magnetometer channels. The hand IMUs provide orientation quaternions `[qx, qy, qz, qw]`.
All IMU data has been resampled to 30 fps to align with video frames using sample-and-hold interpolation from the original variable-rate sensor streams.
### 4. Temporal Alignment
All sensor streams are synchronized to the video frame clock at 30 fps. Cross-modal alignment error is less than 33 ms (less than 1 frame). Variable-rate sensors (tactile gloves, BLE IMUs) are resampled to 30 fps using sample-and-hold: each video frame carries the most recent sensor reading available at that timestamp.
### 5. Hand Motion Capture from Tactile Data
The tactile data can be used to derive per-finger bend (curl) values, providing a form of hand motion capture without an optical tracking system. The method sums the pressure across the fingertip phalanges for each finger to estimate how curled it is:
```python
import numpy as np
def compute_finger_bend(tactile_256: np.ndarray, hand: str = "left") -> np.ndarray:
 """Compute a bend value (0 = open, higher = curled) for each finger.
 Sums 6 taxels across the first 3 phalanges of each finger.
 Returns shape (5,) array: [thumb, index, middle, ring, pinky].
 """
 if hand == "left":
 finger_indices = {
 "thumb": [30, 29, 14, 13, 254, 253],
 "index": [27, 26, 11, 10, 251, 250],
 "middle": [24, 23, 8, 7, 248, 247],
 "ring": [21, 20, 5, 4, 245, 244],
 "pinky": [18, 17, 2, 1, 242, 241],
 }
 else:
 finger_indices = {
 "thumb": [239, 238, 255, 254, 15, 14],
 "index": [236, 235, 252, 251, 12, 11],
 "middle": [233, 232, 249, 248, 9, 8],
 "ring": [230, 229, 246, 245, 6, 5],
 "pinky": [227, 226, 243, 242, 3, 2],
 }
 return np.array([tactile_256[idx].sum() for idx in finger_indices.values()])
def normalize_finger_bend(
 bend_raw: np.ndarray,
 open_hand: np.ndarray,
 closed_fist: np.ndarray,
) -> np.ndarray:
 """Normalize raw bend values to 0.0 (open) – 1.0 (fully curled).
 Requires calibration frames: one with hand open, one with a closed fist.
 """
 range_ = closed_fist - open_hand
 range_[range_ == 0] = 1 # avoid division by zero
 normalized = (bend_raw - open_hand) / range_
 return np.clip(normalized, 0.0, 1.0)
```
To calibrate, capture one frame with the hand fully open and one with a closed fist. The normalized value for each finger then maps directly to joint angle: 0.0 corresponds to fully extended and 1.0 to fully curled. All joints in a finger chain (MCP, PIP, DIP) can use the same normalized value, applying a rotation of `-pi/2 * normalized` per joint for a simple kinematic model.
Combined with the hand IMU quaternion (for wrist orientation) and the per-finger bend values (for finger curl), this provides 6-DOF wrist pose plus 5-DOF finger articulation per hand.
---
## Loading the Dataset
### Prerequisites
```bash
pip install huggingface_hub pandas pyarrow
```
### Download
```bash
huggingface-cli login --token YOUR_TOKEN
huggingface-cli download humanarchive/HA-Multi-Samples \
 --repo-type dataset \
 --local-dir ~/HA-Multi-Samples
```
### Loading in Python
```python
import pandas as pd
import json
from pathlib import Path
DATASET_DIR = Path("~/HA-Multi-Samples").expanduser()
# Load metadata
with open(DATASET_DIR / "meta" / "info.json") as f:
 info = json.load(f)
with open(DATASET_DIR / "meta" / "stats.json") as f:
 stats = json.load(f)
tasks = pd.read_parquet(DATASET_DIR / "meta" / "tasks.parquet")
episodes = pd.read_parquet(DATASET_DIR / "meta" / "episodes" / "chunk-000" / "file-000.parquet")
# Load all sensor data
data = pd.read_parquet(DATASET_DIR / "data" / "chunk-000" / "file-000.parquet")
print(f"Frames: {len(data):,}")
print(f"Episodes: {len(episodes)}")
print(f"Tasks: {list(tasks['task'])}")
print(f"Columns: {list(data.columns)}")
```
### Accessing a Single Episode
Sensor columns are stored as nested arrays (each cell contains a numpy array), not as flattened individual columns.
```python
import numpy as np
episode_id = 0
ep = data[data["episode_index"] == episode_id].reset_index(drop=True)
# Timestamp in seconds
timestamps = ep["timestamp"].values
# Tactile data — shape (N, 256)
left_tactile = np.stack(ep["observation.tactile.left"].values) # (N, 256)
right_tactile = np.stack(ep["observation.tactile.right"].values) # (N, 256)
# Hand IMU — shape (N, 12)
left_hand_imu = np.stack(ep["observation.tactile.left_glove_imu"].values) # (N, 12)
right_hand_imu = np.stack(ep["observation.tactile.right_glove_imu"].values) # (N, 12)
# Body IMUs
chest_imu = np.stack(ep["observation.imu.chest"].values) # (N, 6)
head_imu = np.stack(ep["observation.imu.head"].values) # (N, 9)
left_bicep = np.stack(ep["observation.imu.left_bicep"].values) # (N, 6)
right_bicep = np.stack(ep["observation.imu.right_bicep"].values) # (N, 6)
# Video path for this episode
video_path = DATASET_DIR / "videos" / "observation.images.egocentric" / "chunk-000" / f"file-{episode_id:03d}.mp4"
```
### Playing Videos
```bash
# Play a single camera view for episode 0
open ~/HA-Multi-Samples/videos/observation.images.egocentric/chunk-000/file-000.mp4
# Play with ffplay (if ffmpeg installed)
ffplay ~/HA-Multi-Samples/videos/observation.images.chest/chunk-000/file-005.mp4
```
---
## Per-Episode Reference
| Episode | Task | Environment | Frames | Duration |
|---|---|---|---|---|
| 0 | Cooking | Kitchen | 26,469 | 14.7 min |
| 1 | Cleaning | Living room | 17,792 | 9.9 min |
| 2 | Cleaning | Living room | 38,395 | 21.3 min |
| 3 | Folding and cleaning | Bedroom | 36,747 | 20.4 min |
| 4 | Placing shoes | Hallway | 1,855 | 1.0 min |
| 5 | Cleaning | Bathroom | 9,147 | 5.1 min |
| 6 | Cleaning | Office | 6,842 | 3.8 min |
| 7 | Cleaning | Bedroom | 17,165 | 9.5 min |
| 8 | Folding and cleaning | Bedroom | 9,061 | 5.0 min |
| 9 | Cleaning | Bathroom | 10,974 | 6.1 min |
| 10 | Cleaning | Bedroom | 9,378 | 5.2 min |
| 11 | Folding clothes | Bedroom | 19,023 | 10.6 min |
| 12 | Cleaning | Kitchen | 17,684 | 9.8 min |
| 13 | Cleaning | Living room | 1,925 | 1.1 min |
| 14 | Cleaning | Bedroom | 15,399 | 8.6 min |
| 15 | Folding clothes | Bedroom | 902 | 0.5 min |
| 16 | Folding clothes | Bedroom | 1,193 | 0.7 min |
| 17 | Folding clothes | Bedroom | 3,001 | 1.7 min |
| 18 | Folding clothes | Bedroom | 675 | 0.4 min |
| 19 | Folding clothes | Bedroom | 706 | 0.4 min |
| 20 | Cleaning | Bedroom | 670 | 0.4 min |
| 21 | Cleaning | Bathroom | 12,838 | 7.1 min |
| 22 | Cleaning | Hallway | 2,603 | 1.4 min |
| 23 | Cooking | Kitchen | 36,822 | 20.5 min |
| 24 | Cooking | Kitchen | 3,772 | 2.1 min |
| 25 | Cooking | Kitchen | 10,386 | 5.8 min |
| 26 | Cleaning | Bedroom | 5,622 | 3.1 min |
| 27 | Cleaning | Bedroom | 10,024 | 5.6 min |
| 28 | Cleaning | Bedroom | 1,656 | 0.9 min |
| 29 | Cleaning | Kitchen | 8,522 | 4.7 min |
| 30 | Cleaning | Kitchen | 6,173 | 3.4 min |
| 31 | Cleaning | Bedroom | 21,041 | 11.7 min |
| 32 | Ironing | Bedroom | 1,909 | 1.1 min |
| 33 | Ironing | Bedroom | 27,703 | 15.4 min |
| 34 | Ironing | Bedroom | 14,642 | 8.1 min |
| 35 | Ironing | Bedroom | 11,914 | 6.6 min |
---
## Feature Reference
Complete list of columns in `data/chunk-000/file-000.parquet`. Scalar columns store one value per row. Array columns store a numpy array per row (access with `np.stack(df["column"].values)` to get a 2D matrix).
| Column | Type | Shape | Description |
|---|---|---|---|
| `index` | int64 | scalar | Global frame index across entire dataset |
| `episode_index` | int64 | scalar | Episode number (0–35) |
| `frame_index` | int64 | scalar | Frame number within the episode |
| `timestamp` | float32 | scalar | Time in seconds from episode start |
| `task_index` | int64 | scalar | Task ID (see tasks.parquet) |
| `observation.tactile.left` | float32[] | (256,) | Left hand tactile pressure |
| `observation.tactile.right` | float32[] | (256,) | Right hand tactile pressure |
| `observation.tactile.left_glove_imu` | float32[] | (12,) | Left hand IMU (quaternion + accel/gyro) |
| `observation.tactile.right_glove_imu` | float32[] | (12,) | Right hand IMU (quaternion + accel/gyro) |
| `observation.imu.head` | float32[] | (9,) | Head IMU (accel + gyro + mag) |
| `observation.imu.chest` | float32[] | (6,) | Chest IMU (accel + gyro) |
| `observation.imu.left_bicep` | float32[] | (6,) | Left upper arm IMU |
| `observation.imu.right_bicep` | float32[] | (6,) | Right upper arm IMU |
| `observation.imu.left_forearm` | float32[] | (6,) | Left forearm IMU |
| `observation.imu.right_forearm` | float32[] | (6,) | Right forearm IMU |
| `observation.imu.left_hand` | float32[] | (4,) | Left hand quaternion |
| `observation.imu.right_hand` | float32[] | (4,) | Right hand quaternion |
---
## Format
This dataset uses the [LeRobot v3.0](https://github.com/huggingface/lerobot) chunked format. Key conventions:
- Video files are stored separately from sensor data, referenced by episode index
- Sensor data is stored in Parquet files with one row per frame
- All modalities are time-aligned at 30 fps
- Episodes are independent recording segments; `frame_index` resets to 0 at the start of each episode
- `meta/stats.json` contains per-feature min, max, mean, and standard deviation computed across the full dataset