First time studying this topic?

Launch the interactive walkthrough to discover each component, including the 3D Q-Sphere Lab & Python in Colab.

Back to Quantum Machine Learning
Topic 8.4

Classical Data Encoding: Basis, Angle & Amplitude Embedding

Master the three primary strategies to load classical numbers into quantum registers: Basis Encoding, Angle Encoding, and Amplitude Encoding.

Learning Objectives

  • βœ“Implement Basis Encoding (mapping binary strings to basis states)
  • βœ“Implement Angle Encoding (mapping continuous features to rotation angles)
  • βœ“Implement Amplitude Encoding (packing 2^n features into n qubits)
  • βœ“Analyze the tradeoffs: qubit count vs circuit depth

πŸ“–Let's Begin with a Story

You have a spreadsheet containing customer data: age 35, income 80,000,creditscore720.Howdoyouloadthosethreenumbersintoaquantumcomputer?YoucannotplugaUSBdriveintoadilutionrefrigerator.Youmusttranslatethoseclassicalnumbersintophysicalquantumgateoperations!Therearethreefundamentalstrategies:1.βˆ—βˆ—BasisEncodingβˆ—βˆ—:SpellthenumbersoutinbinaryusingXgates(simple,butuseslotsofqubits).2.βˆ—βˆ—AngleEncodingβˆ—βˆ—:Turnthenumbersintorotationangles(likespinningaknobto35degrees).3.βˆ—βˆ—AmplitudeEncodingβˆ—βˆ—:Theultimatecompressiontrickβ€”packing80,000, credit score 720. How do you load those three numbers into a quantum computer? You cannot plug a USB drive into a dilution refrigerator. You must translate those classical numbers into physical quantum gate operations! There are three fundamental strategies: 1. **Basis Encoding**: Spell the numbers out in binary using X gates (simple, but uses lots of qubits). 2. **Angle Encoding**: Turn the numbers into rotation angles (like spinning a knob to 35 degrees). 3. **Amplitude Encoding**: The ultimate compression trickβ€”packing2^nnumbersintotheprobabilityamplitudesofjustnumbers into the probability amplitudes of justn$ qubits! Choosing the right encoding strategy is the very first architectural decision of every QML pipeline.

Why Should You Learn Classical Data Encoding: Basis, Angle & Amplitude Embedding?

🎯 Practical & Engineering Stakes

The input bottleneck

If your encoding scheme requires an exponential number of gates, your quantum speedup is destroyed before the algorithm even begins. Mastering encoding trade-offs is essential for practical QML engineering.

What Is It?

Simple Explanation

Three ways to load data into qubits: 1. Basis Encoding: Write numbers in binary using 0s and 1s (∣0110⟩|0110\rangle). 2. Angle Encoding: Use numbers as steering angles (rotate qubit by xx degrees). 3. Amplitude Encoding: Compress numbers into the height of the quantum waves! (Pack 1,024 numbers into just 10 qubits!).

Technical Explanation

Classical data encoding maps instance x∈Rd\mathbf{x} \in \mathbb{R}^d into state vector ∣ψ(x)⟩∈H|\psi(\mathbf{x})\rangle \in \mathcal{H}: - Basis Encoding: x∈{0,1}dβ†¦βˆ£x⟩x \in \{0, 1\}^d \mapsto |x\rangle. Requires dd qubits, O(d)\mathcal{O}(d) depth. - Angle Encoding: x∈Rd↦⨂j=1d[cos⁑(xj)∣0⟩+sin⁑(xj)∣1⟩]x \in \mathbb{R}^d \mapsto \bigotimes_{j=1}^d [\cos(x_j)|0\rangle + \sin(x_j)|1\rangle]. Requires dd qubits, O(1)\mathcal{O}(1) depth. - Amplitude Encoding: x∈RN\mathbf{x} \in \mathbb{R}^N (N=2nN=2^n, βˆ₯xβˆ₯=1\|\mathbf{x}\|=1) β†¦βˆ‘i=0Nβˆ’1xi∣i⟩\mapsto \sum_{i=0}^{N-1} x_i |i\rangle. Requires n=log⁑2(N)n = \log_2(N) qubits, but state preparation circuit depth is generally O(2n)\mathcal{O}(2^n).

πŸ“š Key Terms

Basis Encoding

