SuperEncoder: Towards Iteration-Free Approximate Quantum State Preparation

Venue: NeurIPS_cc_2024_Conference
Published: 2024-04-23 09:02:14

Abstract: Numerous quantum algorithms operate under the assumption that classical data has already been converted into quantum states, a process termed Quantum State Preparation (QSP). However, achieving precise QSP requires a circuit depth that scales exponentially with the number of qubits, making it a substantial obstacle in harnessing quantum advantage. Recent research suggests using a Parameterized Quantum Circuit (PQC) to approximate a target state, offering a more scalable solution with reduced circuit depth compared to precise QSP. Despite this, the need for iterative updates of circuit parameters results in a lengthy runtime, limiting its practical application. To overcome this challenge, we introduce SuperEncoder, a pre-trained classical neural network model designed to directly estimate the parameters of a PQC for any given quantum state. By eliminating the need for iterative parameter tuning, SuperEncoder represents a pioneering step towards iteration-free approximate QSP.

Main paper: 
 introduction: 
 Quantum Computing (QC) leverages quantum mechanics principles to address classically intractable problems [47, 36] . Various quantum algorithms have been developed, encompassing quantumenhanced linear algebra [15, 48, 45] , Quantum Machine Learning (QML) [26, 19, 1, 33, 50, 3] , quantum-enhanced partial differential equation solvers [31, 13] , etc. A notable caveat is that those algorithms assume that classical data has been efficiently loaded into a specific quantum state, a process known as Quantum State Preparation (QSP).However, the realization of QSP presents significant challenges. Ideally, we expect each element of the classical data to be precisely transformed into an amplitude of the corresponding quantum state. This precise QSP is also known as Amplitude Encoding (AE). However, a critical yet unresolved problem of AE is that the required circuit depth grows exponentially with respect to the number of qubits [34, 41, 29, 46, 49] . Extensive efforts have been made to alleviate this issue, but they fail to address it fundamentally. For example, while some methods introduce ancillary qubits for shallower circuit [57, 56, 2] , they may encounter an exponential number of ancillary qubits. Other methods aim at preparing special quantum states with lower circuit depth, being only effective for either sparse states [12, 32] or states with some special distributions [14, 17] . To summarize, realizing AE for arbitrary quantum states still remains non-scalable due to its exponential resource requirement with respect to the number of qubits. Moreover, in the Noisy Intermediate-Scale Quantum (NISQ) era [42] , hardware has limited qubit lifetimes and confronts a high risk of decoherence errors when executing deep circuits, further exacerbating the problem of AE.In fact, precise QSP is unrealistic in the present NISQ era due to the inherent errors of quantum devices. Hence, iteration-based Approximate Amplitude Encoding (AAE) emerges as a promising technique [59, 35, 52] . Specifically, AAE constructs a quantum circuit with tunable parameters, then Submitted to 38th Conference on Neural Information Processing Systems (NeurIPS 2024). Do not distribute.it iteratively updates the parameters to approximate a target quantum state. Since the updating of parameters can be guided by states obtained from noisy devices, AAE is robust to noises, becoming especially suitable for NISQ applications. More importantly, AAE has been shown to have shallow circuit depth [35, 52] , making it more scalable than AE. 1 .Unfortunately, AAE possesses a drawback that significantly undermines its potential advantages -the lengthy runtime stemming from iterative optimizations of parameters. For example, when a Quantum Neural Network (QNN) [3] is trained and deployed, the runtime of AAE dominates the inference time as we demonstrated in Fig. 1 .Since loading classical data into quantum states becomes the bottleneck, the potential advantage of QNN diminishes no matter how efficient the computations are done on quantum devices.Compared to AAE, AE employs a pre-defined arithmetic decomposition procedure to construct a circuit, thereby becoming much faster than AAE at runtime. Therefore, it is natural to ask: can we realize both fast and scalable methods for arbitrary QSP? This is precisely the question we tackle in this paper. Overall, we present three major contributions.• Given a Parameterized Quantum Circuit (PQC) U (θ) that approximates a target quantum state, with θ the parameter vector. We show that there exists a deterministic transformation f that could map an arbitrary state |d⟩ to its corresponding parameters θ. Consequently, the parameters can be designated by f without time-intensive iterations.• We show that the mapping f is learnable by utilizing a classical neural network model, which we term as SuperEncoder. With SuperEncoder, you can have your cake and eat it too, i.e., simultaneously realizing fast and scalable QSP. We develop a prototype model and shed light on insights into its training methodology.• We verify the effectiveness of SuperEncoder on both synthetic dataset and representative downstream tasks, paving the way toward iteration-free approximate quantum state preparation. 
preliminaries: 
 In this section, we commence with some basic concepts about quantum computing [36] , and then proceed to a brief retrospect of existing QSP methods.We use Dirac notation throughout this paper. A pure quantum state is defined by a vector |•⟩ named 'ket', with the unit length. A state can be written as |ψ⟩ = Applying quantum operations evolves a system from one state to another. Generally, these operations can be categorized into quantum gates and measurements. Typical single-qubit gates include the Pauli gates X ≡ [ 01 1 0 ], Y ≡ 0 -i i 0 , Z ≡ 1 0 0 -1 . These gates have associated rotation operationsR P (θ) ≡ e -iθP/2, where θ is the rotation angle and P ∈ {X, Y, Z} A quantum circuit is the graphical representation of a series of quantum operations, which can be mathematically represented by a unitary matrix U . In the NISQ era, PQC plays an important role as it underpins variational quantum algorithms [11, 39] . Typical PQC has the form of U (θ) = i U i (θ i )V i , where θ is its parameter vector, U i (θ i ) = e -iθiPi/2 with P i denoting a Pauli gate, and V i denotes a fixed gate such as CNOT. For example, a PQC composed of R y gates and CNOT gates is depicted in Fig. 2 . |0⟩ R y (θ 0 ) R y (θ 4 ) |0⟩ R y (θ 1 ) R y (θ 5 ) |0⟩ R y (θ 2 ) R y (θ 6 ) |0⟩ R y (θ 3 ) R y (θ 7 ) Block # 0 Block # 1 Approximated state of |d⟩Successful execution of many quantum algorithms requires an initial step of loading classical data into a quantum state [5, 15] , a process known as quantum state preparation. This procedure involves implementing a quantum circuit to evolve a system to a designated state. Here, we focus on amplitude encoding and formalize its procedure as follows. Let d be a real-valued N -dimensional classical 34, 41] . This property makes AE impractical in current NISQ era, as decoherence errors [23] can severely dampen the effectiveness of AE as the number of qubits increases [52] .In response to the inherent noisy nature of current devices, approximate amplitude encoding has emerged as a promising technique [59, 35, 52] . Specifically, AAE utilizes a PQC (a.k.a. ansatz) to approximate the target quantum state by iteratively updating the parameters of circuit, following a similar procedure of other variational quantum algorithms [39, 11] . AAE has been shown to be more advantageous for NISQ devices due to its ability to mitigate coherent errors through flexible adjustment of circuit parameters, coupled with its lower circuit depth [52] . We denote an ansatz as U (θ), where θ refers to a vector of tunable parameters for optimizations. A typical ansatz consists of several blocks of operations with the same structure. For example, a two-block ansatz with 4 qubits is shown in Fig. 2 , where the rotation layer is composed of single-qubit rotational gates R y (θ r ) = e -iθrY /2 , and the entangler layer comprises CNOT gates. Note that the entangler layer is configurable and hardware-native, which means that we can apply CNOT gates to physically adjacent qubits, thereby eliminating the necessity of additional SWAP gates to overcome the topological constraints [27] . This type of PQC is also known as hardware-efficient ansatz [20] , being widely adopted in previous studies of AAE [59, 35, 52] .3 SuperEncoderQuestion: Does the paper discuss the limitations of the work performed by the authors?Answer: [Yes] Justification: SuperEncoder sacrifices fidelity, as discussed in Section 4.4. 
