What is my quantum computer good for? Quantum capability learning with physics-aware neural networks

Authors: daniel  hothem
ashe  miller
timothy  proctor
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-15 06:23:40

Abstract: Quantum computers have the potential to revolutionize diverse fields, including quantum chemistry, materials science, and machine learning. However, contemporary quantum computers experience errors that often cause quantum programs run on them to fail. Until quantum computers can reliably execute large quantum programs, stakeholders will need fast and reliable methods for assessing a quantum computer’s capability—i.e., the programs it can run and how well it can run them. Previously, off-the-shelf neural network architectures have been used to model quantum computers' capabilities, but with limited success, because these networks fail to learn the complex quantum physics that determines real quantum computers' errors. We address this shortcoming with a new quantum-physics-aware neural network architecture for learning capability models. Our scalable architecture combines aspects of graph neural networks with efficient approximations to the physics of errors in quantum programs. This approach achieves up to $\sim50\%$ reductions in mean absolute error on both experimental and simulated data, over state-of-the-art models based on convolutional neural networks, and scales to devices with 100+ qubits.

Main paper: 
 introduction: 
 Quantum computers have the potential to efficiently solve classically intractable problems in quantum chemistry [Cao et al., 2019] , materials science [Rubin et al., 2024] , machine learning [Harrow et al., 2009] , and cryptography [Shor, 1997] . While contemporary quantum computers are approaching the size and noise levels needed to solve interesting problems [Arute et al., 2019] , they are far from being capable of reliably running most useful quantum programs [Proctor et al., 2021a] . Until we build quantum computers capable of executing any and all useful and interesting quantum programs, stakeholders will require fast, reliable, and scalable methods for predicting the programs that a given quantum computer can reliably execute.The task of learning which quantum programs a particular quantum computer can reliably execute is known as quantum capability learning [Proctor et al., 2021a] . Quantum capability learning is very difficult because the number of possible (Markovian) errors plaguing a quantum computer grows exponentially in its size [Blume-Kohout et al., 2022] , i.e., in the number of qubits (n) it contains, and errors in a quantum program can combine in difficult-to-predict ways [Proctor et al., 2021a] . Most existing approaches to capability learning restrict themselves to learning how well a quantum computer executes a small set of quantum programs, by running all of those programs and estimating a success metric for each one [Lubinski et al., 2023 , Proctor et al., 2024] . While these methods provide insight into a quantum computer's capability, they are not predictive.Recently, several groups have proposed building predictive models of a quantum computer's capability using convolutional neural networks (CNNs) [Elsayed Amer et al., 2022 , Hothem et al., 2024b , Vadali et al., 2024 , Hothem et al., 2023b] and graph neural networks (GNNs) [Wang et al., 2022] . However, these neural-network-based capability models achieve only modest prediction accuracy when applied to real quantum computers, because they fail to learn the complex physics that determines real quantum computers' failures [Hothem et al., 2024b] .In this work, we introduce a novel quantum-physics-aware neural network (qpa-NN) architecture for quantum capability learning (Fig. 1 ). Our approach uses neural networks with GNN-inspired structures to predict the rates of the most physically relevant errors in quantum programs. These predicted error rates are then combined using an efficient approximation to the exact (but exponentially costly) quantum physics formula for how those errors combine to impact a program's success rate. Our approach leverages the graph structures that encode the physics of how errors' rates typically depend on both the quantum program being run and how a quantum computer's qubits are arranged, and it offloads the difficult-to-learn, yet classically tractable task of approximately combining these error rates to predict a circuit's performance to an already-known function. This enables our qpa-NNs to vastly outperform the state-of-the-art CNNs of Hothem et al. [2024b] on both experimental and simulated data without sacrificing the ability to model large devices of 100+ qubits.Our qpa-NNs are enabled, in part, by focusing on learning a quantum computer's capability on highfidelity quantum programs, which are those programs that a quantum computer correctly executes with high probability. High-fidelity programs are arguably the most interesting programs to study as we care far more about whether a quantum computer successfully executes a program 99% or 90% of the time rather than 1% or 10% of the time.In a head-to-head comparison, our qpa-NNs achieve a ∼ 50% reduction in mean absolute error (MAE) over the CNNs of Hothem et al. [2024b] , on average and on the same experimental datasets. Our qpa-NNs achieve an average ∼ 36% improvement over those CNNs even after fine-tuning those CNNs on the same subset of the training data (high-fidelity programs) used to train our qpa-NNs.Our qpa-NNs' improved performance is likely largely due to their improved ability to model the impact of coherent errors on a program's success rate. Off-the-shelf networks struggle with coherent errors [Hothem et al., 2024b] , but our qpa-NNs are designed to model how these errors add up and cancel out, making the qpa-NNs much better predictors in the presence of coherent errors. To verify this, we demonstrate that our qpa-NNs can accurately predict the performance of random circuits run on a hypothetical 4-qubit quantum computer experiencing only coherent errors. Our qpa-NN obtained a ∼ 50% lower MAE than a CNN, averaged across five datasets, and the trained qpa-NN even exhibits moderate performance when making predictions for a different class of circuits (random mirror circuits [Proctor et al., 2021a] ) simulated on the same hypothetical 4-qubit quantum computer, i.e., our qpa-NNs display moderate prediction accuracy on out-of-distribution data.We make the following contributions in our work:1. We introduce qpa-NNs, a bespoke neural network architecture for modeling the capability of a quantum computer, which outperform state-of-the-art CNN models by ∼ 50% on experimental and simulated data. 
