YunzeLiu/roborag-dreamzero-fixed-video-warmup

RoboRAG fixed video warm-up references for DreamZero

This dataset contains the three fixed DROID reference trajectories used in the retained DreamZero fixed-reference experiments, plus a small server-side Method-V injection adapter. It does not include a DreamZero checkpoint, robot policy weights, simulator, or robot driver. Load the DreamZero checkpoint you are authorized to use in your own checkout.

The three references are synchronized 4-s, 15-FPS, three-view DROID clips:

Task id	Robot instruction	DROID episode / reference window
banana_to_bowl	Put the banana in the bowl.	droid:061652, frames 222--281
block_to_bowl	Put the small block in the bowl.	droid:042177, frames 54--113
soup_to_bowl	Put the tomato soup can in the bowl.	droid:072196, frames 171--230

Each task directory has human-viewable MP4s (three_view.mp4 and one MP4 for each camera) and the exact frames_60x3_180x320_uint8.npz payload used by the injection code. The NPZ has view0, view1, and view2 in this order: exterior_1_left, exterior_2_left, wrist_left.

What warm-up means

This is not imitation replay and does not alter the real robot's state. For each rollout, continue using the original DreamZero perception and control loop. At exactly control step 48 (3.2 s at 15 Hz), send eight sampled frames from one synchronized reference video to the released DreamZero infer API, using the same session_id, prompt, and context_query_id as the live episode. Discard all eight returned actions. The reference forwards enter DreamZero's normal Method-V frame/KV history. The immediately following live calls can use this recent context, but the released local cache is a bounded ring: subsequent live observations normally overwrite/evict the reference history. This package deliberately does not extend the cache window, suppress its native reset/eviction behaviour, or make the reference persist to the end of the rollout. No later re-injection is performed.

The payload is strictly video-only:

• injected: 8 synchronized three-camera RGB observations (indices [7, 15, 23, 31, 39, 47, 55, 59]) from a 60-frame / 4-s clip;
• not injected: retrieved robot action, proprioception, state, reward, or success information;
• reference proprioception is zero only as a transport placeholder and is not copied into the live robot state;
• reference inference actions are discarded;
• Python, NumPy, and Torch RNG streams are restored after injection, so the warm-up arm and no-warmup arm use the same live-policy stochastic stream.

The reference is injected once during the rollout. Its influence is limited to the released model's ordinary finite Method-V local-history horizon; it does not retroactively affect steps 0--47 and it does not run again later in the episode. Do not describe this setting as an episode-long persistent cache.

Real-robot example: Banana -> Bowl

The following is the intended real-robot integration. It assumes that your existing DreamZero server already builds its normal live observation dict and loads its own checkpoint. Do not replace its controller, safety limits, camera calibration, or action post-processing.

huggingface-cli download YunzeLiu/roborag-dreamzero-fixed-video-warmup \
  --repo-type dataset --local-dir roborag-warmup

export PYTHONPATH="$PWD/roborag-warmup/src:${PYTHONPATH}"
export ROBORAG_REFERENCE_ROOT="$PWD/roborag-warmup/references"
export ROBORAG_TASK_ID=banana_to_bowl
export ROBORAG_WARMUP_STEP=48

In the policy server used by the physical robot, create one FixedVideoWarmup object per episode and call it immediately before the normal live infer call. The complete adapter is in examples/dreamzero_server_adapter.py. The essential integration is:

from method_v_video_only import FixedVideoWarmup

# At episode reset (one object per episode):
warmup = FixedVideoWarmup(
    reference_root=os.environ["ROBORAG_REFERENCE_ROOT"],
    task_id="banana_to_bowl",
    warmup_step=48,
)

# In the existing per-control-step policy hook, before normal live inference:
receipt = warmup.maybe_inject(
    control_step=control_step,              # 0, 1, ... at 15 Hz
    prompt="Put the banana in the bowl.",  # unchanged live prompt
    session_id=session_id,                  # same live episode/session
    query_id=context_query_id,              # same live query identity
    upstream_infer=parent_policy_infer,     # bypass this hook; avoids recursion
    clear_predicted_video=clear_video_cache,
)
action = parent_policy_infer(live_observation)  # original DreamZero call

parent_policy_infer must be the released/base DreamZero inference method, not the warm-up override, otherwise it recursively triggers injection. The injected observations must use the same three image keys expected by your DreamZero release. The included adapter uses the DSC/DreamZero wire names: observation/exterior_image_0_left, observation/exterior_image_1_left, and observation/wrist_image_left.

Before moving a physical arm, validate with a dry-run or the robot's normal safe mode that (1) the live camera ordering matches the checkpoint, (2) the reference feed does not send returned reference actions to the robot, (3) the receipt reports reference_requests=8, and (4) the first live action after step 48 still passes your standard safety/action-limit checks.

Paired no-warmup vs warmup evaluation

Run exactly the same task, seeds, robot initialization/calibration, checkpoint, and safety/controller settings in both conditions. The only treatment change is the one Method-V injection at step 48. The wrapper below launches a user-provided existing DreamZero evaluation command twice and exports the condition/reference environment variables.

python roborag-warmup/run_paired_compare.py \
  --task-id banana_to_bowl \
  --command 'python /path/to/your_dreamzero_real_robot_eval.py \
    --checkpoint /path/to/your/checkpoint \
    --task banana_to_bowl --seed 1000 \
    --condition {condition} --warmup-adapter {warmup_adapter}'

For no_warmup, do not instantiate/call FixedVideoWarmup. For fixed_reference_warmup, install the adapter in the policy server and record the returned receipt per rollout. Keep the released bounded local-cache lifecycle unchanged in both arms. The launcher cannot patch an arbitrary third-party DreamZero checkout automatically; it makes the paired condition and artifact locations explicit while you retain ownership of checkpoint loading and robot execution.

Files

src/method_v_video_only.py              # injection implementation
examples/dreamzero_server_adapter.py    # integration template
run_paired_compare.py                   # paired-command launcher
references/<task>/three_view.mp4         # inspection video
references/<task>/exterior_*.mp4         # individual synchronized views
references/<task>/frames_*.npz           # exact injection payload
references_manifest.json                 # task/window/camera metadata

Scope and safety

These clips are task-specific experimental context, not a certified robot policy. They were selected from DROID and are not a substitute for workspace calibration, collision checking, force limits, emergency stop, or operator supervision. Do not use them to bypass the original DreamZero deployment and safety procedures.