Capstone: Data Re-uploading Hybrid Classifier

Stage 4 built a variational classifier piece by piece: a feature map followed by a trainable ansatz and a measured observable (VQC architecture), exact gradients from the parameter-shift rule, an understanding of when gradients vanish (barren plateaus), and the train/test protocol of the quantum-kernel pipeline. The capstone combines these on a task that a linear model cannot solve: classifying points of the unit square by whether they lie inside a circle. The model is the data re-uploading classifier of Pérez-Salinas et al. (2020), which feeds the same input into the circuit again in every layer.

The engine treats all $4L$ weights alike, and the lab requires all of them, but the four dead ones have identically vanishing gradients. The TypeScript cell at the end finds exactly these four with the shift rule. The proposition explains the poor $L=1$ results below, about $0.58$ held-out accuracy: a stripe $\cos(\pi x_1+w)>0$ cannot capture a disc.

The angle-encoding lesson showed that a model with $L$ uploads of a single-qubit rotation is a trigonometric polynomial of degree $L$ (Schuld, Sweke & Meyer 2021). We now prove the two-feature version for our classifier, in the units of the encoding angle $\pi x_j$.

Numerical check. A trigonometric polynomial with $\lvert\omega_j\rvert\le L$ is reproduced exactly by its samples on an $N\times N$ grid of $[0,2)^2$ when $N>2L$, because no two frequencies in range alias. For $L=2$ and the weights $(0.3,1.1,-0.7,2.0,0.5,-1.4,0.9,0.2)$ (order $w_{0,0,0},w_{0,0,1},\dots,w_{1,1,1}$), an $8\times8$ discrete Fourier transform gives coefficients of size at most $10^{-15}$ for every $\lvert\omega_j\rvert>2$: the model has no frequency beyond $L$. Only $9$ of the $25$ allowed coefficients are non-zero, at $\omega_0\in\{-1,0,1\}$ and $\omega_1\in\{-2,0,2\}$. The restriction of $\omega_0$ is part (a) of the proposition. The even values of $\omega_1$ come from the two layers: at $L=2$ the output is a product of two factors of first degree in $\cos\pi x_1,\sin\pi x_1$. For $L=3,4,5$ and random weights the count is $35$, $63$ and $99=(2L-1)(2L+1)$, so at depth $5$ the classifier has $99$ active Fourier coefficients controlled by $16$ live weights. A disc is not a finite Fourier series, so deeper models approximate its boundary better, but each extra layer also adds weights to train.

The widget shows the one-qubit version from the angle-encoding lesson: five $R_Y$ uploads and random trainable layers give a spectrum in $\{-5,\dots,5\}$. Lower the number of layers and the highest available frequency drops with it.

The workbench trains the classifier in your browser with exactly these formulas: initial weights $2\pi u$ from mulberry32(seed), the shift-rule gradient and Adam. Per epoch it shows the loss, the training and test accuracy, the gradient norm and the decision map $\mathrm{sign}\,f_w$ over the unit square, with the true circle drawn on top.

Theorem (Caro, Huang, Cerezo, Sharma, Sornborger, Cincio and Coles, 2022; statement only). Let a quantum machine-learning model contain $T$ trainable local gates, and let it be trained on $M$ points drawn i.i.d. from a distribution $\mathcal D$, with a bounded loss $\ell$. For the trained weights $w^\star$ define the generalisation error $\mathrm{gen}(w^\star)=R(w^\star)-\hat R_M(w^\star)$, the expected loss $R(w)=\mathbb E_{(x,y)\sim\mathcal D}\,\ell(w;x,y)$ minus the training loss $\hat R_M(w)=\frac1M\sum_m\ell(w;x_m,y_m)$. Then, with probability at least $1-\delta$ over the training set, $\mathrm{gen}(w^\star)\in O\Big(\sqrt{\frac{T\log T}{M}}+\sqrt{\frac{\log(1/\delta)}{M}}\Big)=\tilde O\Big(\sqrt{\frac TM}\Big),$ where $\tilde O$ hides logarithmic factors. The bound depends on the number of trainable gates, not on the $2^n$-dimensional Hilbert space.

