Launch the interactive walkthrough to discover each component, including the 3D Q-Sphere Lab & Python in Colab.
Hands-on capstone project ideas, portfolio building guidelines, and career roadmaps for quantum AI engineering.
Interactive 3D state vector exploration, unitary transformation gates, and Born rule collapse for Topic 9.8
| Symbol / Term | Meaning | Beginner Interpretation |
|---|---|---|
| Comprehensive quantum advantage score | Performance margin normalized by computational energy efficiency | |
| Accuracy performance margin | Net improvement over fully tuned classical machine learning baseline | |
| Computational energy consumption | Total electricity consumed by classical GPUs vs cryogenic quantum processor | |
| Uhlmann state fidelity | Quantum state overlap metric where 1.0 indicates perfect distribution match |
Benchmarking a student capstone project comparing a Quantum Support Vector Classifier (QSVC) vs Classical RBF SVM on a financial fraud detection dataset:
Result: The QSVC project demonstrates a verified +4.4% accuracy improvement with 30× lower compute energy consumption.
Choose a domain (e.g. Quantum Kernel SVM for Credit Fraud, Hybrid Transformer for Drug Toxicity, QAOA for Green Logistics).
Train classical Random Forest or PyTorch MLP models to establish honest benchmark metrics.
Design parameterized circuits in PennyLane or Qiskit, choosing expressive feature maps and ansatzes.
Evaluate under ideal and noisy simulators, apply error mitigation, package code with a README, and publish to GitHub.
Problem: Detecting rare fraudulent transactions in unbalanced financial datasets.
Solution: Use ZZFeatureMap to map transaction features into quantum Hilbert space, evaluating kernel matrices on real hardware.
Problem: Classifying ultrasound or X-ray anomalies with small training sample sizes.
Solution: Use a pre-trained classical CNN feature extractor coupled to an 8-qubit variational classifier with parameter-shift training.
Interactive activity component
Run an end-to-end reproducible script comparing a classical Logistic Regression baseline against a Quantum Kernel classifier.
For Google Colab or Jupyter notebooks, run this shell command to install the required dependencies:
!pip install scikit-learn numpy1 import numpy as np 2 from sklearn.datasets import make_moons 3 from sklearn.linear_model import LogisticRegression 4 from sklearn.metrics import accuracy_score
import numpy as np → Import NumPy for matrix operations
from sklearn.datasets import make_moons → Generate synthetic non-linear classification dataset
from sklearn.linear_model import LogisticRegression → Classical linear baseline
from sklearn.metrics import accuracy_score → Compute classification accuracy
1 # Step 1: Generate non-linear dataset 2 X, y = make_moons(n_samples=60, noise=0.1, random_state=42) 3 X_train, X_test = X[:40], X[40:] 4 y_train, y_test = y[:40], y[40:] 5 # Step 2: Classical Baseline 6 classical_model = LogisticRegression() 7 classical_model.fit(X_train, y_train) 8 acc_classical = accuracy_score(y_test, classical_model.predict(X_test)) 9 # Step 3: Simulated Quantum Non-Linear Kernel (cos(pi * ||x1 - x2||^2)) 10 def quantum_sim_kernel(X1, X2): 11 # Models state fidelity |<psi(x1)|psi(x2)>|^2 in non-linear feature map 12 dists = np.sum((X1[:, np.newaxis] - X2[np.newaxis, :])**2, axis=-1) 13 return np.cos(np.pi * dists / 4.0)**2 14 K_train = quantum_sim_kernel(X_train, X_train) 15 K_test = quantum_sim_kernel(X_test, X_train) 16 from sklearn.svm import SVC 17 quantum_svm = SVC(kernel="precomputed") 18 quantum_svm.fit(K_train, y_train) 19 acc_quantum = accuracy_score(y_test, quantum_svm.predict(K_test)) 20 print(f"Classical Baseline Accuracy: {acc_classical * 100:.1f}%") 21 print(f"Quantum Kernel SVM Accuracy: {acc_quantum * 100:.1f}%")
# Step 1: Generate non-linear dataset
Create two interleaving half circles
X, y = make_moons(n_samples=60, noise=0.1, random_state=42)
Sample 60 data points
X_train, X_test = X[:40], X[40:]
Train/test split
y_train, y_test = y[:40], y[40:]
Labels
# Step 2: Classical Baseline
Train linear logistic regression
classical_model = LogisticRegression()
Initialize linear classifier
classical_model.fit(X_train, y_train)
Fit classical model
acc_classical = accuracy_score(y_test, classical_model.predict(X_test))
Evaluate classical accuracy
# Step 3: Simulated Quantum Non-Linear Kernel (cos(pi * ||x1 - x2||^2))
Quantum kernel simulation
def quantum_sim_kernel(X1, X2):
Compute pairwise quantum overlap matrix
# Models state fidelity |<psi(x1)|psi(x2)>|^2 in non-linear feature map
Fidelity formula
dists = np.sum((X1[:, np.newaxis] - X2[np.newaxis, :])**2, axis=-1)
Squared Euclidean distance
return np.cos(np.pi * dists / 4.0)**2
Quantum transition probability
K_train = quantum_sim_kernel(X_train, X_train)
Train kernel matrix
K_test = quantum_sim_kernel(X_test, X_train)
Test kernel matrix
from sklearn.svm import SVC
Use support vector machine with precomputed kernel
quantum_svm = SVC(kernel="precomputed")
Initialize kernel SVM
quantum_svm.fit(K_train, y_train)
Fit kernel classifier
acc_quantum = accuracy_score(y_test, quantum_svm.predict(K_test))
Evaluate quantum accuracy
print(f"Classical Baseline Accuracy: {acc_classical * 100:.1f}%")
Display classical result
print(f"Quantum Kernel SVM Accuracy: {acc_quantum * 100:.1f}%")
Display quantum result
Click "Copy for Colab", open Google Colab, paste into a single cell, and run.
1 # ========================================================= 2 # Complete Capstone Template: Quantum vs Classical Binary Classifier 3 # Prepared for Google Colab (Run with Shift + Enter) 4 # ========================================================= 5 6 # Step 1: Install required packages 7 !pip install scikit-learn numpy 8 9 # Step 2: Import libraries 10 import numpy as np 11 from sklearn.datasets import make_moons 12 from sklearn.linear_model import LogisticRegression 13 from sklearn.metrics import accuracy_score 14 15 # Step 3: Run Demonstration 16 # Step 1: Generate non-linear dataset 17 X, y = make_moons(n_samples=60, noise=0.1, random_state=42) 18 X_train, X_test = X[:40], X[40:] 19 y_train, y_test = y[:40], y[40:] 20 # Step 2: Classical Baseline 21 classical_model = LogisticRegression() 22 classical_model.fit(X_train, y_train) 23 acc_classical = accuracy_score(y_test, classical_model.predict(X_test)) 24 # Step 3: Simulated Quantum Non-Linear Kernel (cos(pi * ||x1 - x2||^2)) 25 def quantum_sim_kernel(X1, X2): 26 # Models state fidelity |<psi(x1)|psi(x2)>|^2 in non-linear feature map 27 dists = np.sum((X1[:, np.newaxis] - X2[np.newaxis, :])**2, axis=-1) 28 return np.cos(np.pi * dists / 4.0)**2 29 K_train = quantum_sim_kernel(X_train, X_train) 30 K_test = quantum_sim_kernel(X_test, X_train) 31 from sklearn.svm import SVC 32 quantum_svm = SVC(kernel="precomputed") 33 quantum_svm.fit(K_train, y_train) 34 acc_quantum = accuracy_score(y_test, quantum_svm.predict(K_test)) 35 print(f"Classical Baseline Accuracy: {acc_classical * 100:.1f}%") 36 print(f"Quantum Kernel SVM Accuracy: {acc_quantum * 100:.1f}%")
Create two interleaving half-moons that cannot be separated by a straight line.
Observe that the linear baseline struggles with the non-linear boundary.
Demonstrate how mapping through a quantum kernel achieves higher separation accuracy.
make_moons non-linear dataset (40 train, 20 test)
Classical Baseline Accuracy: ~85.0% | Quantum Kernel SVM Accuracy: ~100.0%
The quantum feature map naturally projects the curved geometric boundary into a linearly separable space, demonstrating the core principle of quantum-enhanced learning.
Covariance, quadratic programming, SamplingVQE, and portfolio optimization.
Test your understanding with these questions. Remember, this is for learning, not examination!