IntelligentDecisionLab/b1k-torque-sidecars

BEHAVIOR-1K Torque Sidecars

Per-frame joint torque, gravity and Coriolis signals for the BEHAVIOR-1K 2026 challenge demonstrations — the channels the official release does not contain.

The official demos (behavior-1k/2026-challenge-demos) ship a 61-dimensional state of joint positions, velocities and end-effector poses. There is no torque, no contact force, no dynamics decomposition. This dataset adds them by re-simulating the same demonstrations with physics enabled and recording what the solver actually measured, so each episode here joins 1:1 with an official episode by (task_id, demo_id).

Status: 2,452 episodes across all 100 tasks. This is a work in progress — 6 tasks are complete at 200 episodes, and most others hold a single coverage episode while collection continues.

What is in a file

One HDF5 file per episode, named chunk_<demo_id>_1.hdf5. The trailing _1 is the chunk size and is load-bearing — see Provenance.

data/                                  # attrs: see below
└── demo_0/                            # attrs: num_samples
    ├── action        (T, 23)  float32 # the recorded action replayed at this step
    ├── obs/
    │   ├── robot_r1::proprio (T, 229) float32   # ← the point of this dataset
    │   └── task::low_dim     (T, 274) float32   # task-relevant object state
    ├── reward        (T,)     float32
    ├── terminated    (T,)     bool
    └── truncated     (T,)     bool

The robot group is named robot_r1::proprio in most tasks and robot::proprio in some — match on the ::proprio suffix rather than the full name.

The 229-dim proprioception vector

The layout is written into every file as the proprio_layout attribute, so you never have to hard-code these offsets:

slice	field	dims	meaning
[0:61]	challenge_61	61	the official challenge state, unchanged — use this to align with 2026-challenge-demos
[61:89]	joint_qpos	28	joint positions
[89:117]	joint_qvel	28	joint velocities
[117:145]	joint_qeffort	28	measured joint torque (N·m) — PhysX net transmitted force
[145:173]	joint_qeffort_applied	28	torque the controller commanded
[173:201]	joint_gravity	28	gravity term g(q)
[201:229]	joint_coriolis	28	Coriolis/centrifugal term c(q,q̇)

joint_qeffort is the primary signal. joint_qeffort_applied is what the controller asked for; the difference between them is where contact and constraint forces live.

A caveat that matters for dynamics work: gravity is disabled on all non-base links in OmniGibson's robot setup, so the measured efforts carry no gravity load. joint_gravity is a PhysX what-if query — what gravity would contribute if it were enabled — not a component present in joint_qeffort. It is not small: sampled across tasks it runs 80–97 N·m at p95 and saturates near 824 N·m, comparable to the measured efforts themselves (530–590 N·m peak). joint_coriolis is genuinely small at p95 (≤0.2 N·m) though it spikes to tens of N·m.

Subtracting either channel from the measured torque to recover an "external" force is therefore wrong — the terms are not in the measurement to begin with. Take joint_qeffort as the external/contact-bearing signal directly. An early analysis of ours made exactly this mistake and inflated a contact-intensity feature by 2.8× before it was caught.

File attributes

Every file is self-describing:

attribute	contents
proprio_layout	the slice table above, as JSON
manifest	[{"group": "demo_0", "demo_id": ...}] — the source demo
task_id, task_name	e.g. 26, assembling_gift_baskets
n_steps, n_episodes	frame count; always 1 episode per file
config	full env config (30 Hz action, 30 Hz render, 120 Hz physics)
scene_file	the scene, including asset and OmniGibson versions
omnigibson_git_hash	exact commit that produced the file
replay_cell	B-natural-frequency — the validated replay configuration
extracted_from	(present only on rescued episodes — see Provenance)

Layout

task-0000/ … task-0099/         # depth collection, up to 200 episodes per task
  chunk_<demo_id>_1.hdf5
  _manifest.json                # written when a task reaches 200 episodes
  _partial.json                 # written while a task is still filling
coverage-1ep/task-XXXX/         # the earlier one-episode-per-task coverage sweep
  chunk_<demo_id>_1.hdf5

coverage-1ep/ is a separate namespace holding the initial breadth pass. A demo may appear in both namespaces — 145 did at the time of writing, and the count grows as collection continues. Deduplicate on (task_id, demo_id), not on file count, or you will double-count.

How it was obtained

