Improvement of Quantum Feature Extraction Using Quantum Attention for Efficient Image Classification

Convolutional Neural Networks (CNNs) learn local spatial patterns by applying shared filters across an image. Deeper CNNs can learn more complex features. However, they usually require more computation, parameters, and training time [1, 2]. Because the quality of feature extraction strongly affects computer-vision performance [3-11], hybrid quantum-classical alternatives have been investigated for classification, recognition, segmentation, and object tracking [12-15].

Quantum Feature Extraction (QFE) replaces a classical convolutional layer with a parameterized quantum circuit (PQC) whose trainable parameters are shared across image patches [16]. The original QFE design used a Quantum Approximate Optimization Algorithm (QAOA)-inspired circuit and described training through the Parameter-Shift Rule (PSR) and Chain Rule (CR) [17-19]. After each patch is processed, QFE projects and pools the resulting observables to obtain a compact feature vector. However, this aggregation does not explicitly assign larger input-dependent weights to the patches that are more informative for a particular image. Repeated experiments are also needed because early QFE validation used relatively simple settings [20].

Attention provides a way to assign different weights to different feature locations, so the model can emphasize information that is more useful for a given input [21-24]. Existing quantum-attention studies have implemented this idea through Query-Key-Value (QKV) representations, pairwise similarity scores, attention-matrix encoding, qubit-measurement weighting, quantum convolution, or variational quantum circuits [25-32]. These methods demonstrate several ways to combine quantum circuits and attention, but many of them require pairwise comparisons, classical convolutional backbones, or image-wide encoding. Their structures therefore cannot be inserted directly into the patch-wise QFE pipeline without substantial modification.

To address this gap, this study proposed Quantum Feature Extraction-Quantum Attention (QFE-QA). The method added an ancilla-based branch that converted each QFE1 patch-observable vector into one scalar relevance score. Nine controlled-RZ (CRZ) angles were shared across all patches, and one ancilla qubit provided the score used by softmax. This design avoided a full QKV module and was evaluated on controlled subsets containing all ten classes of MNIST and Fashion-MNIST (FMNIST).

In this study, efficiency was assessed only through the number of trainable parameters. The reported fully connected (FC)-only time measured the classifier head. It excluded execution of the QFE and QFE-QA circuits. It therefore cannot be interpreted as end-to-end speedup, computational efficiency, or quantum advantage.

This study makes two main contributions. First, it introduces a QFE-specific, phase-sensitive ancilla-based attention branch. This branch maps each QFE1 patch-observable vector to a scalar score using nine shared CRZ angles and one ancilla qubit. Second, it integrates the Softmax-weighted QFE1 representation with QFE2 while preserving an 18-dimensional classifier input and avoiding QKV representations and pairwise patch-similarity matrices.

The remainder of this paper is organized into four sections. Section 2 reviews related work, and Section 3 explains the proposed method. Section 4 presents the experimental results and discussion, while Section 5 summarizes the conclusions and future work.

$Z=\left[Z^{(1)}, Z^{(2)}, \ldots, Z^{(P)}\right] \in \mathbb{R}^{P \times n_q}$              (13)

The attention branch received each QFE1 vector $z^{(i)}$ and produced one scalar score $a^{(i)}$, as defined in Eq. (14). A larger score did not have a fixed meaning before training. Instead, the classification loss learned which score patterns were useful. The same parameter vector $\alpha$ was reused for every patch, so the number of attention parameters did not grow with the number of patches.

Eq. (15) applies softmax across the $P$ patch scores. Softmax converts the scores into positive weights $w^{(i)}$ that sum to one, which makes the weights comparable across patches. Eq. (16) then computes $z_{\text {attn }}$ as the weighted sum of the QFE1 vectors, producing one nine-dimensional representation for the complete image.

$a^{(i)}=f_{\text {attn }}\left(z^{(i)} ; \alpha\right) \in \mathbb{R}$            (14)

$w^{(i)}=\frac{\exp \left(a^{(i)}\right)}{\sum_{i=1}^P \exp \left(a^{(j)}\right)}($ Softmax $)$            (15)

$z_{\text {attn }}=\sum_{i=1}^P w^{(i)} z^{(i)} \in \mathbb{R}^{n_q}$            (16)

