Precise image generation on current noisy quantum computing devices

The quantum angle generator (QAG) is a new full quantum machine learning model designed to generate accurate images on current noise intermediate scale quantum devices. Variational quantum circuits form the core of the QAG model, and various circuit architectures are evaluated. In combination with the so-called MERA-upsampling architecture, the QAG model achieves excellent results, which are analyzed and evaluated in detail. To our knowledge, this is the first time that a quantum model has achieved such accurate results. To explore the robustness of the model to noise, an extensive quantum noise study is performed. In this paper, it is demonstrated that the model trained on a physical quantum device learns the noise characteristics of the hardware and generates outstanding results. It is verified that even a quantum hardware machine calibration change during training of up to 8% can be well tolerated. For demonstration, the model is employed in indispensable simulations in high energy physics required to measure particle energies and, ultimately, to discover unknown particles at the large Hadron Collider at CERN.


Introduction
Quantum computing has the potential for a new paradigm in future computing to accelerate tasks or even handle classically unsolvable problems [1].In the current Noise Intermediate Scale Quantum (NISQ) era, quantum devices suffer from non-negligible hardware errors, limited connectivity and a limited number of qubits [2].While practical quantum advantage is currently extremely difficult to accomplish, finding the best suited algorithms to effectively combat the problems of NISQ-era devices remains a widely researched topic.Quantum Machine Learning (QML) is a domain which achieves acceptable results on NISQ devices due to the observed robustness against noise [3].
High Energy Physics (HEP) experiments, such as those at the Large Hadron Collider (LHC) at CERN, require enormous amounts of simulated data for deriving high precision physics results [4].To handle this demand, gigantic quantities of computing hardware resources are necessary, which has led to the creation of the world's largest computing grid operated by CERN [5].To alleviate this strain on computational resources, Machine Learning (ML) models have been developed that exhibit remarkable speed-ups over current Monte Carlo-based simulations while maintaining the required level of accuracy.In general, QML simulations represent a promising approach to address the only further increasing simulation demands in the future [6,7].QML employs quantum circuits which exploit the quantum properties of superposition and entanglement, which possess the potential to outperform neural networks, their classical analogue [8].In addition, QML might have the advantage of learning more complex distributions with fewer parameters than classical ML due to their wider accessible phase space.
Encoding the classical data into qubit states on quantum computers is a non-trivial task [9].Currently, many encoding techniques exist, each exhibiting specific advantages and disadvantages, and in practice, identifying "the best" encoding technique remains application dependent [9].To achieve a potential quantum advantage over classical computing, theoretical studies suggest that at least linear scaling from qubits to features is required [10].On the other side, models which employ better than linear scaling encoding techniques have drawbacks, making them unsuitable for generating precise images on NISQ devices.For example, amplitude encoding can only generate probability distributions and not absolute pixel entries, i.e. energy values.
At present, there exist several quantum generative models, for example, the Quantum Circuit Born Machine (QCBM) [11], Quantum Variational Autoencoders [12] or variations of quantum Generative Adversarial Networks [13][14][15].They all face limitations.Some models either do not scale well in terms of qubits required relative to the number of encoded features, or they do not achieve a satisfying level of fidelity.The Quantum Angle Generator (QAG) presented in this paper and first introduced in reference [16], aims to overcome these problems.Employing angle encoding with linear scaling of qubits to features, it achieves extremely accurate results for a real-world problem on current physical noisy quantum devices.
Fig. 1: An example 3D calorimeter shower image.A primary particle enters the calorimeter at (x, y, z) = (13, 13, 0) and generates a secondary particle shower along the z-axis.
The paper content is structured as follows.First, the HEP use case is motivated and the training data is defined.Next, the QAG model and the employed angle encoding technique are presented.Then, multiple circuit architectures are compared and the advantages of the best ones are highlighted.An in-depth accuracy analysis of the model follows to highlight its excellent precision.The quantum hardware noise behavior is evaluated, including training and inference executed on real quantum devices.Lastly, conclusions are drawn and summarized.

