First time studying this topic?

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

Topic 9.3

Quantum Optimization in AI

Master combinatorial and continuous quantum optimization algorithms including QAOA and Quantum Annealing for AI training.

Learning Objectives

✓Formulate machine learning loss functions as Quadratic Unconstrained Binary Optimization (QUBO) problems
✓Understand the Quantum Approximate Optimization Algorithm (QAOA) architecture
✓Compare quantum annealing (D-Wave) with gate-based variational quantum optimization
✓Apply quantum optimization to AI feature selection, clustering, and hyperparameter tuning

📖Let's Begin with a Story

Training machine learning models often boils down to optimization: finding the best weights, the best hyperparameters, or the optimal subset of features among billions of combinations. Classical optimizers easily get trapped in local valleys. Quantum optimization uses quantum tunneling to pass straight through energy barriers rather than climbing over them.

Why Should You Learn Quantum Optimization in AI?

🎯 Practical & Engineering Stakes

Optimization is the core mathematical engine of machine learning. When problems exhibit non-convex landscapes with astronomical combinatorial complexity, quantum optimization provides heuristics that outperform classical simulated annealing and genetic algorithms.

What Is It?

Simple Explanation

Imagine rolling a ball across a bumpy landscape looking for the deepest pit. A classical marble has to roll up and over tall hills, and often gets stuck in a shallow ditch. A quantum marble can perform "quantum tunneling"—ghosting directly through the hill to reach the deepest cavern on the other side.

Technical Explanation

Quantum optimization maps combinatorial discrete problems to Ising spin glass Hamiltonians

H_C = \sum_i h_i Z_i + \sum_{i<j} J_{ij} Z_i Z_j

. Gate-based processors use the Quantum Approximate Optimization Algorithm (QAOA) with alternating cost and mixer unitaries

e^{-i\gamma H_C} e^{-i\beta H_M}

, while quantum annealers physically evolve a transverse-field driver Hamiltonian into the problem Hamiltonian via adiabatic theorem.

📚 Key Terms

$QUBO$

Simple: A standard math format for writing optimization problems using 0s and 1s.

Technical: Quadratic Unconstrained Binary Optimization: minimizing

f(x) = x^T Q x

where

x \in \{0, 1\}^n

and

Q

is an

n \times n

real matrix.

$QAOA$

Simple: A quantum algorithm that searches for near-optimal solutions to hard puzzle problems.

Technical: Quantum Approximate Optimization Algorithm: a variational hybrid algorithm using

p

layers of parameterized cost and mixer Hamiltonians to approximate combinatorial ground states.

Quantum Tunneling

Simple: A quantum particle passing through a physical barrier it classically could not climb.

Technical: The non-zero probability of a quantum state transitioning through a potential energy barrier higher than its kinetic energy.

Q-Sphere Lab: Quantum Optimization in AI

IBM Q-Sphere Model

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

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

F_p(\boldsymbol{\gamma}, \boldsymbol{\beta}) = \langle \psi_p(\boldsymbol{\gamma}, \boldsymbol{\beta}) | H_C | \psi_p(\boldsymbol{\gamma}, \boldsymbol{\beta}) \rangle, \quad |\psi_p\rangle = \prod_{l=1}^p e^{-i \beta_l H_M} e^{-i \gamma_l H_C} |+\rangle^{\otimes n}

What does it mean?

Quantum Approximate Optimization Algorithm (QAOA) Expectation: Formulates combinatorial optimization problems (e.g. Max-Cut, portfolio selection, graph coloring) as finding the ground state of an Ising cost Hamiltonian H_C. The algorithm alternates between applying the problem unitary e^{-i gamma_l H_C} (which encodes problem constraints into relative phases) and the mixer unitary e^{-i beta_l H_M} (which drives quantum tunneling transitions) for p layers.

Understanding the Symbols

Symbol / Term	Meaning	Beginner Interpretation
$H_C$	Problem Cost Hamiltonian	Diagonal Ising operator encoding the combinatorial cost to be minimized
$H_M$	Transverse Mixer Hamiltonian	Sum of Pauli-X operators driving quantum tunneling transitions between states
$\boldsymbol{\gamma}, \boldsymbol{\beta}$	Variational angle parameters	Parameters tuned by classical optimizer to minimize energy expectation
$p$	QAOA circuit depth / layers	Number of alternating cost-mixer layers; higher $p$ approaches optimal solution

