Leveraging Data Locality in Quantum Convolutional Classifiers

1. Introduction

The choice of an appropriate machine learning model for specific applications requires consideration of the size of the model since it is linked to the performance [1]. Considering the aforementioned factor, cnn are preferable to mlp because of their smaller size and reduced training time while maintaining a high accuracy [2,3]. Preserving the spatio-temporal locality of data allows cnn to reduce unnecessary data connections and therefore reduces their memory requirements [2,3]. This phenomenon reduces the number of required training parameters and thus incurs less training time [2,3].

In the context of quantum computing, great emphasis has been given to quantum-based machine learning, and, in recent years, various techniques have been devised to develop this field [4]. The contemporary qml techniques can be considered as hybrid quantum-classical variational algorithms [5,6,7,8,9]. Generally, vqa utilize parameterized rotation gates in fixed quantum circuit structures usually called ansatz and are optimized using classical techniques like gradient descent [5,6,7,8,9]. However, like mlp, preserving data locality is challenging for QML algorithms. For instance, the multidimensionality of input datasets is ignored in contemporary qml algorithms, and are flattened into one-dimensional arrays [5,6,7,8,9]. Furthermore, the absence of a generalizable technique for quantum convolution limits the capability of QML algorithms to directly adapt cnn structures.

In this work, we present a mqcc to address the shortcomings of the existing cnn implementations in reconciling the locality of multidimensional input data. The proposed VQA technique leverages quantum computing to reduce the number of training parameters and time complexity compared to classical cnn models. Similar to the cnn structures, mqcc contains a sequence of convolution and pooling layers for multi-feature extraction from multidimensional input data and a fully-connected layer for classification.

The subsequent sections of this paper are organized in the following structure. Section 2 discusses fundamental background information regarding different basic and complex quantum operations. Section 3 highlights existing works that are related to the proposed techniques. The proposed methodology is introduced in Section 4 with details given to the constituent parts. The experimental results and the explanation of the used verification metrics are presented in Section 5. Further discussion about the obtained results are provided in Section 6. Finally, Section 7 concludes this work with potential future directions.

2. Background

In this section, fundamental information pertaining to quantum computing and quantum machine learning is provided. Here we present the quantum gates and operations that are utilized in the proposed mqcc.

2.1. Quantum Bits and States

A single quantum bit, or qubit, can be represented by a normalized vector $\psi$ with $N=2^1$ elements, called a statevector, see (1). The state of a qubit is represented as a point on the surface of the Bloch sphere [10], as shown in Figure 1. To preserve the normalization property of a statevector, a qubit’s state can only be expressed as a point on the sphere’s surface [11].

$$\psi =c_0|0\rangle +c_1|1\rangle =\left[\begin{array}{c}{c}_0\\ c_1\end{array}\right],\mathrm{where}{c}_0^2+c_1^2=1$$

(1)

For n qubits, the statevector $\psi$ has $N=2^n$ elements . As shown in (2), each element $c_j\in \mathbb{C}$ of $\psi$ represents the amplitude/coefficient of the $j^{th}$ entry in $\psi$, or the basis state j [11].

$$\psi =\sum _{j=0}^{N-1}{c}_j·j=\left[\begin{array}{c}{c}_0\\ c_1\\ ⋮\\ c_j\\ ⋮\\ c_{N-2}\\ c_{N-1}\end{array}\right],\mathrm{where}\sum _{j=0}^{N-1}|c_j{|}^2=1,\mathrm{and}0\le j<(N=2^n)$$

(2)

2.2. Quantum Gates

Quantum gates are reversible operations on qubits and can be mathematically represented by unitary matrices [11]. Serial operations of quantum gates can be represented using matrix multiplication, while parallel operations can be represented using the tensor product [11]. In this section, we briefly discuss single- and multi-qubit quantum gates relevant to the proposed mqcc.

2.2.1. Rotation Gates

The rotation gates, $R_x\left(\theta \right)$, $R_y\left(\theta \right)$, and $R_z\left(\varphi \right)$, are parameterized versions of the Pauli single-qubit gates, shown in (3), (4), and (5), respectively [12]. In qml, rotation gate parameters are trained to produce better models [5,7].

$${\mathbf{R}}_x\left(\theta \right)=\left[\begin{array}{cc}cos\left(\frac{\theta }{2}\right)& -isin\left(\frac{\theta }{2}\right)\\ -isin\left(\frac{\theta }{2}\right)& cos\left(\frac{\theta }{2}\right)\end{array}\right]$$

(3)

$${\mathbf{R}}_y\left(\theta \right)=\left[\begin{array}{cc}cos\left(\frac{\theta }{2}\right)& -sin\left(\frac{\theta }{2}\right)\\ sin\left(\frac{\theta }{2}\right)& cos\left(\frac{\theta }{2}\right)\end{array}\right]$$

(4)

$${\mathbf{R}}_z\left(\varphi \right)=\left[\begin{array}{cc}{e}^{-\frac{i\varphi }{2}}& 0\\ 0& e^{\frac{i\varphi }{2}}\end{array}\right]$$

(5)

2.2.2. Hadamard Gate

The Hadamard gate is a fundamental quantum gate that puts the qubit into a superposition of two basis states, the 0 and 1 states, see (6) and Figure 2 [11]. Similarly, by applying Hadamard gates on n qubits independently, an n-qubit superposition can be created that comprises of $2^n$ basis states, as shown in (7) and Figure 3.

$$\mathbf{H}=\frac{1}{\sqrt{2}}\begin{array}{cc}\hfill \left[r\right]1& 1\\ \hfill 1& -1\end{array}$$

(6)

$$H^{\otimes n}·0^{\otimes n}=\frac{1}{\sqrt{2^n}}\sum _{j=0}^{2^n-1}j$$

(7)

2.2.3. cnot Gate

cnot gates can form a fundamental set of basis gates in conjunction with single-qubit rotation gates [12], see (8) and Figure 4. cnot gates can be used to entangle two qubits, where a measurement of one qubit can provide information about the second qubit [12].

$$\mathbf{CNOT}=\mathbf{cX}=\left(\right|0\rangle \langle 0|\otimes I)+\left(\right|1\rangle \langle 1|\otimes X)=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\\ 0& 0& 1& 0\end{array}\right]$$

(8)

All gates, single- or multi-qubit, can be extended to have control qubit(s), shown for a general U in (9) and Figure 5 [12].

$$\mathbf{cU}=\left(\right|0\rangle \langle 0|\otimes I)+\left(\right|1\rangle \langle 1|\otimes \mathrm{U})=\left[\begin{array}{cc}I& 0\\ 0& \mathrm{U}\end{array}\right]$$

(9)

When a general multi-qubit gate is extended to have more control qubits, it becomes an n-qubit mcu gate. In the context of cnot gates, the operation becomes a mcx gate [13]. For an n-qubit mcx gate with $n-1$ control qubits and 1 target qubit, see (10), the depth of an mcx gate with the addition of a single extra qubit can be found in (11) [13].

$$\mathbf{MCX}\left(n\right)=\sum _{i=0}^{2^{n-1}-2}(ii\otimes \mathit{I})+\left(\right|2^{n-1}-1\rangle \langle 2^{n-1}-1|\otimes \mathit{X})$$

(10)

$${\Delta }_{\mathrm{MCX}}\left(n\right)\le 48n-196=\mathcal{O}\left(n\right)\mathrm{for}\mathrm{large}n$$

(11)

The most general controlled gate is the multiplexer, see (12), which defines a quantum operation to be applied on $n_{target}$ qubits for each state permutation of some control qubit(s), $n_{control}$ [12]. In quantum circuits, the square box notation is used to denote a multiplexer operation, as shown in Figure 6 [12].

$${\mathbf{U}}_{mux}=\sum _{i=0}^{2^{n_c}-1}|i\rangle \langle i|\otimes {\mathrm{U}}_i=\left[\begin{array}{ccc}{\mathrm{U}}_0& & \\ & \ddots & \\ & & {\mathrm{U}}_{2^{n_{control}-1}}\end{array}\right]\begin{array}{c}\updownarrow 2^{n_{target}}\\ ⋮\\ \updownarrow 2^{n_{target}}\end{array}\phantom{\begin{array}{c}0\\ ⋮\\ 0\end{array}}↕2^{n_{target}+n_{control}}$$

