dataset_upload/metrics/bcs_bes.py

#!/usr/bin/env python
"""BCS and BES from the judge's semantic clusters.   (protocol 4, 5, 6)

    python src/bcs_bes.py --model Llama-3.2-1B

Family-balanced, per protocol 4.1: the distribution over answer clusters is
computed WITHIN each condition family first, then the families are averaged with
equal weight. Counting raw queries instead would let paraphrase (10,053) and
multilingual (12,010) drown out anchor (2,592), and the headline number would
mostly measure how many variants we happened to write.

    p(a) = mean over families of  (share of that family's queries in cluster a)
    BCS  = max_a p(a)
    BES  = 1 - H(p)/log A      (1 when only one cluster was observed)

BCS deliberately does not consult correctness: a model that answers "Sydney" for
every phrasing of Australia's capital scores BCS = 1. That is the point --
protocol 6 then splits stable behaviour into Stable Correct and Stable Wrong
using the judge's reference-aware pass.
"""
import os, sys, math, argparse, collections

import numpy as np

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import mcommon as mc


def bcs_bes(assignments, families):
    """assignments: [(condition_family, cluster_id)] for one fact."""
    counts = collections.defaultdict(collections.Counter)
    for fam, cid in assignments:
        counts[fam][cid] += 1
    valid = [t for t in families if counts[t]]
    if not valid:
        return None
    clusters = {c for t in valid for c in counts[t]}
    p = {c: sum(counts[t][c] / sum(counts[t].values()) for t in valid) / len(valid)
         for c in clusters}
    modal = max(p, key=p.get)
    pos = [v for v in p.values() if v > 0]
    if len(pos) == 1:
        bes = 1.0
    else:
        H = -sum(v * math.log(v) for v in pos)
        bes = 1.0 - H / math.log(len(pos))
    return {"bcs": p[modal], "bes": bes, "modal_cluster": modal,
            "cluster_distribution": p, "valid_families": valid}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", required=True)
    ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None)
    ap.add_argument("--sample", type=int, default=0,
                    help="score only the same fixed subset judge_run.py sampled")
    ap.add_argument("--sample-seed", type=int, default=20260101)
    args = ap.parse_args()

    C = mc.cfg()
    mode = args.coverage or C["headline_coverage"]
    fams = C["main_families"]
    tau = C["behavior"]["tau_b"]
    keep = set(mc.eval_fact_set(mode))
    if args.sample:
        # Reproduce judge_run.py's draw exactly. A judge file can hold extra
        # facts -- a debug run, or a --resume over an earlier partial pass --
        # and scoring whatever happens to be in the file would give different
        # models different fact sets, which protocol 1.3 forbids.
        allf = sorted(mc.facts())
        rng = np.random.default_rng(args.sample_seed)
        pick = set(np.array(allf)[rng.choice(len(allf), size=args.sample,
                                             replace=False)].tolist())
        keep &= pick
    rel_of = mc.fact_relation()

    jpath = mc.out("metrics", "judge", f"{args.model}.jsonl")
    if not os.path.exists(jpath):
        raise SystemExit(f"no judge output for {args.model}; run src/judge_run.py")

    per_fact, groups = [], collections.Counter()
    for rec in mc.read_jsonl(jpath):
        fid = rec["fact_id"]
        if fid not in keep:
            continue
        label = {c["cluster_id"]: c for c in rec["clusters"]}
        res = bcs_bes([(a["condition_family"], a["cluster_id"])
                       for a in rec["assignments"]], fams)
        if res is None:
            continue
        modal = label.get(res["modal_cluster"], {})
        correctness = modal.get("correctness", "REVIEW_REQUIRED")
        status = modal.get("status", "ANSWER")
        # Protocol 6: the four behaviour groups partition the fact set, so every
        # fact lands in exactly one and the four rates sum to 1.
        if res["bcs"] < tau:
            grp = "Unstable"
        elif status == "ABSTAIN" or correctness == "ABSTAIN":
            grp = "Stable Abstention"
        elif correctness == "CORRECT":
            grp = "Stable Correct"
        elif correctness == "INCORRECT":
            grp = "Stable Wrong"
        else:
            grp = "Stable Unresolved"
        groups[grp] += 1
        per_fact.append({"model": args.model, "fact_id": fid, "relation": rel_of[fid],
                         "bcs": res["bcs"], "bes": res["bes"],
                         "modal_cluster": res["modal_cluster"],
                         "modal_correctness": correctness, "behavior_group": grp,
                         "valid_families": res["valid_families"]})

    if not per_fact:
        raise SystemExit(f"{args.model}: no facts scored")
    mc.write_jsonl(mc.out("metrics", "behavioral", f"{args.model}.{mode}.per_fact.jsonl"),
                   per_fact)

    n = len(per_fact)
    bs = C["bootstrap"]
    boot_bcs = mc.relation_clustered_bootstrap(
        {r["fact_id"]: r["bcs"] for r in per_fact}, rel_of,
        bs["n_resamples"], bs["seed"], bs["ci"])
    boot_bes = mc.relation_clustered_bootstrap(
        {r["fact_id"]: r["bes"] for r in per_fact}, rel_of,
        bs["n_resamples"], bs["seed"], bs["ci"])

    # Protocol 6: threshold sensitivity, because tau_b = 0.8 is a choice.
    sens = {}
    for t in C["behavior"]["tau_sensitivity"]:
        sens[str(t)] = {"stable_rate": float(np.mean([r["bcs"] >= t for r in per_fact])),
                        "stable_correct": float(np.mean(
                            [r["bcs"] >= t and r["modal_correctness"] == "CORRECT"
                             for r in per_fact]))}

    summary = {
        "model": args.model, "coverage_mode": mode, "n_facts": n, "tau_b": tau,
        "bcs": boot_bcs["mean"], "bcs_ci95": [boot_bcs["lo"], boot_bcs["hi"]],
        "bes": boot_bes["mean"], "bes_ci95": [boot_bes["lo"], boot_bes["hi"]],
        "stable_correct_rate": groups["Stable Correct"] / n,
        "stable_wrong_rate": groups["Stable Wrong"] / n,
        "stable_abstention_rate": groups["Stable Abstention"] / n,
        "stable_unresolved_rate": groups["Stable Unresolved"] / n,
        "unstable_rate": groups["Unstable"] / n,
        "behavior_counts": dict(groups),
        "tau_sensitivity": sens,
    }
    tot = sum(summary[k] for k in ("stable_correct_rate", "stable_wrong_rate",
                                   "stable_abstention_rate", "stable_unresolved_rate",
                                   "unstable_rate"))
    if abs(tot - 1.0) > 1e-6:
        raise SystemExit(f"behaviour rates sum to {tot}, not 1 (protocol 6)")
    mc.write_json(mc.out("metrics", "behavioral", f"{args.model}.{mode}.summary.json"),
                  summary)
    print(f"[{args.model}] BCS={summary['bcs']:.4f} BES={summary['bes']:.4f} "
          f"SC={summary['stable_correct_rate']:.3f} SW={summary['stable_wrong_rate']:.3f} "
          f"SA={summary['stable_abstention_rate']:.3f} "
          f"U={summary['unstable_rate']:.3f}  n={n}  BCSBES_DONE")


if __name__ == "__main__":
    main()