Trim quick start release docs and remove internal verification helper

README.md

@@ -77,14 +77,4 @@ python quick_start/render_prediction_video.py \
   --output-video quick_start/outputs/example_01_pred_progress.mp4
 ```
 
-Verify consistency with the bundled reference outputs:
-
-```bash
-python quick_start/verify_prediction_consistency.py \
-  --pred-jsonl quick_start/outputs/example_01.jsonl \
-  --reference-jsonl examples/reference_outputs/example_01.jsonl \
-  --pred-video quick_start/outputs/example_01_pred_progress.mp4 \
-  --reference-video examples/reference_outputs/example_01_pred_progress.mp4
-```
-
 More detailed usage is provided in `quick_start/README.md`.

quick_start/README.md

@@ -66,12 +66,6 @@ python quick_start/run_example.py \
 python quick_start/render_prediction_video.py \
   --input-jsonl quick_start/outputs/example_01.jsonl \
   --output-video quick_start/outputs/example_01_pred_progress.mp4
-
-python quick_start/verify_prediction_consistency.py \
-  --pred-jsonl quick_start/outputs/example_01.jsonl \
-  --reference-jsonl examples/reference_outputs/example_01.jsonl \
-  --pred-video quick_start/outputs/example_01_pred_progress.mp4 \
-  --reference-video examples/reference_outputs/example_01_pred_progress.mp4
 ```
 
 All three bundled examples:
@@ -86,12 +80,6 @@ for ex in example_01 example_02 example_03; do
   python quick_start/render_prediction_video.py \
     --input-jsonl "quick_start/outputs/${ex}.jsonl" \
     --output-video "quick_start/outputs/${ex}_pred_progress.mp4"