The main QFE path processed the same QFE1 outputs independently of the attention branch. The matrix $Z$ was first flattened and projected by $W_{p 1}$. It was then reduced by onedimensional max pooling, as shown in Eqs. (17) and (18). This step compressed the features from all patches into the ninedimensional vector $z_{\text {pool } 1}$.

$z_{\text {pro } j 1}=\pi \tanh \left(W_{p 1} z_{\text {flat}}+b_{p 1}\right) \in \mathbb{R}^{d_1}$            (17)

$z_{\text {pool } 1}=\operatorname{MaxPool1D}\left(z_{\text {pro } j 1}\right) \in \mathbb{R}^{n_q}$          (18)

where, $W_{p 1} \in \mathbb{R}^{d_1 \times\left(P n_q\right)}$ is the QFE1 projection matrix and MaxPool1D is the pooling of the projection channels. Here $W_{p 1}$ is a linear projection matrix that maps the flattened representation of the entire patches, of dimension $P n_q$, to the feature space of dimension $d_1$.

QFE2 received $z_{\text {pool } 1}$ and produced nine Pauli $Z$ expectation values, as defined in Eq. (19). These values were projected and pooled again through Eqs. (20) and (21). The resulting vector $z_{\text {pool } 2}$ had the same dimension as $z_{\text {attn }}$, which allowed the two branches to be combined directly.

$z_{q f e 2}^{\text {raw }}=\left[\left\langle Z_1\right\rangle,\left\langle Z_2\right\rangle, \ldots,\left\langle Z_{n_q}\right\rangle\right]=Q F E 2\left(z_{\text {pool }}\right) \in \mathbb{R}^{n_q}$          (19)

$z_{\text {proj } 2}=\pi \tanh \left(W_{p 2} z_{q f e 2}^{\text {raw }}+b_{p 2}\right) \in \mathbb{R}^{d_2}$            (20)

$z_{\text {pool } 2}=\operatorname{MaxPool1D}\left(z_{\text {pro } j 2}\right) \in \mathbb{R}^{n_q}$              (21)

where, $W_{p 2} \in \mathbb{R}^{d_2 \times n_q}$ is the projection weight of QFE2, and the output $z_{\text {pool } 2} \in \mathbb{R}^{n_q}$ has the same dimensionality as the attention output.

Eq. (22) concatenates $z_{\text {pool } 2}$ and $z_{\text {attn }}$ rather than adding them. Because each vector has nine components, the combined vector $z_{\text {final }}$ has 18 components. The concatenation preserves information from both branches. This vector was passed to the fully connected classifier.

$z_{\text {final }}=\left[z_{\text {pool } 2} \| z_{\text {attn }}\right] \in \mathbb{R}^{2 n_q}$         (22)

with $n_q=9 \rightarrow$ then $z_{\text {final }} \in \mathbb{R}^{18}$, and $\|$ denotes vector concatenation.

The classifier contained hidden layers with 128 and 64 units followed by a ten-class output layer, as defined in Eqs. (23)–(25). ReLU was used in the two hidden layers. The final layer produced logits for the ten classes. Eq. (26) computes cross-entropy directly from the logits and the class-index label y, and softmax was used only to obtain class probabilities for reporting.

$h_1=\operatorname{ReLU}\left(W_{f c 1} \cdot z_{f i n a l}+b_1\right) \in \mathbb{R}^{128}$              (23)

$h_2=\operatorname{ReLU}\left(W_{f c 2} \cdot h_1+b_2\right) \in \mathbb{R}^{64}$              (24)

$\ell=W_{f c 3} \cdot h_2+b_3 \in \mathbb{R}^C$              (25a)

$\hat{y}=\operatorname{Softmax}(\ell)$              (25b)

$L=\operatorname{CrossEntropy}(\ell, y)$              (26)

where, $\hat{y}$ denotes the predicted class-probability vector, $C$ is the number of classes, $b$ is the bias, $y$ denotes the class-index ground-truth labels, $\ell$ denotes logits, and $L$ is the loss computed at each training iteration.

Algorithm 1 summarizes one QFE-QA training iteration.

