repr_train.py

# /// script
# requires-python = ">=3.10"
# dependencies = ["torch", "numpy", "huggingface_hub"]
# ///
"""Claim 1 (paper Table 2): performance-aware leaf-cell layout representation.

Re-implements the GenLeaf representation stack of Section 3.1:

  * placement heterogeneous graph (PHG) with cell and net vertices, cell-net
    and cell-cell adjacency edges, features of Table 1;
  * GraphSAGE processing exactly as Algorithm 1 (linear projection, K SAGEConv
    layers with neighbourhood sampling + mean aggregation, BatchNorm, dropout,
    residual connections, mean+max pooling, MLP);
  * routing image with net / track / blank regions, discrete Laplacian
    sharpening (Eq. 2-3) and a CNN encoder;
  * multi-head-attention fusion of the two branches;
  * performance-aware supervised loss (Eq. 4) plus the downstream head that
    predicts the (track, wirelength, via) vector.

Baselines: a CircuitGNN-style topological+geometric GNN (no routing branch, no
performance-aware embedding loss) and a DeepLayout-style masked self-supervised
encoder with a linear probe.  Reported metrics are MSE / MAE of the three-metric
prediction on a held-out split, on z-scored targets (as in the paper, where the
errors are ~1.0).
"""
from __future__ import annotations

import argparse, json, math, os, random, sys, time

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

MAX_TRACKS, MAX_COLS, N_LAYERS = 14, 56, 2
EMB = 128


# ----------------------------------------------------------------- featurizing
def build_sample(case, order, flip, leafpnr):
    pins, row_w = leafpnr.place(case, order, flip)
    spans = leafpnr._spans(pins)
    assign, n_tracks, layers = leafpnr.channel_route(spans)
    n = case.n
    nets = case.nets
    nc, nn_ = n, len(nets)

    # --- PHG vertex features (Table 1)
    xs = []
    pos = {}
    x = 0
    for slot, ci in enumerate(order):
        pos[ci] = x
        x += case.cells[ci].width
    for ci, c in enumerate(case.cells):
        oh = [0.0] * 8
        oh[min(c.width, 7)] = 1.0                      # height & width one-hot
        px = [p[1] for p in c.pins]
        xs.append(oh + [c.height / 4.0, c.n_pins / 6.0,
                        pos[ci] / max(row_w, 1),
                        (np.mean(px) if px else 0) / max(c.width, 1),
                        1.0 if flip[order.index(ci)] == "MY" else 0.0,
                        1.0, 0.0])                     # rotation R, is_cell flag
    npins = case.net_pins()
    for net in nets:
        ps = pins[net]
        sx = (max(p[0] for p in ps) - min(p[0] for p in ps)) if ps else 0
        sy = (max(p[1] for p in ps) - min(p[1] for p in ps)) if ps else 0
        xs.append([0.0] * 8 + [0.0, npins[net] / 6.0, 0.0, 0.0, 0.0, 0.0, 1.0]
                  if False else
                  [0.0] * 8 + [0.0, npins[net] / 6.0, sx / max(row_w, 1),
                               sy / 4.0, 0.0, 0.0, 1.0])
    V = np.array(xs, dtype=np.float32)

    # --- PHG edges
    A = np.zeros((nc + nn_, nc + nn_), dtype=np.float32)
    for ci, c in enumerate(case.cells):
        for (net, _, _) in c.pins:                     # cell-net connection
            j = nc + nets.index(net)
            A[ci, j] = A[j, ci] = 1.0
    for a in range(n):                                 # cell-cell adjacency
        for b in range(n):
            if a != b and abs(pos[a] - pos[b]) <= 4:
                A[a, b] = 1.0

    # --- routing image: net / track / blank regions, per layer
    img = np.zeros((N_LAYERS, MAX_TRACKS, MAX_COLS), dtype=np.float32)
    ytr = {}
    idx = 0
    for l in range(N_LAYERS):
        for k in range(len(layers[l])):
            ytr[(l, k)] = idx
            idx += 1
    for l in range(N_LAYERS):
        for k in range(len(layers[l])):
            r = ytr[(l, k)]
            if r < MAX_TRACKS:
                img[l, r, :min(row_w, MAX_COLS)] = 0.25      # track region
    for i, net in enumerate(spans):
        l, k = assign[net]
        r = ytr[(l, k)]
        x0, x1 = spans[net]
        if r < MAX_TRACKS:
            img[l, r, min(x0, MAX_COLS - 1):min(x1 + 1, MAX_COLS)] = \
                0.5 + 0.5 * ((i % 7) + 1) / 8.0                # net region
    m = leafpnr.evaluate(case, order, flip)
    return V, A, img, np.array([m["track"], m["wl"], m["via"]], dtype=np.float32)


