Add scaled WIRE synthetic proxy

train_synthetic.py

@@ -0,0 +1,170 @@
+"""Scaled GPU proxy for the paper's monochromatic-subgraph experiment.
+
+This is deliberately a small independent implementation: 5x5 grids with
+random edge deletions, node colours, a transformer regressor, and optional
+spectral WIRE rotations in every self-attention layer.  It is not claimed to
+reproduce the paper's full 10k/1k, 250-epoch run.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import random
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch import nn
+
+
+N = 25
+GRID_EDGES = [(r * 5 + c, r * 5 + c + 1) for r in range(5) for c in range(4)]
+GRID_EDGES += [(r * 5 + c, (r + 1) * 5 + c) for r in range(4) for c in range(5)]
+
+
+def make_dataset(count: int, seed: int, ape_dim: int = 3) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    rng = np.random.default_rng(seed)
+    laplacians = np.zeros((count, N, N), dtype=np.float32)
+    colours = rng.integers(0, 2, size=(count, N), dtype=np.int64)
+    labels = np.zeros(count, dtype=np.float32)
+    for b in range(count):
+        edges = [e for e in GRID_EDGES if rng.random() > rng.uniform(0.05, 0.45)]
+        # Keep the grid backbone connected enough for meaningful low modes.
+        a = np.zeros((N, N), dtype=np.float32)
+        for i, j in edges:
+            a[i, j] = a[j, i] = 1.0
+        laplacians[b] = np.diag(a.sum(axis=1)) - a
+        seen = np.zeros(N, dtype=bool)
+        best = 0
+        for start in range(N):
+            if seen[start]:
+                continue
+            colour = colours[b, start]
+            stack = [start]
+            seen[start] = True
+            size = 0
+            while stack:
+                node = stack.pop()
+                size += 1
+                for nxt in np.flatnonzero(a[node]):
+                    if not seen[nxt] and colours[b, nxt] == colour:
+                        seen[nxt] = True
+                        stack.append(int(nxt))
+            best = max(best, size)
+        labels[b] = best / N
+    _, vecs = np.linalg.eigh(laplacians)
+    # Include low-frequency spectral coordinates as APE inputs for both arms;
+    # WIRE uses the same coordinates to generate rotations.
+    spectral = vecs[:, :, : max(ape_dim, 3)]
+    colour_onehot = np.eye(2, dtype=np.float32)[colours]
+    x = np.concatenate([colour_onehot, spectral], axis=-1).astype(np.float32)
+    return torch.from_numpy(x), torch.from_numpy(labels), torch.from_numpy(spectral[:, :, :ape_dim].astype(np.float32))
+
+
+class WireAttention(nn.Module):
+    def __init__(self, d_model: int, heads: int, wire_dim: int):
+        super().__init__()
+        assert d_model % heads == 0 and (d_model // heads) % 2 == 0
+        self.heads = heads
+        self.head_dim = d_model // heads
+        self.wire_dim = wire_dim
+        self.qkv = nn.Linear(d_model, 3 * d_model)
+        self.out = nn.Linear(d_model, d_model)
+        self.freq = nn.Parameter(torch.randn(heads, self.head_dim // 2, max(wire_dim, 1)) * 0.15)
+
+    def forward(self, x: torch.Tensor, spectral: torch.Tensor) -> torch.Tensor:
+        batch, nodes, d_model = x.shape
+        q, k, v = self.qkv(x).chunk(3, dim=-1)
+        q = q.view(batch, nodes, self.heads, self.head_dim).transpose(1, 2)
+        k = k.view(batch, nodes, self.heads, self.head_dim).transpose(1, 2)
+        v = v.view(batch, nodes, self.heads, self.head_dim).transpose(1, 2)
+        if self.wire_dim:
+            angles = torch.einsum("bnm,hdm->bhnd", spectral[..., : self.wire_dim], self.freq[..., : self.wire_dim])
+            def rotate(z: torch.Tensor) -> torch.Tensor:
+                z = z.view(batch, self.heads, nodes, self.head_dim // 2, 2)
+                c, s = angles.cos(), angles.sin()
+                x0, x1 = z[..., 0], z[..., 1]
+                return torch.stack([c * x0 - s * x1, s * x0 + c * x1], dim=-1).flatten(-2)
+            q, k = rotate(q), rotate(k)
+        weights = torch.softmax(q @ k.transpose(-1, -2) / self.head_dim**0.5, dim=-1)
+        return self.out((weights @ v).transpose(1, 2).reshape(batch, nodes, d_model))
+
+
+class Block(nn.Module):
+    def __init__(self, d_model: int, heads: int, wire_dim: int):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(d_model)
+        self.attn = WireAttention(d_model, heads, wire_dim)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.ff = nn.Sequential(nn.Linear(d_model, 2 * d_model), nn.GELU(), nn.Linear(2 * d_model, d_model))
+
+    def forward(self, x: torch.Tensor, spectral: torch.Tensor) -> torch.Tensor:
+        x = x + self.attn(self.norm1(x), spectral)
+        return x + self.ff(self.norm2(x))
+
+
+class GraphTransformer(nn.Module):
+    def __init__(self, input_dim: int, wire_dim: int):
+        super().__init__()
+        self.embed = nn.Linear(input_dim, 32)
+        self.blocks = nn.ModuleList([Block(32, 4, wire_dim) for _ in range(2)])
+        self.head = nn.Sequential(nn.LayerNorm(32), nn.Linear(32, 1))
+
+    def forward(self, x: torch.Tensor, spectral: torch.Tensor) -> torch.Tensor:
+        h = self.embed(x)
+        for block in self.blocks:
+            h = block(h, spectral)
+        return self.head(h.mean(dim=1)).squeeze(-1)
+
+
+def train_arm(train: tuple[torch.Tensor, ...], test: tuple[torch.Tensor, ...], wire_dim: int, seed: int, device: torch.device) -> float:
+    torch.manual_seed(seed)
+    model = GraphTransformer(train[0].shape[-1], wire_dim).to(device)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-3, weight_decay=1e-4)
+    x, y, s = [v.to(device) for v in train]
+    xt, yt, st = [v.to(device) for v in test]
+    for _ in range(80):
+        order = torch.randperm(len(x), device=device)
+        for idx in order.split(64):
+            pred = model(x[idx], s[idx])
+            loss = ((pred - y[idx]) ** 2).mean()
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            optimizer.step()
+    model.eval()
+    with torch.no_grad():
+        rmse = float(torch.sqrt(((model(xt, st) - yt) ** 2).mean()).cpu())
+    return rmse
+
+
+def main() -> None:
+    start = time.time()
+    random.seed(18382)
+    np.random.seed(18382)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    train = make_dataset(1600, 18382)
+    test = make_dataset(400, 19382)
+    results = {
+        "paper": "https://huggingface.co/papers/2509.22259",
+        "job_proxy": "monochromatic-subgraph; 1,600/400 graphs vs paper 10,000/1,000; 80 vs 250 epochs; 2-layer 32d model vs 4-layer 32d; 2 seeds",
+        "device": str(device),
+        "baseline_rmse": [],
+        "wire_rmse": [],
+    }
+    for seed in (0, 1):
+        results["baseline_rmse"].append(train_arm(train, test, 0, seed, device))
+        results["wire_rmse"].append(train_arm(train, test, 3, seed, device))
+    results["baseline_mean"] = float(np.mean(results["baseline_rmse"]))
+    results["wire_mean"] = float(np.mean(results["wire_rmse"]))
+    results["relative_rmse_change_pct"] = 100 * (results["wire_mean"] / results["baseline_mean"] - 1)
+    results["wall_seconds"] = time.time() - start
+    out_dir = Path("/data") if Path("/data").exists() else Path(".")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    (out_dir / "synthetic_results.json").write_text(json.dumps(results, indent=2) + "\n")
+    print(json.dumps(results, indent=2))
+
+
+if __name__ == "__main__":
+    main()