Quantum Convolutional Neural Networks

• Quantum Convolutional Neural Networks (QCNNs) are quantum machine-learning architectures that mimic classical CNNs using hierarchical local unitaries, pooling operations, and a final readout layer.
• QCNNs achieve computational efficiency by reducing qubit counts layer-wise and employing O(log N) parameters, which enhances trainability and robustness in phase recognition tasks.
• QCNN variants extend to classical data and image classification, leveraging techniques like amplitude encoding and SWAP-test overlap to accommodate hardware constraints.

Quantum convolutional neural networks (QCNNs) are quantum machine-learning architectures that transplant the convolution–pooling hierarchy of classical convolutional neural networks into quantum circuits. In the original formulation, a QCNN is a hierarchical, translationally invariant circuit acting on $N$-qubit inputs with only $O(\log N)$ variational parameters, built from alternating local “convolution” unitaries, measurement-based or trace-out “pooling” operations, and a small final readout layer; it was introduced for quantum phase recognition and for optimizing quantum error-correction schemes (Cong et al., 2018). Subsequent literature extended the term to several related constructions: fully parameterized and hybrid QCNNs for classical-data classification, measurement-based realizations on cluster states, branching and symmetry-parallelized variants, and image-oriented models that reinterpret convolution directly in amplitude space (Hur et al., 2021, Sun et al., 2024, Qu et al., 11 Apr 2025).

1. Origins and scope of the concept

The canonical QCNN entered the literature as a quantum-native classifier for many-body states. Its defining architectural ideas were locality, translational invariance, and hierarchical coarse-graining: convolution layers apply repeated quasi-local unitaries, pooling layers reduce the number of active qubits, and a final fully connected layer acts on a small surviving register (Cong et al., 2018). The same work tied QCNNs simultaneously to the multi-scale entanglement renormalization ansatz (MERA) and to quantum error correction (QEC): MERA provides the reverse-renormalization viewpoint, while pooling measurements act as syndrome-like diagnostics that can detect and correct local perturbations during coarse-graining (Cong et al., 2018).

Very early expository work already distinguished two research directions. One direction treats QCNNs as quantum-native architectures for quantum many-body data, especially phase recognition in physics and chemistry; the other inserts quantum convolutional components into classical vision pipelines as hybrid quantum–classical models (Oh et al., 2020). Later papers broadened the label further. As a result, “QCNN” now denotes a family of non-identical models rather than a single standardized circuit template. Some constructions remain close to the Cong-style architecture with mid-circuit measurement and qubit reduction; others implement convolution by amplitude-space linear algebra, by SWAP-test overlap estimation, or by local measurements on cluster states (Cong et al., 2018, Stein et al., 2022, Sun et al., 2024, Qu et al., 11 Apr 2025).

2. Architectural principles and formal structure

In the standard variational formulation, a QCNN alternates convolution-like layers and pooling-like layers until only one or a few qubits remain. A representative layer update is written as

$\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$

where $U_i(\boldsymbol{\theta}_i)$ is the parameterized unitary for layer $i$, and $\mathrm{Tr}_{B_i}$ removes the pooled subsystem $B_i$ (Hur et al., 2021). In the original quantum-data setting, the output can be interpreted as the expectation value of a simple observable after a hierarchical basis transformation, whereas in later classification settings it is often the sign or softmax post-processing of a small-register measurement (Cong et al., 2018, Khoo et al., 2024).

A central quantitative feature of the canonical architecture is logarithmic scaling. Because the number of active qubits is halved layer by layer, the depth grows only logarithmically with system size, and the original QCNN uses only $O(\log N)$ variational parameters for $N$-qubit inputs (Cong et al., 2018). This scaling underlies several later claims about trainability and NISQ suitability. In benchmarking work on phase classification and quantum autoencoding, the number of discarded qubits after $l$ QCNN layers is written as

$O(\log N)$0

so each pooling stage removes roughly half of the active qubits (Khoo et al., 2024).

Later classical-data QCNNs often retained the same hierarchy while restricting the circuit primitives. One important line of work emphasized fully parameterized yet shallow circuits using only two-qubit interactions throughout the algorithm, with translationally invariant two-qubit filters and two-qubit pooling blocks (Hur et al., 2021). This restriction makes the architecture closer to near-term hardware constraints, but it does not fix a unique encoding strategy: amplitude encoding, qubit encoding, dense qubit encoding, and hybrid blockwise encodings all appear in the literature (Hur et al., 2021).

