#!/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())