motivation: 
 Although AAE can potentially realize high fidelity QSP with O(poly(n)) circuit depth [35] with n the number of qubits, it requires repetitive online tuning of parameters to approximate the target state, which may result in an excessively long runtime that undermines its feasibility. Specifically, we could consider a simple application scenario in QML. The workflow with AAE is depicted in Fig. 3a .During the inference stage, we must iteratively update the parameters of the AAE ansatz for each input classical data vector, which may greatly dampen the performance. 1 : Performance overhead of AAE. We break down the averaged inference runtime per sample from the MNIST dataset. T AAE denotes time spent on loading classical data into quantum state using AAE, and T total refers to total runtime. The necessity of time-intensive iterations is grounded in the following assumption -Given an arbitrary quantum state |ψ⟩, there does not exist a deterministic transformation f : |ψ⟩ → θ, where θ refers to the vector of parameters enabling a PQC to prepare an approximated state of |ψ⟩. This assumption seems intuitively correct given the randomness of target states. However, we argue that a universal mapping f exists for any arbitrary data state |ψ⟩. Taking a little thought of AE, we see that it implies the following conclusion: given an arbitrary state |ψ⟩, there exists an universal arithmetic decomposition procedure g : |ψ⟩ → U satisfying U |0⟩ = |ψ⟩. Inspired by this deterministic transformation, it is natural to ask: is there an universal transformation g ′ : |ψ⟩ → U ′ satisfying E(U ′ |0⟩, |ψ⟩) ≤ ϵ? Here E denotes the deviation between the prepared state by a circuit U ′ and the target state, and ϵ refers to certain acceptable error threshold. Since the structure of PQC in AAE is the same for any target state, U ′ is determined by θ. Then, the problem is reduced to exploring the existence of f : |ψ⟩ → θ. Should f exist, the overhead of online iterations could be eliminated, resulting in a novel QSP method being both fast and scalable. Let |ψ⟩ be the target state, and U (θ) be the PQC used in AAE with θ the optimized parameters.Our goal is to develop a model, termed SuperEncoder, to approximate the mapping f : |ψ⟩ → θ.Referring back to the scenario in QML, the workflow with SuperEncoder becomes iteration-free, as depicted in Fig. 3b .Since neural networks could be used to approximate any continuous function [6] , a natural solution is to use a neural network to approximate f . Specifically, we adopt a Multi-Layer Perceptron (MLP) as the backbone model for approximating f . However, training this model is nontrivial. Particularly, we find it challenging to design a proper loss function. In the remainder of this section, we explore three different designs and analyze their performance. Unfortunately, results in Table 2 show that L 1 achieves poor performance. The average fidelity of prepared quantum states is only 0.6208. As demonstrated in Fig. 4 , L 1 generates a state that losses the patterns of the original state. Additionally, utilizing L 1 implies that we need to first generate target parameters using AAE, of which the long runtime hinders pre-training on larger datasets. Consequently, required is a more effective loss function design without involving AAE. To address this challenge, we propose a state-oriented training methodology, which employs quantum states as targets to guide optimizations. Specifically, we may apply θ to the circuit and execute it to obtain the prepared state ψ. Then it is possible to calculate the difference between ψ and ψ as the loss to optimize SuperEncoder.In contrast to parameter-oriented training, this approach applies to larger datasets as it decouples the training procedure from AAE. We utilize two different state-oriented metrics, the first being the MSE between ψ and ψ, denoted as L 2 , and the second is the fidelity of ψ relative to ψ, expressed as L 3 = 1 -|⟨ ψ|ψ⟩| 2 [25] . Results in Table 2 show that L 2 and L 3 achieve remarkably higher fidelity than L 1 . Besides, we observe that L 3 prepares a state very similar to the target one (Fig. 4 ), verifying that state-oriented training is more effective than parameter-oriented training.Landscape Analysis. To understand the efficacy of these loss functions, we further analyze their landscapes following previous studies [28, 40, 18] . To gain insight from the landscape, we plot Fig. 6 using the same scale and color gradients [18] . Compared to state-oriented losses (L 2 and L 3 ), L 1 has a largely flat landscape with non-decreasing minima, thus the model struggles to explore a viable path towards a lower loss value, a similar pattern can also be observed in and L 3 have much lower minima and successfully converge to smaller loss values. Furthermore, we observe from Fig. 6 that L 3 has a wider minima than L 2 , which may indicate a better generalization capability [40] .Gradient Analysis. Based on the landscape analysis, we adopt L 3 as the loss function to train SuperEncoder. We note that L 3 can be written as1 -⟨ψ| ψ⟩⟨ ψ|ψ⟩. If ρ is a pure state, it is equivalent to | ψ⟩⟨ ψ|. Then L 3 is given by L 3 = 1 -⟨ψ|ρ|ψ⟩.This re-formalization is important as only the mixed state ρ could be obtained in noisy environments.Suppose an n-qubit circuit is parameterized by m parameters θ = [ θ1 , . . . , θk , . . . , θm ]. Let W be the weight matrix of MLP, with k, l the element indices. We analyze the gradient ofL 3 w.r.t. W k,l toshowcase its feasibility in different quantum computing environments.EQUATIONThe calculation of ∂θj ∂W k,l can be easily done on classical devices using backpropagation supported by automatic differentiation frameworks. Therefore, we only focus on ∂ ρi,j ∂θ k . In a simulation environment, the calculation of ρ is conducted via noisy quantum circuit simulation, which is essentially a series of tensor operations on state vectors. Therefore, the calculation of∂ ρi,j∂θ k is compatible with backpropagation. The situation on real devices becomes more complicated. On real devices, the mixed state ρ is reconstructed through quantum tomography [7] based on classical shadow [55, 16] .Here, for notion simplicity, we denote the process of classical shadow as a transformation S, and denote the measurement expectations of the ansatz as U ( θ). Thus the reconstructed density matrix is given by ρ = S(U ( θ)). Then the gradient of ρi,j with respect to θk is u ∂ ρi,j ∂U ( θ)∂U ( θ) ∂ θk .Here ∂ ρi,j ∂U ( θ) can be efficiently calculated on classical devices using backpropagation, as S operates on expectation values on classical devices. However, U ( θ) involves state evolution on quantum devices, where back-propagation is impossible due to the No-Cloning theorem [36] . Fortunately, it is possible to utilize the parameter shift rule [8, 4, 53] to calculate ∂U ( θ) ∂θ k . In this way, the gradients of the circuit function U with respect to θ j are ∂U ( θ)∂θ k = 1 2 (U (θ + ) -U (θ -)), whereθ + = [θ 1 , . . . , θ k + π 2 , . . . , θ m ], θ -= [θ 1 , . . . , θ k -π 2 , . . . , θ m ].To summarize, training SuperEncoder with L 3 is theoretically feasible on both simulators and real devices.4 Numerical ResultsQuestion: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?Answer: [Yes] Answer: [Yes] Justification: See Section 4.1. 
