ApproxGNN: GNN Framework for DSE

• ApproxGNN is a pretrained graph neural network framework for design space exploration in approximate computing, predicting quality-of-result and hardware cost in accelerators.
• It employs learned component embeddings from circuit graphs to replace handcrafted error metrics, enhancing transferability to unseen designs.
• By serving as a surrogate evaluator in NSGA-II loops, ApproxGNN reduces expensive synthesis and simulation, while maintaining accurate ranking of candidate designs.

ApproxGNN most commonly denotes a pretrained graph neural network framework for design space exploration (DSE) in approximate computing. In that setting, its purpose is to predict the quality-of-result (QoR)—in the paper, approximation error measured by PSNR—and hardware cost—for example, power—of approximate accelerators without repeatedly running expensive synthesis and simulation for every candidate design. The framework is tailored to workflows in which operations in a fixed accelerator are assigned exact or approximate components from a library, and it is distinguished by three linked design choices: a graph representation of circuits, learned embeddings for approximate components in place of handcrafted error metrics, and pretraining for transferability to unseen circuits (Vlcek et al., 22 Jul 2025).

1. Problem setting and design-space exploration role

Approximate computing targets error-tolerant workloads such as image processing, where replacing exact arithmetic with approximate hardware can reduce power, area, or delay while preserving acceptable output quality. The difficult step is the assignment of approximate components to operations in a large combinatorial design space. In the ApproxGNN formulation, the target use case is a fixed accelerator—especially image convolution / blur filters—in which each arithmetic operation can be implemented by an exact or approximate adder from a library such as EvoApproxLib. The resulting DSE objective is multi-objective: optimize PSNR / QoR, power, and related hardware-cost metrics by choosing which adder to assign to each operation (Vlcek et al., 22 Jul 2025).

This problem setting is motivated by the limitations of earlier statistical machine-learning flows such as AutoAx. Those approaches require a new application-specific training set for each accelerator, the data are expensive because each design point must be synthesized and evaluated, and the predictors rely on handcrafted component error metrics such as MAE, MRE, worst-case error, and relative error. ApproxGNN addresses that limitation by learning a transferable graph-based model that can reduce or eliminate repeated retraining on each new accelerator. A plausible implication is that the framework is intended not as a replacement for hardware verification, but as a reusable surrogate model that moves most of the computational cost away from repeated synthesis-driven predictor training.

2. Circuit graph formulation and learned component embeddings

ApproxGNN begins from a parser that converts Verilog RTL descriptions into a directed acyclic graph. In this representation, nodes correspond to hardware elements such as operators, inputs, constants, and components; edges represent signal flow; and edge indices preserve operand order. Approximate components are handled in two ways. If the component is known, its internal structure can be expanded into the graph. If it is an unknown approximate component, it is represented by a placeholder node whose feature vector is later replaced by a learned embedding (Vlcek et al., 22 Jul 2025).

The central novelty is the component-embedding model. Rather than encoding an approximate adder through scalar error summaries alone, ApproxGNN trains a GNN-based model on the gate-level Verilog of approximate components to produce an embedding

$\mathbf{z}_c = f_{\text{embed}}(G_c),$

where $G_c$ is the graph of the component and $\mathbf{z}_c$ is the learned component embedding. These embeddings are then injected as node features into the larger accelerator graph. The motivation given is that conventional metrics are only partial summaries, whereas learned embeddings can capture richer structural and functional characteristics that correlate better with downstream QoR prediction. This suggests that ApproxGNN treats the approximate-component library as a reusable latent space, rather than as a collection of manually specified error descriptors.

3. Architecture, message passing, and joint training

The paper describes a shared architectural pattern for both the embedding model and the prediction model. Node features are initialized, graph convolution or message passing updates node states by aggregating neighborhood information, a graph-level aggregation produces a global representation, and that graph representation is concatenated with features and processed again before a final MLP head produces the prediction. The node update is described in standard form as

$$\mathbf{h}_v^{(k+1)} = \phi\!\left( \mathbf{h}_v^{(k)}, \operatorname{AGG}\left(\left\{\mathbf{h}_u^{(k)} : u \in \mathcal{N}(v)\right\}\right) \right),$$

with attentional aggregation, followed by graph-level readout

$$\mathbf{g}^{(k)} = \operatorname{READOUT}\left(\{\mathbf{h}_v^{(k)} : v \in V\}\right), \qquad \hat{y} = \mathrm{MLP}(\mathbf{g}).$$

