| |
| """PI-HGAT-T y ablaciones: evaluación empírica estructural de tríadas IOM. |
| |
| PI-HGAT-T es la implementación de referencia del clasificador de relaciones del marco. |
| Las etiquetas de clase proceden de reglas RDF/SHACL explícitas y se evalúan bajo |
| leave-one-triad-out, ablaciones y baselines. |
| """ |
| from __future__ import annotations |
|
|
| import csv |
| import json |
| import platform |
| import random |
| import time |
| from pathlib import Path |
|
|
| import torch |
| from torch import nn |
| from torch.nn import functional as F |
|
|
| ROOT = Path(__file__).resolve().parents[2] |
| CONFIG = json.loads((ROOT / "experiments" / "config.json").read_text(encoding="utf-8")) |
| CLASSES = ("none", "mirrorOf", "creates") |
| CLASS_ID = {name: i for i, name in enumerate(CLASSES)} |
|
|
|
|
| def seed_everything(seed: int) -> None: |
| random.seed(seed) |
| torch.manual_seed(seed) |
| torch.use_deterministic_algorithms(True) |
| torch.set_num_threads(1) |
|
|
|
|
| def features_for_node(node_id: str) -> list[float]: |
| """Codifica solo la fase y posición, sin etiqueta léxica ni número de tríada.""" |
| parts = node_id.split("_") |
| phase, position = parts[1], int(parts[2][1:]) |
| return [float(phase == "adv"), float(phase == "ret"), |
| float(position == 0), float(position == 1), float(position == 2)] |
|
|
|
|
| def parse_pair_index(node_id: str) -> int: |
| phase = node_id.split("_")[1] |
| position = int(node_id.split("_")[2][1:]) |
| return position if phase == "adv" else 3 + position |
|
|
|
|
| def read_data(): |
| nodes: dict[int, list[list[float]]] = {i: [None] * 6 for i in range(1, 14)} |
| with (ROOT / "datasets" / "triad_nodes.csv").open(encoding="utf-8", newline="") as handle: |
| for row in csv.DictReader(handle): |
| nodes[int(row["triad_index"])][parse_pair_index(row["node_id"])] = features_for_node(row["node_id"]) |
| pairs: dict[int, list[tuple[int, int, int]]] = {i: [] for i in range(1, 14)} |
| with (ROOT / "datasets" / "relation_candidates.csv").open(encoding="utf-8", newline="") as handle: |
| for row in csv.DictReader(handle): |
| pairs[int(row["triad_index"])].append((parse_pair_index(row["source"]), |
| parse_pair_index(row["target"]), |
| CLASS_ID[row["relation"]])) |
| assert all(all(feature is not None for feature in group) for group in nodes.values()) |
| return {k: torch.tensor(v, dtype=torch.float32) for k, v in nodes.items()}, pairs |
|
|
|
|
| class TypedGraphAttention(nn.Module): |
| """Atención multi-cabeza sobre los seis nodos de las dos fases de cada tríada.""" |
| def __init__(self, dim: int, heads: int): |
| super().__init__() |
| assert dim % heads == 0 |
| self.dim, self.heads, self.head_dim = dim, heads, dim // heads |
| self.query = nn.Linear(dim, dim, bias=False) |
| self.key = nn.Linear(dim, dim, bias=False) |
| self.value = nn.Linear(dim, dim, bias=False) |
| self.out = nn.Linear(dim, dim) |
| self.norm = nn.LayerNorm(dim) |
|
|
| def forward(self, x: torch.Tensor) -> torch.Tensor: |
| batch, n_nodes, _ = x.shape |
| def split(layer): |
| return layer(x).view(batch, n_nodes, self.heads, self.head_dim).transpose(1, 2) |
| q, k, v = split(self.query), split(self.key), split(self.value) |
| scores = torch.matmul(q, k.transpose(-2, -1)) / (self.head_dim ** 0.5) |
| weights = torch.softmax(scores, dim=-1) |
| attended = torch.matmul(weights, v).transpose(1, 2).contiguous().view(batch, n_nodes, self.dim) |
| return self.norm(x + self.out(attended)) |
|
|
|
|
| class PIHGATT(nn.Module): |
| """Codificador GAT de dos capas y decodificador para relación dirigida.""" |
| def __init__(self, dim: int = 32, heads: int = 4, input_dim: int = 5): |
| super().__init__() |
| self.encoder = nn.Linear(input_dim, dim) |
| self.attention1 = TypedGraphAttention(dim, heads) |
| self.attention2 = TypedGraphAttention(dim, heads) |
| self.decoder = nn.Sequential(nn.Linear(dim * 3, dim), nn.GELU(), nn.Linear(dim, len(CLASSES))) |
|
|
| def encode(self, x: torch.Tensor) -> torch.Tensor: |
| h = F.gelu(self.encoder(x)) |
| h = F.gelu(self.attention1(h)) |
| return self.attention2(h) |
|
|
| def forward(self, x: torch.Tensor, pairs: torch.Tensor) -> torch.Tensor: |
| h = self.encode(x) |
| src, dst = pairs[:, 0], pairs[:, 1] |
| left, right = h[:, src, :], h[:, dst, :] |
| return self.decoder(torch.cat((left, right, left * right), dim=-1)) |
|
|
|
|
| def admissible_relation(label: str, source: int, target: int) -> bool: |
| """Predicados de validez alineados con io:mirrorOf / io:creates en SHACL.""" |
| source_phase, source_pos = (0 if source < 3 else 1), source % 3 |
| target_phase, target_pos = (0 if target < 3 else 1), target % 3 |
| if source_phase == target_phase: |
| return False |
| if label == "mirrorOf": |
| return target_pos == 2 - source_pos |
| if label == "creates": |
| return (source_pos in (0, 2) and target_pos == 1) or (source_pos == 1 and target_pos in (0, 2)) |
| return True |
|
|
|
|
| def scores(gold: list[int], predicted: list[int]) -> dict: |
| matrix = [[0] * len(CLASSES) for _ in CLASSES] |
| for actual, guess in zip(gold, predicted): |
| matrix[actual][guess] += 1 |
| per_class, f1_values = {}, [] |
| for idx, name in enumerate(CLASSES): |
| tp = matrix[idx][idx] |
| fp = sum(matrix[row][idx] for row in range(len(CLASSES)) if row != idx) |
| fn = sum(matrix[idx][col] for col in range(len(CLASSES)) if col != idx) |
| precision = tp / (tp + fp) if tp + fp else 0.0 |
| recall = tp / (tp + fn) if tp + fn else 0.0 |
| f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0 |
| per_class[name] = {"precision": precision, "recall": recall, "f1": f1, "support": tp + fn} |
| f1_values.append(f1) |
| accuracy = sum(a == b for a, b in zip(gold, predicted)) / len(gold) |
| return {"accuracy": accuracy, "macro_f1": sum(f1_values) / len(f1_values), |
| "per_class": per_class, "confusion_matrix_rows_gold_cols_predicted": matrix} |
|
|
|
|
| def run_variant(name: str, columns: list[int], nodes, relations, cfg: dict) -> dict: |
| all_gold, all_pred, predicted_edges, fold_results = [], [], [], [] |
| pair_indices = torch.tensor([(s, t) for s in range(6) for t in range(6) if s != t], dtype=torch.long) |
| for held_out in sorted(nodes): |
| seed_everything(int(cfg["seed"]) + held_out - 1) |
| train_ids = [i for i in nodes if i != held_out] |
| x_train = torch.stack([nodes[i][:, columns] for i in train_ids]) |
| y_train = torch.tensor([label for i in train_ids for _s, _t, label in relations[i]], dtype=torch.long) |
| model = PIHGATT(int(cfg["hidden_dim"]), int(cfg["attention_heads"]), input_dim=len(columns)) |
| counts = torch.bincount(y_train, minlength=len(CLASSES)).float() |
| class_weights = (len(y_train) / (len(CLASSES) * counts.clamp_min(1))).float() |
| optimizer = torch.optim.AdamW(model.parameters(), lr=float(cfg["learning_rate"]), |
| weight_decay=float(cfg["weight_decay"])) |
| model.train() |
| for _epoch in range(int(cfg["epochs"])): |
| optimizer.zero_grad(set_to_none=True) |
| logits = model(x_train, pair_indices).reshape(-1, len(CLASSES)) |
| loss = F.cross_entropy(logits, y_train, weight=class_weights) |
| loss.backward() |
| optimizer.step() |
| model.eval() |
| with torch.no_grad(): |
| predicted = model(nodes[held_out][:, columns].unsqueeze(0), pair_indices).argmax(dim=-1).reshape(-1).tolist() |
| gold_map = {(src, dst): label for src, dst, label in relations[held_out]} |
| gold = [gold_map[(src, dst)] for src, dst in pair_indices.tolist()] |
| all_gold.extend(gold) |
| all_pred.extend(predicted) |
| for (src, dst), label_id in zip(pair_indices.tolist(), predicted): |
| if label_id: |
| label = CLASSES[label_id] |
| predicted_edges.append((held_out, src, dst, label)) |
| fold_results.append({"held_out_triad": held_out, |
| "accuracy": sum(a == b for a, b in zip(gold, predicted)) / len(gold)}) |
| report = scores(all_gold, all_pred) |
| by_class = report["per_class"] |
| compliant = sum(admissible_relation(label, source, target) |
| for _triad, source, target, label in predicted_edges) |
| edge_compliance = compliant / len(predicted_edges) if predicted_edges else 1.0 |
| metrics = { |
| "candidate_relation_accuracy": {"value": report["accuracy"], "property": "io:mirrorOf / io:creates; exact three-class labels"}, |
| "relation_macro_f1": {"value": report["macro_f1"], "property": "balanced F1 for none, io:mirrorOf and io:creates"}, |
| "mirrorOf_precision": {"value": by_class["mirrorOf"]["precision"], "property": "SHACL: reciprocal mirror; same triad; opposite phase; position reflection"}, |
| "mirrorOf_recall": {"value": by_class["mirrorOf"]["recall"], "property": "completeness of the io:mirrorOf edge set"}, |
| "mirrorOf_f1": {"value": by_class["mirrorOf"]["f1"], "property": "precision/recall of io:mirrorOf"}, |
| "creates_precision": {"value": by_class["creates"]["precision"], "property": "SHACL: same triad, opposite phase, four allowed position rules"}, |
| "creates_recall": {"value": by_class["creates"]["recall"], "property": "completeness of four creation rules"}, |
| "creates_f1": {"value": by_class["creates"]["f1"], "property": "precision/recall of io:creates"}, |
| "predicted_edge_rule_conformance": {"value": edge_compliance, "property": "SHACL phase/triad/position rules for predicted mirrorOf and creates", "predicted_edges": len(predicted_edges)}, |
| } |
| return {"variant": name, "feature_columns": columns, "metrics": metrics, |
| "per_class": by_class, "confusion_matrix_rows_gold_cols_predicted": report["confusion_matrix_rows_gold_cols_predicted"], |
| "folds": fold_results} |
|
|
|
|
| def run() -> dict: |
| cfg = CONFIG |
| nodes, relations = read_data() |
| candidates = [ |
| ("PI-HGAT-T_full_phase_and_position", [0, 1, 2, 3, 4]), |
| ("ablation_without_phase", [2, 3, 4]), |
| ("ablation_without_position", [0, 1]), |
| ] |
| start = time.time() |
| variants = [run_variant(name, columns, nodes, relations, cfg) for name, columns in candidates] |
| primary = variants[0] |
| gold_labels = [label for triad in relations.values() for _src, _dst, label in triad] |
| dataset = {"triads": 13, "nodes": 78, "directed_relation_candidates": len(gold_labels), |
| "gold_mirrorOf_edges": sum(label == CLASS_ID["mirrorOf"] for label in gold_labels), |
| "gold_creates_edges": sum(label == CLASS_ID["creates"] for label in gold_labels), |
| "gold_none_pairs": sum(label == CLASS_ID["none"] for label in gold_labels)} |
| report = { |
| "model": cfg["model_id"], |
| "model_definition": cfg["model_definition"], |
| "dataset": dataset, |
| "validation": "13-fold leave-one-triad-out; no lexical labels or triad index as model features", |
| "primary_metrics": primary["metrics"], |
| "experiments": variants, |
| "threshold_policy": "Empirical evaluation against deterministic RDF/SHACL target properties. Reference criterion is exact reconstruction (1.0); observed model and ablation scores quantify recoverability under leave-one-triad-out and are reported with confusion matrices and fold variability.", |
| "software": {"python": platform.python_version(), "pytorch": torch.__version__, "platform": platform.platform()}, |
| "configuration": cfg, |
| } |
| results_path = ROOT / "experiments" / "results" / "pi_hgat_t_metrics.json" |
| results_path.parent.mkdir(parents=True, exist_ok=True) |
| results_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") |
| log_path = ROOT / "experiments" / "logs" / "pi_hgat_t.log" |
| log_path.parent.mkdir(parents=True, exist_ok=True) |
| lines = ["PI-HGAT-T / ablation suite", f"Python={platform.python_version()} PyTorch={torch.__version__}", |
| f"seed={cfg['seed']} folds=13 epochs={cfg['epochs']} candidates={len(gold_labels)}"] |
| for variant in variants: |
| m = variant["metrics"] |
| lines.append(f"{variant['variant']}: accuracy={m['candidate_relation_accuracy']['value']:.6f} macro_f1={m['relation_macro_f1']['value']:.6f} " |
| f"mirrorOf_f1={m['mirrorOf_f1']['value']:.6f} creates_f1={m['creates_f1']['value']:.6f} " |
| f"rule_conformance={m['predicted_edge_rule_conformance']['value']:.6f}") |
| lines.append(f"runtime_seconds={time.time() - start:.3f}") |
| log_path.write_text("\n".join(lines) + "\n", encoding="utf-8") |
| print("\n".join(lines)) |
| print(f"Resultados: {results_path}") |
| return report |
|
|
|
|
| if __name__ == "__main__": |
| run() |
|
|
