| """Replay unchanged frozen policies after a source-only, prespecified exclusion.""" |
|
|
| import argparse |
| import hashlib |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| from embedding import recipes as core |
| from evaluation import frontier, sweep, utility_router as utility |
|
|
|
|
| def evaluate(run, frozen_path, grades_path, primary_path, specification_path, output): |
| run = Path(run) |
| plan = core.checked_plan(run) |
| frozen, primary, specification = map(core.read, (frozen_path, primary_path, specification_path)) |
| core.require( |
| primary["frozen_sha256"] == core.sha(frozen_path) |
| and primary["grades_sha256"] == core.sha(grades_path) |
| and primary["no_final_selection"] is True |
| and frozen["plan_sha256"] == core.sha(run / "plan.json") |
| and frozen["frozen_before_final_outcomes"] is True |
| and specification["fixed_before_final_outcomes"] is True |
| and specification["source_plan_sha256"] == plan["source_plan_sha256"], |
| "Sensitivity requires the verified primary replay and original source-only specification", |
| ) |
| rows = core.role_rows(run, plan, "final") |
| y, costs, grade = core.grades(plan, rows, grades_path, "final") |
| setting = specification["final_sensitivity"] |
| excluded = set(setting["excluded_ids"]) |
| core.require(len(excluded) == len(setting["excluded_ids"]), "Duplicate sensitivity ID") |
| declared = {r["id"]: r for r in specification["source_ambiguous_rows"] if r["role"] == "final"} |
| core.require(excluded == set(declared), "Sensitivity differs from predeclared source ambiguities") |
| for row in rows: |
| if row["id"] in excluded: |
| evidence = declared[row["id"]] |
| core.require( |
| row["family"] == evidence["family"] |
| and hashlib.sha256(row["request"].encode()).hexdigest() == evidence["request_sha256"], |
| "Excluded source input changed", |
| ) |
| keep = np.array([row["id"] not in excluded for row in rows], dtype=bool) |
| core.require(len(rows) == setting["n_primary"] and int(keep.sum()) == setting["n_sensitivity"], |
| "Sensitivity population changed") |
| subset = [row for row, retained in zip(rows, keep, strict=True) if retained] |
| y, costs = y[keep], costs[keep] |
| bootstrap = frontier.Bootstrap(subset, primary["bootstrap_draws"]) |
| methods = {} |
| for name, saved in frozen["methods"].items(): |
| score = saved["scores"] |
| probabilities = np.asarray(score["probabilities"])[keep] |
| expected = np.asarray(score["expected_usd"])[keep] |
| fees = np.asarray(frozen["encoder_fees_usd"])[keep] if score["router_kind"] == "embedding" else None |
| frontier_ids = set(saved["calibration_frontier_candidate_ids"]) |
| candidates = [row for row in saved["candidates"] if row["candidate_id"] in frontier_ids] |
| metrics = sweep.sweep_metrics([row["policy"] for row in candidates], probabilities, expected, y, costs, fees) |
| points = [] |
| for candidate, metric in zip(candidates, metrics, strict=True): |
| policy = candidate["policy"] |
| charged = np.zeros(len(subset)) if policy["mode"].startswith("always_") else fees |
| routes = utility.replay(policy, probabilities, expected) |
| points.append({ |
| "candidate_id": candidate["candidate_id"], "rule": policy, **metric, |
| "paired_ci95": frontier.uncertainty(bootstrap, routes, y, costs, charged, |
| candidate["calibration_matched_random_strong_probability"]), |
| }) |
| methods[name] = {"points": points, "router_kind": score["router_kind"], |
| "metadata_assisted": score["metadata_assisted"]} |
| result = { |
| "format": "bbeh-source-format-sensitivity-result-v1", |
| "specification_sha256": core.sha(specification_path), "primary_report_sha256": core.sha(primary_path), |
| "frozen_sha256": core.sha(frozen_path), "grades_sha256": core.sha(grades_path), |
| "source_plan_sha256": plan["source_plan_sha256"], "excluded_ids": sorted(excluded), |
| "n_primary": len(rows), "n": len(subset), "families": len({row["family"] for row in subset}), |
| "random": {"accuracy_endpoints_percent": (100 * y.mean(axis=0)).tolist(), |
| "answer_usd_per_10000_endpoints": (10000 * costs.mean(axis=0)).tolist()}, |
| "methods": methods, "policies_unchanged": True, "no_refit_recalibration_or_selection": True, |
| "cost_scope": grade["cost_scope"], "implementation_sha256": core.sha(__file__), |
| "interpretation": "Supplementary source-quality sensitivity. Primary fixed-population results remain authoritative; no threshold or method is selected using this subset.", |
| } |
| core.write(output, result) |
| return result |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| for flag in ("run", "frozen", "grades", "primary", "specification", "output"): |
| parser.add_argument("--" + flag, required=True) |
| args = parser.parse_args() |
| evaluate(args.run, args.frozen, args.grades, args.primary, args.specification, args.output) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
