First time studying this topic?

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

Topic 8.6

Quantum Kernels & Quantum Support Vector Machines (QSVM)

Master Quantum Kernel Estimation: computing state overlaps |<Phi(x)|Phi(x’)>|^2 to power Quantum Support Vector Machines.

Learning Objectives

✓Define the Quantum Kernel: K(x, x') = |<Phi(x)|Phi(x')>|^2
✓Understand how QSVM combines a quantum kernel estimator with a classical convex SVM solver
✓Evaluate provable quantum speedups in kernel methods (Liu et al., 2021)

📖Let's Begin with a Story

In 2021, an IBM research team led by Yunchao Liu proved a landmark mathematical theorem: There exist specific, mathematically rigorous classification problems that NO classical machine learning model can ever solve efficiently, but which a Quantum Kernel Support Vector Machine can solve in polynomial time. How does a Quantum Kernel work? You don't train a neural network on the quantum chip. Instead, you use the quantum computer as a Geometry Engine! - You give the quantum chip two data points:

x_1

and

x_2

. - The quantum chip encodes both points into quantum wavefunctions:

|\Phi(x_1)\rangle

and

|\Phi(x_2)\rangle

. - It collides the two waves and measures their overlap:

K(x_1, x_2) = |\langle\Phi(x_1) \mid \Phi(x_2)\rangle|^2

- It passes this similarity score back to an ordinary classical computer, which runs a standard Support Vector Machine!

Why Should You Learn Quantum Kernels & Quantum Support Vector Machines (QSVM)?

🎯 Practical & Engineering Stakes

The most theoretically grounded QML algorithm

Unlike variational neural networks which suffer from barren plateaus, Quantum Kernel methods guarantee global convergence via convex quadratic programming.

What Is It?

Simple Explanation

A Quantum Kernel is a similarity measurer: "How similar is patient A to patient B?" Instead of comparing them using ordinary classical formulas, the quantum computer projects both patients into quantum dimensions and measures how much their quantum waves overlap! Once the similarity table (the Kernel Matrix) is built, an ordinary classical computer draws the dividing boundary!

Technical Explanation

A Quantum Kernel evaluates the transition probability fidelity between embedded quantum states:

K(\mathbf{x}, \mathbf{x}') = |\langle \Phi(\mathbf{x}) \mid \Phi(\mathbf{x}') \rangle|^2 = \text{Tr}\big( |\Phi(\mathbf{x})\rangle\langle\Phi(\mathbf{x})| \cdot |\Phi(\mathbf{x}')\rangle\langle\Phi(\mathbf{x}')| \big)

The resulting Gram matrix

\mathbf{K} \in \mathbb{R}^{N \times N}

is symmetric and positive semi-definite, guaranteeing a unique global minimum when solved via classical dual convex quadratic programming:

\max_\alpha \sum \alpha_i - \frac{1}{2}\sum \alpha_i \alpha_j y_i y_j K(\mathbf{x}_i, \mathbf{x}_j)

📚 Key Terms

Quantum Kernel Matrix (Gram Matrix)

Simple: A table comparing the similarity of every data point to every other data point using quantum overlap.

Technical: An

N \times N

positive semi-definite matrix where entry

K_{ij} = |\langle\Phi(x_i)|\Phi(x_j)\rangle|^2

Quantum Support Vector Machine (QSVM)

Simple: A Support Vector Machine that uses a quantum computer to measure similarity scores.

Technical: Support Vector Classifier trained on a quantum kernel matrix evaluated via transition probability circuits.

Q-Sphere Lab: Quantum Kernels & Quantum Support Vector Machines (QSVM)

IBM Q-Sphere Model

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

Azimuth: 45°Elevation: 25°(Click & drag sphere to orbit)

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

K(\mathbf{x}, \mathbf{x}^\prime) = \big| \langle \Phi(\mathbf{x}^\prime) | \Phi(\mathbf{x}) \rangle \big|^2 = \big| \langle 0^{\otimes n} | U_\Phi^\dagger(\mathbf{x}^\prime) U_\Phi(\mathbf{x}) | 0^{\otimes n} \rangle \big|^2 = \text{Tr}\big( \rho(\mathbf{x}) \rho(\mathbf{x}^\prime) \big)

What does it mean?

Quantum Kernel Estimation (Transition Probability): Evaluates the similarity between two classical data samples x and x prime directly in 2^n-dimensional Hilbert space. The kernel value equals the transition probability of preparing state |Phi(x)>, applying the adjoint circuit U_dagger(x prime), and measuring the probability of collapsing back to the all-zero state |00...0>. The resulting Gram matrix is fed into a classical Support Vector Machine (QSVC).

Understanding the Symbols