Simple: Converting classical binary bits directly into qubit states (e.g. 5 = 101 -> |101>).
Technical: Discrete embedding mapping binary vectors x∈{0,1}nx \in \{0, 1\}^n to computational basis kets ∣x⟩|x\rangle.

Angle Encoding

Simple: Using numbers as rotation angles for single-qubit gates.
Technical: Continuous embedding applying single-qubit rotations Ry(2xj)R_y(2x_j) or Rz(2xj)R_z(2x_j) to individual qubits.

Amplitude Encoding

Simple: Packing huge datasets into probability amplitudes (exponential compression).
Technical: Vector embedding normalizing continuous vector x∈R2n\mathbf{x} \in \mathbb{R}^{2^n} directly into state amplitudes.

Q-Sphere Lab: Classical Data Encoding: Basis, Angle & Amplitude Embedding

IBM Q-Sphere Model

Interactive 3D state vector exploration, unitary transformation gates, and Born rule collapse for Topic 8.4

Azimuth: 45Β°Elevation: 25Β°
+Z |0⟩-Z |1⟩+X |+⟩+Y |+i⟩01|ψ⟩
Q-Sphere Phase Color:
0 Ο€/2 Ο€ 3Ο€/2

Quantum Statevector

dim(H) = 2
|ψ⟩ = (1.000 + 0.000i)|0⟩
     + (0.000 + 0.000i)|1⟩
Polar Angle (ΞΈ):0.0Β° (0.000Ο€ rad)
Phase Angle (Ο•):0.0Β° (0.000Ο€ rad)

Born Rule Probabilities: P(x) = |⟨x|ψ⟩|²Σ P = 1.00

P(|0⟩) = |α|²100.0%
P(|1⟩) = |β|²0.0%
Quantum Measurement

Apply Single-Qubit Unitary Gates

Presets:
Continuous Polar Angle θ (0° = |0⟩, 180° = |1⟩):0.0°
Continuous Phase Angle Ο• (0Β° to 360Β°):0.0Β°
Recent Operations Log:
#1Initial state: |0⟩

πŸ“ Mathematical Foundation

LaTeX KaTeX
∣xamp⟩=βˆ‘i=02nβˆ’1xiβˆ₯xβˆ₯2∣i⟩,∣xangle⟩=⨂j=1d(cos⁑(xj)∣0⟩+sin⁑(xj)∣1⟩)|\mathbf{x}_{\text{amp}}\rangle = \sum_{i=0}^{2^n-1} \frac{x_i}{\|\mathbf{x}\|_2} |i\rangle, \quad |\mathbf{x}_{\text{angle}}\rangle = \bigotimes_{j=1}^d \Big( \cos(x_j)|0\rangle + \sin(x_j)|1\rangle \Big)

What does it mean?

Amplitude Encoding vs Angle Encoding: The two foundational strategies for embedding classical datasets into quantum processors. Amplitude encoding achieves exponential compression by packing 2^n classical features into n qubits, but requires O(2^n) gates to synthesize. Angle encoding maps d features into d separate single-qubit rotations with constant depth O(1), ideal for NISQ processors.

Understanding the Symbols

Symbol / TermMeaningBeginner Interpretation
∣xamp⟩|\mathbf{x}_{\text{amp}}\rangleAmplitude encoded stateSuperposition where amplitudes equal normalized feature values
∣xangle⟩|\mathbf{x}_{\text{angle}}\rangleAngle encoded stateTensor product of independent single-qubit state rotations
βˆ₯xβˆ₯2\|\mathbf{x}\|_2Euclidean L2 norm of feature vectorSquare root of sum of squares, ensuring quantum state normalizes to 1.0
2n2^nFeature capacity of n qubitslog2(N) qubits store N features in amplitude encoding

πŸ“Š Numerical Example

Encoding a 4-dimensional classical sensor reading x = [1.0, 2.0, 2.0, 1.0]^T using Amplitude Encoding on 2 qubits (n = log2 4 = 2):

