jisue/robosyn-pi05-analysis

RoboSynChallenge — π0.5 work in progress

Snapshot taken 2026-09-13, ~04:20 UTC, from a VESSL RTX 3090 workspace that was about to be recycled. Everything here was produced in one session on 2026-09-12.

Deadline: 2026-10-11 AoE. Preliminary evaluation runs in simulation; the final round runs on physical robots.

---

Why this repo exists

/root on the VESSL box hit its XFS project quota and became unwritable (df still reports 96 GB free — it lies, the quota is what binds). /workspace is wiped every 24 h. So HuggingFace is the only durable place left.

---

What is in here

File	Contents
code_20260913.tar.gz	The 8 source files changed or added, plus .bak originals
full.diff	git diff against RoboSynChallenge @ cccbbc9
changes.txt	diffstat summary
results_20260913.tar.gz	Attention measurements: 17-seed sweep, per-layer curves, patch coverage
trajectories_20260913.tar.gz	Scripted-expert trajectories: actions, joint states, metadata
expert_dumps.tar.gz	Full dumps incl. camera frames (8 tasks × 2-3 seeds)
seed_sweep.tar.gz	Full dumps incl. frames and segmentation masks (table_rearrangement × 20 seeds)
memory/	Session notes written during the work
ROBOSYN_SETUP.md	Environment rebuild instructions

---

State of the work

Done

• π0.5 base weights downloaded (12.4 GB, 29 files, from gs://openpi-assets/checkpoints/pi05_base)
• policy/pi05 environment installed and working (jax + openpi + torch)
• Four bugs fixed in the pi05 evaluation adapter — evaluation could not have run without these
• Attention-capture tooling built and validated end to end
• Scripted-expert trajectories dumped for 8 of 10 tasks
• 17-seed randomized measurement of language→object grounding

Not done

• No π0.5 checkpoint has ever been trained or run. No dataset picked yet.
• Batch-size sweep (to find the largest batch that fits on a 3090)
• sample_loading segfaults during env construction; water_pouring's scripted expert fails to produce a plan on seeds 0-2

---

The four adapter bugs (all fixed, see full.diff)

policy/pi05/pi_model.py was rewritten against the working policy/pi0/pi_model.py:

1. __init__ took no pytorch_device, but deploy_policy.py:92 passes one → TypeError
2. No self.pytorch_device attribute, read at deploy_policy.py:112,117 → AttributeError
3. create_trained_policy(..., robotwin_repo_id=...) — that keyword does not exist in openpi (zero hits across src/openpi) → TypeError
4. The observation dict used the wrong keys entirely. It built {"state", "images": {...}}, but EmbodiChainInputs (libero_policy.py:125-127) reads observation/image, observation/left_wrist_image, observation/right_wrist_image, observation/state → KeyError

Also in policy/pi05/pyproject.toml, two override-dependencies entries were needed before uv sync would resolve at all:

• dexsim-engine==0.4.3 (openpi pins 0.4.1; EmbodiChain 0.2.4 requires 0.4.3)
• pymeshlab==2023.12.post3 (newest ships only manylinux_2_35 wheels; this host is glibc 2.31)

---

Two traps that cost hours

Physics must run on CPU. Passing --device cuda to the gym env turns on GPU physics (enable_gpu_sim), and the scripted expert then dies during action-graph edge generation with no traceback and exit code 0. The official default is cpu; launch/run_task.sh never passes --device. GPU is for rendering and policy inference only.

env.close() terminates the process. EmbodiChain tears the simulator down with os._exit(0) (EMBODICHAIN_SIM_EXIT_PROCESS=1 by default), which skips tracebacks, stdout flushing, finally bodies and atexit. Write every result to disk before calling it, and never put it in a finally that could swallow an exception.

Diagnostic tip: both processes print their full "EngineConfig" JSON at startup. Diffing that block between a working and a failing run is what isolated the CPU/GPU issue.

---

Main measurement result

Base π0.5 already grounds instruction words to the right objects, and randomization does not break it.

Method: run only the prefix half of π0.5 (SigLIP + Gemma) on one frame, capture the attention from a word token onto the 768 image patches, and score it against the simulator's own instance-segmentation masks. The score is enrichment — how many times more attention an object receives than its share of the frame would give it by chance, so 1.0× means no better than random.

Task table_rearrangement, instruction "Pick the fork and the spoon, place them next to the plate.", cam_high, reset frame, 17 randomized seeds:

word	median	worst seed	best seed	seeds at/near chance
fork	39.6×	30.4×	60.3×	0 / 17
spoon	73.5×	13.1×	124.6×	0 / 17
plate	11.8×	9.6×	14.4×	0 / 17

Object identity was verified by cropping each mask out of the RGB frame and looking at it, not by trusting the model — id 97 is visibly a fork (four tines), 99 a spoon, 95 the plate. Ids are stable across all 17 seeds.

Every word concentrates on its own object: at its peak layer "fork" puts 39.7× on the fork and only 5.0× on the spoon, and "spoon" mirrors that. Fork and spoon look alike and are still told apart.

Grounding peaks at Gemma layer 5 of 18, not in the middle and not at the end. It is absent at layers 0-1, climbs steeply, peaks around 5, holds an uneven plateau, and collapses to below chance over the last three layers. Layers 0 and 17 are attention sinks — 7-8 of each word's top-10 patches are shared with every other word there.

What this rules out

The original plan was to fine-tune the vision encoder so the model would attend to the target object and the end-effector. That intervention has no headroom: the model already attends 13-125× on target, on every randomized draw tested. There is nothing to push.

What it does not rule out

1. Does the action expert use this? The grounding lives in the vision-language half. The action expert reads the prefix's KV cache at matched depth — its layer 5 sees prefix layer 5, so the signal is architecturally available (there is no skip straight to the output; it flows through the action expert's own remaining layers). Whether it is actually used is unmeasured and needs a trained checkpoint.
2. Does fine-tuning destroy it? The numbers above are the pre-training baseline. Re-running the same measurement after LoRA answers this directly.
3. Do other tasks behave the same? Only table_rearrangement was measured.

