---
license: cc-by-nc-4.0
task_categories:
  - robotics
  - video-classification
tags:
  - human-activity
  - tactile
  - multimodal
  - egocentric
  - manipulation
  - imu
  - depth
  - stereo
pretty_name: HA-Multi-Samples v2
size_categories:
  - 100K<n<1M
---

# HA-Multi-Samples v2

A multimodal human activity dataset organized **per-episode, per-modality** with face-blurred RGB video (Meta EgoBlur Gen2), raw stereo pair, full-hand tactile sensing, and distributed body IMUs captured during everyday household tasks.

This is a reformatted and re-blurred release of the original HA-Multi-Samples dataset. The episode set, frame counts, durations, task labels, and environment labels are **bit-identical** to the v1 release, so any annotations or analyses keyed off `(episode_index, frame_index)` continue to work unchanged. What's new:

- **EgoBlur Gen2** face blurring on all 4 RGB streams (replaces the v1 face blur model)
- **Per-episode, per-modality folders** for easier browsing and partial loading — no LeRobot dependency required
- **`.npy` files** for tactile, glove IMU, and body IMUs (one file per modality per episode)
- **Raw stereo pair** preserved (left + right rectified). A self-computed depth map (S²M² Large) will land in v2.1.

---

## Dataset Summary

| Metric | Value |
|---|---|
| Total episodes | 36 |
| Total frames | 420,630 |
| Frame rate | 30 fps |
| Total duration | 3 hours 54 minutes |
| Video streams | 4 synchronized RGB cameras + computed depth |
| Sensor modalities | Tactile (512 taxels), Hand IMU (2), Body IMU (8) |
| Unique tasks | 11 |
| Unique environments | 10 |
| Cross-modal alignment | < 33 ms (< 1 frame at 30 fps) |
| Video data size | ~64 GB (4 RGB streams) |
| Stereo data size | ~26 GB (raw L+R, 1280×720, rectified) |
| Sensor data size | ~66 MB |
| 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-v2/
├── episodes/
│   ├── ep_000/
│   │   ├── videos/
│   │   │   ├── egocentric.mp4        # 1920×1080, 30 fps, fisheye, face-blurred
│   │   │   ├── chest.mp4             # 1920×1080, 30 fps, face-blurred
│   │   │   ├── left_wrist.mp4        # 1920×1080, 30 fps, face-blurred
│   │   │   └── right_wrist.mp4       # 1920×1080, 30 fps, face-blurred
│   │   ├── stereo/
│   │   │   ├── left.mp4              # 1280×720, 30 fps, rectified left
│   │   │   └── right.mp4             # 1280×720, 30 fps, rectified right
│   │   │                             # (Depth coming in v2.1 from S²M² Large)
│   │   ├── tactile/
│   │   │   ├── left.npy              # (N, 256) float32
│   │   │   └── right.npy             # (N, 256) float32
│   │   ├── glove_imu/
│   │   │   ├── left.npy              # (N, 12) float32 — quaternion + accel/gyro
│   │   │   └── right.npy             # (N, 12) float32
│   │   ├── imu/
│   │   │   ├── head.npy              # (N, 9) accel+gyro+mag
│   │   │   ├── chest.npy             # (N, 6) accel+gyro
│   │   │   ├── left_bicep.npy        # (N, 6)
│   │   │   ├── right_bicep.npy       # (N, 6)
│   │   │   ├── left_forearm.npy      # (N, 6)
│   │   │   ├── right_forearm.npy     # (N, 6)
│   │   │   ├── left_hand.npy         # (N, 4) quaternion
│   │   │   └── right_hand.npy        # (N, 4) quaternion
│   │   └── meta.json                 # task, environment, source_run, num_frames, ...
│   ├── ep_001/
│   └── ...
├── meta/
│   ├── episodes.csv                  # one row per episode: ep_id, task, env, num_frames, ...
│   ├── tasks.csv                     # task_index → task_label
│   ├── calibration.json              # all camera intrinsics + stereo baseline + depth formula
│   └── stats.json                    # per-modality min/max/mean/std across the dataset
├── README.md
└── LICENSE
```

For every episode, the first axis of every `.npy` file equals the frame count of the four RGB videos. Frame `i` of any `.npy` corresponds to frame `i` of any of the four MP4s. Depth disparity is at half resolution (640×360) — see "Depth" below for conversion.

---

## Methodology

### Face Blurring — EgoBlur Gen2

All four RGB streams (egocentric, chest, left wrist, right wrist) are processed frame-by-frame with the [EgoBlur Gen2 face detector](https://www.projectaria.com/tools/egoblur/) (Meta Project Aria, Nov 2025), the successor to the original EgoBlur model. Each detected face bounding box is expanded by a factor of 1.15 to provide a buffer, then blurred with an elliptical Gaussian kernel sized in proportion to the face bbox. Detection score threshold: 0.55; NMS IoU threshold: 0.5. Stereo views are not blurred (downward-facing, no faces).

### Stereo Pair

Each episode contains the **raw rectified stereo pair** from the head-mounted OAK-D camera, at 1280×720, 30 fps, H.264 encoded. The left and right videos are frame-aligned: frame `i` of `stereo/left.mp4` corresponds to frame `i` of `stereo/right.mp4` and to frame `i` of the RGB streams. Calibration (intrinsics + baseline) is in `meta/calibration.json` — see "Stereo Pair" under Modalities below.

> **Depth coming in v2.1.** A self-computed depth map (from [S²M² Large](https://github.com/junhong-3dv/s2m2) joint disparity/occlusion/confidence model) will be added in a follow-up release without changing the existing files. Episode `meta.json` already includes a `depth_available: false` flag that will flip when depth lands.

#### Recovering Depth From the Stereo Pair (manual)

```python
import cv2, numpy as np