Eqs. (27) and (28) expand the score function introduced in Eq. (14). For patch i, the QA circuit started from the all-zero state  of the nine feature qubits and one ancilla qubit. The feature register encoded $z^{(i)}$, and a Hadamard gate prepared the ancilla. The nine feature qubits then controlled CRZ rotations on that ancilla.

$\begin{gathered}a^{(i)}=f_{a t t n}\left(z^{(i)} ; \alpha\right)=\left\langle Z_a\right\rangle_i=\operatorname{Tr}\left[\left(I_F \otimes Z_a\right) U_{Q A}\left(z^{(i)}, \alpha\right) \rho_0 U_{Q A}^{\dagger}\left(z^{(i)}, \alpha\right)\right] =P_a^{(i)}(0)-P_a^{(i)}(1) \in[-1,1]\end{gathered}$              (27)

$\begin{gathered}U_{Q A}=\left(I_F \otimes H_a\right)  \left(I_F \otimes R_{Z a}(\delta)\right) U_{i n t}(\alpha)\left[U_{e n c}\left(z^{(i)}\right) \otimes H_a\right], U_{i n t}(\alpha)=\prod_{k=1}^{n_q} C R Z_{k \rightarrow a}\left(\alpha_k\right), \delta=\frac{\pi}{2}\end{gathered}$              (28)

where, $I_F$ is the identity on the feature register, $U_{\text {enc }}\left(z^{(i)}\right)=$ $\otimes_{k=1}^{n_q} R_{Y_k}\left(\phi_k^{(i)}\right)$, with $\phi_k^{(i)}=\frac{\pi}{2}\left(z_k^{(i)}+1\right)$, and $\rho_0=$ $|0\rangle\left.\langle\left. 0\right|^{\otimes\left(n_q+1\right)}\right.$ is the all-zero initial state of the nine feature qubits and one ancilla qubit.

Each QFE1 value $z_k^{(i)}$ lies in $[-1,1]$ and was mapped monotonically to $\phi_k^{(i)}=\pi\left(z_k^{(i)}+1\right) / 2$. This mapping preserved the input order and set the population of feature qubit $k$. The shared angle $\alpha_k$ then controlled how strongly that qubit influenced the ancilla phase.

The fixed $R_Z(\pi / 2)$ rotation changed the ancilla readout from a cosine-sensitive to a sine-sensitive response. Near the zero initialization of $\alpha$, it provided the nonzero first-order response $a^{(i)} \approx-\Sigma_k p_k^{(i)} \alpha_k$. The final Hadamard converted the accumulated phase into the Pauli Z difference $P_a^{(i)}(0)-$ $P_a^{(i)}(1)$, which formed the scalar patch score.

Eqs. (29) and (30) convert the $P$ patch scores into normalized weights and form the weighted representation $z_{attn}$. Index $i$ denotes the weighted patch, $j$ is the dummy index in the softmax denominator, and $k$ indexes the $n_q=9$ feature qubits. The score was not assumed to represent semantic importance before training; its useful interpretation was learned through the classification loss.

$w^{(i)}=\frac{\exp \left(a^{(i)}\right)}{\sum_{j=1}^P \exp \left(a^{(j)}\right)}, i=1, \ldots, P$               (29)

$z_{a t t n}=\sum_{i=1}^P w^{(i)} z^{(i)} \in \mathbb{R}^{n_q}$             (30)

where, $\alpha=\left(\alpha_1, \alpha_2, \ldots, \alpha_{n_q}\right)^{\dagger}$ contains one trainable CRZ angle per feature qubit, while $a^{(i)}, w^{(i)}$, and $z_{\text {attn }}$ denote the score of patch $i$, its normalized weight, and the weighted aggregation, respectively.

This study evaluated QFE-QA, which integrated a phase-sensitive ancilla-based attention branch with QFE. The method produced numerically higher mean test accuracy than QFE on both evaluated datasets, but the differences were not statistically significant. The controlled grayscale subsets and noiseless statevector simulator demonstrated feasibility only within the tested setting and did not establish scalability, end-to-end efficiency, generalizability, or quantum advantage. Future work should evaluate larger RGB datasets, higher resolutions, noisy and transpiled circuits, real quantum hardware, parameter-matched lightweight CNNs, attention maps, latent representations, and component-level ablations.