| |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import subprocess |
| import sys |
| from pathlib import Path |
| from typing import Any |
|
|
| import pandas as pd |
|
|
|
|
| DISPLAY_NAME = { |
| "continuous": "Continuous reference", |
| "standard_rvq_8bit": "standard RVQ 8-bit", |
| "pq_8bit": "PQ 8-bit", |
| "opq_8bit": "OPQ 8-bit", |
| "metadata_basic": "Metadata basic", |
| "metadata_calendar": "Metadata calendar", |
| "random_permuted_continuous": "Random-permuted continuous", |
| } |
|
|
| PUBLIC_METHODS = [ |
| "continuous", |
| "standard_rvq_8bit", |
| "pq_8bit", |
| "opq_8bit", |
| "metadata_basic", |
| "metadata_calendar", |
| "random_permuted_continuous", |
| ] |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Recompute the released CB-Telemetry retrieval and shortcut-control tables." |
| ) |
| parser.add_argument("--root", default=".", help="CB-Telemetry dataset root.") |
| parser.add_argument("--output-dir", default="evaluation_runs/release_retrieval", help="Output directory under --root.") |
| parser.add_argument("--bootstrap-samples", type=int, default=2000, help="Bootstrap resamples.") |
| parser.add_argument("--bootstrap-seed", type=int, default=42, help="Bootstrap random seed.") |
| parser.add_argument("--random-seed", type=int, default=42, help="Random-permuted control seed.") |
| parser.add_argument("--include-gap2", action="store_true", help="Also run the supplemental gap=2 retrieval controls.") |
| parser.add_argument("--tolerance", type=float, default=5e-3, help="Rounded-table comparison tolerance.") |
| return parser.parse_args() |
|
|
|
|
| def resolve(root: Path, raw_path: str) -> Path: |
| path = Path(raw_path).expanduser() |
| if not path.is_absolute(): |
| path = (root / path).resolve() |
| return path |
|
|
|
|
| def release_path(root: Path, path: Path) -> str: |
| try: |
| return path.resolve().relative_to(root).as_posix() |
| except ValueError: |
| return path.as_posix() |
|
|
|
|
| def track_feature_table(track: str) -> str: |
| return "features/feature_table_default.csv.gz" if track == "default" else "features/feature_table_strict_clean.csv.gz" |
|
|
|
|
| def bottleneck_representations(root: Path, track: str) -> list[str]: |
| result = [] |
| for method in ["standard_rvq_8bit", "pq_8bit", "opq_8bit"]: |
| rel = f"features/bottlenecks/{track}/{method}_feature_table.csv.gz" |
| if (root / rel).exists(): |
| result.append(f"{method}={rel}") |
| return result |
|
|
|
|
| def run_command(cmd: list[str]) -> None: |
| subprocess.run(cmd, check=True) |
|
|
|
|
| def run_retrieval_suite( |
| root: Path, |
| output_dir: Path, |
| bootstrap_samples: int, |
| bootstrap_seed: int, |
| random_seed: int, |
| include_gap2: bool, |
| ) -> list[dict[str, Any]]: |
| script = Path(__file__).resolve().parent / "run_retrieval_eval.py" |
| run_rows: list[dict[str, Any]] = [] |
| gaps = [1, 2] if include_gap2 else [1] |
| for track in ["default", "strict_clean"]: |
| feature_table = track_feature_table(track) |
| representations = [f"continuous={feature_table}", *bottleneck_representations(root, track)] |
| for scope_label, archive_scope in [("global", "global"), ("same-archive", "same_archive_only")]: |
| for gap in gaps: |
| run_dir = output_dir / track / f"{archive_scope}_gap{gap}" |
| cmd = [ |
| sys.executable, |
| script.as_posix(), |
| "--root", |
| root.as_posix(), |
| "--feature-table", |
| feature_table, |
| "--output-dir", |
| run_dir.as_posix(), |
| "--archive-scope", |
| archive_scope, |
| "--max-slot-gap", |
| str(gap), |
| "--bootstrap-samples", |
| str(bootstrap_samples), |
| "--bootstrap-seed", |
| str(bootstrap_seed), |
| "--random-seed", |
| str(random_seed), |
| "--include-metadata-controls", |
| ] |
| for item in representations: |
| cmd.extend(["--representation", item]) |
| run_command(cmd) |
| run_rows.append( |
| { |
| "track": track, |
| "scope": scope_label, |
| "gap": gap, |
| "archive_scope": archive_scope, |
| "summary_json_path": (run_dir / "summary.json").as_posix(), |
| "summary_json": release_path(root, run_dir / "summary.json"), |
| } |
| ) |
| return run_rows |
|
|
|
|
| def load_json(path: Path) -> dict[str, Any]: |
| return json.loads(path.read_text(encoding="utf-8")) |
|
|
|
|
| def build_overview(run_rows: list[dict[str, Any]]) -> pd.DataFrame: |
| rows: list[dict[str, Any]] = [] |
| for run in run_rows: |
| summary = load_json(Path(run["summary_json_path"])) |
| aggregate_df = pd.DataFrame(summary["aggregate_rows"]).set_index("method") |
| bootstrap_df = pd.DataFrame(summary["bootstrap_rows"]) |
| for _, boot in bootstrap_df.iterrows(): |
| method = str(boot["method"]) |
| aggregate = aggregate_df.loc[method] |
| rows.append( |
| { |
| "track": run["track"], |
| "scope": run["scope"], |
| "gap": int(run["gap"]), |
| "archive_scope": run["archive_scope"], |
| "method": method, |
| "display_name": DISPLAY_NAME.get(method, method), |
| "bootstrap_unit": str(boot["bootstrap_unit"]), |
| "top1": float(aggregate["mean_top1_hit_rate"]), |
| "top1_ci_low": float(boot["top1_hit_rate_ci_low"]), |
| "top1_ci_high": float(boot["top1_hit_rate_ci_high"]), |
| "mrr": float(aggregate["mean_mrr"]), |
| "mrr_ci_low": float(boot["mrr_ci_low"]), |
| "mrr_ci_high": float(boot["mrr_ci_high"]), |
| "top5": float(aggregate["mean_top5_hit_rate"]), |
| "top5_ci_low": float(boot["top5_hit_rate_ci_low"]), |
| "top5_ci_high": float(boot["top5_hit_rate_ci_high"]), |
| "mean_candidate_size": float(aggregate["mean_candidate_size"]), |
| "mean_chance_top1": float(aggregate["mean_chance_top1"]), |
| "summary_json": str(run["summary_json"]), |
| } |
| ) |
| return pd.DataFrame(rows).sort_values(["track", "scope", "gap", "bootstrap_unit", "method"]).reset_index(drop=True) |
|
|
|
|
| def date_row(df: pd.DataFrame, track: str, method: str, scope: str, gap: int) -> pd.Series: |
| rows = df[ |
| (df["track"] == track) |
| & (df["method"] == method) |
| & (df["scope"] == scope) |
| & (df["gap"] == gap) |
| & (df["bootstrap_unit"] == "date") |
| ] |
| if rows.empty: |
| raise KeyError(f"Missing row: track={track}, method={method}, scope={scope}, gap={gap}") |
| return rows.iloc[0] |
|
|
|
|
| def ci_text(row: pd.Series, metric: str) -> str: |
| return f"{float(row[metric]):.4f} [{float(row[f'{metric}_ci_low']):.4f}, {float(row[f'{metric}_ci_high']):.4f}]" |
|
|
|
|
| def build_table3_recomputed(overview: pd.DataFrame) -> pd.DataFrame: |
| rows = [] |
| for method in PUBLIC_METHODS: |
| global_row = date_row(overview, "default", method, "global", 1) |
| same_row = date_row(overview, "default", method, "same-archive", 1) |
| rows.append( |
| { |
| "method": method, |
| "display_name": DISPLAY_NAME.get(method, method), |
| "global_top1": round(float(global_row["top1"]), 4), |
| "global_mrr": round(float(global_row["mrr"]), 4), |
| "global_top5": round(float(global_row["top5"]), 4), |
| "same_archive_top1": round(float(same_row["top1"]), 4), |
| "same_archive_mrr": round(float(same_row["mrr"]), 4), |
| "same_archive_top5": round(float(same_row["top5"]), 4), |
| "global_mrr_ci": ci_text(global_row, "mrr"), |
| "same_archive_mrr_ci": ci_text(same_row, "mrr"), |
| } |
| ) |
| return pd.DataFrame(rows) |
|
|
|
|
| def build_dual_track_recomputed(root: Path, overview: pd.DataFrame) -> pd.DataFrame: |
| rows = [] |
| for track in ["default", "strict_clean"]: |
| feature_df = pd.read_csv(root / track_feature_table(track), usecols=["date"]) |
| for scope_label, archive_scope in [("global", "global"), ("same-archive", "same_archive_only")]: |
| row = date_row(overview, track, "continuous", scope_label, 1) |
| rows.append( |
| { |
| "track": f"{track}__{archive_scope}", |
| "subset": track, |
| "archive_scope": archive_scope, |
| "rows": int(feature_df.shape[0]), |
| "date_count": int(feature_df["date"].astype(str).nunique()), |
| "top1": round(float(row["top1"]), 4), |
| "mrr": round(float(row["mrr"]), 4), |
| "top5": round(float(row["top5"]), 4), |
| "chance_top1": round(float(row["mean_chance_top1"]), 4), |
| } |
| ) |
| return pd.DataFrame(rows) |
|
|
|
|
| def compare_table( |
| expected_path: Path, |
| actual_df: pd.DataFrame, |
| key_columns: list[str], |
| metric_columns: list[str], |
| tolerance: float, |
| ) -> list[dict[str, Any]]: |
| mismatches: list[dict[str, Any]] = [] |
| if not expected_path.exists(): |
| return [{"table": expected_path.name, "issue": "missing_expected_table"}] |
| expected_df = pd.read_csv(expected_path) |
| merged = expected_df.merge(actual_df, on=key_columns, how="outer", suffixes=("_expected", "_actual"), indicator=True) |
| for _, row in merged.iterrows(): |
| key = {column: row[column] for column in key_columns} |
| if row["_merge"] != "both": |
| mismatches.append({"table": expected_path.name, "key": key, "issue": str(row["_merge"])}) |
| continue |
| for column in metric_columns: |
| expected = float(row[f"{column}_expected"]) |
| actual = float(row[f"{column}_actual"]) |
| if abs(expected - actual) > tolerance: |
| mismatches.append( |
| { |
| "table": expected_path.name, |
| "key": key, |
| "metric": column, |
| "expected": expected, |
| "actual": actual, |
| "abs_delta": abs(expected - actual), |
| } |
| ) |
| return mismatches |
|
|
|
|
| def write_markdown(path: Path, check: dict[str, Any]) -> None: |
| lines = [ |
| "# CB-Telemetry Release Evaluation Check", |
| "", |
| f"- status: `{check['status']}`", |
| f"- bootstrap_samples: `{check['bootstrap_samples']}`", |
| f"- overview_rows: `{check['overview_rows']}`", |
| f"- mismatches: `{len(check['mismatches'])}`", |
| "", |
| "## Mismatches", |
| "", |
| ] |
| if check["mismatches"]: |
| for item in check["mismatches"]: |
| lines.append(f"- `{item}`") |
| else: |
| lines.append("- none") |
| path.write_text("\n".join(lines) + "\n", encoding="utf-8") |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| root = Path(args.root).expanduser().resolve() |
| output_dir = resolve(root, args.output_dir) |
| output_dir.mkdir(parents=True, exist_ok=True) |
|
|
| run_rows = run_retrieval_suite( |
| root=root, |
| output_dir=output_dir, |
| bootstrap_samples=int(args.bootstrap_samples), |
| bootstrap_seed=int(args.bootstrap_seed), |
| random_seed=int(args.random_seed), |
| include_gap2=bool(args.include_gap2), |
| ) |
| overview = build_overview(run_rows) |
| overview_path = output_dir / "release_retrieval_overview.csv" |
| overview.to_csv(overview_path, index=False) |
|
|
| table3 = build_table3_recomputed(overview) |
| table3_path = output_dir / "table_3_retrieval_baselines_and_controls_recomputed.csv" |
| table3.to_csv(table3_path, index=False) |
|
|
| dual = build_dual_track_recomputed(root, overview) |
| dual_path = output_dir / "table_3_dual_track_retrieval_recomputed.csv" |
| dual.to_csv(dual_path, index=False) |
|
|
| mismatches: list[dict[str, Any]] = [] |
| mismatches.extend( |
| compare_table( |
| expected_path=root / "baselines" / "table_3_retrieval_baselines_and_controls.csv", |
| actual_df=table3, |
| key_columns=["method"], |
| metric_columns=[ |
| "global_top1", |
| "global_mrr", |
| "global_top5", |
| "same_archive_top1", |
| "same_archive_mrr", |
| "same_archive_top5", |
| ], |
| tolerance=float(args.tolerance), |
| ) |
| ) |
| mismatches.extend( |
| compare_table( |
| expected_path=root / "baselines" / "table_3_dual_track_retrieval.csv", |
| actual_df=dual, |
| key_columns=["track"], |
| metric_columns=["top1", "mrr", "top5", "chance_top1"], |
| tolerance=float(args.tolerance), |
| ) |
| ) |
|
|
| check = { |
| "status": "pass" if not mismatches else "fail", |
| "root": root.name, |
| "output_dir": release_path(root, output_dir), |
| "bootstrap_samples": int(args.bootstrap_samples), |
| "include_gap2": bool(args.include_gap2), |
| "overview_rows": int(overview.shape[0]), |
| "files": { |
| "overview": release_path(root, overview_path), |
| "table3_recomputed": release_path(root, table3_path), |
| "dual_track_recomputed": release_path(root, dual_path), |
| }, |
| "mismatches": mismatches, |
| } |
| (output_dir / "release_evaluation_check.json").write_text( |
| json.dumps(check, ensure_ascii=False, indent=2) + "\n", |
| encoding="utf-8", |
| ) |
| write_markdown(output_dir / "release_evaluation_check.md", check) |
| print(json.dumps(check, ensure_ascii=False, indent=2)) |
| raise SystemExit(0 if check["status"] == "pass" else 1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
