Quanvolutional Neural Networks

• Quanvolutional neural networks (QNNs) are hybrid quantum–classical models that encode local input patches into quantum states to extract classical features.
• They leverage fixed random or variational quantum circuits to mimic convolutional filters, often achieving faster convergence and improved performance in small-data regimes.
• Ongoing research explores diverse encoding methods and integrated circuit designs to enhance robustness, optimize gradient flow, and balance quantum resource constraints.

Searching arXiv for recent and foundational papers on quanvolutional neural networks to ground the article. Quanvolutional neural networks are hybrid quantum–classical architectures in which local patches of an input image or spectrogram are encoded into small quantum states, transformed by quantum circuits, and decoded into classical feature maps for downstream learning. The paradigm was introduced as a quantum replacement for a classical convolutional filter bank using fixed random circuits on local image patches (Henderson et al., 2019), and has since expanded to include variational quanvolutional layers with alternative image encodings (Mattern et al., 2021), fidelity-based quantum filters with entanglement-based backpropagation (Stein et al., 2022), integrated encoding–processing schemes with quantization and memoization (Bosco et al., 2024), residualized trainable quanvolutional stacks (Kashif et al., 2024), and QCNN formulations in which local quantum gates themselves are treated as convolutional operators on amplitude-encoded data (Qu et al., 11 Apr 2025). Across this literature, the acronyms QNN, QuNN, QCNN, and QuCNN are used for closely related but not identical constructions.

1. Historical emergence and conceptual scope

The original quanvolutional proposal replaced the first classical convolutional layer of a CNN with a bank of small quantum circuits acting on local patches. In the MNIST experiments of Henderson et al., each $3\times 3$ patch was thresholded, encoded into a 9-qubit state, processed by a fixed random quantum circuit, and decoded into a scalar feature; the resulting hybrid QNN slightly exceeded a classical CNN in test accuracy and reached comparable accuracy in fewer training iterations (Henderson et al., 2019). This formulation established the canonical near-term view of quanvolution: shallow, local quantum feature extraction embedded inside an otherwise classical pipeline.

A second, partially overlapping lineage came from quantum convolutional neural networks for quantum states, especially the MERA-inspired construction discussed in the tutorial by Oh et al. That literature emphasized logarithmic-depth circuits, hierarchical coarse-graining, and classification of quantum many-body data, but the same tutorial also treated hybrid image models in which a quantum convolutional layer is inserted into a classical CNN and implemented with TensorFlow Quantum (Oh et al., 2020). The result is a terminological overlap: in some papers, QCNN denotes a hierarchical circuit on quantum data; in others, it denotes a quanvolutional front-end for classical data.

Subsequent work diversified the design space rather than converging on a single canonical architecture. Some papers retained fixed random quantum filters to avoid quantum-layer training costs (Reese et al., 2022, Bosco et al., 2024). Others made the quanvolutional circuit variational (Mattern et al., 2021, Kashif et al., 2024), or redefined the “convolution” itself as a state-overlap computation between amplitude-encoded data states and trainable quantum filter states (Stein et al., 2022). More recent work went further by arguing that local quantum gates already implement convolution-like operations on amplitude-encoded registers, so that a QCNN can be designed by exposing this native block-diagonal action rather than by emulating classical convolutions patch by patch (Qu et al., 11 Apr 2025).

2. Canonical quanvolutional operation

A standard quanvolutional layer maps a local classical patch $x$ to one or more classical features through three primitives: encoding, quantum evolution, and measurement. In the variational formulation used by Kölle et al., if $\rho(x)$ is the encoded patch state and $U(\boldsymbol\theta)$ the quantum circuit, the $j$th feature is

$f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$

with $M_j$ typically chosen as a Pauli-$Z$ observable (Mattern et al., 2021). This expectation-value form is now the dominant mathematical abstraction for quanvolutional feature extraction.

