Train-on-Classical, Deploy-on-Quantum

• Train-on-Classical, Deploy-on-Quantum methods are hybrid quantum-machine-learning workflows that leverage classical optimization and feature extraction to prepare a quantum-ready model.
• They employ classical pre-training techniques—such as tensor-network compression and transfer learning—to build a compact quantum classifier suitable for hardware deployment.
• These methods demonstrate competitive accuracy in tasks like image classification and speech recognition, despite current limitations in quantum hardware scalability and noise.

Train-on-Classical, Deploy-on-Quantum methods are hybrid quantum-machine-learning workflows in which substantial model formation is performed with classical resources—typically through a pre-trained classical backbone, tensor-network compression, simulator-based optimization, or classical evaluation of quantum observables—while the deployed inference or sampling stage is carried by a quantum circuit or quantum optical device. Across current work, this pattern appears in discriminative transfer learning with variational quantum heads, tensor-network front ends that compress classical data into few-qubit states, two-stage compilation pipelines that learn quantum operations classically and then align them to gate-based circuits, and generative models whose training objective is classically tractable although their sampling task is believed classically hard (Chen et al., 2021, Qi et al., 2021, Hu et al., 27 Feb 2025, Kyriacou et al., 7 Apr 2026, Recio-Armengol et al., 4 Mar 2025, Gottlieb et al., 9 Mar 2026).

1. Conceptual scope and neighboring paradigms

A common misconception is that every classical–quantum hybrid model belongs to this class. The literature instead separates at least three patterns. In the direct train-on-classical, deploy-on-quantum pattern, a classical model or classical simulator does most of the feature extraction or optimization, and the deployed object is a quantum circuit; examples include tensor-network feature extractors feeding VQCs, classical-to-quantum transfer learning for spoken commands, amplitude-encoding-based quantum heads for image recognition, and soft-unitary training followed by circuit alignment (Chen et al., 2021, Qi et al., 2021, Hu et al., 27 Feb 2025, Kyriacou et al., 7 Apr 2026).

Two closely related but distinct patterns recur as contrasts. First, some methods are explicitly closer to the inverse pattern, where a quantum subroutine assists training but deployment remains classical. The XOR study based on a lackadaisical quantum walk on a complete graph is formulated as a classical ANN with a quantum optimization/search subroutine over two output-layer weights, and its own discussion states that it is “not ‘train-on-classical, deploy-on-quantum’,” but rather closer in spirit to “(partially) train on quantum, deploy on classical” (Souza et al., 2021). Second, model-compression schemes such as Quantum-Train and “Training Classical Neural Networks by Quantum Machine Learning” use a QNN to generate or compress the parameters of a classical network, after which inference is entirely classical; both are therefore train-on-quantum, deploy-on-classical rather than deploy-on-quantum (Liu et al., 2024, Liu et al., 2024).

This distinction matters because the central engineering question changes. In the direct train-on-classical, deploy-on-quantum setting, the main problem is how to preserve a classical training advantage while producing a quantum object that is small, expressive, and hardware-compatible. In the inverse setting, the main problem is how quantum resources can compress or accelerate classical training.

2. Core architectural motifs

A dominant architectural motif is the frozen or largely classical feature extractor followed by a compact quantum classifier. In “An end-to-end trainable hybrid classical-quantum classifier,” the classical front end is a matrix product state (MPS) that maps each pixel $x_i\in[0,1]$ to a local two-dimensional feature vector and contracts the resulting product state into a low-dimensional feature vector $\mathbf z$. The VQC then applies $H^{\otimes n}$, encodes each feature with $R_y(\arctan(z_i))$ and $R_z(\arctan(z_i^2))$, uses repeated entangling blocks with a general single-qubit unitary $R(\alpha_i,\beta_i,\gamma_i)$, and measures Pauli-$Z$ on the first $k$ qubits. The paper is explicit that the classical–quantum boundary is adjustable: the MPS and VQC can be trained jointly, or one part can be frozen while the other is trained (Chen et al., 2021).