📊 Numerical Example

Solving a 2-node Max-Cut problem with cost Hamiltonian H_C = 0.5*(I - Z0 Z1) using p = 1 QAOA layer with gamma = pi/4 and beta = pi/8:

Step 1: Initial Superposition State

|+\rangle

⊗2:

|\psi0\rangle

= (

|00\rangle

|01\rangle

|10\rangle

|11\rangle

) / 2 Step 2: Cost Unitary Evolution e^{-i γ H_C}: Eigenvalues of H_C: • For

|00\rangle

and

|11\rangle

(uncut edges): H_C = 0 → phase = e^0 = 1 • For

|01\rangle

and

|10\rangle

(cut edges): H_C = 1 → phase = e^{-i π/4} State becomes:

|\psi1\rangle

= 0.5

|00\rangle

+ 0.5 e^{-i π/4}

|01\rangle

+ 0.5 e^{-i π/4}

|10\rangle

+ 0.5

|11\rangle

Step 3: Mixer Unitary Evolution e^{-i β H_M} with β = π/8: Rotates all qubits with Rx(2β) = Rx(π/4): Constructive interference amplifies the cut states

|01\rangle

and

|10\rangle

. Step 4: Expectation Value Evaluation: ⟨H_C⟩ = 0.5 × (1 + sin(2β) sin(2γ)) = 0.5 × (1 + sin(π/4) sin(π/2)) = 0.5 × (1 + 0.7071 × 1.0) = 0.5 × 1.7071 = 0.8536 (Approximation ratio = 85.4% of maximum cut 1.0!)

Result: QAOA achieves an 85.4% approximation ratio for the optimal cut in just 1 layer, favoring solutions $|01\rangle$ and $|10\rangle$ .

⚙️ How Does It Work?

Problem Mapping to QUBO/Ising

Encode constraints and objective functions (e.g. feature selection penalties) into matrix Q or Ising coefficients.

Equal Superposition Initialization

Apply Hadamard gates across all qubits to initialize the search state uniformly.

Alternating Unitary Evolution

Apply cost Hamiltonian $e^{-i\gamma H_C}$ to encode phase penalties, followed by mixer Hamiltonian $e^{-i\beta H_M}$ to induce quantum transitions.

Classical Parameter Optimization

Measure bitstrings, compute energy expectation, and update angles $(\gamma, \beta)$ using classical gradient-free optimizers.

🌍 Where Is It Used?

Optimal Feature Selection in Credit Risk

Problem: Selecting the best 20 features out of 500 financial indicators involves $10^{35}$ combinations.

Solution: Formulating correlation maximization and multicollinearity penalties as a QUBO solved on quantum hardware in seconds.

Autonomous Fleet Route Planning

Problem: Traveling Salesperson and Vehicle Routing problems scale factorially with delivery destinations.

Solution: Quantum annealing schedules find near-optimal delivery paths avoiding urban congestion bottlenecks.

🎯 Try It Yourself

What are the two alternating Hamiltonians applied in each layer of QAOA?

Interactive activity component

🐍 Python Hands-On: Quantum Portfolio Optimization with SamplingVQE in Qiskit Finance

Formulate a 4-asset portfolio selection problem as a Quadratic Program and solve for optimal asset allocation using SamplingVQE and TwoLocal ansatz.

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-finance qiskit-optimization qiskit-algorithms numpy pandas matplotlib

Packages:

qiskitqiskit-financeqiskit-optimizationqiskit-algorithmsnumpypandasmatplotlib

2Import Libraries

Import Statementspython

1 import numpy as np
2 import pandas as pd
3 import matplotlib.pyplot as plt
4 from datetime import datetime
5 from qiskit_finance.data_providers import RandomDataProvider
6 from qiskit_finance.applications.optimization import PortfolioOptimization
7 from qiskit_optimization.algorithms import MinimumEigenOptimizer
8 from qiskit.primitives import Sampler
9 from qiskit.circuit.library import TwoLocal
10 from qiskit_algorithms import SamplingVQE
11 from qiskit_algorithms.optimizers import COBYLA