def laplacian_sharpen(img, c=0.5):
    """Eq. (2)-(3): g = f - c * laplacian(f), discrete 4-neighbour operator."""
    k = torch.tensor([[0., 1., 0.], [1., -4., 1.], [0., 1., 0.]],
                     device=img.device).view(1, 1, 3, 3).repeat(img.shape[1], 1, 1, 1)
    lap = F.conv2d(img, k, padding=1, groups=img.shape[1])
    return img - c * lap


# --------------------------------------------------------------------- models
class SAGE(nn.Module):
    """Algorithm 1: GraphSAGE-based PHG processing."""

    def __init__(self, fin, hid=EMB, K=3, dropout=0.1, sample=8):
        super().__init__()
        self.lin = nn.Linear(fin, hid)
        self.self_w = nn.ModuleList(nn.Linear(hid, hid) for _ in range(K))
        self.nb_w = nn.ModuleList(nn.Linear(hid, hid) for _ in range(K))
        self.bn = nn.ModuleList(nn.BatchNorm1d(hid) for _ in range(K))
        self.K, self.drop, self.sample = K, nn.Dropout(dropout), sample
        self.out = nn.Sequential(nn.Linear(2 * hid, hid), nn.ReLU(), nn.Linear(hid, hid))

    def forward(self, V, A, mask):
        h = self.lin(V)
        deg = A.sum(-1, keepdim=True).clamp(min=1)
        for k in range(self.K):
            if self.training and self.sample:                 # neighbourhood sampling
                keep = (torch.rand_like(A) < (self.sample / deg).clamp(max=1.0)).float()
                Ak = A * keep
            else:
                Ak = A
            agg = torch.bmm(Ak, h) / Ak.sum(-1, keepdim=True).clamp(min=1)
            hn = self.self_w[k](h) + self.nb_w[k](agg)
            B, N, D = hn.shape
            hn = self.bn[k](hn.reshape(B * N, D)).reshape(B, N, D)
            hn = self.drop(F.relu(hn))
            h = hn + h if k > 0 else hn                       # residual
        m = mask.unsqueeze(-1)
        mean = (h * m).sum(1) / m.sum(1).clamp(min=1)
        mx = (h + (m - 1) * 1e9).max(1).values
        return self.out(torch.cat([mean, mx], -1))


class RoutingCNN(nn.Module):
    def __init__(self, hid=EMB):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(N_LAYERS, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(64, hid, 3, padding=1), nn.ReLU(), nn.AdaptiveAvgPool2d(1))

    def forward(self, img):
        return self.net(laplacian_sharpen(img)).flatten(1)