High Energy Physics Simulations
Simulations remain a crucial component of HEP analysis to evaluate the results obtained by the processed data of the experiments.Currently, simulations are performed predominantly with Monte Carlo methods such as the Geant4 toolkit [17].However, Monte Carlo simulations are very hardware resource demanding and occupy half of the worldwide LHC Computing Grid [18].Future LHC experiments will require more simulations due to more energetic particles, simultaneous collisions and detectors constructed with higher granularity.However, the projected budget for hardware development and computing resources cannot keep pace with these increasing demands [19,20].As a result, ML alternatives to Monte Carlo methods are being actively researched.Initial prototypes predict significant reductions in simulation time and hardware resources while retaining acceptable levels of accuracy [21][22][23].This research goes one step beyond classical ML.Since HEP data sets are generally created by underlying quantum mechanical effects, performing the computations on quantum devices which likewise make use of quantum effects has the potential to substantially enhance the simulations in accuracy and in terms of sustainable computing.
Electromagnetic calorimeters are constructed as high granularity sensor grids to measure the energy of photons, electrons, and positrons through Fig. 2: The structure of the Quantum Angle Generator.complex particle shower generation processes in space and time [24].They constitute a key component of HEP detectors to measure the energy of the particles produced in the interaction process and occupy most of the simulation time [18].Calorimeter outputs can be interpreted at lowest order as static and spatial 3D images, which we call "shower images": the value of each pixel corresponds to the energy measured in a specific calorimeter cell.The initial data from reference [25] consists of 25 × 25 × 25 pixel images.An example of a 3D shower image is visualized in figure 1.To reduce the dimensionality, the images are averaged along two spatial axes (x-and y-direction), resulting in a one-dimensional representation that is further downsampled to eight pixels by averaging three contiguous pixels along the z-direction.Although the initial data set provides many different energies, for simplicity this study focuses on images recorded by particles in the energy range of [225,275] GeV.The data set is split into a training and test set, each consisting of approximately 1 000 samples.The downsampled data is available in reference [26], and an example image is illustrated later in this paper in figure 6a.

The Quantum Angle Generator
The QAG represents a QML model which employs the well established technique of angle encoding [27,28] to generate extremely precise images.It scales linearly with the number of encoded features.Thus, the generation of n features requires n qubits.In this study, the number of features corresponds to the number of pixels.A comprehensive description of the QAG model, its objective training function, and an evaluation of several quantum circuits are provided below.

