Seeing Why: Exact Evidence Maps for Quantum and Optical Image Classifiers

Introduction

Explanations of image classifiers are usually approximations. Gradients, class activation maps [1] and their variants estimate which pixels mattered, but their maps need not add up to the decision they explain. Methods whose maps do add up, such as Integrated Gradients [2] and Shapley values [3], must in general be estimated numerically, by a path integral or by a sum over feature coalitions.

Teerawat Tongloy: [email protected]

Rangsan Jomtarak: [email protected], corresponding author Quantum and optical classifiers inherit the problem. Quantum classifiers range from convolution-like circuits, introduced for quantum data [4], through amplitude-encoded classifiers [5], to hybrids that place a pretrained classical network in front of the circuit [6]; in a hybrid, an attribution concerns mainly the classical network. Hardware demonstrations, aimed at other questions, have typically used a few input features (e.g. [7]). Interpretability methods proposed for quantum classifiers include gradient-based saliency through a hybrid network [8], Integrated Gradients and Shapley values of the input pixels, measured on a superconducting chip for $2 \times2$ pictures [9], Integrated Gradients for amplitude-encoded models [10], parameter-shift saliency on tiny inputs [11], and Shapley values over gates [12]. Optical diffractive networks [13] classify pictures with light alone, in simulation and in fabricated devices; attributions for their classifications have so far been gradient-based, computed by back-propagation through the simulated propagation [14]. That map, the overlap of the forward field with the back-propagated detector field, is close in form to ours. Ours adds up exactly to each class’s probability above its share, can be measured from camera intensities alone, and is tested on colour photographs; that work notes that the dark backgrounds of its pictures may favour the foreground. Separately, the layers of trained diffractive networks have been interpreted as the physical transforms they perform [15].

A classifier that is linear in its input amplitudes up to the final measurement, with no classical network before or after it, does not need approximate explanations: the contribution of every input amplitude to every class’s measured probability can be written down in closed form. We build such classifiers for two kinds of hardware, show that this decomposition is exact, check its ranking of pixels in a deletion test, and measure it on hardware ($2 \times2$ blocks on a quantum chip, per pixel on a simulated lens bench). Our contributions:

1. Born evidence maps (BEM, § 2.5): an exact additive decomposition of each class’s probability above its share over the encoded amplitudes, shown as spatial maps and, on hardware, estimated from finite measurements. The split itself is not new mathematics: for the quadratic numerator of each class’s probability, with the light that arrives held fixed, it is what Integrated Gradients from a zero baseline and the Shapley value give, by known results on polynomials [18, 19], and the models of [10] start from the same form. What we add is the target, $p_g-p_{\neg g}$, of a Born-rule classifier, to which the maps sum exactly, and a measurement of the maps from class probabilities or camera frames, without gradient circuits [9, 10] (next item). In a deletion test the maps rank pixels about as well as occlusion (seed 0, 300 pictures), at the cost of one forward and one adjoint pass, while plain gradients remove much less accuracy (§ 3.4).

2. Maps measured on hardware (§ 2.6). On IBM’s ibm_kingston, with the mask computed before loading, $2 \times2$ maps of ten test pictures, one per class chosen by a stated rule among those the chip classified correctly (with probability at least 0.6 for nine of them), correlate with the exact maps at 0.77 (§ 3.7); on a simulated lens bench, per-pixel maps follow from camera intensities alone (§ 3.8).

3. The mean plane (§ 2.1): an amplitude encoding that gives dark features the same weight as bright ones. It is the largest gain among the parts before the readout and moves the explanations onto the object, measured against human-drawn outlines (§ 3.5).

4. One architecture for qubits and lenses (§ 2.2–§ 2.3): a Fourier-plane mask (a quantum Fourier transform on a chip, a 4f system on a bench) followed by a brick-

wall circuit or by phase plates, trained on five datasets from handwritten digits to colour photographs (§ 3.3). The phase plates were checked end to end in an independent optics simulator, and we report the tolerances a bench must meet (§ 3.9).

5. Born headroom (§ 2.4): a readout with no trained parameter that scores each class by how far its measured probability rises above its no-information share. On the optical model it reaches 72.3 %, against 48.6 % for the plain sums of the same outcomes and 73.8 % for a softmax with a learned temperature: BHR comes close to a learned temperature without training one, and is not more accurate (§ 3.2).

6. Explanations in use (§ 3.6): the maps exposed a shortcut, a dark frame on one class’s pictures; we removed it and confirmed the removal with the same maps.

In short, this is an optical image classifier whose class probabilities decompose exactly into contributions of the encoded amplitudes (designed and checked in simulation), and a quantum classifier with no trained classical network whose $2 \times2$ explanations were measured on a quantum computer. On hardware, two steps run classically before the chip: the Fourier-plane mask, which a bench does with lenses, and the fitting of a short circuit that loads each picture (§ 3.7).

Method

Figure 1 shows the pipeline. We describe its parts in the order the light passes through them: the encoding, the Fourier-plane mask, the trained circuit or plates, and the readout. The evidence maps then follow from linearity, and we close with how they are measured on hardware.

Encoding that respects the dark: the mean plane

Amplitude encoding of raw intensities is positive everywhere. The light then follows the bright parts of a picture: a bright sky outweighs a dark hull, and dark features carry little signal however informative they are. We remove each picture’s own mean from each colour plane. A dark detail then becomes a large negative amplitude, with the same energy as an equally strong bright one. The three means move to the encoding’s otherwise empty fourth plane, the means plane: a $2 \times2$ tile repeated over the grid holds the red, green and blue means and one dark cell, scaled so that this plane carries the fraction $f = 0.5$ of the picture’s energy. With $c$ the three colour planes of the picture, each with its own mean $\mu_R$, $\mu_G$ or $\mu_B$ removed, and $m$ the means plane (the tile $\mu_R,\mu_G,\mu_B,0$ repeated), the encoded amplitudes are

in the qubit or field order of § 2.3. Only the ratios of the three means and their common sign survive this scaling, not their overall level. A picture of one flat colour has $c = 0$ and is not encoded; none occurs in the data. The colour planes thus keep no mean (DC) at all, yet the circuit still receives the colour balance and a phase reference; without that reference the sign of a deviation would be lost, since $P(\psi) = P(-\psi)$. Optically, the means plane is the zero frequency, carried as a separate reference tile; like the other planes, it passes the Fourier-plane mask with its own gain. In our setting the picture reaches the bench as a digital image, so the three means are computed while the modulator is written. The centred planes are signed, so the picture modulator writes an amplitude together with a phase of 0 or $\pi$; such complex modulation is established, for example by pairing pixels on a single liquid-crystal modulator [16] or by cascading two modulators. Only a sign is needed, which is simpler than full complex modulation; a double-pixel scheme pays for it with at least two modulator pixels per picture pixel and a spatial filter, which the 4f system’s Fourier plane can provide. An optical front end could instead separate each colour’s zero frequency in a Fourier plane and expand it into the reference tile; reproducing Eq. (1) would additionally need an input-dependent balance of the contrast and reference energies, which our implementation computes digitally before the modulator is written. Grey pictures (one plane on eleven qubits) carry their single mean evenly over the second plane, their means plane, which is then a constant reference and holds no brightness. No dataset statistic is used: every picture is centred on its own mean.

Fourier-plane mask

