Blame for scripts/score_independent_eval.py

#!/usr/bin/env python3
"""Scoring post-hoc de evaluación independiente (capa C).

Formato oficial de anotaciones (annotations_template.json):

    {
      "annotators": ["A1", "A2", "A3"],
      "status": "pending_human_collection" | "complete",
      "items": [
        {
          "id": "NR01",
          "annotations": {"A1": "none" | null, ...},
          "free_text": {"A1": "...", ...}
        },
        ...
      ]
    }

Reglas estadísticas:
  - null / ausente ≠ etiqueta "unsure".
  - Fleiss' kappa exige el **mismo conjunto de anotadores** con respuesta
    no nula en **todos** los ítems incluidos (k fijo). No se trunca.
  - Si un ítem tiene un subconjunto distinto de respondentes, se excluye
    del kappa y se reporta en incomplete/heterogeneous.
  - "unsure" es una respuesta legítima, no un relleno.

Uso:
    python scripts/score_independent_eval.py
    python scripts/score_independent_eval.py --annotations path/to/filled.json
    python scripts/score_independent_eval.py --min-annotators 3
"""
from __future__ import annotations

import argparse
import json
import sys
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any

ROOT = Path(__file__).resolve().parents[1]
EVAL_DIR = ROOT / "datasets" / "independent_eval"
VALID_LABELS = frozenset({"none", "mirrorOf", "creates", "unsure"})


def fleiss_kappa(ratings: list[list[str]], categories: list[str]) -> float:
    """Fleiss' kappa. ratings[i] = etiquetas de los k anotadores para el ítem i.
    Todas las filas deben tener la misma longitud k ≥ 2.
    """
    n_items = len(ratings)
    if n_items == 0:
        return float("nan")
    n_raters = len(ratings[0])
    if n_raters < 2:
        return float("nan")
    if any(len(r) != n_raters for r in ratings):
        raise ValueError("Todas las filas de ratings deben tener la misma longitud")

    cat_idx = {c: i for i, c in enumerate(categories)}
    table = []
    for row in ratings:
        counts = [0] * len(categories)
        for lab in row:
            if lab not in cat_idx:
                raise ValueError(f"Etiqueta fuera de categorías: {lab!r}")
            counts[cat_idx[lab]] += 1
        table.append(counts)

    P = []
    for counts in table:
        s = sum(c * (c - 1) for c in counts)
        P.append(s / (n_raters * (n_raters - 1)))
    P_bar = sum(P) / n_items

    totals = [sum(table[i][j] for i in range(n_items)) for j in range(len(categories))]
    p = [t / (n_items * n_raters) for t in totals]
    P_e = sum(pj ** 2 for pj in p)
    if abs(1 - P_e) < 1e-12:
        return 1.0
    return (P_bar - P_e) / (1 - P_e)


def parse_template_format(data: dict) -> tuple[list[str], dict[str, dict[str, str | None]]]:
    """Formato oficial: annotators=[ids], items=[{id, annotations: {A: label|null}}]."""
    annotator_ids = list(data.get("annotators") or [])
    if not annotator_ids:
        raise ValueError("Campo 'annotators' vacío o ausente")

    by_pair: dict[str, dict[str, str | None]] = {}
    items = data.get("items")
    if not isinstance(items, list):
        raise ValueError("Campo 'items' debe ser una lista")

    for item in items:
        pid = item.get("id")
        if not pid:
            raise ValueError(f"Ítem sin id: {item!r}")
        anns = item.get("annotations") or {}
        if not isinstance(anns, dict):
            raise ValueError(f"annotations de {pid} debe ser un objeto")
        pair_map: dict[str, str | None] = {}
        for aid in annotator_ids:
            raw = anns.get(aid)
            if raw is None:
                pair_map[aid] = None
            elif isinstance(raw, str) and raw.strip() == "":
                pair_map[aid] = None
            elif raw in VALID_LABELS:
                pair_map[aid] = raw
            else:
                raise ValueError(
                    f"Etiqueta inválida en {pid}/{aid}: {raw!r}. "
                    f"Permitidas: {sorted(VALID_LABELS)} o null"
                )
        by_pair[pid] = pair_map
    return annotator_ids, by_pair


def parse_legacy_formats(data: Any) -> tuple[list[str], dict[str, dict[str, str | None]]]:
    by_pair: dict[str, dict[str, str | None]] = defaultdict(dict)
    annotator_ids: list[str] = []

    if isinstance(data, dict) and "annotators" in data:
        anns = data["annotators"]
        if isinstance(anns, list) and anns and isinstance(anns[0], dict) and "labels" in anns[0]:
            for ann in anns:
                aid = str(ann.get("id") or ann.get("name") or f"A{len(annotator_ids)+1}")
                annotator_ids.append(aid)
                for pair_id, label in (ann.get("labels") or {}).items():
                    by_pair[pair_id][aid] = label if label in VALID_LABELS else None
            return annotator_ids, dict(by_pair)

    if isinstance(data, list):
        aids_set: set[str] = set()
        for item in data:
            pid = item.get("id") or item.get("pair_id")
            aid = str(item.get("annotator") or "A1")
            lab = item.get("label") or item.get("annotation")
            if not pid:
                continue
            aids_set.add(aid)
            by_pair[pid][aid] = lab if lab in VALID_LABELS else None
        return sorted(aids_set), dict(by_pair)

    raise ValueError(
        "Formato de anotaciones no reconocido. "
        "Usa el formato de annotations_template.json."
    )


