This is a derivative work of the Nymeria dataset (Meta / Project Aria). By accessing this repository you confirm that you have read and accepted the Project Aria Research License Agreement (https://www.projectaria.com/datasets/nymeria/license/) and will use the data only for non-commercial academic research, citing both the original Nymeria paper and the TartanIMU foundation-model paper when reporting results.

Nymeria → TartanIMU (human IMU, retargetted)

Part of the TartanIMU Benchmark, a large-scale multi-platform inertial (IMU) benchmark for learning-based odometry, released for the IROS 2026 Workshop: Beyond Exteroception: Interoceptive Perception for Resilient Robotics (Pittsburgh, PA, USA). Organized by the AirLab, Robotics Institute, Carnegie Mellon University. See the Tartan-IMU organization for the companion car / drone / quadruped / handheld platforms.

This repository provides the large-scale human / egocentric resource of the benchmark: the human-IMU + ground-truth-pose subset of the Nymeria dataset (Meta / Project Aria), re-projected into the TartanIMU schema.

Drop-in compatible with the official TartanIMU AirLabNPZSequence data loader. No modifications to the upstream TartanIMU-master/ source are required — a one-line apply_patch() call wires in the necessary fix.

Nymeria is Meta / Project Aria's large-scale egocentric multimodal dataset of people walking around with Aria glasses + two wrist-mounted Aria devices. This repository holds the human-IMU + ground-truth-pose subset of Nymeria, re-projected into the schema expected by TartanIMU's dataloader/dataset_AirLab.py::AirLabNPZSequence.

At a glance
sequences (3-role complete)	1 084 / 1 100 (98.5 %)
`traj.npz` files (head + lwrist + rwrist)	3 283 / 3 300 (99.5 %)
unique participants	236
total IMU samples @ 200 Hz	668 377 842 (≈ 0.67 B)
total recording duration	928 h (≈ 39 days)
total disk size	30.05 GB (`.npz` zlib-compressed)
splits (deterministic, by participant)	train / val / test = 2 296 / 496 / 491 role-files
coordinate convention	body = X-forward, Y-left, Z-up world = ENU, gravity-aligned
sample rate	strictly uniform 200 Hz, `float64` timestamps
audit pass-rate	3 281 / 3 283 (99.94 %) on 10 deep checks per NPZ

Authoritative machine-readable stats: _dataset_card.json. Full per-file audit: audit_summary.json.

⚠️ READ-THIS-FIRST: Two non-negotiable rules for training

If you skip either of these, training will silently degrade.

Rule 1 — Apply the `motion_type` patch BEFORE any data loader call

AirLabNPZSequence.load() (in dataloader/dataset_AirLab.py) decides motion_type by substring matching the file path in the order car → dog → drone → human. Because 84 of the 3 283 NPZs come from sequences whose participant token contains the substring car, they would be silently labeled motion_type = 1 (car) instead of 4 (human), routing those 84 trajectories to the wrong prediction head during multi-head training.

Apply the patch shipped at the repo root:

import sys, os
sys.path.insert(0, "/path/to/this/dataset")    # so airlab_human_patch is importable
from airlab_human_patch import apply_patch
apply_patch()                                  # idempotent; call once at startup

Verified fix: every NPZ under data/human/... now reports motion_type == 4. See airlab_human_patch.py — 30 lines, zero edits to TartanIMU source.

Rule 2 — Use `window_time: 1.0` in your training config

TartanIMU's AirLabNPZSequence.load (in dataloader/dataset_AirLab.py) contains a hardcoded 200:

local_disp = quat_gt[self.interval:].inv().apply(pos_gt[self.interval:]) \
           - quat_gt[:-self.interval].inv().apply(pos_gt[:-200])   # ← 200 hardcoded

This only matches when interval = window_time * imu_freq = 1.0 × 200 = 200. Any other value (e.g. window_time: 0.5) raises ValueError: Cannot broadcast N rotations to N-100 vectors.

The official config/resnet_lstm_multihead.yaml ships with window_time: 1.0, so as long as you don't change it you're fine. Don't change it.

Rule 3 (recommended) — minimal training config patch

data:
  dataset: AirLab
  data_path:
    human: /path/to/downloaded/data/human/nymeria   # ← this repo, /human/nymeria/
  use_local_coord: True
  train_dir: train
  validation_dir: val
  test_dir: test
  imu_freq: 200.0
  sample_freq: 40

train:
  active_heads: ["human"]      # skip the car/dog/drone heads — we only have human data

1. Quick start

# install
pip install -U "huggingface_hub[cli]" numpy scipy

# pull the whole dataset (resumable; ~30 GB)
huggingface-cli login                                           # one-time, paste your read token
huggingface-cli download Tartan-IMU/Nymeria \
    --repo-type dataset \
    --local-dir ./nymeria_tartanimu \
    --resume-download

# verify nothing is missing / pointer-only
cd nymeria_tartanimu
python examples/verify_integrity.py

Then a 5-line sanity check:

import numpy as np
from pathlib import Path

p = next(Path("data/human/nymeria/train").glob("*__lwrist/traj.npz"))
with np.load(p) as z:
    ts, imu, pos, quat = (z["retargetted_ts"], z["retargetted_imu"],
                          z["retargetted_pos"], z["retargetted_quat"])
print(f"N={len(ts)} dur={ts[-1]-ts[0]:.1f}s  |q|={np.linalg.norm(quat,1).mean():.6f}")

For TartanIMU-flavoured loading, see the four example scripts in examples/.

2. Directory layout

nymeria-tartanimu/                       ← HF repo root after download
├── README.md                            ← this file
├── LICENSE                              ← Project Aria Research License terms (link)
├── CITATION.cff                         ← how to cite this dataset + upstreams
├── .gitattributes                       ← *.npz → LFS
│
├── airlab_human_patch.py                ← 🔑 the motion_type fix (Rule 1)
├── _dataset_card.json                   ← machine-readable stats / audit / failures
├── audit_summary.json                   ← compact 10-check deep-audit roll-up
│
├── examples/
│   ├── load_raw_numpy.py                ← framework-agnostic; pure np.load
│   ├── load_via_airlab.py               ← uses TartanIMU's AirLabNPZSequence
│   ├── load_for_tartanimu_training.py   ← full BasicSequenceData + SeqToSeqDataset
│   └── verify_integrity.py              ← SHA-256 check against MANIFEST.sha256
│
├── known_issues/
│   └── failed_sequences.tsv             ← the 17 upstream-defective role files
│
├── pipeline/                            ← full retargeting source for reproducibility
│   ├── README_nymeria_pipeline.md
│   ├── nymeria_to_tartanimu.py          ← driver: download → retarget → write NPZ
│   ├── _pipeline_core.py                ← coordinate transforms + integrity checks
│   ├── validate_all_npz.py              ← 10-check deep audit
│   ├── overfit_one_seq.py               ← CPU smoke test (data self-consistency)
│   ├── overfit_config.yaml
│   ├── patch_ts_dtype.py
│   ├── env_setup.sh
│   └── requirements.txt
│
├── MANIFEST.sha256                      ← sha256 + size of every traj.npz
│
└── data/
    └── human/
        └── nymeria/
            ├── train/                   ← 769 head + 765 lwrist + 762 rwrist = 2 296 files
            │   ├── 20230607_s0_james_johnson_act0_e72nhq__lwrist/
            │   │   └── traj.npz
            │   ├── 20230607_s0_james_johnson_act0_e72nhq__lwrist/
            │   │   └── traj.npz
            │   ├── 20230607_s0_james_johnson_act0_e72nhq__rwrist/
            │   │   └── traj.npz
            │   └── …
            ├── val/                     ← 166 / 165 / 165 = 496 files
            └── test/                    ← 165 / 163 / 163 = 491 files

The folder naming convention is <seq_id>__<role> with role ∈ {head, lwrist, rwrist}:

head — IMU inside the Aria glasses (gaze-aligned).
lwrist / rwrist — IMU inside the wrist-worn Aria devices.

seq_id and the participant token are preserved verbatim from the official Nymeria release for full traceability against the original recording.

3. NPZ schema (per file)

Each traj.npz is an np.savez_compressed archive containing exactly four arrays.

key	shape	dtype	meaning
`retargetted_ts`	`(N,)`	`float64`	Seconds since the first frame. Strictly monotonic, uniform spacing of `1/200 s = 5 ms` (jitter < 1 ns).
`retargetted_imu`	`(N, 6)`	`float32`	Body-frame `[ax, ay, az, gx, gy, gz]`. Accelerometer is in m/s² and includes gravity (so a stationary device reads ≈ 9.81 along +Z). Gyro is in rad/s.
`retargetted_pos`	`(N, 3)`	`float32`	World-frame position `[x, y, z]` in metres. World frame is ENU (gravity-aligned, Z up).
`retargetted_quat`	`(N, 4)`	`float32`	xyzw (scalar last) quaternion describing the body→world rotation. Per-sample norm ∈ [0.999, 1.001].

This matches the array reads in AirLabNPZSequence.load (dataloader/dataset_AirLab.py) exactly — AirLabNPZSequence will load these arrays without any further preprocessing.

Coordinate frames

Aria source frame (as it comes out of projectaria_tools): X = left, Y = up, Z = forward.
TartanIMU body frame (what we store): X = forward, Y = left, Z = up.
Conversion: a constant 3×3 rotation R_TI_FROM_ARIA is applied to accel, gyro, and pose. See pipeline/_pipeline_core.py::AXIS_TRANSFORM for the exact matrix and unit tests.
World frame: ENU (East-North-Up), with gravity along −Z (i.e. the world Z axis points up, away from the Earth's centre, consistent with imu[:, 2] ≈ +9.81 at rest).

4. Splits

70 / 15 / 15 train / val / test, deterministic by participant_id. The participant token is the substring between s[01]_ and _actN_ in seq_id (e.g. james_johnson in 20230607_s0_james_johnson_act0_e72nhq), and the assignment is seeded_hash(participant_id) → split. Properties this guarantees:

A given participant never appears in more than one split (no leakage).
Re-running the pipeline (or running it on a subset) yields the same split.

See pipeline/_pipeline_core.py::split_assignment for the deterministic hashing logic.

split	head	lwrist	rwrist	total roles	3-role-complete seqs
train	769	765	762	2 296	759
val	166	165	165	496	164
test	165	163	163	491	161

5. Quality assurance — 10 checks per NPZ

Every traj.npz is validated by pipeline/validate_all_npz.py.

#	check	threshold	result (3 283 files)
1	schema (4 keys, dtypes, shapes)	exact	3 283 / 3 283 ✅
2	timestamps strictly monotonic + uniform 200 Hz	Δt jitter < 1 ns	3 283 / 3 283 ✅
3	no NaN / Inf in any array	—	3 283 / 3 283 ✅
4	per-sample `‖quat‖`	∈ [0.999, 1.001]	3 283 / 3 283 ✅ (observed mean = 1.000000)
5	per-sample max position step	< 0.5 m	3 283 / 3 283 ✅
6	IMU bounds: `‖a‖_max ≤ 245 m/s² (~25 g)`, `‖ω‖_max ≤ 52.4 rad/s (~3000 °/s)`	upstream-quality cap	3 283 / 3 283 ✅
7	velocity RMS sanity	< 5 m/s typical	3 283 / 3 283 ✅
8	gravity in quiet windows: median `‖a_world‖` over 1 s low-motion blocks	∈ [9.0, 10.5] m/s²	3 281 / 3 283 ✳️
9	gyro vs quaternion-derivative MAE	< 0.5 rad/s	3 283 / 3 283 ✅
10	`AirLabNPZSequence.load()` returns `valid=True` and `motion_type=4`	exact	3 283 / 3 283 ✅

Two files (✳️) fail check 8 by a thin margin (max gravity 10.74 / 10.55 m/s² versus the 10.5 m/s² cap, i.e. ≤ 3 % over). They pass all other 9 checks and are perfectly usable for training — listed transparently in audit_summary.json under failures.

Single-sequence overfit smoke test (data self-consistency proof)

We also ship pipeline/overfit_one_seq.py, a CPU-friendly script that trains a 6.4 M-param FoundationModel on one trajectory until body-velocity MSE plateaus, then integrates the predictions back into a world-frame trajectory. This isolates data-quality (no-model "target-velocity vs ground-truth" integration error) from model-quality (predicted vs ground truth).

Reference run on this dataset (train/20230607_s0_james_johnson_act0_e72nhq__lwrist, 60 s clip, 50 epochs, CPU only, batch 16, lr 1e-3, ~33 minutes wall-clock):

metric	value	meaning
`loss_init`	1.12e-4	initial body-velocity MSE
`loss_final`	2.30e-6	final body-velocity MSE
loss drop	49.1×	architecture can fit the data
`ATE_target_vs_gt`	0.026 m / 60 s	data is self-consistent — frames, gravity, dt are right
`ATE_pred_vs_gt`	0.044 m / 60 s	model trajectory is on top of GT
`RTE_pred_vs_gt` (5-step)	0.017 m	local consistency
per-axis vel MAE	0.001 / 0.001 / 0.000 m/s	all 3 axes converge
verdict	PASS	go train at GPU scale

The 0.026 m / 60 s dead-reckoning drift is 0.04 % / s — well below the 1 m / min threshold and an order of magnitude better than typical low-cost MEMS-IMU pure dead-reckoning. This confirms the retargetting pipeline preserves all the physics (frames, quaternion order, gravity sign, dt).

Re-run any time:

python pipeline/validate_all_npz.py --root data/human/nymeria --out-json my_audit.json
python pipeline/overfit_one_seq.py --npz data/human/nymeria/train/<seq>__lwrist/traj.npz --epochs 50

6. Known issues — 17 upstream-defective role files

The pipeline rejected 17 role files coming from real defects in the upstream Nymeria release (Meta CDN bug, IMU calibration anomaly, MPS trajectory glitch — not retargeting bugs). Full list in known_issues/failed_sequences.tsv.

failure mode	count	example
upstream `.zip` missing `motion.vrs` or `closed_loop_trajectory.csv`	3	`20230616_s0_kristen_thomas_act1_2wxfud/lwrist`
Aria accelerometer max > 25 g (245 m/s²), implies calibration spike or impact	12	`20230622_s1_sherri_scott_act2_9y4er8/lwrist` (`max\|a\| = 268.8 m/s²`)
Aria gyroscope max > 3000 °/s (52.4 rad/s), implies clipping	1	`20230911_s1_ethan_jacobson_act4_l7qshl/rwrist` (`max\|ω\| = 54.2 rad/s`)
MPS trajectory position step > 0.5 m, implies a tracking glitch	1	`20230919_s1_jessica_webster_act1_82ye18/lwrist` (`max step = 0.872 m`)

Affecting 16 unique sequences out of 1 100 (1.5 %); the other 1 084 sequences have all 3 roles intact.

If Meta releases corrected source files in the future, you can regenerate the missing NPZs by re-running the pipeline (it is fully idempotent — already-good NPZs are skipped):

# put a fresh Nymeria_download_urls.json at workspace root, then:
bash pipeline/run_full_background.sh start    # if you have the launcher
# or directly:
python pipeline/nymeria_to_tartanimu.py --manifest Nymeria_download_urls.json \
       --out-root dataset/nymeria_retargetted

See pipeline/README_nymeria_pipeline.md for the full retargeting design document (coordinate-frame derivations, integrity-check rationale, IMU bias / scale handling).

7. Loading examples

7.1 Raw NumPy (no TartanIMU dependency)

from pathlib import Path
import numpy as np

p = next(Path("data/human/nymeria/train").glob("*__lwrist/traj.npz"))
with np.load(p) as z:
    ts   = z["retargetted_ts"]    # (N,)   float64
    imu  = z["retargetted_imu"]   # (N, 6) float32   body-frame [a; ω], gravity INCLUDED in a
    pos  = z["retargetted_pos"]   # (N, 3) float32   world-frame position (m), ENU
    quat = z["retargetted_quat"]  # (N, 4) float32   body→world rotation, xyzw

dt = float(np.median(np.diff(ts)))                # = 0.005 s
g  = np.linalg.norm(imu[:, :3], axis=1).mean()    # ≈ 9.8
print(f"N={len(ts)} dur={ts[-1]-ts[0]:.1f}s dt={dt*1e3:.3f}ms <|a|>={g:.3f} m/s²")

See full script: examples/load_raw_numpy.py.

7.2 Single-file via `AirLabNPZSequence`

import sys, os
sys.path.insert(0, "/path/to/TartanIMU-master")
sys.path.insert(0, "/path/to/this/dataset")
from airlab_human_patch import apply_patch
apply_patch()                                   # ⚠️ before constructing the sequence
from dataloader.dataset_AirLab import AirLabNPZSequence

seq = AirLabNPZSequence(
    data_path="data/human/nymeria/train/20230607_s0_james_johnson_act0_e72nhq__lwrist/traj.npz",
    imu_freq=200, window_size=200,
)
assert seq.valid and int(seq.motion_type) == 4   # human
print(seq.features.shape, seq.targets.shape, seq.orientations.shape)

See full script: examples/load_via_airlab.py.

7.3 Full training-ready dataset

# everything: apply_patch + BasicSequenceData + SeqToSeqDataset + shape verify
python examples/load_for_tartanimu_training.py \
    --tartanimu-master /path/to/TartanIMU-master \
    --data-root data/human/nymeria --split train --num 3

Expected output (verified on this dataset, 16-core CPU):

[info] BasicSequenceData: 3 valid seqs, 123 456 total windows after outlier filter
[batch element]
  feat  shape=(10, 6, 200)  dtype=float32   (expected (seq_len=10, channels=6, window=200))
  targ  shape=(10, 3)       dtype=float32   (expected (10, 3))
  ori   shape=(2000, 4)     dtype=float32   (expected (2000, 4))
  label = 4                                  (expected 4 — 'human' motion type)
[OK] dataset is plug-and-play with TartanIMU's official ResNet-LSTM head.

See full script: examples/load_for_tartanimu_training.py.

8. Recommended training workflow

The following four-step sequence is designed to surface data or integration issues early, before committing to a full GPU training run.

Smoke test (5 min, CPU) — load a sample of NPZ files from each split and verify schema + finite + qnorm:

python examples/load_raw_numpy.py --split train --num 5
python examples/load_raw_numpy.py --split val   --num 5
python examples/load_raw_numpy.py --split test  --num 5

Integrity check (one-time, ~10 min) — SHA-256 every file:
```
python examples/verify_integrity.py
```
Single-sequence overfit (30 min, CPU) — confirm physics is right:
```
python pipeline/overfit_one_seq.py \
    --npz data/human/nymeria/train/<seq>__lwrist/traj.npz --epochs 50
```
Expect ate_target_vs_gt_m_sanity < 0.1 m / 60 s and loss_ratio > 10×.

Multi-NPZ TartanIMU loader test (5 min) — confirm batches assemble:

python examples/load_for_tartanimu_training.py \
    --tartanimu-master /path/to/TartanIMU-master \
    --split train --num 10

Full TartanIMU training (GPU) — see the official entry point, remembering Rules 1-3 above:

python TartanIMU-master/main_net.py \
    --config TartanIMU-master/config/datasets/tartanimu/tartan_imu_dataset.yaml

9. Provenance & reproducibility

Source dataset — Nymeria, Meta / Project Aria, 2024. Original VRS files & MPS closed-loop trajectories.
Reader — projectaria_tools==1.7.1.
Conversion — pipeline/nymeria_to_tartanimu.py + pipeline/_pipeline_core.py.
Generated on — 2026-05-14 to 2026-05-16 (44 h wall clock on a 16-core Xeon, single-host pipeline with up-to-3 concurrent retarget workers and HTTP proxy to the Meta CDN).
Target loader version — TartanIMU dataloader/dataset_AirLab.py as of May 2026 commit. The repo is at https://superodometry.com/tartanimu.

To reproduce from raw .zip downloads see pipeline/README_nymeria_pipeline.md. The pipeline is fully idempotent at the sequence level — restart from crash with no manual intervention and it picks up exactly where it left off.

10. License & citation

This dataset is a derivative work of Nymeria and inherits the Project Aria Research License Agreement (non-commercial academic research only). By accessing this repository you agree to the upstream license; see the official terms.

When reporting results, please cite both the upstream Nymeria dataset and the TartanIMU Benchmark:

@misc{tartanimu_benchmark_2026,
  title        = {TartanIMU: A Multi-Platform Benchmark for Learned Inertial Odometry},
  author       = {AirLab, Robotics Institute, Carnegie Mellon University},
  year         = {2026},
  howpublished = {IROS 2026 Workshop: Beyond Exteroception},
  url          = {https://huggingface.co/Tartan-IMU}
}

@inproceedings{ma2024nymeria,
  title     = {Nymeria: A Massive Collection of Multimodal Egocentric Daily Motion in the Wild},
  author    = {Ma, Lingni and others},
  booktitle = {European Conference on Computer Vision (ECCV)},
  year      = {2024}
}

11. Acknowledgements

Meta / Project Aria for releasing the Nymeria dataset under an academic research license.
The TartanIMU Benchmark is organized by the AirLab, Robotics Institute, Carnegie Mellon University, building on the multi-head IMU foundation-model architecture this dataset is designed to feed.
projectaria_tools developers for the robust VRS reader and MPS API.

Contact

TartanIMU Benchmark organizing team — AirLab, Robotics Institute, Carnegie Mellon University. See the organization page.

12. Versioning & changelog

version	date	notes
1.0.0	2026-05-16	First public release. 1 084 / 1 100 complete sequences. 3 281 / 3 283 deep-audit pass.

Downloads last month: 67

Total file size:

32.3 GB

You need to agree to share your contact information to access this dataset