| |
| """Clasificadores base para comparar con PI-HGAT-T. |
| |
| Incluye: |
| - reglas deterministas (oracle de la especificación) |
| - regresión logística sobre features one-hot de fase+posición |
| - MLP sin estructura de grafo |
| """ |
| from __future__ import annotations |
|
|
| import csv |
| import json |
| import random |
| from pathlib import Path |
|
|
| import numpy as np |
| import torch |
| from torch import nn |
| from torch.nn import functional as F |
|
|
| ROOT = Path(__file__).resolve().parents[2] |
| CLASSES = ("none", "mirrorOf", "creates") |
| CLASS_ID = {n: i for i, n in enumerate(CLASSES)} |
|
|
|
|
| def seed_everything(seed: int = 20261008) -> None: |
| random.seed(seed) |
| np.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]: |
| 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_pairs(): |
| pairs: dict[int, list[tuple[str, str, int]]] = {i: [] for i in range(1, 14)} |
| with (ROOT / "datasets" / "relation_candidates.csv").open(encoding="utf-8", newline="") as fh: |
| for row in csv.DictReader(fh): |
| pairs[int(row["triad_index"])].append( |
| (row["source"], row["target"], CLASS_ID[row["relation"]]) |
| ) |
| return pairs |
|
|
|
|
| def admissible(label: str, source: int, target: int) -> bool: |
| 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 deterministic_rule_predict(src_idx: int, tgt_idx: int) -> int: |
| if admissible("mirrorOf", src_idx, tgt_idx): |
| return CLASS_ID["mirrorOf"] |
| if admissible("creates", src_idx, tgt_idx): |
| return CLASS_ID["creates"] |
| return CLASS_ID["none"] |
|
|
|
|
| def pair_feature(src_id: str, tgt_id: str) -> list[float]: |
| return features_for_node(src_id) + features_for_node(tgt_id) |
|
|
|
|
| def scores(gold: list[int], pred: list[int]) -> dict: |
| matrix = [[0] * 3 for _ in range(3)] |
| for a, b in zip(gold, pred): |
| matrix[a][b] += 1 |
| per_class = {} |
| f1s = [] |
| for i, name in enumerate(CLASSES): |
| tp = matrix[i][i] |
| fp = sum(matrix[r][i] for r in range(3) if r != i) |
| fn = sum(matrix[i][c] for c in range(3) if c != i) |
| prec = tp / (tp + fp) if tp + fp else 0.0 |
| rec = tp / (tp + fn) if tp + fn else 0.0 |
| f1 = 2 * prec * rec / (prec + rec) if prec + rec else 0.0 |
| per_class[name] = {"precision": prec, "recall": rec, "f1": f1, "support": tp + fn} |
| f1s.append(f1) |
| acc = sum(a == b for a, b in zip(gold, pred)) / max(len(gold), 1) |
| return { |
| "accuracy": round(acc, 6), |
| "macro_f1": round(sum(f1s) / 3, 6), |
| "per_class": per_class, |
| "confusion_matrix": matrix, |
| } |
|
|
|
|
| class SoftmaxRegression(nn.Module): |
| def __init__(self, in_dim: int, n_classes: int = 3): |
| super().__init__() |
| self.linear = nn.Linear(in_dim, n_classes) |
|
|
| def forward(self, x): |
| return self.linear(x) |
|
|
|
|
| class SimpleMLP(nn.Module): |
| def __init__(self, in_dim: int, hidden: int = 32, n_classes: int = 3): |
| super().__init__() |
| self.net = nn.Sequential( |
| nn.Linear(in_dim, hidden), |
| nn.GELU(), |
| nn.Linear(hidden, hidden), |
| nn.GELU(), |
| nn.Linear(hidden, n_classes), |
| ) |
|
|
| def forward(self, x): |
| return self.net(x) |
|
|
|
|
| def train_sklearn_like(model: nn.Module, X: torch.Tensor, y: torch.Tensor, |
| epochs: int = 200, lr: float = 0.01) -> None: |
| opt = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4) |
| for _ in range(epochs): |
| opt.zero_grad() |
| logits = model(X) |
| loss = F.cross_entropy(logits, y) |
| loss.backward() |
| opt.step() |
|
|
|
|
| def leave_one_triad_out(pairs: dict, model_factory, epochs: int = 200) -> dict: |
| all_gold, all_pred = [], [] |
| fold_accs = [] |
| for held in sorted(pairs): |
| seed_everything(20261008 + held - 1) |
| train_X, train_y = [], [] |
| test_X, test_y, test_meta = [], [], [] |
| for tid, plist in pairs.items(): |
| for src, tgt, label in plist: |
| feat = pair_feature(src, tgt) |
| if tid == held: |
| test_X.append(feat) |
| test_y.append(label) |
| test_meta.append((src, tgt)) |
| else: |
| train_X.append(feat) |
| train_y.append(label) |
| Xtr = torch.tensor(train_X, dtype=torch.float32) |
| ytr = torch.tensor(train_y, dtype=torch.long) |
| Xte = torch.tensor(test_X, dtype=torch.float32) |
| model = model_factory(Xtr.shape[1]) |
| train_sklearn_like(model, Xtr, ytr, epochs=epochs) |
| with torch.no_grad(): |
| pred = model(Xte).argmax(dim=-1).tolist() |
| all_gold.extend(test_y) |
| all_pred.extend(pred) |
| fold_accs.append(sum(a == b for a, b in zip(test_y, pred)) / max(len(test_y), 1)) |
| result = scores(all_gold, all_pred) |
| result["fold_accuracies"] = fold_accs |
| result["fold_accuracy_mean"] = round(float(np.mean(fold_accs)), 6) |
| result["fold_accuracy_std"] = round(float(np.std(fold_accs)), 6) |
| return result |
|
|
|
|
| def run_deterministic(pairs: dict) -> dict: |
| gold, pred = [], [] |
| for plist in pairs.values(): |
| for src, tgt, label in plist: |
| gold.append(label) |
| s_idx = parse_pair_index(src) |
| t_idx = parse_pair_index(tgt) |
| pred.append(deterministic_rule_predict(s_idx, t_idx)) |
| return scores(gold, pred) |
|
|
|
|
| def run() -> dict: |
| seed_everything() |
| pairs = read_pairs() |
| report = { |
| "description": "Comparación de PI-HGAT-T con clasificadores base sobre el mismo leave-one-triad-out", |
| "baselines": {}, |
| } |
| report["baselines"]["deterministic_rules"] = { |
| "description": "Oracle que aplica exactamente las reglas SHACL de mirrorOf/creates", |
| "metrics": run_deterministic(pairs), |
| } |
| report["baselines"]["logistic_regression"] = { |
| "description": "Softmax linear sobre concatenación de one-hot fase+posición (10 dim)", |
| "metrics": leave_one_triad_out(pairs, lambda d: SoftmaxRegression(d), epochs=300), |
| } |
| report["baselines"]["mlp_no_graph"] = { |
| "description": "MLP de dos capas ocultas sin mensaje-passing ni atención", |
| "metrics": leave_one_triad_out(pairs, lambda d: SimpleMLP(d, hidden=32), epochs=200), |
| } |
| out = ROOT / "experiments" / "results" / "baselines_comparison.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("Baselines escritos en", out) |
| for name, block in report["baselines"].items(): |
| m = block["metrics"] |
| print(f" {name}: accuracy={m['accuracy']:.4f} macro_f1={m['macro_f1']:.4f}") |
| return report |
|
|
|
|
| if __name__ == "__main__": |
| run() |
|
|
