| |
| """Evaluate Sys1Cal-v1 predictions against an exact-probability JSONL split.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import statistics |
| import sys |
| from collections import defaultdict |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| def read_jsonl(path: Path) -> list[dict[str, Any]]: |
| rows = [] |
| with path.open("r", encoding="utf-8") as handle: |
| for line_number, line in enumerate(handle, start=1): |
| if not line.strip(): |
| continue |
| try: |
| rows.append(json.loads(line)) |
| except json.JSONDecodeError as exc: |
| raise SystemExit(f"{path}:{line_number}: invalid JSON: {exc}") from exc |
| return rows |
|
|
|
|
| def normalize(distribution: dict[str, Any], outcomes: list[str]) -> dict[str, float]: |
| cleaned = {label: max(0.0, float(distribution.get(label, 0.0))) for label in outcomes} |
| total = sum(cleaned.values()) |
| if total <= 0.0: |
| return {label: 1.0 / len(outcomes) for label in outcomes} |
| return {label: value / total for label, value in cleaned.items()} |
|
|
|
|
| def argmax(distribution: dict[str, float]) -> str: |
| return max(distribution.items(), key=lambda item: (item[1], item[0]))[0] |
|
|
|
|
| def total_variation( |
| gold: dict[str, float], prediction: dict[str, float], outcomes: list[str] |
| ) -> float: |
| return 0.5 * sum(abs(gold[label] - prediction[label]) for label in outcomes) |
|
|
|
|
| def brier_regret( |
| gold: dict[str, float], prediction: dict[str, float], outcomes: list[str] |
| ) -> float: |
| return sum((prediction[label] - gold[label]) ** 2 for label in outcomes) |
|
|
|
|
| def extract_distribution(row: dict[str, Any], item: dict[str, Any]) -> dict[str, float]: |
| outcomes = item["outcomes"] |
| for key in ("predicted_distribution", "distribution", "prediction", "probabilities"): |
| value = row.get(key) |
| if isinstance(value, dict): |
| return normalize(map_labels(value, outcomes), outcomes) |
|
|
| if "probability_true" in row: |
| p_true = float(row["probability_true"]) |
| return normalize({"True": p_true, "False": 1.0 - p_true}, outcomes) |
|
|
| if "p_true" in row: |
| p_true = float(row["p_true"]) |
| return normalize({"True": p_true, "False": 1.0 - p_true}, outcomes) |
|
|
| raise ValueError( |
| "prediction row must contain predicted_distribution, distribution, " |
| "prediction, probabilities, probability_true, or p_true" |
| ) |
|
|
|
|
| def map_labels(distribution: dict[str, Any], outcomes: list[str]) -> dict[str, Any]: |
| if all(label in distribution for label in outcomes): |
| return distribution |
| lower_to_label = {str(label).lower(): label for label in outcomes} |
| mapped = {} |
| for raw_label, value in distribution.items(): |
| label = lower_to_label.get(str(raw_label).lower()) |
| if label is not None: |
| mapped[label] = value |
| return mapped |
|
|
|
|
| def prediction_group(row: dict[str, Any]) -> str: |
| model = row.get("model") or row.get("model_name") or "submission" |
| response_type = row.get("response_type") |
| api_metadata = row.get("api_metadata") |
| if response_type is None and isinstance(api_metadata, dict): |
| response_type = api_metadata.get("question_type") |
| return f"{model}:{response_type}" if response_type else str(model) |
|
|
|
|
| def summarize(values: list[float]) -> dict[str, float]: |
| if not values: |
| return { |
| "mean": 0.0, |
| "median": 0.0, |
| "std": 0.0, |
| "p90": 0.0, |
| "p95": 0.0, |
| "max": 0.0, |
| } |
| ordered = sorted(values) |
| return { |
| "mean": statistics.fmean(values), |
| "median": statistics.median(values), |
| "std": statistics.pstdev(values) if len(values) > 1 else 0.0, |
| "p90": ordered[min(len(ordered) - 1, int(0.90 * (len(ordered) - 1)))], |
| "p95": ordered[min(len(ordered) - 1, int(0.95 * (len(ordered) - 1)))], |
| "max": max(values), |
| } |
|
|
|
|
| def aggregate(rows: list[dict[str, Any]]) -> dict[str, Any]: |
| tv_values = [row["tv"] for row in rows] |
| brier_values = [row["brier_regret"] for row in rows] |
| accuracy_values = [1.0 if row["argmax_correct"] else 0.0 for row in rows] |
| return { |
| "n_predictions": len(rows), |
| "accuracy": statistics.fmean(accuracy_values) if accuracy_values else 0.0, |
| "pointwise_probability_fidelity": 1.0 - statistics.fmean(tv_values) |
| if tv_values |
| else 0.0, |
| "tv": summarize(tv_values), |
| "brier_regret": summarize(brier_values), |
| } |
|
|
|
|
| def evaluate(dataset_path: Path, predictions_path: Path, strict: bool) -> dict[str, Any]: |
| items = {row["instance_id"]: row for row in read_jsonl(dataset_path)} |
| prediction_rows = read_jsonl(predictions_path) |
| scored_rows = [] |
| errors = [] |
|
|
| for index, row in enumerate(prediction_rows, start=1): |
| instance_id = row.get("instance_id") |
| if instance_id not in items: |
| errors.append(f"prediction row {index}: unknown instance_id {instance_id!r}") |
| continue |
| item = items[instance_id] |
| try: |
| pred = extract_distribution(row, item) |
| except Exception as exc: |
| errors.append(f"prediction row {index}: {exc}") |
| continue |
| gold = {key: float(value) for key, value in item["gold_distribution"].items()} |
| outcomes = item["outcomes"] |
| tv = total_variation(gold, pred, outcomes) |
| scored_rows.append( |
| { |
| "group": prediction_group(row), |
| "instance_id": instance_id, |
| "latent_instance_id": item["latent_instance_id"], |
| "family": item["family"], |
| "representation": item["representation"], |
| "probability_band": item.get("probability_band"), |
| "tv": tv, |
| "pointwise_probability_fidelity": 1.0 - tv, |
| "brier_regret": brier_regret(gold, pred, outcomes), |
| "gold_argmax": item["gold_argmax"], |
| "predicted_argmax": argmax(pred), |
| "argmax_correct": argmax(gold) == argmax(pred), |
| } |
| ) |
|
|
| covered = {row["instance_id"] for row in scored_rows} |
| missing = sorted(set(items) - covered) |
| if strict and (errors or missing): |
| for error in errors[:20]: |
| print(error, file=sys.stderr) |
| if len(errors) > 20: |
| print(f"... {len(errors) - 20} more prediction errors", file=sys.stderr) |
| if missing: |
| print(f"missing predictions for {len(missing)} dataset rows", file=sys.stderr) |
| raise SystemExit(1) |
|
|
| by_group = defaultdict(list) |
| by_family = defaultdict(list) |
| by_representation = defaultdict(list) |
| by_probability_band = defaultdict(list) |
| for row in scored_rows: |
| by_group[row["group"]].append(row) |
| by_family[(row["group"], row["family"])].append(row) |
| by_representation[(row["group"], row["representation"])].append(row) |
| by_probability_band[(row["group"], row["probability_band"])].append(row) |
|
|
| return { |
| "dataset_path": str(dataset_path), |
| "predictions_path": str(predictions_path), |
| "n_dataset_items": len(items), |
| "n_prediction_rows": len(prediction_rows), |
| "n_scored_rows": len(scored_rows), |
| "n_missing_items": len(missing), |
| "n_errors": len(errors), |
| "errors": errors, |
| "overall": aggregate(scored_rows), |
| "by_group": {str(key): aggregate(rows) for key, rows in sorted(by_group.items())}, |
| "by_family": { |
| f"{key[0]} / {key[1]}": aggregate(rows) |
| for key, rows in sorted(by_family.items()) |
| }, |
| "by_representation": { |
| f"{key[0]} / {key[1]}": aggregate(rows) |
| for key, rows in sorted(by_representation.items()) |
| }, |
| "by_probability_band": { |
| f"{key[0]} / {key[1]}": aggregate(rows) |
| for key, rows in sorted(by_probability_band.items()) |
| }, |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--dataset", |
| type=Path, |
| default=Path("data/v0.1.0_tiny_cleanvars_parallel_primitives.jsonl"), |
| help="Sys1Cal-v1 JSONL file.", |
| ) |
| parser.add_argument("--predictions", type=Path, required=True, help="Prediction JSONL.") |
| parser.add_argument("--output", type=Path, help="Optional path for summary JSON.") |
| parser.add_argument( |
| "--strict", |
| action="store_true", |
| help="Fail on unknown instance IDs, malformed predictions, or missing items.", |
| ) |
| args = parser.parse_args() |
|
|
| summary = evaluate(args.dataset, args.predictions, args.strict) |
| text = json.dumps(summary, indent=2, sort_keys=True) |
| if args.output: |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| args.output.write_text(text + "\n", encoding="utf-8") |
| print(text) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