Before the main circuit, each colour plane passes a learned filter in its spatial-frequency plane: the plane is taken to its two-dimensional Fourier transform, multiplied by a learned complex mask $d(k)$ (one mask shared by the planes, with a learned gain per plane), and brought back. On a lens bench each plane passes its own 4f system, a $2 \times2$ array of lens pairs with a spatial light modulator in their shared focal plane, so that the planes filtered light does not mix; on qubits it is a quantum Fourier transform on the row qubits and one on the column qubits, with the mask applied by post-selected ancillas. The mask’s amplitude is even in $k$ and its phase odd, so the filter is a convolution with a real kernel; it is shift-equivariant and favours no place in the picture. The qubit version, the circular mask, convolves circularly. The lens version, the lens mask, zero-pads the picture to twice its size and keeps the original frame, so that light leaving the frame is lost, as on a bench. Being lossy, the mask makes all probabilities conditional (§ 2.5); its transmission is reported in Table 1. The mask has an amplitude and a phase, so its modulator, like the picture’s, needs complex modulation, for example amplitude encoded onto a phase-only modulator [17].

row	model	params	accuracy (%)	ROC-AUC	transm.
A	phase plates, plain amplitudes	4,096	61.4 ± 0.8	0.892 ± 0.005	0.419
B	+ mean plane	4,096	68.2 ± 2.2	0.939 ± 0.005	0.405
C	+ lens mask	4,614	68.9 ± 1.1	0.940 ± 0.008	0.044
D	+ phase in the mask	5,124	72.3 ± 0.7	0.947 ± 0.008	0.042
E	D, pixel-aware plates	5,124	71.6 ± 1.7	0.947 ± 0.010	0.020
F	E + light-keeping loss	5,124	67.1 ± 3.0	0.933 ± 0.011	0.038
A′	qubit brickwall $L = 11$, plain	432	52.1 ± 0.8	0.850 ± 0.008	1
D′	qubit $L = 11$ + mask, phase, mean plane	1,460	54.9 ± 1.5	0.864 ± 0.009	0.197
Q	free complex map, no physics (baseline)	1,048,576	75.7 ± 1.8	0.961 ± 0.004	–

Main circuits: qubit brickwall and phase plates

Qubits. A $32 \times32$ colour picture with its means plane fills $2^{12}$ amplitudes on twelve qubits, ordered by plane (the two leading address bits) and within a plane along a Morton (Z-order) curve: the remaining ten bits interleave row and column bits from the most significant down, which organises the pixels into nested, spatially coherent blocks. This orders the basis-state addresses; it does not make gates on neighbouring wires act on neighbouring pixels. The trained circuit is a brickwall of depth $L$: $L+1$ layers of single-qubit rotations $R_XR_YR_Z$ on every qubit, with nearest-neighbour CNOTs on alternating pairs between layers. The first seven qubits are measured; their $2^7=128$ outcomes form the BHR groups. Depth 11 has 432 parameters (1,460 with the mask).

Phase plates. For an all-optical classifier the brickwall is replaced by $L$ phase plates. The four planes are tiled $2 \times2$ on one field of $64 \times64$ pixels. Between plates of $32 \times32$ phase pixels, light propagates by Fresnel diffraction, with transfer function $\exp[-i\pi z(u^2+v^2)]$ on a grid padded twice; $z=\lambda d/\Delta x^2=32$ corresponds to 3.2 mm at 633 nm with 8 μm pixels. A camera at the end is cut into $16 \times8=128$ regions, the BHR outcomes. Everything is linear in the field, so the evidence maps carry over unchanged: $A^\dagger$ is the phase-conjugated return path. The plain model samples each pixel at one point; a pixel-aware variant models every picture and plate pixel as a square, sampled $2 \times2$ times, so that training sees the diffraction of the pixels themselves. Four plates with the mask have 5,124 parameters.

Born headroom readout

A classifier ends in a measurement with $N$ outcomes and Born probabilities $P_b$, $b=1,\ldots,N$: on a qubit chip the $2^{n_{\mathrm{out}}}$ bit strings of its $n_{\mathrm{out}}$ measured qubits, on a lens bench the light falling on $N$ camera regions. The outcomes are split into $G$ contiguous groups $S_g$, one per class, and the class mass is $P_g=\sum_{b\in S_g}P_b$. A maximally mixed input, which carries no information about the picture, gives class $g$ the mass $P_g=b_g=|S_g|/N$ under any unitary circuit. We call $b_g$ the class’s no-information share; where losses or non-unitary noise move the mixed state’s group masses, we keep $b_g$ as a fixed anchor. The Born headroom of class $g$ is how far its measured probability rises above that share, in units of the room above it:

Every class has the same ceiling $u_g=1$, whatever the size of its group. The Born headroom readout (BHR) turns the headrooms into class probabilities with no trained parameter,

Here $\alpha$ is the LeakyReLU’s slope below zero, and $\varepsilon= \alpha= 0.01$ are fixed. The one free choice is $\varphi\in(0,1)$, which sets $\kappa$ through a reference configuration of the headrooms: one equal to $\varphi$ and all others zero, at which the softmax calls that class with probability $1-\varepsilon$. This reference fixes the softmax’s scale; it is not a jointly attainable set of class masses, since the anchors already sum to one. In every run we use $\varphi= 0.0556 = (1.5-1)/(G-1)$, for equal groups the headroom of a class that holds 1.5 times its share (our 128 outcomes form ten groups of 12 or 13, nearly equal); it was fixed before the experiments reported here and not tuned per dataset. Training minimises the cross-entropy of $\hat{p}$. All trainable parameters belong to the quantum or optical transformation: on qubits the mask and the circuit’s angles, on a bench the mask and the plates’ phases. The readout contains no trainable parameter; it is a fixed rule, through which the gradient still reaches those parameters, and the classical optimiser that updates them is no layer on the path from the picture to the answer. Because this scale is set by a headroom the circuit can reach rather than by a probability of one, the cross-entropy’s gradient becomes small once the true class leads the competing classes by a sufficient headroom.

Born evidence maps

Let the input be an amplitude-encoded picture $a$ (real, $\lVert a\rVert= 1$). A linear map $A$ takes it to the measurement plane: a unitary circuit, or a mask followed by a circuit or by free-space propagation. $\Pi_g$ projects onto the outcomes of class $g$. A lossy element such as a mask or an aperture makes the measured probabilities conditional on the light that arrives, $P_g = \langle a|A^\dagger\Pi_gA|a\rangle/Z$ with $Z = \langle a|A^\dagger A|a\rangle$. Writing $M_g = A^\dagger(\Pi_g-b_g)A$, the evidence of amplitude $x$ (one pixel of one plane) for class $g$, displayed as a Born evidence map (BEM), is

The sum is exact, not an approximation: the evidence of the amplitudes adds up to the class’s probability above its share. Exact means three things in this paper: the decomposition is an algebraic identity of the model; our simulator computes it to numerical precision; on hardware it is estimated from a finite number of shots or camera frames, with the errors reported there. An exact sum does not make this the only possible decomposition, nor a proof of cause in the scene: it is the one that Integrated Gradients and the Shapley value give for this form, and the deletion tests (§ 3.4) are a separate check of what it ranks. Positive evidence pushes the class above its share; negative evidence pulls it below. The decomposition is exact for the encoded amplitudes. The encoding subtracts each picture’s channel means, fills the means plane and normalises the result (§ 2.1), so a change of one raw pixel moves the encoded amplitudes all over the picture; the maps are therefore not attributions to raw pixels through the encoder. A pixel map, as shown in our figures, sums the encoded evidence of the three colour planes of each pixel, a spatial evidence map. The means plane belongs to no pixel, so its evidence is left out and a pixel map adds up to $P_g-b_g$ minus that plane’s part; the hardware blocks of § 2.6 include all four planes. The maps are additive over any set of pixels, so block maps are sums of the pixel map.

