Information loss and run time from practical application of quantum data compression

We examine information loss, resource costs, and run time from practical application of quantum data compression. Compressing quantum data to fewer qubits enables efficient use of resources, as well as applications for quantum communication and denoising. In this context, we provide a description of the quantum and classical components of the hybrid quantum autoencoder algorithm, implemented using IBM's Qiskit language. Utilizing our own data sets, we encode bitmap images as quantum superposition states, which correspond to linearly independent vectors with density matrices of discrete values. We successfully compress this data with near-lossless compression using simulation, and then run our algorithm on an IBMQ quantum chip. We describe conditions and run times for compressing our data on quantum devices.


I. INTRODUCTION
In the Information Age [1], data compression has become a powerful tool for dealing with datasets large in number, volume, and variability. Reducing the dimensionality of large datasets allows for efficient use of resources, as well as extraction of useful features. Classical autoencoders are a type of artificial neural network used extensively for feature extraction [2,3], denoising [4,5], and data compression or dimensionality reduction [6][7][8].
Classical autoencoders, as well as variational autoencoders [9], can be utilized to help mitigate some of the limitations we find in quantum computing [10]. With small numbers of noisy qubits in current quantum chips, implementation of quantum algorithms can benefit greatly from efficient use of qubits for data encoding and computation. Quantum data compression has been studied extensively as a means to efficiently use qubits [11] and for denoising quantum states [12]. We can also utilize quantum data compression in the field of quantum communication. Compressed quantum data can be sent between two parties on a public channel, with a private key used to compress or decompress the data, similar to sending classical compressed data over a network [13].
The theoretical limit to losslessly compressing quantum information down to a latent space requires the number of maximum linearly independent vectors from the input state to not exceed the size of the latent space [14]. In practice however, even if we meet this criteria, we find that the performance and efficiency of quantum data compression is limited by the choice of parametric circuit, the classical optimizer, and the gate depth of the circuit.
In this study, we investigate information loss in application of quantum data compression utilizing the quantum autoencoder as formulated in Romero et al. (2017) * saahil.patel@us.af.mil [15]. We study the data compression performance of three parametric circuits on a quantum simulator, and compare the times required to train the network. We then look at a simpler quantum data compression scheme to implement on real qubits that can yield a reasonable training time, with results subject to noise from the quantum devices. Because of long training times necessary for quantum data compression, results from a real device face considerable information loss from noise when compared to simulations. Thus, reduction of gate depth can help mitigate expensive resource costs. We test the parameterized circuits on an IBMQ quantum device [16] in order to understand the running time of the data compression training network when compared to simulations.
In total, we study three parameterized circuits, and compare their perform against measures of expressibility and entangling capability as described in Sim et al. (2019) [17]. Our simulations demonstrate near-lossless compression of quantum data using an image dataset, where each image is encoded as a unique superposition state.
The layout of this paper is as follows: Section II covers the data compression method, which includes the general Quantum Autoencoder framework, the parameterized quantum circuits, and the optimizer we use for this study. Section III covers our dataset and data encoding for the simulation and quantum chip. Section IV covers results from all our simulations and experiments, and discusses the results. In Section V we summarize the paper and provide future prospects for this research.

A. Classical Autoencoder
An autoencoder is an artificial neural network that is used to learn the representation (or features) of an unlabeled dataset. The encoder improves and validates the representation by regenerating the input. It is a dimensionality reduction algorithm that takes in data and compresses it to a latent space. We can think of the latent space as containing the "essence" of the input data -a compressed representation where similar data points are closer together in space. The decoding network then extracts features from the latent space and reconstructs the image, ideally without any noise or unwanted artifacts. A full autoencoder network consists of an encoding neural network, a latent space, and a decoding network, as shown in Figure 1.

