A Hidden Bottleneck in Quantum Machine Learning: Finding Data in a Quantum Computer

• How Classical Neural Networks Learn Data
• Quantum computers cannot read bits
• Embedding Classical Data in Quantum States
• Data Loading Bottleneck in Quantum Machine Learning
• The conclusion

Modern Artificial Intelligence (AI) and Machine Learning (ML) rely heavily on processing big data and learning patterns from it. Usually, a the ability of the model to generalize improves as the amount of available data increases. However, when moving from classical machine learning to Quantum Machine Learning (QML), one of the first major challenges we face is that quantum computers cannot directly learn classical bits. Before any computation can take place, the data must be embedded in quantum states (qubits).

This may sound easy at first, but in practice it is surprisingly difficult. As the size and complexity of data increases, the cost of preparing these quantum states can increase significantly. In fact, no universally efficient method for loading arbitrary classical data into quantum systems is currently known.

In this article, we will explore why this problem exists, look at some common methods of embedding quantum data, and finally discuss a few modern methods that researchers are investigating to overcome these limitations.

How Classical Neural Networks Learn Data

Neural Networks (NNs) are one of the modern building blocks of Machine Learning. Much of their success comes from our growing ability to collect, store, and process large amounts of data.

At their core, neural networks are statistical systems designed to learn patterns in data. During training, they gradually adjust their internal parameters to capture the relationships that generated the data in the first place. This allows them to perform tasks such as predicting, generating, and classifying.

For example:

• predicting future stock prices from historical trends,
• to produce human-like text,
• to identify objects in pictures,
• or distinguishing between different categories of data.

One of the great strengths of neural networks is their flexibility. They can process many different types of data and learn the relationships between them:

• Sequential data → language, financial time series, audio signals
• Location data → photos, videos, location maps
• Potential or noisy data → sensor measurements, radioactive decay, experimental observations

Despite being able to handle many different types of data, neural networks do not directly “see” images, sound, or text the way humans do. Under the hood, everything is finally converted into numeric vectors or tensors before being processed by the network.

For example:

• An image can be represented as a grid of pixel intensity values
• A sentence can be converted into an embedding of tokens
• An audio signal can be represented as a sequence of amplitudes sampled over time

In a neural network, all of these are simply representations of programmed numbers.

Quantum computers cannot read bits

Quantum computers are a very different way of processing information. Instead of working on classical bits, they use quantum bits, or qubitswhich follows the principles of quantum mechanics such as superposition and entanglement.

A primitive bit is a binary value that can be either 0 or 1.

A qubit, however, can exist in the upper region of both states at the same time. A typical qubit state is often written as:

|ψ⟩ = α |0⟩ + β |1⟩ where α and β are complex probabilities of satisfying amplitudes: |α|² + |β|² = 1.

If some of these ideas sound strange, you can check out my beginner-friendly computing articles here. However, in this article, the important idea is that quantum computers store information in a very different way from classical computers.

Since we live in a primitive world, most of our data naturally exists as bits stored in primitive memory. A quantum processor cannot directly read an image, a sentence, or a sound wave the way a neural network works on a GPU. Before any quantum computation can take place, this primitive information must be encoded into qubits – a task that seems more difficult than it sounds.

Embedding Classical Data in Quantum States

Primitive information must somehow be translated into quantum states. This process is known as embedding quantum data or quantum state correction. Possible ways to do this are the amplitudes, phases, or rotations of the qubits.
Over the years, researchers have proposed many ways to embed classical data into quantum systems. The two most commonly used methods are:

• Angular based encoding
• Amplitude encoding

Each method comes with its own advantages, limitations, and computational costs.

Angular based encoding

One of the simplest and most widely used methods of embedding quantum data is this angle text (also called embedding based on rotation).

In this method, primitives are encoded as rotation angles applied to qubits using quantum gates such as RX, RY and RZ that rotate the qubit on the X, Y, and Z axes respectively.
For example, the classic vector: X = [x₁, x₂, x₃] it can be embedded in a quantum circuit by rotating different qubits according to the value of each element.

Let's look at a simple implementation of spin-based encoding in PennyLane:

import pennylane as qml
import numpy as np

# Classical input vector
x = np.array([0.2, 0.7, 1.1])

n_qubits = len(x)
dev = qml.device("default.qubit", wires=n_qubits)

@qml.qnode(dev)
def rotational_embedding_circuit(x):
    # Each feature x_i rotates one qubit
    qml.AngleEmbedding(
        features=x,
        wires=range(n_qubits),
        rotation="Y"   # can also be "X" or "Z"
    )

    return qml.state()

state = rotational_embedding_circuit(x)

qml.draw_mpl(rotational_embedding_circuit, style='pennylane_sketch')(x)
print(state)

One of the main disadvantages of rotation-based encoding is its negative decrease with respect to the number of qubits. In general, we need as many qubits as there are elements in the input vector.

Amplitude-based encoding