Two further maps come from the same quantities: the attention $a(x)\operatorname{Re}[A^\dagger A](x)/Z$, each pixel’s share of the light that reaches the measurement plane, and the input intensity $a(x)^2$ itself. The attention adds up to one but is signed: where interference removes light, a pixel’s share is negative. In our models its negative part is small (on average 2–4% of $\sum_x |t(x)|$, at most 10%), and the figures show it on a scale on which negative values are darkest. All three need one forward and one adjoint pass, which a simulator computes exactly and which hardware can measure (§ 2.6). Because the numerator $\langle a|M_g|a\rangle$ is a quadratic form, the evidence coincides with Integrated Gradients from a zero baseline [2] of $f(v)=v^\top M_gv/Z(a)$, the numerator with the denominator held at its value for the picture explained: the gradient along the path $ta$ is $2t\operatorname{Re}[M_ga]/Z(a)$, and its integral gives Eq. (4). It also coincides with the Shapley value of the game on $f$ that switches amplitudes off and splits each pair term $a(x)[M_g]_{xy}a(y)$ equally between $x$ and $y$. Both follow from known results on polynomials: from a zero baseline, Integrated Gradients share a monomial among its variables in proportion to their exponents and the Shapley value shares it equally [18, 19]; for a quadratic form the two coincide. What this model class adds is the form itself, $P_g-b_g$ of a Born-rule measurement, whose decomposition sums exactly to the class’s probability above its share. Neither statement holds for $P_g$ itself as a function of the input, which does not change when the input is scaled, so that a path from zero tells nothing about it; nor do the maps attribute the readout’s output $\hat p$, which follows through a LeakyReLU and a softmax. They decompose $P_g-b_g$ of the picture explained. Wherever this paper says that the maps add up to a class’s probability, it means this measured class mass $P_g$, never the readout’s $\hat p_g$. The models of [10] start from the same quadratic form, $\langle x|U^\dagger O U|x\rangle$, but read it through a tanh and encode the pixels with an extra overflow amplitude; their Integrated Gradients, from a blank picture, are computed numerically from gradients measured with a Hadamard test. Here the attribution targets the quadratic numerator with the transmission held fixed, the decomposition is closed-form, and it is measured from class probabilities alone (§ 2.6).

Measuring the maps on hardware

On a qubit chip, the evidence of a block $S$ of pixels follows from three class probabilities by the standard polarization identity of a quadratic form, $2\operatorname{Re}\langle u|M|v\rangle=\langle u+v|M|u+v\rangle-\langle u|M|u\rangle-\langle v|M|v\rangle$, applied to $u=\psi_S$, $v=\psi_{\bar S}$:

where $\psi$ is the chip’s (normalised) input, $\psi_S$ its part inside the block and $\psi_{\bar S}$ the rest, and $M_g$ is now the circuit’s own operator. Estimating such cross terms from the probabilities of superposed states, without a Hadamard test, is known in quantum algorithms [20]; here it is applied block by block to explain a classifier. Each term $\langle v|M_g|v\rangle=\|v\|^2(P_g(v)-b_g)$ is a measured class probability of a prepared state. In our hardware runs $\psi$ is the masked picture, so these maps attribute to blocks of the filtered input. A $g\times g$ map needs $1+2g^2$ circuits; the identity is exact, and the measured blocks add up to $P_g-b_g$ in expectation. On a lens bench the same identity needs only camera intensities: the input modulator shows, in turn, the whole picture, only its part inside the block and only its part outside it (the same pixels in all four titles), and each time the camera records the light $I_r$ on every detector region $r$. With weights $W_r=1-b_g$ on the class’s regions and $-b_g$ elsewhere, $\langle v|M|v\rangle=\sum_r W_r I_r(v)$ for any input $v$, so

No phase is measured and no light is sent backwards. A per-pixel map (32 × 32 blocks) takes 2,049 camera frames, about 20 seconds at 100 frames per second.

Results

We first describe the data (§ 3.1), then what each part adds (§ 3.2) and how the model fares on five datasets (§ 3.3). We then test the maps: whether they point at what the model uses (§ 3.4), whether they sit on the object (§ 3.5), and whether they find a flaw in the data (§ 3.6). Finally we measure them on a quantum computer and on a simulated lens bench (§ 3.7–§ 3.8) and give the tolerances a bench must meet (§ 3.9).

Data and protocol

The main set is Caltech-101 [21] (CC BY 4.0), its ten largest object classes (airplane, motorbike, face, watch, leopard, bonsai, car side, ketch, chandelier, hawksbill), called Caltech-10 below: all their pictures, 2,644 for training, 100 held out for validation and 300 for testing (30 per class), with class-balanced batches. Each picture loses 4 % of every side before a square centre crop to $32 \times32$ colour pixels. The trim removes a black frame that one class carried, a shortcut the maps themselves revealed (§ 3.6); the crops without it are the untrimmed set. The trim was chosen after the shortcut was seen in maps of test pictures, so every result on the trimmed Caltech-10 below is exploratory (§ 5). Training uses random square crops of side $U(0.8, 1)$ of the raw picture, resized back, so no artificial edge is created. Every pixel and colour of the $32 \times32$ picture enters the model as an amplitude: there is no PCA, pooling or feature extraction, learned or hand-made. For CIFAR-10 this is the dataset’s full resolution and for MNIST and Fashion-MNIST the full $28 \times28$ picture, padded to $32 \times32$; the Caltech-101 originals are larger and are reduced to $32 \times32$ by the crop above.

On Caltech-10 we train for 50 epochs with three seeds and report mean $\pm$ standard deviation. With 300 test pictures, one point of accuracy is three pictures and a single run’s 95 % interval is about $\pm5.5$ points, so we report ROC-AUC (macro, one-vs-rest) beside every accuracy. The standard sets are MNIST and Fashion-MNIST (grey, 58k training, 2k validation, full test sets) and CIFAR-10 in grey and in colour (48k / 2k), 20 epochs. All runs use BHR with $\varphi= 0.0556$ and the cross-entropy of $\hat{p}$, Adam [22] with learning rate 0.01, batches of 64, and a one-epoch linear warm-up followed by a cosine decay to zero. Rotation angles start from $\mathcal{N}(0, 0.1^{2})$ and plate phases from $\mathcal{N}(0, 1)$. The mask’s amplitude, $\cos\theta_{\mathrm{plane}}\cos\theta_k$, starts at about one half, with both angles at $\pi/4$ plus the same noise; its phases start near zero. The weights of the epoch with the best validation accuracy are kept and evaluated once on the test set.

Our simulator computes states, probabilities and gradients in PyTorch [23] and agrees with PennyLane [24] (to $10^{-10}$) and with Qiskit’s [25] statevector (to $10^{-16}$); the phase-plate propagation agrees with LightPipes [26] Fresnel propagator to $2 \times10^{-10}$. Figure 2 shows how hard the four sets are for a classifier of the raw amplitude states: MNIST separates almost by itself, CIFAR-10 hardly at all. In the charts, orange marks our main model or result and blue or grey what it is compared with; in the maps, red and blue mean evidence for and against a class.

What each part adds