background: 
 In this section, we review the background in quantum computing necessary to understand this paper. See Nielsen and Chuang [2010] for an in-depth introduction to quantum computing and Blume-Kohout et al. [2022] or Hashim et al. [2024] for a thorough description of the errors in quantum computers.A quantum computer performs computations using qubits, which are two-level systems whose pure states are unit vectors in a complex two-dimensional Hilbert space, H. The pure states of n qubits are unit vectors in H ⊗n . The two orthonormal vectors |0 and |1 that are eigenvectors of the Z Pauli operator are identified as the computational basis of H. Errors and noise in real quantum computers mean that they are typically in states ρ that are probabilistic mixtures of pure states.A quantum computation is performed by running a quantum program, typically known as a quantum circuit (see illustration in Fig. 1a ). An n-qubit quantum circuit (c) of depth d is defined by a sequence of d layers of logical instructions {L i }. Executing c consists of preparing each qubit in |0 , applying each L i , and then measuring each qubit to obtain an n-bit string b. Each layer typically consists of parallel one-and two-qubit gates, and it is intended to implement a 2 n × 2 n unitary U (L i ). Together, the layers are intended to implementU (c) = U (L d ) • • • U (L 1 ).If quantum circuit c is implemented without error, its output bit string b is a sample from a distribution P(c) whose probabilities are given by Pr(b = x) = | x|U (c)|00 • • • 0 | 2 where |00 • • • 0 = |0 ⊗ • • • ⊗ |0 , |x = |x 1 ⊗ • • • ⊗ |x n ,and x i is the i-th bit in x. However, when a circuit is executed on a real quantum computer, errors can occur and this means that its output bit string b is a sample from some other distribution P(c). The process of errors corrupting a quantum computation can be modelled as follows. Each logic layer L i implements the intended unitary superoperator U(L i ) :ρ → U (L i )ρU † (L i ),where ρ is a general n-qubit state, followed by an error channel Λ i that is a completely positive and trace preserving (CPTP) superoperator [Blume-Kohout et al., 2022] . The imperfect implementation of a circuit c is then simply Ũ(c) = d i=1 Λ i • U(L i ),= x) = Tr(|x x| Ũ(c)[|00 • • • 0 00 • • • 0|]).Because quantum computers are error-prone, knowing which quantum circuits a particular quantum computer can execute with low error probability is important. Known as quantum capability learning [Proctor et al., 2021a , Hothem et al., 2024b] , this task formally involves learning the mapping between a set of quantum circuits c ∈ C and some success metric s(c) ∈ R quantifying how well c runs on a quantum computer Q. In this work, we consider a large class of circuits known as Clifford (or stabilizer) circuits [Aaronson and Gottesman, 2004] , which are sufficient to enable quantum error correction [Campbell et al., 2017] , and two widely-used success metrics: probability of successful trial (PST) (a.k.a. success probability) and the process fidelity (a.k.a. entanglement fidelity) [Hothem et al., 2024b , Nielsen, 2002] .PST is defined only for definite-outcome circuits, which are circuits whose output distribution has (if run without error) support on a single bit string, b(c). For any such circuit c, PST is defined as PST(c) = Pr(measuring b(c) when executing c on Q).(1) In practice, PST(c) is estimated by running the circuit N shots 1 times on Q and calculatingEQUATION)Process fidelity is defined for all circuits, and it quantifies how close the actual quantum evolution of the qubits is to the ideal unitary evolution. It is given byEQUATIONEstimating F (c) is more complicated than estimating PST(c), but efficient methods exist, such as mirror circuit fidelity estimation [Proctor et al., 2022] . Hence, in theory, it is possible to efficiently gather training data using either PST(c) or F (c) on arbitrarily large quantum computers.Figure 1 : Quantum capability learning with quantum-physics-aware neural networks (qpa-NNs). Our qpa-NNs are a novel architecture for learning a quantum computer's capability, i.e., the mapping from quantum circuits (or programs) to how well that imperfect quantum computer can run those circuits. These networks build in physical principles for how errors in quantum circuits occur-which can be expressed in terms of a quantum computer's connectivity graph-and efficient approximations to the physics of how these errors combine to impact a circuit's success rate.Our qpa-NNs build in efficient approximations to the quantum physics of errors in quantum computers. They do so using the following parameterization of an error channel: Λ = exp( j j G j ).HereG n = {G j } is the set of 2 2n+1 -2 different Hamiltonian (H)and Stochastic (S) elementary error generators introduced by Blume-Kohout et al. [2022] , and j is the rate of error G j . Not every kind of error process can be represented in this form (e.g., amplitude damping, or non-Markovian errors), but this parameterization includes many of the most important kinds of errors in contemporary quantum computers. Each H and S error generator is indexed by a non-identity element of the n-qubit Pauli group (P n ). The Pauli operator indexing an H or S error indicates the qubits it impacts and its direction, e.g., the H error generator indexed by X ⊗ I ⊗(n-1) is a coherent error on the 1 st qubit and it rotates that qubit around its X axis.Our qpa-NNs use approximate formulas for computing PST(c) or F (c) from the rates of H and S errors, which we now review. Consider pushing each error channel Λ i to the end of the circuit and combining them together, i.e., we compute the error channel Λ(c) defined byEQUATIONwhere s P and θ P are the rates of the P -indexed S and H error generators, respectively, in c's error channel Λ(c), and P X,Y n is the set of n-qubit Pauli operators containing at least one X or Y . Similarly,EQUATIONEquations ( 4) and ( 5) are good approximations for low-error circuits [M ądzik et al., 2022] . However, they both suffer from the same flaw: they require tracking O(4 n ) parameters. To address this problem, our qpa-NNs make an approximation: they only account for the contributions of a polynomially-sized set of errors that contains all those errors which are most likely to be experienced by a quantum computer. In this work, we chose to account for only local, low-weight errors, i.e., those with initial support on a small, connected subset of a device's connectivity graph. 
