⚛️ quantum physics

Shot-Based Quantum Encoding: A Data-Loading Paradigm for Quantum Neural Networks

This paper introduces Shot-Based Quantum Encoding (SBQE), a novel data-loading paradigm that leverages shot counts as learnable parameters to create a mixed-state representation compatible with non-linear activations, achieving competitive accuracy on benchmark datasets without requiring data-encoding gates while overcoming the depth limitations of current quantum hardware.

Original authors: Basil Kyriacou, Viktoria Patapovich, Maniraman Periyasamy, Alexey Melnikov

Published 2026-04-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Basil Kyriacou, Viktoria Patapovich, Maniraman Periyasamy, Alexey Melnikov

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The Quantum "Traffic Jam"

Imagine you want to send a massive library of books (your data) into a tiny, high-speed library (a quantum computer).

Currently, there are two main ways to do this, and both have big problems:

The "One-by-One" Method (Angle Encoding): You put one book on one shelf. It's easy to do, but if you have 1,000 books, you need 1,000 shelves. You aren't using the library's full potential.
The "Magic Compression" Method (Amplitude Encoding): You try to stuff all 1,000 books into a single, magical box that holds everything. The problem? Building that box requires a machine so complex and fragile that it breaks before you can even finish loading the books. This is the "depth bottleneck"—the circuit is too deep and too noisy for today's computers.

The Result: Quantum computers are stuck. They have huge potential, but we can't get the data inside them fast enough without breaking them.

The New Solution: The "Shot-Based" Strategy

The authors of this paper propose a clever workaround called Shot-Based Quantum Encoding (SBQE).

Instead of trying to build a complex machine to load the data, they change the rules of the game. They stop trying to force the data into the quantum computer's memory and instead use the counting mechanism that already exists.

The Analogy: The "Voting Booth"

Imagine a quantum computer is a voting booth.

Old Way: You try to write a complex, secret code on a single piece of paper and hand it to the judge. The judge has to decipher it, which takes a long time and is prone to errors.
The SBQE Way: You don't write a code. Instead, you have a bag of 1,000 colored marbles (these are your "shots").
- If your data is "Red," you put 900 red marbles and 100 blue marbles in the bag.
- If your data is "Blue," you put 900 blue marbles and 100 red marbles in the bag.

You don't need a complex machine to do this; you just need a human (a classical computer) to sort the marbles. Then, you hand the bag to the quantum computer. The quantum computer doesn't need to "read" a complex code; it just looks at the ratio of colors.

The Magic: The "data" isn't stored in a quantum gate; it's stored in the probability distribution of the marbles. The quantum computer simply processes the mix.

How It Works in Practice

The Setup: Instead of starting every single experiment with the exact same "zero" state, the researchers prepare a small set of simple, easy-to-make starting states (like "all zeros" or "all ones").
The Encoding: For every piece of data (like a picture of a cat), they calculate a recipe. This recipe says: "Run the 'all zeros' experiment 60% of the time, and the 'all ones' experiment 40% of the time."
The Execution: They run the quantum computer thousands of times (shots), following that recipe.
The Result: The final output is a "mixed state." It's like a smoothie made of different fruits. The flavor (the data) is determined by how much of each fruit you put in, not by how you blended it.

Why Is This a Big Deal?

The paper tested this on two famous image datasets: Fashion-MNIST (clothes) and Semeion (handwritten numbers).

The Competition: They compared their new method against the standard "Magic Compression" method and a simple classical computer program.
The Winner: The SBQE method won.
- It was more accurate than the standard quantum method.
- It matched or beat the simple classical computer.
- Crucially: It did this without using any complex data-loading gates. It was faster, less prone to errors, and used the hardware exactly as it is today.

The "Neural Network" Connection

The authors realized something fascinating: Their quantum method is mathematically identical to a Multilayer Perceptron (MLP), which is a standard type of Artificial Intelligence (AI) brain.

In a normal AI, you have layers of neurons that pass numbers to each other.
In SBQE, the "neurons" are the quantum circuits, and the "connections" are the shot counts.
This means they built a Quantum Neural Network where the "weights" (the learning part) are handled by the quantum computer, but the "input" is handled by a simple probability mix.

The Bottom Line

Think of this paper as a new way to load a truck.

Old way: Try to build a super-complex robotic arm to pack the truck perfectly (expensive, breaks easily).
SBQE way: Just tell the driver, "Load 70% of the truck with boxes from the left pile and 30% from the right pile."

By using the "shots" (the number of times you run the experiment) as a data carrier, the authors found a way to bypass the hardware limitations of today's quantum computers. They proved that you don't need perfect, error-free machines to do great machine learning; you just need to be smart about how you count your votes.

In short: They turned a limitation (needing to run experiments many times) into a superpower (using those counts to store data).

1. Problem Statement

The paper addresses a critical bottleneck in Near-Term Quantum Machine Learning (QML): efficient data loading into quantum registers.

