Yomo: Single-Shot Quantum Machine Learning

• The paper introduces Yomo, a quantum machine learning design that achieves single-shot inference by aggregating computational-basis measurements into class probabilities.
• Yomo strategically incorporates loss terms like probability sharpening and entropy regularization to concentrate the Born distribution, boosting single-shot accuracy even under noise.
• Experimental results on MNIST and CIFAR-10 demonstrate that Yomo attains 90.52% and ~66% single-shot accuracy respectively, significantly reducing required circuit executions compared to conventional methods.

Searching arXiv for the specified paper and the related scaling-laws reference mentioned in the provided data. You Only Measure Once (Yomo) is a quantum machine learning design for single-shot inference in which a classifier is trained so that one computational-basis measurement is already highly informative of the correct class. In contrast to conventional quantum machine learning models that estimate Pauli expectation values by repeating circuit executions over many shots, Yomo replaces expectation-based outputs with a probability aggregation mechanism over computational-basis bit-strings and augments training with losses that encourage sharply peaked Born distributions. The method is introduced in “You Only Measure Once: On Designing Single-Shot Quantum Machine Learning Models” (Liu et al., 24 Sep 2025), which argues that this design substantially reduces inference cost and latency while maintaining high classification accuracy on MNIST and CIFAR-10, including under depolarizing-noise simulations.

1. Problem setting and motivation

A core distinction between classical and quantum machine learning is that quantum circuits produce random measurement outcomes rather than deterministic activations. In conventional QML, described in the paper as “Vanilla,” each class $k$ is associated with a Pauli observable $O_k$, and inference requires estimating

$$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$

by repeating the circuit $N$ times and averaging (Liu et al., 24 Sep 2025). By Hoeffding’s inequality, the estimation error decreases as $O(1/\sqrt{N})$, so even modest precision requires tens to hundreds of shots. The paper identifies this shot dependence as a central deployment bottleneck because cloud-based QPU access is typically billed per shot and because resets between measurements introduce real-time overhead.

The same source further notes that inference cost and latency grow linearly with $N$, and it connects this to a broader lifecycle argument: once a QML model is trained, inference rather than training may dominate total cost (Liu et al., 24 Sep 2025). This motivates the single-shot regime, in which reliable predictions would be obtained with only a handful of measurements, ideally one. Yomo is presented as a response to that objective: if training can shape the model so that a one-shot outcome is already strongly aligned with the correct class, averaging over repeated measurements becomes unnecessary.

A plausible implication is that Yomo is not merely an optimization of measurement budgeting, but a redefinition of the output interface between the variational quantum circuit and the classifier. Instead of treating stochasticity as a nuisance to be averaged away, it treats the Born distribution itself as the object to be sculpted during training.

2. Probability aggregation and single-shot prediction

Yomo performs a full computational-basis measurement on $n_q$ qubits, inducing Born probabilities

$$P(\phi)=\bigl|\langle\phi\,|\,\psi(z,\theta)\rangle\bigr|^2,\qquad \phi\in\{0,1\}^{n_q}.$$

The $2^{n_q}$ basis states are partitioned into $K$ disjoint subsets $O_k$0 of nearly equal size, with each bit-string assigned to exactly one class (Liu et al., 24 Sep 2025). During training, class scores are not Pauli expectations but aggregated probabilities,

$O_k$1

These aggregated values are then fed into the usual cross-entropy objective.

At inference, a single measurement returns one bit-string $O_k$2, and the predicted class is simply the class whose subset contains that outcome: $O_k$3 Operationally, inference therefore reduces to a single circuit execution plus a lookup from measured bit-string to class label (Liu et al., 24 Sep 2025).

This design changes the semantics of the classifier output. In expectation-based models, the score for a class is a real-valued statistic estimated from repeated circuit samples. In Yomo, the relevant object is the distribution of basis-state mass across class subsets. Because the class decision is determined directly by the measured bit-string, the method can exploit the intrinsic discreteness of projective measurement rather than suppressing it. This suggests that Yomo is especially natural for classification settings where a label can be represented as a partition over basis outcomes.

3. Loss design and distribution sharpening

Yomo’s training objective combines three terms: $O_k$4 with $O_k$5 in the reported experiments (Liu et al., 24 Sep 2025).

The cross-entropy term is

$O_k$6

where $O_k$7 is the true label and $O_k$8 is the aggregated probability assigned to the correct class. This is the standard discriminative term, but applied to aggregated Born probabilities rather than to expectation-derived logits.

The probability sharpening term is

$O_k$9