neural network architecture: 
 Our neural network architecture (see Fig. 1 ) for quantum capability learning combines neural network layers that have GNN-like structures with efficient approximations to the physics of errors in quantum computers. The overall action of our neural networks is to map an encoding of a circuit c to a prediction for PST(c) or F (c). The same network can predict either PST(c) or F (c) by simply toggling between two different output layers that have no trainable parameters. Our architecture is divided into two sequential parts. The first part of our architecture is a neural network N that has the task of learning about the kinds and rates of errors that occur in quantum circuits. We use GNN-like structures within N to embed physics knowledge for how those errors depend on the quantum circuit being run. The second part of our architecture is a function f with no learnable parameters, that turns N 's output into a prediction for PST(c) or F (c).The neural network N 's input is a quantum circuit c of depth d(c) represented by (i) a tensor I(c) ∈ {0, 1} n×d(c)×n ch describing the gates in c (see Fig. 1a ), and (ii) a matrix M (c) ∈ {0, 1} 2×n describing the measurement of the qubits at the end of c. N maps I(c) to a matrix E ∈ R k×d(c) and M (c) to a vector m ∈ R k . E ij is a prediction for the rate with which error type j occurs during circuit layer i, and m j is a prediction for the rate with which error type j occurs when measuring the qubits at the end of a circuit. There are 2(4 n -1) different possible error types that can occur in principle (see Section 2) so it is infeasible to predict all their rates beyond very small n. However, the overwhelming majority of these errors are implausible, i.e., they are not expected to occur in real quantum computers [Blume-Kohout et al., 2022] . Our networks therefore predict the rates of every error from a relatively small set of error types G = {G 1 , . . . , G k } containing the k most plausible kinds of error. G is a hyperparameter of our networks. It can be chosen to reflect the known physics of a particular quantum computer and/or optimized using hyperparameter tuning. In our demonstrations, we choose G to contain all one-body H and S errors as well as all two-body H and S errors that interact pairs of qubits within h steps on the modelled quantum computer's connectivity graph for some constant h (see Fig. 1b-c , where Fig. 1c shows an H or S error in G if h ≥ 2). This choice for G encodes the physical principles that errors are primarily either localized to a qubit or are two-body interactions between nearby qubits [Blume-Kohout et al., 2022] . The size of G grows with n, and for planar connectivity graphs (as in, e.g., contemporary superconducting qubit systems [Arute et al., 2019] ) it grows linearly in n. This results in k = O(n) errors whose rates N must learn to predict.The internal structures of N are chosen to reflect general physical principles for how E and m depend on c. E ij is a prediction for the rate that G j occurs in circuit layer i, and this error corresponds to a space/time location within c-because it occurs at layer index or time i and G j acts on a subset of the qubits Q(G j ) (see example in Fig. 1c ). This error's rate will therefore primarily depend only on the gates in a time-and space-local region around its location in c. Furthermore, this dependence will typically be invariant under time translations (this is true except for some exotic non-Markovian kinds of errors, which we discuss in Section 8.1). We can encode these structures into N by predicting E ij from a space-time "window" of c around the associated error's location using a filter W j that "slides" across the circuit to predict the rate of G j versus time i. Stated more formally, we predict E ij using a multilayer perceptron N j whereby N j (W j [I(c), i]) = E ij and W j [I(c), i] is a snippet of I(c) whose temporal origin is i (see Fig. 1e ). The shape of each filter W j is a hyperparameter of our networks and it can be designed to reflect general physical principles, the known physics of a particular quantum computing system, and/or optimized with hyperparameter tuning. The particular neural networks we present later herein use filters W j (I(c), i) that snip out only layer i and discard the parts of the layer that act on qubits more than l steps away from Q(G j ) in the quantum computer's connectivity graph (e.g., the filter shown in Fig. 1e corresponds to the error shown in Fig. 1c and l = 1). This neural network structure has close connections to graph convolution layers [Kipf and Welling, 2016] , as well as CNNs. We choose this structure as it can model spatially localized crosstalk errors, which are a ubiquitous but hard-to-model class of errors in quantum computers [Sarovar et al., 2020] .The network N must also predict the rates of errors that occur during measurements (unless the qpa-NN will only ever predict F (c) not PST(c)), but these are typically independent of the rates of gate errors (which are predicted by the N j ). So we do not use the N j and their convolutional filters W j to make predictions for m. Instead we use separate but structurally equivalent networks N j with corresponding filters W j that take M (c) as input and implement only spatial filtering. That is, W j simply discards rows from M (c), as, unlike I(c), M (c) has no temporal dimension. The W j are hyperparameters of our networks allowing us to separately adjust the shape of each W j to reflect the known physics of errors induced by measuring qubits. In our demonstrations, our W j filters have the same structure as the W j filters but with an independent l steps parameter (large l enables modelling many-qubit measurement crosstalk).We process N 's output to predict PST(c) or F (c) using a function f with no learnable parameters. This turns N 's output into the two quantities of interest, and it also makes training N feasible.We cannot easily train N in isolation because the error matrix E predicted by N is not a directly observable quantity. Generating the data needed to train N directly would require extraordinarily expensive quantum process tomography [Nielsen et al., 2021] , which is infeasible except for very small n. In contrast, both PST(c) and F (c) can be efficiently estimated (see Section 2) for a given circuit c.The function f computes an approximation to the value for PST(c) or F (c) predicted by E and m.The matrix E encodes the prediction that c's imperfect action isEQUATIONwhere the L i are the d layers of c (see Section 2) andΛ i (E) = exp( k j=1 E ij G j ), i.e., Λ i (E)is an error channel parameterized by the i th column of E. Equation ( 6) implies an exact prediction for PST(c) or F (c) [e.g., Eq. ( 3)], but exactly computing that prediction involves explicitly creating and multiplying together each of the 4 n × 4 n matrices in Eq. ( 6). This is infeasible, except for very small n. Instead our f computes an efficient approximation to this prediction.Our function f 's action is most easily described by embedding E into the space of all possible H and S errors G n , resulting in a d × (2 2n+1 -2) matrix E e whose columns are k-sparse. However, we never construct these exponentially large matrices. Consider pulling each error channel to the end of the circuit, givingŨ(c) = Λ d (E e ) • • • Λ 1 (E e )U(c) where Λ d (E e ) = exp( 2 2n+1 -2 j=1 [E e ] ij G j ).Because c contains only Clifford gates and Clifford unitaries preserve the Pauli group [Aaronson and Gottesman, 2004] , E e has columns that are just c-dependent signed permutations of E e 's columns. The signed permutations required can be efficiently computed in advance (i.e., as an input encoding step) using an efficient representation of Clifford unitaries [Gidney, 2021] . Furthermore, these permutations can be efficiently represented in two d × k matrices: a sign matrix S(c) containing ±1 signs to be element-wise multiplied with E and a permutation indices matrix P (c) containing integers between 1 and 2 2n+1 -2, where P ij specifies what error G j becomes when pulled through the d -i circuit layers after layer i.We now have a representation of E's prediction for the circuit c's error map Λ(c) as a sequence of error maps Λ d (E e ) • • • Λ 1 (E e ), and we need to predict PST(c) or F (c). We can do so if we can compute E's prediction for the S and H error rates in Λ(c), as we can then apply Eq. ( 4) or Eq. ( 5). To achieve this, we combine the Λ i (E) into a single error map using a first-order Baker-Campbell-Hausdorff (BCH) expansion. Using our embedded representation, this means simply approximating Λ(c) asΛ(c) ≈ exp( j v j G j ) where v j = d i=1 [E e ] ij , i.e., we sum over the rows of E e . To predict F (c) we then simply apply Eq. ( 4) (meaning summing up v j with those elements that correspond to Hamiltonian errors squared). Because measurement errors impact PST(c), to predict PST(c) we again apply the BCH expansion to combine in the predicted measurement error map exp( l j=1 m j G j ) and then apply Eq. ( 5). The efficient representation of the overall action of f is illustrated in Fig. 1 (the addition of the measurement error map is not shown). 