Source demonstrations: behavior-1k/2026-challenge-rawdata (raw teleoperated HDF5, actions plus serialized simulator states).

Each episode is re-simulated with physics on, one fresh environment per episode:

1. the recorded simulator state is restored at each frame,
2. the robot's own controllers execute the recorded action through one physics step,
3. PhysX's measured joint efforts are recorded.

This is teacher-forced replay at the recorded control frequency (action 30 Hz, physics 120 Hz). The state restoration keeps the trajectory on the demonstrated path while the physics step produces the forces that path implies.

Replay is camera-less (--lean): no render products are created, since the torque channels do not need them. This was validated as bit-exact against full replay (correlation 1.00000) while cutting VRAM from 13.9 GB to 2.7 GB per worker.

Physics runs on the CPU PhysX solver. gm.USE_GPU_DYNAMICS is off — a GPU-solver variant uses different numerics and has not passed an effort-equivalence check, so it is not used for any data here.

Why the official demos cannot be used directly

Upstream warns that observations produced by the stock replay script are not usable for this purpose: it runs with visual-only physics (gravity zeroed, collisions off, state teleported every frame, controllers zeroed), so its efforts are meaningless. Recovering true torques requires the physics-on configuration above.

Provenance — read this before using older copies

An earlier generation of this dataset was contaminated and has been fully purged.

Replay originally batched several episodes into one long-lived environment. Every BEHAVIOR demo is a different task instance — there are 300 object placements per task — so within a batch, each episode after the first was restored into the previous episode's finished world: objects left wherever the last demo had pushed them. The recorded torques were real physics of the wrong scene. Divergence was worst exactly at force peaks, reaching 62,877 N·m, with 61 solver blow-ups against 17 in clean runs.

Crucially, the contaminated episodes passed physical plausibility checks — they are correct physics, just of the wrong configuration. No range or sanity check can detect this. It was found by comparing batched output against single-episode ground truth.

What that means for this repository:

• The chunk size in the filename is the integrity marker. chunk_<demo>_1.hdf5 is structurally immune: the contaminating code path only runs for episodes after the first in a batch, so at chunk size 1 it never executes. Every file here is _1.
• Any file named chunk_<demo>_<N>.hdf5 with N ≥ 2 is from the contaminated generation. 280 such files (947 affected episodes) were deleted on 2026-07-21. If you hold an older snapshot, discard them.
• The first episode of each contaminated batch was valid, and those were rescued rather than discarded — verified first by re-recording 25 of them independently and confirming the proprioception was bit-identical (max |Δtorque| = 0) across batch sizes 5 through 15. Rescued files carry an extracted_from attribute recording their origin.

Collection since then uses chunk size 1 exclusively, and the replay driver now refuses a larger chunk size rather than documenting it as unsafe.

Joining with the official demos

Match on (task_id, demo_id): task_id and the manifest attribute give both. The challenge_61 slice is the official 61-dim state carried through unchanged, so you can verify an alignment by comparing it against observation.state in 2026-challenge-demos.

import h5py, json, numpy as np

with h5py.File("task-0026/chunk_00260420_1.hdf5") as f:
    d = f["data"]
    layout = json.loads(d.attrs["proprio_layout"])
    demo_id = json.loads(d.attrs["manifest"])[0]["demo_id"]

    key = next(k for k in d["demo_0/obs"] if k.endswith("::proprio"))
    proprio = d[f"demo_0/obs/{key}"][:]           # (T, 229)

    lo, hi = layout["joint_qeffort"]
    torque = proprio[:, lo:hi]                    # (T, 28) measured joint torque, N·m
    official_state = proprio[:, 0:61]             # aligns with 2026-challenge-demos

Known limitations

• Coverage is uneven. Median episodes per task is 1; only 6 tasks are complete. Sample with this in mind rather than assuming a balanced set.
• Effort is inversely correlated with task size — small tasks are far better represented (~18% depth under 5 GB of source demos, ~1% above 30 GB), because large scenes are slower to replay. The heaviest, most contact-rich scenes are currently the least covered.
• No gravity load in measured efforts, as described above.
• Contact forces are not stored as an explicit channel; they are implicit in the difference between measured and applied torque.

Intended use

Built to test whether force-awareness improves manipulation policies: training a model with these torque channels against a vision-only baseline on the same demonstrations. The dataset is equally usable for contact detection, dynamics identification, and force-conditioned representation learning.