# Load and rectify is already done — these are rectified frames.
left = cv2.VideoCapture("HA-Multi-Samples-v2/episodes/ep_000/stereo/left.mp4")
right = cv2.VideoCapture("HA-Multi-Samples-v2/episodes/ep_000/stereo/right.mp4")
_, L = left.read(); _, R = right.read()
L_gray = cv2.cvtColor(L, cv2.COLOR_BGR2GRAY)
R_gray = cv2.cvtColor(R, cv2.COLOR_BGR2GRAY)

# Classical SGBM (cheap baseline); for higher quality use S²M² / RAFT-Stereo / etc.
stereo = cv2.StereoSGBM_create(minDisparity=0, numDisparities=128, blockSize=7)
disparity = stereo.compute(L_gray, R_gray).astype(np.float32) / 16.0

# Convert to depth
fx = 566.06
baseline_mm = 74.95
with np.errstate(divide="ignore", invalid="ignore"):
    depth_mm = (fx * baseline_mm) / disparity
```

### 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. The per-camera frame offsets used for alignment are identical to the v1 release.

### Parity with v1

Every episode in v2 has identical `num_frames`, `duration_s`, `task`, and `environment` as v1. Frame `i` of episode `j` in v2 corresponds to frame `i` of episode `j` in v1, even though the underlying pixels are re-blurred. This is enforced programmatically: the build pipeline asserts each output `.npy` and `.mp4` matches the v1 frame count before publishing.

---

## Modalities

### 1. Video Streams (4 cameras)

All videos are H.264 encoded, 30 fps, with `yuv420p` pixel format.

| Stream | Resolution | Mounting Position | Notes |
|---|---|---|---|
| `egocentric` | 1920×1080 | Head-mounted, first-person | Fisheye lens, wide-angle forward view |
| `chest` | 1920×1080 | Chest-mounted, downward-angled | Captures hands and workspace |
| `left_wrist` | 1920×1080 | Left wrist/forearm | Left hand and nearby objects |
| `right_wrist` | 1920×1080 | Right wrist/forearm | Right hand and nearby objects |

#### Egocentric Camera Intrinsics

Fisheye lens, intrinsics at 1920×1080:

```
fx = 1093.98    fy = 1093.39
cx = 953.05     cy = 536.30
```

#### Stereo Pair

The head-mounted stereo pair (1280×720, 30 fps) is shipped as `stereo/left.mp4` and `stereo/right.mp4` per episode. Already rectified at recording time; frame-aligned with the four RGB streams.

**Left stereo camera (at 1280×720):**
```
fx = 566.06    fy = 566.02
cx = 640.75    cy = 400.78
Distortion model: Rational polynomial (14 coefficients)
```

**Right stereo camera (at 1280×720):**
```
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.

### 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`.

| File (per episode) | Shape | Description |
|---|---|---|
| `tactile/left.npy` | (N, 256) | Left hand tactile pressure |
| `tactile/right.npy` | (N, 256) | Right hand tactile pressure |

**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. The taxel layout (finger phalanges, palm grid, bridge sensors) and the hand-motion-capture-from-tactile recipe are described in detail in the appendix below — they are unchanged from v1.

### 3. Hand IMU (12 values per hand)

Each glove contains an inertial measurement unit on the back of the hand, providing orientation and motion data.

| File (per episode) | Shape | Description |
|---|---|---|
| `glove_imu/left.npy` | (N, 12) | Left hand IMU |
| `glove_imu/right.npy` | (N, 12) | Right hand IMU |

The first 4 values are quaternion components `[qx, qy, qz, qw]` representing hand orientation. The remaining 8 values are supplementary IMU channels (accelerometer and gyroscope).

### 4. Body IMUs (8 streams)

IMU sensors are distributed across the upper body, providing acceleration and angular velocity data.