Table 1 adds one part at a time. The mean plane is the largest step: +6.8 points and ROC-AUC 0.892 → 0.939, well outside the spread of the three seeds, with the same parameters and the same transmission. A lens mask with amplitude only adds nothing beyond noise and cuts the transmission tenfold; giving the mask a phase is the second clear step (+3.4 points, again outside the seed spread, with the smallest spread between seeds). We call the mask with its phase plus the mean plane the full front end. Pixel-aware plates keep the accuracy (71.6 ± 1.7 %) while making a simulated physical bench give the same answers (LightPipes, ten pictures; § 3.8); a loss term that rewards keeping light doubles the transmission at a cost of 4.5 points (row F).

The readout matters more than any part before it, and what matters in it is its slope (its temperature). We trained row D with each readout and its own loss, three seeds each. The plain group sums of the same outcomes (raw sums) give 48.6 ± 2.5 % (ROC-AUC 0.859 ± 0.012). A softmax of the group sums with one learned temperature (temperature scaling [28]) gives 73.8±1.0 % (0.959±0.004); its temperature settles at a slope of about 380 per unit of probability. BHR gives 72.3±0.7 % (0.947±0.008) with no trained parameter; its slope, $\kappa/(1-b_g) \approx136$, follows from $\varphi$. At test time the three readouts rank the classes almost alike (they differ only through the small differences in group size), so the slope acts during training, where it sets how hard the loss pushes the true class ahead; slopes of 136 and about 380 both train well, the raw sums’ slope of one does not. BHR’s gain over the raw sums is therefore the slope it fixes in closed form, in units of headroom, not an accuracy advantage over a learned temperature (Figure 3).

On the same data the plates exceed the qubit brickwall by 9 points with plain amplitudes (A against A′) and by 17 points with the full front end (D against D′). Part of the second gap is the mask: D′ uses the circular mask and D the lens mask, and a single-seed qubit run with the lens mask reached 63.7%. The plates also have 3.5–9.5 times the parameters, but parameters alone do not explain the gap (Table 2, Figure 4): four plates of 16 × 16 pixels, with a few hundred parameters more than D′, are 8 points better. Depth pays more than pixels: four plates of 32 × 32 do better than two of 64 × 64 with fewer parameters. Two classical references place these numbers: the plates sit between a linear classifier of the pixels and a small convolutional network trained with the same random crops.

model (Caltech-10)	parameters	accuracy (%)
qubit brickwall $L = 11$ + mask, phase, mean plane (D′)	1,460	54.9 ± 1.5
two phase plates of 16 × 16	1,540	46.7
four phase plates of 16 × 16	2,052	63.3
two phase plates of 32 × 32	3,076	59.7
four phase plates of 32 × 32 (row D)	5,124	72.3 ± 0.7
two phase plates of 64 × 64	9,220	70.7
four phase plates of 64 × 64	17,412	75.7
logistic regression on the raw pixels	30,730	59.7
small convolutional network, same random crops	25,578	85.4 ± 0.4
free complex map, no physics (row Q)	1,048,576	75.7 ± 1.8

Five datasets

Table 3 gathers the full optical model on all five datasets, from handwritten digits to colour photographs. The mean plane helps colour CIFAR-10 (+1.4 points, outside the spread of the three seeds) and is neutral on the grey sets (perhaps because a single grey mean carries little). For context only, since architectures, losses and encodings differ: simulated diffractive networks report 91.75 % on MNIST [13] and 97.18 % with an improved training [29], 45.20 % on grey CIFAR-10 with $2 \times10^{5}$ neurons (48.51 % with differential detection) [30], 62.13 % on grey CIFAR-10 with an ensemble of thirty networks [31], and 38.6 % on colour CIFAR-10 with three wavelengths [32] in a magneto-optical network [33].

dataset	pictures	train / test	plain amplitudes accuracy (%)	plain amplitudes ROC-AUC	mean plane accuracy (%)	mean plane ROC-AUC
MNIST	grey 28 × 28	58k / 10k	96.8 ± 0.2	0.999 ± 0.000	96.8 ± 0.1	0.999 ± 0.000
Fashion-MNIST	grey 28 × 28	58k / 10k	86.8 ± 0.3	0.988 ± 0.000	86.7 ± 0.3	0.988 ± 0.000
CIFAR-10	grey 32 × 32	48k / 10k	37.1 ± 0.7	0.795 ± 0.003	37.6 ± 1.2	0.796 ± 0.007
CIFAR-10	colour 32 × 32	48k / 10k	46.5 ± 0.1	0.853 ± 0.001	47.9 ± 0.2	0.861 ± 0.001
Caltech-10	colour 32 × 32	2,644 / 300	61.4 ± 0.8†	0.892 ± 0.005†	72.3 ± 0.7	0.947 ± 0.008

Figure 5 shows the evidence of the full optical model on each set. On MNIST the digits stand on a black background and the evidence follows their strokes; on Fashion-MNIST the pixel maps are noisier, and on CIFAR-10 and Caltech-10, where the background carries light too, part of the evidence falls on it. The per-pixel maps are speckled, partly because in coherent propagation neighbouring pixels can contribute with opposite signs.

The maps point at what the model uses

Before the maps are used to judge the model, their faithfulness should be checked. Deleting pixels in the order of the maps tests this [34]. We set a pixel’s contrast to zero in the three colour planes (it becomes the picture’s own mean colour; the mean plane is left as it was), renormalise and classify again, ranking the pixels by the evidence for the true class, and for comparison, by the usual alternatives (Table 4, Figure 6). Deleting the 5 % of pixels with the highest evidence drops the plates from 73.0 % to 8.7 % and the qubit circuit from 56.3 % to 4.7 %; deleting the most negative raises them to 97.3 % and 94.0 %, and the true class’s headroom follows the same order. The plain gradient and its magnitude remove much less accuracy than the evidence, at small deletions little more than random order.

ranked by deleted:	plates (row D), 73.0 %				qubits (D′), 56.3 %
	2 %	5 %	10 %	20 %	2 %	5 %	10 %	20 %
evidence (ours)	36.3	8.7	1.0	0.3	20.7	4.7	0.0	0.0
occlusion	36.0	9.3	1.7	0.3	21.0	4.3	0.3	0.0
gradient	68.7	65.0	60.0	53.0	55.0	52.3	48.3	45.0
|gradient| (saliency)	67.3	62.0	57.7	41.7	51.7	45.7	44.3	39.7
random	72.2	70.6	68.2	59.2	56.0	55.6	54.1	50.7
evidence, reversed	89.7	97.3	98.7	99.7	77.3	94.0	98.3	100.0

Occlusion, which deletes each pixel alone and measures the drop, matches the evidence; but it needs 1,024 extra runs per picture, where the evidence needs one forward and one adjoint pass. The two agree because deleting pixel $x$ changes the numerator $\langle a | M_g | a \rangle$ by $-2Z e_g(x)$ plus one diagonal term; a gradient lacks the factor of the pixel’s own amplitude.

In this deletion test the maps rank the pixels faithfully; deleted pixels move a picture away from the training data, so the test is a check of the ranking, not a proof. It uses the true label to choose the pixels, so the rise under reversed order shows what the evidence for the true class holds, not a way for the model to correct itself. That the maps add up exactly and that deleting by them changes the answer are separate properties; the first is proved, the second is tested here. Ranking instead by the evidence for the model’s own answer, which needs no label, tells the same (Table 5): a few percent of the pixels change most answers, wrong answers change sooner than right ones, and deleting the most negative evidence for the answer never changes it and widens its lead.

	answers kept (%) after deleting				kept after 2 %		lead
	2 %	5 %	10 %	20 %	right	wrong	before → after 5 %
plates (row D)	39.3	9.3	1.0	0.3	49.8	11.1	+0.016 → −0.018
qubits (D′)	26.0	4.7	0.0	0.0	36.7	12.2	+0.009 → −0.016