def load_annotations(path: Path) -> tuple[list[str], dict[str, dict[str, str | None]], dict]:
    data = json.loads(path.read_text(encoding="utf-8"))
    meta = {
        "status": data.get("status") if isinstance(data, dict) else None,
        "description": data.get("description") if isinstance(data, dict) else None,
        "evaluation_mode": data.get("evaluation_mode") if isinstance(data, dict) else None,
    }
    if isinstance(data, dict) and isinstance(data.get("items"), list):
        annotator_ids, by_pair = parse_template_format(data)
    else:
        annotator_ids, by_pair = parse_legacy_formats(data)
    return annotator_ids, by_pair, meta


def load_rule_reference() -> dict[str, str]:
    ref_path = EVAL_DIR / "rule_reference.json"
    if not ref_path.is_file():
        return {}
    raw = json.loads(ref_path.read_text(encoding="utf-8"))
    if isinstance(raw, list):
        return {item["id"]: item.get("rule_label") for item in raw if "id" in item}
    if isinstance(raw, dict):
        out = {}
        for k, v in raw.items():
            if k in ("labels",):
                continue
            if isinstance(v, dict):
                out[k] = v.get("rule_label")
            elif isinstance(v, str):
                out[k] = v
        if "labels" in raw and isinstance(raw["labels"], dict):
            out.update(raw["labels"])
        return out
    return {}


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Scoring de evaluación independiente (capa C)"
    )
    parser.add_argument(
        "--annotations",
        type=Path,
        default=EVAL_DIR / "annotations.json",
        help="JSON de anotaciones (plantilla o rellenado)",
    )
    parser.add_argument(
        "--min-annotators",
        type=int,
        default=3,
        help="Número exacto de anotadores con respuesta no nula requerido por ítem (default 3)",
    )
    args = parser.parse_args()

    if not args.annotations.is_file():
        # fallback a plantilla
        alt = EVAL_DIR / "annotations_template.json"
        if alt.is_file():
            args.annotations = alt
        else:
            print(f"ERROR: no se encontró {args.annotations}", file=sys.stderr)
            return 1

    try:
        annotator_ids, by_pair, meta = load_annotations(args.annotations)
    except (ValueError, json.JSONDecodeError) as exc:
        print(f"ERROR de formato: {exc}", file=sys.stderr)
        return 1

    k_required = args.min_annotators
    if k_required < 2:
        print("ERROR: --min-annotators debe ser ≥ 2", file=sys.stderr)
        return 1

    incomplete_pairs: dict[str, dict] = {}
    respondent_sets: dict[str, tuple[str, ...]] = {}
    labels_by_pair_ordered: dict[str, list[str]] = {}
    unsure_counts: Counter = Counter()
    present_counts: Counter = Counter()

    for pid, ann_map in by_pair.items():
        respondents = []
        labels_ordered = []
        missing = []
        for aid in annotator_ids:
            lab = ann_map.get(aid)
            if lab is None:
                missing.append(aid)
            else:
                respondents.append(aid)
                labels_ordered.append(lab)
                present_counts[lab] += 1
                if lab == "unsure":
                    unsure_counts[pid] += 1

        if len(respondents) == k_required:
            respondent_sets[pid] = tuple(respondents)
            labels_by_pair_ordered[pid] = labels_ordered
        else:
            incomplete_pairs[pid] = {
                "n_present": len(respondents),
                "n_missing": len(missing),
                "missing_annotators": missing,
                "present_annotators": respondents,
                "present_labels": labels_ordered,
                "reason": (
                    f"se requieren exactamente {k_required} respuestas no nulas; "
                    f"hay {len(respondents)}"
                ),
            }

    status = meta.get("status") or "unknown"
    n_total = len(by_pair)

    by_respondent_set: dict[tuple[str, ...], list[str]] = defaultdict(list)
    for pid, rset in respondent_sets.items():
        by_respondent_set[rset].append(pid)

    kappa_eligible_ids: list[str] = []
    kappa_annotators: tuple[str, ...] | None = None
    heterogeneous: dict[str, dict] = {}

    if by_respondent_set:
        best_set = max(
            by_respondent_set.keys(),
            key=lambda s: (len(by_respondent_set[s]), s),
        )
        kappa_eligible_ids = sorted(by_respondent_set[best_set])
        kappa_annotators = best_set

        for rset, pids in by_respondent_set.items():
            if rset == best_set:
                continue
            for pid in pids:
                heterogeneous[pid] = {
                    "respondents": list(rset),
                    "n_present": len(rset),
                    "reason": (
                        "conjunto de anotadores distinto al usado para kappa "
                        f"({list(best_set)}); no se trunca ni se mezcla"
                    ),
                    "present_labels": labels_by_pair_ordered[pid],
                }

    n_kappa = len(kappa_eligible_ids)
    n_incomplete = len(incomplete_pairs)
    n_heterogeneous = len(heterogeneous)

    if n_kappa == 0:
        report = {
            "status": status,
            "evaluation_mode": meta.get("evaluation_mode"),
            "n_pairs_total": n_total,
            "n_pairs_in_kappa": 0,
            "n_pairs_incomplete": n_incomplete,
            "n_pairs_heterogeneous_respondent_set": n_heterogeneous,
            "min_annotators_required": k_required,
            "kappa_annotators": None,
            "fleiss_kappa": None,
            "majority_labels": {},
            "posthoc_agreement_with_rule_reference": None,
            "incomplete_detail": incomplete_pairs,
            "heterogeneous_detail": heterogeneous,
            "note": (
                f"Sin ítems con exactamente {k_required} respuestas no nulas "
                "del mismo conjunto de anotadores. No se trunca. "
                "null/ausente ≠ 'unsure'. Protocolo listo; esperando recolección."
            ),
        }
        out = ROOT / "experiments" / "results" / "independent_eval_scores.json"
        out.parent.mkdir(parents=True, exist_ok=True)
        out.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
        print(json.dumps(report, ensure_ascii=False, indent=2))
        print(f"Escrito: {out}")
        return 0

    assert kappa_annotators is not None
    k = len(kappa_annotators)
    categories = ["none", "mirrorOf", "creates", "unsure"]
    ratings = [labels_by_pair_ordered[pid] for pid in kappa_eligible_ids]

    if any(len(r) != k for r in ratings):
        print(
            "ERROR interno: longitudes inconsistentes tras filtrado; no se calcula kappa.",
            file=sys.stderr,
        )
        return 1

    kappa = fleiss_kappa(ratings, categories)

    majority: dict[str, str] = {}
    unanimous = 0
    for pid in kappa_eligible_ids:
        labs = labels_by_pair_ordered[pid]
        cnt = Counter(labs)
        maj_lab, maj_n = cnt.most_common(1)[0]
        majority[pid] = maj_lab
        if maj_n == len(labs):
            unanimous += 1

    majority_all = dict(majority)
    for pid, labs in labels_by_pair_ordered.items():
        if pid not in majority_all and labs:
            majority_all[pid] = Counter(labs).most_common(1)[0][0]

    rule_ref = load_rule_reference()
    comparable = {
        pid: maj
        for pid, maj in majority.items()
        if rule_ref.get(pid) and rule_ref[pid] not in (None, "unspecified")
    }
    agreement_with_rules = None
    if comparable:
        matched = sum(1 for pid, maj in comparable.items() if rule_ref[pid] == maj)
        agreement_with_rules = round(matched / len(comparable), 4)

    report = {
        "status": status,
        "evaluation_mode": meta.get("evaluation_mode"),
        "n_pairs_total": n_total,
        "n_pairs_in_kappa": n_kappa,
        "n_pairs_incomplete": n_incomplete,
        "n_pairs_heterogeneous_respondent_set": n_heterogeneous,
        "min_annotators_required": k_required,
        "kappa_annotators": list(kappa_annotators),
        "n_annotators_per_kappa_item": k,
        "fleiss_kappa": None if (isinstance(kappa, float) and kappa != kappa) else round(kappa, 4),
        "unanimous_fraction": round(unanimous / n_kappa, 4) if n_kappa else None,
        "majority_labels_in_kappa": majority,
        "majority_labels_all_with_any_response": majority_all,
        "label_distribution_present": dict(present_counts),
        "unsure_count_by_pair": dict(unsure_counts),
        "posthoc_agreement_with_rule_reference": agreement_with_rules,
        "n_posthoc_comparable": len(comparable),
        "incomplete_detail": incomplete_pairs if incomplete_pairs else {},
        "heterogeneous_detail": heterogeneous if heterogeneous else {},
        "policy": (
            "Fleiss' kappa solo sobre ítems con exactamente k anotadores no nulos "
            "y el mismo conjunto de respondentes. No se trunca ni se rellena. "
            "null ≠ unsure."
        ),
        "note": (
            "Fleiss' kappa y mayoría (sobre el panel kappa) son el objetivo primario. "
            "posthoc_agreement_with_rule_reference excluye unspecified y es solo post-hoc."
        ),
    }

    out = ROOT / "experiments" / "results" / "independent_eval_scores.json"
    out.parent.mkdir(parents=True, exist_ok=True)
    out.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(json.dumps(report, ensure_ascii=False, indent=2))
    print(f"Escrito: {out}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())