Comparing Three Quantum Data Encoding Methods for Effective QML Models

Underlying Logic of Quantum Encoding

Quantum circuits operate on quantum states rather than classical vectors, so raw numeric lists cannot be fed directly. Data must first be encoded into quantum states that can exhibit superposition and entanglement, forming a bridge between classical datasets and quantum computing environments.

Angle Encoding: Direct Mapping

Angle encoding maps each feature value to a rotation angle applied to a corresponding qubit, typically using the RY gate because it rotates the qubit around the Y‑axis on the Bloch sphere.

For a feature vector x = [x₁, x₂, …, x], the encoding proceeds as:

First qubit: RY(x₁)|0⟩ → cos(x₁/2)|0⟩ + sin(x₁/2)|1⟩ Second qubit: RY(x₂)|0⟩ → cos(x₂/2)|0⟩ + sin(x₂/2)|1⟩, and so on.

The rotation angle directly controls the qubit’s position on the Bloch sphere: 0 keeps it in |0⟩, π/2 creates an equal superposition (|0⟩+|1⟩)/√2, and π flips it to |1⟩. This geometric interpretation makes angle encoding easy to understand.

Qiskit implementation:

from qiskit import QuantumCircuit
import numpy as np

class AngleEncoder:
    def __init__(self, num_features):
        self.num_features = num_features

    def encode(self, features):
        """Encode a single feature vector into a quantum circuit."""
        qc = QuantumCircuit(self.num_features)
        for i, x in enumerate(features):
            qc.ry(x, i)
        return qc

Batch encoding simply iterates over the dataset:

def batch_encode(encoder, data):
    circuits = []
    for features in data:
        circuits.append(encoder.encode(features))
    return circuits

Visualization of the resulting quantum state can be done with Qiskit’s Bloch‑sphere plot:

from qiskit.visualization import plot_bloch_multivector
from qiskit.quantum_info import Statevector

features = [np.pi/4, np.pi/2]
qc = AngleEncoder(len(features)).encode(features)
state = Statevector.from_instruction(qc)
plot_bloch_multivector(state)

Advantages: straightforward, works for any continuous data, and requires only one qubit per feature. Limitations: each qubit encodes a single feature, so interactions between features are not naturally captured, and high‑dimensional data demands many qubits.

Amplitude Encoding: Quantum Advantage

Amplitude encoding compresses an entire feature vector into the amplitudes of a quantum state, achieving exponential data density. For a vector x = [x₁, x₂, x₃, x₄], the resulting state is

|ψ⟩ = α₁|00⟩ + α₂|01⟩ + α₃|10⟩ + α₄|11⟩

, where each αᵢ is a normalized feature value.

Only log₂(n) qubits are needed for n features; e.g., 256 features fit into 8 qubits, whereas angle encoding would need 256 qubits.

The encoding must satisfy Σ|αᵢ|² = 1, so the feature vector must be L2‑normalized. Negative feature values require additional handling because quantum amplitudes are complex; many practical implementations restrict to real, non‑negative amplitudes.

Amplitude encoding also increases circuit depth because preparing an arbitrary amplitude state involves controlled rotations, controlled‑NOT gates, and possibly ancillary qubits. The depth grows logarithmically with the number of features, making implementation more complex.

Qiskit implementation using the initialize method:

from qiskit import QuantumCircuit

class AmplitudeEncoder:
    def __init__(self, num_qubits):
        self.num_qubits = num_qubits

    def encode(self, features):
        """Encode normalized feature vector into quantum circuit."""
        qc = QuantumCircuit(self.num_qubits)
        qc.initialize(features, qc.qubits)
        return qc

Handling arbitrary‑length vectors requires normalization, padding to the nearest power of two, and then encoding:

def encode_vector(vector):
    vec = normalize(vector)
    num_qubits = int(np.ceil(np.log2(len(vec))))
    # Pad vector to length 2**num_qubits
    pad_len = 2**num_qubits - len(vec)
    padded = np.append(vec, [0]*pad_len)
    return AmplitudeEncoder(num_qubits).encode(padded)

Basis Encoding: Simple Discrete Representation

Basis encoding maps categorical data directly to computational basis states |0⟩ and |1⟩. Each class is represented by a binary string, which is then prepared on the qubits using X gates for bits equal to 1.

For example, with three qubits the four basis states |00⟩, |01⟩, |10⟩, |11⟩ can encode four distinct categories. An integer label is converted to a binary string and each ‘1’ flips the corresponding qubit.

Qiskit implementation:

class BasisEncoder:
    def __init__(self, num_qubits):
        self.num_qubits = num_qubits

    def encode(self, binary_string):
        """Prepare qubits in basis state from a binary string."""
        qc = QuantumCircuit(self.num_qubits)
        for i, bit in enumerate(binary_string):
            if bit == "1":
                qc.x(i)  # Apply X gate to flip |0⟩ → |1⟩
        return qc

def int_to_basis(n, num_qubits):
    return format(n, f"0{num_qubits}b")

encoder = BasisEncoder(3)
qc = encoder.encode(int_to_basis(5, 3))  # Encodes integer 5 as |101⟩

Basis encoding is efficient for discrete categories because only log₂(n) qubits are needed for n classes. However, it scales poorly for continuous or high‑dimensional data, as each feature would require its own qubit.

How to Choose an Encoding Method

The appropriate encoding depends on the data characteristics and hardware constraints:

If you are learning quantum machine learning basics, your features are relatively independent, and you need simple circuits on NISQ devices, start with angle encoding.

If you have high‑dimensional continuous data where feature correlations matter and you can tolerate deeper circuits, amplitude encoding offers the best quantum advantage.

If your data is categorical or discrete and you require minimal circuit depth and perfect interpretability, basis encoding is ideal.

Choosing the right encoding fundamentally defines what the quantum model can learn; a poor choice can cause even sophisticated quantum algorithms to underperform compared to classical baselines.