For the lab, $T=4L=20$ and $M=100$ give $\sqrt{T/M}=\sqrt{0.2}\approx0.447$, and with the logarithm $\sqrt{20\ln20/100}\approx0.774$. The constants are not specified, so these numbers describe scaling, not a guarantee: four times more data halves the bound, twice as many gates raise it by $\sqrt2$. Measured with the $0$–$1$ loss, the gaps between training and held-out accuracy of the $L=5$ runs below are $0.08$, $0.04$ and $0.07$, far below $0.447$, as is typical for worst-case bounds.

Depth and initialisation. The table reports the engine's trainVQC with exactly the lab's recipe (MSE, Adam with $\eta=0.1$, $80$ epochs, initial weights $2\pi u$ from mulberry32(seed), the first $100$ points for training, the last $100$ for testing). The $L=5$, seed $1$ run is the lab's reference solution, weight for weight.

One layer gives a stripe classifier, as proved above. Two layers already reach $0.81$–$0.83$. Three layers are not reliably better than two: two of the three $L=3$ runs end below $0.83$, in poorer local minima of a non-convex landscape. With $L=5$, all three initialisations exceed $0.85$, and the training accuracy reaches $0.98$–$1.00$. A practical recipe is to run several restarts and keep the run with the lowest final training loss. That selects seed $1$ for $L=3$ (held-out $0.80$), seed $1$ for $L=4$ ($0.90$) and seed $0$ for $L=5$ ($0.90$). The lowest training loss does not always give the best test score ($L=5$, seed $1$ reaches $0.96$), but choosing by the held-out score would turn the test set into training data and invalidate it as an estimate.

The second workbench trains $L=3$ for $80$ epochs from seed $0$, the $0.77$ run of the table. Change the seed to see the spread between initialisations, then switch on the depth comparison below. It trains $L=1,\dots,6$ with the same settings and draws the final training and test accuracy per depth.

The barren-plateau lesson showed that for random deep circuits the variance of a gradient component decays exponentially with the number of qubits. Our model has only two qubits. As a diagnostic we compute the variance, over random initialisations $w=2\pi u$, of $\partial f_w/\partial w_{0,0,0}$ at the fixed point $x=(0.3,0.7)$. This is the weight furthest from the readout. We first derive the value expected when the rest of the circuit is a unitary 2-design.

Measured. Sample variance over 5000 initialisations $w=2\pi u$ (mulberry32(55)), shift-rule derivative at $x=(0.3,0.7)$:

The statistical standard error is about $0.002$–$0.003$. At $L=1$ the derivative vanishes identically: $w_{0,0,0}$ is a dead weight (part (a) of the proposition). From $L=2$ on, the variance stays between $0.113$ and $0.126$, and at $L=8$ and $L=12$ it agrees with the 2-design value $2/15$ within two standard errors. Shallow circuits are not yet 2-designs, so their values differ by up to $15\%$. Deeper circuits converge to $2/15$, a constant set by the two-qubit dimension. Depth therefore costs no gradient signal here, and the trainability problems seen in the table are local minima, not a plateau. On $n$ qubits the same diagnostic would fall like $2^{-(n+1)}$, which is why the barren-plateau lesson recommends local costs and shallow, structured circuits.

The TypeScript cell evaluates the lab's reference model (weights rounded to four decimals) on both data sets. It compares a hand-written two-term shift rule with the engine's vqcGradient and lists the weights with zero gradient. It finally prints the cost per epoch with and without them.

The NumPy cell rebuilds the classifier from $4\times4$ matrices and regenerates the data set with a port of mulberry32. It checks the shift rule against a central difference and the dead weights, and computes the Fourier coefficients of an $L=2$ model with np.fft.fft2.

The lab. You write trainCapstone: choose the depth $L\in\{3,4,5,6\}$, implement the shift rule and the optimiser, and return the weights. The grader classifies $100$ held-out points it never sends to the browser and requires an accuracy of at least $0.85$. Per the table, $L=5$ with Adam passes from all three tested initialisations, while $L=3$ usually does not.