---

Competition facts worth keeping

Overall Score = 0.75 × Success Rate
              + 0.20 × Action Efficiency      = (1 − steps used / H) × 100
              + 0.05 × Inference Efficiency   = max(0, 1 − time / T) × 100

Failed episodes are charged the task's maximum step count, so their Action Efficiency is zero and both averages include them. π0.5 is a 3B VLM and will likely score near zero on Inference Efficiency against the ACT baseline — acceptable at 5 % weight, but Action Efficiency at 20 % is not, and it tracks success rate closely.

• Task-specific checkpoints are allowed: one repo, one HF checkpoint listed per task.
• Evaluation input is RGB only — no depth, no intrinsics, no point clouds. Depth and masks may be used to generate training data, which is what makes any mask-supervised objective legal.
• The official run uses private hold-out parameters, different seed and config values. Do not overfit the public ones.

Task grouping from the official baseline table

Splitting the ten tasks by spread across pi0 / π0.5 / Motus:

Model-limited (spread ≥ 5/20, best ≥ 10/20) — worth working on: table_rearrangement, click_bell, items_handover, handle_basket, drawer_open_place

Ceiling-limited (spread ≤ 2/20, best ≤ 4/20) — every model fails, don't spend time here: mixer_operating, manipulate_pipette, sample_loading, item_assembly (0/20 for all six entries)

π0.5 has visible headroom on click_bell (10 vs Motus 13) and items_handover (7 vs 10).

---

Action / observation space (measured)

14 dimensions: 0-5 left arm joints, 6 left gripper, 7-12 right arm joints, 13 right gripper. Confirmed independently by make_bool_mask(6, -1, 6, -1) in the delta-action config, which excludes exactly 6 and 13.

• Arm joints: actions are absolute target angles, and tracking error averages 0.0003-0.0035 rad. Treat a predicted action as the next joint angle.
• Grippers: the action is in 0-0.05 while the observed state is in 0-1 — a 20× unit mismatch on the same semantic dimension. Not a bug (the delta transform leaves gripper dims absolute), but any new code assuming "action ≈ next state" breaks here.

table_rearrangement seed 0: expert plan 200 steps, success fires at step 153 — before the planned gripper release at 170. Placing the objects is enough; letting go is not required. Worth remembering, since Action Efficiency rewards finishing early.

---

Verified LoRA settings (teammate, same RTX 3090)

setting	value
num_train_steps	20,000
batch_size	4
method	LoRA
fsdp_devices	1
wall clock	~8 hours

openpi's own README puts LoRA fine-tuning at >22.5 GB with an RTX 4090 as the example card, so 24 GB is enough. (RoboSynChallenge's docs say >46 GB / A6000 for LoRA; that contradicts upstream and upstream is right.)