Model Description
The QAG model consists of variational quantum circuits trained by an objective function.The model structure is visualized in figure 2. All qubits are initialized in the basis state |0⟩.The state preparation function implements a Hadamard (H) gate to constitute superposition, followed by a y-rotational (Ry) gate to introduce randomness so that the model can draw new samples at each execution.For this, the Ry gate angles Ω are randomly drawn from a [-1, The unitary transformation consists of quantum circuits and constitutes the trainable part of the QAG model.Various circuit architectures were tested as documented in section 3.3.
To convert the quantum states back into classical energy values via angle encoding, the model must be executed multiple times and the quantum states measured.The number of executions is commonly denoted as the number of shots nb shots .It is counted how often state |0⟩ is measured.The scalar intersection I of the vertical axis on the Bloch sphere (z-axis) and the angle θ is calculated with: The angle θ operates in the x-z-plane of the Bloch sphere and is defined as zero in the |+⟩ state.Rotating θ clockwise leads to positive angles.The decoding process is visually illustrated in figure 3a with an example state |Ψ⟩, its intersection I and the corresponding angle θ for a single qubit example.The angle θ can then be transformed into a pixel energy E by the linear change of ranges equation: E max , E min , θ max and θ min are defined in figure 3b: the minimum energy E min = 0 MeV is set to θ = −π/2 and the maximum energy E max = 0.6 MeV is set to θ = +π/2.With E min = 0 and θ max = −θ min equation 2 can be simplified into: For multi-qubit quantum circuits: the final quantum states of all qubits are measured, and the outcomes are decoded independently.Although the qubit results are individually decoded, the state of each qubit is entangled with others due to the gates applied within the variational quantum circuit, as lined out later.
It is worth to be noted that the angle θ and, therefore, the corresponding decoded energy E remain in discrete values.Since, θ depends in value and accuracy on the number of shots nb shots : the larger nb shots , the better the achievable energy precision and resolution.Fortunately, with present quantum devices, the nb shots can be easily chosen to be large.Currently, on IBMQ devices the maximum possible number of shots is nb shots = 100 000.For the simplified calorimeter use case, this is more than sufficient.For comparison, in a previous classical reduced precision ML research in reference [29], it is demonstrated that already 256 discrete energy levels are sufficient for correctly reproducing the full-size calorimeter shower image.In this reduced precision research, the parameters of the neural network are quantized from a larger format (floating point 32) down to a smaller number format (integer 8).This study will show that 512 shots provide a sufficient resolution.The detailed image generation process for the QAG model, as described in this subsection, is provided as an algorithm in the appendix A.

Training Objective Function
The QAG model is trained with two losses employed as objective functions.The first one is the Mean Maximum Discrepancy (MMD) loss [30,31], already successfully applied by other quantum models, e.g. the QCBM [11].Training exclusively with the MMD loss resulted in good average shower distributions.However, when exploring the generated images in more detail, for example in the pixel correlation, the model did not perform satisfactorily.Therefore, a second correlation (Corr) loss is added to help learn the patterns present in the training data (e.g., image pixel correlations).The Corr loss is calculated by the pixel-wise mean squared error (MSE) between the pixel correlation values present in the training data and the ones inside the generated data.The pixel-wise correlations are illustrated in figure 6b.
To train the QAG model, the Simultaneous Perturbation Stochastic Approximation (SPSA) optimizer [32] is employed, which only requires two optimization steps per epoch.The hyperparameters for training were found by extensive hyperparameter searches employing the Optuna [33]

Quantum Circuit Study
The ideal circuit should contain a certain, optimized to be minimal, number of parameters to achieve a sufficient level of accuracy.Different circuit architectures were compared to each other based on characteristic numbers expressing the power of the circuit.The circuits employ trainable rotational gates and two-qubit entanglement gates.As the angle encoding primarily uses the qubits y-axis component, we predominantly employ Ry gates.For some circuit architectures, we test if additional z-rotational gates (Rz gates) or deeper circuits with depth 2 (denoted as d2) can further improve the results.We use two-qubit controlled-not gates (cx gates) native on IBM Quantum (IBMQ) [34] devices; while other entanglement gates are compositions of multiple native gates of the hardware.Keeping an eye on the goal of executing the training on a real quantum device, the absolute number of decomposed gates should be kept as small as possible.
The characteristic circuit numbers used in this study are the number of trainable parameters N p , the expressibility X and the entanglement capability E. Larger circuits with more trainable parameters are potentially capable of achieving more accurate results.However, it might be that a plateau is reached at some point where the same task can be solved with similar accuracy by a smaller circuit, which is being investigated here.The definitions for X and E are from reference [35]: X describes how well the circuit can represent the pure states of the representative Hilbert space.For a single qubit the expressibility exhibits how many states of the Bloch sphere can be represented.In this paper, we measure 1 − X: the closer to 1 the better the expressibility of the model, while the closer to 0 the worse.The entanglement capability E is a measure that expresses the ability of a circuit to generate entangled states between the qubits.Likewise, E ranges from 0 to 1, where 1 represents the best achievable value.The circuit architectures under study are introduced in the appendix B. Their corresponding characteristic numbers and theoretical potential are provided in the appendix C. In the following, the circuits are evaluated for the calorimeter use case.
We start by interpreting the results displayed in figure 4. The MSE accuracy metric is calculated by taking the pixel-wise MSE between the average Geant4 and QAG images.The training is repeated 25 times for each circuit and the mean and standard deviations are plotted.To prevent the influence of outliers, the best and worst two trials are discarded in this analysis.The MSE is given as a function of: N p on the left, X in the middle, and E on the right.By inspecting the plots, it can be recognized that the MSE does not correlate with The MERA-up, MERA-up d2, and MERA-up Rz architecture perform best with the lowest MSE.This is consistent with the observation that they maintain a high X and E, as provided in the appendix B. The error bars provide a hint about the training stability.It can be observed that the better the average MSE of a model, the smaller its standard deviation.
All in all, the MERA-up Rz circuit clearly performs best considering the characteristic circuit values and the achieved accuracy in training.However, with the emphasis on a low number of N p , the plain MERA-up circuit performs almost as well, while needing only half the number of parameters.Therefore, the following studies employ the MERA-up circuit for training the QAG model.

In-depth Accuracy Analysis
In this section, we analyze the results of the QAG model operating the MERA-up circuit architecture.We showcase typical accuracy metrics for the calorimeter simulation in HEP.

Training Evaluation
In a first step, the statistical trends of the objective functions during training are investigated.In figure 5

Inference Evaluation
In the following, the accuracy in inference is evaluated.The generated images of the best trained model are compared to the Geant4 test data, which consists of 980 images.Likewise, there are 980 images generated by the QAG model to create the following accuracy metrics.The details about how the accuracy metrics are calculated are provided in the appendix D.
1. Average calorimeter shower shape: The first metric represents the calorimeter shower shape displayed in figure 6a.The shower shape is perfectly reproduced by the QAG model.The MSE corresponds to 0.00059 ± 0.00037, which is extremely close to zero, indicating a very good accuracy.

Pixel-wise correlation:
The second metric corresponds to the pixelwise image correlation.The positive or negative correlation patterns between all the pixels are determined.The baseline represents the correlation from Geant4 in figure 6b.The correlation for the generated data of the QAG model is presented in figure 6c.It can be derived that the overall correlation pattern is accurately reproduced by the QAG model.Like the Geant4 data, it consists of a larger and more compact positively correlated group of pixels.The other pixels are negatively correlated.Inspecting the particular details, different color shades indicate some minor deviations.However, the achieved correlation precision by QAG is astonishing.Therefore, it can be concluded, that the quantum circuits are capable to reproduce complex correlation patterns through substantial entanglement strategies, as present in the MERA-up architecture.

Energy sum:
The energies contained in all pixels calculated for the individual images represent the third accuracy metric.In figure 7a, the energy sum histogram of the Geant4 images reveals a Gaussian shape and is correctly reproduced visually by the QAG model, which is also confirmed by the mean µ and the standard deviation σ.
4. k-means Clusters: This metric evaluates if the QAG model can correctly represent specific image modes.The Geant4 data is clustered with the k-means algorithm [36] to find four clusters or image modes as illustrated in figure 7b.Cluster 0 deposits substantially larger fractions of energy in earlier calorimeter cells than in higher cluster numbers.Further, the particles from clusters 0 and 1 contain a larger energy fraction, estimated by the integral area below the curves.Here we are interested in whether the QAG model can reproduce this behavior.The four clusters of the QAG images are provided in figure 7c.A similar structure can be observed, which indicates a good accuracy in reproducing the energy contents and image modes on average.

Pixel-wise energy distribution:
The last metric is used to examine the distributions of the energy content of each pixel, as illustrated in figure 8. Overall, the histograms of the QAG model match those of the Geant4 model.Even pixels with non-Gaussian energy distributions in the Geant4 model are correctly reproduced by the QAG model.For example, the longer tail towards smaller energies on the left side of pixel 4 is equally present in the histogram for the QAG model.The large histogram overlaps indicate that not only the averages are reproduced with high accuracy, but also the energy distributions returned for each individual pixel are correct.

Quantum Noise Study
In the current NISQ era, relatively high hardware error levels are one of the primary limitations to effectively employing algorithms on real quantum devices.Similar as in the classical case, QML models appear to be noise resilient to some degree of hardware errors [37][38][39][40].In the following, the robustness of Fig. 9: Inference noise study.On the x-axis the noise levels are provided and on the y-axis the MSE as accuracy metrics (the lower, the better).Inference is executed with various noise configurations and on real quantum hardware.At each point, twenty images are generated.
the QAG model to simulated noise is tested in inference and training.Furthermore, training and inference are executed on real quantum devices with measured noise levels and compared to the results with simulated noise.

Inference
In a first step, quantum noise is applied only to the inference of a model trained without noise.Inference is performed using three different noise configurations: simulated noise at varying levels, simulated noise derived from the later used hardware, and finally, with the real quantum hardware.In the simulated noise configurations, each qubit noise is modeled with the same readout measurement error, and each inter-qubit connection with the same two-gate (CNOT) error.In the combined noise model both are on the same level.In contrast, the hardware noise levels can vary widely for individual qubits as well as for gates.
Multiple noise configurations and error levels from zero up to 15% are tested.The MSE is utilized as the accuracy measure.The results are illustrated in figure 9.For each configuration, the average value of 20 generated images is plotted in dependence of the noise level as a solid line and the standard deviation as a colored band around the mean.The gray horizontal line serves as accuracy reference for the noise-free configuration.All configurations maintain sufficient accuracy up to approximately 1.5% of noise.The configuration with readout noise only (green) is most robust and maintains a stable accuracy of up to 8% of noise.CNOT noise only (blue) and both readout noise and CNOT noise combined (orange) experience a stronger impact.As expected, the combined configuration (orange) performs worst.As a side note, current quantum devices have average noise levels below 5%, which is expected to gradually decrease further.But as discussed in the following, the noise levels are unstable and can sometimes spike up.Therefore, wider noise ranges were investigated.
Next, the inference is run by loading the real hardware noise model from ibmq montreal into the simulator.The ibmq montreal device consists of a Falcon r4 processor with 27 qubits.The average readout noise over the qubits employed at the time of the test is 2.51% and the average gate noise level is 0.97%.The explicit noise model, containing the entries for each qubit, is provided in the appendix in figure 11b.The result is included in figure 9 (blue triangle).The noise level position (x-axis) is determined as the average of readout and CNOT noise.Although the noise levels of the qubits vary strongly, the measured accuracy of the hardware noise simulation agrees well with the simulated noise in mean and standard deviation within the uncertainties.This suggests that a model trained without any noise would theoretically be able to run inference on noisy hardware without a significant drop in accuracy.
Finally, the inference is executed on the real ibmq montreal device.The result is plotted as a red triangle in figure 9.The accuracy on the real hardware is worse than predicted by the simulation, as indicated by a larger MSE value.The decomposition of the circuit to the real hardware includes swap operations, which imply additional two-qubit entanglement gates for the quantum circuit.It is possible that these are not included in the hardware noise simulation and lead to higher noise influence on real hardware and thus to worse results.

Training
The noise study is repeated to include noise also during training.We study if the QAG model can learn to compensate for noise in training, especially when running on the real quantum device.Besides, we investigate with which noise values the model can still maintain a reasonable accuracy.
The results are provided in figure 10.The configurations with readout noise (green) and CNOT noise (blue) maintain a similar level of accuracy until approximately 3%.The accuracy of the combination of readout and CNOT noise (orange) decreases marginally from 1% of noise and further with larger noise levels.However, at 3% of noise, its accuracy is still close to the noiseless case, staying within one standard deviation.This indicates that training the model with noise makes the QAG model more robust than only applying noise to a trained model in inference only.
Next, two quantum devices are simulated.ibmq montreal and ibm cairo, which are both 27 qubit devices, but ibm cairo has the more advanced Falcon r5.11 processor.Likewise, the training is repeated ten times and the results are added as blue and orange triangles in figure 10.It can be noted that the average accuracy of the training with hardware noise performs slightly worse than the simulated combined noise model (orange line).The strong overlap between the error from the noise simulation (orange band) and the hardware noise simulation (orange and blue error bar) indicates that the accuracy difference is statistically not significant.The results of both hardware training are included as red and green triangles in figure 10.The error bars correspond to the accuracy deviations within 50 generated validation images.It can be observed that the average accuracy of the ibmq montreal hardware training (red) is visibly worse than the noise simulation (blue).This is most likely due to the large noise increase and the fact that the model did not have enough remaining epochs to fully recover.This is also indicated by the still decreasing losses towards the end of the training.As mentioned above, the training was repeated on the more stable machine ibm cairo.This time, the training was completed without calibration changes and with about 1% lower hardware noise level (readout noise 0.86% and CNOT noise 0.89%).The accuracy of the hardware training on ibm cairo (green) is only marginally worse than the one from the simulator (orange).This indicates that the simulated and real hardware results behave similarly for low hardware noise levels.This fulfills the expectations derived from the pure simulation that exhibit only statistically insignificant variations in the very good accuracy at these low noise levels.Comparing the absolute MSE magnitude of the real hardware training (≈ 0.002 and ≈ 0.003) with the one from inference from the previous section (≈ 0.005), the accuracy improved, suggesting that the QAG model is able to adapt its parameters to the noisy hardware to improve its precision.This is also confirmed by the ibmq montreal training, where the accuracy worsened entirely after the calibration change, but then recovered.In the appendix in figure E3a, the average shower image created by the ibmq montreal device is visualized, and in figure E3b by ibm cairo.The shower image of ibm cairo agrees well with Geant4, whereas ibmq montreal exhibits some deficiencies because of the missing remaining training epochs after the calibration.

Conclusion
The results of this study clearly demonstrate that the newly developed QAG model is capable of generating images with good precision, as measured with a variety of validation metrics.This includes correctly reproducing average values, but most importantly, also complex pixel-wise correlations with the chosen optimal MERA-up quantum architecture.These results reveal that the QAG model with a good entangled circuit is capable of learning intrinsic correlation patterns from the training data.
Our study exhibit the significant impact that quantum hardware noise can have on the accuracy of quantum machine learning models.The results evidence that training the models with noise leads to better performance (stable until 3% noise) because the QAG model adapts to the underlying noise behavior and converges faster in contrast to the situation of applying noise in inference only (stable until 1.5% noise).This was also verified on the real hardware by the ibm cairo training.Furthermore, our study shows that the QAG model is robust and can produce accurate results even with significant hardware calibration changes with up to 8% noise, as demonstrated by the training on ibmq montreal.Overall, the newly developed QAG model demonstrates that training quantum machine learning models with realistic quantum hardware noise can lead to robust models and accurate results, which is of great importance for the future development of real world quantum machine learning applications.accuracy.Both architecture variants double the number of parameters of the initial circuit.For the MERA architecture, further variations are analyzed where only the right circuit half from the original architecture is implemented, denoted as the MERA upsampling (MERA-up) circuit.In the MERA-up circuit, the information is upsampled from the central qubit and spread to all the other qubits, similar to what happens in classical ML generative models, for example, transpose convolutional neural networks.The left half of the MERA circuit, the MERA downsampling (MERA-down) architecture, is not tested because it would rather compress the information as required in classification tasks that are not used in this paper.The last architecture contains a simple linear entanglement strategy.
In reference [35], multiple complex four-qubit architectures are compared.However, these architectures are not exploited in our study.The reason is most of them contain many more gates and parameters, and they do not scale well for more than four qubit circuits.Also, many architectures employ parameterized two-qubit rotational gates which we found, taking the decomposition into account, not as effective as the combination of separate rotation and entanglement gates.The results of evaluating the characteristic circuit numbers (number of parameters N p , expressibility X and entanglement capability E) are shown in figure C2.In figure C2a E is plotted as a function of X.The MERA Rz and MERA-up d2 Rz architecture perform best and lie almost on top of each other in the top right corner, directly followed by MERA-up Rz and TTN Rz.The Linear architecture and the basic TTN perform worst.It can be clearly noted that circuits with more gates (Rz, d2) perform better.N p is studied in figure C2b and figure C2c.It can be seen that the best two circuits -MERA Rz and MERA-up d2 Rz -contain by far the largest number of parameters.However, a more limited number of parameters is desirable to address NISQ hardware limitations.The MERA-up Rz and TTN Rz architectures contain approximately half the number of parameters compared to the MERA Rz and MERA-up d2 Rz circuits but perform almost similarly accurately.Therefore, they may be preferred in practice.Further reducing the number of parameters, the MERA-up architecture with only N p = 23 parameters maintains adequate values for E and X and is the baseline circuit for the more detailed studies.All characteristic circuit numbers measured in the circuit study are summarized in table C1.In the table, it is evident that the MERA-up circuit maintains a considerably lower training time on the classical hardware compared to models with a higher number of parameters.The training was executed on a cluster equipped with 32 Intel Xeon Gold 6130 CPU cores running at 2.10GHz.

Appendix D Definitions of Accuracy Metrics
In this section, we provide detailed formulas for the inference accuracy metrics discussed in section 4.2.

D.1 MSE of the Average Shower Shape
The Mean Squared Error (MSE) for the average calorimeter shower shape is derived from the difference between the average images of Geant4 and the QAG model, calculated over 980 generated inference images and the corresponding 980 Geant4 images.In the subsequent equations, k iterates over the N = 980 images and i denotes the i th pixel of each image.Hence, E G4 k, i (Geant4) and E QAG k, i (QAG model) correspond to the energy of pixel i from image k.The average pixel energies E G4 i and E QAG i are computed as follows: The MSE is then calculated by iterating over the M = 8 individual pixels by the index i: As the MSE corresponds to an error, the smaller the value, the better the accuracy of the QAG model.

Fig. 3 :
Fig. 3: (a) Decoding of an example state Ψ into an angle θ.(b) Some representative angles θ and its corresponding energy values.
library.All tests in this study are executed in Qiskit version 0.26.2.The models are trained for 500 epochs, containing one batch.The dynamic MMD loss weight starts at a value of one and decays linearly with −0.001•epoch, starting from epoch 100.Opposite, the Corr loss weight increases by the same value starting at zero.The dynamical training batch size is set to generate one image in the first hundred epochs and afterward to 20 images to calculate the Corr loss between multiple images.Each quantum job contains 512 shots for training and inference.The generator SPSA optimizer learning rate is set to c 0 = 1 with an exponential learning rate decay of 0.006 starting from epoch 50.All these settings showed the best performance in the tests.

Fig. 4 :
Fig. 4: The MSE uncertainty (the smaller, the better) of the various trained circuit architectures as a function of N p (left), X (middle) and E (right), see text for explanations.Green rectangles mark optimal areas.

Fig. 5 :
Fig. 5: The unweighted loss values the training epochs.The blue lines correspond to the MMD losses and the green lines to the Corr losses.The thick solid line represents the mean loss across trials, the colored band around indicates the standard deviation (STD), and the thin line denotes the loss of the best trial's loss.

Fig. 6 :Fig. 7 :
Fig. 6: (a) Visualization of the average calorimeter shower shapes.The energy is given in an arbitrary unit (a.u.) due to image downsampling.The pixel-wise correlation plot for (b) Geant4 and (c) the QAG model.The correlation ranges between -1 and 1; a value of 1 indicates a perfect positive correlation.

Fig. 8 :
Fig. 8: The energy deposition histograms for Geant4 and the QAG model.Each histogram represents the energy distribution for an individual pixel, as labeled above each plot.The x-axes represent the energies on a consistent scale across all histograms.The y-axes count the hits per energy bin, with each hit corresponding to the energy contained in a pixel for a single image.Note the varying y-axis scales.

Fig. 10 :
Fig. 10: Training noise study.On the x-axis the noise levels are provided and on the y-axis the MSE as accuracy metrics (the lower, the better).Training is executed with various noise configurations and on real quantum hardware.The training with fake noise levels are repeated ten times.

Fig. 11 :Fig. 12 :
Fig. 11: The noise levels of the ibmq montreal device are shown (a) before and (b) after the calibration change during training.The lower x-axes displays qubit indices as provided at the IBMQ hardware, while the upper x-axes represents their usage in the quantum circuit (e.g., in figure B1, counting from top to bottom).Inference is performed with the noise model (b), where it is notable that the readout noise of qubit number five on the hardware increased from two to over eight percent.Note the different y-axis scales.

Fig. B1 :
Fig. B1: The basic quantum circuit architectures under study.Top left: TTN architecture, top right: Linear entanglement architecture, bottom: the full circuit corresponds to the MERA architecture, with the red highlighted section corresponding to the MERA-up architecture.
Fig. C2: Study of potential correlations between the three characteristic circuit numbers.On the left: X versus E. In the middle: N p versus X.On the right: N p versus E.
Fig. E3: On the left, the average shower images of the QAG model are trained on ibmq montreal and in the middle on ibm cairo.The correlation plot on the right is created for the ibm cairo training.

Table C1 :
The characteristic circuit values N p , X and E are listed.Additionally, the statistics of the MSE accuracy metrics and the training times t in minutes are provided for the individual circuits for repeating the training 25 times on the calorimeter data set.