dddraxxx/retryscribe-v5

RetryScribe V5

Video-to-step-sequence training corpus for the RetryScribe student model, plus the already-prepared training store so a second machine can start training without re-running the data pipeline.

What is in it

• 17,592 episodes
  • 10,111 single-arm, source droid_v30
  • 7,481 dual-arm, source robocoin
• 70,368 training pairs — every episode rendered in four variants: json, json_timed, prose, prose_timed (17,592 each).
• Training clips: 17,592 mp4, all at 4 fps, 21 GB total.
• Stage 2 annotation schema r15 (retryscribe-vlm-arm-interaction-r15)
• Stage 3 rewrite prompt r5 (retryscribe-stage3-rewrite-r5)
• Stage 4 render r1 (retryscribe-stage4-render-r1)
• Student model this store was budgeted for: Qwen/Qwen3.5-4B revision 851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a, context 65,536.

The prepared store holds 17,782 samples over 17,590 episodes, not 17,592: two RoboCOIN episodes (robocoin-Split_aloha_pour_tea-234, robocoin-Split_aloha_pour_tea-251) exceeded the 65,536-token budget and were dropped. See store/overbudget.json. Train episodes get one variant each (train-one-dev-all policy); dev episodes get all four.

Layout

pairs/
  pairs.jsonl.gz              70,368 pairs, gzip (raw 275,140,318 B)
  stage4_config.json          Stage 4 render config
store/                        prepared training store - skips prepare_v3_student_training
  samples.sqlite.gz           17,782 samples, gzip (raw 80,396,288 B)
  dataset_summary.json
  split_manifest.jsonl
  overbudget.json
  model_revision.json
manifests/                    plain JSON, uncompressed
  stage4_v5_selection.json
  stage2_v5_r1_selection.json
  stage2_v5_r2_selection.json
  stage2_v5_r1_annotate_config.json
  stage2_v5_r2_annotate_config.json
  stage2_v5_r2_preparation.json
  stage3_v5_config.json
  v5_train_clips_4fps.json    per-clip render report
annotations/
  interactions.tar.gz         17,592 json  -> interactions/
  records.tar.gz              18,367 json  -> records/
  rewrites.tar.gz             17,592 json  -> rewrites/
clips/
  v5_train_clips_4fps.part-00.tar .. part-07.tar
                              8 plain tars (mp4 is already compressed),
                              17,592 members total, ~2.6 GiB each,
                              entries are bare filenames

Two corpora in this repo

The files at the top level are V5: 17,592 episodes. V5L is a separate, larger corpus of 40,784 episodes and lives entirely under the v5l/ prefix, with its own README at v5l/README.md. v5l_backfill/ holds the index and script used to rebuild V5L clip layouts and is V5L provenance, not a third corpus. The download above excludes both, because pulling the whole repo is 157 GiB when V5 alone is 20.9 GiB.

Clip paths are RELATIVE, not absolute

Both pairs.jsonl and samples.sqlite store clip locations as repo-relative paths, not /mnt/localssd/... absolute paths. Verified over every row: 0 of 70,368 pair rows and 0 of 17,782 sqlite rows contain an absolute path.

• In pairs.jsonl the path field is clip, e.g. build/v5_train_clips_4fps/droid_v30-10007.mp4. It is the only field that holds a path. (Other fields: episode_id, variant, prompt, answer, view_line, panels, clip_fps, clip_frames, clip_size, video_tokens, duration_s, arms, source.)
• In samples.sqlite, table samples, the path column is likewise clip, same build/v5_train_clips_4fps/<episode_id>.mp4 form. (Other columns: id, episode, variant, split, arms, source, view_line, prompt, target, frames, fps, width, height, duration_s, prompt_tokens, full_tokens.)

So no path rewriting is needed as long as you extract the clips to <repo>/build/v5_train_clips_4fps/ and launch training with the repo root as the working directory. If you put the clips somewhere else, rewrite the clip field in pairs.jsonl and the clip column in samples.sqlite to match — see the snippet at the end.

Restore

1. Download

hf download dddraxxx/retryscribe-v5 --repo-type dataset --local-dir ./retryscribe-v5 \
  --exclude 'v5l/*' 'v5l_backfill/*'
cd ./retryscribe-v5

2. Extract, into a MotionCaptioner checkout

$REPO = your MotionCaptioner checkout, $RUN = the run dir you want to create, e.g. $REPO/build/retryscribe_training/qwen35_v5_r1.

REPO=/path/to/MotionCaptioner
RUN=$REPO/build/retryscribe_training/qwen35_v5_r1

# clips -> build/v5_train_clips_4fps/   (17,592 mp4, all 8 shards into ONE dir)
mkdir -p "$REPO/build/v5_train_clips_4fps"
for t in clips/v5_train_clips_4fps.part-*.tar; do
  tar -C "$REPO/build/v5_train_clips_4fps" -xf "$t"
done

# pairs -> build/stage4_v5/
mkdir -p "$REPO/build/stage4_v5"
gunzip -c pairs/pairs.jsonl.gz > "$REPO/build/stage4_v5/pairs.jsonl"
cp pairs/stage4_config.json "$REPO/build/stage4_v5/config.json"