class GenLeafRepr(nn.Module):
    """GraphSAGE + routing CNN + attention fusion + prediction head."""

    def __init__(self, fin, use_routing=True, hid=EMB):
        super().__init__()
        self.sage = SAGE(fin, hid)
        self.use_routing = use_routing
        if use_routing:
            self.cnn = RoutingCNN(hid)
            self.attn = nn.MultiheadAttention(hid, 4, batch_first=True)
            self.proj = nn.Linear(hid, hid)
        self.head = nn.Sequential(nn.Linear(hid, hid), nn.ReLU(), nn.Linear(hid, 3))

    def embed(self, V, A, mask, img):
        g = self.sage(V, A, mask)
        if not self.use_routing:
            return g
        r = self.cnn(img)
        toks = torch.stack([g, r], 1)
        a, _ = self.attn(toks, toks, toks)
        return self.proj(a.mean(1) + toks.mean(1))

    def forward(self, V, A, mask, img):
        e = self.embed(V, A, mask, img)
        return e, self.head(e)


class DeepLayoutProxy(nn.Module):
    """Mask-strategy self-supervised encoder (DeepLayout-style) + linear probe."""

    def __init__(self, fin, hid=EMB):
        super().__init__()
        self.sage = SAGE(fin, hid)
        self.recon = nn.Linear(hid, fin)
        self.probe = nn.Linear(hid, 3)

    def forward(self, V, A, mask, img=None):
        e = self.sage(V, A, mask)
        return e, self.probe(e)


# ----------------------------------------------------------------------- data
def collate(samples, device):
    N = max(s[0].shape[0] for s in samples)
    fin = samples[0][0].shape[1]
    B = len(samples)
    V = np.zeros((B, N, fin), np.float32)
    A = np.zeros((B, N, N), np.float32)
    M = np.zeros((B, N), np.float32)
    I = np.zeros((B, N_LAYERS, MAX_TRACKS, MAX_COLS), np.float32)
    Y = np.zeros((B, 3), np.float32)
    for i, (v, a, img, y) in enumerate(samples):
        k = v.shape[0]
        V[i, :k] = v
        A[i, :k, :k] = a
        M[i, :k] = 1
        I[i] = img
        Y[i] = y
    t = lambda x: torch.tensor(x, device=device)
    return t(V), t(A), t(M), t(I), t(Y)


def pairwise_loss(e, y):
    """Eq. (4): (sim(e_i,e_j) - sim(m_i,m_j))^2 over all pairs in the batch."""
    en = F.normalize(e, dim=-1)
    yn = F.normalize(y, dim=-1)
    return ((en @ en.T - yn @ yn.T) ** 2).mean()


