Quantum convolutional neural network for classical data classification

Classification is an example of pattern recognition, which is a fundamental problem in data science that can be effectively addressed via machine learning. The goal of $L$-class classification is to infer the class label of an unseen data point $\tilde{x}\in\mathbbm{C}^{N}$, given a labelled data set

The classification problem can be solved by training a parameterized quantum circuit. Hereinafter, we refer to fully parameterized quantum circuits trained for machine learning tasks as Quantum Neural Network (QNN). For this supervised classification task, a QNN is trained by optimizing the parameters of quantum gates so as to minimize the cost function

where $f(x_{i},\boldsymbol{\theta})$ is the machine learning model defined by the set of parameters $\boldsymbol{\theta}$ that predicts the label of $x_{i}$, $c(a,b)$ quantifies the dissimilarity between $a$ and $b$, and $\alpha_{i}$ is a weight that satisfies $\sum_{i=1}^{M}\alpha_{i}=1$. After the training is finished, the class label for the unseen data point $\tilde{x}$ is determined as $\tilde{y}=f(\tilde{x},\boldsymbol{\theta}^{*}),$ where $\boldsymbol{\theta}^{*}=\arg\min_{\boldsymbol{\theta}}C(\boldsymbol{\theta})$. If the problem is restricted to binary classification (i.e. $L=2$), the class label can be inferred from a single-qubit von Neumann measurement. For example, the sign of an expectation value of $\sigma_{z}$ observable can represent the binary label [27]. Hereinafter, we focus on the binary classification, albeit potential future work towards multi-class classification will be discussed in Sec. V.

An interesting family of quantum neural networks utilizes tree-like (or hierarchical) structures [28] with which the number of qubits from a preceding layer is reduced by a factor of two for the subsequent layer. Such architectures consist of $O(\log(n))$ layers for $n$ input qubits, thereby permitting shallow circuit depth. Moreover, they can avoid one of the most critical problems in the PQC based algorithms known as “barren plateau”, thereby guaranteeing the trainability [29]. These structures also make a natural connection to the tensor network, which serves as a useful ground for exploring many-body physics, neural networks, and the interplay between them.

The progressive reduction of the number of qubits is analogous to the pooling operation in CNN. A distinct feature of the QCNN architecture is the translational invariance, which forces the blocks of parameterized quantum gates to be identical within a layer. The quantum state resulting from an $i$th layer of QCNN can be expressed as

where $\Tr_{B_{i}}(\cdot)$ is the partial trace operation over subsystem $B_{i}\in\mathbb{C}^{2^{n/2^{i}}}$, $U_{i}$ is the parameterized unitary gate operation that includes quantum convolution and the gate part of pooling, and $|\psi_{0}\rangle=|0\rangle^{\otimes n}$. Following the existing nomenclature, we refer to the structure (or template) of the parameterized quantum circuit as ansatz. In our QCNN architecture, $U_{i}$ always consists of two-qubit quantum circuit blocks, and the convolution and pooling part each uses the identical quantum circuit blocks within the given layer. Since a two-qubit gate requires 15 parameters at most [30], in $i$th layer consisting of $l_{i}>0$ independent convolutional filter and one pooling operation the maximum number of parameters subject to optimization is $15(l_{i}+1)$. Then the total number of parameters is at most $15\sum_{i=1}^{\log_{2}(n)}(l_{i}+1)$ if the convolution and pooling operations are iterated until only one qubit remains. One can also consider an interesting hybrid architecture in which the QCNN layers are stacked until $m$ qubits are remaining and then a classical neural network takes over from the $m$ qubit measurement outcomes. In this case, the number of quantum circuit parameters is less than the maximum number given above. Usually, $l_{i}$ is set to be a constant. Therefore, the number of parameters subject to optimization grows as $O(\log(n))$, which is an exponential reduction compared to the general hierarchical structure discussed in Ref. [28]. This also implies that the number of parameters can be suppressed double-exponentially with the size of classical data if the exponentially large state space is fully utilized for encoding the classical data. An example quantum circuit for a QCNN algorithm with eight qubits for binary classification is depicted in Fig. 1.

Generalizing Fig. 1 to larger systems can be done simply by connecting all neighboring qubits with the two-qubit parameterized gates in the translationally invariant way.