A second motif is classical transfer learning into a quantum head. In the spoken-command system of “Classical-to-Quantum Transfer Learning for Spoken Command Recognition Based on Quantum Neural Networks,” a 1D CNN extracts 64-dimensional features from raw waveforms, a dense layer compresses them to 8 dimensions, and an 8-qubit VQC with 4 repeated blocks and 96 adjustable parameters performs the quantum classification stage. Transfer learning appears in two variants: CNN-QNN$_2$, where the pre-trained CNN is frozen and only the VQC is trained, and CNN-QNN$_3$, where both CNN and QNN are fine-tuned jointly (Qi et al., 2021).

A third motif is direct amplitude encoding of high-dimensional classical features into a small quantum register. In the amplitude-encoding-based CQTL framework, pre-trained ResNet18, DenseNet121, and ResNet50 produce 512-, 1024-, and 2048-dimensional feature vectors, which are padded to length $\mathbf z$0 and amplitude encoded as

$\mathbf z$1

This yields 9, 10, or 11 qubits respectively. The resulting quantum heads, TLQNN and TLQCNN, deliberately allocate most trainable capacity to the PQC rather than to classical layers, pushing quantum parameter counts above one hundred while keeping the post-processing layer linear and small (Hu et al., 27 Feb 2025).

A fourth motif is classical compression into a few-qubit quantum fidelity test. co-TenQu uses an MPS to compress a 784-dimensional image to 4 dimensions for binary tasks or 6 dimensions for multiclass tasks, then encodes those features into 5 or 7 qubits and evaluates class similarity through a SWAP test between a data state $\mathbf z$2 and a learned state $\mathbf z$3. This makes the classical tensor network the dominant representation learner and the quantum circuit the final classifier (L'Abbate et al., 2024).

3. Training, optimization, and compilation mechanisms

The simplest training mechanism is joint hybrid optimization in which a classical simulator provides differentiable access to the quantum head. In the MPS–VQC classifier, the loss is cross-entropy, the VQC gradients are obtained with the parameter-shift rule,

$\mathbf z$4

and the MPS is differentiated through PyTorch autograd. In the spoken-command system, the classical CNN gradients are obtained by ordinary backpropagation while the quantum gradients are computed by finite differences, and transfer learning reduces the amount of quantum-side optimization needed on top of the pre-trained classical extractor (Chen et al., 2021, Qi et al., 2021).

A more explicit train-on-classical, deploy-on-quantum strategy appears in “Soft-Quantum Algorithms.” There the trainable quantum layer is treated not as a gate sequence but as a dense matrix $\mathbf z$5, and training minimizes

$\mathbf z$6

The trained “soft-unitary” is then converted into a deployable VQC by circuit alignment, i.e. variationally fitting a gate-based ansatz $\mathbf z$7 to $\mathbf z$8. On a 5-qubit supervised classification task with 1000 datapoints, soft-unitary training ran for 200 epochs in 48 seconds and alignment for another 200 epochs in 174 seconds, whereas direct VQC training took roughly 42 seconds per epoch, or about 138 minutes total; the aligned circuit reproduced the soft-unitary outputs with mean squared error $\mathbf z$9 (Kyriacou et al., 7 Apr 2026).

Another mechanism preserves a classical training loop while replacing the predictor block with a quantum component. “From Classical to Hybrid: A Practical Framework for Quantum-Enhanced Learning” keeps the outer self-training loop of a PLSR-based classical baseline unchanged, swaps the core predictor for a 2-qubit EstimatorQNN plus a small classical head, and then refines the circuit using QMetric diagnostics such as Training Stability Index, Quantum Gradient Norm, Effective Dimension of the Quantum Feature Space, Effective Entanglement Entropy, and Quantum Mutual Information. The workflow is therefore classical at the level of learning logic and hyperparameter control, but quantum at the deployed predictor block (Illésová et al., 11 Nov 2025).

4. Discriminative applications and empirical evidence

The discriminative literature provides several concrete demonstrations that a classically trained or classically simulated front end can support a competitive deployed quantum head. In the MPS–VQC model, the hybrid system reached about $H^{\otimes n}$0 test accuracy on binary Fashion-MNIST with $H^{\otimes n}$1, exceeded $H^{\otimes n}$2 on a ternary MNIST task with $H^{\otimes n}$3, and reached about $H^{\otimes n}$4 on ternary Fashion-MNIST, with increasing $H^{\otimes n}$5 improving accuracy by about $H^{\otimes n}$6 in the latter case (Chen et al., 2021).

In spoken command recognition, the benefit of transfer is especially explicit. The purely classical CNN-DNN baseline achieved 94.42% accuracy and CE 0.251. CNN-QNN from scratch reached only 83.25% accuracy, but transfer learning changed the picture: CNN-QNN$H^{\otimes n}$7, which froze the pre-trained CNN and trained only the 96-parameter VQC, achieved 94.58% accuracy with only 0.00096 Mb trainable parameters, and CNN-QNN$H^{\otimes n}$8, which fine-tuned both parts, achieved 94.87% accuracy with 0.071 Mb parameters. Under a noisy circuit model derived from an IBM Q 20-qubit device, the same transferred hybrids still reached 93.38% and 93.84% accuracy respectively (Qi et al., 2021).

The Iris workflow further illustrates that the value of the quantum block can persist even when the classical outer loop is unchanged. The classical self-training PLSR baseline reached accuracy $H^{\otimes n}$9, ARI $R_y(\arctan(z_i))$0, and NMI $R_y(\arctan(z_i))$1. Replacing the regressor by a minimal 2-qubit hybrid model raised these to $R_y(\arctan(z_i))$2, $R_y(\arctan(z_i))$3, and $R_y(\arctan(z_i))$4. After QMetric-guided refinement, HybridPlus reached $R_y(\arctan(z_i))$5, $R_y(\arctan(z_i))$6, and $R_y(\arctan(z_i))$7 (Illésová et al., 11 Nov 2025).

Image-classification studies with stronger classical backbones show the same pattern. co-TenQu achieved 99.79% on MNIST $R_y(\arctan(z_i))$8, 97.39% on a 3-class MNIST task $R_y(\arctan(z_i))$9, and 73.21% on 10-class MNIST while using 5 or 7 qubits; compared with a 17-qubit PCA-QuClassi variant, it achieved similar performance in some settings while using 70.59% fewer qubits. On IBM-Q hardware, the best reported device, IBMQ-Lima, reached 82.10% accuracy on a binary MNIST task after simulation-trained transfer (L'Abbate et al., 2024). In AE-CQTL, TLQNN and TLQCNN consistently exceeded a parameter-matched classical transfer-learning head. With a ResNet18 backbone, TLQNN reached 96.1% on MNIST $R_z(\arctan(z_i^2))$0 versus 82.8% for the classical CCTL baseline, and both TLQNN and TLQCNN reached 90.4% on CIFAR10 $R_z(\arctan(z_i^2))$1 versus 75.9% for CCTL, while also showing lower loss and stronger ROC/AUC behavior (Hu et al., 27 Feb 2025).

5. Generative and sampling-oriented methods

The generative branch gives the clearest asymmetry between classical training and quantum deployment. In “Train on classical, deploy on quantum: scaling generative quantum machine learning to a thousand qubits,” the model family is a parameterized IQP circuit,

$R_z(\arctan(z_i^2))$2

and training minimizes MMD$R_z(\arctan(z_i^2))$3 with a Gaussian kernel. The crucial observation is that MMD can be rewritten as an average over Pauli-$R_z(\arctan(z_i^2))$4 expectation values,

$R_z(\arctan(z_i^2))$5

and those expectation values for IQP circuits can be estimated efficiently on classical hardware. The authors trained models with up to one thousand qubits and hundreds of thousands of parameters, and on large datasets such as D-Wave data, binarized MNIST, scale-free Ising models, and genomic SNPs, the IQP models captured nontrivial covariance structure and often outperformed simple energy-based classical baselines trained with similar hyperparameter effort (Recio-Armengol et al., 4 Mar 2025).

The photonic analogue, “Efficient training of photonic quantum generative models,” uses discrete-variable linear optics and the same train-on-classical, deploy-on-quantum logic. Training again uses MMD, but the expectation values are expressed as permanents of matrices of the form $R_z(\arctan(z_i^2))$6 and approximated with Gurvits’ algorithm. Deployment is literally a boson-sampling experiment. The paper reports classical training for interferometers with up to 256 modes, 16 photons, and more than 100,000 parameters, and studies how ansatz choice and initialization affect trainability (Gottlieb et al., 9 Mar 2026).

These generative papers imply a sharper criterion for the topic than the discriminative transfer-learning papers do. A method belongs squarely to the train-on-classical, deploy-on-quantum class when the training objective depends only on observables that are classically tractable, while the deployed task is a sampling problem that is widely believed classically hard. IQP models and photonic boson-sampling models are the clearest current examples of that asymmetry (Recio-Armengol et al., 4 Mar 2025, Gottlieb et al., 9 Mar 2026).

6. Limitations, misconceptions, and future directions

Several limitations recur across the literature. First, real hardware remains difficult. co-TenQu’s IBM-Q results were markedly below simulation, with machine-specific and temporal variation and only IBMQ-Lima reaching 82.10% on the tested binary task (L'Abbate et al., 2024). AE-CQTL reports simulator experiments rather than hardware deployment, so amplitude-encoding overhead and NISQ noise remain unresolved at the system level (Hu et al., 27 Feb 2025). The MPS–VQC classifier likewise demonstrates the architecture on simulators and does not quantify exact qubit/depth trade-offs for replacing the MPS by quantum circuits (Chen et al., 2021).

Second, some of the most elegant train-on-classical strategies scale poorly in qubit count. Soft-unitaries require $R_z(\arctan(z_i^2))$7, so memory scales like $R_z(\arctan(z_i^2))$8, and the paper states that the depth required for accurate circuit alignment scales roughly as $R_z(\arctan(z_i^2))$9; the method is therefore restricted to few-qubit problems despite its strong speedups in that regime (Kyriacou et al., 7 Apr 2026). IQP generative models avoid that specific bottleneck, but their model family is not universal on exactly $R(\alpha_i,\beta_i,\gamma_i)$0 qubits, and the paper leaves universality with ancillas as an open question (Recio-Armengol et al., 4 Mar 2025). Photonic MMD training assumes the no-collision regime, which is natural for boson sampling but still a structural restriction in the derivation (Gottlieb et al., 9 Mar 2026).

Third, the topic’s boundary with neighboring paradigms remains easy to blur. Quantum-walk training of a classical XOR network, Quantum-Train, and related compression-based schemes are important because they identify low-dimensional bottlenecks, structured search spaces, and compact parameterizations, but they do not themselves instantiate deployment on a quantum model (Souza et al., 2021, Liu et al., 2024, Liu et al., 2024). This suggests a plausible future direction: classical pre-training may first identify a bottleneck, manifold, or compressed latent representation, and only then a deployable quantum module may be attached, aligned, or fine-tuned.

Taken together, the literature suggests that train-on-classical, deploy-on-quantum methods are most mature in three settings: modular transfer learning with a frozen classical backbone and a small quantum head; tensor-network compression that reduces classical data to a few-qubit representation; and generative models whose observables are classically tractable although their sampling task is not. The unifying design principle is not simply hybridization, but a deliberate asymmetry: classical resources are used where optimization is expensive, data are high-dimensional, or simulators remain effective, while quantum hardware is reserved for the final decision, transformation, or sampling stage.