(12)

Here, $U_i$ is a matrix of size $2^{n_{target}}\times 2^{n_{target}}$ defining the unitary operations/gates applied on each data qubit for the corresponding values i, where, $0<i<2^{n_{control}-1}$.

2.2.4. SWAP Gate

In a quantum circuit, SWAP gates are applied to interchange the position of two qubits, as shown in (13) and Figure 7. The SWAP gate can be decomposed into three cnot gates [11], see Figure 7.

$$\mathbf{SWAP}=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 1& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\end{array}\right]$$

(13)

2.2.5. Quantum Perfect-Shuffle Permutation (PSP)

The quantum psp are operations that perform a cyclical rotation of given input qubits and can be implemented using SWAP gates. Figure 8 shows the rol and ror psp operations [14] with $(n-1)$ SWAP operations, or $3(n-1)$ equivalent cnot operations.

2.2.6. Quantum Shift Operation

The quantum shift operation also performs a cyclic rotation of the basis states [15] similar to the quantum perfect-shuffle operations. Here, the basis states of the n-qubit state $\psi$ are shifted by $+k$ or $-k$ positions by applying a shift operation ${\mathrm{U}}_{\mathrm{shift}}^{\pm k}$, see (14). Here the value of k determines the type of operation such that when $k>0$, the corresponding shift operation is denoted as a quantum incrementer, shown in Figure 9[16,17] and when $k<0$, the corresponding shift operation is denoted as a quantum decrementer [16,17], shown in Figure 9. The quantum shift operation plays a vital role in convolution operation by striding the filter operation over data windows [18].

$$\begin{array}{cc}\hfill {\mathbf{U}}_{\mathrm{shift}}^{\pm k}\psi & =\sum _{i=0}^{2^n-1}{c}_{i}j,\mathrm{where}j=(i\pm k)mod{2}^n\hfill \\ \hfill & =\left(\prod _{i=0}^{k-1}{\mathrm{U}}_{\mathrm{shift}}^{\pm 1}\right)\psi ={\left(U_{\mathrm{shift}}^{\pm 1}\right)}^k\psi \hfill \end{array}$$

(14)

Each quantum shift operation ${\mathrm{U}}_{\mathrm{shift}}^{\pm 1}$ acting on an n-qubit state can be decomposed into a pyramidal structure of n×mcx gates in a series pattern [15], as shown in Figure 9 and Figure 9. In terms of fundamental single-qubit and cnot gates, the depth of a quantum shift operation with $\pm 1$ can be demonstrated as quadratic [13], see (15). Generalized quantum shift operations ${\mathrm{U}}_{\mathrm{shift}}^{\pm k}$ can be derived using $k\times {\mathrm{U}}_{\mathrm{shift}}^{\pm 1}$ operations, from the expression in (14) and the corresponding circuit depth can be derived as shown in ().

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill {\Delta }_{{\mathrm{U}}_{\mathrm{shift}}^{-1}}\left(n\right)& =\sum _{i=0}^{n-1}{\Delta }_{\mathrm{MCX}}\left(i\right)\hfill \\ \hfill & =\sum _{i=0}^{n-1}48i-196\hfill \\ \hfill & \le 24n^2-220n=\mathcal{O}\left(n^2\right)\mathrm{for}\mathrm{large}n\hfill \end{array}\end{array}$$

(15)

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill {\Delta }_{{\mathrm{U}}_{\mathrm{shift}}^{\pm k}}(n,k)& =k·{\Delta }_{{\mathrm{U}}_{\mathrm{shift}}^{\pm 1}}\left(n\right)=\mathcal{O}\left(k{n}^2\right)\hfill \end{array}\end{array}$$

(16)

Now, ${\mathrm{U}}_{\mathrm{shift}}^{\pm k}$ can be expressed as a sequence of controlled shift operations, as shown in (17a). Such operations can be denoted as ${\mathrm{U}}_{\mathrm{shift}}^{\pm k_j{2}^j}\left(n\right)$, where $0\le j<n$ and $\left(n\right)$ indicates that the shift operation is applied to an n-qubit state, as shown in (). Instead of applying sequential ${\mathrm{U}}_{\mathrm{shift}}^{\pm 1}\left(n\right)$ operations, each ${\mathrm{U}}_{\mathrm{shift}}^{\pm 2^j}\left(n\right)$ operation can be performed using a single ${\mathrm{U}}_{\mathrm{shift}}^{\pm 1}(n-j)$ operation, see (). Therefore, a more depth-efficient decomposition is shown in Figure 9 and the corresponding depth is provided in ().

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill k& ={\left(k_{n-1}{k}_{n-2}\cdots k_j\cdots k_1{k}_0\right)}_2=\sum _{j=0}^{n-1}{k}_j{2}^j:k_j\in \{0,1\}\hfill \end{array}\end{array}$$

(17a)

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill {\mathrm{U}}_{\mathrm{shift}}^{\pm k}\left(n\right)& ={\mathrm{U}}_{\mathrm{shift}}^{\pm {\sum }_{j=n-1}^0{k}_j{2}^j}\left(n\right)=\prod _{j=n-1}^0{\mathrm{U}}_{\mathrm{shift}}^{\pm k_j{2}^j}\left(n\right)\hfill \\ \hfill & =\prod _{j=n-1}^0\left({\mathrm{U}}_{\mathrm{shift}}^{\pm k_j}(n-j)\otimes I^{\otimes j}\right)\hfill \end{array}\end{array}$$

(17b)

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill {\Delta }_{{\mathrm{U}}_{\mathrm{shift}}^{\pm k}}^{\mathrm{opt}}\left(n\right)& \le \sum _{j=0}^{n-1}{\Delta }_{{\mathrm{U}}_{\mathrm{shift}}^{-1}}(n-j)=24\sum _{j=0}^{n-1}{j}^2-220\sum _{j=0}^{n-1}j\hfill \\ \hfill & \le 8n^3-122n^2+114n=\mathcal{O}\left(n^3\right)\mathrm{for}\mathrm{large}n\hfill \end{array}\end{array}$$

(17c)

2.3. Quantum Measurement and Reset

The quantum measurement operation of a qubit, is usually and informally referred to as a measurement “gate“. The measurement gate is a non-unitary operation that can project the quantum state of a qubit $\psi$ to the 0 or 1 basis states [11]. The likelihood of measuring any basis state can be obtained by taking the squared magnitude of their corresponding basis state coefficient. For a n-qubit register $\psi$ with $2^n$ possible basis states, the probability of measuring each qubit in any particular basis state j, where $0\le j<2^n$, is given by $|c_j{|}^2$ [14]. The classical output of an n-qubit amplitude-encoded [19] data can be decoded as ${\psi }_{\mathrm{decoded}-\mathrm{data}}^{\mathrm{classical}}$. This classical output vector can be reconstructed by the square root of the probability distribution $\sqrt{P\left(\psi \right)}$, as shown in (18), (19) and Figure 10. When amplitude-encoding [19] is used for encoding positive real classical data, the coefficients of the corresponding quantum pure state [11]$\psi$ are also positive real, i.e.,  $c_j\in {\mathbb{R}}^{+}$ , where $0\le j<2^n$. Thus, the amplitudes of $\psi$ are numerically equal in values to the coefficients of ${\psi }_{\mathrm{decoded}-\mathrm{data}}^{\mathrm{classical}}$, i.e., $\psi ={\psi }_{\mathrm{decoded}-\mathrm{data}}^{\mathrm{classical}}$. Therefore, the quantum state $\psi$ can be completely determined from the measurement probability distribution such that $\psi =\sqrt{P\left(\psi \right)}$ only when the amplitudes of the quantum state are all of positive real values. Moreover, the probability distribution $P\left(\psi \right)$ can be reconstructed by repeatedly measuring (sampling) the quantum state $\psi$. In general, an order of $2^n$ measurements is required to accurately reconstruct the probability distribution. In order to reduce the effects of quantum statistical noise, it is recommended to gather as many circuit samples (shots) [20] as possible.