B. Quantum Autoencoder
The quantum autoencoder (QAE) is a hybrid algorithm, where the encoding and decoding neural networks of a classical autoencoder are replaced by quantum subroutines that use quantum data, utilizing parameterized unitary gates and entanglement. The circuit's aim is to compress information from an input state |ϕ to a mixed compressed state ρ B , labeled in Figure 2A as B. With optimal parameters θ, we can get lossless compression, where all the information from |ϕ is compressed down into state ρ B . The remaining "trash" state is an empty state (|0 ⊗n ), shown as |A in Figure 2A. To do this, the overlap between the trash state and a reference |0 ⊗n state is computed, shown as |ψ in Figure 2A. Extracting the trash state |A requires taking the partial trace on the mixed state U ρU † with respect to B, where U is our parameterized circuit, and ρ = |ϕ ϕ|. The overlap, ψ| T r B (U ρU † ) |ψ , is a measure of fidelity between |ψ and |A . The maximum of this fidelity measure is 1, which ensures that the trash state is empty, and the compression is lossless. So the task of the classical optimizer is to minimize the cost function J(U ), defined as Within the quantum circuit, the overlap between the reference (|ψ ) and trash (|A ) states is computed using the Swap Test [18], as shown in Figure 2B. Test is a quantum operation that measures the difference between two quantum states. From Figure 2B, we measure out the ancilla qubit, which computes the overlap between the two states, reference and trash, using a control-swap gate. If the two states are orthogonal, then the probability of the ancilla qubit measured as |0 is 1/2 (J(U ) = 1/2), while if the two states are the same, the probability of measuring the ancilla as |0 is 1 (J(U ) = 0) [19].
Once the training circuit minimizes the cost function, we get the final set of parameters θ that compresses the dataset as efficiently as the parameterized quantum circuit (PQC) allows. The performance of the PQC is measured by two circuit descriptors, entangling capability and expressibility [17], discussed in the next section. The success of the algorithm is gauged by using new qubits to decompress the latent space back to the original state. Since we are gauging the efficiency of the compression, the decompression is not a training network. We simply use the optimal set of parameters to implement U † on the qubits, as shown in Figure 2C. The optimal parameters take in new qubits and the compressed state ρ B , and decompresses the data back to the original input state |ϕ . For this study, we measure the fidelity between the original input and the final decompressed output to understand information loss and compression efficiency.

C. Parameterized Quantum Circuit
In order to efficiently compress our images into fewer qubits, we quantitatively describe certain properties of Approved for Public Release; Distribution Unlimited. PA#: AFRL-2022-1262 the PQC such as performance and resource costs. Using these properties aids us in constructing our circuit with optimal gate sets, which in turn minimize the cost function of the training circuit while limiting computational complexity. First, we look at two circuit descriptors, expressibility and entangling capability, as defined in Sim et al. (2019) [17]. The authors show expressibility and entangling capability measures for 19 PQCs in their paper [17], one of which we use for our simulations ( Figure 3A Circuit 2).
After encoding the data as quantum states (a step we will cover in the following section), we apply the parameterized circuit that best ensures that the data encoding preserves all features of the original data. Thus, an ideal PQC must have the ability to generate states that are well representative of the full Hilbert space. For a single qubit, this means that the PQC must have the ability to explore the full Bloch Sphere. The quantity that measures this property is called the expressibility of a circuit [17]. Expressibility is measured by generating a sampled distribution of state fidelities of the parameterized circuit, and a sampled distribution using Haar random states (uniform distribution of random states) [20]. We then measure the Kullback-Leibler (KL) divergence [21] between the two distributions, given by equation (2). The KL divergence, or relative entropy, measures how two probability distributions, P and Q, differ from one another, given by equation 3. A divergence measure of D KL = 0 implies the two distributions are the same. Hence, the smaller the KL divergence, or , the more expressible the parameterized circuit.
In equation (2), P P QC (F ; θ) is the probability distribution from fidelities resulting from sampling states from the parameterized circuit; F is the fidelity, calculated using sampled parameters θ. P Haar (F ) is the probability distribution from fidelities resulting from sampling states from Haar random states. = D KL (P P QC (F ; θ)||P Haar (F )). (2) For the entangling capability measurement, the Meyer-Wallach (MW) measure [22] is used, a single scalar measurement for pure-state entanglement [23]. The entanglement of each individual qubit is measured with the remaining qubits in the system. One limitation with this measure is that it cannot distinguish between entangled states that are fully inseparable, and entangled states that can be separated into subsystems [23]. However, in this study, we are measuring the global entanglement of the PQCs, and the ease of computation and scalability [17] of the MW measure makes it fitting for our experiments. In the Brennen form [24], this distance measure is written as where T r[ρ 2 k ] traces out all but the one-qubit reduced density matrix of the kth qubit. For set S of sampled circuit parameters θ i , the entangling capability E [17] is then given by: For this study, we examine three different PQCs to implement into the quantum subroutine. Note that in principle it is possible to build an arbitrarily complex PQC capable of achieving lossless or near-lossless compression. However, complex PQCs with large gate depths are detrimental to quantum data compression in the Noisy Intermediate Scale Quantum (NISQ) era [25]. Hence, we aim to build PQCs with certain characteristics in mind that make quantum data compression more achievable.
Along with expressibility and entangling capability, we describe the performance of our circuits by examining the resource costs for each run. Figure 3A shows the three PQCs used for simulations in this study, each composed of 4 qubits. Table 1 shows the resource costs per circuit for the general case of n qubits and L layers for each of the three circuits. Table 2 shows the expressibility and entangling capability of each PQC studied in this paper with layers L = 3. Intuitively, increasing the number of layers L of a PQC should improve the performance of the compression, consequently also requiring more computational time while training the circuit. However, for expressibility and entangling capability, the circuits can reach a saturation point, whereby increasing the number of layers of the PQC does not improve the metrics or the PQC's performance. In this study, we look at two PQCs that are more resource intensive and better suited for simulations (PQCs 2 and 3 in Fig 3A), and one PQC that can be applicable on NISQ devices for small input sizes (PQC 1 in Fig 3A). Fig 3B shows this implementation for 3 qubits, run on an IBMQ device [16].