The optimization of the gate parameters can be carried out by iteratively updating the parameters based on the gradient of the cost function until some condition for the termination is reached. The cost function gradient can be calculated classically or by using a quantum computer via parameter-shift rule [31, 32, 33]. When the parameter-shift rule is used, QCNN requires an exponentially smaller number of quantum circuit executions compared to the general hierarchical structures inspired by tensor networks (e.g. tree tensor network) in Ref. [28]. While the latter uses $O(n)$ runs, the former only uses $O(\log(n))$ runs.

Many machine learning techniques transform input data $\mathcal{X}$ into a different space to make it easier to work with. This transformation $\phi:\mathcal{X}\rightarrow\mathcal{X}^{\prime}$ is often called a feature map. In quantum computing, the same analogy can be applied to perform a quantum feature map, which acts as $\phi:\mathcal{X}\rightarrow\mathcal{H}$ where the vector space $\mathcal{H}$ is a Hilbert space [34]. In fact, such feature mapping is mandatory when one uses quantum machine learning on classical data, since classical data must be encoded as a quantum state [11, 9, 35, 36, 37, 38]. The quantum feature map $x\in\mathcal{X}\rightarrow\ket{\phi(x)}\in\mathcal{H}$ is equivalent to applying a unitary transformation $U_{\phi}(x)$ to the initial state $\ket{0}^{\otimes{n}}$ to produce $U_{\phi}(x)\ket{0}^{\otimes{n}}=\ket{\phi(x)}$, where $n$ is the number of qubits. This refers to the green rectangle in Fig. 1.

There exist numerous structures of $U_{\phi}(x)$ to encode the classical input data $x$ into a quantum state. In this work, we benchmark the performance of the QCNN algorithm with several different quantum data encoding techniques. These techniques are explained in detail in this section.

An important step in the construction of a QCNN model is the choice of ansatz. In general, the QCNN structure is flexible to use an arbitrary two-qubit unitary operation at each convolutional filter and each pooling step. However, we constrain our design such that all convolutional filters use the same ansatz, and the same applies to all pooling operations (but differ from convolutional filters). We later show that the QCNN with fixed ansatz provides excellent results for the benchmarking datasets. While using different ansatz for all filters can be an interesting attempt for further improvements, this will increase the number of parameters to be optimized.

In the following, we introduce a set of convolutional and pooling ansatz (i.e. parameterized quantum circuit templates) used in our QCNN models.

The variational parameters of the ansatz are updated to minimize the cost function calculated on the training data set. In this benchmark study, we test the performance of QCNN models with two different cost functions, namely the mean squared error and the cross-entropy loss.

The size of quantum circuits that can be reliably executed on NISQ devices is limited due to the noise and technical challenges of building quantum hardware. Thus the encoding schemes for high dimensional data usually require the number of qubits that are beyond the current capabilities of quantum devices. Therefore, classical dimensionality reduction techniques will be useful in the near-term application of quantum machine learning techniques. In this work, we pre-process data with three classical dimensionality reduction techniques, namely bilinear interpolation, principal component analysis (PCA) [43] and autoencoding (AutoEnc) [44]. For the simulation presented in the following section, amplitude encoding is used only with bilinear interpolation while all other encoding schemes are tested with PCA and autoencoding. Bilinear interpolation and PCA are carried out by utilizing tf.image.resize from TensorFlow and sklearn.decomposition.PCA from scikit-learn, respectively. Autoencoders are capable of modelling complex non-linear functions, while PCA is a simple linear transformation with cheaper and faster computation. Since the pre-processing step should not produce too much computational resource overhead or result in overfitting, we train a simple autoencoder with one hidden layer. The data in the latent space (i.e. hidden layer) is then fed to quantum circuits.

This section reports the classical simulation results of the QCNN algorithm for binary classification carried out with Pennylane [26]. The test is performed with two standard datasets, namely MNIST and Fashion MNIST, under various conditions as described in the previous section. Note that the MNIST and Fashion MNIST datasets are 28$\times$28 image data, each with ten classes. Our benchmark focuses on binary classification, and hence we select classes 0 and 1 for both datasets.