In fixed-filter quanvolutional models, $U(\boldsymbol\theta)$ is replaced by a circuit whose parameters are randomly sampled once and then held static. Henderson et al. used shallow random circuits on threshold-encoded $3\times 3$ patches and reduced the resulting quantum state to a scalar by selecting the most likely bitstring and counting the number of ones (Henderson et al., 2019). Many later implementations instead measure each qubit in the $x$0-basis and use all $x$1 expectation values as an $x$2-channel output for each patch, which makes the quanvolutional output resemble a classical multi-channel convolutional feature map (Reese et al., 2022).

Lizzio Bosco et al. formalized the usual quanvolutional workflow as a four-step pipeline: optional input binary quantization, classical-to-quantum encoding, quantum processing, and quantum-to-classical decoding (Bosco et al., 2024). In that description, rotational encoding uses

$x$3

or threshold encoding applies either an $x$4 gate or identity depending on whether the binarized pixel equals $x$5 or $x$6. The processing stage applies a fixed sequence of single- and two-qubit gates, and the decoding stage commonly reduces the output distribution to the average number of qubits found in $x$7 (Bosco et al., 2024).

The locality prior of classical convolution survives in these constructions through the patching scheme rather than through a global translationally equivariant operator. A quanvolutional layer typically scans the input with an $x$8 or $x$9 kernel, applies the same quantum circuit to every patch, and assembles the resulting measured features into a feature map. This suggests that quanvolution inherits the patchwise inductive bias of classical convolution even when the quantum circuit itself is highly non-classical.

3. Encodings and circuit constructions

The most immediate architectural choice is the image or patch encoding. Kölle et al. compared three approaches: threshold encoding, FRQI, and NEQR (Mattern et al., 2021). Threshold encoding uses one qubit per pixel and $\rho(x)$0 single-qubit $\rho(x)$1 gates. FRQI uses one color qubit plus $\rho(x)$2 position qubits for an $\rho(x)$3 patch and requires one controlled-$\rho(x)$4 per pixel plus $\rho(x)$5 Hadamards, for a total of $\rho(x)$6 gates. NEQR uses $\rho(x)$7 position qubits plus 8 color qubits and also has worst-case $\rho(x)$8 gate complexity, reducible by classical logic minimization (Mattern et al., 2021). Their experiments showed that trainable circuits helped FRQI most strongly: for $\rho(x)$9 filters, FRQI improved from $U(\boldsymbol\theta)$0 to $U(\boldsymbol\theta)$1, and for $U(\boldsymbol\theta)$2 filters from $U(\boldsymbol\theta)$3 to $U(\boldsymbol\theta)$4, while threshold encoding remained competitive in untrainable settings (Mattern et al., 2021).

A different line of work focuses on reducing the rigid coupling between patch size and qubit count. In the standard rotational or threshold pipeline, a $U(\boldsymbol\theta)$5 patch requires exactly $U(\boldsymbol\theta)$6 qubits, and the number of two-qubit gates grows as $U(\boldsymbol\theta)$7 (Bosco et al., 2024). The integrated encoding scheme of Lizzio Bosco et al. instead combines encoding and processing into a single circuit

$U(\boldsymbol\theta)$8

with $U(\boldsymbol\theta)$9, random feature assignments, random qubit pairs, and one of three scalar mappings $j$0 (Bosco et al., 2024). Because each gate both injects classical information and performs a two-qubit interaction, the number of qubits $j$1 can be chosen independently of the filter size $j$2. In their experiments, the integrated model used a fixed $j$3 qubits and $j$4 gates, so a $j$5 kernel required $j$6 two-qubit rotations on 4 qubits rather than 25 qubits and about 119 gates in the rotational baseline (Bosco et al., 2024).

The same paper also introduced a preprocessing optimization that is particularly relevant for quanvolution’s high circuit-call count. The $j$7-level quantizer

$j$8

creates a finite grid of patch values that can be memoized in a hash table. Only the first occurrence of a quantized patch triggers a quantum circuit execution; later occurrences reuse the cached output (Bosco et al., 2024). Empirically, using $j$9 on $f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$0 patches yielded $f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$1 on both MiraBest and LArTPC and reduced circuit calls by about $f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$2–$f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$3 (Bosco et al., 2024).