experimental 5-qubit data: 
 We used the 5-qubit datasets from Hothem et al. [2024b] for our experimental demonstrations. Each of these datasets D = {(c, PST(c))} was gathered by running random and periodic mirror circuits (two types of definite-outcome circuits) on 5-qubit IBM Q computers (ibmq_london, ibmq_essex, ibmq_burlington, ibmq_vigo, ibmq_ourense and ibmq_yorktown), and estimating the PST of each circuit using Eq. ( 2). Each circuit was run between 1024 and 4096 times, with the exact number depending upon how many times the circuit sampling process generated the circuit (some short, 1-qubit circuits were generated multiple times). The random and periodic mirror circuits contained between 1 and 5 active qubits-called the circuit's width-and ranged in depth from 3 to 515 layers (alt. 259 layers for the ibmq_yorktown dataset).As we focus on high-PST circuits, we removed all circuits with a PST less than 85% from each dataset, leaving between 864 (ibmq_burlington) and 1369 (ibmq_yorktown) circuits in each dataset. The remaining circuits were partitioned into training, validation, and test sets by their original assignment in Hothem et al. [2024b] . This setup enables a direct comparison between our qpa-NNs and the CNNs trained in Hothem et al. [2024b] . Training set sizes ranged from 682 circuits on ibmq_burlington to 1097 circuits on ibmq_yorktown, with an approximate training, validation, testing split of 80%, 10%, and 10%, respectively.For our 4-qubit simulations, we generated 5 datasets of 5000 high-fidelity (F (c) > 85%) random circuits, for a hypothetical 4-qubit processor with a "ring" geometry (i.e., like that in Fig. 1b ). The circuits ranged in width (w) from 1 to 4 qubits, and in depth from 1 to 180 circuit layers. We designed each circuit for a randomly chosen subset of w qubits. Each circuit layer was created by i.i.d. sampling from all possible circuit layers on the w active qubits. We used a gate set containing two-qubit CNOT gates and 7 different single-qubit gates (specifically {X(π/2), Y (π/2), X(3π/2), Y (3π/2), X(π), Y (π), Z(π)} where P (θ) denotes a rotation around the P axis of the Bloch sphere by θ). See Appendix C for additional details.All circuits were simulated under the same error model, consisting of local coherent (i.e., H) errors, to exactly compute each c's F (c) [Fig. 3 shows a histogram of F (c)]. After removing duplicate circuits, the resulting datasets D = {(c, F (c))} were partitioned into training, validation, and testing subsets, with a partition of 56.25%, 18.75%, and 25%, respectively. The parameters of the error model were randomly selected: each gate was assigned a small error strength, which was then distributed randomly across all possible (local) one-or two-qubit coherent errors, for the one-and two-qubit gates, respectively. We chose a model with only coherent errors as these errors are ubiquitous, they are hard to model accurately and efficiently, and we conjecture that qpa-NNs can model them.We also generated 5 datasets of 750 random mirror circuits on the same hypothetical 4-qubit quantum computer. Again, the random mirror circuits varied in width from 1 to 4 qubits, and were designed to be run on a randomly selected subset of w qubits. However, instead of i.i.d. sampling of each circuit layer, each circuit was randomly sampled from the class of random mirror circuits on the w qubits. The depth of the mirror circuits ranged from 8 to 174 layers. Because we generated the mirror circuit datasets to evaluate how well qpa-NNs and CNNs generalize to out-of-distribution circuits, they were used exclusively as testing sets. To ensure that no training was performed on mirror circuits, we removed any mirror circuits that appeared in the random circuit sets (in actuality, there were no duplicates).For our 100-qubit simulation, we generated a single dataset of 5000 high-fidelity (F (c) > 91%) random circuits, for a hypothetical 100-qubit quantum computer with a "ring" geometry. All of the circuits had a width of 100 qubits, and ranged in depth from 1 to 22 circuit layers. We sampled circuit layers using the same process and gate set as in the 4-qubit simulations.We simulated every circuit using the same error model, consisting of local, weight-1 S and H errors. As before, the parameters of the error model were randomly selected and the data were partitioned into training, validation, and testing subsets according to a 56.25%, 18.75%, 25% split.Unlike in our 4-qubit simulations, we did not compute F (c) exactly as doing so for a 100-qubit circuit is infeasible in the presence of coherent errors. Instead, we used a first-order simulation method to approximate F (c). In this method, F (c) is computed by assigning each gate its own error vector based on the error model, adding up the error vectors layer-wise to compute an error vector We used two different encoding schemes for converting each circuit c into a tensor. For the CNNs on experimental data, we used the same encoding scheme as Hothem et al. [2024b] , as we used their data and networks. For all qpa-NNs, and the CNNs on simulated data, we used the following scheme. As outlined in Section 3, each width-w circuit c is represented by a three-dimensional tensor I(c) ∈ {0, 1} n×d(c)×n ch describing the gates in c and a matrix M (C) ∈ {0, 1} 2×w describing the measurement of the qubits. The ij-th entry of I(c),EQUATIONis a one-hot encoded vector of what happens to qubit i in layer j. For the hypothetical 4-qubit ring processor, n ch = 11: one channel for each single-qubit gate and four channels for the CNOT gates. There are four CNOT channels to specify if the qubit i is the target or control qubit and if the interacting qubit is to the left or right of qubit i. We used an additional 4 or 8 CNOT channels for the experimental data, depending on the quantum computer's geometry. The first row in M (c) is the bitstring specifying which qubits are measured at the end of c. When c is a definite-outcome circuit, the second row is its target bit string, i.e., the sole bit string in the support of c's outcome distribution when it is executed without error [i.e., P(c)]. Both I(c) and M (c) are zero-padded to ensure a consistent tensor shape across a dataset.Additionally, each circuit c is accompanied by a permutation matrix P (c) ∈ N n×k and sign matrix S(c) ∈ {±1} n×k . The ij-entry of P (c) specifies which error the j-th tracked error occurring after the i-th layer is transformed into at the end of the circuit. The ij-th entry of S(c) specifies the sign of that error. 