D. Classical Optimizer
It is important to understand how a classical optimizer works in order to compute the run time of our algorithm. We calculate the number of times our circuit runs per epoch by examining the Analytical Quantum Gradient Descent (AQGD), an IBM Qiskit component that performs gradient descent optimization [26][27][28]. One epoch involves running every image in the training dataset once through the compression circuit. After an image is run, the optimizer takes the output observable, B , and separately conducts two more runs of the circuit for each parameter in order to calculate the gradient. For each parameter θ j , the circuit is run once with a positive shift θ j + ∆θ j , giving the output B + j , and another run with a negative shift θ j − ∆θ j , giving the output B − j , as shown in Figure 4 (∆θ = θ j · π/2). The gradient of the D Classical Optimizer observable B is then given by equation (6): Calculating equation (6) for all parameters gives us the total gradient ∇ B . We calculate the next step in the gradient descent with equation (7), where B is the new observable, B is the current observable, and η is the learning rate. The learning rate is the coefficient of the gradient update, whereby increasing its value results in larger step sizes for the gradient optimization. Once the new observable B is found, gradient descent is used to find new adjusted parameters θ j used for the next iteration of training, i.e. θ t+1 − θ t ∝ −η∇ B [29]. In this study, B is the expectation value of the measured ancilla qubit (from the SWAP test), as shown in Figure 2B.
The total number of times a circuit is run per image involves 1 run of the original circuit, and 2 runs of the circuit per parameter to calculate ∂ B /∂θ j . This operation can be performed for many iterations of the optimizer, adjustable by an AQGD hyper-parameter. So for the full training dataset, the number of times we run the circuit per epoch is given by: where N iter is the maximum number of iterations of the optimizer, N images is the number of images in the training dataset that the training circuit goes through in one epoch, and N params is the total number of parameters in   the PQC. Here, N iter is equivalent to number of shots (circuit runs + measurement) the optimizer takes to calculate the average cost function in equation (1). For all simulations in this paper, the maximum number of iterations, N iter , was set to 10.

