angkul07/so101-sim-ego-v21

final_data — SO-101, two halves, one schema

A sim/real pair for SO-101 co-training. Both halves are LeRobot v2.1, 30 fps, 6-DOF, two cameras, and carry a byte-for-byte identical feature schema.

final_data/
  sim_v21/    50 eps    16,658 frames    1 task    9.3 min   132 MB
  ego_v21/   324 eps    36,442 frames   89 tasks  20.2 min   335 MB
  README.md

source	provenance
sim_v21	makermods/maniskill_50ep_so101_blue_cube_orange_tray_20260812_131142, LeRobot v3.0 → v2.1
ego_v21	angkul07/ego-data (EgoDex), retargeted through DT-pipeline stage 6 run F (--arm dominant, IK_FREE_ROLL, approach-aware BPP)

Schema

feature	dtype	shape	notes
observation.state	float32	(6,)	shoulder_pan, shoulder_lift, elbow_flex, wrist_flex, wrist_roll, gripper — degrees
action	float32	(6,)	same names, same units
observation.images.front	video	480×640×3	h264, yuv420p, 30 fps
observation.images.wrist	video	480×640×3	h264, yuv420p, 30 fps

Plus the standard timestamp, frame_index, episode_index, index, task_index.

---

1. Variant audit

Everything below is measured off the files — 748 video probes and every parquet — not read from info.json.

	sim (sim_v21)	ego (ego_v21)
variants found	1	1
episodes	50 (100%)	324 (100%)
hours	0.154 (9.3 min)	0.337 (20.2 min)
cameras	2 — front, wrist	2 — same keys
codec	h264	h264
resolution	640×480	640×480
camera fps	30.0	30.0
state Hz	30.0	30.0
action Hz	30.0 (shared timestamp col)	30.0 (shared timestamp col)
cam frames == state rows	yes (100/100)	yes (648/648)

Timestamp jitter is 2.6e-07 s (sim) and 1.1e-07 s (ego) — both are exact 1/30 grids, not resampled approximations.

2. Dataset comparison