experiment setup: 
 Datasets. To train a SuperEncoder for arbitrary quantum states, we need a dataset comprising a wide range of quantum states with different distributions. To our knowledge, there is no dataset dedicated for this special purpose. A natural solution is to use readily available datasets from classical machine learning domains (e.g., ImageNet [9] , Places [58] , SQuAD [44] ) by normalizing them to quantum states. However, QSP is essential in various application scenarios besides QML. The classical data to be loaded may not only contain natural images or languages but also contain arbitrary data (e.g., inHHL algorithm [15] ). Therefore, we construct a training dataset adapted from FractalDB-60 [21] with 60k samples, a formula-driven dataset originally designed for computer vision without any natural images. We also construct a separate dataset to test the performance of QSP, which consists of data sampled from different statistical distributions, including uniform, normal, log-normal, exponential, and Dirichlet distributions, with 3000 samples per distribution. Hereafter we refer this dataset as the synthetic dataset.Platforms. We implement SuperEncoder using PennyLane [34] , PyTorch [37] and Qiskit [43] .Simulations are done on a Ubuntu server with 768 GB memory, two 32-core Intel(R) Xeon(R) Silver 4216 CPU with 2.10 GHz, and 2 NVIDIA A-100 GPUs. IBM quantum cloud platform2 is adopted to evaluate the performance on real quantum devices.Metrics. We evaluate SuperEncoder and compare it to AE and AAE in terms of runtime, scalability, and fidelity. Runtime refers to how long it takes to prepare a quantum state. Scalability refers to how the circuit depth grows with the number of qubits. Fidelity evaluates the similarity between prepared quantum states and target quantum states. Specifically, the fidelity for two mixed states given by density matrices ρ and ρ is defined asF (ρ, ρ) = Tr √ ρρ √ ρ 2 ∈ [0, 1]. A larger F indicates a better fidelity.Implementation. We implement SuperEncoder using an MLP consisting of two hidden layers.The dimensions of input and output layers are respectively set to 2 n and m, where n refers to the number of qubits and m refers to the number of parameters. We adopt L 3 as the loss function.Training data are down-sampled, flattened, and normalized to 2 n -dimensional state vectors. We adopt the hardware efficient ansatz [20] (Fig. 2 ) as the backbone of quantum circuits and use the same structure for AAE. Given a target state, a pre-trained SuperEncoder model is invoked to generate parameters and thus the circuit for QSP. While for AAE, we employ online iterations for each state. For AE, the arithmetic decomposition method in PennyLane [34, 4] is adopted. We defer more details about implementation to Appendix A. Our framework is open-source at https: //anonymous.4open.science/r/SuperEncoder-A733 with detailed instructions to reproduce our results.For simplicity and without loss of generality, we focus our discussion on the results of 4-qubit QSP tasks. The outcomes for larger quantum states are detailed in Appendix B.1. The parameters of both AAE and SuperEncoder are optimized based on ideal quantum circuit simulation.Runtime. The runtime and fidelity results, evaluated on the synthetic dataset, are presented in Table 3 .We observe that SuperEncoder runs faster than AAE by orders of magnitudes and has a similar runtime to AE, affirming that SuperEncoder effectively overcomes the main drawback of AAE. Scalability. Although AE runs fast, it exhibits poor scalability since the circuit depth grows exponentially with the number of qubits. The depth of AAE is empirically determined by increasing depth until the final fidelity does not increase, same depth is adopted for SuperEncoder. We deter the details of determining the depth of AAE/SuperEncoder to Appendix A. As shown in Fig. 7a Fidelity. From Table 3 , it is evident that SuperEncoder experiences notable fidelity degradation when compared with AAE and AE. Specifically, the average fidelity of SuperEncoder is 0.9307, whereas AAE and AE achieve higher average fidelities of 0.9994 and 1.0, respectively. Note that, although AE demonstrates the highest fidelity under ideal simulation, its performance deteriorates significantly in noisy environments. Fig. 7b presents the performance of these three QSP methods on quantum states with 4, 6, and 8 qubits on the ibm_osaka machine. While the fidelity of AE is higher than AAE/SuperEncoder on the 4-qubit and 6-qubit states, its fidelity on the 8-qubit state is only 0.0049, becoming much lower than AAE/SuperEncoder.This decline is primarily attributed to its large circuit depth as shown in Fig. 7a . Quantum Machine Learning. We first apply SuperEncoder to a QML task. MNIST dataset is adopted for demonstration, we extract a sub-dataset composed on digits 3 and 6 for evaluation.The quantum circuit that implements a QNN is depicted in Fig. 8 , Phase Estimation [10] (QPE) to estimate the eigenvalue of A (iii) Apply conditioned rotation gates on ancillary qubits based on the eigenvalues (R). (iv) Apply an inverse QPE (QPE_inv) and measure the ancillary qubits to reconstruct the solution vector x. Note that, HHL does not return the solution xwhichitself, but rather an approximation of the expectation value of some operator M associated with x, e.g.,x † Mx. Here, we adopt an optimized version of HHL proposed by Vazquez et al. [51] for evaluation.To compare the performance between different QSP methods, we construct linear equations with fixed matrix A and operator M, while we sample different vectors from our synthetic dataset as b. The results of our evaluation can be concluded in two folds.(i) SuperEncoder effectively eliminates the iteration overhead of AAE, thereby becoming both fast and scalable.However, it has a notable degradation in fidelity. (ii) The impact of fidelity degradation varies across different downstream applications. For QML, the fidelity degradation is affordable as long as the prepared states are distinguishable across different classes. However, algorithms like HHL rely on precise QSP to produce the best result. In these algorithms, SuperEncoder suffers from higher error ratio than AAE.Note that, the current evaluation results may not reflect the actual performance of SuperEncoder on real NISQ devices.Recent work has shown that AAE achieves significantly better fidelity than AE does [52] . This is due to the intrinsic noise awareness of AAE, as it could obtain states from noisy devices to guide updating parameters with better robustness. In essence, the proposed SuperEncoder possesses the same nature as AAE. Unfortunately, although the noise-robustness of AAE can be evaluated on a small set of test samples, it is difficult to perform noise-aware training for SuperEncoder as it requires a large dataset for pre-training. Consequently, SuperEncoder relies on huge amounts of interactions with noisy devices, thereby becoming extremely time-consuming. As a result, the effectiveness of SuperEncoder in noisy environments remains largely unexplored, which we leave for future exploration. More discussion about this perspective is in Appendix C. 