A. Data for Simulations
In order to train the network to efficiently compress quantum data, we use a data set consisting of black and white pixelated images following specific rules. For the simulations, we use 4x4 pixel images where all squares touching the border are either black or white, creating a "frame" around the 4 central squares, thereby functioning as a single pixel. The number of arrangements in the full dataset is then dependent on the central 4 squares and the frame, yielding a total 2 5 variations. Figure 5A shows 6 examples out of 32 total images. Using 4x4 images (16 pixels) allows us to represent each image as an equal superposition state of 4 qubits, giving us 16 total states for the 16 pixels. The phases on each state encode the different images by the following sign convention: phases on the superposition states go as (−1) n , where n = 0 for a black pixel (positive phase), and n = 1 for a white pixel (negative phase). Phases on the pixels are assigned left to right, and top to bottom, following the convention in Tacchino et al. (2019) [30]. This encoding of pixels creates a dataset of unique linearly independent vectors encoded using 4 qubits, which we then compress down to 3, 2 and 1 qubit in our simulations. The border rule on the dataset ensures a specific pattern for the images, and limits the dataset to size 2 5 , instead of 2 16 . The density matrices generated from the quantum states are discrete, and allow for efficient and lossless compression to a more continuous latent space. In Figure 5A, the top-right image would have the following associated superposition state: Having established our dataset and our methodology for distinguishing different quantum states for each image, we now utilize IBM's Qiskit programming language to produce these states for the simulator. Qiskit's simulator includes a built-in function for complex amplitude initialization, called Initialize [28]. This Initialize function first takes the desired initialized quantum state to the zero state |0 ⊗n in the computational basis. The gate sequence that accomplishes this is then implemented backwards after resetting the qubits, taking the |0 ⊗n quantum state to the desired initialized state. Hence, Initialize is not a unitary gate, but a resource intensive Qiskit instruction that iteratively disentangles qubits from the register one by one. Since manually assigning controlnot and control-phase gates to get the desired state for each 4-qubit image can become cumbersome, we opted for using the Initialize function for our 4-qubit simulations. Future applications with different datasets would require data loading operations unique to those datasets.
With a total 32 images, we split our dataset with 14 images for training, and 18 images for testing. We augmented the training images by duplicating the dataset, shuffling the list, and picking a small batch of images at a time to train, thereby enabling the training network to train on each image multiple times through one epoch. In total, we trained the network using 42 images with batch size of 7. All simulations were run for 40 epochs with a fixed learning rate of 0.05.

B. Quantum Device Implementation
Due to limitations in quantum hardware (number of qubits and qubit connectivity), we created a smaller 2x4 pixel image dataset for compression when working with IBMQ. This involved encoding 8 pixels into a 3-qubit superposition state, using the same phase encoding scheme as done for the 4-qubit images. The dataset consists of 10 training images with bar and stripe patterns, where the black/white pixels form horizontal bars, or vertical stripes, but never both. Similar to the 4x4 image dataset, we augmented this dataset to 20 total training images. We used the PQC shown in Figure 3B, and compressed the 3-qubit superposition state down to 2 qubits. For comparison, this image dataset was compressed with a simulator as well, using the same optimizer and training network hyper-parameters as for the quantum device. For this study, we used the IBMQ 'Casablanca' chip, which is one of the IBM Quantum Falcon Processors [16]. To maximize the efficiency of the training network, the data encoding initialization circuit (a combination of CNOT and CPHASE gates), and the parameterized quantum circuit, were transpiled first before training the network using Qiskit's Transpiler [28].

IV. RESULTS
Results from our simulations and device experiments are split into two subsections. The first covers the performance and run time of the compression algorithm for the simulated runs. The second subsection goes over the performance and run times of the algorithm for the IBMQ experiment.
A. Simulations

