"""``explicit-eval`` — frozen prediction, scoring, and paired statistics.""" from __future__ import annotations import argparse import json import sys from pathlib import Path from ..atomic_io import atomic_write_json, read_jsonl from ..config import ConfigError, load_resources from ..evaluation import ( RETENTION_SOURCES, EvaluationError, compare_runs, freeze_certified_groups, freeze_retention_items, load_evaluation_manifest, materialize_hf_retention, score_predictions, ) from ..evaluation.core import write_score_outputs from ..evaluation.inference import predict_run from ..paths import repo_root def _assignment(value: str, *, label: str) -> tuple[str, str]: if "=" not in value: raise argparse.ArgumentTypeError(f"{label} must use NAME=PATH") name, path = value.split("=", 1) if not name or not path: raise argparse.ArgumentTypeError(f"{label} must use non-empty NAME=PATH") return name, path def _run_assignment(value: str) -> tuple[str, str]: return _assignment(value, label="--run") def _score_assignment(value: str) -> tuple[str, str]: return _assignment(value, label="--score") def cmd_freeze(args: argparse.Namespace) -> int: try: summary = freeze_certified_groups( args.groups, args.output, expected_groups=args.expected_groups, ) except (EvaluationError, OSError, json.JSONDecodeError) as exc: print(f"EVALUATION FREEZE FAILED: {exc}", file=sys.stderr) return 1 print(json.dumps(summary, sort_keys=True)) return 0 def cmd_predict_matrix(args: argparse.Namespace) -> int: try: rows = load_evaluation_manifest(args.manifest) run_specs = dict(args.run) if len(run_specs) != len(args.run): raise EvaluationError("duplicate --run name") summaries = [] for run_id, raw_adapter in run_specs.items(): adapter = None if raw_adapter == "BASE" else Path(raw_adapter) summaries.append( predict_run( rows, run_id=run_id, base_model=args.base_model, adapter=adapter, asset_root=args.asset_root, output_path=args.output_dir / f"{run_id}.predictions.jsonl", max_prompt_tokens=args.max_prompt_tokens, max_new_tokens=args.max_new_tokens, limit=args.limit, input_mode=args.input_mode, constant_answer=args.constant_answer, ) ) except (EvaluationError, OSError, json.JSONDecodeError, RuntimeError) as exc: print(f"EVALUATION PREDICTION FAILED: {exc}", file=sys.stderr) return 1 print(json.dumps({"status": "completed", "runs": summaries}, sort_keys=True)) return 0 def cmd_score(args: argparse.Namespace) -> int: try: gold = load_evaluation_manifest(args.manifest) predictions = tuple(read_jsonl(args.predictions)) metrics, scored = score_predictions(gold, predictions) write_score_outputs(args.output_dir, metrics, scored) except (EvaluationError, OSError, json.JSONDecodeError) as exc: print(f"EVALUATION SCORE FAILED: {exc}", file=sys.stderr) return 1 print( json.dumps( { "status": "completed", "run_id": metrics["run_id"], "metrics": str((args.output_dir / "metrics.json").resolve()), "scored": str((args.output_dir / "scored.jsonl").resolve()), "strict_group_accuracy": metrics["strict_group_accuracy"], }, sort_keys=True, ) ) return 0 def cmd_freeze_retention(args: argparse.Namespace) -> int: try: summary = freeze_retention_items( args.items, args.output, expected_items=args.expected_items, ) except (EvaluationError, OSError, json.JSONDecodeError) as exc: print(f"RETENTION FREEZE FAILED: {exc}", file=sys.stderr) return 1 print(json.dumps(summary, sort_keys=True)) return 0 def cmd_materialize_retention_hf(args: argparse.Namespace) -> int: try: resources = load_resources(args.resources) summary = materialize_hf_retention( resources, args.output, args.asset_root, cache_dir=args.cache_dir, sources=args.source or RETENTION_SOURCES, ) except (ConfigError, EvaluationError, ImportError, OSError, ValueError) as exc: print(f"RETENTION MATERIALIZATION FAILED: {exc}", file=sys.stderr) return 1 print(json.dumps(summary, sort_keys=True)) return 0 def cmd_statistics(args: argparse.Namespace) -> int: try: score_paths = dict(args.score) if len(score_paths) != len(args.score): raise EvaluationError("duplicate --score run name") runs = {run_id: tuple(read_jsonl(Path(path))) for run_id, path in score_paths.items()} result = compare_runs( runs, reference=args.reference, metric=args.metric, benchmark=args.benchmark, bootstrap_replicates=args.bootstrap_replicates, permutation_replicates=args.permutation_replicates, seed=args.seed, ) atomic_write_json(args.output, result) except (EvaluationError, OSError, json.JSONDecodeError) as exc: print(f"EVALUATION STATISTICS FAILED: {exc}", file=sys.stderr) return 1 print( json.dumps( { "status": "completed", "output": str(args.output.resolve()), "comparison_count": len(result["comparisons"]), }, sort_keys=True, ) ) return 0 def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(prog="explicit-eval") sub = parser.add_subparsers(dest="command", required=True) freeze = sub.add_parser( "freeze", help="Flatten certified release groups into one write-once evaluation manifest.", ) freeze.add_argument("--groups", type=Path, action="append", required=True) freeze.add_argument("--output", type=Path, required=True) freeze.add_argument("--expected-groups", type=int) freeze.set_defaults(func=cmd_freeze) retention = sub.add_parser( "freeze-retention", help="Convert untouched normalized eval items into the common evaluation manifest.", ) retention.add_argument("--items", type=Path, action="append", required=True) retention.add_argument("--output", type=Path, required=True) retention.add_argument("--expected-items", type=int) retention.set_defaults(func=cmd_freeze_retention) materialize = sub.add_parser( "materialize-retention-hf", help="Download exact pinned HF retention splits and build the common manifest.", ) materialize.add_argument( "--resources", type=Path, default=repo_root() / "configs" / "resources.yaml", ) materialize.add_argument( "--source", choices=RETENTION_SOURCES, action="append", help="Repeat to select a subset; defaults to all four untouched sources.", ) materialize.add_argument("--output", type=Path, required=True) materialize.add_argument("--asset-root", type=Path, required=True) materialize.add_argument("--cache-dir", type=Path) materialize.set_defaults(func=cmd_materialize_retention_hf) predict = sub.add_parser( "predict-matrix", help="Generate deterministic predictions for one or more base/adapter checkpoints.", ) predict.add_argument("--manifest", type=Path, required=True) predict.add_argument("--asset-root", type=Path, required=True) predict.add_argument("--base-model", type=Path, required=True) predict.add_argument( "--run", type=_run_assignment, action="append", required=True, metavar="RUN_ID=ADAPTER_PATH", help="Use RUN_ID=BASE for the unadapted base model.", ) predict.add_argument("--output-dir", type=Path, required=True) predict.add_argument("--max-prompt-tokens", type=int, default=4096) predict.add_argument("--max-new-tokens", type=int, default=256) predict.add_argument("--limit", type=int) predict.add_argument( "--input-mode", choices=["standard", "question_only", "full_image_control"], default="standard", ) predict.add_argument( "--constant-answer", help="Skip model inference and emit this answer for every item (diagnostic baseline).", ) predict.set_defaults(func=cmd_predict_matrix) score = sub.add_parser("score", help="Join exact prediction coverage and compute metrics.") score.add_argument("--manifest", type=Path, required=True) score.add_argument("--predictions", type=Path, required=True) score.add_argument("--output-dir", type=Path, required=True) score.set_defaults(func=cmd_score) statistics = sub.add_parser( "statistics", help="Run group-clustered bootstrap, paired permutation, and Holm correction.", ) statistics.add_argument( "--score", type=_score_assignment, action="append", required=True, metavar="RUN_ID=SCORED_JSONL", ) statistics.add_argument("--reference", required=True) statistics.add_argument( "--metric", choices=["strict_group_accuracy", "accuracy"], default="strict_group_accuracy" ) statistics.add_argument( "--benchmark", help="Required when scored rows contain more than one benchmark suite.", ) statistics.add_argument("--bootstrap-replicates", type=int, default=10_000) statistics.add_argument("--permutation-replicates", type=int, default=10_000) statistics.add_argument("--seed", type=int, default=20260728) statistics.add_argument("--output", type=Path, required=True) statistics.set_defaults(func=cmd_statistics) return parser def main(argv: list[str] | None = None) -> int: if argv == []: build_parser().print_usage(sys.stderr) return 2 args = build_parser().parse_args(argv) return int(args.func(args)) if __name__ == "__main__": raise SystemExit(main())