scripts/validate_classifier.py

"""Validate the rule-based error-type classifier against an LLM judge.

Samples N failed steps from the existing diagnosis output, re-classifies
them with an LLM judge (OpenAI or Anthropic via stepprobe.diagnose's
built-in LLMJudge), and reports Cohen's κ plus a 4×4 confusion matrix.

Without an API key, the script still runs end-to-end using a second
round of rule-based labelling with different hashing seeds as a weak
sanity check (prints agreement, κ likely near 1.0 — signals you need a
real API call to reach something publishable).

Outputs (JSON):
    results/validation/classifier/agreement.json
    results/validation/classifier/samples.jsonl
"""

import argparse
import json
import os
import random
import sys
from collections import Counter
from typing import Dict, List, Tuple

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from stepprobe.diagnose import LLMJudge, RuleBasedJudge
from stepprobe.utils import load_jsonl


ERROR_TYPES = ["conceptual", "methodological", "executional", "logical"]


def _cohen_kappa(labels_a: List[str], labels_b: List[str],
                 categories: List[str]) -> float:
    """Unweighted Cohen's kappa on two aligned label sequences."""
    assert len(labels_a) == len(labels_b)
    n = len(labels_a)
    if n == 0:
        return float("nan")

    cat_idx = {c: i for i, c in enumerate(categories)}
    K = len(categories)
    cm = [[0] * K for _ in range(K)]
    for a, b in zip(labels_a, labels_b):
        if a not in cat_idx or b not in cat_idx:
            continue
        cm[cat_idx[a]][cat_idx[b]] += 1

    total = sum(sum(row) for row in cm)
    if total == 0:
        return float("nan")
    p_obs = sum(cm[i][i] for i in range(K)) / total
    row_sums = [sum(cm[i]) for i in range(K)]
    col_sums = [sum(cm[i][j] for i in range(K)) for j in range(K)]
    p_exp = sum(row_sums[i] * col_sums[i] for i in range(K)) / (total * total)
    if p_exp >= 1:
        return float("nan")
    return (p_obs - p_exp) / (1 - p_exp)


def _collect_failed_steps(diagnosis_root: str, max_samples: int,
                          seed: int = 42) -> List[dict]:
    """Walk diagnosis dir, pull (problem_id, step, error_type) triples."""
    rng = random.Random(seed)
    candidates: List[dict] = []
    for root, _dirs, files in os.walk(diagnosis_root):
        for fname in files:
            if not fname.endswith(".jsonl"):
                continue
            path = os.path.join(root, fname)
            try:
                traces = load_jsonl(path)
            except Exception:
                continue
            # infer (quant, model) from the path
            parts = os.path.relpath(path, diagnosis_root).split(os.sep)
            quant_tag = parts[0] if len(parts) > 1 else "unknown"
            model_tag = parts[1] if len(parts) > 2 else "unknown"
            for t in traces:
                for step in (t.get("steps") or []):
                    if step.get("is_correct") is False and step.get("error_type") in ERROR_TYPES:
                        candidates.append({
                            "problem_id": t.get("problem_id"),
                            "model": model_tag,
                            "quant": quant_tag,
                            "step_index": step.get("index"),
                            "step_text": step.get("text", ""),
                            "rule_based": step.get("error_type"),
                        })
    rng.shuffle(candidates)
    return candidates[:max_samples]


def _relabel_with_judge(samples: List[dict], judge_kind: str,
                        judge_model: str = None) -> List[str]:
    """Re-run error-type classification on each sampled step using an LLM
    judge. Falls back to a rule-based re-judge if `judge_kind=rule`."""
    if judge_kind == "rule":
        j = RuleBasedJudge()
    else:
        j = LLMJudge(judge_kind, judge_model or ("gpt-4o" if judge_kind == "openai" else "claude-3-5-sonnet-latest"))

    out = []
    for i, s in enumerate(samples):
        try:
            # We don't have paired ref step here; pass an empty ref to let
            # the classifier decide on content alone. The paper's rule-based
            # classifier works this way too.
            label = j.classify_error(problem=s["problem_id"],
                                     ref_step="",
                                     hyp_step=s["step_text"])
        except Exception:
            label = "executional"
        if label not in ERROR_TYPES:
            label = "executional"
        out.append(label)
        if (i + 1) % 25 == 0:
            print(f"  judged {i+1}/{len(samples)}")
    return out


def _confusion(labels_a, labels_b, categories):
    cat_idx = {c: i for i, c in enumerate(categories)}
    K = len(categories)
    cm = [[0] * K for _ in range(K)]
    for a, b in zip(labels_a, labels_b):
        if a in cat_idx and b in cat_idx:
            cm[cat_idx[a]][cat_idx[b]] += 1
    return cm


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--diagnosis-root", default="results/diagnosis")
    parser.add_argument("--output-dir", default="results/validation/classifier")
    parser.add_argument("--n-samples", type=int, default=200)
    parser.add_argument("--judge", default="rule",
                        choices=["rule", "openai", "anthropic"],
                        help="Which judge to use as ground truth. 'rule' is a "
                             "sanity-check mode that gives κ≈1 — use openai or "
                             "anthropic for a real validation.")
    parser.add_argument("--judge-model", default=None,
                        help="Model name for the judge (e.g., gpt-4o, claude-3-5-sonnet-latest).")
    parser.add_argument("--seed", type=int, default=42)
    args = parser.parse_args()

    os.makedirs(args.output_dir, exist_ok=True)

    print(f"Sampling up to {args.n_samples} failed steps from {args.diagnosis_root}...")
    samples = _collect_failed_steps(args.diagnosis_root, args.n_samples, args.seed)
    print(f"  Collected {len(samples)} samples.")

    print(f"Judging with {args.judge}...")
    judge_labels = _relabel_with_judge(samples, args.judge, args.judge_model)

    rule_labels = [s["rule_based"] for s in samples]

    kappa = _cohen_kappa(rule_labels, judge_labels, ERROR_TYPES)
    cm = _confusion(rule_labels, judge_labels, ERROR_TYPES)

    dist_rule = Counter(rule_labels)
    dist_judge = Counter(judge_labels)

    # Persist everything so downstream reports can reuse it.
    with open(os.path.join(args.output_dir, "samples.jsonl"), "w") as f:
        for s, jl in zip(samples, judge_labels):
            f.write(json.dumps({**s, "judge_label": jl, "judge": args.judge},
                               ensure_ascii=False) + "\n")

    report = {
        "n_samples": len(samples),
        "judge": args.judge,
        "cohen_kappa": kappa,
        "categories": ERROR_TYPES,
        "confusion_matrix_rule_rows_judge_cols": cm,
        "distribution_rule_based": dict(dist_rule),
        "distribution_judge": dict(dist_judge),
    }
    with open(os.path.join(args.output_dir, "agreement.json"), "w") as f:
        json.dump(report, f, indent=2)

    print()
    print(f"  Cohen's κ (rule vs {args.judge}): {kappa:.3f}")
    print(f"  Confusion matrix (rows = rule-based, columns = {args.judge}):")
    header = "            " + "  ".join(f"{c[:6]:>6s}" for c in ERROR_TYPES)
    print(header)
    for i, c in enumerate(ERROR_TYPES):
        row = "  ".join(f"{cm[i][j]:>6d}" for j in range(len(ERROR_TYPES)))
        print(f"    {c[:10]:<10s}  {row}")
    print()
    print(f"  Full report: {os.path.join(args.output_dir, 'agreement.json')}")


if __name__ == "__main__":
    main()