The Hidden Bottleneck in Quantum Machine Learning: Getting Data into a Quantum Computer - Towards Data Science

• How Classical Neural Networks Read Data
• Quantum Computers Can’t Read Bits
• Embedding Classical Data into Quantum States
• The Data Loading Bottleneck in Quantum Machine Learning
• Conclusion

Modern Artificial Intelligence (AI) and Machine Learning (ML) rely heavily on processing large volumes of data and learning patterns from them. In general, a model’s ability to generalise improves as the amount of available data increases. However, when we move from classical machine learning to Quantum Machine Learning (QML), one of the first major challenges we encounter is that quantum computers cannot directly read classical bits. Before any computation can happen, the data must first be embedded into quantum states (qubits).

This may sound simple at first, but in practice it is surprisingly difficult. As the size and complexity of the data increase, the cost of preparing these quantum states can grow exponentially. 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 quantum data embedding techniques, and finally discuss a few modern approaches researchers are investigating to overcome these limitations.

How Classical Neural Networks Read Data

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

At their core, neural networks are mathematical systems designed to learn patterns from 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 prediction, generation, and classification.

For example:

• predicting future stock prices from historical trends,
• generating human-like text,
• identifying objects in images,
• or distinguishing between different categories of data.

One of the biggest strengths of classical neural networks is their flexibility. They can process many different types of data and learn the relationships that exist within them:

• Sequential data → language, financial time series, audio signals
• Spatial data → images, videos, geographical maps
• Probabilistic 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, audio, or text the way humans do. Under the hood, everything is ultimately converted into numerical 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 token embeddings
• An audio signal can be represented as a sequence of amplitudes sampled over time

To a neural network, all of these are simply structured numerical representations.

Quantum Computers Can’t Read Bits

Quantum computers are a fundamentally different way of processing information. Instead of operating on classical bits, they use quantum bits, or qubits, which follow the principles of quantum mechanics such as superposition and entanglement.

A classical bit is a binary value which is either 0 or 1.

A qubit, however, can exist in a superposition of both states simultaneously. A general qubit state is typically written as:

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

If some of these concepts feel unfamiliar, you can refer to my beginner-friendly quantum computing articles here. For this article, however, the important idea is simply that quantum computers store information very differently from classical computers.

Since we live in a classical world, most of our data naturally exists as bits stored in classical memory. A quantum processor cannot directly read an image, a sentence, or an audio waveform the way a neural network running on a GPU can. Before any quantum computation can happen, this classical information must be encoded into qubits — a task that turns out to be far more difficult than it sounds.

Embedding Classical Data into Quantum States

Classical information must somehow be translated into quantum states. This process is known as quantum data embedding or quantum state preparation. Possible ways to do this are amplitudes, phases, or rotations of qubits.
Over the years, researchers have proposed multiple approaches for embedding classical data into quantum systems. Two of the most commonly used techniques are:

• Angle-based encoding
• Amplitude encoding

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

Angle-based encoding

One of the simplest and most widely used approaches for quantum data embedding is angle encoding (also called rotation-based embedding).

In this method, classical features are encoded as rotation angles applied to qubits using quantum gates such as ​R-X, R-Y and R-Z which rotate a qubit along the X, Y, and Z axes respectively.
For example, a classical vector: X = [x₁, x₂, x₃] can be embedded into a quantum circuit by rotating different qubits according to the value of each feature.

Let’s look at a simple implementation of rotation-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 poor scalability with respect to the number of qubits. In general, we need as many qubits as there are features in the input vector.

Amplitude-based Encoding

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

For example:

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

qubits as:

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

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

In fact, this is one of the most fascinating ideas in quantum computing because the number of amplitudes grows exponentially with the number of qubits.

For example:

• 2 qubits → 2² = 4 amplitudes
• 10 qubits → 2¹⁰ = 1024 amplitudes
• 20 qubits → over one million amplitudes

This means that an n-qubit system is described by 2ⁿ amplitudes, leading to an exponentially growing state space.

As a result, amplitude encoding is exponentially more space-efficient than rotation-based encoding. Instead of requiring one qubit per feature, it only requires approximately: log₂(n) qubits for n features.

Let’s now look at a simple implementation of amplitude encoding 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 are as suspicious as I am, you might already be thinking:

“This looks too good to be true.”

And you would be right. While amplitude encoding allows us to represent exponentially more data compared to angle encoding, actually preparing such quantum states generally requires an exponentially large number of operations.

The representation is exponentially compact.
The loading process usually is not.

The following table compares the two encoding approaches:

The Data Loading Bottleneck in Quantum Machine Learning

Modern Machine Learning systems work with extremely large and high-dimensional data. Images may contain millions of pixels, audio signals can span thousands of timesteps, and modern language models operate on massive embedding vectors.

We looked at two fundamental approaches for embedding classical data into quantum systems. While amplitude encoding appears theoretically attractive because of its exponential compactness, the process of actually preparing such quantum states becomes increasingly difficult as the size of the data grows.

This creates one of the biggest practical bottlenecks in Quantum Machine Learning:

Loading classical information into a quantum system can itself become computationally expensive.

In many cases, the cost of state preparation may partially or completely offset the theoretical advantages promised by quantum algorithms.

This is an important subtlety that is often overlooked in discussions around Quantum Machine Learning. Many research papers give very little attention to the fact that:

A quantum model may process information in an exponentially large Hilbert space, but before any computation can happen, the data must first be embedded into that space efficiently.

And that turns out to be an extremely difficult problem.

For arbitrary classical data, no universally efficient quantum state preparation method is currently known. In fact, preparing a completely general quantum state often requires an exponentially large number of quantum operations.

This creates a fascinating tradeoff:

• Rotation-based encoding is relatively easy to implement but scales poorly with qubit count.
• Amplitude encoding is exponentially compact but can be exponentially expensive to prepare.

In other words:

The representation problem and the loading problem are not the same thing.

A quantum computer may be capable of representing exponentially large amounts of information, but efficiently loading that information into the quantum system is a fundamentally different challenge altogether.

Furthermore, during the embedding process, important structural relationships present in the original data — such as spatial relationships in images or temporal dependencies in sequential data — may also become difficult to preserve naturally inside quantum representations.

Conclusion

Quantum Machine Learning promises access to exponentially large representational spaces, but before any computation can happen, classical information must first be embedded into quantum systems efficiently.

As we explored in this article, this turns out to be far more difficult than it initially appears. While methods such as amplitude encoding offer extremely compact representations, the process of preparing arbitrary quantum states itself can become computationally expensive.

This has made quantum data loading one of the central practical bottlenecks in modern QML research. Many discussions around Quantum Machine Learning focus heavily on the power of exponentially large Hilbert spaces while giving far less attention to the cost of actually reaching those states — almost like saying:

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

Researchers are now actively exploring newer approaches such as learned quantum embeddings, data re-uploading techniques, and structure-preserving embeddings to overcome some of these limitations. Even large companies such as Google Quantum AI have recently explored more efficient embedding and representation strategies for quantum machine learning systems.

We may explore some of these approaches in future articles.

Thank you for reading!

Disclaimer:

This article was grammatically refined with the assistance of Large Language Models (LLMs). All illustrations in this article were created by the author using GPT and Gemini image-generation tools, while quantum circuit diagrams were generated using PennyLane.

Version 1.1