reference/vla/convert/README.md

# convert — raw episodes → training datasets

One canonical intermediate, many conventions as pure projections of it. Every raw
source — a sim episode today, a real-robot log tomorrow — is read into the same
`Episode` (episode.py); a convention (conventions.py) projects it to (state, action)
at a control rate; convert.py streams the result into a LeRobotDataset that both
π/openpi and GR00T consume. Sim-real co-training data goes through identical code by
construction; a new source costs one reader, a new label costs one pure function.

    episode.py       the canonical Episode + the sim reader

    conventions.py   label conventions (projections)

    filters.py       opt-in tick filters (idle removal)

    convert.py       the bake CLI


## Bake

    .venv-lerobot/bin/python vla/convert/convert.py \

        <…/data_gen/<gen_name>> --repo-id cosigen/bulb_franka_osc \

        [--control_space joint_vel] [--control_freq 15]  (default space: joint_target) [--batches …] [--cams front wrist] \

        [--root <out>] [--task "…"] [--include-failures] \

        [--workers auto] [--max-video-file-seconds 800]


Views come from each episode's `render_<view>.json` (`--cams` narrows); successful
episodes only by default; the dataset lands at `<gen_root>/datasets/<repo_id>` —
datasets stay with the campaign that produced them. Videos are decoded sequentially,
an episode never sits in RAM.

**Parallelism.** A bake costs ~2 min/episode (decode → PNG staging → h264 encode).
`--workers N` (or `auto` = `SLURM_CPUS_PER_TASK` / `os.cpu_count()`) splits the episodes
across N worker processes, each baking a temporary shard (`<root>.shards/wNN`), then
merges them with lerobot's `aggregate_datasets` into `--root`, applies the video-duration
cap (caveat 7) to the merged packing, verifies it, and deletes the shards. One command,
one dataset, whether you have 1 CPU or 48: `sbatch -c 32 … convert.py … --workers auto`.
Sequential mode (`--workers 1`, the default) uses lerobot's async image writer.
Multi-node scale-out = run the sharded bake per node and merge the same way
(`hpc/bulb_ik/merge_shards.py` is the template).

## The two decisions

Everything else is derived; a bake is fully specified by:

**`--control_freq`** — the label control frequency. Omitted = the native control rate (one tick

per latch; precisely, the video fps — equal to the solver rate for matched-regime

renders). A lower rate must divide the fps exactly and be an integer (60 → 30, 20,

15, 12, 10).



**`--control_space`** — what the action column means (default: `joint_target`). State is
always the same (`[arm q, gripper]` at the tick whose image the policy sees):

| convention  | action at tick t                       | semantics |
|-------------|----------------------------------------|-----------|
| `joint_pos` | achieved `q` at t+1/rate + gripper     | absolute tracking target; GR00T / LeRobot school; the sim-real workhorse — any joint PD executes it |
| `joint_vel` | `(q_next − q)·rate` + gripper          | π₀.₅-DROID exactly (15 Hz). NOT the measured `joint_vel`: the finite difference — "the average velocity that reaches the next pose", the form a tracker integrates |
| `joint_target` | the COMMANDED joint targets in force at t + commanded gripper closedness (UNCLAMPED: >1 = squeeze) | THE DEFAULT — controller intent: presses/squeezes survive as sustained target offsets that achieved labels flatten. Position-mode campaigns only (joint/diff_ik/pink_ik; the recorder omits the channel under a torque-mode arm, and this bake then refuses loudly — use joint_pos/joint_vel/raw_cmd for osc campaigns) |

| `raw_cmd`   | the recorded controller command, verbatim | LIBERO/MimicGen school; the sim-only matched-controller benchmark arm — deploy through the SAME controller |

At a fixed rate these are the same information (v = Δq·rate), so conventions are
dialects, not different data. Whatever the convention, sim bakes also carry the
verbatim command as a `raw_command` column: contact intent (a press = a sustained
offset that achieved kinematics hide) survives every projection, and later
relabelings (e.g. commanded joint targets via IK) never need the raw files again.

**Gripper** is one scalar CLOSEDNESS in [0, 1] (0 = fully open, 1 = fully closed),
normalized by each finger joint's travel (`episode.FINGER_TRAVEL`). It is achieved,
not commanded — squeeze force lives only in `raw_command`.

## Dataset schema

Keys are the superset-friendly ones: `observation.images.<view>` (video, native
render resolution — training transforms resize), `observation.state`,
`action`, `raw_command` (sim only), `task` (the scene's Goal sentence, `--task`
overrides). This satisfies the strict consumer natively and the flexible one
trivially:

- **GR00T** hardcodes these key names and needs `meta/modality.json` (written by the
  bake: named parts as start/end slices of the concatenated vectors, video key map).
- **π/openpi** is key-agnostic: each fine-tune declares a ~10-line repack transform
  mapping any keys to the model's inputs. Its other artifact, `norm_stats.json`,
  is generated by openpi's `compute_norm_stats` at training setup — derived, not
  authored; the dataset needs nothing extra.

The bake also writes `meta/bake.json` — THE provenance stamp: convention, rate,
part maps, gripper convention, the recorded control law, source episodes + git
shas. The stamp is the single source of truth an eval bridge reads to build the
matching executor (`raw_cmd` → the same OSC env.step; `joint_pos`/`joint_vel` → one
joint-PD tracking wrapper at the stamped rate), so train/eval convention drift is
structurally impossible.

## Video encoding

Dataset videos are written by lerobot's encoder; the bake exposes its knobs and picks
defaults for *training data that many frameworks will read*, which differ from lerobot's
own storage default (`libsvtav1`, `crf 30`, `g=2`):