def run(model, data, device, epochs, lr, pair_w, ssl=False, bs=32, log=print):
    opt = torch.optim.AdamW(model.parameters(), lr=lr)
    tr, va = data
    for ep in range(epochs):
        model.train()
        random.shuffle(tr)
        tot = 0.0
        for i in range(0, len(tr), bs):
            batch = tr[i:i + bs]
            if len(batch) < 2:
                continue
            V, A, M, I, Y = collate(batch, device)
            if ssl and ep < epochs // 2:            # masked reconstruction phase
                Vm = V * (torch.rand_like(V[..., :1]) > 0.3).float()
                e = model.sage(Vm, A, M)
                loss = F.mse_loss(model.recon(e).unsqueeze(1).expand_as(V) * M.unsqueeze(-1),
                                  V * M.unsqueeze(-1))
            else:
                e, p = model(V, A, M, I)
                loss = F.mse_loss(p, Y) + pair_w * pairwise_loss(e, Y)
            opt.zero_grad()
            loss.backward()
            opt.step()
            tot += float(loss) * len(batch)
        if (ep + 1) % 5 == 0:
            log(f"  epoch {ep+1}/{epochs} train_loss={tot/len(tr):.4f}")
    model.eval()
    se, ae, k = 0.0, 0.0, 0
    with torch.no_grad():
        for i in range(0, len(va), bs):
            batch = va[i:i + bs]
            V, A, M, I, Y = collate(batch, device)
            _, p = model(V, A, M, I)
            se += float(((p - Y) ** 2).sum())
            ae += float((p - Y).abs().sum())
            k += Y.numel()
    return se / k, ae / k


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--data", default="data")
    ap.add_argument("--epochs", type=int, default=40)
    ap.add_argument("--lr", type=float, default=1e-3)
    ap.add_argument("--layouts-per-case", type=int, default=5)
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--out", default="repr_results.json")
    ap.add_argument("--repo", default="", help="optional HF dataset repo to pull data from")
    args = ap.parse_args()

    if args.repo:
        from huggingface_hub import snapshot_download
        args.data = snapshot_download(args.repo, repo_type="dataset")
    sys.path.insert(0, args.data)
    sys.path.insert(0, os.path.join(args.data, "scripts"))
    import leafpnr  # noqa: E402

    torch.manual_seed(args.seed); random.seed(args.seed); np.random.seed(args.seed)
    device = "cuda" if torch.cuda.is_available() else "cpu"
    print("device:", device, torch.cuda.get_device_name(0) if device == "cuda" else "")

    cases = leafpnr.load_cases(os.path.join(args.data, "cases_repr.json"))
    rng = random.Random(args.seed)
    samples = []
    for c in cases:
        o, f = leafpnr.expert_designer(c)
        samples.append(build_sample(c, o, f, leafpnr))
        for _ in range(args.layouts_per_case - 1):
            oo = list(range(c.n)); rng.shuffle(oo)
            ff = [rng.choice(["R0", "MY"]) for _ in range(c.n)]
            samples.append(build_sample(c, oo, ff, leafpnr))
    print(f"{len(samples)} layouts from {len(cases)} cases")

    Y = np.stack([s[3] for s in samples])
    mu, sd = Y.mean(0), Y.std(0) + 1e-9
    samples = [(v, a, i, (y - mu) / sd) for (v, a, i, y) in samples]
    rng.shuffle(samples)
    cut = int(0.8 * len(samples))
    data = (samples[:cut], samples[cut:])
    fin = samples[0][0].shape[1]

    results = {}
    configs = [
        ("GenLeaf (ours)", lambda: GenLeafRepr(fin, True), dict(pair_w=1.0, ssl=False)),
        ("CircuitGNN (proxy)", lambda: GenLeafRepr(fin, False), dict(pair_w=0.0, ssl=False)),
        ("DeepLayout (proxy)", lambda: DeepLayoutProxy(fin), dict(pair_w=0.0, ssl=True)),
    ]
    for name, ctor, kw in configs:
        t0 = time.time()
        torch.manual_seed(args.seed)
        model = ctor().to(device)
        print(f"[{name}] params={sum(p.numel() for p in model.parameters())}")
        mse, mae = run(model, data, device, args.epochs, args.lr, **kw)
        results[name] = {"MSE": round(mse, 4), "MAE": round(mae, 4),
                         "seconds": round(time.time() - t0, 1)}
        print(f"[{name}] MSE={mse:.4f} MAE={mae:.4f} ({time.time()-t0:.0f}s)", flush=True)

    g = results["GenLeaf (ours)"]
    for b in ("CircuitGNN (proxy)", "DeepLayout (proxy)"):
        results[b]["genleaf_mse_reduction_pct"] = round(
            100 * (results[b]["MSE"] - g["MSE"]) / results[b]["MSE"], 1)
        results[b]["genleaf_mae_reduction_pct"] = round(
            100 * (results[b]["MAE"] - g["MAE"]) / results[b]["MAE"], 1)
    results["_meta"] = {"n_layouts": len(samples), "epochs": args.epochs,
                        "device": device, "seed": args.seed,
                        "paper_table2": {"GenLeaf": [0.849, 0.722],
                                         "CircuitGNN": [1.287, 0.815],
                                         "DeepLayout": [1.324, 0.969]}}
    print(json.dumps(results, indent=1))
    json.dump(results, open(args.out, "w", encoding="utf-8"), indent=1)
    print("wrote", args.out)


if __name__ == "__main__":
    main()