The variational parameters in the QCNN ansatze are optimized by minimizing the cost function with an optimizer provided in Pennylane [26]. In particular, we tested Adam [45] and Nesterov moment [46] optimization algorithms. At each iteration $t$, we create a small batch by randomly selecting data from the training set. Compared to training on the full data set, training on the mini-batch not only reduces simulation time but also helps the gradients to escape from local minima. For both Adam and Nesterov moment optimizers, the batch size was 25 and the learning rate was 0.01. We also fixed the number of iterations to be 200 to speed up the training process. Note that the training can alternatively be stopped at different conditions, such as when the validation set accuracy does not increase for a predetermined number of consecutive runs [28]. The number of training (test) data are 12665 (2115) and 12000 (2000) for MNIST and fashion MNIST datasets, respectively.

Table 1 and 2 show the mean classification accuracy and one standard deviation obtained from five instances with random initialization of parameters. The number of random initialization is chosen to be the same as that of Ref. [28]. The results are obtained for various QCNN models of different convolutional and pooling circuits and data encoding strategies. When benchmarking with the hybrid encoding schemes (i.e. HDE and HAE), we used two blocks of four qubits, which results in having 32 and 30 features encoded in 8 qubits, respectively. For all results presented here, training is done with the cross-entropy loss. Similar results are obtained when MSE is used for training, and we present the MSE results in Appendix C. Here we only report the classification results obtained with the Nesterov optimizer, since it consistently provided better convergence. The ansatze in the table are listed in the same order as the list of convolutional circuits shown in Fig. 2. The last row of the table (i.e. Ansatz 9b) contains the results when the QCNN circuit only consists of the convolutional circuit 9 without any unitary gates in the pooling step.

The simulation results show that all ansatze perform reasonably well, while the ones with more number of free parameters tend to produce higher score. Since all ansatze perform reasonably well, one may choose to use the ansatz with smaller number of free parameters to save the training time. For example, by choosing ansatz 4 and amplitude encoding, one can achieve $97.8\%$ classification accuracy while using only 24 free parameters total instead of achieving $98.4\%$ at the cost of increasing the number of free parameters to 51. It is also important to note that most of the results obtained with the hybrid data encoding and PCA is considerably worse than the others. This is due to the normalization problem discussed in Sec. II.3.4, which motivated the development of the hybrid angle encoding. We observed that the normalization problem is negligible in the case with autoencoding. The simulation results clearly demonstrates that the normalization problem is resolved by the hybrid angle encoding as expected, and reasonably good results can be obtained with this method. For MNIST, HAE with PCA provides the best solution among the hybrid encoding schemes on average. On the other hand, for Fashion MNIST, HDE with autoencoding provides the best solution among the hybrid encoding schemes on average.

In the following, we also compare the two classical dimensionality reduction methods by presenting the overall mean accuracy and standard deviation values obtained by averaging over all ansatze and the random initializations. The average values are presented in Tab. 3. As discussed before, the HDE with PCA does not perform well for both datasets due to the data normalization issue. Besides this case, interestingly, PCA works better than autoencoding for MNIST data, and vice versa for Fashion MNIST data, thereby suggesting that the choice of the classical pre-processing method should be data-dependent.

Finally, we also examine how classification performance improves as the number of convolutional filters in each layer increases. For simplicity, we set the number of convolutional filters in each layer to be same, i.e $l_{1}=l_{2}=l_{3}=L$ (see Fig. 1 for the definition of $l_{i}$). Without loss of generality, we pick two ansatze and five encodings. For ansatze, we choose the one with the smallest number of free parameters and another with arbitrary $SU(4)$ operations. These are circuit 2 and circuit 9b, and they use 12 and 45 parameters total, respectively. For data encoding, we tested amplitude, qubit, and dense encoding. The qubit and dense encoding are further grouped under two different classical dimensionality reduction techniques, PCA and autoencoding. Since the qubit and dense encoding load 8 and 16 features, respectively, we label them as PCA8, AutoEnc8, PCA16, and AutoEnc16 based on the number of features and the dimensionality reduction techniques. The classification accuracies for $L=\{1,2,3\}$ are plotted in Fig. 4. The simulation results show that in some cases, the classification accuracy can be improved by increasing the number of convolutional filters. For example, the classification accuracy for MNIST data can be improved from about $86\%$ to $96\%$ when circuit 2 and dense encoding with autoencoding are used. For Fashion MNIST, the classification accuracy is improved from about $88\%$ to $90\%$ when circuit 2 and amplitude encoding are used, and from about $86\%$ to $90\%$ when circuit 2 and qubit encoding with PCA is used. However, we do not observe general trend with respect to the number of convolutional filters. In particular, the relationship between the classification accuracy and $L$ is less obvious for circuit 9b. We speculate that this attributes to the fact that circuit 9b implements an arbitrary $SU(4)$, which is an arbitrary two-qubit gate, and hence repetitive application of an arbitrary $SU(4)$ is redundant.