Current Limitations: Existing encoding schemes face a trade-off between circuit depth and representational capacity:
- Angle Encoding: Maps features to qubit rotations. It is hardware-friendly (shallow circuits) but scales linearly with qubit count, failing to utilize the exponential Hilbert space.
- Amplitude Encoding: Compresses $2^n$ features into $n$ qubits. While it maximizes capacity, exact state preparation requires $O(2^n)$ gates, exceeding the coherence budgets and fidelity limits of current Noisy Intermediate-Scale Quantum (NISQ) hardware.
The Challenge: How to load classical data into a quantum system without incurring deep circuits that introduce excessive noise, while still leveraging the exponential dimensionality of the quantum state space.

2. Methodology: Shot-Based Quantum Encoding (SBQE)

The authors propose Shot-Based Quantum Encoding (SBQE), a paradigm that shifts the encoding workload from coherent quantum gates to the classical control layer managing circuit repetitions ("shots").

Core Concept: Instead of preparing a single pure state for a data point, SBQE treats the data as a classical probability distribution over a fixed set of easily preparable initial quantum states (e.g., computational basis states $|0\rangle, |1\rangle, |+\rangle, |-\rangle$ ).
Mechanism:
1. Classical Pre-processing: A data point $x$ is mapped to a probability vector $p(x) = (p_1, \dots, p_n)$ where $\sum p_j = 1$ .
2. Shot Allocation: For a total shot budget $N_{tot}$ , the system draws integer counts $N_j$ from a multinomial distribution $Multinomial(N_{tot}, p(x))$ .
3. Execution: The quantum circuit is executed $N_j$ times starting from the $j$ -th initial state $|\psi_j\rangle$ .
4. Result: The effective input to the variational circuit is a mixed state (density matrix):
  $\rho(x) = \sum_{j} p_j(x) |\psi_j\rangle\langle\psi_j|$
Linearity and Composition: The expectation values of observables are linear in the classical probabilities $p_j(x)$ . This allows the quantum layer to be composed with non-linear classical activation functions, enabling deep architectures.
Multilayer Architecture: The output of one layer (a probability vector) can serve as the input distribution for the next layer. The authors define a specific activation function (a "log-ReLU cascade") that preserves the probability vector structure, allowing for stacked "quantum perceptrons" where all trainable weights reside in the quantum circuit parameters.

3. Key Contributions

Novel Encoding Paradigm: SBQE bypasses the need for data-encoding gates entirely. It utilizes "shots" (a resource already abundant in NISQ experiments) as a learnable degree of freedom.
Structural Equivalence to MLPs: The authors prove that SBQE is structurally equivalent to a Multilayer Perceptron (MLP) where the weight matrices are realized by quantum circuits. This bridges the gap between classical deep learning theory and variational quantum algorithms.
Hardware Compatibility: By eliminating encoding gates, SBQE significantly reduces circuit depth, making it compatible with current NISQ devices (approx. 100-gate error budgets) and reducing coherent error accumulation.
Linear Separability: Unlike angle-encoding VQCs, which produce truncated Fourier series and struggle with linear decision boundaries, SBQE (encoding via probabilities) is not restricted to periodic functions and can easily separate linearly separable data.

4. Experimental Results

The authors benchmarked SBQE on two image classification tasks: Semeion (handwritten digits) and Fashion-MNIST. The models used 8 qubits and 4 variational layers.

Semeion Dataset:
- SBQE Accuracy: $89.1\% \pm 0.9\%$ .
- Comparison: Outperformed Amplitude Encoding by a 5.3% relative error reduction. It matched the performance of a width-matched classical MLP ( $89.6\% \pm 1.3\%$ ) within statistical noise.
Fashion-MNIST Dataset:
- SBQE Accuracy: $80.95\% \pm 0.10\%$ .
- Comparison: Outperformed Amplitude Encoding by 2.0% and a linear MLP by 1.3%.
Statistical Significance: Paired t-tests confirmed SBQE is significantly better than amplitude encoding ( $p < 0.01$ ) on both datasets.
Efficiency: All results were achieved with zero data-encoding gates, staying well within NISQ depth constraints.

5. Significance and Implications

Resource Re-allocation: The paper demonstrates that the "shot degree of freedom," often viewed merely as a statistical necessity for measurement precision, is a powerful channel for data encoding.
Scalability: SBQE offers logarithmic scaling of qubits with feature count (similar to amplitude encoding) but without the exponential circuit depth penalty. For example, 784 image pixels can be encoded into a 10-qubit register without encoding gates.
Future Directions: The authors suggest that SBQE is well-suited for high-dimensional inputs and can be combined with error mitigation techniques (like classical shadows) and noise-induced regularization.
Limitations: The approach requires a sufficiently large shot budget to distinguish probability distributions (variance issues) and relies on a pre-processing step to map data to probability vectors, which currently requires heuristic selection.

Conclusion: SBQE represents a practical shift in QML architecture, proving that probabilistic shot allocation can outperform traditional gate-heavy encoding methods on current hardware, effectively unifying the expressivity of quantum circuits with the efficiency of classical probabilistic modeling.