# prepared store -> the RUN ROOT (this is what lets you skip preparation).
# train_student.py reads root/samples.sqlite, root/dataset_summary.json and
# root/model_revision.json, where root == --run-dir. NOT root/data/.
mkdir -p "$RUN"
gunzip -c store/samples.sqlite.gz > "$RUN/samples.sqlite"
cp store/dataset_summary.json store/split_manifest.jsonl store/overbudget.json "$RUN/"
cp store/model_revision.json "$RUN/model_revision.json"

# annotations -> build/v5_pool/ and build/stage3_v5/
mkdir -p "$REPO/build/v5_pool" "$REPO/build/stage3_v5"
tar -C "$REPO/build/v5_pool"   -xzf annotations/interactions.tar.gz   # -> interactions/
tar -C "$REPO/build/v5_pool"   -xzf annotations/records.tar.gz        # -> records/
tar -C "$REPO/build/stage3_v5" -xzf annotations/rewrites.tar.gz       # -> rewrites/

# manifests -> build/
cp manifests/stage4_v5_selection.json    "$REPO/build/stage4_v5_selection.json"
cp manifests/v5_train_clips_4fps.json    "$REPO/build/v5_train_clips_4fps.json"
mkdir -p "$REPO/build/stage2_v5_r1" "$REPO/build/stage2_v5_r2"
cp manifests/stage2_v5_r1_selection.json       "$REPO/build/stage2_v5_r1/selection.json"
cp manifests/stage2_v5_r2_selection.json       "$REPO/build/stage2_v5_r2/selection.json"
cp manifests/stage2_v5_r1_annotate_config.json "$REPO/build/stage2_v5_r1/annotate_config.json"
cp manifests/stage2_v5_r2_annotate_config.json "$REPO/build/stage2_v5_r2/annotate_config.json"
cp manifests/stage2_v5_r2_preparation.json     "$REPO/build/stage2_v5_r2/preparation_082359.json"
cp manifests/stage3_v5_config.json             "$REPO/build/stage3_v5/config.json"

3. Verify before training

ls "$REPO/build/v5_train_clips_4fps" | wc -l          # 17592
wc -l < "$REPO/build/stage4_v5/pairs.jsonl"           # 70368
sqlite3 "$RUN/samples.sqlite" 'select count(*) from samples'        # 17782
# every clip referenced by the store actually exists:
cd "$REPO" && sqlite3 "$RUN/samples.sqlite" 'select distinct clip from samples' \
  | while read p; do [ -f "$p" ] || echo "MISSING $p"; done

4. Train

With samples.sqlite, dataset_summary.json, split_manifest.jsonl and overbudget.json in place in the run root, preparation (prepare_v3_student_training) is skipped and you can go straight to:

cd "$REPO"
./scripts/launch_retryscribe_student.sh \
  --run-dir build/retryscribe_training/qwen35_v5_r1 \
  --data-version v3 \
  --mode lora \
  --model data/models/Qwen3.5-4B \
  --epochs 3

The launcher lives in scripts/, cds to the repo root itself, and runs torchrun --nproc_per_node=${NPROC_PER_NODE:-8}. Set NPROC_PER_NODE if you have fewer than 8 GPUs.

Three things will stop a fresh machine before the first step:

1. build/secrets/wandb.env must exist. The launcher runs under set -euo pipefail and does source build/secrets/wandb.env on line 5, so a missing file aborts immediately. Create it (it just needs to export your WANDB_API_KEY), or call the module directly and skip wandb:

   build/venvs/qwen35-train/bin/torchrun --standalone --nproc_per_node=8 \
     -m retryscribe.scripts.train_student --run-dir ... --data-version v3 \
     --mode lora --model data/models/Qwen3.5-4B --epochs 3 --no-wandb
   

2. --model must match model_revision.json. train_student.py compares the resolved --model path against local_dir in model_revision.json and raises if they differ. This store pins data/models/Qwen3.5-4B. Put the model there, or edit local_dir in $RUN/model_revision.json to your path.
3. --data-version v3 is required. The default is v2, which selects a different dataset class and will not read this store correctly.

store/model_revision.json records the exact revision this store was token-budgeted against (851bf6e8...). A different tokenizer changes the token counts in samples.sqlite, so re-prepare if you swap the student.

If you extract clips somewhere else

NEW=/abs/path/to/clips   # dir holding the 17,592 mp4
python3 - <<PY
import json, sqlite3, os
NEW="$NEW".rstrip("/")
old="build/v5_train_clips_4fps"
src="$REPO/build/stage4_v5/pairs.jsonl"
with open(src) as f, open(src+".tmp","w") as o:
    for line in f:
        d=json.loads(line)
        d["clip"]=os.path.join(NEW, os.path.basename(d["clip"]))
        o.write(json.dumps(d)+"\n")
os.replace(src+".tmp", src)
con=sqlite3.connect("$RUN/samples.sqlite")
con.execute("update samples set clip = ? || '/' || replace(clip, ? || '/', '')", (NEW, old))
con.commit(); con.close()
PY