The general structure of QCNN shown in Fig. 1 uses two-qubit gates between the first (top) and last (bottom) qubits, which can be thought of as imposing periodic boundary condition. One may notice that all-to-all connectivity can be established even without connecting the boundaries. Thus we tested the classification performance of a QCNN architecture without having the two-qubit gates to close the loop. We refer to this case as the open boundary QCNN. Without loss of generality, we tested QCNNs with two different ansatz, the convolutional circuit 2 (Ansatz 2 in Tabs. 1 and 2) which uses the smallest number of free parameters and the convolutional circuit 9 which implements an arbitrary $SU(4)$. In case of the latter, pooling was done without parameterized gates, and hence the ansatz is equivalent to ansatz 9b in Tabs. 1 and 2. By imposing the open-boundary condition in conjunction with the ansatz 9b, one can modify the qubit arrangement of the QCNN circuit so as to use nearest-neighbour qubit interactions only. For an example of 8-qubit QCNN circuit, the modified structure is depicted in Fig. 5. Such design is particularly advantageous for NISQ devices that have limited physical qubit connectivity. For example, if one employs the qubit or the dense encoding method, the QCNN algorithm can be implemented with a 1-dimensional chain of physical qubits.

The simulation results are presented in Tab. 4 for MNIST and Fashion MNIST datasets. These results are attained with one convolutional filters per layer, i.e. $l_{1}=l_{2}=l_{3}=1$. The simulation results demonstrate that for the case of two ansatze tested the classification performance between open- and periodic-boundary QCNN circuits are similar. Although the number of free parameters are the same under these conditions, depending on the specification of the quantum hardware such as the qubit connectivity, the open-boundary QCNN circuit can have shallower depth. The open-boundary circuit with ansatz 9b is even more attractive for NISQ devices since the convolutional operations can be done with only nearest-neighbour qubit interactions as mentioned above.

We now compare the classification results of QCNN to that of classical CNN. Our goal is to compare the classification accuracy of the two given a similar number of parameters subject to optimization. To make a fair comparison between the two, we fix all hyperparameters of the two methods to be the same, except we used the Adam optimizer for CNN since it performed significantly better than the Nesterov moment optimizer. A detailed description of the classical CNN architecture is provided in Appendix B.

It is important to note that CNN can be trained with such small number of parameters effectively only when the number of nodes in the input layer is small. Therefore, the CNN results are only comparable to that of the qubit and dense encoding cases which requires 8 and 16 classical input nodes, respectively. We designed four different CNN models with the number of free parameters being 26, 34, 44 and 56 to make them comparable to the QCNN models. In these cases, a dimensionality reduction technique must precede. For hybrid and amplitude encoding, which require relatively simpler data pre-processing, the number of nodes in the CNN input layer is too large to be trained with a small number of parameters as in QCNN.

Comparing the values in Tab. 5 with the QCNN results, one can see that QCNN models perform better than their corresponding CNN models for the MNIST dataset. The same conclusion also holds for the Fashion dataset, except for the CNN models with 44 and 56 parameters that achieve similar performance as their corresponding QCNN models. Another noticeable result is that the QCNN models have considerably smaller standard deviations than the CNN models on average. This implies that the QCNN models not only achieve higher classification accuracy than the CNN models under similar training conditions but also are less sensitive to the random initialization of the free parameters.

In Fig. 6, we present two representative examples of the cross-entropy loss as a function of the number of training iterations. For simplicity, we show such data for two cases in MNIST data classification: circuit 9b and qubit encoding with autoencoding, and circuit 9b and dense encoding with PCA. Considering the number of free parameters, these cases are comparable to the CNN models with 8 inputs with autoencoding and 16 inputs with PCA, respectively. Recall that the mean classification accuracy and one standard deviation in QCNN (CNN) is $96.6\pm 2.2$ ($90.4\pm 13.4$) for the first case, and $98.3\pm 0.5$ ($93.0\pm 13.4$) for the second case. Figure 6 shows that in both cases, the QCNN models are trained faster than the CNN models, while the advantage manifests more clearly in the first case. Furthermore, the standard deviations in the QCNN models are significantly smaller than that of the CNN models.