related work: 
 Besides QSP, there are other methods for loading classical data into quantum states. These methods can be roughly regarded as quantum feature embedding primarily used in QML, which maps classical data to a completely different distribution encoded in quantum states. A widely used embedding method is known as angle embedding. Li et al. have proven that this method has a concentration issue, which means that the encoded states may become indistinguishable as the circuit depth increases [26] .Lei et al. proposed an automatic design framework for efficient quantum feature embedding, resolving the issue of concentration [24] . The central idea of this framework is to search for the most efficient circuit architecture for a given classical input, which is also known as Quantum Architecture Search (QAS) [38, 30, 54] . While the application scenario of quantum feature embedding is largely limited to QML, QSP has broader usage in general quantum applications, distinguishing SuperEncoder from all aforementioned work. 
conclusion: 
 In Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?Answer: [Yes] Justification: We illustrate the experimental settings in Section 4.1, and provides additional details in Appendix A. 
experiment statistical significance: 
 Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?Answer: [No] Justification: Throughout our experiments, we set the random seed to be fixed for all libraries we used. 
code of ethics: 
 Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines? 
broader impacts: 
 Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?Answer: [NA] Justification: This work has no societal impact. 
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: This paper poses no such risks as our released model and datasets are only able to be used for quantum state preparation. 
new assets: 
 Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?Answer: [Yes] Justification: We submit our assets in zip file and also put them on the anonymous github repository, we have included a README file with detailed descriptions. 
crowdsourcing and research with human subjects: 
 Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?Answer: [NA] Justification: This paper does not involve crowdsourcing nor research with human subjects. 
 
 Appendix: In this section, we elaborate the missing details of SuperEncoder in the main text.The overarching workflow of SuperEncoder is illustrated in Fig. 10 . The target quantum states are input to the MLP model. Then, the MLP model generates predicted parameters based on the target states. Afterwards, the parameters are applied to the PQC to obtain the prepared quantum states.Finally, we calculate the loss based on the prepared states and target states and optimize the weights of MLP through backpropagation. The settings of MLP and PQC are as follows. (batch_size, dim(θ)) Table 5 : MLP based SuperEncoder. n refers to the number of qubits. θ denotes the parameter vector.PQC. The circuit structure is the same with the one depicted in Fig. 2 , except that the number of blocks is determined dynamically through empirical examinations. Specifically, we utilize AAE to approximate a target state while increasing the number of blocks. The number of blocks is designated when the resulting state fidelity no longer increases. For example, Fig. 11 demonstrates how fidelity changes while increasing the number of blocks. As one can observe, the fidelity converges when the number of layers is larger than 8. Hence, the number of layers is set to be 8 for 4-qubit quantum states. We follow the same procedure to set the number of blocks for other state sizes. Each block has the same structure, consisting of a rotation layer and an entangler layer. Given an n-qubit system, a rotation layer comprises n R y gates, each operating on a distinct qubit. The entangler layer is composed of two CNOT layers. The first CNOT layer applies CNOT gates to {(q 0 , q 1 ), (q 2 , q 3 ), . . . }, and the second CNOT layer applies CNOT gates to {(q 1 , q 2 ), (q 3 , q 4 ), . . . }. Hence, the depth of a block is 3. Let l be the number of blocks; then the dimension of the parameter vector is given by dim(θ) = n × l, and the depth of AAE/SuperEncoder is 3 × l. We conclude the settings of AAE/SuperEncoder used throughout this study in Table 6 . Training Hyperparameters for SuperEncoder. Throughout our experiments, the number of epochs are consistently set to be 10. For 4-qubit states, we set bath_size to 32, while we set it 64 for 6-qubit and 8-qubit states. We adopt Adam optimizer [22] with a learning rate of 3e-3 and a weight decay of 1e-5.Hyperparameters for AAE. To optimize the parameters of AAE, we also use the Adam optimizer, with a learning rate of 1e-2 and zero weight decay. For all quantum states, we train the AAE for 100 steps.In line with the main text, we train the SuperEncoder for 6-qubit and 8-qubit quantum states using FractalDB-60 as the training dataset. Then we evaluate the performance of SuperEncoder on the synthetic test datasets. As shown in As a preliminary investigation, the optimal model architecture for SuperEncoder still requires further exploration. Currently, we have set the size of the hidden units at a constant 512 (Table 5 ). However, as the number of qubits, n, increases, a wider network architecture may become necessary. To showcase the impact of model width, we adjust the size to 4 × 2 n for 6-qubit states and 16 × 2 n for 8-qubit states, and compare their performance with the original settings, as shown in Table 8 . As evident from the results, this simple adjustment significantly enhances the fidelity of SuperEncoder, suggesting that there is substantial potential to boost SuperEncoder's performance by developing a more tailored network architecture. 8 : Impact of increasing network width. Here h refers to the size of hidden units.n = 6 n = 8 Dataset h = 512 h = 4 × 2 6 h = 512 h = 16×2In addition to refining the model architecture, the development of a specially designed dataset for pre-training SuperEncoder is essential. Currently, the dataset utilized is FractalDB [21] , which is originally designed for computer vision tasks. However, given the wide range of applications of QSP, there is a need to accommodate diverse types of classical data from various domains. Therefore, how to create a comprehensive dataset that could fully unleash the potential of SuperEncoder remains an open question. While developing a pre-trained model that performs well in all kinds of applications may be challenging, we advocate for a strategy that combines pre-training with fine-tuning for the practical deployment of SuperEncoder, similar to the approach used with foundation models in classical machine learning. To substantiate this approach, we have compiled a separate dataset that encompasses a variety of statistical distributions not limited to those utilized for evaluation (but with different settings). As demonstrated in 9 : Fidelity improvements after fine-tuning SuperEncoder using a dataset consisting of different distributions.Although we have theoretically analyzed the feasibility of training SuperEncoder using states from real devices (Section 3.2), its practical implementation poses significant challenges. Specifically, state-of-the-art quantum tomography techniques, such as classical shadow [55, 16] , require numerous snapshots, each measuring a distinct observable.To train SuperEncoder, each sample in the training dataset necessitates one classical shadow to obtain the prepared state. For instance, with the FractalDB-60 dataset, one training epoch requires 60,000 classical shadows. Our experiments on the IBM cloud platform reveal an average runtime of 3.02 seconds per circuit job excluding queuing time. Suppose the number of snapshots is 1000, then the total runtime to train SuperEncoder for 10 epochs is about 1,812,000,000 seconds3 , roughly 57 years, making the process prohibitively expensive and time-consuming.However, quantum tomography is under active investigation, and we expect more efficient techniques to emerge for acquiring noisy quantum states from real devices. Additionally, with the advancement of quantum computing system, future systems may have tightly integrated quantum-classical heterogeneous architectures (shorter runtime per job) while being capable of executing numerous quantum circuits in parallel (jobs within a classical shadow can execute in parallel). Hence, we anticipate the training of SuperEncoder to be feasible in the future. Guidelines:• The answer NA means that the abstract and introduction do not include the claims made in the paper.• The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.• The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.• It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.• The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.• The authors are encouraged to create a separate "Limitations" section in their paper.• The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.• The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.• The authors should reflect on the factors that influence the performance of the approach.For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.• The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.• If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.• While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.• The answer NA means that paper does not include experiments requiring code.• Please see the NeurIPS code and data submission guidelines (https://nips.cc/ public/guides/CodeSubmissionPolicy) for more details.• While we encourage the release of code and data, we understand that this might not be possible, so "No" is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).• The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines (https: //nips.cc/public/guides/CodeSubmissionPolicy) for more details.• The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.• The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.• At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).• Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.• The answer NA means that the paper does not include experiments.• The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.• The full details can be provided either with the code, in appendix, or as supplemental material.• 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.• It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.• For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).• If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text. • The answer NA means that the paper does not include experiments.• The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.• The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.• The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper).Justification: We have read the code of ethics and followed its requirements.• 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).• 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).• 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? • 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.• 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.• At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.• The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.• Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper. • 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.In this paper, Rz, Ry are equivalent to RZ , RY .https://quantum-computing.ibm.com/10 × 1000 × 60000 × 3.02 