Compression Efficiency
Visualizing an image undergoing compression and decompression allows us to gauge the performance of our compression algorithm. The original input image and the latent space are visualized via density matrices to show the discrete or continuous nature of the Hilbert space. For the 3 PQCs outlined in Figure 3A, each one was trained with the Qiskit simulator using layer values of L = 3, 5, 7, along with three compression ratios (4 qubits compressed to 3, 2, 1 qubit(s), where the ratio is defined as n initial /n compressed ), giving a total of 27 full training simulations. Figure 6 illustrates the full set of simulation results for a single test image, shown as density matrices. The leftmost column shows the example 4x4 image and the associated density matrix visualized as a 16x16 matrix (ρ = i p i |ψ ψ|). The density matrices take on values in the range {−0.0625, 0.0625}, with ρ initial taking discrete values ±1/16.
The top third section of Figure 6 shows the simulation results for Circuit 1. The nine cells display the latent space and the decompressed density matrix of the example image for the 3 different compression ratios and 3 PQC depths. The size of the latent space corresponds with the compression ratio; for the 4 to 3 qubit compres-sion, the latent space is an 8x8 matrix. In general, the latent space is 2 m x2 m , where m is the number of compressed qubits. The forms of the latent space differ for each PQC, regardless of achieving a high fidelity compression. In each case, we decompress back to a 16x16 density matrix, with the aim of recreating the original density matrix shown in the leftmost column. The latent space is continuous, while the 16x16 density matrices is discrete. The discrete nature in the initial density matrix can allow us to compress the data down to a continuous mixed state, and potentially without losing information. Theoretically, the data meets the criteria for lossless compression even for the 1 qubit compression since we would have one linearly independent vector compressed down to a latent space size 2.
So theoretically, there should be no information loss across each compression ratio. In practice, Figure 6 shows that the greater the compression ratio, the worse the compression algorithm performs. Conversely, increasing the number of layers of the PQC decreases loss of information, and improves compression efficiency. For Circuit 1, 7 layers yields a near lossless compression for the 4 to 3 qubit compression ratio for this particular image. For Circuit 2 with 7 layers, both 4 to 3 and 4 to 2 qubit compressions perform well, while Circuit 3 with 7 layers performs best across the three compression ratios for this image. Ultimately, for any image in the dataset, information loss is proportional to increase in compression, and inversely proportional to number of PQC layers.
This relationship can be seen more clearly in Figure 7 for Circuit 3. The cost function relates to the amount of information lost from data compression via equation (1). Hence, minimizing the cost function is directly related to minimizing information loss, and true lossless compression would see the cost function go down to zero. Figure 7 shows loss curves from simulation of Circuit 3 for the full dataset. At the end of 40 epochs the smallest compression ratio (4 to 3 qubits), with 7 PQC layers, yields the least information loss, minimizing the cost function to 0.02.
While Figure 6 visualizes density matrices for a single image, and provides an insight into how the compression algorithm performs across the 27 simulations, Figure 8 gives further insight by quantitatively describing how well the PQCs performed on the full test dataset. Figure 8 plots the fidelity between the original and decompressed images from the full test dataset. Here, we compare the direct results of compression efficiency from simulation per each test image. The box plots show the spread in fidelity measurements across the dataset, with the box containing 50% of the data, and the horizontal black bar as the median value. The highest fidelity measure across all simulations is 0.98, while the lowest is 0.65. For the original density matrix of an image ρ, and the decompressed density matrix σ, the fidelity is calculated using equation (9) [31]. The maximum fidelity of 1 means the final and initial image is identical, and the F (ρ, σ) ≡ T r( ρ 1/2 σρ 1/2 ). (9) In Figure 8, the general trend for PQCs with 3 layers (the leftmost column) shows Circuit 3 performing slightly better than the other two. Since the entangling capability and expressibility measures for Circuits 2 and 3 are more favorable compared to Circuit 1 (Table 2), we see this reflected in the fidelity measures, where Circuit 2 and 3 generally outperform Circuit 1. This can clearly be seen in the simplest case of 4 to 3 qubit compression with 3 layers of PQC (top left of Figure 8). This result agrees with Hubregtsen et al. (2021), who found a strong correlation between classification accuracy of their circuit with expressibility of the circuit [32]. Even in the general case, Circuit 3 performs slightly better than the other two circuits given that its median fidelity measure is the highest or near highest in all cases. Additionally, aside from the simulation with the smallest compression ratio and the most number of PQC layers (top right of Figure 8), Circuit 1 has the largest spread in fidelity measures. Increase in spread of fidelity measures generally corresponds with increase in compression ratios, but not with increase in number of layers, even if the median fidelity score improves with number of PQC layers. While the increase in number of layers can improve the compression efficiency, each PQC behaves differently to this increase, as evident in Figure 9. The overall compression efficiency of Circuit 1 is most susceptible to change with number of layers, shown as red lines in the plot. Increasing the number of layers for Circuit 2 and 3 (blue and green lines, respectively) does not significantly change the compression efficiency of the algorithm using the simulator on the full test data set, albeit increasing the running time.