The explanations sit on the object

With the deletion test supporting their ranking, the maps can judge the encoding. Caltech-101 provides an outline of the object in every picture, which we carry through the trim and the crop onto the 32 × 32 grid. The outline covers 39 % of a crop on average. Table 6 compares where the maps put their weight. With plain amplitudes the evidence is spread evenly (1.00–1.04 times the outline’s area share, its peak inside the outline in under half of the pictures). With the mean plane it concentrates on the object: 1.32–1.37 times the area share for the plates (peak inside in 68–71 % of the pictures) and 1.26 for the qubit circuit (62 %). Most of the shift comes from the encoding itself: the input intensity already sits

caption: Share of each map inside the Caltech-101 object outline divided by the outline’s area share (1 = spread evenly), and the share of pictures whose strongest pixel lies inside it. Means over three seeds, 300 test pictures.

:::

1.42 times on the object, and the trained circuits keep it there. The sketch in Figure 1 (and in Figure 9) illustrates this: the evidence and the attention are strongest on the dark hull at the waterline, the part that plain amplitudes would barely light.

The maps find and fix a shortcut

The maps can also find a flaw in the data. On the untrimmed crops the maps of a qubit model (depth 11 with the lens mask) showed the leopard’s evidence running along the top edge of the picture. The cause is in the data: leopard pictures carry a dark top row (mean brightness 50 against 88 one row lower, 150 for the other classes). For leopards, a median 0.89 of the net evidence lay in the 2-pixel border ring, which covers 23% of the area. Blanking the ring to each picture’s own mean dropped that model’s leopard accuracy to 10% and its overall accuracy from 62% to 47%. Trimming 4% of every side removed the frame. Retrained on the trimmed set (now also with random crops), the same architecture puts a median 0.17 of the leopards’ evidence on the ring, and the phase plates put 0.15, both below the ring’s area share; the evidence moves onto the body and legs (Figure 7). The maps also explain errors: a yellow biplane with a round marking (not shown) is called a leopard, and its leopard evidence lies on the marking and the dark undercarriage, a spotted yellow-and-black texture.

How the shortcut was found bears on the test set, so we state it. The edge was seen in the maps of test pictures, the statistics above were measured on the test set, and the trim was then set and applied to the same split, which was kept. The test set therefore informed one preprocessing decision. Model selection used only the 100 validation pictures, and $\varphi$ was fixed before these experiments, but no untouched holdout of Caltech-10 remains: the results on the trimmed set carry this caveat.

On a quantum computer

We ran all 300 Caltech-10 test pictures through model $D'$ (seed 0) on IBM’s ibm_kingston (Heron r2), one circuit per picture, 4,000 shots, in ten jobs of thirty pictures (340 quantum seconds). For each picture, the masked state is computed off the chip (on a bench, the 4f system in front of the plates) and loaded by a fitted RY–CNOT circuit of depth 8, with 105 CNOTs and a median state fidelity of 0.77; an exact preparation would need about 3,900 CNOTs. The trained depth-11 brickwall follows without any SWAP. Accuracy falls in steps we can measure separately (Figure 8): from 56.3% exact to 41.3% with the fitted loading and to 37.7% on the chip, 3.8 times chance; ROC-AUC 0.863 → 0.824 → 0.783. Loading the picture costs 15 points; the chip’s noise costs another 4, within the chip’s 95% interval. Every job of the test-set and map runs, with its calibration, the qubits used, the circuits as sent and the raw counts, is kept in a ledger released with the code.

For the evidence maps we chose one picture per class by a stated rule: correctly classified on the chip with probability at least 0.6, and of those the one whose background covers most of the crop and varies most (one class, motorbike, had no such picture and took its most confident correct one). Each $2 \times2$ map takes nine circuits (Eq. (5)); all 90 were run in one job. Table 7 compares the chip’s maps with the exact ones over the 40 blocks; a noisy simulation of the same circuits does somewhat better (Figure 9). The exact maps are those of the ideal masked state, so the chip’s maps also carry the error of the fitted block preparations. Pairing each chip map with another picture’s exact map gives correlations below 0.19 in 95 % of cases, so the agreement is specific to each picture. A first run, which reused each picture’s whole-picture term $\langle\psi\vert M_g \vert\psi\rangle$ from the test-set job an hour earlier, gave 0.626. That term is shared by all four blocks of a map, so its drift

caption: Evidence maps measured on the chip against the exact ones. Brackets: 95 % bootstrap intervals over the ten pictures. The median correlation per picture, over only four blocks each, is 0.92.

:::

shifts the whole map uniformly; this may explain much of the difference, but we did not test it separately.

On a simulated lens bench

We rebuilt the trained pixel-aware model of row E in LightPipes, an independent scalar-optics package: each plane through its own 4f system with the learned mask, the planes tiled, Fresnel propagation through the plates with square pixels, the light summed over the camera regions. The output of each 4f system reaches the first plate as it is, smooth and band-limited, sampled four times per pixel. Table 8 compares the light per detector region with our model on ten test pictures, by its overlap (the normalised inner product of the two vectors of region intensities) and by the prediction. Two of its rows test what both simulators assume: glass plates of real thickness in place of thin phase masks, and LightPipes’ convolution propagator in place of its spectral one. The thin-plate approximation holds at these 16 µm pixels. Under the convolution propagator two answers below 0.36 change; this grid samples the field at $\Delta x = \lambda z/L$, where the two methods are about equally accurate. Both are paraxial; at the system’s numerical aperture of about 0.04 the paraxial phase error, $kz\,\mathrm{NA}^{4}/8 \approx0.01$ rad, is a tenth of the plate phase noise the model tolerates (Table 12).

LightPipes bench (10 test pictures)	overlap (min)	same prediction
row E, 4f output passed on as it is	0.997 (0.996)	10 / 10
row E, 4f output re-made into square pixels	0.998 (0.996)	10 / 10
row E, glass plates ($n = 1.457$) crossed in 32 layers	0.997 (0.994)	10 / 10
row E, convolution propagator instead of the spectral one	0.995 (0.993)	8 / 10
row D, point-sampled plates, 4f output as it is	0.980 (0.971)	7 / 10

flaw	tolerated	breaks
picture modulator levels	3–4 bits	2 bits: 68.7 %
mask modulator levels	5 bits	4 bits: 70.0 %; 2 bits: 58.0 %
plate phase levels	5–6 bits	4 bits: 71.0 %; 2 bits: 44.0 %
plate sideways shift	0.05 plate px (0.8 µm; 72.9 %)	0.1 px: 69.2 %; 0.25 px: 51.2 %; 0.5 px: 24.7 %
plate rotation	0.25° (71.1 %)	0.5°: 66.0 %; 1°: 58.9 %; 2°: 41.9 %
mask off-centre	0.25 mask px (2 µm; 71.7 %)	0.5 px: 63.6 %; 1 px: 38.2 %
4f magnification error	0.5 % (72.7 %)	1 %: 69.0 %; 2 %: 60.3 %
camera regions shifted	1 px (8 µm; 71.8 %)	2 px: 66.8 %
plate spacing error	2 % (71.4 %)	5 %: 61.7 %; 10 %: 49.8 %
picture shift, whole field	< 0.5 px	0.5 px: 63.0 %; 1 px: 34.7 %; 2 px: 57.0 %
picture shift, means fixed	0.5 px (71.7 %)	1 px: 68.7 %; 2 px: 62.0 %; 4 px: 37.0 %
plate phase noise	0.1 rad (72.0 %)	0.2 rad: 67.8 %; 0.5 rad: 42.2 %
photons per picture	$10^{5}$ (73.3 %)	$10^{4}$: 70.3 %; $10^{3}$: 59.9 %