For comparative prediction tasks, two graphs are processed in parallel and their embeddings are concatenated before the final head (Vlcek et al., 22 Jul 2025).

A notable methodological point is joint training of the component-embedding model and the accelerator-level prediction model. The paper states that the approximate-component library is small because it contains only Pareto-relevant designs, which makes standalone embedding training difficult. The solution is to pass all components in the library through the embedding network during each batch, insert the resulting embeddings into circuit graphs, and backpropagate the prediction loss through both networks simultaneously. This arrangement lets the embedding space be shaped directly by the downstream QoR and hardware-cost objective. In that sense, ApproxGNN couples representation learning for approximate components with system-level surrogate modeling.

4. Synthetic data generation, evaluation protocol, and empirical results

The training corpus is synthetic and is built from image convolution accelerators. The generation flow consists of randomly generating blur kernels, converting each kernel into a shift-adder graph, rewriting constant multiplications into shifts and additions, using random grouping to create diverse and sometimes suboptimal structures, applying bit-width minimization, and randomly assigning approximate adders from EvoApproxLib to adder nodes. The resulting accelerator variants are evaluated by synthesis in Synopsys Design Compiler, functional evaluation on 10 images, and PSNR as the QoR metric. The paper further notes a weighted selection process for approximate components to avoid overrepresenting highly inaccurate implementations (Vlcek et al., 22 Jul 2025).

The principal regression metric is mean squared error: $$\mathrm{MSE} = \frac{1}{|X|}\sum_{\forall x \in X} \left(\mathrm{True}(x) - \mathrm{Est}(x)\right)^2.$$ For pairwise exploration tasks, the paper also defines Relative MSE, measuring how well the model predicts differences between circuit pairs,

$$\mathrm{mean}_{\forall a,b \in X}\left(\mathrm{True}_\Delta(a,b) - \mathrm{Est}_\Delta(a,b)\right)^2,$$

and Fidelity, which measures how often the model correctly predicts the ordering $<$, $=$, or $>$ between two designs. These metrics are motivated by the fact that DSE and NSGA-II rely on ranking and Pareto dominance, not only on absolute-value prediction.

The reported training dataset contains 240 randomly generated 3×3 image convolution accelerators, 159 unique kernel patterns after filtering, and about 15,900 circuit configurations in the final 16K training set, with 100 approximate component assignments per accelerator. Two unseen Gaussian-filter transfer datasets were constructed: SG and LG. Two model sizes were evaluated, approximately 80 kB and 340 kB, with the larger model used for transfer experiments. Training used 32 independent training runs, 150 epochs per run, required about 8 minutes per model training, and was implemented in PyTorch Geometric on a workstation with AMD Ryzen 5 5000X and 32 GB RAM (Vlcek et al., 22 Jul 2025).

The headline results are stated directly. The proposed embeddings improve prediction accuracy, measured by MSE, by 50% compared to conventional methods. Overall prediction accuracy is reported as 30% better than statistical machine learning approaches without fine-tuning and 54% better with fast finetuning. On unseen transfer datasets, the embedding-based model improves the Pearson correlation coefficient to 0.88 on SG and 0.83 on LG, compared with lower values such as 0.73 / 0.75 and 0.67 / 0.72 for the compared baselines. Fine-tuning with 1,500 samples—roughly 15% of SG, 33% of LG, and 10% of the original 16K dataset size—further improves accuracy (Vlcek et al., 22 Jul 2025).

Dataset or setting	Reported best result	Additional reported figure
SG	2.9 MSE with Embed + fine-tuning both networks	94.8% fidelity
LG	7.6 MSE with Embed + fine-tuning prediction	92.9% fidelity
Calibration	Offset correction using 10 randomly selected target samples	On LG, calibrated embedding-based models outperform a fully trained Random Forest baseline in MSE

These numbers are accompanied by a more qualitative claim about transfer behavior: transferred models show good Pareto approximation, especially in the middle approximation range, and fine-tuning improves agreement with true Pareto fronts. This indicates that ApproxGNN is intended to preserve ordering information well enough to support search, not merely to regress single-point accuracy.

5. Deployment in DSE, practical significance, and limitations