import numpy as np → NumPy array processing

import pandas as pd → Pandas dataframes

import matplotlib.pyplot as plt → Matplotlib for visualization

from datetime import datetime → Date time helper

from qiskit_finance.data_providers import RandomDataProvider → Financial market data provider

from qiskit_finance.applications.optimization import PortfolioOptimization → Portfolio optimization problem generator

from qiskit_optimization.algorithms import MinimumEigenOptimizer → Optimization wrapper for eigensolvers

from qiskit.primitives import Sampler → Qiskit Sampler primitive

from qiskit.circuit.library import TwoLocal → Hardware-efficient TwoLocal ansatz

from qiskit_algorithms import SamplingVQE → Sampling Variational Quantum Eigensolver

from qiskit_algorithms.optimizers import COBYLA → COBYLA classical optimizer

3Demonstration Code & Logic

Python Execution Codepython

1 # Step 1: Generate Synthetic Financial Market Data for 4 Assets
2 num_assets = 4
3 start = datetime(2022, 1, 1)
4 end = datetime(2023, 1, 1)
5 data_provider = RandomDataProvider(tickers=['AAPL', 'GOOGL', 'MSFT', 'TSLA'], start=start, end=end, seed=42)
6 data_provider.run()
7 stock_data = data_provider.get_covariance_matrix()
8 expected_returns = np.mean(stock_data, axis=0)
9  
10 # Step 2: Define Portfolio Optimization Problem (Budget = 2 assets)
11 risk_factor = 0.5  # Risk tolerance trade-off
12 budget = 2       # Select best 2 out of 4 assets
13 portfolio = PortfolioOptimization(expected_returns=expected_returns, covariances=stock_data, risk_factor=risk_factor, budget=budget)
14 quadratic_program = portfolio.to_quadratic_program()
15  
16 # Step 3: Solve Using SamplingVQE and TwoLocal Ansatz
17 ansatz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz')
18 optimizer = COBYLA(maxiter=100)
19 sampler = Sampler()
20 sampling_vqe = SamplingVQE(sampler=sampler, ansatz=ansatz, optimizer=optimizer)
21 qaoa = MinimumEigenOptimizer(sampling_vqe)
22 result = qaoa.solve(quadratic_program)
23  
24 # Step 4: Interpret Results
25 optimal_portfolio = portfolio.interpret(result)
26 selected_assets = np.where(np.atleast_1d(optimal_portfolio) == 1)[0]
27 tickers = ['AAPL', 'GOOGL', 'MSFT', 'TSLA']
28 selected_tickers = [tickers[i] for i in selected_assets]
29 print("Optimal Portfolio Allocation:", selected_tickers)

Step-by-Step Code Breakdown:

# Step 1: Generate Synthetic Financial Market Data for 4 Assets

Data generation

num_assets = 4

4 stock assets

start = datetime(2022, 1, 1)

Start date

end = datetime(2023, 1, 1)

End date

data_provider = RandomDataProvider(tickers=['AAPL', 'GOOGL', 'MSFT', 'TSLA'], start=start, end=end, seed=42)

Data provider

data_provider.run()

Run simulation

stock_data = data_provider.get_covariance_matrix()

Covariance matrix

expected_returns = np.mean(stock_data, axis=0)

Mean expected returns

# Step 2: Define Portfolio Optimization Problem (Budget = 2 assets)

Problem definition

risk_factor = 0.5 # Risk tolerance trade-off

Risk penalty

budget = 2 # Select best 2 out of 4 assets

Asset budget

portfolio = PortfolioOptimization(expected_returns=expected_returns, covariances=stock_data, risk_factor=risk_factor, budget=budget)

Portfolio formulation

quadratic_program = portfolio.to_quadratic_program()

Convert to Quadratic Program

# Step 3: Solve Using SamplingVQE and TwoLocal Ansatz

Quantum optimization

ansatz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz')

Variational ansatz

