Datasets:
license: cc-by-4.0
language:
- en
pretty_name: ForceBody
size_categories:
- 10K<n<100K
task_categories:
- other
tags:
- 3d-human-body-models
- force-paired-dataset
- uncertainty-annotations
- biomechanics
- human-motion
- inverse-dynamics
- ground-reaction-force
- skel
- joint-torque
- motion-capture
configs:
- config_name: default
data_files:
- split: train
path: manifest_train.csv
- split: test
path: manifest_test.csv
ForceBody
ForceBody pairs the SKEL parametric body model with measured ground reaction forces and inverse-dynamics joint torques across 10,386 motion trials (26.9 hours of motion at 100 Hz) from 140 subjects. A subset of 8,652 trials additionally ships per-frame, per-joint Monte Carlo uncertainty sigma_tau for every torque label.
Each trial is stored as a single NumPy .npz file readable with numpy.load. No nimblephysics, OpenSim, or AddBiomechanics tooling is needed to consume the data.
Layout
ForceBody/
├── trials_skelfit_with_uncertainty/ 8,652 trials. SKEL + measured GRF + tau + Monte Carlo sigma_tau
│ └── <subject_id_raw>/trial_<idx>.npz
├── trials_skelfit_only/ 1,734 trials. SKEL + measured GRF + tau (no Monte Carlo)
│ └── <subject_id_raw>/trial_<idx>.npz
├── manifest.csv 10,386 rows, one per trial (full)
├── manifest_train.csv 9,649 train rows
├── manifest_test.csv 737 test rows
├── subjects.csv 378 rows, one per subject_id_raw
├── ForceBody_sample.tar.gz 100-trial reviewer sample (157 MB)
└── README.md
Folder names use a study-prefix when needed to disambiguate identical subject names across source datasets (Moore2015__subject7 vs Uhlrich2023__subject7). Subjects unique within their source dataset (e.g. P002_split0 from Carter2023) appear without the prefix. The study prefix is also applied where two source studies use the same subject identifier under different capitalisation, so that the layout is safe on case-insensitive filesystems (Windows, macOS default).
Quick start for reviewers (small sample)
The full release is roughly 19 GB. For a fast first look, download the 100-trial sample (157 MB), which carries the same per-trial schema as the full release.
Direct download URL:
https://huggingface.co/datasets/ForceBody/ForceBody_ano/resolve/main/ForceBody_sample.tar.gz
Or with wget / curl:
wget https://huggingface.co/datasets/ForceBody/ForceBody_ano/resolve/main/ForceBody_sample.tar.gz
tar -xzf ForceBody_sample.tar.gz
ls ForceBody_sample/
The sample is stratified across all 10 source studies: 72 trials with Monte Carlo uncertainty and 28 skelfit-only trials, drawn with numpy seed 42. A SAMPLE_README.md inside the archive describes the selection. The schema documented in this README applies verbatim to every npz in the sample.
subject_id_raw carries a study prefix where it is needed to disambiguate identical subject names across source datasets (Moore2015__subject7 vs Uhlrich2023__subject7). Subjects unique within their source dataset (e.g. P002_split0 from Carter2023) appear without the prefix.
Composition
10,386 trials. 26.92 hours of motion. 140 subjects, defined as the unique pair (study, subject) after collapsing the _splitN rolling-window suffix used by Carter2023. Concretely, Carter2023/P002_split0..2 count as one subject; Moore2015/subject7 and Uhlrich2023/subject7 count as two.
The split column on manifest.csv is the subject-level partition inherited from AddBiomechanics. There is no leakage between train and test.
| Split | Trials | Subjects (study, base) | Hours |
|---|---|---|---|
| train | 9,649 | 121 | 24.93 |
| test | 737 | 19 | 1.99 |
| total | 10,386 | 140 | 26.92 |
The Monte Carlo subset is a strict subset of these 10,386 trials. Of the released trials, 8,086 train and 566 test trials carry sigma_tau. The remaining 1,734 trials carry SKEL fit, measured GRF, and the deterministic inverse-dynamics torque, but no Monte Carlo annotation. Most of the 1,734 are excluded from the Monte Carlo pass because their GRF coverage falls below 50%.
There is no validation split. If you need one, derive it from the train trials by hashing on trial_uid.
Per-trial NPZ schema
Each trial_<idx>.npz is a NumPy archive. T is the trial frame count after resampling to 100 Hz (also stored as num_frames). n_c is the number of contact bodies (n_contacts), which is 2 (left and right foot) in 10,316 trials and 3 (left foot, right foot, chair) in 70 sit-to-stand trials from Falisse2017.
The schema below applies to every trial. Trials in trials_skelfit_with_uncertainty/ carry six additional fields marked "MC only" below, for a total of 38 keys; trials in trials_skelfit_only/ have 32 keys.
Identity
| Field | dtype | shape |
|---|---|---|
subject_id_raw |
str | scalar |
subject_pure |
str | scalar |
study |
str | scalar |
trial_idx |
int32 | scalar |
SKEL parameters
| Field | dtype | shape | Notes |
|---|---|---|---|
poses |
float32 | [T,46] |
SKEL pose, axis-angle per joint |
betas |
float32 | [10] |
SKEL shape, constant within a trial |
trans |
float32 | [T,3] |
Global translation, world frame, meters |
Kinematics, AddB Rajagopal (37 DOF)
| Field | dtype | shape | Notes |
|---|---|---|---|
q_gt |
float32 | [T,37] |
Joint angles, radians for revolute and meters for prismatic |
qd_gt |
float32 | [T,37] |
Joint velocities |
qdd_gt |
float32 | [T,37] |
Joint accelerations |
dof_names lists the 37 DOFs in order. The first 6 DOFs are the floating-base pelvis. direct_dof_mask is True on the 20 DOFs at the 14 anatomical joints (bilateral hip, knee, ankle, MTP, elbow, radioulnar, wrist) that have a direct correspondence to SKEL. Together with the pelvis these give the 15 directly matched joints used for SKEL fitting (Fig. 3 of the paper).
Torques
tau_gt_det is present in every trial. The Monte Carlo fields are present only when the trial lives in trials_skelfit_with_uncertainty/.
| Field | dtype | shape | Always present | Notes |
|---|---|---|---|---|
tau_gt_det |
float32 | [T,37] |
yes | Inverse-dynamics torque inherited from AddB, deterministic |
mu_tau |
float32 | [T,37] |
MC only | Monte Carlo mean torque |
sigma_tau |
float32 | [T,37] |
MC only | Monte Carlo standard deviation, the released uncertainty |
percentiles |
float32 | [7,T,37] |
MC only | Per-DOF Monte Carlo percentiles |
percentile_values |
float32 | [7] |
MC only | Percentile levels: 1, 5, 25, 50, 75, 95, 99 |
Torques are in N·m. To match the mass-normalized reporting used in the paper (Tables 2, 4, 5), divide by mass_kg.
Forces, measured ground reaction
| Field | dtype | shape | Notes |
|---|---|---|---|
grf |
float32 | [T,n_c,3] |
3D ground reaction force per foot, world frame, Newtons |
cop |
float32 | [T,n_c,3] |
3D center of pressure per foot, world frame, meters |
contact_torque |
float32 | [T,n_c,3] |
Contact moment per foot |
n_contacts |
int32 | scalar | Typically 2 |
grf_valid_mask |
bool | [T] |
False on frames where AddB marks the GRF as missing |
Optical markers
Raw mocap marker trajectories from the source recording. M is per-trial: marker sets differ across source studies (e.g. Carter2023 uses 56 markers with names like RFT1, LCAL; Tiziana2019 uses 29 markers with names like LxAsis). Names are kept as-is rather than remapped to a common skeleton. NaN indicates marker dropout in the original recording. World frame, meters, resampled to the trial's 100 Hz timeline by nearest-neighbor in the index domain.
| Field | dtype | shape | Notes |
|---|---|---|---|
markers |
float32 | [T, M, 3] |
3D marker positions, world frame, NaN on dropout |
marker_names |
str | [M] |
Per-trial marker names |
n_markers |
int32 | scalar | M for this trial |
Trial metadata
| Field | dtype | Notes |
|---|---|---|
num_frames |
int32 | T |
fps |
float32 | 100 Hz throughout |
dt |
float32 | 1 / fps |
mass_kg |
float32 | Subject mass at the time of recording |
height_m |
float32 | Subject height at the time of recording |
dof_names |
str[37] | Names of the 37 Rajagopal DOFs |
direct_dof_mask |
bool[37] | True on the 20 direct DOFs |
Subject metadata, snapshotted into each trial
| Field | dtype | Notes |
|---|---|---|
activity_class |
str | running, walking, jumping, sit_to_stand, standing, stairs, others, or unknown |
sex |
str | male, female, or unreported |
age |
float32 | Years, NaN if unreported |
bmi |
float32 | kg/m², NaN if unreported |
Provenance
| Field | dtype | Always present | Notes |
|---|---|---|---|
mc_source |
str | yes | Monte Carlo source pass, one of v3, b2, b3, or skelfit_only |
b3d_path |
str | yes | Path to the source AddBiomechanics b3d file |
sigma_q_deg |
float32 | MC only | RMS of the input-side angle noise used for Monte Carlo. 1.6° throughout, matching the AddB IK angle RMSE on synthetic walking data |
n_mc_samples |
int32 | MC only | Number of Monte Carlo samples per frame. 1000 throughout |
manifest.csv
One row per trial. The columns mirror the most useful per-trial scalars on disk and add a few precomputed conveniences for filtering and splitting.
| Column | Notes |
|---|---|
trial_uid |
<subject_id_raw>__trial<idx>, unique key, safe to hash on |
subject_id_raw |
identity |
subject_pure |
identity within the source dataset |
subject_base |
subject_pure with the _splitN suffix collapsed, used for the 121/19 subject count |
study |
source dataset |
split |
train or test |
trial_idx |
int |
has_uncertainty |
1 if the trial lives in trials_skelfit_with_uncertainty/, else 0 |
mc_source |
v3, b2, b3, or skelfit_only |
activity_class, sex, age, mass_kg, height_m, bmi |
subject metadata |
num_frames, fps, dt, duration_s |
trial length |
n_grf_valid, grf_ratio |
per-trial GRF coverage |
mpjpe_mm |
SKEL fitting error, mean per-joint |
npz_path |
relative path. Load with np.load(ROOT / row["npz_path"]) |
subjects.csv aggregates by subject_id_raw and adds n_trials, n_with_uncertainty, total_hours, and an activities summary.
Quickstart
import csv
from pathlib import Path
import numpy as np
ROOT = Path("/path/to/ForceBody")
manifest = list(csv.DictReader(open(ROOT / "manifest.csv")))
print(len(manifest), "trials")
print(sum(1 for r in manifest if r["has_uncertainty"] == "1"), "with uncertainty")
r = manifest[0]
d = np.load(ROOT / r["npz_path"], allow_pickle=True)
print(d.files)
print("poses:", d["poses"].shape, "tau:", d["tau_gt_det"].shape, "grf:", d["grf"].shape)
if int(r["has_uncertainty"]):
print("median sigma_tau:", float(np.nanmedian(d["sigma_tau"])))
PyTorch dataset
A minimal lazy-loading dataset. Set direct=True to return only the 20 direct-DOF channels used in Tables 4 and 5 of the paper.
import csv
from pathlib import Path
import numpy as np
import torch
from torch.utils.data import Dataset
class ForceBody(Dataset):
def __init__(self, root, split="train", uncertainty_only=False, direct=False):
self.root = Path(root)
rows = list(csv.DictReader(open(self.root / "manifest.csv")))
self.trials = [
r for r in rows
if r["split"] == split
and (not uncertainty_only or r["has_uncertainty"] == "1")
]
self.direct = direct
def __len__(self):
return len(self.trials)
def __getitem__(self, i):
r = self.trials[i]
d = np.load(self.root / r["npz_path"], allow_pickle=True)
sel = d["direct_dof_mask"] if self.direct else slice(None)
item = {
"poses": torch.from_numpy(d["poses"]),
"betas": torch.from_numpy(d["betas"]),
"trans": torch.from_numpy(d["trans"]),
"q_gt": torch.from_numpy(d["q_gt"][:, sel].copy()),
"qd_gt": torch.from_numpy(d["qd_gt"][:, sel].copy()),
"qdd_gt": torch.from_numpy(d["qdd_gt"][:, sel].copy()),
"tau": torch.from_numpy(d["tau_gt_det"][:, sel].copy()),
"grf": torch.from_numpy(d["grf"]),
"cop": torch.from_numpy(d["cop"]),
"valid": torch.from_numpy(d["grf_valid_mask"]),
"mass_kg": float(d["mass_kg"]),
}
if int(r["has_uncertainty"]):
item["sigma_tau"] = torch.from_numpy(d["sigma_tau"][:, sel].copy())
item["mu_tau"] = torch.from_numpy(d["mu_tau"][:, sel].copy())
return item
Trials have variable length. Crop or pad them in your collator.
Common usage patterns
Joint torque regression. Predict tau_gt_det from (q_gt, qd_gt, qdd_gt, grf, cop). Train on the 9,649-trial train split.
Uncertainty-weighted training. Restrict to the 8,086 train trials with has_uncertainty == 1 and weight the per-frame loss by 1 / sigma_tau².
GRF and GRM regression from kinematics. Predict (grf, cop, contact_torque) from (q_gt, qd_gt, trans). grf_valid_mask selects supervisable frames.
Marker-based pose fitting. Use markers and marker_names to retrain a marker-to-pose model and compare against the released SKEL fit.
Subject-level evaluation. Group test trials by subject_id_raw (or by the (study, subject_base) pair) and report subject-mean metrics so that a single long trial does not dominate.
Joints used for evaluation
The paper benchmarks torque prediction on the 15 directly matched joints between Rajagopal and SKEL (Fig. 3). These break down as:
- 14 anatomical joints with a direct SKEL correspondence: bilateral hip, knee, ankle, MTP, elbow, radioulnar, and wrist. These contribute the 20 direct DOFs flagged by
direct_dof_mask. - 1 floating-base pelvis (DOFs 0..5). Reported separately because its inverse-dynamics output re-expresses ground reaction rather than a muscle-driven joint torque.
Tables 4 and 5 of the paper report Upper mean (elbow, radioulnar, wrist) and Lower mean (hip, knee, ankle, MTP), each averaged across left and right.
Anonymous release
This release is shared anonymously to support double-blind review of the accompanying submission. Author names, affiliations, and contact information are omitted.
Attribution
ForceBody is a derivative of the AddBiomechanics dataset, with motion re-expressed on the SKEL body model and accompanied by Monte Carlo torque uncertainty. Users should attribute the upstream AddBiomechanics dataset and the original source studies listed in the study column of subjects.csv (e.g. Carter2023, Moore2015, Hammer2013, Falisse2017, Fregly2012, Han2023, Li2021, Tiziana2019, Uhlrich2023, vanderZee2022).
License
The motion and force annotations in ForceBody inherit the CC BY 4.0 license of the upstream AddBiomechanics dataset. Redistribution and modification are permitted with attribution.
The SKEL parameters released here (poses, betas, trans) are derived numerical fits and depend on the SKEL body model. The SKEL model itself is distributed under a separate non-commercial research license by its authors and is not redistributed here. Users who need to instantiate meshes from the released SKEL parameters must obtain the SKEL model directly from its authors and accept their license terms.
Commercial use of ForceBody additionally requires permission from the SKEL licensors for any pipeline that loads the SKEL model.