We then measured evidence maps on this simulated bench by Eq. (6), from camera intensities alone, at the full resolution of $32 \times32$ pixels (2,049 frames per picture; Figure 10, Table 9). For each of three pictures the measured map adds up to the bench’s own $P-b$ to $10^{-15}$, so the procedure returns the simulated bench’s own decomposition. It resembles our model’s map; the residual is the model’s own small difference from the bench, which also moves $P-b$ (for the airplane 0.026 on the bench against 0.041 in the model). With $10^{8}$ photons per frame the maps correlate with our model as well as the noise-free ones do; $10^{6}$ are too few. A map needs more light than a classification ($10^{5}$ photons per picture suffice to classify, § 3.9), because it is built from differences of frames. A milliwatt laser gives far more than $10^{8}$ photons per 10-ms frame; the practical limit is the camera’s full-well capacity and dynamic range, which may call for averaging frames.

per-pixel map ($32 \times32$)	airplane	leopard	ketch	ketch’s sum
correlation with our model’s exact map
bench, no noise	0.91	0.71	0.78	0.038
$10^8$ photons per frame	0.90	0.70	0.77
$10^6$ photons per frame	0.57	0.31	0.44
correlation with the flawless bench’s map
laser drift 0.1 % per frame	0.995	0.997	0.984	0.041
laser drift 1 % per frame	0.71	0.81	0.50	0.059
off pixels pass 1 % of their amplitude	1.000	1.000	1.000	0.040
off pixels pass 3 %	1.000	1.000	1.000	0.056
crosstalk 2 % to each off neighbour	0.999	0.999	0.999	0.038
crosstalk 5 %	0.996	0.993	0.994	0.038

Three flaws of a real bench were then applied to the measurement (Table 9, lower part). Laser power that drifts between frames matters most: the laser must hold its power to about 0.1% over a map, or each frame be normalised by a reference detector. A modulator whose off pixels still pass some amplitude leaves the map’s pattern unchanged but scales it, so the map no longer adds up to $P-b$. Crosstalk between modulator pixels changes the maps little and keeps their sum. The sum rule $\sum_{s} E_{S} = P-b$ is thus a ready self-test on a bench: it flags drift and leakage, and crosstalk does little harm.

For builders

We applied bench flaws to the trained pixel-aware model without retraining it (Figure 11, Table 12). Modulators of 8 bits are enough everywhere: the picture tolerates 3–4 bits, the Fourier-plane modulator 5 and the plates 5–6. A 2% error in plate spacing or a random phase error of 0.1 rad costs one to two points, and $10^{5}$ photons per picture at the camera suffice. The hard requirement is alignment: each plate must sit within about a twentieth of a plate pixel sideways (0.8 µm; a tenth costs four points, a quarter drops accuracy to 51 %) and turn by no more than about a quarter of a degree; the Fourier-plane mask must be centred to about $2\,\mu\mathrm{m}$ and the 4f magnification right to 0.5 %, while the camera regions may be off by a whole pixel (Table 12). Training with random shifts buys tolerance at a cost of 2–3.3 points of aligned accuracy (one seed; separate models trained with the

light-keeping term, Table 13). A model trained with shifts of up to half a plate pixel keeps 47% instead of 23% when a plate is 8 μm off. Four plates 3.2 mm apart are closer than separate modulators can be mounted: they can be fabricated as fixed phase plates, or one reflective modulator can carry all four with a mirror folding the light between them, as in multi-plane light conversion [35]; the aperture after each plate becomes an absorbing stop, and anti-reflection coatings keep the coherent light from forming fringes between the plates. Much of the means plane’s light lies at the edge of the band, $|k| = 16$, because its tile repeats every two pixels; a mask off-centre in the Fourier plane cuts it first. Shifting the whole field, means tile included, dips at one pixel and partly recovers at two, because the means tile repeats every two pixels and an odd shift swaps its colour cells; with the means tile held in place, as a separate reference on a bench would be, the dip is gone (Table 12).

trained with shifts up to (plate, picture)	aligned	plate off 0.25 px	plate off 0.5 px
none	68.7	54.0	23.1
0.25 plate px, 0.5 px	66.7	58.3	32.7
0.5 plate px, 1 px	65.3	60.9	46.6

Discussion: how this compares

Table 10 sets this work beside the works it builds on, on the qubit side and on the optical side. The comparison is of kind, not a ranking: datasets, encodings, losses and budgets differ, and most optical numbers are simulations, as ours are.

work	classical network?	data	reported result	explanation
qubits
QCNN [4]	none	quantum states	phase recognition
circuit-centric [5]	none	small benchmarks	simulation
quantum kernels [7]	none	few features	superconducting chip
transfer learning [6]	pretrained CNN in front	images	IBM and Rigetti chips
QGrad-CAM [8]	CNN in front	MNIST (10), dogs vs cats	simulation	gradient (Grad-CAM)
QCxAI [11]	none	$2 \times2$ pixels	explanation study	parameter-shift saliency
gate Shapley [12]	none	small circuits	explanation study, also on chips	Shapley values of gates
xAI for QML [9]	none	$2 \times2$ pixels	Rigetti chip	IG, SHAP on chip
HattriQ [10]	none	MNIST, Fashion-MNIST, Bars and Stripes	simulation, also noisy	IG (numerical)
this work, qubits	none	colour Caltech-10, all pixels	37.7 % on chip	exact; $2 \times2$ on chip, $r = 0.77$
light
$D^2$NN [13]	none	MNIST (10)	91.75 % (sim.)
$D^2$NN, improved training [29]	none	MNIST (10)	97.18 % (sim.)
differential $D^2$NN [30]	none	grey CIFAR-10	48.51 % (sim.)
ensemble of 30 [31]	none	grey CIFAR-10	62.13 % (sim.)
magneto-optical [33, 32]	none	MNIST; colour CIFAR-10	>90 %; 38.6 % (sim.)
GPAM [14]	none	MNIST, Fashion-MNIST	94.37 %; 92.75 %	gradient maps
this work, light	none	colour Caltech-10, CIFAR-10, all pixels	72.3 %; 47.9 % (sim.)	exact; per pixel, simulated bench

Two points of this setting do not show in the table alone. Colour is handled with one wavelength: the channels and their means travel as tiles of one field rather than as separate wavelengths, and every pixel and colour of the $32 \times32$ picture is an amplitude. And the decomposition needs no approximation, while one identity estimates it from measurements: on a quantum computer and, from camera frames, on a (simulated) lens bench. This sets them beside the gradient [8], Integrated-Gradients and Shapley [9, 10], parameter-shift [11] and gate-Shapley [12] explanations proposed for quantum models, and the gradient maps of diffractive networks [14], which serve other models and questions. For Integrated Gradients with a zero baseline, pixels that are exactly zero receive zero attribution by construction, as on the black backgrounds of MNIST; we therefore tested our maps on colour photographs in which object and background both carry signal: against human-drawn object outlines, by deletion, and by a shortcut in the data that the maps exposed.