$$P\left(\psi \right)=\begin{array}{c}\hfill p_0\\ \hfill p_1\\ \hfill ⋮\\ \hfill p_j\\ \hfill ⋮\\ \hfill p_{N-2}\\ \hfill p_{N-1}\end{array}=\begin{array}{c}\hfill |c_0{|}^2\\ \hfill |c_1{|}^2\\ \hfill ⋮\\ \hfill |c_j{|}^2\\ \hfill ⋮\\ \hfill |c_{N-2}{|}^2\\ \hfill |c_{N-1}{|}^2\end{array},\mathrm{where}{p}_j={\left|c_j\right|}^2,\mathrm{and}0\le j<N$$

(18)

$${\psi }_{\mathrm{decoded}-\mathrm{data}}^{\mathrm{classical}}=\sqrt{P\left(\psi \right)}=\begin{array}{c}\hfill |c_0|\\ \hfill |c_1|\\ \hfill ⋮\\ \hfill |c_j|\\ \hfill ⋮\\ \hfill |c_{N-2}|\\ \hfill |c_{N-1}|\end{array}$$

(19)

The reset operation sets the state of qubits to 0. This operation consists of a mid-circuit measurement gate followed by a conditional X gate [21,22] such that the bit-flip operation is applied when the measured qubit is in state 1. The reset gate and its equivalent circuit are both shown in Figure 11 [22].

2.4. Classical-to-Quantum (C2Q)

There are a number of quantum data encoding techniques [19,23], each of which uses different methods to initialize quantum circuits from the ground state. Among the many methods, this work leverages the classical-to-quantum (C2Q) arbitrary state synthesis [19,23] operation to perform amplitude encoding and initialize an n-qubit state ${\psi }_0$, see Figure 12. The c2q operation employs a pyramidal structure of multiplexed $R_y$ and $R_z$ gates. It should be noted that the $R_z$ gates are only required for positive real data. Thus, for positive real data, the circuit depth is $2·2^n-n-2$, while for complex data, the circuit depth is $3·2^n-n-4$ [19].

2.5. Quantum Machine Learning with Variational Algorithms

Variational quantum algorithms are a type of quantum-classical techniques that facilitate implementations of machine learning on noisy-intermediate-scale-quantum (nisq) machines [5,7]. Current quantum devices are not able to maintain coherent states for sufficient periods, preventing current algorithms from performing meaningful optimization on the machine learning model. Thus, vqa combine classical optimization algorithms with parameterized quantum circuits, or ansatz. Here, the ansatz takes on the role of the model [5]. One specific type of vqa is the vqc, which is used for classification problems. Existing vqc [6,8,9] have been shown to be effective for classifying datasets with high accuracy and few training parameters in both simulation and current quantum processors.

3. Related Work

In this section, we discuss the existing related works with an emphasis on quantum machine learning. Our discussion focuses on commonly used Data Encoding techniques, existing implementations of the Convolution and Quantum Convolution algorithms, and related Quantum Machine Learning algorithms. Moreover, we also discuss existing quantum convolutional classification algorithms that leverage data locality.

3.1. Data Encoding

For encoding classical image data into the quantum domain, the commonly used methods are frqi [24] and the neqr [25]. In frqi, positional and color information are encoded as amplitude encoding and angle encoding respectively. In neqr, positions of the pixels are encoded using amplitude encoding but color information is encoded using basis encoding, where q represents the number of bits/qubits allocated for color data. For $N=2^n$ data points, in terms of circuit width and depth, frqi incurs $n+1$ and $\mathcal{O}\left(4^n\right)$, respectively, while neqr incurs $n+q$ and $\mathcal{O}\left(qn{2}^n\right)$, respectively [15]. Although these techniques are employed in the existing quantum convolution techniques, their disadvantages are discussed below.

3.2. Convolution

We now discuss existing implementations of convolution and discuss their associated time complexity. These implementations consist of various classical and quantum techniques. In addition, we consider the shortcomings of existing quantum convolution methods.

3.2.0.1. Classical Convolution

Classical implementations of convolution are usually implemented directly, through gemm, or through the fft. For a data size N, running the direct implementation on CPUs has complexity $\mathcal{O}\left(N^2\right)$[26], while the complexity of an fft-based implementation is $\mathcal{O}(NlogN)$[26]. On GPUs, fft-based convolution incurs a similar $\mathcal{O}(NlogN)$ complexity [27], while the direct approach requires $\mathcal{O}\left(N_{F}N\right)$ FLOPS [28,29], where $N_F$ is the filter size.

3.2.0.2. Quantum Convolution

The existing quantum convolution techniques [18,30,31,32,33] rely on fixed filter sizes and support only specific filters at a time, e.g., edge-detection. They do not contain methods for implementing a general filter. Additionally, these techniques have a quadratic circuit depth, i.e., $\mathcal{O}\left(n^2\right)$, where $n=\lceil {log}_{2}N\rceil$ is the number of qubits and N is the size of the input data. While these methods appear to show quantum advantage, these results do not include overhead incurred from data encoding. The related methods employ the FRQI and NEQR data encoding methods, leading to inferior performance compared to classical methods once the additional overhead is factored in. The authors in [16] propose an edge-detection technique based on quantum wavelet transform QWT and amplitude encoding, named quantum Hadamard edge detection (QHED) which is not generalizable for multiple convolution kernels or multidimensional data. Thus, their algorithm loses parallelism, increases circuit depth, and is difficult to generalize beyond capturing 1D features. In [15], the authors have developed a quantum convolution algorithm that supports single feature/kernel and multidimensional data. In this work, we leverage the convolution method from [15] and generalize it to support multiple features/kernels in our proposed MQCC framework.

3.3. Quantum Machine Learning

There exist two primary techniques for quantum convolutional classification that may leverage data locality through convolution: qcnn [34] and quanvolutional neural networks [35]. QCNN is inspired by classical convolutional neural networks, employs quantum circuits to perform convolutions, while quanvolutional neural networks replace classical convolutional layers with quantum convolutional (or quanvolutional) layers.

3.3.1. Quantum Convolutional Neural Networks

The qcnn [34] and our proposed mqcc are both vqa with structures inspired by cnns. However, qcnn borrows the superficial structure of cnns without considering the underlying purpose. Specifically, the qcnn quantum ansatz is designed so that its "convolution" and "pooling" operations exploit the locality of qubits in the circuit (rather than the locality of data). However, unlike data locality, qubit locality does not have a practical purpose for machine learning in terms of isolating relevant input features. Moreover, by considering input data as 1D, qcnn do not leverage the dimensionality of datasets, which constitute a primary advantage of cnn. mqcc, on the other hand, faithfully implements cnn operations in quantum circuits, offering performance improvements in computational speed and classification accuracy even over contemporary implementations on classical computers.

3.3.2. Quanvolutional Neural Networks

Quanvolutional neural networks [35] are a hybrid quantum-classical algorithm named eponymously after the quanvolutional layer added to a conventional cnn. These quanvolutional layers serve to decimate a 2-D image, which is then sequentially fed into a quantum device. In this manner, the quanvolutional layer effectively exploits data locality. Yet, the model’s dependency on classical operations, specifically the decimation of input data and the repeated serial data I/O transfer, vastly increases compute time. In contrast, the required convolution operation is incorporated into our proposed mqcc, reducing classical-quantum data transfer. Moreover, mqcc takes advantage of parallelism inherent to quantum computers, while quanvolutional neural networks do not. Together, this allows the mqcc to apply convolutional filters to window data in parallel.

4. Materials and Methods

In this section, we describe the materials and methods associated with the proposed mqcc. The proposed method mainly uses generalized quantum convolution, quantum pooling based on the qht and partial measurement [14], and a quantum fully-connected layer that will be illustrated in this section. To the best of our knowledge, this work is the first to:

• Develop a generalizable quantum convolution algorithm for a quantum convolution-based classifier that supports multiple features/kernels.
• Design a scalable mqcc that uses multidimensional quantum convolution and pooling based on the qht. This technique reduces training parameters and time complexity compared to other classical and quantum implementations.
• Evaluate the mqcc model in a state-of-the-art QML simulator from Xanadu using a variety of datasets.

4.1. Quantum Fully-Connected Layer

A fully-connected neural network constitutes a collection of layers that each perform a linear transformation on $N_{\mathrm{in}}$ input features $\mathbf{x}\in {\mathbb{R}}^{N_{\mathrm{in}}}$ to generate $N_{\mathrm{out}}$-feature output $\mathbf{y}\in {\mathbb{R}}^{N_{\mathrm{out}}}$[2,3]. Each layer can be represented in terms of a multiply-and-accumulate (MAC) operation and an addition operation as shown in (20), where $\mathbf{W}\in {\mathbb{R}}^{N_{\mathrm{out}}\times N_{\mathrm{in}}}$ and $\mathbf{b}\in {\mathbb{R}}^{N_{\mathrm{out}}}$ represent the trainable weight and bias parameters, respectively.

$$\mathbf{y}={\mathbf{W}}^T\mathbf{x}+\mathbf{b}$$

(20)

The particular weights and biases that generate the $j^{\mathrm{th}}$ feature of the output, $y_j$, can be isolated by taking the $j^{\mathrm{th}}$ column of $\mathbf{W}$, ${\mathbf{w}}_j$, and the $j^{\mathrm{th}}$ term of $\mathbf{b}$, $b_j$, as shown in (21), which can be directly implemented using quantum circuits. Section 4.1.1 discusses the quantum circuits for a single-feature output, and Section 4.1.2 generalizes the proposed technique for an arbitrary amount of features in the output.

$$\begin{array}{c}\hfill y_j=({\mathbf{w}}_j·\mathbf{x})+b_j,\mathrm{where}0\le j<N_{\mathrm{out}}\end{array}$$

(21)

4.1.1. Single-Feature Output

For a single-feature output neural network, the weight parameters can be represented as a vector $\mathbf{w}\in {\mathbb{R}}^{N_{\mathrm{in}}}$. Here $\mathbf{w}$ can be expressed as a quantum state w as shown in (22) similar to the process of C2Q data encoding, see Section 2.4.

$$\begin{array}{cc}\hfill w& =\frac{1}{\mathbf{w}}\left[\begin{array}{c}\mathbf{w}\\ 0\\ ⋮\\ 0\end{array}\right]\begin{array}{c}\hfill \left[l\right]\phantom{\mathbf{w}}↕N_{\mathrm{in}}\\ \hfill \phantom{\begin{array}{c}0\\ ⋮\\ 0\end{array}}\end{array}↕2^{n_{\mathrm{in}}},\mathrm{where}{n}_{\mathrm{in}}=\lceil {log}_2{N}_{\mathrm{in}}\rceil \hfill \end{array}$$

(22)

Similarly, for a single-feature output, Dirac notation of the MAC operation follows from (21) as shown in (23), where $\psi$ corresponds to the input data.

$$y-b=w\psi$$

(23)

However, it is necessary to obtain a quantum operator to perform a parameterized unitary linear transformation from the weights vector w on the input data $\psi$ using an inverse C2Q operation, as shown in (24).

$$\begin{array}{cc}\hfill {\mathrm{U}}_{\mathrm{MAC}}\left(w\right)& =\left[\begin{array}{c}w\\ \times \\ ⋮\\ \times \end{array}\right]↕2^{n_{\mathrm{in}}}\hfill \\ \hfill & ={\mathrm{U}}_{\mathrm{C}2\mathrm{Q}}^{†}\left(w\right)\hfill \end{array}$$

(24)

4.1.2. Multi-Feature Output

A Multi-Feature Output can be implemented in a naive approach using Single-Feature Output (24) for an $N_{\mathrm{out}}$-feature output, where $N_{\mathrm{out}}\le N_{\mathrm{in}}$, which can be obtained by encoding each weight vector ${\mathbf{w}}_j:0\le j<N_{\mathrm{out}}$ as a normalized row in ${\mathrm{U}}_{\mathrm{MAC}}$. However, the result might yield a non-unitary operator as the weight vectors can be arbitrary. ${\mathrm{U}}_{\mathrm{MAC}}$ is unitary when each row is orthogonal to all other rows in the matrix, mathematically, $W_i{W}_j={\delta }_{ij}:\forall i,j\in [0,N_{\mathrm{out}})$. As described in Section 2.2.3, independently-defined weights can be supported for each feature of the output by multiplexing ${\mathrm{U}}_{\mathrm{MAC}}$. Now, the generic fully-connected operation, ${\mathrm{U}}_{\mathrm{FC}}$, can be generated as shown in (25), where $n_{\mathrm{out}}=\lceil {log}_2{N}_{\mathrm{out}}\rceil$.

$${\mathrm{U}}_{\mathrm{FC}}=\left[\begin{array}{ccc}{\mathrm{U}}_{\mathrm{MAC}}\left(w_0\right)& & \\ & \ddots & \\ & & {\mathrm{U}}_{\mathrm{MAC}}\left(w_{2^{n_{\mathrm{out}}}-1}\right)\end{array}\right]$$

(25)

By generating $N_{\mathrm{out}}$ replicas of the initial state, ${\psi }_0$, the operation can be parallelized, i.e., ${\mathrm{U}}_{\mathrm{MAC}}\left(w_0\right)\cdots {\mathrm{U}}_{\mathrm{MAC}}\left(w_{2^{n_{\mathrm{out}}}-1}\right)$ transformations from (25).

4.1.2.1. Replication:

To replicate the initial state, ${\psi }_0$ $n_{\mathrm{out}}$ qubits, which extend the statevector to a total size of $2^{n_{\mathrm{in}}+n_{\mathrm{out}}}$, see (26) and Figure 14.

$${\psi }_1=0^{\otimes n_{\mathrm{out}}}\otimes {\psi }_0=\left[\begin{array}{c}{\psi }_0\\ 0\\ ⋮\\ 0\end{array}\right]\begin{array}{c}\hfill \left[l\right]\phantom{{\psi }_0}↕2^{n_{\mathrm{in}}}\\ \hfill \phantom{\begin{array}{c}0\\ ⋮\\ 0\end{array}}\end{array}↕2^{n_{\mathrm{in}}+n_{\mathrm{out}}}$$

(26)

By applying an $n_{\mathrm{out}}$-qubit Hadamard operation to the relevant qubits the replicas can be obtained through superposition, see (27) and Figure 14, which generates the desired replicas scaled by a factor of $\frac{1}{\sqrt{2^{n_{\mathrm{out}}}}}$ to maintain normalization ${\psi }_2=1$.

$$\begin{array}{c}\hfill {\psi }_2=\left(H^{\otimes n_{\mathrm{out}}}\otimes I^{\otimes n_{\mathrm{in}}}\right){\psi }_1=\frac{1}{\sqrt{2^{n_{\mathrm{out}}}}}\left[\begin{array}{c}{\psi }_0\\ ⋮\\ {\psi }_0\end{array}\right]\begin{array}{c}\hfill \left[l\right]\phantom{{\psi }_0}↕2^{n_{\mathrm{in}}}\\ \hfill \phantom{⋮}\phantom{\updownarrow }⋮\\ \hfill \phantom{{\psi }_0}↕2^{n_{\mathrm{in}}}\end{array}↕2^{n_{\mathrm{in}}+n_{\mathrm{out}}}\end{array}$$

(27)

4.1.2.2. Applying the ${\mathrm{U}}_{\mathrm{FC}}$ Filter:

${\mathrm{U}}_{\mathrm{FC}}$ can perform the MAC operation for the entire $N_{\mathrm{out}}$-feature output in parallel with the set of replicas of ${\psi }_0$, see, (28) and Figure 14.