A more radical reconstruction of quanvolution appears in QuCNN. There, each image patch is amplitude-encoded as a quantum data state $f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$4, each filter is a trainable quantum state $f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$5, and the “convolution” is a similarity score given by the squared overlap

$f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$6

estimated via a SWAP test (Stein et al., 2022). The ancilla measurement obeys

$f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$7

so local feature extraction becomes a fidelity estimation problem rather than an expectation-value readout of a single encoded patch (Stein et al., 2022). This formulation is closer to matched filtering in a Hilbert space of quantum states than to the random-feature perspective of early quanvolution.

4. Trainability, depth, and theoretical reformulations of convolution

Early quanvolutional layers were mostly static. Henderson et al. explicitly kept the quantum filters fixed and trained only the classical part of the network (Henderson et al., 2019). Later work showed that making the quantum layer trainable can materially alter performance, but also introduces severe gradient-flow constraints. In ResQuNN, Kashif and Shafique parameterized the quanvolutional unitary as

$f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$8

and reported that a static QuNN reached about $f_j(x;\boldsymbol\theta) \;=\; \Tr\!\Bigl[\,U(\boldsymbol\theta)\,\rho(x)\,U^\dagger(\boldsymbol\theta)\,M_j\Bigr], \qquad j=1\ldots Q,$9 accuracy on 1,000 MNIST images after 30 epochs, whereas a trainable quanvolutional layer reached about $M_j$0 (Kashif et al., 2024). They further found that multi-layer trainable QuNNs suffered from missing gradients in early quantum layers unless residual connections were inserted.

The central empirical result of ResQuNN is that skip-connection placement matters. In a two-layer model, only the residual configurations $M_j$1 and $M_j$2 enabled gradient flow through both quantum layers; the no-residual and $M_j$3 configurations stalled at about $M_j$4 accuracy (Kashif et al., 2024). In the three-layer case, only $M_j$5 and $M_j$6 admitted gradients in all three quanvolutional layers (Kashif et al., 2024). This suggests that depth in trainable quanvolution is not merely a matter of stacking more PQCs; it requires an architecture-level remedy for measurement-induced optimization bottlenecks.

QuCNN proposed a different answer to the training problem: perform backpropagation through a SWAP-test-based ancilla routine. Using the parameter-shift rule,

$M_j$7

and a second ancilla qubit to encode the backpropagated weight $M_j$8, the authors showed how to estimate the weighted loss gradient directly on chip (Stein et al., 2022). In their MNIST-subset experiments, forward-pass feature maps matched classical convolutional maps with mean absolute error $M_j$9, the gradient error fell to $Z$0 with 4,096 shots, and a 3-layer ansatz reached $Z$1 fidelity with an ideal target filter state after $Z$2 optimization steps (Stein et al., 2022).

A more foundational reformulation appears in the “inherent convolution” view of quantum neural networks. Qu et al. showed that if an $Z$3-qubit unitary $Z$4 acts on the $Z$5 least-significant qubits of an $Z$6-qubit amplitude-encoded register, then the full operator $Z$7 is block-diagonal with repeated $Z$8 blocks, so the same $Z$9 weight matrix is applied simultaneously to each local patch (Qu et al., 11 Apr 2025). Their Theorem 1 identifies this action with a stride $U(\boldsymbol\theta)$0, kernel-size $U(\boldsymbol\theta)$1, $U(\boldsymbol\theta)$2-channel convolution; a single $U(\boldsymbol\theta)$3-qubit gate implements $U(\boldsymbol\theta)$4 multiplies in one shot, whereas a classical convolutional layer would require $U(\boldsymbol\theta)$5 scalar multiplications (Qu et al., 11 Apr 2025). In this framework, parameter sharing follows from block-diagonal repetition, local connectivity from using $U(\boldsymbol\theta)$6, and dilation from changing which qubits the gate acts upon.

