Transpilation-Aware Runtime Prediction for Noisy Quantum Circuit Simulation

summary

The gist

Predicting noisy-simulator runtime is important for scheduling, resource allocation, and performance optimization <ref:2609.12980#pg5> The overall model setting…

In short

The study evaluates three graph representations for predicting noisy quantum circuit simulation runtime: source-level, hybrid, and transpiled GNNs. The transpiled GNN consistently provided the best results across all optimization levels, proving that post-transpilation information is valuable for accurate runtime prediction in quantum computing.

Key concepts

Circuit Representations
The paper tests three ways to model a quantum circuit: source-level (before changes), hybrid (source plus post-transpilation features), and transpiled (built entirely from the backend-specific, optimized circuit). These representations are fed into Graph Neural Networks (GNNs) to predict how long the simulation will take.
Transpilation
Transpilation is the process of rewriting a quantum circuit to be compatible with a specific quantum hardware's native gate set and coupling map. It involves decomposing unsupported gates and inserting routing operations like SWAPs. The paper examines how different optimization levels of this process affect prediction accuracy.
Transpiled GNN
This is the GNN model that uses the circuit structure *after* it has been fully transpiled for a target backend. It consistently outperformed other models because it captures crucial information about the final, optimized circuit structure, proving that post-transpilation details are important for reliable runtime estimation.

Terminology used across episodes

This episode discusses

The paper

Transpilation-Aware Runtime Prediction for Noisy Quantum Circuit Simulation · Read on arXiv

Davud Azizov, Javier Vela-Tambo, Tian Guo

Worcester Polytechnic Institute

Predicting the runtime of noisy quantum circuit simulations is important for scheduling, resource allocation, and performance optimization. However, accurate prediction is challenging because backend-aware transpilation can substantially alter the original circuit structure, while the backend-derived noise model and simulator execution behavior can introduce additional runtime variation. We study the effectiveness of graph neural networks (GNNs) and conventional regression methods in predicting Qiskit Aer simulation runtime measured after transpilation. We construct a dataset from a benchmark pool of 1,402 unique circuits spanning 22 circuit families, two Qiskit fake-backend configurations, and four transpiler optimization levels. Specifically, we compare a source GNN using original circuit information, hybrid GNN combining source-level graph with post-transpilation features, and transpiled GNN using only transpiled circuit information, along with five regression models. In the overall-model setting, the transpiled GNN achieves the strongest performance among the graph-based representations at all four optimization levels, obtaining R squared values of 0.974, 0.713, 0.745, and 0.605 for optimization levels 0 through 3, respectively. However, under backend-specific evaluation, the advantage of GNN decreases, with conventional regression models matching or outperforming the GNNs in several settings. These results indicate that post-transpilation information is useful, while the value of explicit graph modeling depends on the backend and optimization level.

DOI: 10.1609/aaaiss.v10i1.43479

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: We're looking at the paper: "Transpilation-Aware Runtime Prediction for Noisy Quantum Circuit Simulation".