$$\begin{array}{cc}\hfill {\psi }_3={\mathrm{U}}_{\mathrm{FC}}{\psi }_2& =\left[\begin{array}{c}{\mathrm{U}}_{\mathrm{MAC}}\left(w_0\right){\psi }_0\\ ⋮\\ {\mathrm{U}}_{\mathrm{MAC}}\left(w_j\right){\psi }_0\\ ⋮\\ {\mathrm{U}}_{\mathrm{MAC}}\left(w_{2^{n_{\mathrm{out}}}-1}\right){\psi }_0\end{array}\right]\begin{array}{c}\hfill \left[l\right]\phantom{{\mathrm{U}}_{\mathrm{MAC}}\left(w_0\right){\psi }_0}↕2^{n_{\mathrm{in}}}\\ \hfill \phantom{⋮}\phantom{\updownarrow }⋮\\ \hfill \phantom{{\mathrm{U}}_{\mathrm{MAC}}\left(w_j\right){\psi }_0}↕2^{n_{\mathrm{in}}}\\ \hfill \phantom{⋮}\phantom{\updownarrow }⋮\\ \hfill \phantom{{\mathrm{U}}_{\mathrm{MAC}}\left(w_{2^{n_{\mathrm{out}}}-1}\right){\psi }_0}↕2^{n_{\mathrm{in}}}\end{array}↕2^{n_{\mathrm{in}}+n_{\mathrm{out}}}\hfill \\ \hfill & =\left[\begin{array}{c}{w}_0{\psi }_0\\ \times \\ ⋮\\ \times \\ ⋮\\ w_j{\psi }_0\\ \times \\ ⋮\\ \times \\ ⋮\\ w_{2^{n_{\mathrm{out}}}-1}{\psi }_0\\ \times \\ ⋮\\ \times \end{array}\right]\begin{array}{c}\hfill \left[l\right]\phantom{\begin{array}{c}{w}_0{\psi }_0\\ \times \\ ⋮\\ \times \end{array}}↕2^{n_{\mathrm{in}}}\\ \hfill \phantom{⋮}\phantom{\updownarrow }⋮\\ \hfill \phantom{\begin{array}{c}{w}_j{\psi }_0\\ \times \\ ⋮\\ \times \end{array}}↕2^{n_{\mathrm{in}}}\\ \hfill \phantom{⋮}\phantom{\updownarrow }⋮\\ \hfill \phantom{\begin{array}{c}{w}_{2^{n_{\mathrm{out}}}-1}{\psi }_0\\ \times \\ ⋮\\ \times \end{array}}↕2^{n_{\mathrm{in}}}\end{array}↕2^{n_{\mathrm{in}}+n_{\mathrm{out}}}\hfill \end{array}$$

(28)

4.1.2.3. Data Rearrangement:

The data rearrangement operation can be performed by applying perfect-shuffle gates, see Section 2.2.5. It simplifies the output-feature extraction by gathering them into $N_{\mathrm{out}}$ data points at the top of the statevector, see (29) and Figure 14.

$$\begin{array}{cc}\hfill {\psi }_4=\prod _{i=0}^{n_{\mathrm{out}}-1}\left(\mathrm{RoL}(n_{\mathrm{in}}+n_{\mathrm{out}}-i)\otimes I^{\otimes i}\right){\psi }_3& =\left[\begin{array}{c}{w}_0{\psi }_0\\ ⋮\\ w_j{\psi }_0\\ ⋮\\ w_{2^{n_{\mathrm{out}}}-1}{\psi }_0\\ \times \\ ⋮\\ \times \end{array}\right]\begin{array}{c}\hfill \left[l\right]\phantom{\begin{array}{c}{w}_0{\psi }_0\\ ⋮\\ w_j{\psi }_0\\ ⋮\\ w_{2^{n_{\mathrm{out}}}-1}{\psi }_0\end{array}}↕2^{n_{\mathrm{out}}}\\ \hfill \phantom{\begin{array}{c}\times \\ ⋮\\ \times \end{array}}\end{array}↕2^{n_{\mathrm{in}}+n_{\mathrm{out}}}\hfill \end{array}$$

(29)

It is worth mentioning that instead of applying the auxiliary qubits at the most-significant position as shown in the decomposed and simplified fully-connected circuit in Figure 15, auxiliary qubits can be applied at the least-significant position to avoid perfect-shuffle permutations.

4.1.3. Circuit Depth of the Quantum Fully-Connected Layer

As discussed in Section 2.4, ${\mathrm{U}}_{\mathrm{MAC}}$ operation is implemented by applying the C2Q / arbitrary state synthesis operation with a depth of $\left(3·2^{n_{\mathrm{in}}}-n_{\mathrm{in}}-4\right)$ fundamental single-qubit and CNOT gates. The depth is expected to increase by a factor of $2^{n_{\mathrm{out}}}$ when multiplexing ${\mathrm{U}}_{\mathrm{MAC}}$ to implement an $N_{\mathrm{out}}$-feature output [12], see (30).

$$\begin{array}{cc}\hfill {\Delta }_{{\mathrm{U}}_{\mathrm{FC}}}(n_{\mathrm{in}},n_{\mathrm{out}})& =2^{n_{\mathrm{out}}}·{\Delta }_{{\mathrm{U}}_{\mathrm{MAC}}\left(n_{\mathrm{in}}\right)}\hfill \\ \hfill & =2^{n_{\mathrm{out}}}\left(3·2^{n_{\mathrm{in}}}-n_{\mathrm{in}}-4\right)\hfill \\ \hfill & =\mathcal{O}\left(2^{n_{\mathrm{in}}+n_{\mathrm{out}}}\right)\hfill \end{array}$$

(30)

4.2. Generalized Quantum Convolution

The most significant part of the mqcc framework is the generalized quantum convolution operation with support for arbitrary, parameterized filters. Compared to the classical convolution operation, the convolution operation in the quantum domain achieves exponential improvement in time complexity due to its innate parallelism. The convolution operation consists of stride, data rearrangement, and multiply-and-accumulate (MAC) operations.

4.2.0.1. Stride:

The first step of quantum convolution is generating shifted replicas of the input data. Quantum decrementers controlled by additional qubits, called "filter" qubits are used for this purpose. The ${\mathrm{U}}_{\mathrm{shift}}^{-1}$ operator as shown in Figure 9 shifts the replica by a single stride.

4.2.0.2. Multiply-and-Accumulate (MAC):

Kernels are applied to the strided replicas of the input data in parallel using the MAC operation, see Figure 13. In the MAC operations, kernels are applied to the contiguous set of data with the help of the inverse arbitrary state synthesis operation. One benefit achieved from using this MAC operation is the superposition of multiple kernels. The superposition of the kernel can be helpful for the classification of multiple features.

4.2.0.3. Data Rearrangement:

Data rearrangement is required to coalesce the output pieces of the MAC steps and create one contiguous piece of output. This step is performed using perfect shuffle permutation (PSP) operations described in Section 2.2.5.

4.2.1. One-Dimensional Multi-Feature Quantum Convolution

The one-dimensional quantum convolution operation, with kernel of size $N_K$ terms, requires generating $N_K$ replicas of the input data in a range of possible strides between $0\le k<N_K$. Therefore, a total of $N_{K}N$ terms need to be encoded into a quantum circuit including the $n_k=\lceil {log}_2{N}_K\rceil$ additional auxiliary qubits, denoted as “kernel” qubits that are allocated the most-significant qubits to maintain data contiguity.

Necessary $N_K$ replicas of the input vector are created by using Hadamard gates, see Figure 16. Convolution kernels can be implemented using multiply-and-accumulate (MAC) operations; as such, it is possible to leverage ${\mathrm{U}}_{\mathrm{MAC}}$ as defined in Section 4.1 for implementing quantum convolution kernels. Given a kernel $\mathbf{K}\in {\mathbb{R}}^{N_K}$, the corresponding kernel operation ${\mathrm{U}}_K$ can be constructed from the normalized kernel K as shown in (31).

$${\mathrm{U}}_K={\mathrm{U}}_{\mathrm{MAC}}\left(K\right),\mathrm{where}K=\widehat{\mathbf{K}}=\frac{\mathbf{K}}{\mathbf{K}}$$

