Fix Tr006 V2 online Segment preprocessing

Pixel-based blue-screen detection without videoID mapping; non-blue bin-center sampling; 420x224 letterbox; absolute PTS metadata. CPU gate: 16/16 PASS, grid 40x14x26, selected blue frames 0.

pipelines/Tr006_V2/FARM04_PACKAGING_GUIDE.md

@@ -107,15 +107,17 @@ bash do_test_run.sh
 
 ## 6. 推理一致性门禁
 
-当前 `docker/segment-algorithm/inference.py` 是低分线上提交的事实快照，不是已经修正后的 V2 对齐实现。重新提交前，必须在公开样本上对比：
+当前 `docker/segment-algorithm/inference.py` 已包含 2026-09-02 的 V2 在线修复：
 
-1. V2 训练侧选择的 80 个绝对 source PTS。
-2. 420x224 letterbox 后的帧内容。
-3. 蓝屏区间是否被排除。
-4. `video_metadata.frames_indices`、`video_grid_thw` 和输入 token。
-5. 同一 checkpoint 在本地训练/评测链与 Docker Transformers 链中的最终答案。
+1. 从 clip 像素在线识别纯蓝信号丢失画面，不使用 `videoID` 或文件名映射。
+2. 在检测到的非蓝时间上选择 80 个 bin-center 帧。
+3. 使用与训练相同的 PIL bicubic 420x224 letterbox。
+4. 根据官方 clip PTS 与 `request.start_time` 生成绝对毫秒时间元数据。
 
-若这些项目不一致，本次构建只能用于复现旧提交，不能视为修复版。
+服务器侧 answer-free CPU 门禁结果：16/16 样本通过，选中蓝帧为 0，
+`video_grid_thw=[[40,14,26]]`，平均预处理 4.254 秒、最大 10.905 秒。
+仿官方视频不需要下载到 Farm04。Farm04 只需完成官方 `do_test_run.sh` 的
+容器/GPU/`answer.json` smoke，再执行 `do_save.sh`。
 
 ## 7. 保存官方 tar.gz
 

pipelines/Tr006_V2/README.md

@@ -124,7 +124,12 @@ bash do_test_run.sh
 bash do_save.sh
 ```
 
-不要使用当前线上版本的 `np.linspace` 推理预处理作为“已与 V2 对齐”的证据。必须先在公开样本上比较训练 V2 的采样 PTS、420x224 帧、processor 输入和 Docker 输入；`docker/segment-algorithm/inference.py` 是已提交版本的事实快照，保留它是为了复现和定位差异。
+`docker/segment-algorithm/inference.py` 已更新为 V2 在线推理实现：它不依赖
+`videoID` 映射，而是从官方 5fps clip 的像素识别纯蓝信号丢失画面，随后在
+非蓝时间上选择 80 个 bin-center 帧、做 420x224 letterbox，并生成原视频绝对
+毫秒时间元数据。2026-09-02 的 16 段 answer-free CPU 门禁为 16/16 PASS，
+`video_grid_thw=[[40,14,26]]`，最终选中蓝帧为 0。该门禁数据不需要传到
+Farm04；Farm04 直接拉取本目录文件覆盖官方目录即可。
 
 ## 本地评测边界
 

pipelines/Tr006_V2/docker/segment-algorithm/inference.py

@@ -79,10 +79,11 @@ with no answer is simply scored incorrect.
 
 Frame sampling
 --------------
-The clip is decoded with `decord <https://pypi.org/project/decord/>`_ using a single
-batched read of exactly 80 evenly spaced frame indices. The pixels come from the
-trimmed clip, while their timestamps are reconstructed on the original timeline
-from ``Request.start_time``. Decoding and processor work count towards latency.
+The clip is decoded with `decord <https://pypi.org/project/decord/>`_. Full-frame
+solid-blue signal-loss screens are detected from pixels, without relying on a
+video identifier. Exactly 80 bin-centre frames are then sampled over the remaining
+time and letterboxed to the Tr006 training resolution. Their timestamps are mapped
+back to the original timeline from ``Request.start_time``.
 
 Trying it out
 -------------
@@ -108,6 +109,7 @@ import torch
 # "random_device could not be read" or a segfault).
 import decord
 from focus import Request, Response, load_requests, save_items