Related QCNN work has attempted to address two long-standing objections to quantum neural networks: the absence of intrinsic nonlinearity and barren plateaus. Yang proposed orthonormal basis expansions of power-series features to induce nonlinear effects and direct unitary-matrix parameterization to avoid deep stacks of parameterized gates (Yang, 4 Aug 2025). That model was trained in PyTorch on matrix representations and then validated in Qiskit; the reported accuracies of the two simulations agreed to within $U(\boldsymbol\theta)$7 on resized MNIST (Yang, 4 Aug 2025). This suggests that some recent QCNN designs are moving away from gate-by-gate variational circuits toward matrix-native quantum convolution blocks.

5. Empirical performance across benchmark and application domains

The earliest MNIST benchmark results established both the promise and the ambiguity of quanvolution. Henderson et al. reported that after 10,000 training steps, a classical CNN reached about $U(\boldsymbol\theta)$8 test accuracy, the QNN about $U(\boldsymbol\theta)$9, and a classical random-nonlinearity control about $3\times 3$0 (Henderson et al., 2019). The QNN reached $3\times 3$1 accuracy in about 2,000 iterations, whereas the CNN required about 3,000, corresponding to an about $3\times 3$2 speedup to that threshold (Henderson et al., 2019). However, because the random classical control matched the quantum model within experimental noise, that study did not establish a uniquely quantum source for the improvement.

The tutorial implementation of Oh et al. placed a $3\times 3$3 quanvolutional layer in front of a classical fully connected head and simulated the model on downscaled $3\times 3$4 MNIST using TensorFlow Quantum. After 20 epochs, the reported final test accuracies were about $3\times 3$5 for a fully connected baseline, $3\times 3$6 for a classical CNN, and $3\times 3$7 for the QCNN (Oh et al., 2020). This result framed quanvolution as capable of classical-CNN-level accuracy on a small benchmark rather than as an immediate route to large empirical gains.

More recent work has focused on multiclass tasks and circuit efficiency. Qu et al. evaluated two-layer QCNNs with $3\times 3$8 kernels on zero-padded $3\times 3$9 MNIST images amplitude-encoded into 10 qubits and reported the following accuracies: for 2 classes, $x$00, $x$01, and $x$02 for 1, 4, and 8 channels; for 4 classes, $x$03, $x$04, and $x$05; and for 8 classes, $x$06, $x$07, and $x$08 (Qu et al., 11 Apr 2025). Those models used only 40 trainable parameters and no classical feature-extraction front-end, while matching or exceeding prior pure-quantum CNN accuracies in the 2-class, 4-class, and 8-class settings (Qu et al., 11 Apr 2025).

Integrated encoding and quantization were evaluated on two non-MNIST image tasks. On MiraBest, a classical CNN baseline achieved $x$09, rotational encoding with $x$10 achieved $x$11, and the integrated Simple mapping with $x$12 achieved $x$13, which was the best overall result (Bosco et al., 2024). On LArTPC, the baseline achieved $x$14, rotational encoding with $x$15 achieved $x$16, and integrated Simple with $x$17 achieved $x$18 (Bosco et al., 2024). These comparisons are notable because all models used the same downstream classical head and the integrated quantum encoding required fewer quantum resources than the rotational baseline.

Quanvolutional models have also been studied in explicitly small-data regimes. In an industrial crack-detection task, the hybrid QNN of Kairouz et al. reached about $x$19 test accuracy with 100 training images, whereas the classical CNN plateaued at about $x$20; with only 50 training images, the QNN still achieved about $x$21, while the classical model dropped to about $x$22 (Reese et al., 2022). In a second-stage configuration with 16 qubits and a $x$23 train/test split, the QNN reached about $x$24 validation accuracy by epoch 30 versus about $x$25 for the CNN, and with only $x$26 of the data for training the QNN reached $x$27 test accuracy while the classical CNN remained at about $x$28–$x$29; the reported false negative rates were below $x$30 (Reese et al., 2022).