What the setting does not do is match electronic networks or the largest diffractive models in accuracy. A small convolutional network reaches 85.4 % on Caltech-10 where the plates reach 72.3 %, and ensembles of thirty diffractive networks reach 62 % on grey CIFAR-10 where our single four-plate model reaches 37.6 % (47.9 % in colour). A less constrained quadratic model helps separate the physical constraints from the rest: the same encoding, readout and training with a free complex map in place of the mask and plates (row Q of Table 1) reaches $75.7 \pm1.8$ %. Like ours, it is a ratio of quadratic forms of the encoded picture. The four plates come within 3.3 points of it with 0.5% of its parameters, in this training budget; this does not bound what quadratic models in general can reach. The aim was a classifier whose class probabilities decompose exactly into contributions of its encoded input that can be measured on hardware; these numbers are its price today.

Limitations

• Loading on qubits. The chip receives each picture through a fitted circuit of state fidelity 0.77; this, not the chip’s noise, costs most of the hardware accuracy (Figure 8). Exact loading of $2^{12}$ amplitudes with the general scheme of [36] takes about $\frac{23}{24}2^{12} \approx3{,}900$ CNOTs in leading order, so direct amplitude-encoded image classification, without a trained classical feature extractor or classifier, stays limited on today’s chips by loading, the known caveat of quantum machine learning on classical data [37].

• The mask is computed off the chip. In the hardware runs the Fourier-plane mask acts on the picture before the chip; on a bench this is the 4f system in front of the plates, and on qubits a QFT with post-selected ancillas that we simulate but did not run.

• Scope of the hardware results. One trained model (seed 0), one run of the test set and two runs of ten $2 \times2$ maps; finer maps need more shots than our quota allowed (a $4 \times4$ block is smaller than the shot noise at 4,000 shots). The phase-plate model and its map measurement were checked in an independent simulator, not built. The simulations support the feasibility of an optical implementation, but do not establish its experimental accuracy or the fidelity of its evidence maps. A physical bench must still demonstrate signed-field and means-plane preparation, alignment and magnification within the reported tolerances, and stable or reference-normalised optical power across the frames of a map.

• What we do not claim. The all-optical model is a linear diffractive network: classical light suffices and no quantum advantage is claimed. Four masks in superposition gave the same accuracy as four masks measured apart (a no-interference control), so no interference advantage is claimed either. The datasets are small images of ten classes; accuracies are below those of electronic networks.

• The readout. BHR replaces a learned temperature by a chosen constant $\varphi$; it is not more accurate than a learned temperature, and we did not study other values of $\varphi$ here. Its anchor $b_g$ is the group mass of a maximally mixed input, exact for unitary circuits; on a lossy bench it is kept as a fixed reference (§ 2.4).

• Stability of pixel maps. Each map explains its own model exactly, but models trained from different seeds use different single pixels: the maps of two seeds agree little pixel by pixel and much more in blocks (Table 11), and a model and a bench that agree to an overlap of 0.999 give pixel maps that correlate at 0.71–0.91 (§ 3.8). Single-pixel detail is therefore a property of one trained model; block sums and the share on the object (Table 6; it varies by at most 0.01 between seeds) are the robust readings. Maps of the plates and of the qubit circuit agree about as much as those of two qubit seeds do (on pictures both classify correctly 0.15 against 0.16), a little less in the coarsest blocks (last row of Table 11), so the two systems differ in their maps no more than the less stable of them differs from itself.

model	pixels	blocks of 4 px	blocks of 8 px	blocks of 16 px	pixels
plates (row D)	0.25 (0.16–0.35)	0.69 (0.55–0.79)	0.78 (0.63–0.88)	0.89 (0.61–0.96)	0.29 (0.19–0.40)
qubits (D′)	0.10 (0.02–0.18)	0.26 (0.09–0.43)	0.40 (0.16–0.63)	0.56 (−0.09–0.87)	0.16 (0.09–0.27)
plates vs qubits	0.09 (0.02–0.19)	0.28 (0.07–0.48)	0.37 (0.08–0.64)	0.42 (−0.16–0.82)	0.15 (0.06–0.26)

• Test-set reuse. The trim that removed the shortcut was chosen after the shortcut was seen in maps of test pictures (§ 3.6). The trimmed Caltech-1010 results are

therefore exploratory: validation-only model selection afterwards does not undo that earlier use, and no independent holdout confirms the choice.

• Dataset bias. Trimming removed one shortcut; others belong to the data (motorbikes photographed on white studio backgrounds, sketches on water) and remain visible in the maps.

Conclusion

In a classifier that is linear in its encoded amplitudes up to a Born-rule measurement, of light or of qubits, each class’s probability above its share splits exactly into contributions of the encoded amplitudes, shown as Born evidence maps; the split does not depend on the readout that follows. These maps can be measured on the hardware that runs the classifier, and in our tests they were useful: in a deletion test they ranked pixels about as well as occlusion, they showed that encoding dark features with the same weight as bright ones puts the explanation on the object, and they found a shortcut in the data. On a superconducting quantum computer, with the mask applied before loading, the whole test set ran at 3.8 times chance, and the explanations measured for ten correctly classified pictures, selected by the class-wise rule of § 3.7, correlated with the exact ones ($r = 0.77$); loading the picture, not the chip, limits the qubit side today. As the trim of Caltech-10 was chosen on test pictures, these results are exploratory. The phase-plate version needs no quantum hardware at all; in simulation its main demand on a builder is sideways alignment of the plates to about a micron. A single learned Fourier-plane filter already added about four points (rows B to D of Table 1); several filters, side by side as channels or in series with the plates, would keep the model linear up to the measurement and its explanations exact, and are a natural next step. The code, the trained models, the data and a ledger of every hardware job are released with the paper, with notebooks to try the maps and to train a model in the browser.

Code and data availability

The code, the trained models used in the interactive demo, Caltech-10 as prepared here (derived from Caltech-101, CC BY 4.0), the record of every job run on ibm_kingston (circuits as sent, calibration and raw counts), and two notebooks (an interactive demo and training in the simulator) are at https://github.com/stein-research/seeing-why; release v1.0 is archived at Zenodo, doi:10.5281/zenodo.23906357.

Author contributions and use of AI tools

T.T. conceived the study, developed the methods and the code, ran the simulations and the hardware experiments, and wrote the manuscript. R.J. worked with T.T. on the physics and the optics of the model, reviewed the manuscript and advised on its content and presentation. An AI assistant (Claude, Anthropic) was used under the authors’ direction to write and run simulation and analysis code, to prepare and check the hardware jobs, to write the code that draws the figures, to search the literature and check the references against their sources, and to draft and revise the text; the authors chose what to cite. The authors retained responsibility for the study design, the scientific judgments and the claims, checked the reported results against the saved data and the code, approved the final version, and take full responsibility for its content.

Model and training details

Mask parameters. Per colour plane $c$ and spatial frequency $k$ the mask is $d_c(k) = \cos\theta_c \cos\bar{\theta}_k e^{i\bar{\phi}_k}$, with $\bar{\theta}_k = (\theta_k + \theta_{-k})/2$ even and $\bar{\phi}_k = (\phi_k - \phi_{-k})/2$ odd in $k$, so the filter’s kernel is real. The amplitude adds 518 parameters (row C against B in Table 1: 514 frequency angles and one gain for each of the four planes) and the phase 510 more (row D; the zero and Nyquist frequencies, their own mirrors, have no phase). With the lens mask every frequency of the picture zero-padded to $64 \times64$ takes the mask value of the modulator pixel it falls on. Qubit circuit. Rotations $R_X(w_1)R_Y(w_0)R_Z(w_2)$ per wire and layer; $\operatorname{CNOT}(i,i+1)$ for $i \equiv k \pmod2$ after layer $k$; qubits ordered most significant first; the measured qubits are the first seven. Phase plates. Plate pixels of $2 \times2$ field samples ($32 \times32$ plate pixels on the $64 \times64$ field); transfer function on a grid padded to $128 \times128$, cropped back after every step (light outside the aperture is lost); detector regions $4 \times8$ field pixels. The pixel-aware variant uses $2 \times2$ samples per field pixel and $z$ scaled by 4; the adjoint sums the samples.