Decision: This paper studied quantum state preparation, an important problem in quantum computing. The algorithm is named SuperEncoder, a pre-trained classical neural network model designed to directly estimate the parameters of a parametrized quantum circuit for any given quantum state. 

The discussion between authors and reviewers were adequate during the discussion period, and the authors attempted to address concerns raised from reviews about scalability, barren plateau, runtime, etc. However, as a summary, the paper has a main concern that the data distribution scope can be selective, whereas literature in quantum state preparation typically works for preparing an arbitrary quantum state (see for instance [1] below and references therein). In addition, there is a concurrent work [2] that was a published paper back in 2023, and the authors are obliged to clarify more about its technical novelty.

In all, although there are interesting points raised by the paper, its current version is not ready for NeurIPS 2024 from the perspective of Area Chairs, but it is encouraged that the authors can incorporate all the discussions and prepare well for the next venues.

[1] Xiao-Ming Zhang, Tongyang Li, and Xiao Yuan. "Quantum state preparation with optimal circuit depth: Implementations and applications." Physical Review Letters 129, no. 23 (2022): 230504.

[2] Chao-Chao Li, Run-Hong He, and Zhao-Ming Wang. "Enhanced quantum state preparation via stochastic predictions of neural networks." Physical Review A 108.5 (2023): 052418.

Reviews: review: paper_summary: paper_summary: The paper addresses the problem of Quantum State Preparation (QSP), which is critical for quantum computing but requires a circuit depth that scales exponentially with the number of qubits, making it impractical for large-scale problems. The authors propose SuperEncoder, a pre-trained classical neural network model designed to estimate the parameters of a Parameterized Quantum Circuit (PQC) for any given quantum state. This approach eliminates the need for iterative parameter tuning, making it a significant advancement towards iteration-free approximate QSP. 

Contributions

1. Introduction of SuperEncoder, which pre-trains a classical neural network to estimate PQC parameters directly, bypassing the need for iterative updates.
2.  Provides empirical evidence that SuperEncoder significantly reduces the runtime for quantum state preparation compared to traditional methods, thus enhancing the efficiency of quantum algorithms.
strength_weakness: strength_weakness: 1. [Scalability Issue]
The most significant drawback of this work is its poor scalability. Since the input to the SuperEncoder is $2^n$ dimensional, the number of qubits cannot be too high, such as exceeding 20 qubits. This limitation severely restricts the applicability of the SuperEncoder to larger quantum systems. Discussing potential strategies to overcome this drawback would greatly enhance the practical value of the SuperEncoder.

2. [Barren Plateau Problem]
Another major issue is that, even within a reasonable range of qubit numbers (e.g., 10-20), training the SuperEncoder is challenging due to the barren plateau problem. Consequently, the SuperEncoder is likely only suitable for situations involving fewer than 10 qubits. In these cases, the time difference between AAE and SuperEncoder is not as significant as one might expect, which greatly limits the potential impact of this work.
questions: questions: See Weaknesses.

Additionally,

1. [Target Parameters Acquisition]
In the parameter-oriented training section, the process for obtaining the target parameters $\theta$ is not sufficiently clarified. If I understand correctly, these parameters are initially derived using the Variational Quantum Eigensolver (VQE) method. This approach inherently introduces errors and is prone to local minima, which could negatively impact the effectiveness of the SuperEncoder. It would be beneficial for the authors to address these issues and discuss the implications of using VQE-derived parameters.

2. [Gradient Calculation Complexity]
The gradient analysis section appears overly complex. Specifically, the calculation of gradients could be simplified by using the parameter shift rule to directly compute the gradient of $L_3$ with respect to $\theta$, rather than calculating the gradient with respect to $U$. 

3. [Runtime Clarification]
In Table 3, the term "Runtime" needs clarification. It is unclear whether this refers to the training time required for the SuperEncoder or the inference time once the model is trained. Providing a clear distinction between these two would help in accurately assessing the efficiency and practicality of the proposed method.