Run Time
One major focus of this study was to successfully compress quantum data near-losslessly, and quantify how changing the training network hyper-parameters affect information loss and compression efficiency. However, in practice, one must also take into account the running time of the algorithm in question when working with real data. In Figure 10, for the 4 to 3 qubit compression, we compare simulation data for the total time taken to train the three PQCs across 40 epochs, with 10 iterations of the optimizer. Circuit 1 is the most practical of the three, taking the least time to train and minimize the cost function. It also has the least spread in training time when increasing layers. These characteristics are attributed to its shallow gate depth, which is also reflected in poorer entanglement and expressibility scores. Conversely, Circuit 2 is the slowest circuit across all layers, with the slowest iteration of Circuit 1 being faster than the fastest iteration of Circuit 2.
To study the applicability between the other two circuits, 1 and 3, we examine two competing aspects between the two PQCs: speed vs. performance. The median fidelity measure for Circuit 3 in the the top left box (3 layers) of Figure 8 is 0.92, while the median fidelity measure for Circuit 1 in the top right box (7 layers) is 0.98. That is approximately a 6% improvement in the median fidelity for Circuit 1. Consequently, the average time per epoch between these two circuits, shown in Table 3, shows Circuit 3 (3 layers) is approximately 9% faster than Circuit 1 (7 layers). So for simulated quantum data compression, to minimize the run time while maximizing performance, Circuit 3 with fewer layers is more favorable. Generally, PQCs with better expressibility and entangling capability measures, like Circuit 3, tend to have higher gate depths, and are only suited to simulated data compression. Provided a 6% increase in information loss can be tolerated by a particular dataset or problem, simulating a more complex PQC with few layers becomes useful. Training networks run on quantum devices, however, requires both faster run times and shallower gate depths, with a preference for overall shallower gate depth over number of layers implemented. Hence, Circuit 1's design (shown in Figure 3B) was chosen to run data compression on the IBMQ quantum device.

Compression Efficiency
Due to the longer training time on the quantum device -primarily due to Queue Time -the network was trained on the device for 20 epochs. Figure 11 (top) shows the loss curves for the device and simulator, with the vertical line at 20 epochs. We compare the two to show the difference in compression efficiency between the latest superconducting quantum hardware and a simulator. At the end of 20 epochs, the minima of the cost function for the device was over 3 times higher than the cost function for the simulator. The simulator trained the network out to 40 epochs, whereby the cost function was minimized to 0.04, indicating that the 3-to-2 qubit compression of this 2x4 dataset is indeed near-lossless with this particular set of hyper-parameters. Figure 11 (bottom) shows the fidelity measurements after training with the simulator and the device for 20 epochs. The median fidelity for the IBMQ device is 0.37, while the median fidelity for the simulator is 0.68, around 1.84 times the value.

Run Time
For our experiment on IBMQ, we have to calculate the time cost in more detail. This requires a closer look at the number of jobs the training network sends to the device. In our case, three layers of the circuit from Figure 3B means N params = 12, and from the training dataset, N images = 20. So number of jobs sent to device is given by equation (8)  So for the simplest PQC with 3 layers, as well as our simple image data set compressing 3 qubits down to 2, the number of jobs with just one iteration of the optimizer means 500 jobs were sent to the device per epoch. For 40 epochs, that is 20,000 total jobs sent to the device. Each job is one run of the entire circuit for a set amount of shots (set to a maximum of 8192 shots). The time per job for the training network run on the device, with one iteration of the optimizer, is broken up into several processes, shown in Table 4. Omitting the queue time for the job sent to the device, since it can vary greatly depending on number of users on the device, the average time per job is then 22.18 seconds. For comparison, we ran this dataset through the compression algorithm using a simulator with 1 iteration of the optimizer. The simulator took an average of 7.46 seconds per job (one run of the circuit with 8192 shots). Therefore, the device takes roughly 3 times longer per job compared to the simulator for the same dataset, PQC, and hyper-parameters.  Figure 3B. Bottom: Fidelity measures from IBMQ Device and simulator of test dataset with parameters from cost function minima at the end of 20 epochs.