The repo ships no π0.5 LoRA config — pi05_base_robosynchallenge_full is full fine-tuning at batch size 64. One has to be added, modelled on pi0_libero_low_mem_finetune (config.py:757). A draft is in ROBOSYN_SETUP.md.

Before training: wandb_enabled defaults to True and will block waiting for a login — set WANDB_MODE=offline. save_interval defaults to 10,000, which is too coarse for a 24 h workspace; 2,000 is safer.

---

Next steps

1. Batch-size sweep. Measure peak GPU memory for a real train step at batch 4/8/16/32 using synthetic batches — no dataset needed, since memory barely depends on content. Doubling the batch is worth hours inside a 24 h window.
2. Pick a dataset and train one checkpoint. This is now the blocking item: two of the three open questions need a trained model, and π0.5 has never been run.
3. Re-measure grounding after training with scripts/attention_probe.py and compare against the table above.
4. Measure action-expert attention — same capture, query the suffix tokens instead of the language tokens.

Rebuilding the environment

See ROBOSYN_SETUP.md. Short version: recreate /workspace, clone RoboSynChallenge, unpack code_20260913.tar.gz over it, uv sync inside policy/pi05, and re-download the base weights with the curl loop in that document (~12.4 GB, 29 files, no auth needed).

---

Update — 2026-09-13

The released π0.5 checkpoint still has its language head, and it works

openpi's pi0.py never calls decode, so the hierarchical half of π0.5 — the part that writes the next subtask as text before generating actions — looked absent. It is not absent. The head is in the weights, tied to the input embeddings (gemma.py Embedder.decode), and greedy decoding through it produces coherent text.

scripts/language_probe.py runs the prefix on a real observation and decodes from the language head. On table_rearrangement seed 0, base weights, no fine-tuning:

prompt	output
Task: … State: …;\nAction: (what evaluation sends)	໑訐♼Ꮸ𓋼牐㈬ⓙ… — noise
What objects are on the table?	"The table has a fork and a spoon on it."
Task: … What should the robot do first?	"Subtask: pick up fork"

Token confidences on the third: Sub(0.86) task(1.00) :(1.00) ▁(1.00) pick(0.91) ▁up(1.00) ▁fork(0.89) <eos>(0.99).

The word "Subtask" was never in the prompt, and the model emits that exact format at near-certainty — it is reproducing a format it was trained on. The content is right too: the scripted expert also starts with fork_grasp.

The first prompt failing is expected rather than discouraging: after Action: the post-trained model emits actions, not text, so the language head has no target at that position. Change the prompt shape and the language comes back.

This reopens the hierarchical route. The parts are all present — decoding now works (language_probe.py), and the pipeline already feeds a per-frame task string (prompt_from_task=True, and datasets.py passes task into every frame, just with the same value each time). What is untested is whether LoRA fine-tuning on RoboSynChallenge data — which carries one instruction per episode and no subtask labels — preserves this. Both baselines are now recorded, so re-running the probe after training answers it.

Batch size sweep (RTX 3090, LoRA)

Real openpi train steps on synthetic batches; no data loader, so these are pure compute.

batch	peak memory	s/step	20k steps	samples/s
4	18.3 GB	1.394	7.7 h	2.87
8	19.6 GB	2.471	13.7 h	3.24
16	19.6 GB	4.555	25.3 h	3.51

bs4's 7.7 h matches the teammate's measured ~8 h, which validates the probe.

Scaling is near-linear because the GPU is already saturated at batch 4: one sample is three 224×224 images through a 400M vision tower plus 968 tokens through 18 layers of 2B, and the step sustains ~72 TFLOPS against the 3090's ~71 TFLOPS bf16 peak. Larger batches buy +22 % throughput at most. Memory is not the constraint — bs8 and bs16 both peak at 19.6 GB because XLA rematerializes rather than storing activations.

Use batch 4 for 20k steps. It fits a 24 h workspace with room to spare; bs16 × 20k would need 25.3 h. bs16 × 5k sees the same number of samples 18 % faster but gives a quarter of the optimizer updates.

An earlier run of this probe reported a false OOM at batch 4. The cause was skipping the bf16 cast that init_train_state applies to frozen parameters (train.py), which costs about 5.9 GB. scripts/batch_size_probe.py now calls the real initializer.

Also note

