TRI-ML/s1-progact270k-s2-qwen35-4b-full-ep3-11416-v2

Rollout export — s1-progact270k_s2-qwen35-4b-full-ep3-11416-v2

1499 robot rollout episodes from a hierarchical policy evaluated in simulated RoboCasa kitchens. A System2 planner watches the video of the step just executed and issues the next natural-language subgoal; a System1 policy executes that subgoal as low-level actions and predicts how far through it it is. Each episode here is one video plus one JSON describing what was being attempted, frame by frame.

Layout

index.json                                   # all 1499 episodes with their outcomes
<Task>__target__episode_NNNNNN/
├── episode.mp4                              # the whole episode as one video
└── episode.json                             # what was attempted, per frame span

Size and shape

episodes	1499 across 50 tasks (692 succeeded, 46.2%)
total	1.15 GB, 2999 files
episode.mp4	median 656 KB, max 3.4 MB
episode.json	median 19 KB, max 80 KB
index.json	552 KB
frames per episode	median 1000, max 4591 (1.71 M frames total)
duration per episode	median 50 s, max 230 s (23.8 h total)
segments per episode	median 13, max 42 (19926 total)

episode.mp4

• 384×128, 20 fps, H.264. Playable in any normal player.
• Each frame is one control step of the policy — the video is not time-resampled, so frame index = control step index. This is what makes the frame spans in the JSON exact.
• Each frame is three camera views tiled left-to-right, each 128×128: left-shoulder | right-shoulder | wrist.
• Built by concatenating the eval's per-turn segment videos with an ffmpeg stream copy (no re-encode), so frames are bit-identical to what the policy actually saw.

episode.json

{
  "episode_id": "WaffleReheat/target/episode_000019",
  "task_name": "WaffleReheat",
  "instruction": "Open the microwave, place the bowl with waffle inside the microwave, ...",
  "episode_success": false,
  "video": {"path": "episode.mp4", "n_frames": 1641, "fps": 20.0, "width": 384, "height": 128},
  "n_segments": 20,
  "segments": [ /* one per subgoal attempt, in order */ ]
}

field	meaning
episode_id	<task>/target/episode_<N> — identifies the source scene and initial state
task_name	RoboCasa composite task, e.g. WaffleReheat
instruction	the natural-language goal for the whole episode
episode_success	the simulator's verdict, not the planner's opinion. true only if the environment's own success check passed
video.n_frames	frames in episode.mp4; also the number of control steps executed
n_segments	number of subgoal attempts, i.e. len(segments)

A segment is one subgoal attempt:

{
  "frame_start": 1311,
  "frame_end": 1383,
  "n_frames": 73,
  "subgoal": "retract the arm from the microwave door",
  "progress_start": 0.0,
  "progress_end": 1.0,
  "turn": 15,
  "progress_per_frame": [0.0, 0.0068, 0.0247, "..."]
}

field	meaning
frame_start, frame_end	the span of episode.mp4 this subgoal was executed over. frame_end is inclusive, so slice with frames[frame_start : frame_end + 1]
n_frames	frame_end - frame_start + 1; the number of control steps spent on this subgoal
subgoal	the natural-language instruction System1 was driven with over this span. Usually System2's; occasionally replaced by a hand-written task rule (e.g. when the planner repeated itself too many times)
progress_start, progress_end	System1's predicted progress through this subgoal at the first and last frame of the span. 0.0 = just started, 1.0 = believes it is done. It is per-subgoal, not per-episode — it resets each segment
turn	index of the planner turn this came from
progress_per_frame	one predicted progress value per frame of the span, so it plots directly against the video. Emitted fresh every 16 steps and held in between, hence the visible staircase

Segments are contiguous and gap-free: segment i's frame_end + 1 is segment i+1's frame_start, and together they cover every frame of the video.

index.json lists every episode with task_name, episode_success, termination, n_frames, n_segments and relative paths to its two files. termination says how the episode ended:

value	count	meaning
env_success	692	the simulator's success check passed — these are the successes
max_turns	576	ran out of planner turns without succeeding
task_finish	226	System2 declared the task finished but the simulator disagreed — a false positive
no_subgoal	5	the planner emitted no usable subgoal

Reading it

Any mp4 player works for the video. To pull the frames of one subgoal in Python (pip install imageio-ffmpeg numpy):

import json, numpy as np, imageio_ffmpeg as iio

meta = json.load(open("WaffleReheat__target__episode_000019/episode.json"))
reader = iio.read_frames("WaffleReheat__target__episode_000019/episode.mp4")
info = next(reader)                                    # {'size': (384, 128), 'fps': 20.0, ...}
w, h = info["size"]
frames = [np.frombuffer(f, np.uint8).reshape(h, w, 3) for f in reader]

seg = meta["segments"][15]
clip = frames[seg["frame_start"] : seg["frame_end"] + 1]   # frame_end is INCLUSIVE
print(seg["subgoal"], len(clip), seg["progress_per_frame"][:5])

left, right, wrist = clip[0][:, 0:128], clip[0][:, 128:256], clip[0][:, 256:384]

Edge cases worth knowing

• A trailing null in progress_per_frame is expected on the frame where the simulator reported success: the rollout loop stops on that step before a prediction is made.
• Episodes can be very short. NavigateKitchen__target__episode_000024 succeeded on its first control step, so it is a single frame with a single segment.
• One episode of the original 1500 (PackIdenticalLunches__target__episode_000002) is absent: that eval run aborted before executing anything, so there was nothing to export.
• episode_success: false with termination: "task_finish" (226 episodes) is the interesting failure mode — the planner believed it was done and was wrong.