5-qubit experiments: 
 We now present the results from our head-to-head comparison between the qpa-NNs and the CNNs on the 5-qubit datasets used in Hothem et al. [2024b] . Figure 2 shows the mean absolute error (MAE) achieved by the CNNs (+) and the qpa-NNs (•) on each of the datasets. For all datasets, MAE is lower for the qpa-NNs than the CNNs, with an average reduction of 50.4% (σ x = 16.7%, i.e., the standard deviation of percent-drop in MAE). The Bayes factor K is between K = 10 30 and K = 10 383 (here, K is the ratio of the likelihood of the qpa-NN to the likelihood of the CNN given the test data). This is overwhelming evidence that the qpa-NN is a better model (K ≥ 10 2 is typically considered decisive). These results strongly suggest that the extra infrastructure in the qpa-NNs is making a difference.The improved performance of the qpa-NNs is not because of an increase in model size. For example, the ibmq_london CNN contains 6, 649, 531 trainable parameters compared to the 1, 218, 348 trainable parameters in the qpa-NN. Moreover, CNNs of similar or larger sizes than the qpa-NNs were included in the hyperparameter optimization space of the CNNs [Hothem et al., 2024b] .Nonetheless, comparing the qpa-NNs to the CNNs is somewhat unfair as the CNNs were trained on out-of-distribution circuits-they were trained on the entire training dataset from Hothem et al.[2024b] which also contains low-PST circuits. For a fairer comparison, we fine-tuned each CNN (Fig. 2 , ) on the same high-PST training set used to train the qpa-NNs. Fine-tuning typically increased the CNNs' performances (mean 25.1% improvement, σ x = 22.3%). However, the qpa-NNs achieve a MAE that is lower than the fine-tuned CNNs by 32.2% on average (σ x = 17.3%) and outperform the fine-tuned CNNs on all six datasets. K is between 10 28 and 10 238 , which is overwhelming evidence that the qpa-NNs are better models than the fine-tuned CNNs.Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material? Answer: [Yes] Justification: We plan to provide open access to all the data and code used in the paper through a GitHub repository. We also provide explicit instructions on how to access the experimental data in Appendix B. Guidelines:• The answer NA means that paper does not include experiments requiring code. Justification: We report error bars on the mean absolute error of the models' predictions in Section 6. We do not report error bars on the models' predictions in the experimental data as the original paper [Hothem et al., 2024b] reported their error bars as being trivial. However, we do provide the standard deviation of the percent change in the MAE across the experimental datasets, and we report Bayes factors for each model on each experimental dataset, demonstrating substantial improvement by the physics-aware networks.Guidelines:• The answer NA means that the paper does not include experiments.• The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper. • The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions). • The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.) • The assumptions made should be given (e.g., Normally distributed errors). • It should be clear whether the error bar is the standard deviation or the standard error of the mean. Justification: We believe that we have conducted our research in a manner that conforms, in every respect, with the NeurIPS Code of Ethics. The only relevant areas of concern are the use of deprecated datasets and respect for copyright and fair use. We believe that we have not violated either of these requirements, although the cloud-accessed processors used in the experimental section are no longer available (but the datasets are not deprecated).Guidelines:• The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.• If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics. • The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction). 
4-qubit simulations: 
 One reason why the extra infrastructure in our qpa-NNs may be necessary is that off-the-shelf networks struggle with modeling coherent errors [Hothem et al., 2024b] . To test our hypothesis, we trained a qpa-NN to predict the fidelity F (c) of random circuits executed on a hypothetical 4-qubit quantum computer experiencing purely coherent errors. We compared this qpa-NN to a hyperparameter-tuned CNN trained on the same data. Figure 3 shows the results from one representative dataset.The qpa-NNs again significantly outperform the CNNs. Across the five datasets, the qpa-NNs' averaged a 52.4% reduction in MAE (σ x = 3.00%) on the test data. We also see a significant improvement in the mean Pearson correlation coefficient, rqpa-NN = .968 vs. rCNN = .749.We also found that qpa-NNs trained on random circuits are modest predictors of the infidelity of random mirror circuits, which are a different family of circuits. This is an example of out-ofdistribution generalization. Random mirror circuits differ in a variety of ways from the random circuits on which the qpa-NNs were trained, including both the presence of idle gates (which are noiseless in our simulations) and a motion-reversal structure in the circuits that causes the addition or cancellation of errors that are far apart in time. The qpa-NNs achieve an average MAE of .72% on the random mirror circuits (σ x = .046%). Although this is a 3.2× increase in MAE over the in-distribution test data, the strong linear relation between the network's predictions and the ground truth (r = .912, σ x = .009) strongly suggests that the qpa-NNs are learning information relevant to random mirror circuits. 