optimizer = COBYLA(maxiter=100)

Classical optimizer

sampler = Sampler()

Sampler primitive

sampling_vqe = SamplingVQE(sampler=sampler, ansatz=ansatz, optimizer=optimizer)

SamplingVQE

qaoa = MinimumEigenOptimizer(sampling_vqe)

MinimumEigenOptimizer

result = qaoa.solve(quadratic_program)

Solve problem

# Step 4: Interpret Results

Result interpretation

optimal_portfolio = portfolio.interpret(result)

Extract binary selection

selected_assets = np.where(np.atleast_1d(optimal_portfolio) == 1)[0]

Find selected asset indices

tickers = ['AAPL', 'GOOGL', 'MSFT', 'TSLA']

Stock names

selected_tickers = [tickers[i] for i in selected_assets]

Selected tickers

print("Optimal Portfolio Allocation:", selected_tickers)

Print selected stocks

📋 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 Portfolio Optimization with SamplingVQE in Qiskit Finance
3 # Prepared for Google Colab (Run with Shift + Enter)
4 # =========================================================
5  
6 # Step 1: Install required packages
7 !pip install qiskit qiskit-finance qiskit-optimization qiskit-algorithms numpy pandas matplotlib
8  
9 # Step 2: Import libraries
10 import numpy as np
11 import pandas as pd
12 import matplotlib.pyplot as plt
13 from datetime import datetime
14 from qiskit_finance.data_providers import RandomDataProvider
15 from qiskit_finance.applications.optimization import PortfolioOptimization
16 from qiskit_optimization.algorithms import MinimumEigenOptimizer
17 from qiskit.primitives import Sampler
18 from qiskit.circuit.library import TwoLocal
19 from qiskit_algorithms import SamplingVQE
20 from qiskit_algorithms.optimizers import COBYLA
21  
22 # Step 3: Run Demonstration
23 # Step 1: Generate Synthetic Financial Market Data for 4 Assets
24 num_assets = 4
25 start = datetime(2022, 1, 1)
26 end = datetime(2023, 1, 1)
27 data_provider = RandomDataProvider(tickers=['AAPL', 'GOOGL', 'MSFT', 'TSLA'], start=start, end=end, seed=42)
28 data_provider.run()
29 stock_data = data_provider.get_covariance_matrix()
30 expected_returns = np.mean(stock_data, axis=0)
31  
32 # Step 2: Define Portfolio Optimization Problem (Budget = 2 assets)
33 risk_factor = 0.5  # Risk tolerance trade-off
34 budget = 2       # Select best 2 out of 4 assets
35 portfolio = PortfolioOptimization(expected_returns=expected_returns, covariances=stock_data, risk_factor=risk_factor, budget=budget)
36 quadratic_program = portfolio.to_quadratic_program()
37  
38 # Step 3: Solve Using SamplingVQE and TwoLocal Ansatz
39 ansatz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz')
40 optimizer = COBYLA(maxiter=100)
41 sampler = Sampler()
42 sampling_vqe = SamplingVQE(sampler=sampler, ansatz=ansatz, optimizer=optimizer)
43 qaoa = MinimumEigenOptimizer(sampling_vqe)
44 result = qaoa.solve(quadratic_program)
45  
46 # Step 4: Interpret Results
47 optimal_portfolio = portfolio.interpret(result)
48 selected_assets = np.where(np.atleast_1d(optimal_portfolio) == 1)[0]
49 tickers = ['AAPL', 'GOOGL', 'MSFT', 'TSLA']
50 selected_tickers = [tickers[i] for i in selected_assets]
51 print("Optimal Portfolio Allocation:", selected_tickers)

⚡ 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

Financial Risk Formulation

Generates asset price returns and covariance matrix across AAPL, GOOGL, MSFT, and TSLA.

→

Quadratic Program Mapping

Formulates Markowitz portfolio selection balancing expected return against risk covariance under a budget constraint of 2 assets.

→

SamplingVQE Convergence

Executes SamplingVQE with TwoLocal ansatz, measuring the minimum eigenvalue bitstring that identifies the optimal assets.

📥 Input / Initial State