V. SUMMARY AND CONCLUSION
In the Noisy Intermediate Scale Quantum (NISQ) era, qubits are expensive resources, and multi-qubit operations are fragile. By leveraging classical dimensional reduction techniques such as autoencoders, quantum data can be compressed to fewer qubits. Reducing the dimensionality of this problem can allow us to utilize fewer qubits, aiding in more efficient use of resources. However, quantum autoencoders face challenges in efficient data compression even if data sets match the theoretical limit for lossless compression [14]. Application of quantum data compression needs to address consequences from choice of data, parameterized quantum circuits, and optimizer. In this paper, we successfully demonstrate nearlossless quantum data compression using a simulator. We chose datasets with linearly independent vectors following specific patterns, visualized as black-and-white pixel images. Wavefunctions generated from encoding these images create density matrices with discrete values, allowing for efficient compression down to continuous latent spaces. Three PQCs were tested on the quantum autoencoder framework [15], using Qiskit's Analytical Quantum Gradient Descent optimizer. The PQCs were chosen for different gate depths, number of parameters, number of two-qubit gates, and their performance quantified using expressibility and entangling capability measures [17].
Our results show that while all three PQCs manage to efficiently compress the test data set with near-lossless compression using a simulator, their performance was dependent on the compression ratio, number of layers, and running time. For example, Circuit 3 with 3 layers had a 6% higher cost function minimum compared Circuit 1 with 7 layers, but was 9% faster in training time. Only if a 6% increase in information loss can be tolerated, does a more complex PQC with few layers becomes useful, since the speed-up in training can be beneficial. However, for a fixed number of layers, training on a quantum device finds a faster circuit more useful than an efficient one. So although circuits with higher expressibility and entangling capability, like Circuits 2 and 3, generally perform better with larger compression ratios, their complexity leads to noise washing out our results. For devices with limited qubits and connectivity, a simple circuit with smaller gate depth, like Circuit 1, is more NISQ-friendly.
For comparisons of run times and performance of the training circuit between an IBMQ quantum device and the simulator, we used the 3-qubit version of Circuit 1 for the PQC, shown in Figure 3B. Using a simulator with this PQC on our smaller data set, and one iteration of the optimizer, we compressed from 3 to 2 qubits near-losslessly by minimizing the cost function to 0.04, as seen in Figure 11 (top). When run on an IBMQ device, the loss curve minima was a little over 3 times larger than the minima for the simulator after 20 epochs. Additionally, the device took three times longer per job compared to the simulator, when omitting queue time. Ideally, increase in total run time due to the job queue can be mitigated by reserving time on the device. We are still at a stage in the NISQ era where not only the noise and limited connectivity affect quantum algorithms, but processes within classical optimizers and data encoding as well.
Ultimately, efficient compression of quantum data on a quantum device will require careful construction of PQCs based on parameters examined in this paper, as well as choice of classical optimizer. In this paper, we examined the performance of our compression algorithm for different PQCs, and IBMQ's Analytical Quantum Gradient Descent optimizer. Future work will involve integrating other gradient descent optimizers into Qiskit that promise a faster convergence, such as the Quantum Natural Gradient proposed by Stokes et al. (2019) [29]. Upon compressing quantum data is efficiently, future work will also involve decompressing latent states into any desired output state by implementing a parameterized circuit for decompression as well. If these compressed states have missing information from the original input, any operation performed using the latent space would compound inaccuracies in the final result. Hence, the goal of this paper to practically achieve lossless compression is important for future applications of quantum data compression.

ACKNOWLEDGMENTS
The views expressed are those of the authors and do not reflect the official guidance or position of the United States Government, the Department of Defense or of the United States Air Force.
The appearance of external hyperlinks does not constitute endorsement by the United States Department of Defense (DoD) of the linked websites, or the information, products, or services contained therein. The DoD does not exercise any editorial, security, or other control over the information you may find at these locations