(31)

When applied to the $n_k$ lower qubits of the state vector, ${\mathrm{U}}_K$ applies the kernel $\mathbf{K}$ to all data windows in parallel. However, in CNNs, convolution layers typically must support multiple convolution kernels/ features. Fortunately, one major advantage of the proposed quantum convolution technique is that multiple features can be supported by multiplexing only the MAC operations – the stride and data rearrangement operations do not need to be multiplexed, see Figure 16. Accordingly, for $N_F$ features, $n_f=\lceil {log}_2{N}_F\rceil$ must be added to the circuit and placed in superposition using Hadamard gates, similar to the process in (26). The depth of the proposed multi-feature 1-D quantum convolution can be obtained as (32).

$$\begin{array}{cc}\hfill {\Delta }_{1-\mathrm{D}\mathrm{conv}}(n,n_k)& =\mathcal{O}\left(n_k{n}^2-n_k^{2}n+2^{n_f+n_k}\right),\mathrm{where}n\gg n_f,n_k\hfill \end{array}$$

(32)

4.2.2. Multi-Dimensional Multi-Feature Quantum Convolution

Multi-dimensional quantum convolution can be implemented by stacking multiple one-dimensional quantum circuits as shown in Figure 17. A d-dimensional quantum convolution circuit can be constructed with a stacked kernel of 1-dimensional convolution circuits only when the multidimensional kernels are outer products of d instances of 1-dimensional kernels. The depth of d-D quantum convolution can be obtained as (33).

$$\begin{array}{cc}\hfill {\Delta }_{d-\mathrm{D}\mathrm{conv}}(n,n_k)& =\mathcal{O}\left(n_{k_{\max }}{n}_{\max }^2-n_{k_{\max }}^2{n}_{\max }+2^{n_k+n_f}\right),\mathrm{where}\hfill \\ \hfill n_{\max }& =\underset{i=0}{\overset{d-1}{max}}\left(n_i\right),n_{k_{\max }}=\underset{i=0}{\overset{d-1}{max}}\left(n_{k_i}\right),\mathrm{and}{n}_{\max }\gg n_f,n_{k_{\max }}\hfill \end{array}$$

(33)

4.3. Quantum Pooling

A critical part of cnn is the pooling operation or downsampling of the feature maps. One widely-used method is average pooling, where only the average of the adjacent pixels in the feature map is preserved, creating a smoothing effect [36].

4.3.1. Quantum Average Pooling using Quantum Haar Transform

The average pooling operation can be implemented using the qwt [14] which has the advantage of preserving data locality using wavelet transform decomposition. It is a commonly used technique for dimension reduction in image processing [14]. In this work, we utilize the simplest and first wavelet transform, quantum Haar transform (QHT) [14] to implement quantum pooling operation. This operation is executed in 2 steps: the Haar wavelet operation and data rearrangement.

4.3.1.1. Haar Wavelet Operation:

For separating the high and low-frequency components from the input data, H gates are applied in parallel. The number of H gates applied in QHT is equal to the levels of decomposition.

4.3.1.2. Data Rearrangement:

After separating the high- and low-frequency components, quantum rotate-right (RoR) operations are applied to group them accordingly.

As mentioned before, the proposed framework is highly parallelizable regardless of the dimensions of the data as the QHT operation can be applied to multiple dimensions of data in parallel.

As shown in Figure 18, for a single-level of decomposition, H gates are applied on one qubit (the least significant qubit) per dimension, and for ℓ-level decomposition, shown in Figure 18, l number of H gates are applied per dimension. Each level of decomposition reduces the size of the corresponding dimension by a factor of 2.

4.3.2. Quantum Euclidean Pooling using Partial Measurement

In machine learning applications, the average and maximum (max) pooling [36] are the most commonly used pooling schemes for dimension reduction. The two schemes differ in the sharpness of data features. On one hand, max pooling yields a sharper definition of input features which makes it preferable for edge detection and certain classification applications [36]. On the other hand, average pooling offers a smoother dimension reduction that may be preferred in other workloads [36]. Thus, to accompany our implementation of quantum averaging pooling using QHT, see Section 4.3.1, it would be beneficial to have an implementation of quantum max pooling. However, such an operation would be non-unitary, creating difficulty for the implementation of quantum max pooling [37]. Therefore, instead of max pooling, we utilize an alternative pooling technique we denote as quantum Euclidean pooling.

Mathematically, average and Euclidean pooling are special cases of the p-norm [38], where for a vector of size N elements, the p-norm or ${\ell }^p$ norm of a vector $\mathbf{x}\in {\mathbb{C}}^N$ is given by (34) for $p\in \mathbb{Z}$ [38]. The average pooling occurs for the 1-norm ($p=1$) and Euclidean pooling occurs for the 2-norm ($p=2$). A notable benefit of the Euclidean pooling technique is its zero-depth circuit implementation by leveraging partial measurement [37].

$${\mathbf{x}}_p={\left(\sum _{i=0}^N{x}_i^p\right)}^{\frac{1}{p}}$$

(34)

This work leverages the multilevel, d-dimensional quantum Euclidean pooling circuit presented in [37], see Figure 19.

Here, for each dimension i, ${\ell }_i$ is the number of decomposition levels for dimension where $0\le i<d$ [37].

4.4. Multidimensional Quantum Convolutional Classifier

The proposed multidimensional quantum convolution classifier framework, see Figure 20, resembles cnn [2] structures. After a sequence of convolution-pooling (CP) pairs, the model is finally connected to a fully-connected layer, see Figure 15 and Figure 20. The total number of layers in the proposed model can be expressed in terms of CP pairs as $2\lambda +1$, where $\lambda$ is the number of CP pairs.

It is worth mentioning that there is no advantage in changing the number of features among convolution/pooling layers in the mqcc because of the implementation constraints. Therefore, the total number of kernel features can be estimated globally instead of layer-by-layer.

The circuit width of mqcc (35) can be derived from the number of convolution layers, pooling layers, and the fully-connected layer. Input data is encoded using n qubits and each convolution operation adds $n_f=\lceil {log}_2{N}_F\rceil$ qubits for $N_F$ features and $n_k=\lceil {log}_2{N}_K\rceil$ qubits per layer for kernels. In addition, the fully-connected operation contributes $n_c=\lceil {log}_2{N}_C\rceil$ qubits to encode $N_C$ output features/classes. On the other hand, each Euclidean pooling layer frees ℓ qubits, which can then be reused by other layers.

$$\begin{array}{cc}\hfill n_{\mathrm{mqcc}}^{\mathrm{Avg}}& =n+n_f+\lambda n_k+n_c\hfill \\ \hfill n_{\mathrm{mqcc}}^{\mathrm{Euclidean}}& =n+n_f+n_k+max(0,(\lambda -1)n_k-\lambda \ell +n_c)\hfill \end{array}$$

(35)

The mqcc can be further parallelized in terms of circuit depth between the inter-layer convoluti- on/fully-connected layers. This parallelism can be achieved by performing (multiplexed) MAC operations from the quantum convolution and fully-connected layers in parallel with the stride operation from the previous layer(s) of quantum convolution. The circuit depth of mqcc can be derived as shown in (36).

$$\begin{array}{cc}\hfill {\Delta }_{\mathrm{mqcc}}& =\underset{i=0}{\overset{d-1}{max}}{\Delta }_{{\mathrm{U}}_{\mathrm{stride}}}(n_i,n_{k_i})+\lambda ({\Delta }_H+{\Delta }_{\mathrm{SWAP}})\hfill \\ \hfill & +\sum _{j=0}^{\lambda -2}max\left(\underset{i=0}{\overset{d-1}{max}}{\Delta }_{{\mathrm{U}}_{\mathrm{stride}}}(n_i-j{\ell }_i,n_{k_i}),{\Delta }_{{\mathrm{U}}_K}(n_k,n_f)\right)\hfill \\ \hfill & +max\left({\Delta }_{\mathrm{FC}}(n-(\lambda -1)\ell ,n_c),{\Delta }_{{\mathrm{U}}_K}(n_k,n_f)\right)\hfill \end{array}$$