/root on the VESSL box hit its XFS project quota mid-session and became completely unwritable — df reported 96 GB free and 33k inodes free while every write failed with ENOSPC. Only ~19k files under /root are ours, so the quota is not something we filled. Plan for /root being read-only.

---

Update — 2026-09-13, later

A teammate's checkpoint arrived: yai-robosync/pi05-lora-click-bell, LoRA 15,000 step on RoboSynChallenge/cobotmagic_Sim_click_bell, 50.0 % success over 100 episodes (ACT 37 %, DP 51 %). Their robosync_fixes.patch was applied wholesale rather than hand-porting fixes — it repairs the same four adapter bugs found independently here, plus two more (truncated.any() on a plain bool, and env.close() in the finally).

Evaluation runs here

The pipeline works on this box. 10 episodes gave 4/10, a later 8-episode run 5/8 — both consistent with the teammate's 50 % at this sample size. Two environment notes: XLA_PYTHON_CLIENT_PREALLOCATE=false is needed or the run OOMs partway through, and ffmpeg comes free from openpi's bundled imageio_ffmpeg binary — symlink it onto PATH, no install required. The DexSim Vulkan init segfaults intermittently; retrying works.

Grounding after fine-tuning

Same 17 seeds, same frames, same metric as the pre-training baseline:

word	before	after	worst seed before → after
fork	39.6×	28.6×	30.4 → 8.6
spoon	73.5×	10.9×	13.1 → 3.7
plate	11.8×	12.2×	9.6 → 11.0

Not uniform. The plate holds; the spoon drops to a seventh. Plate covers 5.2 % of the frame, spoon 0.2 % — the small objects are what gets lost, though that reading needs more tasks to confirm. No seed fell to chance in either model.

Language after fine-tuning

The base checkpoint emits a subtask from the bare instruction, with no format hint: "Pick the fork and the spoon…" → "Subtask: pick up fork", Sub at p=1.00. Five different prompt shapes all produced the same string, so the behaviour is not prompt-sensitive. On "Click the bell" the base instead answers "Yes" at p=0.30 — it does not force a subtask onto a task that has only one step.

After fine-tuning the format hardens and the content breaks: "Click the bell" now yields "Subtask: pick up the blue bottle" at p=1.00, on the very task it was trained on. Free-form captioning degrades too ("the large blue plate", "a small blue cup" — neither is in the scene). The training loss covers actions only, so nothing held the language head in place while the backbone moved under it.

Stuck detection works; prompting the policy out of it does not

Failed rollouts re-press the same spot. Measuring ‖arm(state_t) − arm(state_t−1)‖ across inferences separates cleanly, using only an input the policy already receives:

	median arm movement
successful episodes	0.522
failed episodes, later half	0.025

At a 0.08 threshold the two successful episodes had zero readings below it, and one failure sat below for 26 consecutive inferences — 260 of its 361 steps. Detection costs one vector subtraction; no extra model, no extra inference.

Acting on the detection by swapping the language instruction, however, changed nothing. Three conditions, eight episodes each, same seeds: baseline, a recovery instruction ("Lift the arm up and move away from the table.") and a state notice that keeps the original goal ("The robot is stuck. Click the bell."). All three scored 5/8, with the same episodes succeeding and failing, and the first two matched step-for-step.

In the one episode captured in detail, the swap fired at step 90 of 361. Mean arm movement was 0.316 before it and 0.071 across the 270 steps after — the arm kept tapping the same spot. The detector itself was exact: it fired on all three episodes that failed and none of the five that succeeded.

The likely reason is in the training data: all 74,000 frames of cobotmagic_Sim_click_bell carry the same single sentence, so the policy has no reason to read language at all.

Recovery is better approached through data than through language: generate failure-then-recover trajectories in sim, where create_demo_action_list can re-plan from a deliberately displaced pose.

The base model still reads the instruction; the fine-tune does not

To separate "π0.5 never listens" from "the fine-tune stopped listening", the same instruction swap was run on the unmodified π0.5 checkpoint (pi05_base), on click_bell, three seeds, two instructions:

• "Click the bell"
• "Lift both arms straight up and hold them there."

The base model scores 0/3 either way — expected, since it was never trained on this robot — but the trajectories differ:

seed	mean per-step arm difference	max
398764591	0.089	0.48
924231285	0.125	0.48
441365315	0.095	1.20

The fine-tuned checkpoint, given the same pair of instructions, produced bit-identical trajectories — difference exactly 0.0000 on every step of every seed.