4. [Data Distribution Scope]
The distribution characterized by the SuperEncoder seems to be specifically tailored to a particular dataset. Theoretically, the SuperEncoder should be capable of characterizing vectors across the entire space. Have the authors tested the SuperEncoder on a broader range of vectors? If so, what were the results? Addressing this question could provide valuable insights into the versatility and generalizability of the SuperEncoder.
limitations: limitations: NA
paper_summary: paper_summary: In this paper, the authors propose a model, namely SuperEncoder, to solve the quantum state preparation problem. Instead of evolving the parameterized gates to generate the target quantum state, they train a model to predict the rotation parameters from the target states.
strength_weakness: strength_weakness: 1. Poor results. The results seem ok with four qubits but decrease way too fast when increasing the number of qubits. The proposed method is not comparable to previous methods.
2. It is actually impossible to use an ML model to predict the parameters. Since training the AAE ansatz is a non-convex optimization problem, finding the optimal parameter is indeed an NP-hard problem. There are infinitely many pairs of quantum states and parameters, and I wonder how the size of the training set would scale with the number of qubits. 
3. The training overhead is non-negligible. If we are preparing a quantum state that is beyond the simulation power of classical devices, the evaluation methods based on state fidelity would need an enormous number of quantum circuit executions, which I suspect would not be much less than training the AAE.
questions: questions: No questions
limitations: limitations: Naive ideas with poor experimental results.
paper_summary: paper_summary: This paper introduces SuperEncoder, a novel approach to Quantum State Preparation (QSP) that aims to combine the scalability of Approximate Amplitude Encoding (AAE) with the speed of traditional Amplitude Encoding (AE). SuperEncoder uses a pre-trained neural network to directly estimate the parameters of a Parameterized Quantum Circuit (PQC) for any given quantum state, eliminating the need for iterative parameter tuning during runtime. The authors explore different loss functions for training SuperEncoder, finding that state-oriented training using fidelity as a metric (L3) performs best. They evaluate SuperEncoder on synthetic datasets and downstream tasks like Quantum Machine Learning and the HHL algorithm, comparing it to AE and AAE. Results show that SuperEncoder achieves runtime similar to AE while maintaining the scalability of AAE, but with some degradation in fidelity. The impact of this fidelity loss varies across applications, being more tolerable in QML tasks than in precise algorithms like HHL.
strength_weakness: strength_weakness: 1. The gradient evaluation of the loss function (e.g. Eq. 1) requires computing the derivative of the state $\rho$ with respect to model parameters. As the authors acknowledge, this could become complicated on real devices due to the enormous cost of quantum state tomography. The authors work around this by using the parameter-shift rule to compute the gradient. However, the parameter-shift rule does not scale as well as classical backpropagation with autodiff (see https://openreview.net/forum?id=HF6bnhfSqH -- I guess a citation to this work would be relevant here). This casts doubts on the whole scalability of this method.

2. Again related to scalability, the number of input neurons to the model has to be $2^n$. This again doesn't look too scalable past 20 qubits, which can already be realized experimentally.
questions: questions: 1. What are the expected compute/memory/time costs in training SuperEncoder with larger qubit numbers? Is training with more than 10 qubits feasible?

Minor:

- In ine 284: Is $m$ for the number of entangling layers the same $m$ that appears in line 242?
- In line 335: could you add a citation to the work of Li et al that you are referring to the first time it appears?
limitations: limitations: Limitations have been discussed

Comments: comment: > _Are you thinking that these 12 qubits are only a subset of more qubits within a single QML pipeline?_

We have found that this is truly an issue worth considering for the entire QML field.
Taking ChatGPT as an example, the embedding we mentioned (3072-dim) corresponds to one token.
Then question is: (a) Should we encode all tokens using one data loading quantum subroutine? (b) Or should we encode each token using a different subroutine?

We have found some studies that employ the latter design (e.g., \[R0\]).
In this scenario, there may be many 12-qubit data loading subroutines, if we create entanglements between all these qubits after data loading, there will be a large number of qubits (>100) and the complete system is far beyond the storage capacity of classical system.

Currently, most QML research utilizes the same models as those demonstrated in our paper, which contain only one data loading block, i.e., akin to design (a). In this scenario, we may load a complete sequence of tokens using one data loading subroutine. The required number of qubits will not be very large.

Which design is better is indeed an open question.

However, we believe it is very safe to say: The data loading quantum subroutine will not involve very large number of qubits that is beyond the simulation power of classical computers.
Therefore, we believe that the scope of our work is reasonable, and our work has practical value.

\[R0\] G. Li, X. Zhao, and X. Wang, “Quantum Self-Attention Neural Networks for Text Classification,” May 11, 2022, arXiv: arXiv:2205.05625. Accessed: Jun. 03, 2022.
Thank you for your reply and thanks for raising this interesting question.

> _Why would we use a quantum computer (or rather QML) at this scale? Since we can simulate 12 qubits classically, what is the value of using a quantum computer here?_

In QML, or more precisely the "quantum learning for classical data" problem, _data loading_ has long been considered as a significant obstacle \[R0\]\[R1\]\[R2\], which motivates us to conduct this study.
Among all these previous studies of QML, the data to be loaded are all classical and thus can be accommodated by classical systems. If the qubits for loading classical data are all the qubits used in the complete quantum pipeline. Then it is true that all these QML circuits can be classically simulated.
However, the advantage of quantum computing lies not only in its information storage capacity but also in its **information processing capabilities**.
As discussed in the review by Biamonte, Jacob, et al.: "The input problem. Although quantum algorithms can **provide dramatic speedups for processing data**, they seldom provide advantages in reading data. This means that the cost of reading in the input can in some cases dominate the cost of quantum algorithms. Understanding this factor is an ongoing challenge."
(The statement also highlights the importance of data loading)

In other words, in QML, quantum computers are processing **the same data** as classical processors like modern GPUs. What we anticipate is a **faster processing speed** when quantum computers become more powerful.

Other advantages of QML may include (1) better performance with the same amounts of parameters \[R4\]; (2) it may reach the same performance with classical model with fewer training data \[R6\]. In fact, fully understanding the advantages of QML is still an active research area.

All these "quantum learning for classical data" problems assume the data to be able to be classically stored and thus do not rely on the storage capacity larger than classical system for data loading.

**Or we can say, QML does not enforce large qubit numbers (at least for data loading) that are beyond the simulation capacity of classical computers.**

> _Are you thinking that these 12 qubits are only a subset of more qubits within a single QML pipeline?_

This is a very interesting question, it may be a possible direction to develop certain QNN architectures, where only a subset set of qubits are responsible for data loading, and there can be many additional qubits responsible for data processing.
Then the complete circuit may be beyond the simulation capacity of classical computers.
While we do not know many QML studies that implement circuits with such a structure, some algorithms like HHL \[R3\] do have many more ancilla qubits in addition to data loading qubits. However, we do not assume "these 12 qubits are only a subset of more qubits" for QML in our study.

> _Or are you rather implying that the quantum-like architecture of a layered circuit can be a useful classical model in itself?_

This is another interesting question. While we do not assume the quantum-like architecture to be a useful classical model, we are not sure whether it is entirely true that they are not useful. We do have seen some quantum-inspired designs for classical ML \[R5\].

\[R0\] Biamonte, Jacob, et al. "Quantum machine learning." Nature 549.7671 (2017): 195-202.

\[R1\] Caro, Matthias C., et al. "Encoding-dependent generalization bounds for parametrized quantum circuits." Quantum 5 (2021): 582.

\[R2\] Li, Guangxi, et al. "Concentration of data encoding in parameterized quantum circuits." Advances in Neural Information Processing Systems 35 (2022): 19456-19469.

\[R3\] A. W. Harrow, A. Hassidim, and S. Lloyd, “Quantum Algorithm for Linear Systems of Equations,” Phys. Rev. Lett., vol. 103, no. 15, p. 150502, Oct. 2009, doi: 10.1103/PhysRevLett.103.150502.

\[R4\] L'Abbate, Ryan, et al. "A quantum-classical collaborative training architecture based on quantum state fidelity." IEEE Transactions on Quantum Engineering (2024).

\[R5\] A. Panahi, S. Saeedi, and T. Arodz, “word2ket: Space-efficient Word Embeddings inspired by Quantum Entanglement,” Mar. 03, 2020, arXiv: arXiv:1911.04975. Accessed: Dec. 08, 2022. (ICLR'20)

\[R6\] Caro, Matthias C., et al. "Generalization in quantum machine learning from few training data." Nature communications 13.1 (2022): 4919.
Thank you for your reply. 

Now I understand that the scope of this work does not require large qubit numbers. I would still have a follow-up question (probably more related to QML, which is the motivation to develop this technique). Let's take OpenAI's text-embedding-3-large, which in principle can be accommodated by 12 qubits. Why would we use a quantum computer (or rather QML) at this scale? Since we can simulate 12 qubits classically, what is the value of using a quantum computer here? Are you thinking that these 12 qubits are only a subset of more qubits within a single QML pipeline? Or are you rather implying that the quantum-like architecture of a layered circuit can be a useful classical model in itself?
Thank you for your constructive feedback. We are pleased that you acknowledged the contributions of our work, and we respect your overall evaluation of this study. However, we believe that it is worthy for us to further discuss on your remained two concerns. Particularly, we lookfoward to your further response on the Barren Plateaus problem, we appreciate your time and sincerely hope to learn more during the discussion phase

- **Data Distribution Scope**: In our test sets, we have randomized quantum states covering a wide range of vector space. In this context, SuperEncoder is not tailored for any particular data distribution. However, we do acknowledge that the current SuperEncoder's performance degrades with the number of qubits increases. Fully covering the entire space when increasing the number of qubits is an open challenge, we will definitely head in this direction.

- **Barren Plateaus**: The gradient of loss $L$ w.r.t. weights $W$ of MLP is given by $\frac{\partial L}{\partial W} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial  W}$. Here we let $y$ be the output of MLP, i.e., the parameters of quantum circuit to be consistent your previous comment. If we understand correctly, you believe that as long as this item: $\frac{\partial L}{\partial y}$ exists, it will become zero as the number of qubits increases and we will experience Barren Plateaus problem. We respectfully argue that this is questionable. As illustrated in the original Barren Plateaus paper \[R0\], Barren Plateaus occurs under the assumption that circuit is initialized to be Haar random unitary, so that variance of measurements will decrease exponentially in the number of qubits. But in our framework, we do not explicitly randomly initialize a quantum circuit since that it contains no trainable parameters. Since the parameters are the outputs from MLP, they carry the pattern of inputs and do not necessarily lead to a randomly initialized quantum circuit. In our framework, the quantum circuit acts more like a differentiable activation function. We have verified that the loss of training with 10+ qubits converges well (However it seems we could not add images here). Moreover, there have been extensive efforts on avoiding Barren Plateaus, we believe that this common concern in the entire field is not a significant drawback.

\[R0\] J. R. McClean, S. Boixo, V. N. Smelyanskiy, R. Babbush, and H. Neven, “Barren plateaus in quantum neural network training landscapes,” Nat Commun, vol. 9, no. 1, p. 4812, Nov. 2018, doi: 10.1038/s41467-018-07090-4.
Thanks for the authors' detailed rebuttal. While I appreciate your responses, I still have a few disagreements.

1. Barren Plateaus: I respectfully disagree that my concern about the Barren Plateaus was a misunderstanding. I have conducted similar experiments, and while it is true that the trainable parameters are within the classical neural network (NN), the output of the NN (denoted as y) ultimately serves as the rotation angles in the quantum circuit. Applying the chain rule for gradients, we first need to compute the gradient of the loss with respect to y before computing the gradient of y with respect to the NN parameters. While the latter part is free from the barren plateau issue, the former is indeed subject to it. Therefore, the barren plateau phenomenon still poses a challenge in this context.

2. Data Distribution Scope: After considering the feedback from other reviewers, I tend to agree that the SuperEncoder may not fully cover the entire space. The primary contribution of this paper seems to be that the SuperEncoder can effectively handle certain particular datasets. However, the performance on these datasets may have led the authors to an optimistic view that it can scale to any qubit count, which may not be entirely accurate.

In summary, while the SuperEncoder presents some notable contributions, I do not believe it meets the bar for acceptance at NeurIPS. Therefore, I maintain my original score.
Regarding scalability concerns about the input size. We have a concrete example:
According to [OpenAI documentation](https://openai.com/index/new-embedding-models-and-api-updates/), its latest embedding model `text-embedding-3-large` creates embeddings with up to 3072 dimensions, which can be accommodated by 12 qubits.
For classical data of this size, our approach holds promise for efficiently achieving approximate state preparation.
We have found a concurrent work \[R0\] that explores a similar direction with us, which has been published.

In short, their method is also NN-based arbitrary QSP, but with a focus on low-level quantum control.
Specifically, the authors proposed to "use a large number of initial and target states to train the neural network and subsequently use the well-trained network to generate the pulse sequence"

Since our study started before this paper is published, we were unaware of this work. We would incorporate relevant discussions in Sec. 5.

This paper serves as strong evidence of the feasibility of our work.


\[R0\] Li, Chao-Chao, Run-Hong He, and Zhao-Ming Wang. "Enhanced quantum state preparation via stochastic predictions of neural networks." Physical Review A 108.5 (2023): 052418.
Dear Reviewer,

Before making an ultimate judgment on the feasibility of the methodology behind SuperEncoder. We would like to humbly ask you to think about following questions.

- What is the essence of AAE? It constructs a circuit with fixed structure and trainable parameters, then it iteratively update its parameters to approximate the target state. Indeed, this implies that, given an arbitrary quantum state, it is possible to utilize the same procedure to construct a QSP circuit that could approximately generate this state. However, this procedure utilizes a try-and-error methodology, its iterative optimizations at runtime becomes a bottleneck.
- What is the essential goal of SuperEncoder? The goal is to build an AI designer to directly generate a QSP circuit that can approximately prepare an arbitrary quantum state, while minimizing online iterations to ensure efficiency. Our current work is just an initial exploration, we argue that there is significant room for further improvement. However, we may need to address some interesting but challenging research questions, which may require more people to engage in for a long time. We list some of these research questions as follows (Part of them are our ongoing work, we have to reveal these ideas for clarification).
    - Because the procedure of precise QSP (i.e., AE) is deterministic ---- essentially arithmetic decomposition, how can we let a ML model learn from this procedure? If we can make a model understand some fundamental principles and methods of QSP, is it possible for this model to find a universal, non-iterative QSP circuit construction method while limiting circuit depth under a given approximation ratio?
    - Currently we use a fixed circuit structure and predict its parameters. We ask, is it possible to train a model to generate different circuit structure (as well as the associated parameters) for different target states? The freedom of circuit structure, i.e., what type of gates to use and where to put them, can potentially enhance circuit expressibility. However, we may need to find an effective training methodology for this kind of models.

The above dicussions may be beyond the scope of our paper. We just want to emphasize that there are many possibilities for exploration in this direction.

Since we have shown the feasibility of our methodology with strong empirical evidence at the scale of 4\~8 qubits, we disagree that it is reasonable to make a conclusion that our methodology is definitely not able to be extended to larger quantum states.
> If the NN model can predict the parameters from the target state, then there will be an inverse model that can predict the target state from the parameters

This assumption is almost equivalent to: For any machine learning model trained by a dataset $(x,y)$, where $x$ refers to the input and $y$ refers to the output, we can train another model using a dataset $(y,x)$, with $y$ the input and $x$ the output. We are not sure why this assumption hold.
If the NN model can predict the parameters from the target state, then there will be an inverse model that can predict the target state from the parameters. Consider the random circuit sampling problem. We can preobtain a dataset with different circuit parameters and the final state. Under your assumption, can we train an NN model based on this dataset and predict the final state?
We thank the reviewer for the quick response, and understand that our work is counter-intuitive. Following are our response to your additional comments (highlighted in italics).

> *I found it really hard to believe that such a mapping exists. Firstly, training a given quantum ansatz, as VQE does, is already a non-convex problem, and you are saying that you can "predict" all the parameters without onsite training. Secondly, we can use different ansatz (with different amounts of parameters) to achieve the same target state, and you are saying that you can map the target states to parameters in entirely different spaces. If this is possible, why do we need VQE anymore? Since you can map an arbitrary state to the ansatz parameters with your trainable neural networks.*

The reviewer believe that: If the methodology of SuperEncoder is feasible, we can predict the parameters of VQE and we do not need VQE anymore. Therefore, the methodology of SuperEncoder is not feasible.

We believe this is a misunderstanding.
We argue that AAE is fundamentally different from other Hamiltonian-oriented Variational Quantum Algorithms (VQA) (e.g., VQE).
That is, the final state that we want the system to evolve to is **NOT known** for typical VQAs, whereas the final state is known for AAE.
Essentially, AAE belongs to QSP, but VQE does not.
Thus, it is certainly impossible to use SuperEncoder to predict parameters for these VQAs, but this does not necessarily mean that our methodology is unfeasible.

We argue that our methodology is feasible. Besides the empirical evidence provided in our paper, we would like to illustrate it from following perspective, which we have also elaborated in lines 136\~148.

- In AE, i.e., the precise QSP method. For arbitrary target state, we are using exactly the same procedure to generate the required QSP circuit. That is, for any given state $|\psi\rangle$, there exists an universal mapping $f: |\psi\rangle \to U_\theta$, such that $U_\theta |0\rangle = |\psi\rangle$.
- In this paper, we simply take one step further and are basically asking following question: Given a quantum state, is there a deterministic mapping between this state and the QSP circuit that could *approximately* prepare the state? We argue that our intuition is natural and reasonable.

> *I've checked with other reviewers, and it seems common sense that the proposed method lacks scalability. How can you map a quantum state with $1\times 10^9$ dimension to the parameter vector with $1\times 10^9$ dimension?*

Based on our understanding, the concerns are more about the input size and the training efficiency when the number of qubits is large.
As we emphasized in the global response, we refer to QSP as a process of loading classical data into quantum states.
Realistic classical data such as image/text embeddings typically do not have a exceedingly large number of dimensions.
According to [OpenAI documentation](https://openai.com/index/new-embedding-models-and-api-updates/), its latest embedding model `text-embedding-3-large` creates embeddings with up to 3072 dimensions, which can be accommodated by 12 qubits.

Moreover, it is certainly possible to use neural network to map large vectors from one space to another. The classical text-to-image tasks are great examples.

> *which means we have infinitely many pairs of target states (training data) and parameters (labels)*

Is "infinitely many pairs of inputs and outputs" really a problem in machine learning? As long as the mapping between inputs and outputs is learnable, it is definitely possible to construct a dataset with finite number of data points. This can be verified by all classical ML problems.

> *You are saying that the proposed method can achieve similar results with a shallower circuit, and I would like to point out that this is not an advantage at all. If you please try to alter the ansatz used in your experiment with extreme depth (extremely large number of parameters) and I suspect that you will find out the proposed NN is not able to map the state to such a large parameter space. The proposed method is only possible with a toy scale (including the state space and parameter space).*

We disagree with this point. Deep circuit depth is a well-known challenge in QSP, thus we definitely prefer shallower circuits.


We sincerely thank the reviewer for the feedback and look forward to any further questions.
Let's first find some common ground that we both agree on. The essence of this paper is to train a neural network that is used to map the target quantum state to the parameters in the ansatz. The authors claim the proposed NN can achieve comparable results with much shallower circuits compared to the previous method. (I don't think that I have any misunderstanding in the original review)

Then comes the disagreements.
1. We have infinitely many target states for any number of qubits, which means we have infinitely many pairs of target states (training data) and parameters (labels). I found it really hard to believe that such a mapping exists. Firstly, training a given quantum ansatz, as VQE does, is already a non-convex problem, and you are saying that you can "predict" all the parameters without onsite training. Secondly, we can use different ansatz (with different amounts of parameters) to achieve the same target state, and you are saying that you can map the target states to parameters in entirely different spaces. If this is possible, why do we need VQE anymore? Since you can map an arbitrary state to the ansatz parameters with your trainable neural networks.
2. I've checked with other reviewers, and it seems common sense that the proposed method lacks scalability. How can you map a quantum state with $1\times 10^9$ dimension to the parameter vector with $1\times 10^9$ dimension? 
3. You are saying that the proposed method can achieve similar results with a shallower circuit, and I would like to point out that this is not an advantage at all. If you please try to alter the ansatz used in your experiment with extreme depth (extremely large number of parameters) and I suspect that you will find out the proposed NN is not able to map the state to such a large parameter space. The proposed method is only possible with a toy scale (including the state space and parameter space).

I intend to keep my score.