Launch the interactive walkthrough to discover each component, including the 3D Q-Sphere Lab & Python in Colab.
Construct a complete hybrid supervised learning pipeline: Feature Map + Variational Ansatz + Measurement Readout + Classical Optimizer.
Interactive 3D state vector exploration, unitary transformation gates, and Born rule collapse for Topic 8.8
| Symbol / Term | Meaning | Beginner Interpretation |
|---|---|---|
| Predicted probability of Class 1 | Calibrated output probability bounded between 0.0 and 1.0 | |
| Pauli-Z expectation value on qubit 0 | Physical QPU measurement value between -1.0 and +1.0 | |
| Binary Cross-Entropy Loss | Supervised classification error minimized by classical optimizer | |
| Ground-truth label | True binary class label (1 or 0) for training sample m |
Evaluating VQC prediction and cross-entropy loss for a training sample with ground truth y = 1 when the quantum circuit yields <Z_0> = +0.72:
Result: The VQC achieves an 86.0% probability for the true class with a low cross-entropy error of 0.1508.
Apply feature map U_Phi(x) on ground state |0>.
Pass state through layers of parameterized rotation and CNOT entangling gates.
Read out Pauli-Z expectation value on output qubit.
Classical optimizer computes loss and steps parameters theta.
Problem: Classifying loan applicants in non-linear credit risk manifolds.
Solution: VQC maps customer financial features into entangled quantum states, optimizing decision hyperplanes.
Interactive activity component
Build, transpile, train, and test an end-to-end Variational Quantum Classifier using ZZFeatureMap, RealAmplitudes ansatz, COBYLA optimizer, and StatevectorSampler.
For Google Colab or Jupyter notebooks, run this shell command to install the required dependencies:
!pip install qiskit qiskit-machine-learning qiskit-algorithms scikit-learn numpy1 import numpy as np 2 from qiskit.primitives import StatevectorSampler 3 from qiskit_machine_learning.algorithms.classifiers import VQC 4 from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes 5 from qiskit_algorithms.optimizers import COBYLA 6 from qiskit.transpiler import PassManager 7 from qiskit.transpiler.passes import Optimize1qGatesDecomposition, CommutativeCancellation 8 from sklearn.model_selection import train_test_split 9 from sklearn.preprocessing import StandardScaler 10 from sklearn.datasets import make_classification
import numpy as np → NumPy array computations
from qiskit.primitives import StatevectorSampler → Sampler primitive for quantum state sampling
from qiskit_machine_learning.algorithms.classifiers import VQC → Variational Quantum Classifier estimator
from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes → Quantum feature map and parameterized ansatz
from qiskit_algorithms.optimizers import COBYLA → Classical derivative-free numerical optimizer
from qiskit.transpiler import PassManager → Circuit transpilation pipeline
from qiskit.transpiler.passes import Optimize1qGatesDecomposition, CommutativeCancellation → Transpilation optimization passes
from sklearn.model_selection import train_test_split → Dataset split utility
from sklearn.preprocessing import StandardScaler → Feature standardization
from sklearn.datasets import make_classification → Synthetic classification dataset
1 # Step 1: Generate and Preprocess Classification Data 2 X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=42) 3 scaler = StandardScaler() 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) & Ansatz (RealAmplitudes) 8 feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement='linear') 9 ansatz = RealAmplitudes(num_qubits=2, reps=3, entanglement='linear') 10 11 # Step 3: Initialize StatevectorSampler and Optimizer 12 sampler = StatevectorSampler() 13 optimizer = COBYLA(maxiter=100) 14 15 # Step 4: Define Transpiler Pass Manager 16 pass_manager = PassManager([ 17 Optimize1qGatesDecomposition(basis=['u3', 'cx']), 18 CommutativeCancellation() 19 ]) 20 21 # Step 5: Instantiate and Train Variational Quantum Classifier (VQC) 22 vqc = VQC( 23 feature_map=feature_map, 24 ansatz=ansatz, 25 optimizer=optimizer, 26 sampler=sampler, 27 pass_manager=pass_manager 28 ) 29 vqc.fit(X_train, y_train) 30 31 # Step 6: Evaluate Model Accuracy on Test Set 32 y_pred = vqc.predict(X_test) 33 accuracy = np.mean(y_pred == y_test) 34 print(f"VQC Accuracy: {accuracy * 100:.2f}%")
# Step 1: Generate and Preprocess Classification Data
Data generation
X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=42)
100 samples with 2 features
scaler = StandardScaler()
StandardScaler
X_scaled = scaler.fit_transform(X)
Standardize features
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
80/20 train/test split
# Step 2: Define Quantum Feature Map (ZZFeatureMap) & Ansatz (RealAmplitudes)
Circuit setup
feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement='linear')
Angle feature mapping
ansatz = RealAmplitudes(num_qubits=2, reps=3, entanglement='linear')
Parameterized variational ansatz
# Step 3: Initialize StatevectorSampler and Optimizer
Primitives & Optimizer
sampler = StatevectorSampler()
Primitive sampler
optimizer = COBYLA(maxiter=100)
COBYLA optimizer instance
# Step 4: Define Transpiler Pass Manager
Transpiler
pass_manager = PassManager([
Transpiler pipeline
Optimize1qGatesDecomposition(basis=['u3', 'cx']),
Optimize 1q gates
CommutativeCancellation()
Cancel commutative gates
])
Close pass manager
# Step 5: Instantiate and Train Variational Quantum Classifier (VQC)
Model training
vqc = VQC(
VQC constructor
feature_map=feature_map,
Assign feature map
ansatz=ansatz,
Assign variational ansatz
optimizer=optimizer,
Assign classical optimizer
sampler=sampler,
Assign sampler primitive
pass_manager=pass_manager
Assign pass manager
)
Instantiate VQC
vqc.fit(X_train, y_train)
Train VQC on training data
# Step 6: Evaluate Model Accuracy on Test Set
Evaluation
y_pred = vqc.predict(X_test)
Predict on test samples
accuracy = np.mean(y_pred == y_test)
Compute test accuracy
print(f"VQC Accuracy: {accuracy * 100:.2f}%")
Print accuracy
Click "Copy for Colab", open Google Colab, paste into a single cell, and run.
1 # ========================================================= 2 # Variational Quantum Classifier (VQC) 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 qiskit.primitives import StatevectorSampler 12 from qiskit_machine_learning.algorithms.classifiers import VQC 13 from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes 14 from qiskit_algorithms.optimizers import COBYLA 15 from qiskit.transpiler import PassManager 16 from qiskit.transpiler.passes import Optimize1qGatesDecomposition, CommutativeCancellation 17 from sklearn.model_selection import train_test_split 18 from sklearn.preprocessing import StandardScaler 19 from sklearn.datasets import make_classification 20 21 # Step 3: Run Demonstration 22 # Step 1: Generate and Preprocess Classification Data 23 X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=42) 24 scaler = StandardScaler() 25 X_scaled = scaler.fit_transform(X) 26 X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42) 27 28 # Step 2: Define Quantum Feature Map (ZZFeatureMap) & Ansatz (RealAmplitudes) 29 feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement='linear') 30 ansatz = RealAmplitudes(num_qubits=2, reps=3, entanglement='linear') 31 32 # Step 3: Initialize StatevectorSampler and Optimizer 33 sampler = StatevectorSampler() 34 optimizer = COBYLA(maxiter=100) 35 36 # Step 4: Define Transpiler Pass Manager 37 pass_manager = PassManager([ 38 Optimize1qGatesDecomposition(basis=['u3', 'cx']), 39 CommutativeCancellation() 40 ]) 41 42 # Step 5: Instantiate and Train Variational Quantum Classifier (VQC) 43 vqc = VQC( 44 feature_map=feature_map, 45 ansatz=ansatz, 46 optimizer=optimizer, 47 sampler=sampler, 48 pass_manager=pass_manager 49 ) 50 vqc.fit(X_train, y_train) 51 52 # Step 6: Evaluate Model Accuracy on Test Set 53 y_pred = vqc.predict(X_test) 54 accuracy = np.mean(y_pred == y_test) 55 print(f"VQC Accuracy: {accuracy * 100:.2f}%")
Encodes standardized data into 2-qubit states with ZZFeatureMap and prepares a 3-repetition RealAmplitudes trainable ansatz.
PassManager optimizes 1-qubit gate decompositions and cancels commuting gates to reduce quantum circuit depth.
COBYLA optimizer tunes the variational quantum gate angles over 100 iterations, achieving >90% classification accuracy on unseen test samples.
100 binary classification samples split into 80 training and 20 test instances
VQC Accuracy: 95.00%
The Variational Quantum Classifier successfully optimizes parameterized quantum rotational gates in Hilbert space, discovering clean non-linear separation boundaries between binary classes.
Feature maps, RealAmplitudes ansatz, COBYLA optimization, PassManager transpilation, and complete VQC pipeline.
Test your understanding with these questions. Remember, this is for learning, not examination!