scripts/score_annotations.py

"""
Computes Cohen's kappa and self-report consistency between two label files.

The two label files can be any combination of annotators: LLM-vs-LLM,
LLM-vs-human, or human-vs-human. Each CSV must have columns:
    row_idx, candidate_shard, human_label (or llm_label), agent_said_used_it

The "label" column can be either 'human_label' or 'llm_label'; both are read.
The kappa computation does not depend on which annotator type produced the
labels --- it measures agreement between whatever pair of label files
is passed on the command line.

Usage:
    python3 score_annotations.py judge_a.csv judge_b.csv
"""
import csv
import sys


def load_labels(path):
    """Return dict: (row_idx, candidate_shard) -> 'yes' / 'no' / 'unclear' / ''."""
    out = {}
    with open(path, newline="", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        for row in reader:
            label = (row.get("llm_label") or row.get("human_label") or "").strip().lower()
            key = (row["row_idx"], row["candidate_shard"])
            out[key] = label
    return out


def agent_claim(path):
    out = {}
    with open(path, newline="", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        for row in reader:
            key = (row["row_idx"], row["candidate_shard"])
            out[key] = row["agent_said_used_it"].strip().lower() == "yes"
    return out


def cohen_kappa(labels_a, labels_b, classes):
    """Cohen's kappa for categorical labels."""
    keys = [k for k in labels_a
            if k in labels_b
            and labels_a[k] in classes
            and labels_b[k] in classes]
    n = len(keys)
    if n == 0:
        return None, 0

    agree = sum(1 for k in keys if labels_a[k] == labels_b[k])
    p_o = agree / n

    p_e = 0.0
    for c in classes:
        p_a = sum(1 for k in keys if labels_a[k] == c) / n
        p_b = sum(1 for k in keys if labels_b[k] == c) / n
        p_e += p_a * p_b

    if p_e == 1.0:
        return (1.0 if p_o == 1.0 else 0.0), n
    return (p_o - p_e) / (1 - p_e), n


def confusion_matrix(labels_a, labels_b, classes, label_a="A", label_b="B"):
    keys = [k for k in labels_a
            if k in labels_b
            and labels_a[k] in classes
            and labels_b[k] in classes]
    matrix = {(ca, cb): 0 for ca in classes for cb in classes}
    for k in keys:
        matrix[(labels_a[k], labels_b[k])] += 1

    col = 12
    print(f"{'':>{col}}", end="")
    for cb in classes:
        print(f"{(label_b + ':' + cb):>{col}}", end="")
    print()
    for ca in classes:
        print(f"{(label_a + ':' + ca):>{col}}", end="")
        for cb in classes:
            print(f"{matrix[(ca, cb)]:>{col}}", end="")
        print()


def self_report_vs_labels(path_csv, annotator_label):
    claim = agent_claim(path_csv)
    labels = load_labels(path_csv)
    keys = [k for k in claim if k in labels and labels[k] in ("yes", "no")]
    tp = sum(1 for k in keys if claim[k] and labels[k] == "yes")
    fp = sum(1 for k in keys if claim[k] and labels[k] == "no")
    fn = sum(1 for k in keys if not claim[k] and labels[k] == "yes")
    tn = sum(1 for k in keys if not claim[k] and labels[k] == "no")
    total = tp + fp + fn + tn
    if total == 0:
        return None
    return {
        "annotator": annotator_label,
        "tp": tp, "fp": fp, "fn": fn, "tn": tn,
        "precision": tp / (tp + fp) if (tp + fp) else 0.0,
        "recall":    tp / (tp + fn) if (tp + fn) else 0.0,
        "accuracy":  (tp + tn) / total,
        "n": total,
    }


def annotator_name_from_path(path):
    base = path.rsplit("/", 1)[-1].rsplit(".", 1)[0]
    return base.replace("_labels", "").replace("_", "-")


def main():
    if len(sys.argv) != 3:
        print(f"Usage: {sys.argv[0]} annotator_a.csv annotator_b.csv")
        sys.exit(1)

    path_a, path_b = sys.argv[1], sys.argv[2]
    name_a = annotator_name_from_path(path_a)
    name_b = annotator_name_from_path(path_b)

    labels_a = load_labels(path_a)
    labels_b = load_labels(path_b)

    classes_strict = ["yes", "no"]
    classes_lenient = ["yes", "no", "unclear"]
    kappa_strict, n_strict = cohen_kappa(labels_a, labels_b, classes_strict)
    kappa_lenient, n_lenient = cohen_kappa(labels_a, labels_b, classes_lenient)

    keys_strict = [k for k in labels_a
                   if k in labels_b
                   and labels_a[k] in classes_strict
                   and labels_b[k] in classes_strict]
    agree_strict = sum(1 for k in keys_strict if labels_a[k] == labels_b[k])

    print("=" * 64)
    print("Inter-annotator agreement report")
    print("=" * 64)
    print(f"Annotator A: {name_a}   ({path_a})")
    print(f"Annotator B: {name_b}   ({path_b})")
    print()
    print("Pairs labelled by both annotators:")
    print(f"  yes/no only (strict):  {n_strict}")
    print(f"  including unclear:     {n_lenient}")
    print()
    if kappa_strict is not None:
        print(f"Strict  kappa (yes/no):  {kappa_strict:+.4f}")
    else:
        print("Strict  kappa: no comparable data")
    if kappa_lenient is not None:
        print(f"Lenient kappa (3-class): {kappa_lenient:+.4f}")
    else:
        print("Lenient kappa: no comparable data")
    if n_strict:
        print(f"Raw agreement (strict):  "
              f"{agree_strict}/{n_strict} = {agree_strict/n_strict:.1%}")
    print()
    print("Landis & Koch (1977) interpretation:")
    print("  <0.00 poor | 0.00-0.20 slight | 0.21-0.40 fair")
    print("  0.41-0.60 moderate | 0.61-0.80 substantial | 0.81-1.00 almost perfect")
    print()
    print("NOTE: Cohen's kappa measures inter-annotator agreement. The")
    print("annotator type (LLM or human) is determined by what produced")
    print("the input CSVs, not by this script. When one of the input")
    print("files contains human-produced labels, kappa is an LLM-vs-human")
    print("(or human-vs-human) agreement; when both are LLM-produced,")
    print("it is an inter-LLM agreement.")
    print()

    print("Confusion matrix (strict, yes/no only):")
    confusion_matrix(labels_a, labels_b, classes_strict,
                     label_a=name_a[:8], label_b=name_b[:8])
    print()

    print("=" * 64)
    print("Self-report vs annotator labels (weak validation)")
    print("=" * 64)
    for path in (path_a, path_b):
        r = self_report_vs_labels(path, annotator_name_from_path(path))
        if r is None:
            print(f"{path}: insufficient data")
            continue
        print(f"{r['annotator']} (n={r['n']}):")
        print(f"  self-report precision: {r['precision']:.3f}  "
              f"(when agent says 'used', how often does this annotator agree?)")
        print(f"  self-report recall:    {r['recall']:.3f}  "
              f"(of annotator-marked 'used', how many did agent self-report?)")
        print(f"  self-report accuracy:  {r['accuracy']:.3f}")
        print(f"    TP={r['tp']}  FP={r['fp']}  FN={r['fn']}  TN={r['tn']}")
        print()


if __name__ == "__main__":
    main()