Step 1: Compute Vector L2 Norm: ||x||_2 = √(1.0Β² + 2.0Β² + 2.0Β² + 1.0Β²) = √(1 + 4 + 4 + 1) = √10 β‰ˆ 3.1623 Step 2: Normalize Feature Vector: x_norm = [1/√10, 2/√10, 2/√10, 1/√10]^T = [0.3162, 0.6325, 0.6325, 0.3162]^T Check: 0.3162Β² + 0.6325Β² + 0.6325Β² + 0.3162Β² = 0.1 + 0.4 + 0.4 + 0.1 = 1.00 Step 3: Construct the 2-Qubit Quantum State: |ψ_amp⟩ = 0.3162∣00⟩|00\rangle + 0.6325∣01⟩|01\rangle + 0.6325∣10⟩|10\rangle + 0.3162∣11⟩|11\rangle Step 4: Measurement Probabilities: P(∣00⟩|00\rangle) = 10%, P(∣01⟩|01\rangle) = 40%, P(∣10⟩|10\rangle) = 40%, P(∣11⟩|11\rangle) = 10%

Result: All 4 continuous features are successfully compressed into a single 2-qubit register with exact normalized amplitudes.

βš™οΈ How Does It Work?

1

Data Normalization

Scale features to [0, pi] for angle encoding, or normalize vector norm to 1.0 for amplitude encoding.

2

Circuit Synthesis

Apply Ry(2*x_i) rotations for angle encoding or multi-controlled Givens rotations for amplitude encoding.

3

QML Hand-off

State |psi(x)> is passed into variational layers.

🌍 Where Is It Used?

Quantum Image Processing

Problem: Loading a 1024x1024 pixel medical scan into quantum memory.

Solution: Flexible Representation of Quantum Images (FRQI) uses amplitude encoding to store 1 million pixels in just 20 qubits.

🎯 Try It Yourself

You have a dataset with 8 continuous features and only 3 qubits available. Which encoding method must you choose to fit all 8 features?

Interactive activity component

🐍 Python Hands-On: Angle Encoding vs Amplitude Encoding in Qiskit

Implement both Angle Encoding (rotation gates) and Amplitude Encoding (statevector isometry) in Qiskit and analyze qubit requirements.

Open Colab

1Install Required Packages

For Google Colab or Jupyter notebooks, run this shell command to install the required dependencies:

Terminal / Notebook Install Commandbash
!pip install qiskit numpy
Packages:
qiskitnumpy

2Import Libraries

Import Statementspython
1from qiskit import QuantumCircuit
2from qiskit.quantum_info import Statevector
3import numpy as np

from qiskit import QuantumCircuit β†’ Circuit builder

from qiskit.quantum_info import Statevector β†’ Statevector module

import numpy as np β†’ Vector normalization

3Demonstration Code & Logic

Python Execution Codepython
1features = [1.2, 0.7, -0.9, 1.8]
2print(f'Original Classical Vector: {features}\n')
3 
4# Strategy 1: Angle Encoding (1 qubit per feature -> 4 qubits)
5qc_angle = QuantumCircuit(4)
6for i, val in enumerate(features):
7    qc_angle.ry(val, i)  # Ry rotation by feature angle
8print('Strategy 1: Angle Encoding (O(N) qubits):')
9print(qc_angle.draw('text'))
10 
11# Strategy 2: Amplitude Encoding (log2(N) qubits -> 2 qubits for 4 features)
12norm = np.linalg.norm(features)
13norm_features = np.array(features) / norm
14qc_amp = QuantumCircuit(2)
15qc_amp.initialize(norm_features, [0, 1])  # Amplitude encoding isometry
16print('\nStrategy 2: Amplitude Encoding (O(log N) qubits):')
17print(f'Normalized Amplitudes in 2 Qubits: {norm_features.round(3)}')
18print(f'Amplitudes verify to exact sum of squares: {np.sum(norm_features**2):.4f}')
Step-by-Step Code Breakdown:

features = [1.2, 0.7, -0.9, 1.8]

4-dimensional classical data vector

print(f'Original Classical Vector: {features}\n')

Print vector

# Strategy 1: Angle Encoding (1 qubit per feature -> 4 qubits)

Angle encoding

qc_angle = QuantumCircuit(4)

4 qubits required

for i, val in enumerate(features):

Encode each feature

qc_angle.ry(val, i) # Ry rotation by feature angle

Apply Ry

print('Strategy 1: Angle Encoding (O(N) qubits):')

Header 1

print(qc_angle.draw('text'))

Draw circuit

# Strategy 2: Amplitude Encoding (log2(N) qubits -> 2 qubits for 4 features)

Amplitude encoding

norm = np.linalg.norm(features)

Compute L2 norm

norm_features = np.array(features) / norm

Normalize to unit vector

qc_amp = QuantumCircuit(2)