with threshold $$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$0. According to the paper, this term rewards samples whose correct-class probability already exceeds the threshold and pushes confident predictions toward one-hot structure (Liu et al., 24 Sep 2025). The effect is not simply margin enlargement in the classical sense; it explicitly redistributes Born mass so that a single sample from the measurement distribution becomes reliable.

The entropy regularizer is

$$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$1

which penalizes flat output distributions and encourages low-entropy predictions. Together, $$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$2 and $$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$3 act as sharpness-promoting mechanisms. The paper states that these terms shape the Born distribution so that even under a single-shot sampling regime, the correct class carries a large probability mass, thereby mitigating shot noise (Liu et al., 24 Sep 2025).

An ablation reported in the same work supports the functional importance of the sharpening term: removing $$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$4 degrades single-shot test accuracy by approximately $$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$5 percentage points. This indicates that single-shot viability depends not only on the aggregation rule but also on the explicit optimization pressure toward concentrated class-subset mass.

4. Shot-complexity analysis

Appendix C of the paper derives tail bounds for both Vanilla and Yomo inference (Liu et al., 24 Sep 2025). For Vanilla, let $$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$6 denote the gap between the top two infinite-shot logits and let $$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$7 be the Lipschitz constant of the score map $$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$8. Then Theorem 3.2 gives

$$\mu_k=\langle\psi(z,\theta)\,|\,O_k\,|\,\psi(z,\theta)\rangle$$9

so achieving error at most $N$0 requires

$N$1

For Yomo, if each shot returns the correct class with probability $N$2, then majority vote over $N$3 shots satisfies, by Theorem 3.1,

$N$4

and error at most $N$5 is achieved when

$N$6

The comparison isolates the paper’s main theoretical claim: Yomo avoids the $N$7 blowup that characterizes expectation-based models because its controlling quantity is the training-shaped success probability $N$8, which the authors describe as not degrading with system size in the same way (Liu et al., 24 Sep 2025). The paper also states that Theorems 3.3–3.5 provide conditions under which Yomo strictly outperforms Vanilla at fixed $N$9, fixed $O(1/\sqrt{N})$0, and in the single-shot limit $O(1/\sqrt{N})$1.

This analysis reframes measurement complexity in terms of two different failure modes. In Vanilla, error is driven by concentration of empirical expectation estimates around their true means, and small logit gaps are therefore costly. In Yomo, error is driven by Bernoulli concentration around a per-shot correctness probability exceeding $O(1/\sqrt{N})$2. A plausible implication is that the model’s learnability depends on whether training can produce high subset mass for the correct label more readily than it can produce large and stable expectation gaps.

5. Experimental architecture and empirical results

All experiments in the paper use a hybrid classical–quantum classifier consisting of two convolution–pooling layers and one linear layer as a feature extractor, followed by angle encoding into an $O(1/\sqrt{N})$3-qubit variational circuit with $O(1/\sqrt{N})$4 blocks; each block is a CNOT chain followed by single-qubit $O(1/\sqrt{N})$5 rotations (Liu et al., 24 Sep 2025). Yomo is compared against the Vanilla baseline, which measures a fixed set of $O(1/\sqrt{N})$6 Pauli observables and applies softmax to the estimated expectation values.

The study evaluates shot budgets $O(1/\sqrt{N})$7 up to $O(1/\sqrt{N})$8 via exact state-vector simulation, on MNIST and CIFAR-10, both in 10-class settings with 4 qubits. The principal noiseless results are summarized below.

Setting	Yomo	Vanilla
MNIST, single-shot accuracy	90.52%	26.59%
CIFAR-10, single-shot accuracy	$O(1/\sqrt{N})$9	$N$0

The paper further reports that Vanilla requires approximately $N$1 shots to reach $N$2 accuracy on MNIST, implying a $N$3 shot-efficiency advantage for Yomo in that setting (Liu et al., 24 Sep 2025). It also states that as $N$4, Yomo still slightly outperforms Vanilla.

The qubit-scaling experiments are particularly important for interpretation. As $N$5 increases from 4 to 12, Vanilla’s single-shot and few-shot performance collapses, which the paper attributes to a shrinking margin $N$6, whereas Yomo remains nearly flat (Liu et al., 24 Sep 2025). This is consistent with the theoretical analysis of shot complexity and suggests that the practical advantage of Yomo may widen in larger systems if expectation gaps continue to deteriorate.