3. Quantum-data QCNNs: phase recognition and compression

The most developed quantum-native application of QCNNs is phase recognition in many-body systems. In the original 1D example, the target was a $O(\log N)$1-protected symmetry-protected topological phase containing the 1D cluster state. The Hamiltonian studied was

$O(\log N)$2

and the QCNN was designed so that states in the target phase flow toward a fixed-point representative under repeated convolution, pooling, and correction (Cong et al., 2018). The same paper also formulated QCNN training on a small set of exactly solvable points and showed that the learned circuit could reproduce the phase diagram over the full parameter regime (Cong et al., 2018).

This program was later implemented experimentally on a 7-qubit superconducting processor. There, the QCNN identified the symmetry-protected topological phase of a cluster-Ising Hamiltonian using one convolutional layer, one pooling layer, a fully connected layer, and final measurement of a single output qubit, with part of the pooling and fully connected logic compiled into classical Boolean post-processing (Herrmann et al., 2021). The experimentally relevant output observable was $O(\log N)$3, and the reported result was that the QCNN recognized the topological phase with higher fidelity than direct measurement of the string order parameter on the prepared approximate ground states; in the SPT region, the QCNN output reached values up to about $O(\log N)$4 while remaining near zero outside the phase (Herrmann et al., 2021).

The same conceptual machinery has been extended to higher-dimensional and intrinsically topological settings. A 2D QCNN for the toric code recognized the transition from the $O(\log N)$5-topologically ordered toric-code phase to a trivial paramagnet, locating the $O(\log N)$6-driven boundary at $O(\log N)$7, detecting a multicritical point near $O(\log N)$8 in the symmetric-field case, and exhibiting a Pauli-noise threshold $O(\log N)$9 below which topological order remained identifiable (Sander et al., 2024). This construction used a toric-code inverse-preparation circuit as convolution and stabilizer-based pooling with CNOT and Toffoli gates (Sander et al., 2024).

QCNNs have also been benchmarked against hardware-efficient ansätze (HEAs) for quantum-data classification and quantum autoencoding. For transverse-field Ising and XXZ ground states on 4, 8, and 16 qubits, real-valued RY-based QCNNs matched HEA performance while training much faster because of reduced parameter count; in one representative 16-qubit classification task, QCNN (RY) achieved test accuracy $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$0 with training time $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$1 s per sample and $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$2 trainable parameters, while a 3-layer HEA achieved $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$3, $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$4 s per sample, and $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$5 parameters (Khoo et al., 2024). The same work also used QCNN-based autoencoders for compressing quantum states, with reconstruction quality evaluated by $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$6 (Khoo et al., 2024).

4. Classical-data and image-classification QCNNs

A second major literature adapts QCNNs to classical images and tabular data. One early NISQ-oriented proposal mapped classical convolutional kernels directly into implementable quantum circuits via linear combinations of unitaries, with claimed gate complexity $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$7 and variational parameter scaling $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$8, where $\ketbra{\psi_i(\boldsymbol{\theta}_i)}{\psi_i(\boldsymbol{\theta}_i)} = \mathrm{Tr}_{B_i}\!\left( U_i(\boldsymbol{\theta}_i)\, \ketbra{\psi_{i-1}}{\psi_{i-1}}\, U_i^\dagger(\boldsymbol{\theta}_i) \right),$9 is the input size, $U_i(\boldsymbol{\theta}_i)$0 the filter-mask size, and $U_i(\boldsymbol{\theta}_i)$1 the number of Hamiltonian parameters in the fully connected layer (Wei et al., 2021). That work used amplitude encoding, average-pooling by qubit discarding, and a Hamiltonian-based quantum fully connected layer, and reported MNIST accuracies $U_i(\boldsymbol{\theta}_i)$2 noisy and $U_i(\boldsymbol{\theta}_i)$3 noise-free on a binary task, and $U_i(\boldsymbol{\theta}_i)$4 noisy and $U_i(\boldsymbol{\theta}_i)$5 noise-free on a 10-class task, versus $U_i(\boldsymbol{\theta}_i)$6 and $U_i(\boldsymbol{\theta}_i)$7 for a classical CNN baseline (Wei et al., 2021).

