- How classic neural networks read data
- Quantum computers can’t read bits
- Embedding classical data into quantum states
- Data loading bottleneck in quantum machine learning
- conclusion
Modern artificial intelligence (AI) and machine learning (ML) rely heavily on processing large amounts of data and learning patterns from it. in general, As the amount of available data increases, the generalization ability of the model increases. However, one of the first major challenges encountered when moving from classical machine learning to quantum machine learning (QML) is that quantum computers cannot directly read classical bits. Before any computation can be performed, data must first be embedded into quantum states (qubits).
It may sound easy at first glance, but it is surprisingly difficult when you actually try it. As the size and complexity of the data increases, the cost of preparing these quantum states can increase exponentially. In fact, there is currently no known universally efficient way to load arbitrary classical data into a quantum system.
In this article, we explore why this problem exists, look at some common quantum data embedding techniques, and finally discuss some modern approaches that researchers are working on to overcome these limitations.
How classic neural networks read data
Neural networks (NNs) are one of the fundamental building blocks of modern machine learning. Much of their success is due to their increased ability to collect, store, and process large amounts of data.
At the heart of a neural network is a mathematical system designed to learn patterns from data. During training, we gradually adjust the internal parameters to capture the relationships that generated the data in the first place. This allows you to perform tasks such as prediction, generation, and classification.
for example:
- Predict future stock prices based on past trends,
- Generate human-like text,
- identify objects in images,
- Or distinguish between different categories of data.
One of the greatest strengths of classical neural networks is their flexibility. You can process different types of data and learn the relationships that exist within the data.
- sequential data → Language, financial time series, audio signals
- spatial data → Images, videos, topographic maps
- Stochastic or noisy data → Sensor measurements, radioactive decay, experimental observations
Although neural networks can process many different types of data, they cannot directly “see” images, audio, or text the way humans can. Internally, everything is finally converted to a numeric vector or tensor before being processed by the network.
for example:
- An image can be represented as a grid of pixel intensity values.
- You can convert sentences to token embeddings
- An audio signal can be represented as a series of amplitudes sampled over time.
To a neural network, these are all simply structured numerical representations.
Quantum computers can’t read bits
Quantum computers are a fundamentally different way of processing information. Instead of manipulating classical bits, we use qubits. quantum bitfollows the principles of quantum mechanics such as superposition and entanglement.
A classical bit is a binary value of 0 or 1.
However, a qubit can exist in a superposition of both states simultaneously. The state of a typical qubit is usually written as:
|ψ⟩ = α |0⟩ + β |1⟩ where α and β are the complex probability amplitudes that satisfy the constraint: |α|² + |β|² = 1.
If any of these concepts are unfamiliar to you, please see my article on quantum computing for beginners here. However, the key ideas in this article are: Quantum computers store information in a completely different way than classical computers.
Since we live in a classical world, most of our data naturally exists as bits stored in classical memory. Quantum processors cannot directly read images, text, or audio waveforms like neural networks running on GPUs. Before performing quantum computation, this classical information must be encoded into qubits. — This task turned out to be much more difficult than I expected.
Embedding classical data into quantum states
Classical information must somehow be transformed into a quantum state. This process is known as Quantum data embedding or Preparation of quantum state. Possible ways to do this are the amplitude, phase, or rotation of the qubit.
Over the years, researchers have proposed multiple approaches to embed classical data into quantum systems. The two most commonly used techniques are:
- Angular based encoding
- amplitude encoding
Each approach comes with its own advantages, limitations, and computational costs.
Angular based encoding
One of the simplest and most widely used approaches for quantum data embedding is: angular encoding (also called) Rotation-based embedding).
In this method, classical features are encoded as rotation angles applied to the qubit using quantum gates such as RX, RY, and RZ that rotate the qubit along the X, Y, and Z axes, respectively.
For example, the classical vector: X = [x₁, x₂, x₃] By rotating different qubits according to the value of each feature, they can be embedded in quantum circuits.
Let’s take a 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 drawbacks of rotation-based encoding is: Poor scalability in terms of number of qubits. In general, you 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 the qubit, amplitude encoding stores information directly in the amplitude of the quantum state. For example, the α and β terms in |ψ⟩ = α |0⟩ + β |1⟩.
for example:
X = [x₁, x₂, x₃, x₄] It can be encoded using log₂(|X|) = 2
A qubit looks like this:
∣ψ(x)⟩= x₁∣00⟩ + x₂∣01⟩ + x₃∣10⟩ + x₄∣11⟩.
This is significantly more compact compared to the rotation-based encoding we looked at earlier.
In fact, this is one of the most attractive ideas in quantum computing because the number of amplitudes increases exponentially with the number of qubits.
for example:
- 2 qubits → 2² = 4 amplitudes
- 10 qubits → 2¹⁰ = 1024 amplitude
- 20 qubits → more than 1 million amplitudes
This means that an n-qubit system can be described with 2ⁿ amplitudes, and the state space grows exponentially.
As a result, amplitude encoding is much more space efficient than rotation-based encoding. Instead of requiring 1 qubit per feature, only approximately log₂(n) qubits are required for n features.
Next, let’s 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’re as skeptical as I am, you may already be thinking:
“This seems too good to be true.”
And you would be right. Although amplitude encoding can represent exponentially more data compared to angular encoding, actually preparing such a quantum state generally requires an exponentially larger amount of operations.
Expression becomes dramatically more compact.
There is usually no loading process.
The following table compares the two encoding methods.
Data loading bottleneck in quantum machine learning
Modern machine learning systems process data at very large scale and with high dimensions. Images can contain millions of pixels, audio signals can span thousands of timesteps, and modern language models work with large embedding vectors.
We considered two basic approaches for embedding classical data into quantum systems. Although amplitude encoding looks attractive in theory because it is exponentially compact, the process of actually preparing such quantum states becomes increasingly difficult as the size of the data increases.
This poses one of the biggest practical bottlenecks in quantum machine learning.
Loading classical information into a quantum system can itself be computationally expensive.
In many cases, the cost of state preparation can partially or completely offset the theoretical benefits promised by quantum algorithms.
This is an important point that is often overlooked in discussions about quantum machine learning. Many research papers pay little attention to the fact that:
Quantum models have the potential to process information in an exponentially large Hilbert space, but before any computation can be done, data must first be efficiently embedded in that space.
And it turns out to be a very difficult problem.
There is currently no known universally efficient method for preparing quantum states for arbitrary classical data. In fact, preparing a fully general quantum state often requires an exponentially large number of quantum operations.
This creates some interesting trade-offs:
- Rotation-based encoding is relatively easy to implement, but is less scalable with the number of qubits.
- Amplitude encoding is very compact, but can be very expensive to prepare.
In other words:
Representation problems and loading problems are not the same thing.
Quantum computers have the potential to represent exponentially large amounts of information, but efficiently loading that information into a quantum system is a fundamentally different challenge.
Furthermore, during the embedding process, important structural relationships present in the original data (such as spatial relationships in images or temporal dependencies in continuous data) may also become difficult to preserve naturally within the quantum representation.
conclusion
Quantum machine learning promises access to an exponentially larger representation space, but classical information must first be efficiently embedded into quantum systems before any computation can take place.
As discussed in this article, this turned out to be much more difficult than it initially appeared. Although methods such as amplitude encoding provide very compact representations, the process of preparing arbitrary quantum states can itself be computationally expensive.
For this reason, quantum data loading has become one of the central practical bottlenecks in modern QML research. Many discussions about quantum machine learning focus on exponentially large Hilbert space forces, with little consideration given to the cost of actually reaching those states. It’s like saying:
“You can make tea at the top of a mountain, but how you get there is another matter.”
Researchers are currently actively investigating new approaches such as learned quantum embeddings, data re-upload techniques, and structure-preserving embeddings to overcome some of these limitations. Even large companies like Google Quantum AI have recently been exploring more efficient embedding and representation strategies for quantum machine learning systems.
Future articles may consider some of these approaches.
Thank you for reading!
Disclaimer:
This article was grammatically refined with the help of Large-Scale Language Models (LLM). All figures in this article were created by the author using GPT and Gemini image generation tools, and quantum schematics were generated using PennyLane.
Version 1.1