| flag | default | why |
|---|---|---|
| `--vcodec` | `h264` | decodes everywhere (torchcodec, pyav, decord, every NVDEC generation); AV1 needs dav1d / Ampere+ |
| `--crf` | `23` | x264's standard quality point (18 ≈ visually lossless, ~35 % more bytes) |
| `--gop-seconds` | `0.25` | keyframe interval in **seconds** (`g = round(fps·s)`, min 1): worst-case seek cost is constant across control rates — g=15 at 60 Hz, g=4 at 15 Hz |
| `--pix-fmt` | `yuv420p` | the universally decodable layout |

Measured (torchcodec, 1 thread, 640×480 @ 60 fps, one 175 s episode, front camera):

| encode | size | random-access decode | sequential decode |
|---|---|---|---|
| lerobot default `libsvtav1 crf30 g=2` | ~90 MB | 330 fps | 850 fps |
| `h264 crf23 g=2` | 75 MB | 355 fps | 1020 fps |
| **`h264 crf23 g=15` (this default)** | **17 MB** | 264 fps | 2200 fps |
| `h264 crf18` long GOP (render masters) | 11 MB | 47 fps | 1790 fps |

Random access is governed by the GOP, not the codec: the render masters' long GOP is what
makes them slow to sample, and lerobot's g=2 buys the last 20 % of seek speed with 4–5× the
bytes. Policies read short clips (a few observation frames + an action chunk), where the
GOP-15 h264 is the fastest of all. The chosen encoder is stamped into `meta/bake.json`
(`video_encoder`) and lerobot's own `meta/info.json`. Pass `--vcodec libsvtav1 --gop-seconds 0.034`
to reproduce lerobot's default exactly.

Decoder note: in a conda env torchcodec needs the env's FFmpeg on the loader path
(`export LD_LIBRARY_PATH=$CONDA_PREFIX/lib:$LD_LIBRARY_PATH`) or lerobot silently falls back
to pyav — same frames, lower throughput.

## The control law travels with the data

`raw_cmd` numbers only mean anything under the controller that interpreted them
(pos/rot scale, re-anchoring, kp/kd, gripper drive stiffness). Generation stamps
that law as a `controller` block in each episode's `meta.json` (since 2026-08-18);
the bake copies it into `bake.json` and REFUSES pools whose blocks differ —
mixed presets or sim+real teleop must be separate bakes, staying partitionable.
Earlier batches lack the block (`controller: null`); recovering their law means
reading the batch's own solve.py, because solves override preset defaults live
(the bulb campaign sets rot_scale 0.15 over the preset's 0.097 — the exact

silent drift stamping exists to catch; kp 150/600, pos_scale 0.02 and gripper
drive stiffness 8000 came from setup writes too).

## Extending

- **New gripper**: one `FINGER_TRAVEL` entry (joint name → travel). Unknown finger
  joints are a hard error — a guessed travel silently corrupts every gripper label.
  Fingers are found by name marker ("finger"/"gripper"); an oddly named vendor
  joint means switching that lookup to an explicit per-robot registry entry.
- **New arm**: free — joints, dims and names flow from the render contract.
- **New source** (real robot): one reader returning `Episode`; nothing downstream
  changes.
- **New convention**: one pure function `Episode → Projected` in conventions.py
  (dexterous hands would enter here: per-finger parts instead of the closedness
  scalar — the named-parts machinery already supports it).

## Caveats

1. **Contact flattening**: during a press, achieved q barely moves — `joint_pos`
   says "stay", `joint_vel` says ~0, while the intent is *push*. `raw_command` is
   the recovery path; a joint-convention policy stalling exactly at contact phases
   is this. Same for gripper squeeze force.
2. **Idle/settle phases** are kept by default. `--filter-idle` (opt-in) drops the
   DEAD ticks only: robot static AND every object static (pose delta + recorded
   velocities ~0) AND no command intent. The intent guard (|EE offset| >= 0.1)
   keeps static-but-pushing press ticks; active settling has nonzero velocities
   and is kept; the first tick of each idle run stays as the arrive-and-settle
   cue. ~25% of the bulb episode is dead ticks. The classic BC freeze failure
   mode is the reason to turn it on; survivorship of presses is why it's safe.
3. The **last tick's action is "stay"** by construction (clamped lookahead).
4. **Norm stats**: near-constant dims explode after quantile normalization (openpi
   warns about this) — inspect `norm_stats.json` before the first training run.
5. **GR00T container version**: our lerobot writes the v3 layout; GR00T docs
   describe v2. Verify (or down-convert) before the first GR00T run.
6. **Success-only** by default — survivor bias, correct for BC
   (`--include-failures` exists).
7. **Video file duration vs LeRobot's timestamp check.** LeRobot stores frame
   timestamps as float32 and verifies each decoded frame within `tolerance_s=1e-4`.
   Past 1024 s into a video file the float32 step is 1.2e-4 s > the tolerance, so
   two roundings of the same instant fail the check and training dies mid-run
   (`FrameTimestampError`, ~50 min in; a short smoke never draws such a frame).
   LeRobot only caps files by MB (default 200 MB ≈ 30 min at 15 fps / 640×480 h264),
   so `--max-video-file-seconds` (default 800) measures the bitrate on the first
   episode, derives the MB cap from it, and an ffprobe pass fails the bake if any
   file still exceeds 1000 s. The merge step (`aggregate_datasets`) repacks and
   must be given the same MB cap (see the hpc merge script). Consumers should still
   pass `--tolerance_s=0.005` (13× finer than the 66.7 ms frame period) as a belt.