A frozen pre-trained image model, used as a fixed feature extractor, already does the hard part of a vision task. Only a small classifier on top of its embeddings has to be trained. Separately, a small line of quantum machine learning work, the Quantum-Train family, uses a quantum circuit only during training, as a weight generator. The circuit's measurement probabilities, passed through a small classical network, produce every weight of an ordinary classical model, and the deployed model runs on a CPU with no quantum hardware. These generators compress millions of weights into a few hundred circuit parameters, and their authors report a regularizing effect. When they train vision networks from scratch, however, they pay a large accuracy penalty. The natural joint proposal is to use the quantum generator only for the downstream head on top of a frozen foundation encoder. That shifts the burden from learning low-level filters under extreme compression to separating already well-organized embeddings, which is where a strong structural prior could plausibly help in low-label settings.
That combination is easy to propose and easy to dismiss. Heads are already small, and the shallow circuits these methods use can be simulated exactly on classical hardware. The question worth answering is therefore not whether quantum-synthesized heads work. It is whether anything about the quantum generator, as opposed to the low-dimensional family of weights it induces, matters once the backbone is frozen. We propose to build quantum-synthesized heads and pit each one against an exactly matched classical "twin": a tensor-network generator that provably contains the same weight family. We will measure accuracy, sample efficiency, and robustness to hardware noise and finite measurement shots.
Core Claim
Our hypothesis is that any generalization benefit of Quantum-Train-style weight synthesis for downstream heads comes from the restricted, entanglement-limited structure of the weight distribution, not from anything quantum. If so, the benefit should grow with circuit entanglement, and a classical matrix product state (a chain of small tensors that represents a probability distribution over bit strings, with "bond dimension" controlling how much correlation it can carry) should reproduce it at matched bond dimension.
The argument for the matching is simple. Consider a brickwork circuit of depth $L$ on $N$ qubits built from two-qubit gates with operator Schmidt rank at most 2, such as CNOT or CZ. Each gate that crosses a cut at most doubles the rank across that cut. The circuit's output state is therefore exactly a matrix product state with bond dimension at most $2^L$.
The prediction is falsifiable in both directions. If the quantum head beats a matrix-product-state twin of bond dimension $\chi \ge 2^L$ trained with the same budget, then the circuit's specific parameterization (its gate set and its optimization landscape) carries a useful inductive bias that the containing classical family does not find. If the twin matches it, the community learns that these methods are tensor-network priors that need no quantum processor at any stage. Either result is new, because no work on Lacuna applies offline quantum weight synthesis to heads on frozen encoders, and none runs a containment-matched classical control.
Research Program
We reuse the generator from Quantum-Train, which trains classical CNNs and LSTMs from scratch by generating their weights from a quantum circuit. We also reuse the chunked generation of Quantum Parameter Adaptation, which applies the same idea to LoRA-style updates inside large language models and reaches a 0.52-billion-parameter output layer with 4 to 11 qubits. For a head with $M$ weights, a circuit on $N=\lceil \log_2 M\rceil$ qubits (or fewer, when chunked) prepares a state $|\psi(\phi)\rangle$ with gate angles $\phi$. Each weight is then produced as
$$\theta_i = G_\gamma\big(b_i,\ |\langle b_i|\psi(\phi)\rangle|^2\big),$$
where $b_i$ is the bit string indexing weight $i$, $|\langle b_i|\psi\rangle|^2$ is its measurement probability, and $G_\gamma$ is a small classical network with parameters $\gamma$. Gradients of the task loss flow through the head and $G_\gamma$ into $\phi$. Only $\phi$ and $\gamma$ are trained, and the deployed head is plain classical weights.
The heads sit on frozen encoders already used for low-label transfer in the file. These are RADIOv2.5-B, the backbone in TwinTURBO, a semi-supervised method that trains a projector on frozen features; EfficientNetB7, the backbone in PRPL, which does unsupervised domain adaptation with frozen features and pseudo-labels; and Inception-v3, as in Kieffer et al., who showed frozen ImageNet features plus a linear SVM beat from-scratch models on histopathology. We study both linear heads and two-layer MLP heads. The MLP heads, at around a million weights on 2,560-dimensional EfficientNetB7 features for 65-class Office-Home, are the regime where head size starts to matter: many heads stored per device, or many tasks served from one backbone.
The analysis has three threads.
The first thread is the twin ladder. We vary circuit depth $L$, and therefore entanglement, and pair each depth with a matrix-product-state generator of bond dimension $2^L$, trained directly as a classical probability model with the same $G_\gamma$. We also add a product-state circuit with no entanglement, the classical limit.
The second thread is noise. QPA reports that IBM hardware noise models improved perplexity, while Quantum LEGO Learning, a frozen classical backbone feeding an active quantum-circuit head, loses accuracy on real hardware, falling from about 97% in simulation to 90–92% on IBM Heron r2. We think the two observations are compatible. Noise on a weight generator acts like weight noise during training, whereas noise on an active head corrupts every prediction. We test this by matching hardware-model noise against classical Gaussian weight noise of equal variance on the generated weights.
The third thread is the one-shot hardware path. We train in simulation, then run the trained circuit once on hardware with $S$ shots to estimate the probabilities that produce the deployed weights. Accuracy is measured against $S$. Probability estimates from shots have error of order $1/\sqrt{S}$, so accuracy should saturate once that error falls below the head's tolerance to weight perturbation, which we measure separately. This turns the open shot-noise problem flagged by Quantum-Train into a single measured curve.
Baselines
The naive reference is a linear probe on the frozen features: L2-regularized logistic regression, plus a linear SVM following Kieffer et al.. Its regularization strength is tuned by cross-validation on the same labeled subset. This baseline matters most in the low-label regime, because a well-tuned probe is often hard to beat there, and our generator must beat it to claim any regularization benefit at all.
The strongest classical competitor on the specific question is the matrix-product-state twin. It contains the circuit's weight family by construction, uses the same $G_\gamma$, and gets the same number of optimizer steps and the same hyperparameter search budget. We will match its parameter count to the circuit where possible and report it at both equal parameters and equal bond dimension. Beating it means a statistically reliable accuracy gain, over at least five seeds and label subsets, at matched bond dimension and parameter count.
A third baseline is a parameter-matched low-rank head. The weight matrix is factored as $UV^\top$, with rank chosen so the trainable count equals the circuit's. This is the obvious classical compression of a head. We also use the Quantum-PEFT unitary parameterization applied to the head. Quantum-PEFT is a classically simulated circuit reparameterization of adapter updates that reaches 98.46% on CIFAR-10 with a ViT versus 98.39% for rank-4 LoRA, using 21 times fewer parameters. Since it is already "quantum structure run classically", it is a direct competitor.
Two task-specific ceilings provide context; our methods are not expected to beat them. For SVHN with 100 labels, TwinTURBO reports about 50% for a standard supervised head and about 85% for its semi-supervised projector. We will also run TwinTURBO with its projector weights synthesized by the circuit and by the twin, so the comparison is like for like. For domain adaptation, PRPL reports 92.4% on Office-31 and 81.2% on Office-Home. We swap our heads into PRPL's classifier slot. Finally, Quantum LEGO's active quantum head is run at the same qubit count on the same frozen features where data permit, to isolate what decoupling costs or saves in accuracy.
Why not just…?
Why not just fit a regularized linear probe and stop? For a single-task linear head this is a real threat, and we expect it to be competitive. A probe on 768-dimensional features for 10 classes has under 8,000 weights, so compressing it buys nothing at deployment. We therefore make the compression claim only for MLP and many-class or many-task heads. We let the generalization claim stand or fall on the low-label comparison against the tuned probe. If the probe matches the quantum head at 100 and 1,000 labels, we will report that the proposed regularization benefit does not exist on frozen features.
Why not just use a classical hypernetwork or low-rank head of the same size? The Quantum-Train evidence against classical alternatives compares against shrunken classical architectures, not against classical generators of the same weights. The quantum sidecar study, which inserts an active 4-qubit circuit into a ResNet-50, found that an equal-parameter classical bottleneck did worse than its baseline, but that bottleneck sits on the data path, a different setting. Neither result settles the question here. The twin ladder and low-rank baselines settle it directly, and Quantum-PEFT's success with purely classical simulation already suggests the structure, not the hardware, does the work.
Why not just inject weight noise instead of using quantum hardware noise? The QPA noise benefit may be ordinary noise regularization. Our matched-variance Gaussian control tests exactly this. If it reproduces the hardware-noise effect, the "beneficial quantum noise" claim reduces to a known classical trick.
Why not just keep an active quantum head, as in Quantum LEGO? An active head needs a quantum processor or simulator for every prediction and must encode every embedding into a quantum state. The sidecar study shows a 4-qubit data bottleneck hitting a capacity ceiling on 31 classes. We test whether synthesized heads avoid that ceiling by comparing accuracy at matched qubit count on high-class-count tasks: 65-class Office-Home and 24-class Kimia Path24.
Proposed Experiments
Low-label image classification. We use SVHN and CIFAR-10 at 100, 1,000, and full labels, with frozen RADIOv2.5-B features. The reported reference points are TwinTURBO's approximate 50% supervised and 85% semi-supervised accuracy on SVHN at 100 labels. For CIFAR-10 with a frozen backbone at low label counts, no reported result was found on Lacuna. Quantum-Train's 60.69% from scratch, using about 8% of the parameters, marks how much a frozen backbone could recover.
Domain shift. We use Office-31 and Office-Home with EfficientNetB7 features inside PRPL, which reports 92.4% and 81.2%.
Cross-domain transfer. We use Kimia Path24 with Inception-v3 features, scored by total accuracy. Reported results are 50.54% for frozen features with an SVM and 56.98% for full fine-tuning.
Many-class neural decoding. We use the 31-class imagined-handwriting data. The sidecar paper reports only a +0.19% gain over ResNet-50; no absolute accuracy was found on Lacuna, so we will establish our own baseline.
Metrics. We report accuracy, generalization gap, trainable and stored parameters, and training wall-clock including simulation cost. Simulation cost is an acknowledged limitation in QPA.
Decisive checks. The first concerns entanglement. If accuracy is flat across circuit depth $L$ and the product-state circuit matches the deeper ones, entanglement is irrelevant. The second concerns the twin. If the matrix-product-state twin at $\chi=2^L$ matches the circuit within seed variance on every benchmark, the quantum generator is a classical prior in disguise. The third concerns the probe. If the tuned probe matches both at 100 labels, synthesized heads offer no low-label advantage. The fourth concerns the hardware path: the curve of accuracy against shots $S$ for one-shot hardware weight generation, which tells practitioners how many shots a deployable head needs.
A positive result on all four checks would be the first evidence that quantum weight generators carry a useful bias beyond their classical containing family. A negative result would redirect this line of work toward tensor-network heads that need no quantum hardware.
References
- Quantum-Train: rethinking hybrid quantum-classical machine learning in the model compression perspective
- A Quantum Circuit-Based Compression Perspective for Parameter-Efficient Learning
- TwinTURBO: Semi-Supervised Fine-Tuning of Foundation Models via Mutual Information Decompositions for Downstream Task and Latent Spaces
- Efficient Pre-Trained Features and Recurrent Pseudo-Labeling in Unsupervised Domain Adaptation
- Convolutional neural networks for histopathology image classification: Training vs. Using pre-trained networks
- Quantum LEGO Learning: A Modular Design Principle for Hybrid Artificial Intelligence
- Quantum-PEFT: Ultra parameter-efficient fine-tuning
- Quantum-Inspired Hybrid Neural Networks for Neural Decoding: A Controlled Ablation Study of Learnable Quantum Sidecar Integration