100-qubit simulation: 
 Quantum-physics-aware neural networks scale just as well as CNNs, despite their extra infrastructure.To demonstrate their scalability, we trained a qpa-NN to predict the fidelity F (c) of random circuits executed on a hypothetical 100-qubit quantum computer experiencing a mix of stochastic and coherent errors. To our knowledge, this is the first creation of a capability model of any kind, for a 100+ qubit quantum computer. Figure 3 (c) shows the results from our demonstration.The qpa-NN achieved a MAE of 0.097%. While the underlying noise model was quite simple, this result shows that it is technically feasible to construct qpa-NN capability models for today's moderate-scale quantum computers and for tomorrow's early fault-tolerant quantum computers. 
limitations: 
 Our results are a significant improvement over the state of the art, but our approach does have several limitations:1. As presently conceived, our approach assumes that the modelled quantum computer's error rates are invariant under time translations, which is a kind of Markovianity assumption (although it is weaker than the typical Markovian assumption used in conventional quantum computer models [Nielsen et al., 2021] ). However, non-Markovian noise exists in quantum computers [White et al., 2020] . In the future, we plan to address this issue by adding temporal information into our approach, perhaps with a temporal or positional encoding [Vaswani et al., 2017] .2. Our approach only considers two error classes (H and S errors). Other Markovian error classes, like amplitude damping, exist, but their error rates ε contribute to PST and fidelity at order O(ε 3 ) [M ądzik et al., 2022] . Our approach can be easily extended to include those errors, if necessary, by learning their rates with N and updating f to account for their presence.3. Our current approach works for Clifford circuits, which includes arguably the most important kinds of circuits (e.g., quantum error correction circuits) but not all interesting circuits. This is because our method for efficiently propagating errors through circuits (implemented by f together with the S and P matrices) leverages the elegant mathematics of Clifford circuits.Our approach can be easily extended to generic few-qubit quantum circuits ( 10 qubits), but to obtain the efficiency needed for large n with general circuits we will need to develop approximate methods for propagating errors through those circuits.In this paper, we presented a new quantum-physics-aware neural network architecture for modelling a quantum computer's capability that significantly improves upon the state of the art. The new architecture concatenates two parts: (i) a neural network with structural similarities to GNNs that uses gate information and a quantum computer's connectivity graph to predict the rates of errors in each of a circuit's layers, and (ii) a non-trainable function that turns the predicted error rates into a capability prediction. By imbuing these networks with knowledge about how errors occur and combine within a circuit, we are able to outperform state-of-the-art CNN-based capability models by ∼ 50% on both experimental data and simulated data. We also provided evidence that our quantum-physics-aware networks are learning the true physical error rates, as they exhibit modest prediction accuracy when predicting the fidelity of out-of-distribution quantum circuits, which would enable our networks to also be used to diagnose the error processes occurring in a particular quantum computer (an important task known as characterization or tomography [Nielsen et al., 2021] ).Understanding which quantum circuits a quantum computer can run, and how well it can run them, is an important yet challenging component of understanding a quantum computer's power. Given the complexity of the problem, neural networks are likely to play a large role in its solution. As our results demonstrate, our new physics-aware network architecture could play a critical role in building fast and reliable neural network-based capability models.All of the quantum-physics-aware neural networks used in our 5-qubit experiments and 4-qubit simulations were trained using a 6-Core Intel Core i9 processor on a MacBookPro 15.1 with 32GB of memory. Each model took roughly 15-20 wall clock minutes to train. Total training time, across the paper, totaled ∼ 160 wall clock minutes.All of the 4-qubit simulations and data pre-processing were performed using a 6-core Intel Core i9 processor on a MacBookPro 15.1 with 32GB of memory. Each dataset took approximately 1 hour of wall clock time to create. This total includes the initial circuit creation, simulating the circuits, and encoding each circuit into a tensor.All of the 100-qubit simulations, data pre-processing, and model training were performed using two 14-core Intel Xeon CPU E5-2697 v3 @ 2.60GHz processors. An end-to-end run (i.e., circuit generation to trained model predictions) took roughly 12 hours of wall clock time.The simulated data as well as records of all the quantum physics-aware networks will be released publicly once they clear Sandia's copyright process. Until then, please email the authors. The CNNs and 5-qubit experimental datasets used in Hothem et al. [2024b] are available at Hothem et al. [2023a] . The datasets were originally located at Proctor et al. [2021b] . Each dataset was released under a CC-BY 4.0 International license.All simulations were performed using a combination of pygsti version 0.9.11.2 [Nielsen et al., 2020] and stim version 1.13.0 [Gidney, 2021] . Models were trained and developed using Keras version 2.12.0 [Chollet et al., 2015] and TensorFlow version 2.12.0 [Abadi et al., 2015] . The physics-aware network model classes (CircuitErrorVecScreenZErrorsWithMeasurementsBitstrings for PST and CircuitErrorVec for process fidelity) are available in the Supplementary Material [Hothem et al., 2024a] as well as on the featureml branch of pygsti. 1 : Summary data of every dataset used in the paper. The data for the 4-qubit ring processors is averaged over the 5 simulated datasets. See Figure 4 for images of each processor geometry (i.e., the qubit connectivity graph).We provide additional details on the datasets used in the paper. Table 1 summarizes each dataset. We tracked all weight-2 errors with support on qubits connected by 2 hops in all, but the 100-qubit datasets. Below, we provide additional details on the circuit and error model generating processes. In this subsection, we go over how the random i.i.d.-layer circuits and random mirror circuits were created for this paper. We start by explaining how we generated the random i.i.d.-layer circuits for a 4-qubit ring processor, and then explain the modifications needed to generate the random mirror circuits. This subsection's content is conceptual. The actual circuits were created in pygsti using the code in the Supplementary Material.Each random i.i.d.-layer circuit c was created by a multi-step process. First, we randomly sampled a connected subset Q c ⊆ {Q0, Q1, Q2, Q3} of qubits for which c is designed for. Then, we uniformly sampled c's depth from between 1 and d w , a pre-determined, circuit-width-dependent maximum depth. The depths d w were selected to ensure that F (c) > 85% given the maximum error strengths used to create the simulated error model (Section C.2). Third, we randomly sampled a two-qubit gate density ρ 2Q between 0 and 2/3. The density ρ 2Q determines the average number of two-qubit gates in each of c's layers. We then sampled each layer i.i.d. from all possible circuit layers on the qubits in Q c .The random mirror circuits were generated using a similar multi-step process with two differences. The first difference is that we used a pre-determined maximum depth of d w /6. We chose to reduce the pre-determined, circuit-width-dependent maximum depth so that the deepest random mirror circuits had roughly the same length as the deepest random i.i.d. circuits. The second difference is that we created a random mirror circuit on Q c . See Proctor et al. [2021a] for more details.In this subsection, we explain how we constructed the 4-qubit Markovian local coherent error model used in Section 6. Again, we provide a conceptual explanation. The actual error model was created in pygsti using the code found in the Supplementary Material.The 4-qubit Markovian local coherent error model was specified using the error generator framework explained in Section 2 and Blume-Kohout et al. [2022] . The error model consists of operationdependent errors sampled according to a two-step process. The error strengths for each gate and qubit(s) pairs were independently sampled. First, we sampled an overall error strength ε g for each oneand two-qubit gate g by randomly sampling from [0, 1] and scaling by a pre-determined maximum error strength (.025%). Then we sampled the relative error strengths ε g,rel of each of the 4 n -1 coherent errors, where n = 1, 2 for one-and two-qubit gates, respectively. We then normalized ε g,rel to obtain the actual error strengths according to the following equation:ε g = √ ε g • ε g,rel i ε 2 g,i.(8)The re-scaling ensures that, to first order, gate g contributes approximately ε g to the circuit's process infidelity (or PST, if appropriate).In this subsection, we explain how we constructed the 100-qubit Markovian error model used in Section 7. As with the 4-qubit error model, we provide a conceptual explanation. The actual error model was created in pygsti.As with the 4-qubit error model, the 100-qubit Markovian error model was specified using the error generator framework explained in Section 2. The error model consisted of gate-dependent errors sampled according to a two-step process. Unlike with the 4-qubit error model, the 100-qubit error model included non-local Pauli stochastic and coherent errors, and the errors for each gate were independent of the qubit acted upon by the gate. Moreover, all of the errors in the 100-qubit error model are weight-1 errors (i.e., they affect a single qubit).Each gate's error strengths were independently sampled. First, we enumerated all 600 possible weight-1 Pauli stochastic and coherent errors in a 100-qubit device. Then, for each gate g, we independently sampled the strength of each of the 300 weight-1 Pauli stochastic errors and the 300 possible weight-1 coherent errors. The strengths were sampled uniformly random, with a maximum Pauli stochastic error strength of 0.0000001 and a maximum coherent error strength of 0.00005. The resulting 600 error strengths were assembled into a 600-dimensional error vector for the gate, ε g .In this subsection, we describe the first-order simulation method used to approximate F (c) in our 100-qubit simulations (Section 4.3). The method works by constructing an approximate error matrix Readers should refer to Section 3 for an in-depth explanation on how to use E(c) to estimate F (c).For each circuit c, we constructed an approximate error matrix E(c) by concatenating approximate error vectors E i (c) for each circuit layer in c. Each layer's error vector was computed as a linear combination of the individual gate error vectors, with coefficients equal to the number of times each gate appears in the circuit layer. [30, 20, 10, 5, 5 , 1] Table 2 : Summary data for the quantum-physics-aware networks used in the paper.Table 2 briefly outlines the hyperparameters and model sizes of the physics-aware neural networks used in this paper. The N hops and N errors hyperparameters were chosen by hand based upon subjectmatter-expert knowledge of the errors in a quantum computer. The size and shape of the dense layers were selected arbitrarily. All dense subunits used a ReLU activation function. All models were trained using keras's Adam [Kingma and Ba, 2015] optimizer with a step size of 10 -3 and with mean squared error as the loss function. Model training was cut short using early stopping. To help with training, we scaled PST(c) and F (c) by 10000 when training the physics-aware networks. The notebooks in the Supplementary Material contain more details.Details on the specific convolutional neural networks used in this paper are located in Hothem et al. [2024b] . We fine-tuned each network on high-PST experimental data using the Adam optimizer and early stopping.We selected the model architecture for the convolutional neural networks used in our simulations via hyperparameter tuning. We performed 100 trials of hyperparameter tuning using the BayesianOptimization class in kerastuner. Additional details, including the specific hyperparameter space, are located in the Supplementary Material. 3 : Summary model performance data on experimental data.Table 3 summarizes model performance on each of the experimental datasets used in the paper.Copies of the pre-trained quantum-physics-aware neural networks, original CNNs, and fine-tuned CNNs are available in the Supplementary Material. Scatter plots of each model's predictions are also available in the Supplementary Material.Table 4 summarizes model performance on each of the 4-qubit simulated datasets used in the paper.Copies of the pre-trained quantum-physics-aware neural networks and fine-tuned CNNs are available in the Supplementary Material. Scatter plots of each model's prediction errors are also available in the Supplementary Material.• The answer NA means that the paper does not include experiments.• If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not. • If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable. • Depending on the contribution, reproducibility can be accomplished in various ways.For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed. • While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. (d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility.In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results. 
