single-pass per-frame temporal-distance readout

app.py

@@ -1,17 +1,18 @@
 """RynnValue-4B — robot-manipulation value model demo.
 
 Given a manipulation video and the task instruction, RynnValue predicts the
-*temporal distance* (remaining seconds until the task is done) for a sequence of
-video prefixes, plus a short natural-language analysis (description / does the
-video match the instruction / did it succeed).
-
-The inference path mirrors the authors' reference script
-(`rynn_infer/inference.py` in github.com/alibaba-damo-academy/RynnValue):
-prefix-uniform sampling — for each evaluated step `i` the prefix `frames[0:i+1]`
-is resampled to `num_frames` with `np.linspace` and the value of the *last*
-prediction slot is read out, so every score only conditions on frames seen so
-far — followed by one `generate()` pass on the full-video prefix for the
-Analysis block, and the same side-by-side "video + trend plot" rendering.
+*temporal distance* (remaining seconds until the task is done) for every
+sampled frame, the signed time delta between consecutive frames, and a short
+natural-language analysis (description / does the video match the instruction /
+did it succeed).
+
+Inference follows the model card's `process_episode` protocol: the video is
+uniformly resampled to `num_frames` frames, the episode prompt interleaves each
+frame with its `<value>` / `<relative_value>` query group, and one forward pass
+yields one remaining-time prediction per frame (the LM is causal, so the value
+at frame *i* only conditions on frames 0..i). A second `generate()` pass on the
+same prompt produces the Analysis block. Rendering reproduces the authors'
+`rynn_infer/plot_utils.py` layout: the clip next to a synchronized value trend.
 """
 
 import os
@@ -65,13 +66,11 @@ EOS_TOKEN_ID = tokenizer.convert_tokens_to_ids("<|im_end|>")
 
 DEFAULT_ROBOT = "a Franka single-arm robot"
 DEFAULT_CAMERA = "the main camera"
-DEFAULT_NUM_FRAMES = 32
-DEFAULT_NUM_STEPS = 24
+DEFAULT_NUM_FRAMES = 48
 DEFAULT_MAX_IMAGE_SIDE = 384
 DEFAULT_MAX_NEW_TOKENS = 128
-BATCH_SIZE = 2
 
