Make VPB public evaluation strict by default

README.md

@@ -65,7 +65,8 @@ Annotated semantic keyframes are converted into a canonical reference trajectory
 
 - global and terminal metrics are computed on the official `1 Hz` evaluation grid;
 - local direction metrics are computed directly on adjacent annotated semantic anchors;
-- metrics are first computed per record and then macro-averaged, preventing long videos from dominating the result.
+- global metrics are first computed per record and then averaged over metric-valid records, preventing long videos from dominating the result;
+- prediction coverage is strict by default: missing curve points, terminal predictions, or local-direction anchor predictions stop evaluation unless `--allow-missing` is explicitly used for diagnostics.
 
 ### Metrics
 
@@ -196,15 +197,9 @@ The evaluator reports:
 - terminal metrics for four-bucket overall, seen merged, and unseen merged;
 - local direction AP for four-bucket overall, seen merged, and unseen merged.
 
-See `docs/evaluate_vlac_cut_on_vpb.md` for accepted prediction formats and complete metric definitions.
-
-## Reference VLAC-Cut Results
+By default, the evaluator requires complete predictions for all selected benchmark records. Use `--allow-missing` only when you intentionally want a diagnostic report with coverage and missing-count fields.
 
-| Global MAE ↓ | Global PRC ↑ | Terminal Macro-F1 ↑ | Local Direction MacroAP ↑ |
-|---:|---:|---:|---:|
-| **7.3344** | **0.9230** | **73.75** | **71.01** |
-
-These values summarize the overall VPB evaluation. Terminal Macro-F1 and Local Direction MacroAP are reported in percent. Refer to the paper for per-bucket results and baseline comparisons.
+See `docs/evaluate_vlac_cut_on_vpb.md` for accepted prediction formats and complete metric definitions.
 
 ## Citation
 

docs/evaluate_vlac_cut_on_vpb.md

@@ -17,6 +17,8 @@ reconstructed from each dense video timeline:
 - terminal metrics: final progress threshold `90%`
 - local direction metrics: `AP+`, `AP-`, and `MacroAP_D` on adjacent
   `semantic_anchors` with `tau=0`
+- coverage requirement: complete predictions are required by default; use
+  `--allow-missing` only to produce a diagnostic report for incomplete runs
 
 For VLAC-Cut evaluation we feed the model frames sampled at 2Hz. This 2Hz input
 rate is a VLAC-Cut evaluation setting, not a benchmark-wide protocol
@@ -124,7 +126,7 @@ For each trajectory, the evaluator compares predictions against the released
 `dense_kinematic_progress` values at the selected 1Hz frames.
 
 - `MAE`: mean absolute error over valid points in one trajectory, then averaged
-  equally over trajectories.
+  equally over trajectories with at least one valid evaluated point.
 - `PRC`: Spearman correlation between GT progress and predicted progress in one
   trajectory, then averaged equally over valid trajectories.
 - `VOC`: Spearman correlation between predicted progress and chronological
@@ -176,6 +178,12 @@ counts for predictions outside the nominal `[0, 100]` range. The nominal range
 counts are diagnostics only; predictions are not clipped unless `--clip-pred` is
 set.
 
+The evaluator is strict by default: if any selected trajectory lacks required
+curve points, terminal predictions, or local-direction anchor predictions, the
+command exits with an error before writing outputs. Add `--allow-missing` only
+when debugging incomplete prediction files and intentionally writing a
+diagnostic report.
+
 ## Quick Checks
 
 Run the evaluator self-test:

scripts/evaluate_vpb_predictions.py

@@ -99,6 +99,11 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Linearly interpolate missing prediction frames within each trajectory. This is not the strict default.",
     )