Symbol / Term	Meaning	Beginner Interpretation
$K(\mathbf{x}, \mathbf{x}^\prime)$	Quantum kernel similarity score	Bounded in [0.0, 1.0], where 1.0 is identical and 0.0 is orthogonal
$\|\Phi(\mathbf{x})\rangle$	Quantum state of sample $\mathbf{x}$	State vector created by feature map $U(\mathbf{x})\|0\rangle$
$U_\Phi^\dagger(\mathbf{x}^\prime)$	Adjoint feature map for sample x prime	Inverted circuit running the second data point in reverse
$\|0^{\otimes n}\rangle$	All-zero ground state	Reference state measured to determine transition probability overlap

📊 Numerical Example

Computing the quantum kernel similarity between two 1-qubit data points x = 0.2 and x prime = 0.8 with angle feature map U(x) = Ry(2x):

Step 1: Compute State Overlap: U(x)

|0\rangle

= Ry(0.4)

|0\rangle

U(x')

|0\rangle

= Ry(1.6)

|0\rangle

Combined Unitary: U_dagger(x') · U(x) = Ry(-1.6) · Ry(0.4) = Ry(0.4 - 1.6) = Ry(-1.2) Step 2: Evaluate Statevector After Inverted Circuit: |ψ_test⟩ = Ry(-1.2)

|0\rangle

= cos(-0.6)

|0\rangle

+ sin(-0.6)

|1\rangle

cos(-0.6) = 0.8253, sin(-0.6) = -0.5646 |ψ_test⟩ = 0.8253

|0\rangle

- 0.5646

|1\rangle

Step 3: Measure Overlap with Ground State

|0\rangle

: K(x, x') = |

\langle 0|

ψ_test⟩|² = |0.8253|² = 0.6812 (68.12%) Step 4: Self-Similarity Verification: For identical points x = x': Ry(0.4 - 0.4) = Ry(0) = I → |

\langle 0|

0⟩|² = 1.00 (100%)

Result: Points x and x prime have a quantum kernel similarity score of 0.6812, populating matrix entry K_12 in the Gram matrix.

⚙️ How Does It Work?

Pairwise Circuit Execution

For every pair of samples (x_i, x_j), construct circuit U_dagger(x_j) * U(x_i).

All-Zero Readout

Measure probability of measuring bitstring 00...0; this equals K(x_i, x_j).

Classical SVM Fitting

Pass computed Kernel Matrix into Scikit-Learn SVC(kernel="precomputed") to find optimal support vectors.

🌍 Where Is It Used?

Credit Card Fraud Classification

Problem: Identifying rare fraudulent transactions hidden in high-dimensional behavioral feature spaces.

Solution: QSVM with ZZ-kernels maps transactions into quantum space, detecting fraud clusters invisible to classical RBF kernels.

🎯 Try It Yourself

In a quantum kernel estimation circuit, how is the kernel value K(x, x') physically measured?

Interactive activity component

🐍 Python Hands-On: Quantum Kernel Support Vector Machine in Qiskit Machine Learning

Construct a ZZFeatureMap, evaluate quantum kernel Gram matrices with FidelityQuantumKernel, and train a Scikit-Learn Support Vector Classifier with precomputed quantum kernel.

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 qiskit-machine-learning qiskit-algorithms scikit-learn numpy

Packages:

qiskitqiskit-machine-learningqiskit-algorithmsscikit-learnnumpy

2Import Libraries

Import Statementspython

1 import numpy as np
2 from sklearn.datasets import make_blobs
3 from sklearn.model_selection import train_test_split
4 from sklearn.preprocessing import MinMaxScaler
5 from sklearn.svm import SVC
6 from qiskit.circuit.library import ZZFeatureMap
7 from qiskit.primitives import StatevectorSampler
8 from qiskit_machine_learning.kernels import FidelityQuantumKernel

import numpy as np → NumPy array computation

from sklearn.datasets import make_blobs → Synthetic classification dataset

from sklearn.model_selection import train_test_split → Dataset split utility

from sklearn.preprocessing import MinMaxScaler → Scale features to [0, 2pi]

from sklearn.svm import SVC → Classical Support Vector Classifier

from qiskit.circuit.library import ZZFeatureMap → Quantum ZZ feature map

from qiskit.primitives import StatevectorSampler → Statevector sampler primitive

from qiskit_machine_learning.kernels import FidelityQuantumKernel → Quantum fidelity kernel evaluator

3Demonstration Code & Logic

Python Execution Codepython

1 # Step 1: Generate synthetic 2-feature dataset and scale to [0, 2*pi]
2 X, y = make_blobs(n_samples=20, centers=2, random_state=42, n_features=2)
3 scaler = MinMaxScaler(feature_range=(0, 2 * np.pi))
4 X_scaled = scaler.fit_transform(X)
5 X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
6  
7 # Step 2: Define Quantum Feature Map (ZZFeatureMap with linear entanglement)
8 feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement='linear')
9  
10 # Step 3: Initialize StatevectorSampler and FidelityQuantumKernel
11 sampler = StatevectorSampler()
12 quantum_kernel = FidelityQuantumKernel(feature_map=feature_map)
13  
14 # Step 4: Compute Quantum Kernel Gram Matrices for Train and Test sets
15 X_train_kernel = quantum_kernel.evaluate(X_train)
16 X_test_kernel = quantum_kernel.evaluate(X_test, X_train)
17  
18 # Step 5: Train Classical Support Vector Machine (SVM) with Precomputed Quantum Kernel
19 svm = SVC(kernel="precomputed")
20 svm.fit(X_train_kernel, y_train)
21  
22 # Step 6: Evaluate Model Accuracy on Test Set
23 y_pred = svm.predict(X_test_kernel)
24 accuracy = np.mean(y_pred == y_test)
25 print(f"Quantum Kernel SVM Accuracy: {accuracy * 100:.2f}%")

Step-by-Step Code Breakdown:

# Step 1: Generate synthetic 2-feature dataset and scale to [0, 2*pi]

Data generation

X, y = make_blobs(n_samples=20, centers=2, random_state=42, n_features=2)

20 samples, 2 classes

scaler = MinMaxScaler(feature_range=(0, 2 * np.pi))

MinMax scaler

X_scaled = scaler.fit_transform(X)

Fit and transform features

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

Train/test split

# Step 2: Define Quantum Feature Map (ZZFeatureMap with linear entanglement)

Feature map

feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement='linear')

2-qubit ZZFeatureMap

# Step 3: Initialize StatevectorSampler and FidelityQuantumKernel

Kernel initialization

sampler = StatevectorSampler()

Sampler primitive

quantum_kernel = FidelityQuantumKernel(feature_map=feature_map)

Fidelity quantum kernel

# Step 4: Compute Quantum Kernel Gram Matrices for Train and Test sets

Kernel evaluation

X_train_kernel = quantum_kernel.evaluate(X_train)

Evaluate N_train x N_train Gram matrix

X_test_kernel = quantum_kernel.evaluate(X_test, X_train)

Evaluate N_test x N_train kernel matrix

# Step 5: Train Classical Support Vector Machine (SVM) with Precomputed Quantum Kernel

SVM training

svm = SVC(kernel="precomputed")

Instantiate SVM with precomputed kernel

svm.fit(X_train_kernel, y_train)

Fit SVM on quantum Gram matrix

# Step 6: Evaluate Model Accuracy on Test Set

Inference & evaluation

y_pred = svm.predict(X_test_kernel)

Predict test classes

accuracy = np.mean(y_pred == y_test)

Calculate classification accuracy

print(f"Quantum Kernel SVM Accuracy: {accuracy * 100:.2f}%")

Print accuracy

📋 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 # Quantum Kernel Support Vector Machine in Qiskit Machine Learning
3 # Prepared for Google Colab (Run with Shift + Enter)
4 # =========================================================
5  
6 # Step 1: Install required packages
7 !pip install qiskit qiskit-machine-learning qiskit-algorithms scikit-learn numpy
8  
9 # Step 2: Import libraries
10 import numpy as np
11 from sklearn.datasets import make_blobs
12 from sklearn.model_selection import train_test_split
13 from sklearn.preprocessing import MinMaxScaler
14 from sklearn.svm import SVC
15 from qiskit.circuit.library import ZZFeatureMap
16 from qiskit.primitives import StatevectorSampler
17 from qiskit_machine_learning.kernels import FidelityQuantumKernel
18  
19 # Step 3: Run Demonstration
20 # Step 1: Generate synthetic 2-feature dataset and scale to [0, 2*pi]
21 X, y = make_blobs(n_samples=20, centers=2, random_state=42, n_features=2)
22 scaler = MinMaxScaler(feature_range=(0, 2 * np.pi))
23 X_scaled = scaler.fit_transform(X)
24 X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
25  
26 # Step 2: Define Quantum Feature Map (ZZFeatureMap with linear entanglement)
27 feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement='linear')
28  
29 # Step 3: Initialize StatevectorSampler and FidelityQuantumKernel
30 sampler = StatevectorSampler()
31 quantum_kernel = FidelityQuantumKernel(feature_map=feature_map)
32  
33 # Step 4: Compute Quantum Kernel Gram Matrices for Train and Test sets
34 X_train_kernel = quantum_kernel.evaluate(X_train)
35 X_test_kernel = quantum_kernel.evaluate(X_test, X_train)
36  
37 # Step 5: Train Classical Support Vector Machine (SVM) with Precomputed Quantum Kernel
38 svm = SVC(kernel="precomputed")
39 svm.fit(X_train_kernel, y_train)
40  
41 # Step 6: Evaluate Model Accuracy on Test Set
42 y_pred = svm.predict(X_test_kernel)
43 accuracy = np.mean(y_pred == y_test)
44 print(f"Quantum Kernel SVM Accuracy: {accuracy * 100:.2f}%")

⚡ How to Run in Google Colab (3 Quick Steps)

Click "Copy for Google Colab" above.
Click Open New Google Colab Notebook (opens in a new tab).
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

Feature Space Mapping

Classical 2D data vectors are scaled into [0, 2pi] angles and mapped into 2-qubit Hilbert space via ZZFeatureMap.

→

Gram Matrix Computation

FidelityQuantumKernel computes inner product overlaps |<psi(xi)|psi(xj)>|^2 between all pairs of data vectors.

→

Convex SVM Optimization

A classical Support Vector Classifier finds the optimal separating maximum-margin hyperplane in Hilbert space with 100% accuracy.

📥 Input / Initial State

20 synthetic data samples with 2 continuous features and binary labels

📤 Expected Output

Quantum Kernel SVM Accuracy: 100.00%

💡 What Does This Demonstration Show?

The quantum kernel projects non-linearly separable data into an entangled Hilbert state space where classical hyperplanes can separate classes with high accuracy and zero barren plateau risk.

Course Learning Resource • Slide DeckLesson 1110 Slides

Lesson 11: Quantum Kernel Methods

Quantum feature maps, FidelityQuantumKernel Gram matrix evaluation, and classical Support Vector Machine (SVM) training.

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: Why are Quantum Kernel methods free from the "Barren Plateau" problem that plagues Variational Quantum Neural Networks?

Question 2: Placeholder question 2

Question 3: Placeholder question 3

Question 4: Placeholder question 4

Question 5: Placeholder question 5

Previous: Quantum Feature Maps & Non-Linear Embeddings Next: Variational Quantum Circuits (VQE & PQC): The Quantum Neural Network

1	import numpy as np
2	from sklearn.datasets import make_blobs
3	from sklearn.model_selection import train_test_split
4	from sklearn.preprocessing import MinMaxScaler
5	from sklearn.svm import SVC
6	from qiskit.circuit.library import ZZFeatureMap
7	from qiskit.primitives import StatevectorSampler
8	from qiskit_machine_learning.kernels import FidelityQuantumKernel

1	# =========================================================
2	# Quantum Kernel Support Vector Machine in Qiskit Machine Learning
3	# Prepared for Google Colab (Run with Shift + Enter)
4	# =========================================================
5
6	# Step 1: Install required packages
7	!pip install qiskit qiskit-machine-learning qiskit-algorithms scikit-learn numpy
8
9	# Step 2: Import libraries
10	import numpy as np
11	from sklearn.datasets import make_blobs
12	from sklearn.model_selection import train_test_split
13	from sklearn.preprocessing import MinMaxScaler
14	from sklearn.svm import SVC
15	from qiskit.circuit.library import ZZFeatureMap
16	from qiskit.primitives import StatevectorSampler
17	from qiskit_machine_learning.kernels import FidelityQuantumKernel
18
19	# Step 3: Run Demonstration
20	# Step 1: Generate synthetic 2-feature dataset and scale to [0, 2*pi]
21	X, y = make_blobs(n_samples=20, centers=2, random_state=42, n_features=2)
22	scaler = MinMaxScaler(feature_range=(0, 2 * np.pi))
23	X_scaled = scaler.fit_transform(X)
24	X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
25
26	# Step 2: Define Quantum Feature Map (ZZFeatureMap with linear entanglement)
27	feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement='linear')
28
29	# Step 3: Initialize StatevectorSampler and FidelityQuantumKernel
30	sampler = StatevectorSampler()
31	quantum_kernel = FidelityQuantumKernel(feature_map=feature_map)
32
33	# Step 4: Compute Quantum Kernel Gram Matrices for Train and Test sets
34	X_train_kernel = quantum_kernel.evaluate(X_train)
35	X_test_kernel = quantum_kernel.evaluate(X_test, X_train)
36
37	# Step 5: Train Classical Support Vector Machine (SVM) with Precomputed Quantum Kernel
38	svm = SVC(kernel="precomputed")
39	svm.fit(X_train_kernel, y_train)
40
41	# Step 6: Evaluate Model Accuracy on Test Set
42	y_pred = svm.predict(X_test_kernel)
43	accuracy = np.mean(y_pred == y_test)
44	print(f"Quantum Kernel SVM Accuracy: {accuracy * 100:.2f}%")