ApproxGNN is used as a surrogate evaluator inside a multi-objective DSE loop, specifically in an NSGA-II-like exploration loop. For each candidate accelerator assignment, it predicts PSNR / approximation quality and power / hardware cost. The operational purpose is straightforward: instead of synthesizing and simulating every design point, the DSE procedure can screen a large number of candidates cheaply and reserve exact evaluation for promising points near the Pareto front (Vlcek et al., 22 Jul 2025).

The practical significance attributed to the framework follows from this role. ApproxGNN is described as removing the need to train a new ML predictor for each accelerator, providing better transfer to unseen circuit structures, replacing handcrafted component metrics with learned embeddings, supporting multi-objective exploration, and reducing the synthesis burden. The paper also notes the open-source release of the parser, datasets, and pretrained models, which it presents as lowering the barrier for future work.

The limitations are narrower but equally explicit. First, transferred models can exhibit residual bias after transfer, including systematic underestimation on more complex unseen circuits. Second, final verification still needed: surrogate prediction is useful for screening, but final candidates should still be evaluated exactly. Third, the reported experiments focus primarily on image convolution / Gaussian filter accelerators and approximate adders, so broader validation is required for other application classes. Fourth, the available component library is limited and Pareto-pruned, which is one reason the joint-training strategy is necessary. A common misconception is therefore that ApproxGNN eliminates exact hardware evaluation; the paper instead positions it as an efficient surrogate within a verification-aware design flow.

6. Broader uses of “approximation” around GNNs

The designation ApproxGNN is not monosemous across the broader GNN literature. In adjacent work, “approximation” can refer to function approximation theory, approximate universal graph representations, approximate diffusion or propagation, approximation ratios for combinatorial optimization, approximate equivariance, or approximate optimization algorithms.

In approximation theory for node-level prediction, message-passing GNNs have been shown to be universal approximators in probability for node classification and regression on connected graph domains with bounded size, provided the target function is measurable and respects 1-WL node equivalence; that work also gives an explicit depth bound of $G_c$0 layers for graphs with at most $G_c$1 nodes (D'Inverno et al., 2021). In a different direction, PF-GNN starts from the exact Individualization and Refinement search tree and approximates universal graph representations by sampling multiple root-to-leaf paths with particle filtering, yielding an end-to-end differentiable and backbone-agnostic framework (Dupty et al., 2024).

Approximation also appears in graph propagation. GPR-GNN learns the coefficients of a polynomial graph filter to adapt propagation across homophilic and heterophilic regimes, generalizing fixed schemes such as APPNP and SGC (Chien et al., 2020). Approximate Graph Propagation (AGP) provides a unified randomized algorithm for transition probabilities, Personalized PageRank, heat kernel PageRank, Katz, SGC, GDC, and APPNP, with bounded error guarantees and almost optimal time complexity (Wang et al., 2021). Another line, presented as LSAP and described in the supplied material under the ApproxGNN label, learns node-wise diffusion scales via polynomial approximations to adaptive kernel convolution, targeting oversmoothing while avoiding Laplacian diagonalization (Sim et al., 2024).

Further uses of approximation are more theoretical. One paper studies approximation ratios of GNNs for combinatorial problems such as minimum dominating set and minimum vertex cover, linking GNN expressivity to distributed local algorithms and showing how port numbering and weak coloring change achievable guarantees (Sato et al., 2019). Another develops approximately equivariant graph networks for learning on a fixed graph domain, where the relevant symmetry group is induced by graph coarsening and the main result is a bias-variance tradeoff between expressivity and regularization (Huang et al., 2023). A separate line analyzes approximate gradient descent for learning one-hidden-layer GNNs in a teacher-student setting, proving linear convergence up to a statistical error floor for both node-level and graph-level labels (Li et al., 2020). There is also work on GenAgg, a learnable generalized $G_c$2-mean aggregation operator that parameterizes a space of approximate and exact neighborhood reducers including mean, sum, max, product, geometric mean, standard deviation, and log-sum-exp (Kortvelesy et al., 2023).

Taken together, these works show that “ApproxGNN” can denote a specific pretrained surrogate model for approximate-computing DSE, but it also resonates with a wider family of research programs in which GNNs are analyzed or designed through approximation: approximation of node-level functions, approximation of universal graph identifiers, approximation of diffusion operators, approximation guarantees for optimization problems, approximate equivariance on fixed domains, and approximate-gradient training. The 2025 ApproxGNN paper belongs specifically to the approximate-computing DSE branch, where approximation refers to circuit behavior, surrogate prediction, and transfer across accelerator designs (Vlcek et al., 22 Jul 2025).