So the language pathway is intact in the released weights and is severed by the fine-tune. Training on 74,000 frames that all carry one sentence appears to collapse the policy onto ignoring the text input entirely. This is the same conclusion the language probe reached from the other side (the fine-tuned model answering "Click the bell" with "Subtask: pick up the blue bottle" at p = 1.00), now measured in actions rather than tokens.

Missing control: the base model was not run twice with the same instruction, so simulator nondeterminism is not yet ruled out as a contributor to the difference. The fine-tuned model's exact 0.0000 suggests the rollout is deterministic, but that was measured on a different checkpoint.

Videos: videos/base_orig.mp4 and videos/base_alt.mp4 (seed 398764591, episode 1).

Correction: the base-vs-fine-tune instruction result does not hold

The section above claimed the base checkpoint follows instructions because two instructions produced different trajectories. The missing control was run, and it kills the result. Base model, click_bell, three seeds, same instruction twice:

seed	different instruction	same instruction, rerun
398764591	0.089	0.109
924231285	0.125	0.104
441365315	0.095	0.080

Rerunning with the same instruction moves the trajectory as much as changing the instruction did. The 0.089 was run-to-run noise, not language sensitivity.

Two further corrections to earlier claims in this file:

• The three swap conditions did not all score 5/8. Baseline and condition A scored 5/8; condition B scored 3/8 (stuck_noticeB.log: ep1, 4, 6, 7, 8 failed). A rerun of condition B with the identical prompt and identical seeds scored 5/8. The 5/8 reported for B came from that rerun.
• "The fine-tuned model produced bit-identical trajectories" had no data behind it. Those runs (stuck_base.log, stuck_liftA.log) carried no per-inference movement logging at all; what matched was the pattern of successes and the step counts.

Evaluations do not repeat, and the cause is in the environment

Same checkpoint, same seeds, same instruction, different process → different outcome. The cause was isolated by elimination:

test	result
policy, fixed observation, 3 calls in one process	bit-identical
policy, fixed observation, two processes	differs (sum 151.17056 vs 151.23981)
policy, fixed observation, two processes, XLA_FLAGS=--xla_gpu_autotune_level=0	bit-identical
full evaluation, two processes, autotune disabled	still differs (mean 0.08–0.15)
environment only, fixed action sequence, two processes	differs at reset, before any action

So XLA autotuning does make the model non-reproducible across processes, and disabling it fixes the model — but it is not what makes evaluations diverge. The observation already differs immediately after env.reset(seed=...), with no policy in the loop. Domain randomization drawing from an RNG outside the episode seed is the leading suspect; this is not yet confirmed.

scripts/determinism_probe.py (model) and scripts/env_determinism_probe.py (environment) reproduce both halves.

Consequence for every comparison in this file: eight-episode A/B runs cannot separate a real effect from this noise. The swap experiment, the grounding-versus-SR comparison and the base experiment all sit inside it. Future comparisons need the run-to-run spread measured first, and episode counts set against it.

One arm is parked

Splitting the movement metric by arm (it was a single norm over all 12 joints) shows the base model on click_bell holds the left arm completely still and moves only the right:

[move] 0.3109  L 0.0002  R 0.3109
[move] 1.3546  L 0.0002  R 1.3546

The left arm sits at 0.0002 for the whole episode. A combined norm hides this.

Subtask labels are recoverable, but not from the released data

The released datasets carry no subtask column — cobotmagic_Sim_table_rearrangement has observation.state/qvel/qf, action, three camera videos and index columns, with one sentence for all 200,000 frames. The simulator's own expert generators do name their phases (stack_blocks_two.py: approach_block2, pick_block2, lift_block2, … with a segments list giving each phase's frame count), but those names are dropped on export. Two ways to recover them: regenerate the data in sim, or segment the existing trajectories at the gripper open/close transitions (dims 6 and 13).

Separately, openpi cannot train the subtask generator as released: pi0.py:214 returns only the flow-matching MSE, with no token loss, so the language head receives no gradient during fine-tuning. That is why the fine-tuned checkpoint answers "Click the bell" with "Subtask: pick up the blue bottle".

Batch sizes, from the teammate's own probe

Their measurements line up with the ones here (4 → 1.6 s/it, 8 → 2.9, 12 → 3.6 with the data loader included). More useful is their training curve: 15,000 steps is the optimum, and 20,000 is worse — 50 % versus 35 %, with shorter successful episodes too (213 versus 255 steps). The 20k figure in the config is not the target to aim for.