-MAX_DECODE_FRAMES = 900  # hard cap on decoded frames (memory guard)
+MAX_FRAMES = 450  # decoded/rendered frame cap (memory + render-time guard)
 RENDER_MAX_SIDE = 640  # frames are downscaled to this for the rendered video
 
 ROBOT_CHOICES = [
@@ -100,11 +99,11 @@ CAMERA_CHOICES = [
 
 
 def load_video_frames(video_path):
-    """Decode a video to RGB PIL frames, capped at MAX_DECODE_FRAMES.
+    """Decode a video to RGB PIL frames, capped at MAX_FRAMES.
 
     Returns (frames, effective_fps). Long videos are decoded with a stride so
-    memory stays bounded; the effective fps is scaled to match, which keeps the
-    wall-clock timeline (and therefore the seconds axis) correct.
+    memory and render time stay bounded; the effective fps is scaled to match,
+    which keeps the wall-clock timeline (and the seconds axis) correct.
     """
     if not video_path or not os.path.isfile(video_path):
         raise gr.Error("Please provide a video file.")
@@ -118,8 +117,8 @@ def load_video_frames(video_path):
     estimated = int(duration * fps) if duration and np.isfinite(duration) else None
 
     stride = 1
-    if estimated and estimated > MAX_DECODE_FRAMES:
-        stride = int(np.ceil(estimated / MAX_DECODE_FRAMES))
+    if estimated and estimated > MAX_FRAMES:
+        stride = int(np.ceil(estimated / MAX_FRAMES))
 
     frames = []
     try:
@@ -132,7 +131,7 @@ def load_video_frames(video_path):
                 s = RENDER_MAX_SIDE / max(w, h)
                 img = img.resize((max(1, round(w * s)), max(1, round(h * s))), Image.BICUBIC)
             frames.append(img)
-            if len(frames) >= MAX_DECODE_FRAMES:
+            if len(frames) >= MAX_FRAMES:
                 break
     finally:
         reader.close()
@@ -154,16 +153,6 @@ def resize_frames(frames, max_side):
     return [f.resize(new_size, resample=Image.BICUBIC) for f in frames]
 
 
-def sample_frame_indices(total, num_frames):
-    """Uniformly pick ``num_frames`` indices out of ``total`` frames."""
-    if num_frames <= 0 or num_frames >= total:
-        return list(range(total))
-    if num_frames == 1:
-        return [total - 1]
-    step = (total - 1) / (num_frames - 1)
-    return [int(round(j * step)) for j in range(num_frames)]
-
-
 # ---------------------------------------------------------------------------
 # Analysis parsing (same regexes as the reference script)
 # ---------------------------------------------------------------------------
@@ -197,12 +186,12 @@ def _format_time(seconds):
     return f"{minutes:02d}:{secs:02d}.{millis:03d}"
 
 
-def _render_trend_frames(values, sampled_indices, fps, size, title, task_title):
+def _render_trend_frames(values, sampled_indices, fps, size, task_title):
     """Render one plot image per prediction step.
 
-    The plot only changes at the sampled indices, so we render
-    ``len(values)`` images (a couple of dozen) and reuse them across the video
-    instead of re-rendering a figure for every frame.
+    The plot only changes at the sampled indices, so we render ``len(values)``
+    images and reuse them across the video instead of re-rendering a figure for
+    every video frame.
     """
     w, h = size
     dpi = 100
@@ -210,12 +199,13 @@ def _render_trend_frames(values, sampled_indices, fps, size, title, task_title):
 
     x = np.asarray(sampled_indices, dtype=float)
     y = np.asarray(values, dtype=float)
-    remaining = (x[-1] - x) / float(fps)
+    actual = (x[-1] - x) / float(fps)
 
-    (line,) = ax1.plot([], [], color="tab:blue", linewidth=2.0, label="predicted value")
-    pt1 = ax1.scatter([x[0]], [y[0]], color="red", s=30, zorder=3, label="current value")
+    ax1.plot(x, y, color="tab:blue", linewidth=1.0, alpha=0.25)
+    (line,) = ax1.plot([], [], color="tab:blue", linewidth=2.0, label="predicted remaining")
+    pt1 = ax1.scatter([x[0]], [y[0]], color="red", s=32, zorder=3, label="current prediction")
     ax1.set_xlabel("Frame", fontsize=9)
-    ax1.set_ylabel("Value", color="tab:blue", fontsize=9)
+    ax1.set_ylabel("Predicted value (s)", color="tab:blue", fontsize=9)
     ax1.tick_params(axis="x", labelsize=8)
     ax1.tick_params(axis="y", labelcolor="tab:blue", labelsize=8)
     ax1.grid(True, alpha=0.3)
@@ -229,13 +219,11 @@ def _render_trend_frames(values, sampled_indices, fps, size, title, task_title):
     ax1.set_ylim(y_min - margin, y_max + margin)
 
     ax2 = ax1.twinx()
-    ax2.plot(x, remaining, color="green", linestyle="--", linewidth=2.0, label="remaining time")
-    pt2 = ax2.scatter(
-        [x[0]], [remaining[0]], color="green", s=25, zorder=3, label="current remaining"
-    )
-    ax2.set_ylabel("Remaining Time (s)", color="green", fontsize=9)
+    ax2.plot(x, actual, color="green", linestyle="--", linewidth=2.0, label="actual remaining")
+    pt2 = ax2.scatter([x[0]], [actual[0]], color="green", s=26, zorder=3)
+    ax2.set_ylabel("Actual remaining (s)", color="green", fontsize=9)
     ax2.tick_params(axis="y", labelcolor="green", labelsize=8)
-    rt_min, rt_max = float(np.min(remaining)), float(np.max(remaining))
+    rt_min, rt_max = float(np.min(actual)), float(np.max(actual))
     if rt_min == rt_max:
         rt_min -= 1.0
         rt_max += 1.0
@@ -243,7 +231,7 @@ def _render_trend_frames(values, sampled_indices, fps, size, title, task_title):
     ax2.set_ylim(rt_min - rt_margin, rt_max + rt_margin)
 
     short_task = task_title if len(task_title) <= 42 else task_title[:39] + "..."
-    ax1.set_title(f"{short_task}\n{title}", fontsize=10)
+    ax1.set_title(f"{short_task}\nTemporal distance to completion", fontsize=10)
 
     lines1, labels1 = ax1.get_legend_handles_labels()
     lines2, labels2 = ax2.get_legend_handles_labels()
@@ -253,10 +241,9 @@ def _render_trend_frames(values, sampled_indices, fps, size, title, task_title):
     for i in range(len(y)):
         line.set_data(x[: i + 1], y[: i + 1])
         pt1.set_offsets(np.array([[x[i], y[i]]]))
-        pt2.set_offsets(np.array([[x[i], remaining[i]]]))
+        pt2.set_offsets(np.array([[x[i], actual[i]]]))
         fig.canvas.draw()
-        buf = np.asarray(fig.canvas.buffer_rgba())[:, :, :3].copy()
-        images.append(Image.fromarray(buf))
+        images.append(np.asarray(fig.canvas.buffer_rgba())[:, :, :3].copy())
     plt.close(fig)
     return images
 
@@ -271,13 +258,13 @@ def _overlay_font(size):
 def _draw_overlay_text(img, lines, font):
     img = img.copy()
     draw = ImageDraw.Draw(img)
-    x, y = 8, 8
+    x, y = 8, 6
     for line in lines:
         draw.text(
             (x, y), line, fill=(255, 235, 59), font=font, stroke_width=2, stroke_fill=(0, 0, 0)
         )
         bbox = draw.textbbox((x, y), line, font=font)
-        y += (bbox[3] - bbox[1]) + 8
+        y += (bbox[3] - bbox[1]) + 9
     return img
 
 
@@ -293,27 +280,23 @@ def save_video_with_trend(frames, values, sampled_indices, fps, output_path, tas
         base_w, base_h = int(round(base_w * scale)), 260
         frames = [f.resize((base_w, base_h)) for f in frames]
 
-    plot_w = int(min(520, max(300, base_w * 0.75)))
+    plot_w = int(min(560, max(320, base_w * 0.8)))
     plot_h = max(260, base_h)
 
-    plots = _render_trend_frames(
-        values,
-        sampled_indices,
-        fps,
-        (plot_w, plot_h),
-        "Remaining Time (s)",
-        task_title,
-    )
-    if plots[0].height != base_h:
-        plots = [p.resize((plot_w, base_h)) for p in plots]
+    plots = _render_trend_frames(values, sampled_indices, fps, (plot_w, plot_h), task_title)
+    if plots[0].shape[0] != base_h:
+        plots = [
+            np.asarray(Image.fromarray(p).resize((plot_w, base_h))) for p in plots
+        ]
 
     idx_to_pos = {idx: pos for pos, idx in enumerate(sampled_indices)}
     n = len(frames)
-    remaining_all = (n - 1 - np.arange(n)) / float(fps)
+    actual_all = (n - 1 - np.arange(n)) / float(fps)
 
     font = _overlay_font(16)
     canvas_w = _ceil_to_multiple(base_w + plot_w, 16)
     canvas_h = _ceil_to_multiple(base_h, 16)
+    canvas = np.full((canvas_h, canvas_w, 3), 255, dtype=np.uint8)
 
     writer = imageio.get_writer(
         output_path,
@@ -321,10 +304,11 @@ def save_video_with_trend(frames, values, sampled_indices, fps, output_path, tas
         codec="libx264",
         quality=7,
         macro_block_size=None,
+        output_params=["-pix_fmt", "yuv420p"],
     )
     try:
         pos = 0
-        short_task = task_title if len(task_title) <= 48 else task_title[:45] + "..."
+        short_task = task_title if len(task_title) <= 44 else task_title[:41] + "..."
         for i, img in enumerate(frames):
             if i in idx_to_pos:
                 pos = idx_to_pos[i]
@@ -333,14 +317,13 @@ def save_video_with_trend(frames, values, sampled_indices, fps, output_path, tas
                 [
                     f"task: {short_task}",
                     f"predicted remaining: {values[pos]:.2f}s",
-                    f"actual remaining: {_format_time(remaining_all[i])}",
+                    f"actual remaining: {_format_time(actual_all[i])}",
                 ],
                 font,
             )
-            canvas = Image.new("RGB", (canvas_w, canvas_h), (255, 255, 255))
-            canvas.paste(left, (0, 0))
-            canvas.paste(plots[pos], (base_w, 0))
-            writer.append_data(np.asarray(canvas))
+            canvas[:base_h, :base_w] = np.asarray(left)
+            canvas[:base_h, base_w : base_w + plot_w] = plots[pos]
+            writer.append_data(canvas)
     finally:
         writer.close()
     return output_path
@@ -357,7 +340,6 @@ def _gpu_duration(
     robot_description=DEFAULT_ROBOT,
     camera_description=DEFAULT_CAMERA,
     num_frames=DEFAULT_NUM_FRAMES,
-    num_steps=DEFAULT_NUM_STEPS,
     max_image_side=DEFAULT_MAX_IMAGE_SIDE,
     max_new_tokens=DEFAULT_MAX_NEW_TOKENS,
     *args,
@@ -365,13 +347,14 @@ def _gpu_duration(
 ):
     try:
         nf = int(num_frames)
-        ns = int(num_steps)
         side = int(max_image_side)
     except (TypeError, ValueError):
-        nf, ns, side = DEFAULT_NUM_FRAMES, DEFAULT_NUM_STEPS, DEFAULT_MAX_IMAGE_SIDE
-    # base (load + render) + per prefix-forward cost, scaled by tokens per frame
-    work = ns * nf * (side / 384.0) ** 2
-    return int(min(300, 45 + 0.09 * work))
+        nf, side = DEFAULT_NUM_FRAMES, DEFAULT_MAX_IMAGE_SIDE
+    # Sequence length scales with frames x tokens-per-frame, and the eager
+    # value-isolation attention makes the forward grow ~quadratically in it.
+    # Calibrated against a measured 32-frame @384px run.
+    n = nf * (side / 384.0) ** 2
+    return int(min(240, 20 + 0.6 * n + 0.012 * n**2))
 
 
 @spaces.GPU(duration=_gpu_duration)
@@ -381,7 +364,6 @@ def analyze(
     robot_description=DEFAULT_ROBOT,
     camera_description=DEFAULT_CAMERA,
     num_frames=DEFAULT_NUM_FRAMES,
-    num_steps=DEFAULT_NUM_STEPS,
     max_image_side=DEFAULT_MAX_IMAGE_SIDE,
     max_new_tokens=DEFAULT_MAX_NEW_TOKENS,
     progress=gr.Progress(),
@@ -399,104 +381,52 @@ def analyze(
         robot_description = DEFAULT_ROBOT
 
     num_frames = int(num_frames)
-    num_steps = int(num_steps)
     max_image_side = int(max_image_side)
     max_new_tokens = int(max_new_tokens)
 
-    progress(0.02, desc="Decoding video...")
+    progress(0.03, desc="Decoding video...")
     frames, fps = load_video_frames(video)
     total = len(frames)
     model_images = resize_frames(frames, max_image_side)
 
-    eval_indices = sample_frame_indices(total, min(num_steps, total))
-
-    def build_prefix_sample(end_idx):
-        frame_idx = np.linspace(0, end_idx, num_frames, dtype=int)
-        prefix_images = [model_images[j] for j in frame_idx]
-        return processor.process_episode(
-            instruction=instruction,
-            images=prefix_images,
-            robot_description=robot_description,
-            camera_description=camera_description,
-        )
-
-    def run_batch(samples):
-        """One forward pass over a batch of prefixes -> last-slot value each."""
-        batch_kwargs = dict(
-            input_ids=torch.cat([s["input_ids"] for s in samples], dim=0).to("cuda").long(),
-            attention_mask=torch.cat([s["attention_mask"] for s in samples], dim=0)
-            .to("cuda")
-            .long(),
-            pixel_values=torch.cat([s["pixel_values"].flatten(0, 1) for s in samples], dim=0)
-            .to("cuda")
-            .to(torch.bfloat16),
-            image_grid_thw=torch.cat([s["image_grid_thw"].flatten(0, 1) for s in samples], dim=0)
-            .to("cuda")
-            .long(),
-        )
-        with torch.inference_mode():
-            outputs = model(**batch_kwargs)
-        pred = outputs.value.pred_value
-        if pred.dim() == 2 and pred.shape[0] == 1:
-            pred = pred.reshape(len(samples), -1)
-        if pred.dim() == 3:
-            pred = pred.mean(dim=0)
-        if pred.dim() == 2 and pred.shape[-1] > 1:
-            pred = pred[:, -1]
-        elif pred.dim() == 2:
-            pred = pred[:, 0]
-        return pred.float().reshape(-1).tolist()
-
-    pred_value = []
-    final_sample = None
-    batch = []
-    for step, end_idx in enumerate(eval_indices):
-        sample = build_prefix_sample(end_idx)
-        if end_idx == eval_indices[-1]:
-            final_sample = sample
-        batch.append(sample)
-        if len(batch) >= BATCH_SIZE or step == len(eval_indices) - 1:
-            pred_value.extend(run_batch(batch))
-            batch = []
-            progress(
-                0.05 + 0.75 * len(pred_value) / len(eval_indices),
-                desc=f"Value pass {len(pred_value)}/{len(eval_indices)}",
-            )
+    num_frames = max(2, min(num_frames, total))
+    sampled_indices = np.linspace(0, total - 1, num_frames, dtype=int).tolist()
 
-    # --- DEBUG: single-pass per-frame readout (model card "Programmatic Usage") ---
-    dbg_idx = np.linspace(0, total - 1, num_frames, dtype=int)
-    dbg_sample = processor.process_episode(
+    progress(0.18, desc="Building episode prompt...")
+    sample = processor.process_episode(
         instruction=instruction,
-        images=[model_images[j] for j in dbg_idx],
+        images=[model_images[j] for j in sampled_indices],
         robot_description=robot_description,
         camera_description=camera_description,
     )
+    input_ids = sample["input_ids"].to("cuda").long()
+    attention_mask = sample["attention_mask"].to("cuda").long()
+    pixel_values = sample["pixel_values"].flatten(0, 1).to("cuda")
+    image_grid_thw = sample["image_grid_thw"].flatten(0, 1).to("cuda").long()
+
+    progress(0.28, desc="Predicting temporal distance...")
     with torch.inference_mode():
-        dbg_out = model(
-            input_ids=dbg_sample["input_ids"].to("cuda").long(),
-            attention_mask=dbg_sample["attention_mask"].to("cuda").long(),
-            pixel_values=dbg_sample["pixel_values"].flatten(0, 1).to("cuda"),
-            image_grid_thw=dbg_sample["image_grid_thw"].flatten(0, 1).to("cuda").long(),
+        outputs = model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            pixel_values=pixel_values,
+            image_grid_thw=image_grid_thw,
         )
-    dbg_pred = dbg_out.value.pred_value.float().reshape(-1).tolist()
-    dbg_rel = dbg_out.relative.pred_value.float().reshape(-1).tolist()
-    debug_lines = [
-        "```",
-        "SINGLE-PASS values: " + ", ".join(f"{v:.2f}" for v in dbg_pred),
-        "SINGLE-PASS deltas: " + ", ".join(f"{v:.2f}" for v in dbg_rel),
-        "PREFIX last-slot  : " + ", ".join(f"{v:.2f}" for v in pred_value),
-        f"fps={fps:.2f} total={total}",
-        "```",
-    ]
-
-    progress(0.82, desc="Generating analysis...")
-    input_ids = final_sample["input_ids"].to("cuda").long()
+    # (num_value_heads, num_frames) -> one remaining-time prediction per frame
+    pred_value = outputs.value.pred_value.float()
+    if pred_value.dim() > 1:
+        pred_value = pred_value.reshape(-1, len(sampled_indices)).mean(dim=0)
+    pred_value = pred_value.reshape(-1).tolist()
+    # relative head: signed time delta between consecutive sampled frames
+    rel_value = outputs.relative.pred_value.float().reshape(-1).tolist()
+
+    progress(0.6, desc="Generating analysis...")
     with torch.inference_mode():
         gen_out = model.generate(
             input_ids=input_ids,
-            attention_mask=final_sample["attention_mask"].to("cuda").long(),
-            pixel_values=final_sample["pixel_values"].flatten(0, 1).to("cuda").to(torch.bfloat16),
-            image_grid_thw=final_sample["image_grid_thw"].flatten(0, 1).to("cuda").long(),
+            attention_mask=attention_mask,
+            pixel_values=pixel_values,
+            image_grid_thw=image_grid_thw,
             max_new_tokens=max_new_tokens,
             do_sample=False,
             num_beams=1,
@@ -508,32 +438,32 @@ def analyze(
     analysis = parse_analysis(analysis_text)
     gpu_seconds = time.time() - started
 
-    progress(0.88, desc="Rendering trend video...")
+    progress(0.85, desc="Rendering trend video...")
     out_path = os.path.join(tempfile.mkdtemp(), "rynnvalue_trend.mp4")
-    save_video_with_trend(frames, pred_value, eval_indices, fps, out_path, instruction)
+    save_video_with_trend(frames, pred_value, sampled_indices, fps, out_path, instruction)
 
     def _verdict(v):
         if v is None:
             return "—"
         return "✅ Yes" if v.lower() == "yes" else "❌ No"
 
+    clip_seconds = (total - 1) / fps
+    predicted_span = float(np.sum(rel_value)) if rel_value else float("nan")
     description = analysis["description"] or (analysis_text.strip() or "—")
     summary = "\n".join(
         [
-            f"**Task instruction** — {instruction}",
-            "",
             f"**Video description** — {description}",
             "",
             f"**Matches the instruction?** {_verdict(analysis['match'])} &nbsp;&nbsp;·&nbsp;&nbsp; "
             f"**Task completed?** {_verdict(analysis['success'])}",
             "",
-            f"**Predicted remaining time** — {pred_value[0]:.2f} s at the first frame → "
-            f"{pred_value[-1]:.2f} s at the last frame "
-            f"(video is {(total - 1) / fps:.1f} s long, {total} frames decoded).",
+            f"**Temporal distance** — {pred_value[0]:.2f} s remaining at the first sampled frame → "
+            f"{pred_value[-1]:.2f} s at the last. The clip itself is {clip_seconds:.1f} s long.",
             "",
-            "\n".join(debug_lines),
+            f"**Relative head** — the predicted time deltas between the {num_frames} sampled "
+            f"frames sum to {predicted_span:.1f} s (actual clip length {clip_seconds:.1f} s).",
             "",
-            f"<sub>{len(eval_indices)} prefix evaluations · {num_frames} frames per prefix · "
+            f"<sub>{num_frames} frames · longest side {max_image_side}px · "
             f"{gpu_seconds:.1f} s on GPU</sub>",
         ]
     )
@@ -549,21 +479,21 @@ DESCRIPTION = """
 
 # 🤖 RynnValue-4B — how much longer until the robot is done?
 
-[Model](https://huggingface.co/Alibaba-DAMO-Academy/RynnValue-4B) ·
-[Paper](https://arxiv.org/abs/2608.09853) ·
-[GitHub](https://github.com/alibaba-damo-academy/RynnValue) ·
-[Project page](https://alibaba-damo-academy.github.io/RynnValue.github.io/)
+<a href="https://huggingface.co/Alibaba-DAMO-Academy/RynnValue-4B">Model</a> ·
+<a href="https://arxiv.org/abs/2608.09853">Paper</a> ·
+<a href="https://github.com/alibaba-damo-academy/RynnValue">GitHub</a> ·
+<a href="https://alibaba-damo-academy.github.io/RynnValue.github.io/">Project page</a>
 
 </div>
 
-**RynnValue** is a value foundation model for robot manipulation, built on RynnBrain (Qwen3-VL).
-Given a manipulation video *and* a task instruction, it predicts the **temporal distance** —
-the remaining time in seconds until the task is complete — for a series of video prefixes, and
-generates a short analysis: what the video shows, whether it **matches** the instruction, and
-whether the task **succeeded**.
+**RynnValue** is a value foundation model for robot manipulation, built on RynnBrain (Qwen3-VL) and
+trained on 7,000+ hours of embodied data. Give it a manipulation video **and** the task instruction,
+and for every sampled frame it predicts the **temporal distance** — the remaining time in seconds
+until the task is complete — plus a short analysis: what the video shows, whether it **matches** the
+instruction, and whether the task **succeeded**.
 
-The output video plays the clip next to the predicted value curve (blue) alongside the actual
-remaining time of the clip (dashed green).
+The result video plays the clip beside the predicted value curve (blue), with the clip's actual
+remaining time (dashed green) for reference.
 """
 
 with gr.Blocks(title="RynnValue-4B") as demo:
@@ -571,7 +501,7 @@ with gr.Blocks(title="RynnValue-4B") as demo:
 
     with gr.Row():
         with gr.Column(scale=1):
-            video_in = gr.Video(label="Manipulation video", sources=["upload"], height=320)
+            video_in = gr.Video(label="Manipulation video", sources=["upload"], height=300)
             instruction = gr.Textbox(
                 label="Task instruction",
                 placeholder="Put the box in the drawer and close it",
@@ -592,23 +522,20 @@ with gr.Blocks(title="RynnValue-4B") as demo:
                     allow_custom_value=True,
                 )
         with gr.Column(scale=1):
-            video_out = gr.Video(label="Value trend", height=360, autoplay=True)
+            video_out = gr.Video(label="Value trend", height=340, autoplay=True)
             analysis_md = gr.Markdown(label="Analysis")
 
     with gr.Accordion("Advanced options", open=False):
         gr.Markdown(
-            "The model is queried once per curve point, on the prefix of the video seen so far "
-            "(the authors' `rynn_infer/inference.py` protocol). More curve points and more frames "
-            "per prefix mean a smoother, better-conditioned curve — and a longer run."
+            "The video is uniformly resampled to *N* frames; the model emits one remaining-time "
+            "prediction per frame, so **frames sampled** is also the resolution of the curve. "
+            "More frames / larger frames give a finer, better-grounded curve and a longer run."
         )
         num_frames = gr.Slider(
-            8, 64, value=DEFAULT_NUM_FRAMES, step=8, label="Frames per prefix (context length)"
-        )
-        num_steps = gr.Slider(
-            8, 48, value=DEFAULT_NUM_STEPS, step=4, label="Curve points (prefix evaluations)"
+            16, 64, value=DEFAULT_NUM_FRAMES, step=8, label="Frames sampled from the video"
         )
         max_image_side = gr.Slider(
-            256, 640, value=DEFAULT_MAX_IMAGE_SIDE, step=64, label="Max frame side fed to the model"
+            256, 512, value=DEFAULT_MAX_IMAGE_SIDE, step=64, label="Max frame side fed to the model"
         )
         max_new_tokens = gr.Slider(
             32, 256, value=DEFAULT_MAX_NEW_TOKENS, step=32, label="Analysis token budget"
@@ -620,7 +547,6 @@ with gr.Blocks(title="RynnValue-4B") as demo:
         robot_desc,
         camera_desc,
         num_frames,
-        num_steps,
         max_image_side,
         max_new_tokens,
     ]