A related fully parameterized line restricted the entire model to two-qubit interactions and benchmarked circuit templates, encodings, preprocessors, losses, and optimizers on binary MNIST and Fashion-MNIST classification (Hur et al., 2021). In that study, 8-qubit QCNNs with only $U_i(\boldsymbol{\theta}_i)$8 to $U_i(\boldsymbol{\theta}_i)$9 trainable parameters reached about $i$0–$i$1 on MNIST and about $i$2 on Fashion-MNIST, and generally outperformed small classical CNNs trained under similar parameter budgets and training conditions (Hur et al., 2021). The same literature includes image-specific proposals based on implementable quantum circuits and MNIST evaluation, although some 2021 arXiv records provide only the abstract-level claim that a QCNN with a CNN-like structure was proposed and numerically validated on MNIST (Lü et al., 2021).

Multi-class QCNNs for classical data have emphasized output design, encoding choice, and hardware-feasible preprocessing. A PennyLane implementation for 4-, 6-, 8-, and 10-class MNIST used a preconvolutional filter before each convolution block and trained the circuit by minimizing cross-entropy with Adam; with amplitude encoding, reported QCNN accuracies were $i$3, $i$4, $i$5, and $i$6 for 4, 6, 8, and 10 classes, compared with $i$7, $i$8, $i$9, and $\mathrm{Tr}_{B_i}$0 for a classical CNN of comparable scale (Mordacci et al., 2024). Another line removed the power-of-two input restriction by introducing layer-wise and single-ancilla qubit padding; on PCA-reduced MNIST and Breast Cancer tasks, the single-ancilla variant matched the best baselines while using only one reusable ancilla and remaining more robust than skip-pooling under IBMQ Jakarta-inspired noise (Lee et al., 2024).

Recent hardware-aware work has pushed the fully quantum image-classification line further. A fragment-encoding QCNN processed raw $\mathrm{Tr}_{B_i}$1 MNIST images using a 49-qubit architecture with no classical dimensionality reduction, compressing $\mathrm{Tr}_{B_i}$2 inputs per qubit so that $\mathrm{Tr}_{B_i}$3 covers the full image (Röseler et al., 9 May 2025). In simulation, the best regular QCNN reached $\mathrm{Tr}_{B_i}$4 accuracy with $\mathrm{Tr}_{B_i}$5 parameters on binary $\mathrm{Tr}_{B_i}$6-vs-$\mathrm{Tr}_{B_i}$7 classification; on IBM’s Heron r2 processor, the same line reported $\mathrm{Tr}_{B_i}$8 QCNN accuracy versus a $\mathrm{Tr}_{B_i}$9 classical benchmark under identical training conditions (Röseler et al., 9 May 2025). Another recent proposal introduced nonlinear effects through orthonormal basis expansions of power series and mitigated barren plateaus by direct unitary-matrix parameterization, reporting $B_i$0 on MNIST and $B_i$1 on Fashion-MNIST (Yang, 4 Aug 2025).

5. Theoretical reinterpretations and architectural diversification

A major theoretical reinterpretation argues that quantum neural networks already possess an inherent convolution property in amplitude space. After amplitude encoding of a flattened image, an $B_i$2-qubit gate acting on qubits $B_i$3 through $B_i$4 can be viewed as a convolution layer with kernel size $B_i$5, stride $B_i$6, and $B_i$7 output channels; in the simplest example, a single two-qubit gate corresponds to kernel size $B_i$8, stride $B_i$9, and $O(\log N)$0 output channels (Qu et al., 11 Apr 2025). From that standpoint, several earlier QCNNs were quantum-inspired but not fully convolution-aware, because they did not explicitly realize local connectivity, sparse receptive fields, multi-channel processing, and layered hierarchical feature extraction in the classical CNN sense (Qu et al., 11 Apr 2025). The same work proposed explicit channel and layer registers for MNIST, used only $O(\log N)$1 parameters, and reported $O(\log N)$2, $O(\log N)$3, $O(\log N)$4, and $O(\log N)$5 on 2-, 4-, 8-, and 9-class tasks without classical feature extraction (Qu et al., 11 Apr 2025).