broader impacts: 
 Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?Answer: [NA] Justification: We believe that there is little to no societal impact of our work. We believe that the following quote from the checklist guidelines is relevant: "it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster." While quantum computers might some day have a large societal impact, our work does not directly improve their ability to run programs with societal impact.Guidelines:• The answer NA means that there is no societal impact of the work performed.• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. • Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.• The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML). 
safeguards: 
 Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?Answer: [NA] Justification: Our paper poses no such risks.Guidelines:• The answer NA means that the paper poses no such risks.• Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters. • Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images. • We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.12. Licenses for existing assets Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?Answer: [Yes] Justification: We explicitly reference each existing dataset in the References, and state each existing datasets license in Appendix B. All existing assets were licensed under a CC-BY 4.0 license, requiring proper attribution.Guidelines:• The answer NA means that the paper does not use existing assets.• The authors should cite the original paper that produced the code package or dataset.• The authors should state which version of the asset is used and, if possible, include a URL. • The name of the license (e.g., CC-BY 4.0) should be included for each asset.• For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided. • If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset. • For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided. • If this information is not available online, the authors are encouraged to reach out to the asset's creators. 
new assets: 
 Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?Answer: [Yes] Justification: At the time of submission, we have released code used in Section 6 and the new simulated dataset in the supplemental material. In the future we will release additional assets, such as the models trained on experimental data, publicly after receiving approval from our employer. Guidelines:• The answer NA means that the paper does not release new assets.• Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc. • The paper should discuss whether and how consent was obtained from people whose asset is used. • We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution. • For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.38th Conference on Neural Information Processing Systems (NeurIPS 2024).We use our qpa-NNs to model the capability of a simulated 100-qubit device; the largest ever neural network capability learning demonstration by a factor of two.We demonstrate, for the first time, how to train NNs to predict the process fidelity[Nielsen, 2002] of a circuit, which is the most widely used quantum channel error metric.We provide evidence that the improved performance of our qpa-NNs is partly due to their ability to better model the effect of coherent errors, which are known to be challenging for other state-of-the-art methods. 
 
 Appendix:  