+from PIL import Image, ImageOps
 from transformers import AutoProcessor, Qwen3_5ForConditionalGeneration
 
 logging.basicConfig(
@@ -124,6 +126,11 @@ MODEL_PATH = RESOURCES_PATH / "model"
 INPUT_PATH = Path("/input")
 OUTPUT_PATH = Path("/output")
 N_FRAMES = 80
+FRAME_WIDTH = 420
+FRAME_HEIGHT = 224
+BLUE_DETECT_CHUNK = 64
+BLUE_DETECT_STRIDE = 16
+BLUE_REFINE_ATTEMPTS = 2
 MAX_NEW_TOKENS = 64
 USE_OVERLAY = False  # The trained Tr006 V2 model used plain frames + metadata.
 VIDEO_DIR = INPUT_PATH / ("overlayed" if USE_OVERLAY else "plain")
@@ -212,13 +219,64 @@ def clip_path_for(req: Request) -> Path:
     return VIDEO_DIR / f"{req.qID}.mp4"
 
 
+def blue_screen_flags(frames: np.ndarray) -> np.ndarray:
+    """Classify full-frame solid-blue signal loss on a sparse pixel grid."""
+    sampled = frames[:, ::BLUE_DETECT_STRIDE, ::BLUE_DETECT_STRIDE]
+    pixels = sampled.reshape(len(sampled), -1, 3).astype(np.float32)
+    red, green, blue = pixels[:, :, 0], pixels[:, :, 1], pixels[:, :, 2]
+    blue_fraction = ((blue > 180) & (blue > 4 * (red + 1)) & (blue > 4 * (green + 1))).mean(1)
+    return (blue_fraction >= 0.98) & (pixels.std(1).mean(1) <= 15)
+
+
+def sample_non_blue_indices(blue: np.ndarray) -> np.ndarray:
+    valid = np.flatnonzero(~blue)
+    if not len(valid):
+        log.warning("Every decoded frame looks like a blue screen; using the full clip")
+        valid = np.arange(len(blue))
+    positions = (np.arange(N_FRAMES) + 0.5) * len(valid) / N_FRAMES
+    slots = np.floor(positions + 0.5 - 1e-9).astype(np.int64).clip(0, len(valid) - 1)
+    return valid[slots]
+
+
+def detect_blue_intervals(vr: decord.VideoReader) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Probe 80 time bins and expand blue probes to their represented intervals."""
+    probes = sample_non_blue_indices(np.zeros(len(vr), dtype=bool))
+    probe_frames = vr.get_batch(probes).asnumpy()
+    flags = blue_screen_flags(probe_frames)
+    if flags.all():
+        blue = np.zeros(len(vr), dtype=bool)
+        for begin in range(0, len(vr), BLUE_DETECT_CHUNK):
+            indices = np.arange(begin, min(begin + BLUE_DETECT_CHUNK, len(vr)))
+            blue[indices] = blue_screen_flags(vr.get_batch(indices).asnumpy())
+        return blue, probes, probe_frames
+    boundaries = np.concatenate((
+        [0], ((probes[:-1] + probes[1:]) // 2 + 1), [len(vr)]
+    ))
+    blue = np.zeros(len(vr), dtype=bool)
+    for index in np.flatnonzero(flags):
+        blue[boundaries[index]:boundaries[index + 1]] = True
+    return blue, probes, probe_frames
+
+
+def letterbox_frames(frames: np.ndarray) -> np.ndarray:
+    return np.stack([
+        np.asarray(ImageOps.pad(
+            Image.fromarray(frame),
+            (FRAME_WIDTH, FRAME_HEIGHT),
+            method=Image.Resampling.BICUBIC,
+            color=(0, 0, 0),
+            centering=(0.5, 0.5),
+        ))
+        for frame in frames
+    ])
+
+
 def your_preprocessing(video_path: Path, req: Request) -> tuple[np.ndarray, dict]:
     """Decode exactly ``N_FRAMES`` and attach original-timeline millisecond PTS.
 
-    Official clips are already trimmed and encoded at 5fps.  The local frame
-    indices are therefore sampled across the whole clip, while ``frames_indices``
-    are rebuilt from Request.start_time so Qwen's processor emits absolute
-    ``<... seconds>`` anchors, matching the Tr006 fixed80 training contract.
+    Official clips are already trimmed and encoded at 5fps. Blue signal-loss time
+    is detected online, then the same non-blue bin-centre and 420x224 letterbox
+    contracts used for Tr006 V2 are applied. ``frames_indices`` remain absolute.
     """
     log.debug("Decoding %s (size on disk: %d bytes)", video_path, video_path.stat().st_size)
 
@@ -227,24 +285,36 @@ def your_preprocessing(video_path: Path, req: Request) -> tuple[np.ndarray, dict
     n_frames = len(vr)
     if n_frames <= 0 or base_fps <= 0:
         raise RuntimeError(f"invalid video stream: n_frames={n_frames}, fps={base_fps}")
-    # np.linspace + round mirrors the fixed-frame preprocessing and supports
-    # short clips by repeating the nearest decoded frame.
-    indices = np.linspace(0, n_frames - 1, N_FRAMES).round().astype(np.int64)
-    log.debug("Video: %d frames @ %.3f fps; sampling %d across %.2f s", n_frames, base_fps, N_FRAMES, n_frames / base_fps)
-    frames = vr.get_batch(indices).asnumpy()  # (T, H, W, 3) uint8 RGB — one batched decode
+    blue, indices, frames = detect_blue_intervals(vr)
+    if blue.any():
+        for _ in range(BLUE_REFINE_ATTEMPTS + 1):
+            indices = sample_non_blue_indices(blue)
+            frames = vr.get_batch(indices).asnumpy()
+            selected_blue = blue_screen_flags(frames)
+            if not selected_blue.any() or blue.all():
+                break
+            radius = max(1, int(np.ceil(n_frames / (2 * N_FRAMES))))
+            for index in indices[selected_blue]:
+                blue[max(0, index - radius):min(n_frames, index + radius + 1)] = True
+    local_seconds = vr.get_frame_timestamp(indices)[:, 0]
+    frames = letterbox_frames(frames)
+    log.debug(
+        "Video: %d frames @ %.3f fps; excluded %d blue frames; selected %d non-blue bin centres",
+        n_frames, base_fps, int(blue.sum()), len(indices),
+    )
     del vr
 
     # Qwen3's processor averages timestamps per temporal patch (2 frames), so
     # metadata must have one entry per decoded frame and use the absolute source
     # timeline.  The request endpoint is in seconds; the training manifest used
     # the same millisecond grid and ``precomputed_absolute_pts`` backend.
-    absolute_ms = np.rint((float(req.start_time) + indices / base_fps) * 1000.0).astype(np.int64)
+    absolute_ms = np.rint((float(req.start_time) + local_seconds) * 1000.0).astype(np.int64)
     metadata = {
         "fps": 1000,
         "frames_indices": absolute_ms.tolist(),
         "total_num_frames": int(absolute_ms.max()) + 1,
-        "width": int(frames.shape[2]),
-        "height": int(frames.shape[1]),
+        "width": FRAME_WIDTH,
+        "height": FRAME_HEIGHT,
         "duration": (int(absolute_ms.max()) + 1) / 1000.0,
         "video_backend": "precomputed_absolute_pts",
     }

pipelines/Tr006_V2/docker/segment-algorithm/requirements.txt

@@ -13,6 +13,7 @@ orena-focus>=0.3.4
 # of orena-focus, but anything imported directly is declared explicitly.
 decord>=0.6.0
 numpy>=1.26.0
+Pillow>=11.0.0
 
 # Qwen3.5 support (including Qwen3_5ForConditionalGeneration and the
 # timestamp-aware Qwen3VLProcessor) landed after the 4.x line.  The merged

pipelines/Tr006_V2/manifest/pipeline_manifest.json

@@ -52,6 +52,26 @@
     "lora_rank": 64,
     "lora_alpha": 128
   },
+  "online_inference_preprocessing": {
+    "version": "v2_online_blue_pixel_bin_center_letterbox_20260902",
+    "video_id_mapping_required": false,
+    "blue_detection": "sparse pixel probes with boundary refinement; full scan fallback when all probes are blue",
+    "sampling": "80 bin-center frames over detected non-blue time",
+    "letterbox": "PIL bicubic 420x224",
+    "metadata": "absolute millisecond PTS from request.start_time plus official clip PTS",
+    "inference_sha256": "a1eae658018582a5feb9fc0b844c5ae38c7c1dc73c541efb928e991924c62005",
+    "cpu_gate": {
+      "date": "2026-09-02",
+      "samples": 16,
+      "passed": 16,
+      "selected_blue_frames": 0,
+      "video_grid_thw": [40, 14, 26],
+      "mean_preprocess_seconds": 4.254098,
+      "max_preprocess_seconds": 10.904805,
+      "answers_read": false,
+      "test_references_read": false
+    }
+  },
   "submission_image_snapshot": {
     "image_id": "sha256:3ea66ddf64a40c9d2389f7c78326ab3728d54d6bb287b0cfa27cdee391827c5f",
     "runtime_backend": "transformers Qwen3_5ForConditionalGeneration",