Field	sim_v21 (ManiSkill)	ego_v21 (retargeted)
Format	LeRobot v2.1 (converted from v3.0)	LeRobot v2.1 ✓
Robot	maniskill_so101_follower	so101_follower — same arm, different string
Rate	30 Hz / 30 fps	30 Hz / 30 fps ✓
Episodes	50	324
Frames	16,658	36,442
Tasks	1	89
Duration	9.3 min	20.2 min
Episode length	237–447 f (7.9–14.9 s), median 331	30–354 f (1.0–11.8 s), median 96
Camera keys	front / wrist	front / wrist ✓
Video shape/codec	480×640×3, h264, yuv420p	same ✓
Image source	rendered sim cameras (2 real viewpoints)	synthesized (2 crops from 1 ego cam)
state / action	float32[6]	float32[6] ✓
State layout	[pan, lift, elbow, wrist_flex, wrist_roll, gripper], degrees	same ✓ (remapped from the URDF's reversed order)
Action convention	PD setpoint, leads state by 5 frames (argmin lag = 5 on all 50 eps)	absolute next-frame target — exact, max abs diff 0.0 on all 324 eps
Gripper encoding	joint angle deg, larger = open	same polarity ✓
Gripper occupancy	rests closed (0.107), opens to 0.581, mean 0.221	rests mid (0.227), spans 0.000–0.857, mean 0.281
Handedness	single fixed arm	261 R / 63 L, folded onto one arm
On disk	132 MB	335 MB

Compatible on format, rate, schema, DOF, joint order, units and gripper polarity. The real differences are image provenance, the action-horizon gap, and gripper occupancy — §3 and §6.

3. The gripper

Normalized to the joint's physical travel (URDF −10°…100°), so the two rows are directly comparable. 0 = jaws fully closed at the stop, 1 = fully open. If you normalize from LeRobot dataset statistics instead, these numbers shift.

	absolute	p1–p99	p5–p95	typical closed → open	rest (frame 0)
sim_v21	[0.10, 0.58]	[0.11, 0.45]	[0.11, 0.40]	0.107 → 0.389	0.107
ego_v21	[0.00, 0.86]	[0.05, 0.63]	[0.10, 0.54]	0.154 → 0.447	0.227

Decile histograms (% of frames):

sim   0.0  41.3  28.6  25.3   4.3   0.5   0.0   0.0   0.0   0.0
ego   4.9  23.1  34.3  20.4   9.9   5.6   1.6   0.2   0.0   0.0

Same distribution shape — a single mode with an upward taper — offset to the right in ego. Not two different regimes.

Polarity was settled from the video, not assumed. At each dataset's gripper minimum the sim's black jaws are pinched shut and the ego hand is closed around the object; at the maximum the jaws are wide and the hand is spread. Both larger-is-open, so no sign flip is needed anywhere.

Is the resting difference a training problem?

Mostly no — and the part that could bite is not the resting value.

Why it's mostly fine. The distributions overlap heavily rather than forming two clusters: the band [0.15, 0.45] holds 61.5% of sim frames and 74.8% of ego frames. More to the point the signal is consistent — the typical per-episode close→open swing is 0.107→0.389 in sim and 0.154→0.447 in ego. Same direction, nearly the same magnitude (≈0.29 of travel each). "Close to grasp, open to release" is what the policy has to learn, and both halves teach it the same way.

The one to watch is the closed end. Ego's typical closed is 0.154 against sim's 0.107. The ego gripper comes from a human pinch aperture mapped onto the jaw, so on a thick object it never fully commits. If a policy learns "closed ≈ 0.154" and the object needs 0.107 to actually clamp, grasps slip. That is a real failure mode; a 0.12 offset in idle pose is not.

Two cheap fixes, either one removes it:

• Per-dataset normalization stats rather than one mixture-wide mean/std. With a single normalizer the frame-weighted mean lands at ≈0.26, between the two halves, so neither one's "closed" maps to a value the policy can memorize.
• Binarize the gripper at the midpoint of each dataset's own closed→open swing. Standard in most SO-101 recipes and it makes the offset structurally impossible.

Ranked against the other two gaps in §6, this is the smallest of the three by a good margin.

---

4. How ego_v21 was built

One episode per retargeted clip, from stage-6 run F.

Only the active arm is exported. Stage 6 emits (T, 12) — both arms, with the non-dominant one parked at a constant. --arm dominant picks the hand that actually moves, so the active side is read per clip from the active_arms attribute, never assumed to be right (261 R / 63 L).

Two conversions, both silent corruption if skipped:

• Column order. The SO-101 URDF is written distal-to-proximal, so stage 6 emits [wrist_roll, wrist_flex, elbow_flex, shoulder_lift, shoulder_pan, gripper] — the sim's first five joints exactly reversed. The permutation is built by name from each clip's own joint_names attribute, so a future URDF reorder cannot quietly mis-map it.
• Units. Stage 6 works in radians, the gripper included (its range is the URDF's −0.174533‥1.74533, not a normalized [0,1]). The sim is in degrees: its elbow_flex tops out at 96.65 against a URDF limit of 1.69 rad = 96.83°, which is what rules out the LeRobot normalized-[−100,100] reading — that would have given exactly 100.

action[t] = state[t+1], last frame repeated.

The second camera is synthesized

EgoDex has one 1920×1080 egocentric camera. The sim has two.

key	how it is made
front	full frame → 4:3 centre crop (1440×1080) → 640×480
wrist	native 640×480 window tracking the active hand's grasp point — a 1:1 pixel crop, no resampling. Centre track gaussian-smoothed (σ = 2 frames) and clamped so the window is always fully in-frame.

Grasp point = 0.5·thumbTip + 0.35·indexTip + 0.15·middleTip, projected with EgoDex's own intrinsics and per-frame camera pose:

Xc = inv(camera_pose) @ p_world
u  = cx + fx · Xc[0] / Xc[2]
v  = cy + fy · Xc[1] / Xc[2]

Grasp point in-frame: 98.3% mean, 52% on the worst clip.

This is not the formula in multiview.py, which used z = -Xc[2] and v = cy - fy·Y/z — the ARKit convention. On this data Xc[2] is positive on every frame of every clip and the camera's +Y axis points down in world, so both signs are inverted here. Verified by rendering the full 28-point hand skeleton over the source video; the ARKit form lands ~380 px low and mirrored. Note that scoring candidate conventions by "does the projection hit skin pixels" picks the wrong one — it is confounded by the other arm.

No barrel/tilt/colour "virtual lens" is applied. multiview.py used those to make three crops of one video read as three different physical cameras; here the two views are already a wide shot and a close-up, and inventing distortion would put a lens in the data that no camera has.

5. How sim_v21 was built

v3.0 concatenates every episode into one parquet and one mp4 per camera, with per-episode boundaries in meta/episodes/**.parquet. v2.1 wants one file per episode per camera, so the job is: read the boundary table, slice the parquet, cut the videos. No value in any column was changed.

The video cut re-encodes (libx264, crf 20, g=2). It has to: keyframes in the source land every 2 frames but episodes start on odd frames as often as even ones, so -c copy would silently shift half the episodes by one frame against their actions.

Two fixes were needed in convert_v30_to_v21.py before the output could be trusted:

• info.json claimed the wrong codec. The features block is copied from the v3.0 source, which says av1 and carries SVT-AV1-only knobs (video.preset, video.fast_decode) — but every file written is h264. Anything reading the metadata to pick a decoder was being told a lie. Now retagged to what was actually written.
• The pixel-alignment check hardcoded 20 fps in its source seek. On this 30 fps dataset it seeked 1.5× too far and compared each cut against an unrelated frame, so it reported MISALIGNED for every episode except the one at skip=0. The check was wrong, not the cut.

---

6. Before you train on both halves

1. The action semantics differ. The sim's action is a PD setpoint that leads its own state by ~5 frames (argmin of mean|a[t] − s[t+L]| is L=5 on all 50 episodes). The ego half's action is the next retargeted joint position — L=1 by construction, exact to max|a[t] − s[t+1]| = 0.0. A policy trained on the mixture is being asked to predict two different horizons under one head.

2. The visual domain gap is total. The ego half shows human hands manipulating real objects from a head-mounted camera. The sim half shows a robot arm in a rendered scene. The wrist view in particular is a crop of a human hand, not a view from a gripper-mounted camera. Matching the schema does not make these the same distribution.

3. The ego half is joint-saturated. Stage 6 run F still FAILs QA saturation on 203 of 324 clips, and it shows up directly in the exported values as frames sitting on a URDF stop (within 0.5°):

fraction of frames at a joint limit	pan	lift	elbow	wrist_flex	wrist_roll	gripper
sim_v21	0.0%	0.0%	14.0%	0.0%	0.0%	0.0%
ego_v21	12.5%	33.4%	42.3%	38.8%	18.0%	0.0%

The ego half spends between an eighth and two fifths of every joint's frames pinned against a stop; wrist_roll is often flat at −157.2° for a whole episode. Mean IK position error for this run is 12.39 cm. The sim's 14% on elbow_flex is its own resting pose sitting near the stop, not a tracking failure.

4. Five sim episodes have video longer than their data. Episodes 39, 41, 44, 47, 49 have segments 49–213 frames longer than their parquet row count (731 frames total). The extra frames are real motion followed by a static hold — almost certainly the post-demo reset. The conversion takes the first length frames from from_timestamp, which is the only anchor the format gives. Flagging it because it is a defect in the source metadata, not here.

---

7. Verify

python verify_final.py final_data/sim_v21 final_data/ego_v21

Per dataset: parquet rows == declared length == every camera's frame count; video starts at pts 0 on a uniform 1/fps grid (a count check alone sails past a uniform timestamp shift, and LeRobot indexes video by timestamp); frame_index is 0..T−1; index is globally contiguous; episodes_stats.jsonl covers every episode and feature; the declared codec matches the file. Then it diffs the two schemas and prints per-joint ranges and limit-pinning.

Both datasets pass with zero failures, and the schema diff is empty.

Scripts

script	role
convert_v30_to_v21.py	sim v3.0 → v2.1 (provided; codec-retag + fps fixes applied)
ego_to_v21.py	retargeted clips → v2.1, both views, one pass per episode
verify_final.py	structural + cross-schema verification
stats_final.py	the measured numbers in §1–§2

to_lerobot_v21.py, multiview.py and finalize_multiview.py are the originals this work started from; they target the YAM bimanual + abc-teleop 3-view schema and are left untouched.