Decision: The paper introduces a neural network to predict quantum capability, namely quantifying the noise in the quantum circuit. The work focuses on Clifford gates which can be simulated efficiently and presents experiments on quantum devices as well. The method improves the state of the art for predicting the behaviour of a quantum computer using classical neural networks, an important direction in quantum computing. The rebuttal addresses some of the questions on scalability and related work.

Reviews: review: paper_summary: paper_summary: The paper presents an approach to improve the state of the art in quantum capability learning, which is the task to predict the prowess for error when running a specific quantum algorithm given a fixed quantum computer. The tackle this, the authors introduce some specializations on (graph) neural networks that fit the nature of quantum computers and their errors especially well. The new approach yields better results than purlely CNN-based methods on a specific synthetic and empirical data.
strength_weakness: strength_weakness: To be frank, I consider the issue of quantum capabilty learning (especially as it is motivated in this paper) a rather artificial one, given the quite small number of potentially useful quantum algorithms. And I think this leads to some rather weak arguments, mostly in the motivation of this paper. However, quantum capability learning (as the authors examine it in this paper) is still an interesting and relevant topic. I suggest cutting down on practical promises and focusing on the pure challenge of predicting a quantum computer's behavior using classical neural networks, which I consider a sufficient motivation for the study of this topic.

While the performance-based analysis has good results, I would have wished for a more in-depth take that can actually clarify the speculation posed in the introduction: "Our qpa-NNs' improved performance is likely largely due to their improved ability to model the impact of coherent errors..."
questions: questions: None.
limitations: limitations: No comments.
paper_summary: paper_summary: This paper introduces a neural-network-based architecture for quantum capability learning. The idea is to utilize the architecture to predict rates of errors in quantum circuits. The authors compared their qpa-NN with previous CNN-based method and elucidated their improved performance.
strength_weakness: strength_weakness: 1. Given that neural network-based methods for predicting circuit success probability have been previously discussed in the literature, the novelty of the approach is not sufficiently convincing. 
2. The explanation of how the qpa-NNs leverage graph structures could benefit from further elaboration to enhance clarity. 
3. The scope of the considered noise types is limited, and the authors have benchmarked their results exclusively on small-scale devices.
questions: questions: 1. Have the authors compared their qpa-NN with the so-called “stability baseline model”, (which was mentioned to be better than CNN-based method Hothem et al. [2023c]) ?
limitations: limitations: There does not seem to be negative social impact of this theoretical research.
paper_summary: paper_summary: The paper introduces a novel quantum-physics-aware neural network (qpa-NN) architecture for quantum capability learning. The model achieves error reduction in capability prediction on both experimental and simulated data.
strength_weakness: strength_weakness: 1. The reviewer's main concern is regarding the qubit scale of the dataset. However, the dataset used in the experiments, which consists of maximum 5 qubits, appears too small both from the perspective of current quantum hardware and classical simulations. The reviewers are curious to know the reason behind the inability to collect data on systems with more qubits (either experimental data or simulated data). Is it due to the high difficulty of experimental deployment, or is it because the current models struggle to train on larger datasets?

2. The evaluation method mentioned in the paper, Process Fidelity (Eq. 3), may have scalability issues. Although the authors attempted to explain in Section 3.2 how some approximations can be used to calculate Eq. 3 relatively efficiently, this description is hard to follow. For instance, can the proposed approximation method avoid exponential computational and storage complexity? Additionally, the reviewer hope that in the revised version, the authors can provide a discussion on the differences between the approximations designed in this paper and the estimation methods in [Proctor et al., 2022], or if the approximations in this paper are merely direct adaptations of the latter's estimation methods.
questions: questions: How does the proposed architecture handle scalability challenges as the number of qubits increases?
limitations: limitations: The authors have discussed the limitations.

Comments: comment: I do not agree with the points made here.

Most importantly, the fact that the qpa-NN's performance scales better with quantum noise compared to a classical approach still is not a sufficient argument that handling quantum noise is the reason for that performance.

I advise to be cautious about making too grand claims in either case.
Thanks for the response. Most of my questions are solved. I would happy to raise my score.
Thank you for your detailed response. A good portion of my concerns have been addressed.