Quadratic baseline (row Q of Table 1). A free complex matrix $W$ ($128 \times4096$, real and imaginary parts trained, entries drawn from a complex normal distribution of variance $1/4096$, no regulariser or constraint) maps the encoded picture to 128 outcomes, $P_b = \lvert(Wa)_b\rvert^2/\lVert Wa\rVert^2$, grouped as for the plates and read by the same BHR ($\phi= 0.0556$). Training as for row D: 50 epochs, class-balanced batches of 64, random crops 0.8, Adam 0.01 with a one-epoch warm-up and cosine decay, the weights of the best epoch on the 100 validation pictures kept, seeds 0–2. It reaches 0.97–0.99 on training pictures and 0.87–0.89 on validation. Unlike the plates, $W$ is neither a product of free-space propagation and phase masks nor limited to the losses of an aperture. Code: quad_baseline.py.

One picture through the trained models

Figure 12 follows the sketch of Figure 1 through the trained models of rows D and D′, step by step, with the numbers each step produces. The interactive demo (Code and data availability) draws the same view for any test picture and model.

Depth

On the untrimmed crops (which carry the shortcut of § 3.6, so these numbers are a record, one seed): the brickwall at depths 22 / 11 / 6 reaches 58.7 % / 56.3 % / 45.0 % plain (ROC-AUC 0.884 / 0.868 / 0.802) and 63.7 % / 60.0 % / 53.7 % with the mask and the mean plane (0.918 / 0.893 / 0.863). With the front end, half the depth exceeds the plain circuit (depth 11 at 60.0 % against depth 22 at 58.7 %), and depth 6 gains nine points; the mask alone does not help the shallow circuits.

Four masks and the interference control

Four Fourier-plane masks in superposition, selected by two register qubits and mixed by the main circuit, reach $69.1 \pm2.1$ % on the untrimmed crops (three seeds; one mask $59.1 \pm2.9$ %). A control with the same circuit and parameters, in which the register is measured after the masks so that the filtered pictures never interfere, reaches 69.3 % against 70.3 % at the same seed, with the same ROC-AUC (0.938). The gain comes from having four filters, not from their interference, and we claim no interference advantage.

Tolerances of the phase-plate bench

Hardware details

Loading. For one test picture (with an earlier model trained on the untrimmed crops) the fitted RY–CNOT preparation of depth 8 (fidelity 0.75, 105 CNOTs) gave the true class a probability of 0.950 under a noisy simulation (FakeFez) and of 0.771 on ibm_kingston, against 0.626 and 0.686 for depths 16 and 24 in simulation: deeper loading is more exact but noisier, and depth 8 was kept. For the test set, all 300 preparations were fitted at once (3,000 Adam steps, 10 minutes on one GPU). Each circuit was transpiled at Qiskit’s level 3 with eight seeds and the one with the best calibrated success estimate kept (all chose the same layout: the brickwall maps onto a line of the heavy-hex lattice without SWAPs); dynamical decoupling (XY4) was on. The bit order of the counts was checked end to end against our simulator (total variation distance 0.011 at 200,000 shots, logical and transpiled; a reversed order would give 0.24). Pictures and jobs. Pictures were sent one of each class in turn, ten jobs of thirty; per job the chip’s accuracy (23.3%–50.0%) followed the fitted loading’s on the same pictures (26.7%–53.3%). Every job is kept in a ledger: job id, backend, times, quantum seconds, the calibration at sending, the qubits used, the circuits as built and as sent, and the raw counts; a measurement is never sent twice (keys over the circuits, the backend and the shots). Maps. The ten pictures of Figure 9 were the most cluttered of those the chip classified correctly with probability at least 0.6 (background share of the crop times the grey-level spread outside the object outline). Block preparations were fitted like the pictures (fidelity median 0.81).

Computational setup

Everything except the hardware runs was done on one laptop (Table 14).

hardware
GPU, CPU, memory	NVIDIA GeForce RTX 5050 Laptop GPU (8 GB); Intel Core i5-13450HX; 16 GB
quantum computer	IBM ibm_kingston (Heron r2) through Qiskit Runtime
software
Python 3.12.3
PyTorch 2.11 (CUDA 12.8) [23]	simulator, optics, training
NumPy 2.5, SciPy 1.18	arrays, data
scikit-learn 1.9.1 [38]	ROC-AUC, logistic-regression reference
OpenCV 5.0	random crops
PennyLane 0.45.1 [24]	cross-check of the simulator
Qiskit 2.6.1 [25]	cross-check, circuits, transpiling
qiskit-ibm-runtime 0.51.0	hardware jobs
qiskit-aer 0.18.2	noisy simulations (FakeKingston)
LightPipes 2.1.5 [26]	independent optics simulation (the bench)
umap-learn 0.5.12 [27]	Figure 2
time
training, 50 epochs	48 s phase plates (row D); 2.7–6.7 min qubit circuit (D′, 12-qubit state vector; by seed)
loading circuits	300 fitted in about 10 min
ibm_kingston	340 quantum seconds (test set), 184 (two runs of maps)

Bench simulation

LightPipes (BSD-3), 633 nm, 8 µm pixels: each colour plane through its own 4f system (focal length chosen so the Fourier plane falls on the simulation grid, 4× sampling per pixel, grid padded 2×), the learned mask on a modulator covering $|k| \le16$ and divided by the square pixel’s sinc envelope; the 4f output passed to the plates unaveraged; the planes tiled; Fresnel propagation (Forvard) over $d = z \Delta x^{2}/\lambda= 3.24$ mm between plates with square pixels; light summed over each detector region. Propagation alone agrees with ours to $2 \times10^{-10}$; with no mask the 4f system images the picture to $2 \times10^{-6}$. For the thick-plate check, each plate is a fused-silica relief ($n = 1.457$) of height $h(x) = [\phi(x) \mathop{\rm mod} 2\pi]\lambda/[2\pi(n - 1)]$, at most 1.385 µm, crossed in 32 layers of LightPipes’ finite-difference Steps (version 2.1.5). On a uniform slab of thickness $t = \lambda/[4(n - 1)]$, whose expected phase is $k(n - 1)t = \pi/2$, Steps returns $\pi/4$ (0.500 of it, measured at the start of every run); the plates are therefore given the index $1 + (n - 1)/0.500 = 1.914$, which restores the phase $k(n - 1)h$ and is not fitted to our model. With it, a single thick plate matches its thin phase mask to an overlap of 0.998. (Steps also takes its index array transposed, which the code accounts for.) The check is consistency under this corrected software convention, not an independent model of the glass. Code: optics_check_full.py, option –thick. With 8 µm modulator pixels and one mask pixel per spatial frequency, a real lens pair has $f = s \Delta x p/\lambda\approx3.2$ mm ($s = 32$ pixels of $\Delta x = 8$ µm, mask pitch $p = 8$ µm); a longer focal length spreads each frequency over several mask pixels. Dividing out the sinc envelope asks for gains up to 2.1 (rows D and E), highest at the corners of the band, where the envelope is lowest; a passive mask is scaled to a peak of 1 and then keeps 23 % of the light. The readout normalises the camera light, so the predictions do not change, but the photon budget falls by that factor.