2^2 = 4 features fits into 2 qubits!

qc_amp.initialize(norm_features, [0, 1]) # Amplitude encoding isometry

Qiskit initialize

print('\nStrategy 2: Amplitude Encoding (O(log N) qubits):')

Header 2

print(f'Normalized Amplitudes in 2 Qubits: {norm_features.round(3)}')

Print amplitudes

print(f'Amplitudes verify to exact sum of squares: {np.sum(norm_features**2):.4f}')

Sum of squares = 1

πŸ“‹ Complete Script (All-in-One)

Click "Copy for Colab", open Google Colab, paste into a single cell, and run.

Google Colab Notebook Scriptpython
1# =========================================================
2# Angle Encoding vs Amplitude Encoding in Qiskit
3# Prepared for Google Colab (Run with Shift + Enter)
4# =========================================================
5 
6# Step 1: Install required packages
7!pip install qiskit numpy
8 
9# Step 2: Import libraries
10from qiskit import QuantumCircuit
11from qiskit.quantum_info import Statevector
12import numpy as np
13 
14# Step 3: Run Demonstration
15features = [1.2, 0.7, -0.9, 1.8]
16print(f'Original Classical Vector: {features}\n')
17 
18# Strategy 1: Angle Encoding (1 qubit per feature -> 4 qubits)
19qc_angle = QuantumCircuit(4)
20for i, val in enumerate(features):
21    qc_angle.ry(val, i)  # Ry rotation by feature angle
22print('Strategy 1: Angle Encoding (O(N) qubits):')
23print(qc_angle.draw('text'))
24 
25# Strategy 2: Amplitude Encoding (log2(N) qubits -> 2 qubits for 4 features)
26norm = np.linalg.norm(features)
27norm_features = np.array(features) / norm
28qc_amp = QuantumCircuit(2)
29qc_amp.initialize(norm_features, [0, 1])  # Amplitude encoding isometry
30print('\nStrategy 2: Amplitude Encoding (O(log N) qubits):')
31print(f'Normalized Amplitudes in 2 Qubits: {norm_features.round(3)}')
32print(f'Amplitudes verify to exact sum of squares: {np.sum(norm_features**2):.4f}')
⚑ How to Run in Google Colab (3 Quick Steps)
  1. Click "Copy for Google Colab" above.
  2. Click Open New Google Colab Notebook (opens in a new tab).
  3. Click on the first empty code cell, press Ctrl + V (or Cmd + V) to paste, then press Shift + Enter to execute!
Launch Blank Colab Notebook

πŸ”„ Algorithmic Execution Flow

1
Angle Encoding Method

Map each feature value directly to a single-qubit rotation angle (Ry) requiring N qubits.

β†’
2
Amplitude Encoding Method

Normalize the vector and encode N features into the 2^n amplitudes of only log2(N) qubits.

β†’
3
Trade-off Analysis

Angle encoding uses shallow depth but O(N) qubits; Amplitude encoding achieves exponential compression O(log N) but requires deeper state preparation unitaries.

πŸ“₯ Input / Initial State
4-element classical feature vector [1.2, 0.7, -0.9, 1.8].
πŸ“€ Expected Output
Angle Encoding: Uses 4 qubits with individual Ry gates.
Amplitude Encoding: Compresses all 4 features into only 2 qubits ([0.495, 0.289, -0.371, 0.742]).
πŸ’‘ What Does This Demonstration Show?

Classical-to-quantum encoding is the entry gate of QML. Amplitude encoding achieves logarithmic spatial compression (encoding 1,024 features in 10 qubits), while angle encoding is NISQ-friendly with shallow circuit depth.

Course Learning Resource β€’ Slide DeckLesson 1011 Slides

Lesson 10: Variational Quantum Classification

Feature maps, ansatz, COBYLA optimization, and complete VQC pipeline.

Author: Dr. Syed Muzamil Bashaβ€’ FDP Approved Curriculum
Open in New Tab

πŸ“ Learning Check

Test your understanding with these questions. Remember, this is for learning, not examination!

Question 1: What is the primary drawback of Amplitude Encoding for large classical datasets?

Question 2: Placeholder question 2

Question 3: Placeholder question 3

Question 4: Placeholder question 4

Question 5: Placeholder question 5

Previous: Quantum Data vs Classical Data: Sources & StructuresNext: Quantum Feature Maps & Non-Linear Embeddings