(36)

4.5. Optimized MQCC

Figure 21 presents a width-optimized implementation of MQCC, to which we refer as mqccoptimized. To reduce the required number of qubits, the convolution and pooling operations are swapped which allows kernel qubits to be trimmed for each convolution layer, see Section 4.2. To achieve higher processing efficiency, trimmed qubits are reassigned to later layers of dimension reduction and run in parallel. Furthermore, only Euclidean pooling with partial measurements is used because of the inherent circuit depth efficiency. The circuit width of mqccoptimized is shown in (37), where n is the number of qubits corresponding to the data size, $n_f$ is the number of qubits corresponding to the features, and $n_c$ is the number of qubits corresponding to the classes. If necessary, additional pooling operations can be applied to keep the circuit width at or below the absolute minimum number of qubits n, via excluding qubits dedicated to features and classes. It should be noted that reordering convolution and pooling operations reduces the maximum number of convolution operations by 1.

$$n_{\mathrm{bad}\mathrm{hbox}}=n+n_f+n_c$$

(37)

Accordingly, the depth of mqccoptimized can be expressed as shown in (38).

$$\begin{array}{cc}\hfill {\Delta }_{\mathrm{mqcc}}^{\mathrm{opt}}& =\underset{i=0}{\overset{d-1}{max}}{\Delta }_{{\mathrm{U}}_{\mathrm{stride}}}(n_i-{\ell }_i,n_{k_i})+\lambda ({\Delta }_H+{\Delta }_{\mathrm{SWAP}})\hfill \\ \hfill & +\sum _{j=1}^{\lambda -1}max\left(\underset{i=0}{\overset{d-1}{max}}{\Delta }_{{\mathrm{U}}_{\mathrm{stride}}}(n_i-j{\ell }_i,n_{k_i}),{\Delta }_{U_K}(n_k,n_f)\right)\hfill \\ \hfill & +max\left({\Delta }_{\mathrm{FC}}(n-\lambda \ell ,n_c),{\Delta }_{{\mathrm{U}}_K}(n_k,n_f)\right)\hfill \end{array}$$

(38)

To further reduce the depth of mqccoptimized, we investigated replacing inverse-c2q operations for mac operations with different parameterized ansatz. More specifically, a common ansatz in qml, namely, NLocal operation in Qiskit [39] or

BasicEntanglerLayer in Pennylane [40] was utilized, see Figure 22. The depth of this ansatz is linear with respect to the data size, see (39), which is a significant improvement over arbitrary state synthesis, which has a circuit depth of $\mathcal{O}\left(2^n\right)$ for an n-qubit state. Although the ansatz could potentially reduce circuit depth, its structure lacks theoretical motivation or guarantees for high fidelity when modeling convolution kernels.

$${\Delta }_{\alpha }(n,\ell )=\ell ·n+1$$

(39)

5. Experimental Work

In this section, we first detail our experimental setup, followed by the results for the proposed mqcc technique. Experiments were conducted using real-world, multidimensional image data to test both the individual and composite components of our techniques.

5.1. Experimental Setup

The mqcc methodology was validated by first evaluating its components, and then evaluating the complete technique. For experiments on 1-D data, we used audio material published by the European Broadcasting Union for sound quality assessment [41]. Using a pre-processing step, the data was converted into a single channel, with the data size varying from $2^8$ data points to $2^{20}$ data points, sampled at a rate of $44.1$ kHz. Further tests were conducted using high-resolution, multidimensional, real-world images of various kinds. The 2-D images used were either black-and-white or color Jayhawks [42], as shown in Figure 23, sized from $(8\times 8)$ pixels to $(512\times 512\times 3)$ pixels. For the 3-D image experiments, we used hyperspectral images from the Kennedy Space Center (KSC) dataset [43]. It was pre-processed and resized, with the sizes ranging from ($8\times 8\times 8$) pixels to ($128\times 128\times 128$) pixels.

Simulations of quantum convolution operation were run using Qiskit SDK (v0.45.0) from IBM Quantum [20] over the given data. To demonstrate the effect of statistical noise on the fidelity (40), both noise-free and noisy (with 1,000,000 circuit samples/shots) simulation environments were evaluated.

$$\mathrm{Fidelity}\left(\mathbf{X},\mathbf{Y}\right)=\frac{\langle \mathbf{X},\mathbf{Y}\rangle }{{\mathbf{X}}_F{\mathbf{Y}}_F}$$

(40)

To evaluate the performance of the complete mqcc technique, it was tested against cnns, qcnn, and quanvolutional neural networks by its capabilities of binary classification on real-world datasets such as MNIST [45], FashionMNIST [46], and CIFAR10 [47]. The classical components in these trials were run using PyTorch (v2.1.0) [48], while the quantum circuits used Pennylane (v0.32.0), a Xanadu QML-focused framework [49].

The experiments were performed on a cluster node at the University of Kansas [50]. The node consisted of a 48-Core Intel Xeon Gold 6342 CPU, three NVIDIA A100 80GB GPUs (CUDA version 11.7) with PCIe 4.0 connectivity and 256GB of 3200MHz DDR4 RAM. To account for initial parameter variance in ML or noise in noisy simulations, experiments were repeated for 10 trials with the median being displayed in graphs.

5.2. Configuration of ML models

The different techniques fundamentally being ML models meant that they could share some parameters and metrics during their testing. For example, the log loss and the Adam optimizer [51] was shared by all the techniques, and the "feature-count" metric was shared between the cnn and mqcc, which had 4 features per convolution layer. The parameters that were unique to each model are discussed next.

Convolutional Neural Networks: In Figure 24, we show the classification accuracy of the cnn model on ($16\times 16$) and ($28\times 28$) FashionMNIST datasets, using average pooling, max pooling, and Euclidean pooling. The plots show the obtained accuracy with and without ReLU [52], which is an optional layer that can be appended to each pooling layer in cnn. Based on the results, which show Max Pooling without ReLU to be the configuration with the best accuracy, we chose it to be the baseline configuration for cnn in our tests.

Quanvolutional Neural Networks: While quanvolutional neural networks were initially introduced without a trainable random quantum circuit in the quanvolutional layer, later work has suggested implementing parameterized and trainable quanvolutional layers. We, therefore, test both the trainable and non-trainable quanvolutional techniques and Figure 25 demonstrates that the trainable variant outperforms the other method in the ($16\times 16$) FashionMNIST dataset, although the differences are negligible on the ($28\times 28$) dataset. This is used as evidence behind our decision to use the trainable variant of the quanvolutional neural network as the baseline for comparison with the other models.

Quantum Convolutional Neural Networks: We based our implementation of qcnn on [53], however, some modifications were made to the technique to work around limitations present in the data encoding method. When encoding data that is not of size $2^n$ in each dimension, the original method flattens (vectorizes) the input before padding with zeros, as opposed to padding each dimension. However, this sacrifices the advantage of multidimensional encoding, where each dimension is mapped to a region of qubits. To ensure a level field between qcnn and mqcc, the ($16\times 16$) and ($28\times 28$) FashionMNIST datasets were tested both for the original (1-D) and a corrected (2-D) data encoding configuration of qcnn, the results of which are shown in Figure 26. As expected, we see a clear improvement on the ($28\times 28$) dataset and based on this, we chose the corrected (2-D) data encoding method as our baseline qcnn for comparison against other ML models.

5.3. Results and Analysis

We first present the results of the quantum convolution operations on data with varying dimensionalities. Then, we compare the fidelity results of the quantum convolution under a noisy simulation environment with reference to classical convolution implementation. Finally, we present the results for mqcc.

5.3.1. Quantum Convolution Results