| File (per episode) | Shape | Channels | Placement |
|---|---|---|---|
| `imu/head.npy` | (N, 9) | accel(3) + gyro(3) + mag(3) | On the camera, ~2 inches in front of the forehead |
| `imu/chest.npy` | (N, 6) | accel(3) + gyro(3) | Center of the sternum |
| `imu/left_bicep.npy` | (N, 6) | accel(3) + gyro(3) | Outer surface of the left upper arm |
| `imu/right_bicep.npy` | (N, 6) | accel(3) + gyro(3) | Outer surface of the right upper arm |
| `imu/left_forearm.npy` | (N, 6) | accel(3) + gyro(3) | Outer surface of the left forearm |
| `imu/right_forearm.npy` | (N, 6) | accel(3) + gyro(3) | Outer surface of the right forearm |
| `imu/left_hand.npy` | (N, 4) | quaternion(4) | Back of the left hand (from glove) |
| `imu/right_hand.npy` | (N, 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 is resampled to 30 fps to align with video frames using sample-and-hold interpolation from the original variable-rate sensor streams.

---

## Loading the Dataset

### Prerequisites

```bash
pip install huggingface_hub numpy opencv-python
```

### Download

```bash
huggingface-cli login --token YOUR_TOKEN
huggingface-cli download humanarchive/HA-Multi-Samples-v2 \
    --repo-type dataset \
    --local-dir ~/HA-Multi-Samples-v2
```

Or with `snapshot_download`:

```python
from huggingface_hub import snapshot_download
local = snapshot_download(repo_id="humanarchive/HA-Multi-Samples-v2", repo_type="dataset")
```

### Loading One Episode

```python
import json
import numpy as np
import cv2
from pathlib import Path

DATASET = Path("~/HA-Multi-Samples-v2").expanduser()

ep = DATASET / "episodes" / "ep_000"
meta = json.loads((ep / "meta.json").read_text())
print(meta["task"], meta["environment"], meta["num_frames"])

# Sensor data — all aligned to 30 fps, one row per video frame
tactile_left = np.load(ep / "tactile" / "left.npy")              # (N, 256)
tactile_right = np.load(ep / "tactile" / "right.npy")            # (N, 256)
glove_imu_left = np.load(ep / "glove_imu" / "left.npy")          # (N, 12)
glove_imu_right = np.load(ep / "glove_imu" / "right.npy")        # (N, 12)
head_imu = np.load(ep / "imu" / "head.npy")                      # (N, 9)
chest_imu = np.load(ep / "imu" / "chest.npy")                    # (N, 6)
left_bicep = np.load(ep / "imu" / "left_bicep.npy")              # (N, 6)
right_bicep = np.load(ep / "imu" / "right_bicep.npy")            # (N, 6)
left_forearm = np.load(ep / "imu" / "left_forearm.npy")          # (N, 6)
right_forearm = np.load(ep / "imu" / "right_forearm.npy")        # (N, 6)
left_hand = np.load(ep / "imu" / "left_hand.npy")                # (N, 4)
right_hand = np.load(ep / "imu" / "right_hand.npy")              # (N, 4)

# Stereo pair (raw, rectified)
stereo_left  = cv2.VideoCapture(str(ep / "stereo" / "left.mp4"))
stereo_right = cv2.VideoCapture(str(ep / "stereo" / "right.mp4"))

# RGB videos — load with cv2 or decord
cap = cv2.VideoCapture(str(ep / "videos" / "egocentric.mp4"))
frames = []
while True:
    ok, frame = cap.read()
    if not ok: break
    frames.append(frame)  # BGR HxWx3 uint8
ego = np.stack(frames)                                            # (N, 1080, 1920, 3)
```

### Loading All Episodes

```python
import pandas as pd

episodes = pd.read_csv(DATASET / "meta" / "episodes.csv")
tasks = pd.read_csv(DATASET / "meta" / "tasks.csv")

for _, row in episodes.iterrows():
    ep = DATASET / "episodes" / f"ep_{row['episode_index']:03d}"
    # ... load whatever modalities you need
```

### Playing a Video

```bash
open ~/HA-Multi-Samples-v2/episodes/ep_000/videos/egocentric.mp4
ffplay ~/HA-Multi-Samples-v2/episodes/ep_005/videos/chest.mp4
ffplay ~/HA-Multi-Samples-v2/episodes/ep_007/stereo/left.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 |

---

## License

Released under [Creative Commons BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/) for research and non-commercial use. The original v1 dataset is licensed identically.

## Citation

```
@misc{humanarchive2026hamulti,
  title  = {HA-Multi-Samples v2: A Multimodal Human Activity Dataset with Tactile and Computed Depth},
  author = {Human Archive Team},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/datasets/humanarchive/HA-Multi-Samples-v2}}
}
```

Face blurring uses the [EgoBlur Gen2](https://github.com/facebookresearch/EgoBlur) model from Meta. Stereo depth uses [S²M²](https://github.com/junhong-3dv/s2m2) (Junhong et al.). The original sensor recordings and alignment match HA-Multi-Samples v1.

---

## Appendix: Taxel Layout and Hand Motion Capture

The taxel index mapping (per-finger, per-phalanx) and the bend-from-tactile recipe are unchanged from v1 and reproduced below for completeness.

[See full taxel layout in the v1 dataset card — finger mapping, bridge sensors, palm grid, and `compute_finger_bend()` helper.](https://huggingface.co/datasets/humanarchive/HA-Multi-Samples)