GAT-Steiner Algorithm for RSMT Prediction

• GAT-Steiner Algorithm is a GPU-accelerable graph attention network approach that predicts rectilinear Steiner minimal trees in VLSI designs.
• It reformulates the RSMT problem as a node-classification task on a Hanan grid using multi-head attention and deep learning techniques.
• The method achieves superior accuracy and substantial speedup over traditional solvers, while also enabling scalable batch processing on modern GPUs.

The GAT-Steiner Algorithm is a high-accuracy, GPU-parallelizable approach for predicting rectilinear Steiner minimal trees (RSMTs) using graph attention networks, applicable to VLSI placement and routing, and providing substantial computational and solution quality advantages over traditional exact and heuristic methods. The term "GAT-Steiner" refers to both a neural approach for RSMT prediction (Onal et al., 2024) and, in an earlier context, to a class of goal-oriented Steiner tree algorithms utilizing dynamic programming with A*-style admissible heuristics and pruning (Hougardy et al., 2014). The deep learning formulation delivers strong prediction accuracy for Steiner-point placement, while the combinatorial algorithm achieves scalability and speed through intelligent search-space reduction.

1. Problem Formulation and Historical Background

The rectilinear Steiner minimum tree (RSMT) problem seeks, for a set of $k$ terminal points $T=\{t_1,...,t_k\}$ in the plane, a rectilinear tree (with only horizontal or vertical edges) that spans $T$ and possibly includes additional "Steiner" points $S$, such that the total wire length is minimized. This problem is NP-hard; polynomial-time algorithms are not known unless P=NP. Traditional algorithms include:

• Exact solvers: e.g., GeoSteiner via integer linear programming or branch-and-cut, which exhibit exponential runtime for $k \gg 20$.
• Heuristics: e.g., FLUTE, SALT, which trade optimality for runtime and can suffer from suboptimal results and high-variance outliers in wire length.

GAT-Steiner breaks from both classes by reformulating RSMT as a graph learning problem using a graph attention network (GAT) and by leveraging large-scale batch inference via GPUs to accelerate computation and improve reliability (Onal et al., 2024).

2. Graph Construction and GNN Problem Setup

GAT-Steiner constructs its input graph $G$ by mapping all Hanan-grid intersections derived from terminal x- and y-coordinates to nodes, such that:

• Nodes ($V$):
  • Terminal points $(x_i,y_i)$: nodes with features $f_i^{(0)} = [x_i, y_i, 1]$.
  • Candidate Steiner points $(x_i, y_j),\ i \neq j$: nodes with features $f_j^{(0)} = [x_i, y_j, 0]$.
• Edges ($E$):
  • Connect any pair $(u,v)$ at Manhattan distance 1 (grid step), encoded in adjacency matrix $A$.
• Node feature vectors: 3-dimensional, distinguishing type (terminal/Steiner).
• Edge features: None are used beyond adjacency.

This formulation casts the RSMT as a node-classification problem: predict $y_v \in \{0,1\}$ for each node $v$, with $y_v=1$ indicating use as a Steiner point in the optimal RSMT. The function $f_\theta:G \to [0,1]^{|V|}$ is learned to approximate the indicator labels generated by GeoSteiner (Onal et al., 2024).

3. Graph Attention Architecture and Prediction Mechanism

The GAT-Steiner network comprises $L=2$ layers of GATConv. At each layer $\ell$ and for each multi-attention head $k$:

• Linear transform: $\hat h_i^k = W^{k\ell} h_i^{(\ell)}$, with $$W^{k\ell} \in \mathbb{R}^{d_{\ell+1} \times d_\ell}$$
• Attention logits: $$e_{ij}^k = \text{LeakyReLU}(a^{k\ell\top}[\hat h_i^k \Vert \hat h_j^k])$$ for neighborhood aggregation
• Softmax normalization over neighbors
• Feature update: $$h_i^{(\ell+1),k} = \sum_{j \in \mathcal{N}(i)} \alpha_{ij}^k \cdot \hat h_j^k$$
• Multi-head aggregation: Concatenate across heads, then apply ELU nonlinearity
• Final prediction: In the last layer, use a single attention head and Sigmoid activation:

$$h_i^{(L)} = \sigma\left(\sum_{j \in \mathcal{N}(i)} \alpha_{ij} W^{1,L-1} h_j^{(L-1)}\right)$$

Output $p_i = h_i^{(L)}$ is the predicted probability for node $i$ being a Steiner point.

Predicted points above threshold ($p_i \geq 0.5$) form the candidate Steiner set. A refinement step removes spurious degree-2 predicted Steiner nodes by iterative deletion and MST recomputation, strictly preserving or improving wire length (Onal et al., 2024).

4. Training Pipeline and Loss Objective

Supervised training is performed on labeled (graph, label) pairs:

• Label source: GeoSteiner-generated optimal Steiner-point labels on random nets ($k=3..50$), with coordinates normalized to $[0,100]$.
• Objective: Binary Focal Loss (BFL) with L2 regularization:

$$\ell_i = \begin{cases} - \alpha (1-p_i)^\gamma \log p_i & \text{if } y_i = 1 \ - (1-\alpha) p_i^\gamma \log(1-p_i) & \text{if } y_i = 0 \end{cases}$$

where $\alpha=0.8$, $\gamma=2$ (Eq. 7).

• Training hyperparameters: Adam optimizer (lr=0.01), early stopping (patience=5 epochs), configuration chosen via Hyperband (2 GAT layers; 2→1 channels; 8→1 heads; dropout=0.225).

Batched training is supported by constructing a disjoint block-diagonal graph over minibatches, enabling scaling to thousands of nets on a typical GPU (Onal et al., 2024).

5. Computational Complexity and GPU-Batching Advantages

The method attains per-layer complexity $O(|E| d + |V| d^2)$ for $d$-dimensional node embeddings. Forming the Hanan grid for $k$ terminals yields $|V| = O(k^2)$ and $|E| = O(k^2)$. Key computational advantages:

• Parallelism: Unlike single-threaded C/C++ baselines (e.g., FLUTE, SALT, GeoSteiner), GAT-Steiner batches thousands of nets onto a GPU.
• Scaling: Experimentally supports batches of $\sim$1000 nets (degree $\leq50$) per 24 GiB GPU.
• Speedup: Achieves $10\times$–$20\times$ wall-clock accelerations compared to classical codes for large batch sizes (Onal et al., 2024).

6. Performance Results and Comparative Evaluation

The performance of GAT-Steiner was systematically benchmarked against both random synthetic nets and ISPD19 real-world datasets.

• Accuracy (random nets, $k \leq 50$): $\sim$99.2% average on held-out test, 3.5% suboptimal nets, mean $\Delta$WL = 0.7%, max $\Delta$WL $<$5%.
• Accuracy (ISPD19): $\sim$98.7% average, 4.1% suboptimal nets, mean $\Delta$WL = 0.9%, max $\Delta$WL $<$6%.
• Outlier suppression: GAT-Steiner produces far fewer (by 1–2 orders of magnitude) high-penalty outlier nets compared to FLUTE/SALT, which display thousands of $10–20\%$ wire-length outliers.
• Metric detail: Custom accuracy ignores true negatives and measures only the quality of Steiner-point selection, as

$$\text{Accuracy} = \begin{cases} 1 & \text{if } TP + FP + FN = 0 \ TP / (TP + FP + FN) & \text{otherwise} \end{cases}$$

where $TP$, $FP$, $FN$ denote true/false positives/negatives (Onal et al., 2024).

7. Limitations and Extensions

GAT-Steiner is restricted to Steiner points on the Hanan grid, so off-grid optimizations are not possible. Predicted extra degree-2 Steiner nodes are handled by post-prediction refinement. Input features are minimal (coordinates and node type); no congestion, obstacles, or multi-layer routing context is currently modeled. Plausible extensions include:

• Incorporation of heterogeneous edge weights for congestion modeling
• Geometric GNN topologies for Euclidean SMT instances
• Deeper post-prediction refinement or reinforcement learning to mitigate postprocessing needs
• Reduction of graph size via pin clustering for scaling to large nets
• Integration with dynamic cost models for detailed routing awareness (Onal et al., 2024)

8. Related Exact and Goal-Oriented Steiner Tree Algorithms

Prior to neural approaches, state-of-the-art exact solvers (e.g., (Hougardy et al., 2014)) combined dynamic programming (Dreyfus-Wagner recurrence) with A*-style admissible "future-cost" lower bounds to prune the search space. Here, label sets (subsets of terminals) are managed with hash representations, and future-cost lower bounds $L(v, I)$ integrate short MST/TSP bounds. Pruning and priority-queue expansion focus computation on promising solutions, dramatically reducing label-set proliferation. Experimental evidence demonstrates that on large VLSI and high-dimensional Hanan-grid instances, such goal-oriented algorithms can outperform traditional branch-and-bound solvers by orders of magnitude, with robust scaling up to millions of nodes/edges (Hougardy et al., 2014).

9. Context and Significance

GAT-Steiner exemplifies the translation of combinatorial VLSI design problems into learnable graph-structured prediction tasks, merging advances in GNN architectures (GAT) with domain-specific input construction (Hanan grid). The method establishes new benchmarks for both efficiency and solution quality in RSMT prediction, and underscores the impact of GPU-accelerated GNNs for combinatorial optimization within physical design. It also frames opportunities for the integration of learned approaches with established combinatorial algorithms—for instance, using neural predictions to focus or seed classical solvers, or learning to guide the construction of reduced search spaces—thus suggesting a convergence between neural and algorithmic toolkits in large-scale graph optimization (Onal et al., 2024, Hougardy et al., 2014).