| """Score explicit claims and fixed-balance replays remotely using the old executor.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from collections import Counter |
| from pathlib import Path |
|
|
| from run_evaluate import execute, oracle, parse_response, read_jsonl, score_response, structural_check, write_jsonl |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--series", default="cliff_dev_r1") |
| args = parser.parse_args() |
| data = Path("data") / args.series |
| destination = Path("results") / args.series |
| profiles = {row["id"]: row for row in read_jsonl(data / "profiles.jsonl")} |
| references = {key: oracle(profile) for key, profile in profiles.items()} |
| design = json.loads((data / "design.json").read_text(encoding="utf-8")) |
| buffers = {row["profile_id"]: row["buffers"] for row in design["profile_specific_buffers"]} |
| raw = read_jsonl(Path("results") / f"{args.series}_4b_native.jsonl") |
| scores = [] |
| for row in raw: |
| profile = profiles[row["profile_id"]] |
| score = score_response(profile, row, references[row["profile_id"]]) |
| plan, parse_error = parse_response(row.get("response")) |
| claim = plan.get("feasibility_claim") if plan is not None else None |
| claim_is_bool = isinstance(claim, bool) |
| finished = row.get("finish_reason") == "stop" |
| evaluable = finished and parse_error is None and claim_is_bool |
| score.update({"feasibility_claim": claim if claim_is_bool else None, |
| "claim_raw_value": claim, "claim_true": claim is True, |
| "claim_missing": plan is None or "feasibility_claim" not in plan, |
| "claim_invalid_type": plan is not None and "feasibility_claim" in plan and not claim_is_bool, |
| "claim_vs_reason_conflict": None, |
| "claim_vs_reason_conflict_status": "pending qualitative reading, never inferred from risk words", |
| "finish_reason": row.get("finish_reason"), "output_tokens": row.get("output_tokens"), |
| "length_limited": row.get("finish_reason") == "length", "claim_evaluable": evaluable, |
| "false_assurance_cash_only": evaluable and claim is True and score["structurally_valid"] and not score["full_schedule_feasible"], |
| "physical_false_assurance_cash_only": evaluable and claim is True and not score["oracle_feasible"] and score["structurally_valid"] and not score["full_schedule_feasible"], |
| "avoidable_false_assurance_cash_only": evaluable and claim is True and score["oracle_feasible"] and score["structurally_valid"] and not score["full_schedule_feasible"], |
| "false_assurance_structural": evaluable and claim is True and not score["structurally_valid"], |
| "reference_feasible_no_successful_plan_claimed": evaluable and claim is False and score["oracle_feasible"], |
| "own_plan_false_negative": evaluable and claim is False and score["full_schedule_feasible"], |
| "explicit_instance_infeasibility_claim": None, |
| "false_instance_infeasibility_claim": None, |
| "physical_infeasible": not score["oracle_feasible"], |
| "presentation": row.get("presentation"), "buffer_roles": row.get("buffer_roles"), |
| "counterfactual_replays": []}) |
| if score["structurally_valid"]: |
| actions, _ = structural_check(profile, plan) |
| score["counterfactual_replays"] = [ |
| {"B": buffer, "oracle_feasible": buffer >= references[row["profile_id"]]["minimum_initial_cash"], |
| **execute(profile, actions, buffer)} for buffer in buffers[row["profile_id"]]] |
| if profile.get("funding_totals"): |
| families = {"GA": "GA", "TR_r": "TR", "TR_a": "TR", "AR": "AR", "DE_r": "DE", "DE_a": "DE"} |
| stages = {"funding_agreement": "GA", "travel_receipt_settlement": "TR", |
| "arrival_confirmation": "AR", "final_funding_settlement": "DE"} |
| funding_errors, error_families = [], set() |
| for error in score["structural_errors"]: |
| tokens = error.split(":") |
| matched = {families[token] for token in tokens if token in families} |
| matched.update(stages[token] for token in tokens if token in stages) |
| if matched: |
| funding_errors.append(error) |
| error_families.update(matched) |
| score["funding_condition_errors"] = funding_errors |
| score["funding_condition_error_families"] = sorted(error_families) |
| selected = {item.get("id") for item in (plan or {}).get("actions", []) |
| if isinstance(item, dict) and isinstance(item.get("id"), str)} |
| required_ids = {"GA", "AR"} |
| if "G_reimburse" in selected and "G_advance" not in selected: |
| required_ids.update(("TR_r", "DE_r")) |
| elif "G_advance" in selected and "G_reimburse" not in selected: |
| required_ids.update(("TR_a", "DE_a")) |
| score["submitted_funding_condition_ids"] = sorted(selected.intersection(families)) |
| score["missing_funding_condition_ids"] = sorted(required_ids - selected) |
| score["missing_funding_condition_groups"] = [ |
| {"stage": group["stage"], "alternative_ids": group["ids"]} |
| for group in profile["required_groups"] if group["stage"] in stages |
| and not selected.intersection(group["ids"])] |
| score["missing_funding_prerequisite_ids"] = sorted({ |
| error.split(":")[-1] for error in funding_errors if error.startswith("dependency_missing:")}) |
| score["funding_condition_classification_note"] = ( |
| "Literal schedule/dependency errors involving GA/TR/AR/DE; qualitative reading distinguishes omitted thought from unlisted code") |
| scores.append(score) |
| write_jsonl(destination / "scores_4b_native.jsonl", scores) |
| keys = ("claim_evaluable", "claim_true", "claim_missing", "claim_invalid_type", "length_limited", |
| "physical_infeasible", "structurally_valid", "full_schedule_feasible", "false_assurance_cash_only", |
| "physical_false_assurance_cash_only", "avoidable_false_assurance_cash_only", "false_assurance_structural", |
| "reference_feasible_no_successful_plan_claimed", "own_plan_false_negative") |
| summary = {"observed_n": len(scores), "expected_n": design["request_count"], |
| "counts": {key: sum(bool(row[key]) for row in scores) for key in keys}, |
| "parse_failure_n": sum(row["parse_error"] is not None for row in scores), |
| "failure_counts": dict(Counter((row.get("failure") or {}).get("kind", "success") for row in scores)), |
| "claim_vs_reason_conflict": "pending full raw qualitative review", |
| "cash_definition": "length/format/claim-interface failures excluded; cash-only requires noncash-valid full plan; avoidable additionally requires B>=physical R*", |
| "location": "Molab RTX PRO 6000", "profile_specific_buffers": design["profile_specific_buffers"]} |
| if any(profile.get("funding_totals") for profile in profiles.values()): |
| summary["claim_true_funding_condition_family_error_counts"] = { |
| family: sum(row["claim_evaluable"] and row["claim_true"] and |
| family in row.get("funding_condition_error_families", []) for row in scores) |
| for family in ("GA", "TR", "AR", "DE")} |
| summary["funding_condition_error_definition"] = ( |
| "Preserved structural errors categorized by named free funding condition; not parser/engineering labels or cash-only failures") |
| summary["claim_true_missing_funding_condition_id_counts"] = { |
| key: sum(row["claim_evaluable"] and row["claim_true"] and |
| key in row.get("missing_funding_condition_ids", []) for row in scores) |
| for key in ("GA", "TR_r", "TR_a", "AR", "DE_r", "DE_a")} |
| (destination / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8") |
| print(json.dumps(summary, ensure_ascii=False), flush=True) |
| for score in scores: |
| print(json.dumps({key: score.get(key) for key in ("id", "B", "oracle_min_cash", "feasibility_claim", |
| "structurally_valid", "full_schedule_feasible", "model_min_cash", "startup_cash_excess", |
| "false_assurance_cash_only", "avoidable_false_assurance_cash_only", "false_assurance_structural", |
| "reference_feasible_no_successful_plan_claimed", "own_plan_false_negative", "parse_error", "structural_errors", |
| "failure", "counterfactual_replays")}, ensure_ascii=False), flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