4 stocks (AAPL, GOOGL, MSFT, TSLA) with risk factor 0.5 and budget 2

📤 Expected Output

Optimal Portfolio Allocation: ['AAPL', 'GOOGL']

💡 What Does This Demonstration Show?

The quantum eigensolver successfully identified the optimal portfolio combination that maximizes financial returns while minimizing risk variance under budget constraints.

Course Learning Resource • Slide DeckLesson 1412 Slides

Lesson 14: Quantum Optimization for Portfolio Selection

Asset covariance matrices, Quadratic Programming, TwoLocal ansatz, and SamplingVQE portfolio optimization.

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: How does quantum annealing find low-energy states in rugged optimization landscapes?

Question 2: In QUBO optimization, what values do the decision variables x_i take?

Previous: Quantum Data Processing & Quantum RAM Next: Hybrid Classical-Quantum AI Architectures

1	import numpy as np
2	import pandas as pd
3	import matplotlib.pyplot as plt
4	from datetime import datetime
5	from qiskit_finance.data_providers import RandomDataProvider
6	from qiskit_finance.applications.optimization import PortfolioOptimization
7	from qiskit_optimization.algorithms import MinimumEigenOptimizer
8	from qiskit.primitives import Sampler
9	from qiskit.circuit.library import TwoLocal
10	from qiskit_algorithms import SamplingVQE
11	from qiskit_algorithms.optimizers import COBYLA

1	# =========================================================
2	# Quantum Portfolio Optimization with SamplingVQE in Qiskit Finance
3	# Prepared for Google Colab (Run with Shift + Enter)
4	# =========================================================
5
6	# Step 1: Install required packages
7	!pip install qiskit qiskit-finance qiskit-optimization qiskit-algorithms numpy pandas matplotlib
8
9	# Step 2: Import libraries
10	import numpy as np
11	import pandas as pd
12	import matplotlib.pyplot as plt
13	from datetime import datetime
14	from qiskit_finance.data_providers import RandomDataProvider
15	from qiskit_finance.applications.optimization import PortfolioOptimization
16	from qiskit_optimization.algorithms import MinimumEigenOptimizer
17	from qiskit.primitives import Sampler
18	from qiskit.circuit.library import TwoLocal
19	from qiskit_algorithms import SamplingVQE
20	from qiskit_algorithms.optimizers import COBYLA
21
22	# Step 3: Run Demonstration
23	# Step 1: Generate Synthetic Financial Market Data for 4 Assets
24	num_assets = 4
25	start = datetime(2022, 1, 1)
26	end = datetime(2023, 1, 1)
27	data_provider = RandomDataProvider(tickers=['AAPL', 'GOOGL', 'MSFT', 'TSLA'], start=start, end=end, seed=42)
28	data_provider.run()
29	stock_data = data_provider.get_covariance_matrix()
30	expected_returns = np.mean(stock_data, axis=0)
31
32	# Step 2: Define Portfolio Optimization Problem (Budget = 2 assets)
33	risk_factor = 0.5 # Risk tolerance trade-off
34	budget = 2 # Select best 2 out of 4 assets
35	portfolio = PortfolioOptimization(expected_returns=expected_returns, covariances=stock_data, risk_factor=risk_factor, budget=budget)
36	quadratic_program = portfolio.to_quadratic_program()
37
38	# Step 3: Solve Using SamplingVQE and TwoLocal Ansatz
39	ansatz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz')
40	optimizer = COBYLA(maxiter=100)
41	sampler = Sampler()
42	sampling_vqe = SamplingVQE(sampler=sampler, ansatz=ansatz, optimizer=optimizer)
43	qaoa = MinimumEigenOptimizer(sampling_vqe)
44	result = qaoa.solve(quadratic_program)
45
46	# Step 4: Interpret Results
47	optimal_portfolio = portfolio.interpret(result)
48	selected_assets = np.where(np.atleast_1d(optimal_portfolio) == 1)[0]
49	tickers = ['AAPL', 'GOOGL', 'MSFT', 'TSLA']
50	selected_tickers = [tickers[i] for i in selected_assets]
51	print("Optimal Portfolio Allocation:", selected_tickers)