Quantum Machine Learning for Finance

A comprehensive Python framework leveraging quantum computing and machine learning for advanced financial modeling and analysis.

Overview

This project combines quantum computing algorithms with machine learning techniques to solve complex financial problems that are computationally intensive for classical computers. The framework provides tools for portfolio optimization, option pricing, risk analysis, and market prediction using quantum circuits and hybrid quantum-classical algorithms.

Features

🔬 Quantum Portfolio Optimization

• QAOA-based Portfolio Optimization: Use Quantum Approximate Optimization Algorithm for portfolio selection
• Risk-Return Trade-off: Optimize portfolios based on modern portfolio theory
• Constraint Handling: Support for various investment constraints

💰 Quantum Option Pricing

• Quantum Monte Carlo: Accelerated Monte Carlo simulations for option pricing
• Quantum Amplitude Estimation: Faster convergence for derivative pricing
• Multi-asset Options: Support for complex multi-asset derivatives

📊 Quantum Risk Analysis

• VaR Calculation: Quantum-enhanced Value at Risk computation
• Credit Risk Modeling: Quantum machine learning for credit scoring
• Market Risk Assessment: Volatility and correlation analysis

🤖 Quantum Reinforcement Learning (Q-Learning)

• Classical Q-Learning: Tabular Q-learning for trading strategies
• Deep Q-Networks (DQN): Neural network Q-value approximation with experience replay
• Quantum Q-Learning: Variational quantum circuits for Q-value function approximation
• Hybrid Quantum-Classical: Quantum feature extraction with classical decision-making
• Trading Environment: Realistic trading simulator with transaction costs

🔧 Utilities

• Data Preprocessing: Financial data cleaning and normalization
• Quantum Circuit Builders: Customizable quantum circuit templates
• Visualization: Plot quantum circuits and financial results
• Backtesting: Framework for strategy evaluation

Installation

Prerequisites

• Python 3.8 or higher
• pip package manager

Install from source

git clone https://github.com/yourusername/Quantum-Machine-Learning-For-Finance.git
cd Quantum-Machine-Learning-For-Finance
pip install -r requirements.txt
pip install -e .

Quick Start

Portfolio Optimization Example

from qml_finance.portfolio import QuantumPortfolioOptimizer
import numpy as np

# Historical returns data
returns = np.array([...])  # Your asset returns

# Create optimizer
optimizer = QuantumPortfolioOptimizer(
    n_assets=5,
    risk_aversion=0.5,
    backend='qasm_simulator'
)

# Optimize portfolio
weights, expected_return, risk = optimizer.optimize(returns)
print(f"Optimal weights: {weights}")
print(f"Expected return: {expected_return:.2%}")
print(f"Portfolio risk: {risk:.2%}")

Option Pricing Example

from qml_finance.pricing import QuantumOptionPricer

# Black-Scholes parameters
pricer = QuantumOptionPricer(
    S0=100,        # Current stock price
    K=105,         # Strike price
    T=1.0,         # Time to maturity
    r=0.05,        # Risk-free rate
    sigma=0.2      # Volatility
)

# Price European call option
call_price = pricer.price_european_call(n_shots=1000)
print(f"Call option price: ${call_price:.2f}")

Risk Analysis Example

from qml_finance.risk import QuantumRiskAnalyzer

# Portfolio data
portfolio_returns = [...]  # Historical returns

analyzer = QuantumRiskAnalyzer()

# Calculate Value at Risk
var_95 = analyzer.calculate_var(portfolio_returns, confidence=0.95)
print(f"95% VaR: ${var_95:.2f}")

# Calculate Conditional VaR (Expected Shortfall)
cvar_95 = analyzer.calculate_cvar(portfolio_returns, confidence=0.95)
print(f"95% CVaR: ${cvar_95:.2f}")

Q-Learning Trading Agent Example

from qml_finance.reinforcement_learning import (
    TradingEnvironment,
    QLearningAgent,
    QuantumQLearningAgent
)

# Create trading environment
env = TradingEnvironment(
    price_data=historical_prices,
    initial_balance=10000.0,
    transaction_cost=0.001,
    window_size=10
)

# Initialize Q-learning agent
agent = QLearningAgent(
    state_dim=env.state_dim,
    n_actions=env.n_actions,
    learning_rate=0.1,
    discount_factor=0.99
)

# Train agent
for episode in range(100):
    total_reward, loss = agent.train_episode(env)
    print(f"Episode {episode}: Reward = {total_reward:.2f}")