Similar to pooling, the fidelity of the quantum convolution technique was tested in both a noise-free and noisy environment against a classical implementation using common $(3\times 3)$ and $(5\times 5)$ filter kernels. These kernels, as described in [Section 5.3.1–Section 5.3.1[, include the Averaging $F_{\mathrm{avg}}$, Gaussian blur $F_{\mathrm{blur}}$, Sobel edge-detection $F_{\mathrm{Sx}}$/$F_{\mathrm{Sy}}$, and Laplacian of Gaussian blur (Laplacian) $F_{\mathcal{L}}$ filters. To enable a quantum implementation of these kernels, a classical pre-processing step zero-padded each kernel until the dimensions were an integer power of two. As negative values may occur in classical convolution, the magnitudes of the output values were cast into a single-byte range $[0,255]$ in a classical post-processing step.

    .35

$$F_{\mathrm{avg}}^{3\times 3}=\frac{1}{9}\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\end{array}\right],$$

(41a)

     .5

$$F_{\mathrm{avg}}^{5\times 5}=\frac{1}{25}\left[\begin{array}{ccccc}1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1\end{array}\right]$$

(41b)

.35

$$F_{\mathrm{blur}}^{3\times 3}=\frac{1}{16}\left[\begin{array}{ccc}1& 2& 1\\ 2& 4& 2\\ 1& 2& 1\end{array}\right],$$

(42a)

     .5

$$F_{\mathrm{blur}}^{5\times 5}=\frac{1}{273}\left[\begin{array}{ccccc}1& 4& 7& 4& 1\\ 4& 16& 26& 16& 4\\ 7& 26& 41& 26& 7\\ 4& 16& 26& 16& 4\\ 1& 4& 7& 4& 1\end{array}\right]$$

(42b)

.35

$$F_{\mathrm{Sx}}=\frac{1}{4}\left[\begin{array}{ccc}1& 0& -1\\ 2& 0& -2\\ 1& 0& -1\end{array}\right],$$

(43a)

     .5

$$F_{\mathrm{Sy}}=\frac{1}{4}\left[\begin{array}{ccc}1& 2& 1\\ 0& 0& 0\\ -1& -2& -1\end{array}\right]$$

(43b)

.35

$$F_{\mathcal{L}}^{3\times 3}=\frac{1}{6}\left[\begin{array}{ccc}1& 1& 1\\ 1& -8& 1\\ 1& 1& 1\end{array}\right],$$

(44a)

     .5

$$F_{\mathcal{L}}^{5\times 5}=\frac{1}{20}\left[\begin{array}{ccccc}1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1\\ 1& 1& -24& 1& 1\\ 1& 1& 1& 1& 1\\ 1& 1& 1& 1& 1\end{array}\right]$$

(44b)

   

A 1-D averaging kernel of sizes ($1\times 3$) and ($1\times 5$) was applied to audio files after pre-processing, described in Section 5.1, with data size ranging from $2^8$ to $2^{20}$ data points. Figure 27 presents the reconstructed output data of this operation, with Figure 28 displaying the associated calculated fidelity.

The 2-D Averaging, Gaussian blur, Sobel edge-detection, and Laplacian kernels were applied to 2-D black-and-white and 3-D RGB Jayhawk images see Figure 23, ranging from ($8\times 8$) to ($512\times 512$) pixels and ($8\times 8\times 3$) pixels to ($512\times 512\times 3$) pixels, respectively.

The reconstruction from convolution operations in classical, noise-free, and noisy environments on ($128\times 128$) and ($128\times 128\times 3$)-pixel input images can be seen in Table 1 and Table 2, respectively.

Finally, a 3-D averaging kernel of sizes ($3\times 3\times 3$) and ($5\times 5\times 5$) was applied to hyperspectral images from the KSC

dataset [43] with pre-processing applied to ensure images were resized to a power of two, ranging from ($8\times 8\times 8$) pixels to ($128\times 128\times 128$) pixels in size. Figure 29 shows the reconstructed output images, while Figure 30 illustrates the fidelity of the operation compared to its classical counterpart.

Compared to the expected, classically generated results, the noise-free quantum results tested at 100% fidelity across all trials. Therefore, in a noise-free environment, given the same inputs, the proposed convolution techniques have no degradation compared to classical convolution. The fidelity of noisy simulation using 1-D audio and 3-D hyperspectral data are presented in Figure 28 and Figure 30, respectively. The fidelity degradation in both figures is due to the statistical noise where the constant shot count (number of circuit samples) becomes less and less sufficient to describe the increasing data size.

6. Discussion

In this section, we discuss the results of our experiments with MQCC and compare them against the other models in terms of the number of required training parameters, the accuracy of the model, and circuit depth of the implemented model.

6.1. Number of parameters

Among the ml models evaluated, mqcc had the fewest trainable parameters, see Figure 31. This implies potential advantages such as reduced memory usage and faster performance when using classical gradient descent. Although the reduction in parameter decreases from (mlp to cnn) and then further from (cnn to mqcc), parameter reduction diminishes from (mlp to cnn) and further from (cnn to mqcc), there is still a significant $83.62\%$ decrease in parameter count.

6.2. Loss History and Accuracy

ml-based classifiers aim to maximize the accuracy of their classifications, measured by a loss function during training to estimate the accuracy that may be exhibited when deployed. Hence, Figure 32 and Figure 33 depict the performance of the ml models across the experimental datasets in their plotting of log-loss history and classification accuracy. The MNIST [45] dataset is not complex enough to effectively distinguish models, however, differences begin to emerge in the FashionMNIST [46] and CIFAR10 [47] datasets. mlp consistently achieves the highest accuracy across trials due to its larger parameter count, allowing for greater flexibility in adapting to nuances in input. cnn showcases its ability to select relevant input features using convolution and data locality, demonstrating the second-highest accuracy. Among the tested models, qcnn generally performs the poorest, displaying its inability to properly leverage data locality. However, comparing the accuracy of mqcc and quanvolutional neural networks is inconclusive. Quanvolutional neural networks performed better on FashionMNIST, whereas mqcc performed better on CIFAR10.

6.3. Gate Count and Circuit Depth

Although comparing mqcc, mqccoptimized, and qcnn with quantum metrics like gate count and circuit depth is viable, see Figure 34, it is challenging to include quanvolutional neural networks in the comparison due to their significant differences from the other models. These differences are due to the quantum component within quanvolutional neural networks constituting a small fraction of the entire algorithm, bringing it closer to a classical algorithm than a quantum algorithm. Meanwhile, comparing the techniques of mqcc and qcnn in Figure 34, highlights the rationale behind developing mqccoptimized. Initially, mqcc performed worse than qcnn in gate count and circuit depth. However, after optimizations, mqcc matches the performance of qcnn and even outperforms it in best-case scenarios. While the qcnn architecture appears more suitable for shallower quantum circuits than mqcc, it is because the high parallelization of each qcnn layer halves the active qubits. Despite qcnn using half the active qubits per layer than mqcc, mqcc utilizes the extra qubits for weights and features, with each pooling layer reducing the qubit count by a constant amount, $n_k$. However, as qcnn’s structure was motivated by the classical convolution operation, they usually need more complex and deeper “convolution” and “pooling” ansatz to attain a higher accuracy.

7. Conclusions

In this paper, we presented the multidimensional quantum convolutional classifier (MQCC) that consists of quantum convolution, quantum pooling, and a quantum fully-connected layer. We leveraged existing convolution techniques to support multiple features/kernels and utilized it in our proposed method. Furthermore, we proposed a novel width-optimized quantum circuit that reuses freed-up qubits from pooling layer in the subsequent convolutional layer. The proposed MQCC additionally preserves data locality in the input data which has shown to improve data classification in convolutional classifiers. The MQCC methodology is generalizable for any arbitrary multidimensional filter operation and pertinent for multi-feature extraction. The proposed method can also support data of arbitrary dimensionality since the underlying quantum pooling and convolution operations are generalizable across data dimensions. We experimentally evaluated the proposed MQCC on various real-world multidimensional images, utilizing several filters through simulations on state-of-the-art quantum simulators from IBM Quantum and Xanadu. In our experiments, MQCC produced higher classification accuracy while having a lower training time and reduced quantum gate count. In our future work, we are planning on expanding mqcc with additional convolution capabilities such as arbitrary striding and dilation and further optimizing it for deployment on real-world quantum processors. In addition, we will investigate using our proposed quantum techniques for real-life applications such as medical imaging and classification.