Speech and biomedical applications show a similar emphasis on limited data. Tran et al. converted dysphonia recordings into $x$31 Mel spectrograms and compared two QNNs with two CNN baselines across ten training-set sizes (Tran et al., 13 Feb 2025). At $x$32, QNN2 achieved $x$33 versus $x$34 for CNN2, and at $x$35, QNN2 achieved $x$36 versus $x$37 (Tran et al., 13 Feb 2025). The authors reported that the QNN models consistently outperformed the CNN models in both accuracy and stability across most experiments (Tran et al., 13 Feb 2025).

6. Robustness, limitations, and open research questions

Adversarial robustness has become a distinct subtopic in quanvolutional research. AdvQuNN evaluated five non-trainable ansätze under FGSM, PGD, and MIM on MNIST and Fashion-MNIST, using only 50 training samples per model, and reported that QuNNs can achieve up to $x$38 higher robustness on MNIST and $x$39 on FMNIST relative to classical convolutional networks (Maouaki et al., 2024). On MNIST under FGSM, the classical CNN’s accuracy fell to near zero by $x$40, whereas the ZZ-full QuNN remained above $x$41 even at $x$42; ZZ-full and ZZ-star were the most robust on MNIST, while the ranking changed on FMNIST (Maouaki et al., 2024). RobQuNN reached a similar conclusion for white-box attacks on MNIST: at $x$43, the Full ZZ ansatz achieved $x$44 accuracy under FGSM versus $x$45 for the CNN, $x$46 versus $x$47 under PGD, and $x$48 versus $x$49 under MIM (Maouaki et al., 2024). At the same time, RobQuNN found that adversarial examples transferred between classical and quantum models without a clear architecture-dependent asymmetry (Maouaki et al., 2024).

Robustness to non-adversarial corruption is more mixed. In speech applications, quanvolutional front-ends generally outperformed a simple CNN baseline under pitch shift, temporal shift, and speed variation, with up to $x$50 lower CE/RCE at severe temporal shift, but the CNN baseline remained more resilient to Gaussian noise (Tran et al., 5 Jan 2026). Among the quantum circuits studied, QNN-Basic gave the best overall robustness on AVFAD, whereas QNN-Random was strongest on TESS; the quantum models also converged up to six times faster than the CNN-Base (Tran et al., 5 Jan 2026). This suggests that quanvolution may confer robustness to structured spectral or temporal perturbations without guaranteeing resistance to additive noise.

Several limitations recur across the literature. Data encoding is often the dominant bottleneck: amplitude encoding of large images is explicitly identified as costly (Qu et al., 11 Apr 2025), and rotational encoding ties qubit count to patch size while incurring $x$51 two-qubit-gate growth (Bosco et al., 2024). Simulator-based workloads can also be prohibitive; the industrial crack-detection study notes that each forward pass required thousands of quantum circuit evaluations on classical hardware (Reese et al., 2022). Many application papers remain purely simulated and do not include real-device noise (Reese et al., 2022, Tran et al., 13 Feb 2025), and integrated encoding beyond $x$52 or large-kernel rotational baselines were left untested because of simulator limits (Bosco et al., 2024).

A further unresolved issue is interpretive rather than purely technical. Quanvolutional gains do not automatically imply a uniquely quantum benefit. The original MNIST study showed that a random classical nonlinearity matched the reported gains of the quantum layer within experimental noise (Henderson et al., 2019). Conversely, later small-data and robustness studies report sizable empirical advantages for quantum front-ends (Reese et al., 2022, Maouaki et al., 2024, Tran et al., 13 Feb 2025). This suggests that the utility of quanvolution is strongly task-, encoding-, and circuit-dependent.

Open design directions already identified within the cited work include adaptive gate positioning for multiscale context (Qu et al., 11 Apr 2025), parameter-shift-based learning of integrated encoding maps (Bosco et al., 2024), variational quanvolutional kernels beyond fixed random circuits (Reese et al., 2022), and deeper residualized quanvolutional stacks that preserve gradient access across multiple quantum layers (Kashif et al., 2024). A plausible implication is that future progress will depend less on the generic idea of “adding a quantum layer” and more on matching encoding, circuit topology, measurement strategy, and optimization method to the inductive biases of the target domain.