-
-  python quick_start/verify_prediction_consistency.py \
-    --pred-jsonl "quick_start/outputs/${ex}.jsonl" \
-    --reference-jsonl "examples/reference_outputs/${ex}.jsonl" \
-    --pred-video "quick_start/outputs/${ex}_pred_progress.mp4" \
-    --reference-video "examples/reference_outputs/${ex}_pred_progress.mp4"
 done
 ```
 

quick_start/verify_prediction_consistency.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-from pathlib import Path
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Verify that a newly generated prediction JSONL/video matches a reference output.",
-    )
-    parser.add_argument("--pred-jsonl", type=Path, required=True, help="Newly generated prediction JSONL.")
-    parser.add_argument("--reference-jsonl", type=Path, required=True, help="Reference prediction JSONL.")
-    parser.add_argument("--pred-video", type=Path, default=None, help="Optional newly generated preview video.")
-    parser.add_argument("--reference-video", type=Path, default=None, help="Optional reference preview video.")
-    parser.add_argument("--tolerance", type=float, default=1e-6, help="Numeric tolerance for float comparisons.")
-    return parser.parse_args()
-
-
-def load_row(path: Path) -> dict:
-    lines = path.read_text(encoding="utf-8").splitlines()
-    if not lines:
-        raise SystemExit(f"Empty JSONL file: {path}")
-    return json.loads(lines[0])
-
-
-def get_alias_value(row: dict, *keys: str):
-    for key in keys:
-        if key in row:
-            return row[key]
-    return None
-
-
-def compare_numeric_lists(name: str, lhs, rhs, tolerance: float, errors: list[str]) -> None:
-    if lhs is None or rhs is None:
-        errors.append(f"{name}: missing on one side")
-        return
-    if len(lhs) != len(rhs):
-        errors.append(f"{name}: length mismatch {len(lhs)} != {len(rhs)}")
-        return
-    for idx, (a, b) in enumerate(zip(lhs, rhs, strict=True)):
-        if abs(float(a) - float(b)) > tolerance:
-            errors.append(f"{name}: mismatch at index {idx}: {a} != {b}")
-            return
-
-
-def sha256_file(path: Path) -> str:
-    h = hashlib.sha256()
-    with path.open("rb") as f:
-        while True:
-            chunk = f.read(1024 * 1024)
-            if not chunk:
-                break
-            h.update(chunk)
-    return h.hexdigest()
-
-
-def main() -> int:
-    args = parse_args()
-    pred_row = load_row(args.pred_jsonl.resolve())
-    ref_row = load_row(args.reference_jsonl.resolve())
-    errors: list[str] = []
-
-    pred_response = str(pred_row.get("response", "")).strip()
-    ref_response = str(ref_row.get("response", "")).strip()
-    if pred_response != ref_response:
-        errors.append("response: text mismatch")
-
-    pred_parse_ok = bool(pred_row.get("pred_curve_parse_ok"))
-    ref_parse_ok = bool(ref_row.get("pred_curve_parse_ok"))
-    if pred_parse_ok != ref_parse_ok:
-        errors.append(f"pred_curve_parse_ok: mismatch {pred_parse_ok} != {ref_parse_ok}")
-
-    compare_numeric_lists(
-        "pred_curve_point_times_sec",
-        pred_row.get("pred_curve_point_times_sec"),
-        ref_row.get("pred_curve_point_times_sec"),
-        args.tolerance,
-        errors,
-    )
-    compare_numeric_lists(
-        "pred_curve_point_progress",
-        pred_row.get("pred_curve_point_progress"),
-        ref_row.get("pred_curve_point_progress"),
-        args.tolerance,
-        errors,
-    )
-
-    compare_numeric_lists(
-        "input_frame_indices",
-        get_alias_value(pred_row, "input_frame_indices", "input_frame_indices_2hz"),
-        get_alias_value(ref_row, "input_frame_indices", "input_frame_indices_2hz"),
-        args.tolerance,
-        errors,
-    )
-    compare_numeric_lists(
-        "input_timestamps_sec",
-        get_alias_value(pred_row, "input_timestamps_sec", "input_timestamps_sec_2hz"),
-        get_alias_value(ref_row, "input_timestamps_sec", "input_timestamps_sec_2hz"),
-        args.tolerance,
-        errors,
-    )
-
-    pred_sample_hz = float(get_alias_value(pred_row, "input_sample_hz") or 0.0)
-    ref_sample_hz = float(get_alias_value(ref_row, "input_sample_hz") or 0.0)
-    if abs(pred_sample_hz - ref_sample_hz) > args.tolerance:
-        errors.append(f"input_sample_hz: mismatch {pred_sample_hz} != {ref_sample_hz}")
-
-    pred_frame_count = int(get_alias_value(pred_row, "input_frame_count", "input_frame_count_2hz") or 0)
-    ref_frame_count = int(get_alias_value(ref_row, "input_frame_count", "input_frame_count_2hz") or 0)
-    if pred_frame_count != ref_frame_count:
-        errors.append(f"input_frame_count: mismatch {pred_frame_count} != {ref_frame_count}")
-
-    if args.pred_video is not None or args.reference_video is not None:
-        if args.pred_video is None or args.reference_video is None:
-            errors.append("video comparison requires both --pred-video and --reference-video")
-        else:
-            pred_video = args.pred_video.resolve()
-            ref_video = args.reference_video.resolve()
-            if not pred_video.exists():
-                errors.append(f"Missing pred video: {pred_video}")
-            if not ref_video.exists():
-                errors.append(f"Missing reference video: {ref_video}")
-            if pred_video.exists() and ref_video.exists():
-                pred_sha = sha256_file(pred_video)
-                ref_sha = sha256_file(ref_video)
-                if pred_sha != ref_sha:
-                    errors.append(f"preview_video: sha256 mismatch {pred_sha} != {ref_sha}")
-
-    if errors:
-        print("CONSISTENCY_CHECK=FAILED")
-        for item in errors:
-            print(item)
-        return 1
-
-    print("CONSISTENCY_CHECK=PASSED")
-    print(f"pred_jsonl={args.pred_jsonl.resolve()}")
-    print(f"reference_jsonl={args.reference_jsonl.resolve()}")
-    if args.pred_video is not None and args.reference_video is not None:
-        print(f"pred_video={args.pred_video.resolve()}")
-        print(f"reference_video={args.reference_video.resolve()}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())