Mira: Here's the gist of the paper. Predicting noisy-simulator runtime is important for scheduling, resource allocation, and performance optimization <ref:2609.12980#pg5> The overall model setting, the transpiled GNN provides the strongest and most consistent results across all optimization levels, outperforming both the Source and Hybrid GNNs as well as ML models <ref:2609.12980#pg6> These results indicate that post-transpilation information is useful, while the value of explicit graph modeling depends on the backend and optimization level <ref:2609.12980#pg2> Circuit Representation and Modeling The study formulates and evaluates three GNN graph representations (source, hybrid, and transpiled), alongside five ML regression methods to quantify the effects of feature representations and model choices on noisy-simulator runtime prediction <ref:2609.12980#pg5> Specifically, the source setting uses a source-level directed acyclic graph (DAG) extracted from the original circuit before transpilation, while the hybrid setting augments this with 13 post-transpilation global features <ref:2609.12980#pg5> The transpiled setting builds both its graph and global feature vector entirely from the backend-specific transpiled circuit <ref:2609.12980#pg5> Evaluation Methodology The evaluation methodology involves constructing a circuit dataset consisting of source-level and transpiled graphs for four optimization levels and two simulation backends using Qiskit Aer simulator <ref:2609.12980#pg5> The evaluation uses two standard regression metrics: root mean squared error (RMSE) and the coefficient of determination (R2) to measure prediction performance <ref:2609.12980#pg6> Data splitting is performed by generating 1,000 candidate 80/20 train-test splits and selecting the one that minimizes a distribution-matching score based on backend, circuit family, and execution-time distributions <ref:2609.12980#pg6> Performance Comparison Among Models The Transpiled GNN provides the strongest and most consistent results across all optimization levels, outperforming both the Source and Hybrid GNNs as well as the baseline winner <ref:2609.12980#pg5> The gain of the Transpiled GNN becomes clearer at higher optimization levels, Opt 2 and Opt 3, where transpilation phase has more optimizations such as more intensive layout, routing, cancellation and resynthesis passes <ref:2609.12980#pg6> However, R2 generally decreases as the optimization level increases because the Opt 3 dataset has a much tighter runtime distribution <ref:2609.12980#pg6> Backend-Specific Predictions Washington shows a clear benefit from backend-stratified results across all optimization levels and representations, with the overall Transpiled GNN being the best-performing model <ref:2609.12980#pg6> Sherbrooke shows that backend-specific training can improve prediction in selected settings, particularly for the Transpiled GNN at some optimization levels <ref:2609.12980#pg6> This suggests that separate training is not necessary for Washington <ref:2609.12980#pg6> Optimization Level Impact on Transpilation The benefit of additional optimization depends on the circuit characteristics, as deeper and slower circuits are much more likely to benefit from additional optimization <ref:2609.12980#pg6> On Washington, the percentage of circuits benefiting from Opt 1 increases significantly between fastest and slowest circuits <ref:2609.12980#pg6> Conversely, on Sherbrooke, there is almost no benefit for the slowest circuits with Opt 3 <ref:2609.12980#pg6> This suggests that additional transpilation overhead of Opt 3 generally outweighs its execution time savings <ref:2609.12980#pg6> Accuracy and Inference Cost The Transpiled GNN achieves the strongest predictive performance among the GNN representations in most evaluated settings <ref:2609.12980#pg6> The Transpiled GNN processes graphs that are approximately 34.9× larger on average and requires about 7.4× more inference time than other representations <ref:2609.12980#pg6> Despite the increased graph cost, its inference time is still in milliseconds, 2.35 ms per circuit, while achieving the highest mean R2 <ref:2609.12980#pg6> The Transpiled GNN's advantage is due to the post-transpilation representation rather than differences in dataset composition <ref:2609.12980#pg6> The paper proposes two GNN circuit representations (hybrid and transpiled) and evaluates their prediction accuracy and overhead with a circuit dataset collected on two backends with four transpilation optimization levels <ref:2609.12980#pg5> The results demonstrate that the transpiled GNN generally provides the strongest performance among the graph-based representations, suggesting the importance of post-transpilation circuit structure and features <ref:2609.12980#pg6> However, conventional ML regression models using transpilation-aware circuit features remain competitive with or outperform GNNs in several settings <ref:2609.12980#pg6> These findings suggest that post-transpilation information is important for reliable quantum execution-time predictors <ref:2609.12980#pg6> Such predictors are essential for future quantum operating systems and schedulers, where runtime estimates can guide job placement and resource allocation <ref:2609.12980#pg6> Acknowledgments This work is supported in part by NSF Grant 2426940 and a high-performance computing system acquired through NSF MRI grant DMS-1337943 to WPI <ref:2609.12980#pg6> The paper's references include Bisicchia et al.

Kai: 2025, Chen and Guestrin 2016, Dam et al.

Mira: 2024, and Ma and Li 2026 The paper also cites Quetschlich et al.

Kai: 2023a, Quetschlich et al.

Paper summary: Kai: So to wrap up, the paper "Transpilation-Aware Runtime Prediction for Noisy Quantum Circuit Simulation" looked at how different ways of representing a circuit—source, hybrid, or fully transpiled—affect our ability to predict runtime on noisy simulators.

Mira: They found that the fully transpiled GNN generally gives the best prediction accuracy among the graph-based methods, suggesting that knowing what's happening after transpilation is important for understanding circuit structure and features.

Lev: But they also showed that standard machine learning models using features aware of transpilation can still be just as good or even better than those graph neural networks in some settings.

Kai: The implications are that post-transpilation information is a key piece of the puzzle for building reliable predictors for quantum execution times.

Mira: For people who listen to this show, this means these runtime estimates are going to be crucial when we start building quantum operating systems and schedulers so they can decide where jobs go and how resources are used on real hardware.

Conclusion: Kai: So we're wrapping up this look at how circuit representations affect predicting noisy simulator runtime, focusing on the work by Bisicchia and his team.

Mira: They put forward two main GNN models for representing circuits—one hybrid and one fully transpiled—and they show that the latter, the transpiled one, is generally the strongest predictor.

Kai: But they also point out that standard machine learning models using features derived from that transpilation are still quite competitive with those graph neural networks.

Mira: That suggests post-transpilation information is genuinely useful for building these quantum execution time predictors.

Kai: It means these estimates become more reliable, which is important for the future of scheduling and resource allocation in quantum computing systems.

Mira: Exactly, because if we can predict how long a circuit will actually take to run on hardware after all that transpilation work is done, we can place jobs much better on real quantum machines.

Kai: It seems like the main thing here is that the structure of the circuit *after* it’s been prepared for a specific machine matters for accurate runtime guessing.

Mira: Right, and while they show this works well across different optimization levels and backends, we still have to look at how much extra computation that transpilation itself adds to the overall process.

More episodes

← Home