+    parser.add_argument(
+        "--allow-missing",
+        action="store_true",
+        help="Write a diagnostic report even when predictions do not cover every required evaluation point.",
+    )
     parser.add_argument(
         "--self-test",
         action="store_true",
@@ -748,6 +753,65 @@ def build_report(
     }
 
 
+def validate_no_missing(report: dict[str, Any]) -> dict[str, Any]:
+    errors: list[str] = []
+
+    curve_sources = [("overall_4bucket", report["curve"]["overall_4bucket"])]
+    curve_sources.extend(
+        (bucket, item)
+        for bucket, item in report["curve"]["per_bucket"].items()
+    )
+    for scope, item in curve_sources:
+        if int(item.get("point_valid", 0)) != int(item.get("point_base_total", 0)):
+            errors.append(
+                f"curve.{scope}: point_valid={item.get('point_valid')} "
+                f"point_base_total={item.get('point_base_total')}"
+            )
+        if int(item.get("traj_with_valid_pred", 0)) != int(item.get("traj_base_total", 0)):
+            errors.append(
+                f"curve.{scope}: traj_with_valid_pred={item.get('traj_with_valid_pred')} "
+                f"traj_base_total={item.get('traj_base_total')}"
+            )
+
+    terminal_sources = [
+        ("overall_4bucket", report["terminal"]["overall_4bucket"]),
+        ("seen_merged", report["terminal"]["seen_merged"]),
+        ("unseen_merged", report["terminal"]["unseen_merged"]),
+    ]
+    terminal_sources.extend(
+        (bucket, item)
+        for bucket, item in report["terminal"]["per_bucket"].items()
+    )
+    for scope, item in terminal_sources:
+        if int(item.get("valid_final", 0)) != int(item.get("support", 0)) or int(item.get("missing_final", 0)) != 0:
+            errors.append(
+                f"terminal.{scope}: valid_final={item.get('valid_final')} "
+                f"support={item.get('support')} missing_final={item.get('missing_final')}"
+            )
+
+    direction_sources = [
+        ("overall_4bucket", report["local_direction_ap"]["overall_4bucket"]),
+        ("seen_merged", report["local_direction_ap"]["seen_merged"]),
+        ("unseen_merged", report["local_direction_ap"]["unseen_merged"]),
+    ]
+    direction_sources.extend(
+        (bucket, item)
+        for bucket, item in report["local_direction_ap"]["per_bucket"].items()
+    )
+    for scope, item in direction_sources:
+        if int(item.get("valid", 0)) != int(item.get("transition_total", 0)) or int(item.get("missing", 0)) != 0:
+            errors.append(
+                f"local_direction_ap.{scope}: valid={item.get('valid')} "
+                f"transition_total={item.get('transition_total')} missing={item.get('missing')}"
+            )
+
+    return {
+        "no_missing_check": not errors,
+        "error_count": len(errors),
+        "errors": errors,
+    }
+
+
 def point_ratio(item: dict[str, Any]) -> str:
     return f"{int(item.get('point_valid', 0))}/{int(item.get('point_base_total', 0))}"
 
@@ -772,9 +836,12 @@ def build_markdown(report: dict[str, Any]) -> str:
     lines.append(f"- sample_hz: `{config['sample_hz']}`")
     lines.append(f"- success_threshold: `{config['success_threshold_percent']}`")
     lines.append(f"- interpolate_missing: `{config['interpolate_missing']}`")
-    lines.append("- Curve metrics are trajectory-equal means.")
+    lines.append(f"- allow_missing: `{config['allow_missing']}`")
+    lines.append(f"- no_missing_check: `{report['validation']['no_missing_check']}`")
+    lines.append("- Curve metrics are trajectory-equal means over metric-valid trajectories.")
     lines.append("- VOC is reported only for expert bucket rows.")
     lines.append("- Local Direction AP uses adjacent released `semantic_anchors`; predictions are linearly interpolated at anchor frames.")
+    lines.append("- By default, missing curve, terminal, or local-direction predictions stop evaluation; use `--allow-missing` only for diagnostics.")
     lines.append("")
 
     curve_rows: list[list[Any]] = []
@@ -988,6 +1055,7 @@ def run_self_test() -> None:
         assert report["curve"]["overall_4bucket"]["mae"] == 0.0
         assert report["terminal"]["overall_4bucket"]["tsa"] == 1.0
         assert report["local_direction_ap"]["overall_4bucket"]["ap_positive"] == 1.0
+        assert validate_no_missing(report)["no_missing_check"] is True
     print("[self-test] ok")
 
 
@@ -1029,6 +1097,7 @@ def main() -> None:
         "sample_hz": float(args.sample_hz) if args.eval_points == "time_hz" else None,
         "success_threshold_percent": float(args.success_threshold),
         "interpolate_missing": bool(args.interpolate_missing),
+        "allow_missing": bool(args.allow_missing),
         "clip_pred": list(clip_range) if clip_range is not None else None,
     }
     report = build_report(
@@ -1037,6 +1106,14 @@ def main() -> None:
         prediction_info=prediction_info,
         config=config,
     )
+    report["validation"] = validate_no_missing(report)
+    if not args.allow_missing and not report["validation"]["no_missing_check"]:
+        preview = "\n".join(report["validation"]["errors"][:20])
+        raise SystemExit(
+            "Predictions do not cover every required evaluation item. "
+            "Use --allow-missing only for a diagnostic report.\n"
+            f"{preview}"
+        )
     if args.out_json is not None:
         dump_json(args.out_json, report)
     if args.out_md is not None: