| |
| """Invariancia interna no trivial (con control negativo). |
| |
| Mide autonomía *y* distingue el grafo canónico de uno corrompido: |
| |
| 1. Auto-regeneración: etiqueta ≡ regla (fase, pos) aplicada al par. |
| 2. Invariancia bajo índice de tríada. |
| 3. Reconstrucción desde subconjunto (LOO feature lookup sin etiquetas del held-out). |
| 4. **Control negativo:** al corromper una arista del grafo, (1) o (3) debe fallar. |
| |
| Sin el control negativo, un 1.0 podría ser tautología. |
| """ |
| from __future__ import annotations |
|
|
| import copy |
| import csv |
| import json |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
|
|
|
|
| def parse_node(node_id: str) -> tuple[str, int]: |
| parts = node_id.split("_") |
| return parts[1], int(parts[2][1:]) |
|
|
|
|
| def rule_label(src: str, tgt: str) -> str: |
| sp, spos = parse_node(src) |
| tp, tpos = parse_node(tgt) |
| if sp == tp: |
| return "none" |
| if tpos == 2 - spos: |
| return "mirrorOf" |
| if (spos in (0, 2) and tpos == 1) or (spos == 1 and tpos in (0, 2)): |
| return "creates" |
| return "none" |
|
|
|
|
| def feature_key(src: str, tgt: str) -> tuple: |
| sp, spos = parse_node(src) |
| tp, tpos = parse_node(tgt) |
| return (sp, spos, tp, tpos) |
|
|
|
|
| def self_regen_rate(rows: list[dict]) -> float: |
| mism = sum(1 for r in rows if rule_label(r["source"], r["target"]) != r["relation"]) |
| return 1.0 - mism / max(len(rows), 1) |
|
|
|
|
| def triad_invariant(rows: list[dict]) -> bool: |
| by_feat: dict[tuple, set[str]] = defaultdict(set) |
| for r in rows: |
| by_feat[feature_key(r["source"], r["target"])].add(r["relation"]) |
| return all(len(v) == 1 for v in by_feat.values()) |
|
|
|
|
| def subset_reconstruction(rows: list[dict]) -> bool: |
| for held in range(1, 14): |
| train: dict[tuple, str] = {} |
| test: list[tuple[tuple, str]] = [] |
| for r in rows: |
| key = feature_key(r["source"], r["target"]) |
| tid = int(r["triad_index"]) |
| if tid == held: |
| test.append((key, r["relation"])) |
| else: |
| train[key] = r["relation"] |
| if any(train.get(k) != lab for k, lab in test): |
| return False |
| return True |
|
|
|
|
| def corrupt_one_edge(rows: list[dict]) -> list[dict]: |
| """Cambia la etiqueta de la primera arista mirrorOf a none (grafo inválido).""" |
| out = copy.deepcopy(rows) |
| for r in out: |
| if r["relation"] == "mirrorOf": |
| r["relation"] = "none" |
| break |
| return out |
|
|
|
|
| def main() -> int: |
| rows = list( |
| csv.DictReader( |
| (ROOT / "datasets" / "relation_candidates.csv").open( |
| encoding="utf-8", newline="" |
| ) |
| ) |
| ) |
|
|
| regen = self_regen_rate(rows) |
| inv = triad_invariant(rows) |
| subset = subset_reconstruction(rows) |
|
|
| corrupted = corrupt_one_edge(rows) |
| |
| corrupted_regen = self_regen_rate(corrupted) |
| negative_control_detects = corrupted_regen < 1.0 |
|
|
| autonomy = regen == 1.0 and inv and subset |
| non_trivial = autonomy and negative_control_detects |
|
|
| report = { |
| "framing": ( |
| "Invariancia no trivial: el canónico regenera 1.0; un grafo con una " |
| "arista corrupta debe fallar el control negativo." |
| ), |
| "canonical": { |
| "self_regeneration_rate": round(regen, 6), |
| "triad_index_invariance": inv, |
| "subset_reconstruction": subset, |
| "autonomy_measurable": autonomy, |
| }, |
| "negative_control": { |
| "description": "primera arista mirrorOf relabelada a none", |
| "corrupted_self_regeneration_rate": round(corrupted_regen, 6), |
| "detects_corruption": negative_control_detects, |
| "interpretation": ( |
| "si detects_corruption es false, la métrica no distingue " |
| "grafo correcto de corrompido (tautología)" |
| ), |
| }, |
| "invariance_non_trivial": non_trivial, |
| } |
|
|
| out = ROOT / "experiments" / "results" / "invariance_metrics.json" |
| out.parent.mkdir(parents=True, exist_ok=True) |
| out.write_text(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") |
|
|
| print("Invariancia interna (con control negativo)") |
| print(f" Auto-regeneración canónica: {regen}") |
| print(f" Invariancia bajo índice de tríada: {inv}") |
| print(f" Reconstrucción desde subconjunto: {subset}") |
| print(f" Control negativo detecta corrupción: {negative_control_detects} (rate={corrupted_regen:.6f})") |
| print(f" Invariancia no trivial: {non_trivial}") |
| print(f" Informe: {out}") |
| return 0 if non_trivial else 1 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