The sensitivity analysis identifies a sharpening threshold peak at $N$7 for single-shot accuracy, with little sensitivity once $N$8. The paper also reports depolarizing-noise simulations using device error rates from Quantinuum H1-1, IBM Pittsburgh, Google Willow, and IonQ Forte. Under all tested noise models and shot budgets $N$9, Vanilla exhibits a “sweet-spot” depth of approximately 10–15 blocks at large $n_q$0 before noise dominates, while Yomo reaches approximately 85–90% MNIST accuracy with $n_q$1 and $n_q$2, then degrades monotonically with depth (Liu et al., 24 Sep 2025). CIFAR-10 follows the same qualitative trend. The source concludes that even in the single-shot regime under real-device noise levels, Yomo matches or exceeds large-$n_q$3 Vanilla performance.

6. Deployment considerations and practical scope

The implementation strategy emphasized in the paper is train-on-classical and deploy-on-quantum. Training requires access to full Born distributions and is therefore carried out with classical state-vector simulators such as TorchQuantum, whereas only inference is executed on quantum hardware (Liu et al., 24 Sep 2025). This division is central to the method’s practicality: the computational burden of distribution-aware training is absorbed by simulation, while the hardware-facing stage exploits the single-shot inference path.

The reported hyperparameters are fixed at $n_q$4, $n_q$5, and $n_q$6, with Adam optimization using learning rate $n_q$7 for MNIST and $n_q$8 for CIFAR-10, batch sizes 128 and 64, and 100 epochs (Liu et al., 24 Sep 2025). The paper advises shallow circuits, noting that Yomo already attains strong accuracy at $n_q$9 and that noisy simulations show no benefit from greater depth. This is aligned with the broader NISQ constraint that decoherence and two-qubit error rates typically dominate before deeper expressivity can be exploited.

The source also discusses hardware connectivity and noise handling. Extra SWAP operations on limited-connectivity superconducting platforms increase noise, whereas ion-trap systems such as Quantinuum and IonQ, with all-to-all connectivity, are described as ideal (Liu et al., 24 Sep 2025). The paper mentions readout-error mitigation and zero-noise extrapolation as possible practical techniques, while adding that Yomo is relatively robust to small systematic readout biases because it relies on majority-vote-style aggregation.

At inference time, the computational overhead is minimal: one circuit execution and a comparison of the measured bit-string with a precomputed lookup table $$P(\phi)=\bigl|\langle\phi\,|\,\psi(z,\theta)\rangle\bigr|^2,\qquad \phi\in\{0,1\}^{n_q}.$$0. The paper contrasts this with expectation-based inference, which must accumulate sufficient statistics to estimate observables. This suggests that Yomo’s practical advantage is not limited to shot count alone but includes a simplified post-processing pipeline.

7. Relation to conventional QML and interpretive issues

Yomo is presented not as a generic replacement for all quantum classifiers, but as a design targeted at the high cost of repeated measurements in expectation-based QML (Liu et al., 24 Sep 2025). Its key distinction is architectural: the model is optimized so that one sample from the measurement distribution is itself predictive, rather than so that an average over many samples converges to a useful statistic.

A common misconception would be to view Yomo as merely a decoding trick applied after standard training. The paper’s formulation indicates otherwise. The probability aggregation mechanism, the partition of basis states into class subsets, and the sharpness-promoting loss terms are jointly responsible for its single-shot behavior (Liu et al., 24 Sep 2025). In particular, the ablation of $$P(\phi)=\bigl|\langle\phi\,|\,\psi(z,\theta)\rangle\bigr|^2,\qquad \phi\in\{0,1\}^{n_q}.$$1 shows that the aggregation rule alone is insufficient to recover the reported one-shot accuracies.

Another potential misunderstanding is that “single-shot” implies deterministic prediction. The method remains probabilistic: a single measurement returns the correct class with some probability $$P(\phi)=\bigl|\langle\phi\,|\,\psi(z,\theta)\rangle\bigr|^2,\qquad \phi\in\{0,1\}^{n_q}.$$2, and the theory explicitly models this through tail bounds for repeated majority vote if more than one shot is available. What changes is the regime of usefulness. In Yomo, a single shot is intended to be operationally sufficient because training concentrates Born weight onto the correct subset.

The broader significance of the work lies in its challenge to the assumption that accurate QML inference must be expectation-based. By showing both theoretically and experimentally that a subset-aggregated, distribution-shaped model can outperform conventional baselines across shot budgets and under depolarizing noise, the paper positions single-shot inference as a viable design objective for near-term quantum classifiers (Liu et al., 24 Sep 2025). A plausible implication is that future QML architectures may increasingly co-design circuit outputs, loss functions, and measurement protocols rather than treating measurement as a fixed readout layer.