# Use trained agent for trading
state = env.reset()
while not done:
    action = agent.choose_action(state, training=False)
    state, reward, done, info = env.step(action)

print(f"Final portfolio value: ${env.portfolio_value:,.2f}")

Quantum Q-Learning Example

from qml_finance.reinforcement_learning import QuantumQLearningAgent

# Initialize quantum Q-learning agent
quantum_agent = QuantumQLearningAgent(
    state_dim=env.state_dim,
    n_actions=env.n_actions,
    n_qubits=4,
    n_layers=2,
    backend='qasm_simulator'
)

# Train with quantum circuits
for episode in range(50):
    total_reward, loss = quantum_agent.train_episode(env)
    print(f"Quantum Episode {episode}: Reward = {total_reward:.2f}")

Architecture

src/qml_finance/
├── portfolio/          # Portfolio optimization algorithms
│   ├── qaoa.py        # QAOA implementation
│   └── optimizer.py   # Main portfolio optimizer
├── pricing/           # Option pricing models
│   ├── monte_carlo.py # Quantum Monte Carlo
│   └── pricer.py      # Main pricing interface
├── risk/              # Risk analysis tools
│   ├── var.py         # Value at Risk
│   └── analyzer.py    # Main risk analyzer
├── reinforcement_learning/  # Q-Learning for trading
│   ├── environment.py       # Trading environment
│   ├── qlearning.py         # Classical Q-learning & DQN
│   └── quantum_qlearning.py # Quantum Q-learning
├── circuits/          # Quantum circuit builders
│   ├── ansatz.py      # Parameterized circuits
│   └── encoding.py    # Data encoding circuits
└── utils/             # Utility functions
    ├── data.py        # Data preprocessing
    └── visualization.py

Dependencies

• Qiskit: IBM's quantum computing framework
• PennyLane: Quantum machine learning library
• NumPy: Numerical computing
• Pandas: Data manipulation
• Matplotlib/Seaborn: Visualization
• scikit-learn: Classical ML algorithms
• yfinance: Financial data retrieval

Quantum Backends

The framework supports multiple quantum backends:

• Simulators: Local simulation for testing and development

  • qasm_simulator: Standard Qiskit simulator
  • statevector_simulator: Statevector simulation

• Real Quantum Hardware: Execute on actual quantum computers

  • IBM Quantum devices (via Qiskit)
  • AWS Braket devices (via PennyLane)

Examples

Explore the examples/ directory for detailed examples:

• portfolio_optimization_example.py: Complete portfolio optimization workflow
• option_pricing_example.py: Compare quantum vs classical pricing
• risk_analysis_example.py: Comprehensive risk analysis and stress testing
• qlearning_trading_example.py: Classical Q-learning and DQN for trading
• quantum_qlearning_example.py: Quantum Q-learning with VQC for algorithmic trading

Testing

Run the test suite:

pytest tests/

Run with coverage:

pytest tests/ --cov=src/qml_finance --cov-report=html

Documentation

Full documentation is available in the docs/ directory:

• User Guide
• API Reference
• Quantum Algorithms
• Performance Benchmarks

Research Papers & References

This project implements algorithms from:

1. Quantum Portfolio Optimization: arXiv:1911.05296
2. Quantum Option Pricing: arXiv:1905.02666
3. Quantum Risk Analysis: arXiv:2004.10242

Performance

Quantum algorithms can provide advantages:

• Portfolio Optimization: Quadratic speedup for large portfolios (>100 assets)
• Option Pricing: Square root speedup in Monte Carlo sampling
• Risk Analysis: Exponential speedup for correlation analysis

Note: Actual performance depends on problem size and quantum hardware availability

Contributing

Contributions are welcome! Please read our Contributing Guide for details on:

• Code style and standards
• Pull request process
• Issue reporting
• Development setup

License

This project is licensed under the MIT License - see the LICENSE file for details.

Citation

If you use this framework in your research, please cite:

@software{quantum_ml_finance,
  title={Quantum Machine Learning for Finance},
  author={Your Name},
  year={2025},
  url={https://github.com/yourusername/Quantum-Machine-Learning-For-Finance}
}

Disclaimer

This software is for educational and research purposes only. It should not be used for actual financial decision-making without proper validation and risk assessment. Quantum computing is an emerging technology, and results may vary based on hardware limitations and noise.

Contact

• Issues: GitHub Issues
• Discussions: GitHub Discussions

Acknowledgments

• IBM Quantum for providing quantum computing resources
• The Qiskit and PennyLane communities
• Financial data providers