Amplitude-based encoding is another way to embed classical data in quantum systems. Unlike rotation-based encoding, where each element controls the rotation of a qubit, amplitude encoding stores information directly on the amplitudes of the quantum state, for example, the terms α and β in |ψ⟩ = α |0⟩ + β |1⟩.

For example:

X = [x₁, x₂, x₃, x₄] can be coded using log₂(|X|) = 2

qubits like this:

∣ψ(x)⟩= x₁∣00⟩ + x₂∣01⟩ + x₃∣10⟩ + x₄∣11⟩.

This is very compact compared to the rotation-based encoding we saw earlier.

In fact, this is one of the most interesting ideas in quantum computing because the number of amplitudes increases continuously with the number of qubits.

For example:

• 2 qubits → 2² = 4 amplitudes
• 10 qubits → 2¹⁰ = 1024 amplitudes
• 20 qubits → more than a million amplitudes

This means that the n-qubit system is defined by 2ⁿ amplitudes, resulting in a significantly larger state space.

As a result, amplitude encoding is more spatially efficient than rotation-based encoding. Instead of needing one qubit per element, it only needs approximately: log₂(n) qubits for n elements.

Now let's look at a simple implementation of the amplitude script in PennyLane:

import pennylane as qml
import numpy as np

# Classical input vector
x = np.array([0.2, 0.4, 0.6, 0.8])

# Amplitude encoding needs a normalized vector
x = x / np.linalg.norm(x)

# Number of qubits needed:
# 2 qubits can represent 2^2 = 4 amplitudes
n_qubits = int(np.log2(len(x)))

dev = qml.device("default.qubit", wires=n_qubits)

@qml.qnode(dev)
def amplitude_encoding_circuit(x):
    qml.AmplitudeEmbedding(
        features=x,
        wires=range(n_qubits),
        normalize=True
    )

    return qml.state()

state = amplitude_encoding_circuit(x)

qml.draw_mpl(amplitude_encoding_circuit, style='pennylane_sketch')(x)
print(state)

If you're suspicious like me, you're probably already thinking:

“This seems too good to be true.”

And you would be right. Although the amplitude encoding allows us to represent more data more clearly compared to the angle encoding, actually preparing those quantum states usually requires a much larger number of operations.

The presentation is incredibly cohesive.
The loading process is usually non-existent.

The following table compares the two encoding methods:

Data Loading Bottleneck in Quantum Machine Learning

Modern Machine Learning Systems work with very large and high-dimensional data. Images can contain millions of pixels, audio signals can span thousands of times, and modern language models operate on large embedding vectors.

We looked at two important ways of embedding classical data in quantum systems. While amplitude encoding seems attractive in theory due to its defined coherence, the process of preparing such quantum states becomes more difficult as the data size increases.

This creates one of the biggest bottlenecks in Quantum machine learning:

Loading primitive information into a quantum system can be computationally expensive.

In many cases, the cost of state correction can partially or completely offset the theoretical benefits promised by quantum algorithms.

This is an important trick that is often overlooked in discussions about Quantum Machine Learning. Most research papers pay little attention to the fact that:

A quantum model can process information in a remarkably large Hilbert space, but before any computation can take place, the data must be effectively embedded in that space.

And that turns into a very difficult problem.

For non-classical data, no universally efficient method for preparing the quantum state is currently known. In fact, fixing a normal quantum state usually requires a very large number of quantum operations.

This creates an interesting trade-off:

• Rotation-based encoding is easy to use but approximates poorly with qubit computation.
• Amplitude encoding is more compact but can be more expensive to configure.

In other words:

Representation problem and loading problem are not the same thing.

A quantum computer may be able to represent large amounts of information, but successfully loading that information into a quantum system is an entirely different challenge.

In addition, during the embedding process, important structural relationships present in real data – such as spatial relationships in images or temporal dependencies in sequential data – may be difficult to preserve naturally in the value representation.

The conclusion

Quantum Machine Learning promises access to very large representation spaces, but before any computation can take place, primitive knowledge must be properly embedded in quantum systems.

As we have explored in this article, this seems more difficult than it seems at first. While methods such as amplitude encoding provide extremely compact representations, the process of randomly configuring quantum states can itself be very expensive.

This has made quantum data loading one of the most pressing issues in modern QML research. Most discussions around Quantum Machine Learning focus a lot on the power of large Hilbert spaces while paying very little attention to the cost of reaching those states – roughly like:

“We can make tea at the top of the mountain, but how we get there is another problem.”

Researchers are now actively exploring new methods such as quantum learned embedding, data reloading techniques, and structure-preserving embedding to overcome some of these limitations. Even large companies like Google Quantum AI have recently explored more efficient techniques for embedding and representing quantum machine learning systems.

We may explore some of these methods in future articles.

Thanks for reading!

Disclaimer:

This topic was systematically refined with the help of large language models (LLMs). All diagrams in this article were created by the author using the GPT and Gemini image generation tools, while the quantum circuit diagrams were created using PennyLane.

Version 1.1