Other variants modify how the hierarchy is implemented rather than how convolution is interpreted. A QCNN with flexible stride used quantum arithmetic, swap tests, and quantum amplitude estimation to recover receptive-field positions via relations such as $O(\log N)$6 and $O(\log N)$7, thereby allowing stride selection without qubit count growing proportionally with window size; on reduced MNIST, the best reported accuracies were $O(\log N)$8 for $O(\log N)$9 vs $N$0 at stride $N$1 and $N$2 for $N$3 vs $N$4 at stride $N$5 (Yu et al., 2024). A measurement-based QCNN replaced deep unitary circuits by cluster-state resources and local measurement-basis optimization, giving an exact cluster-state construction for general QCNN blocks and showing fast convergence on both Haldane-phase recognition and iris classification (Sun et al., 2024).

Several proposals increase expressivity by exploiting mid-circuit measurement or non-canonical convolution primitives. Branching QCNNs use pooling-layer measurement outcomes to select subsequent convolutional branches; in a 4-qubit example, this increased the trainable parameter count from $N$6 for QCNN to $N$7 for bQCNN at the same quantum depth, and on 8 qubits the expressibility metric based on KL divergence to the Haar fidelity distribution improved from $N$8 for QCNN to $N$9 for bQCNN (MacCormack et al., 2020). QuCNN replaced classical dot-product filtering by SWAP-test overlap between a quantum data patch and a quantum filter state, with ancilla-assisted backpropagation; it was validated on small MNIST subsets and is best regarded as a QCNN-style convolutional model rather than the canonical Cong architecture (Stein et al., 2022).

6. Trainability, measurement efficiency, and open issues

A recurring claim in the QCNN literature is that the hierarchical structure improves trainability relative to generic variational circuits. The original QCNN emphasized $l$0 parameter scaling (Cong et al., 2018); later work on arbitrary input dimensions described QCNNs as attractive partly because of the absence of the barren plateau problem, and benchmarking studies argued that logarithmic-depth hierarchy and reduced parameter count explain faster training of RY-based QCNNs relative to HEAs (Lee et al., 2024, Khoo et al., 2024). A more recent matrix-based model attempted barren-plateau mitigation explicitly by parameterizing full unitaries rather than deep stacks of parameterized gates (Yang, 4 Aug 2025).

Measurement cost, however, remains a major bottleneck. For translationally symmetric quantum data, split-parallelizing QCNNs replace qubit discarding by symmetry-preserving circuit splitting and average readout,

$l$1

yielding a relative measurement efficiency $l$2 in favorable regimes and reducing the conventional QCNN measurement cost $l$3 by about an order of the number of qubits (Chinzei et al., 2023). This addresses statistical error in loss-gradient estimation but depends on strong prior symmetry assumptions (Chinzei et al., 2023).

Several technical limitations recur across the literature. Classical-data QCNNs frequently rely on amplitude encoding or QRAM-style assumptions, both of which are costly in practice; even authors advocating amplitude-space convolution note that the model still depends on amplitude encoding and that the proposed “nonlinearity” is not a true classical activation function (Qu et al., 11 Apr 2025). Hardware-oriented HEP QCNNs remark that parameter-shift training becomes expensive because a filter of size $l$4 scanned over $l$5 locations requires at least $l$6 circuit evaluations (Chen et al., 2020). Experimental realizations exist, but at limited scale: a 7-qubit superconducting QCNN for SPT recognition (Herrmann et al., 2021) and a Heron-r2 image classifier on binary MNIST (Röseler et al., 9 May 2025).

A further conceptual issue is interpretive rather than hardware-specific. Analysis of QCNNs on quantum data argues that their performance often comes less from generic variational expressivity than from a hidden physical feature map induced by ground-state preparation and from learning a sharp dressed measurement. In that view, QCNNs are “measurement-adaptation” architectures whose strong generalization in limited-shot regimes is tied to physically structured embeddings; in the reported comparison, a ground-state embedding recovered high accuracy with about $l$7 shots, whereas a Fourier-type embedding needed around $l$8 shots to match its infinite-shot behavior (Umeano et al., 2023). This suggests that the practical meaning of “convolution” in QCNN research is highly task-dependent: for quantum phases it is often renormalization plus error correction, while for classical images it may be amplitude-space filtering, local variational patch processing, or measurement-based feature extraction.