quantumflow-sdk 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

quantumflow/pipeline/finance/portfolio_optimization.py

@@ -0,0 +1,595 @@
+"""
+Portfolio Optimization Pipeline with QAOA.
+
+Uses Quantum Approximate Optimization Algorithm for portfolio
+optimization with risk metrics, regime detection, and auto-rollback.
+
+Example:
+    pipeline = PortfolioOptimizationPipeline(
+        name="Tech Portfolio",
+        assets=["AAPL", "GOOGL", "MSFT", "AMZN"],
+        expected_returns=[0.12, 0.10, 0.11, 0.09],
+        covariance_matrix=cov_matrix,
+        initial_capital=100000,
+    )
+
+    result = pipeline.run(total_steps=50)
+    print(f"Final Sharpe: {result.final_state.metrics['sharpe_ratio']}")
+"""
+
+import math
+import random
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+from enum import Enum
+
+from quantumflow.pipeline.base_pipeline import (
+    BasePipeline,
+    PipelineConfig,
+    PipelineState,
+)
+from quantumflow.pipeline.anomaly_detector import (
+    AnomalyDetector,
+    create_var_detector,
+    create_drawdown_detector,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class MarketRegime(str, Enum):
+    """Market regime classification."""
+
+    BULL = "bull"
+    BEAR = "bear"
+    SIDEWAYS = "sideways"
+    CRISIS = "crisis"
+
+
+@dataclass
+class PortfolioConfig(PipelineConfig):
+    """Configuration for portfolio optimization pipeline."""
+
+    # Assets
+    assets: List[str] = field(default_factory=list)
+    expected_returns: List[float] = field(default_factory=list)
+    covariance_matrix: List[List[float]] = field(default_factory=list)
+
+    # Capital
+    initial_capital: float = 100000.0
+
+    # QAOA settings
+    n_qubits: int = 8
+    qaoa_depth: int = 2
+    optimizer: str = "COBYLA"
+
+    # Risk constraints
+    max_var: float = 0.05  # 5% VaR limit
+    max_drawdown: float = 0.20  # 20% max drawdown
+    target_return: float = 0.10  # 10% target annual return
+    risk_free_rate: float = 0.02  # 2% risk-free rate
+
+    # Rebalancing
+    rebalance_threshold: float = 0.05  # 5% drift triggers rebalance
+
+
+@dataclass
+class PortfolioState(PipelineState):
+    """State for portfolio optimization pipeline."""
+
+    # Portfolio weights
+    weights: List[float] = field(default_factory=list)
+    weights_history: List[List[float]] = field(default_factory=list)
+
+    # Value tracking
+    portfolio_value: float = 0.0
+    value_history: List[float] = field(default_factory=list)
+    peak_value: float = 0.0
+
+    # Risk metrics
+    var: float = 0.0  # Value at Risk
+    cvar: float = 0.0  # Conditional VaR
+    sharpe_ratio: float = 0.0
+    sortino_ratio: float = 0.0
+    max_drawdown: float = 0.0
+    current_drawdown: float = 0.0
+
+    # Regime
+    market_regime: str = "sideways"
+    regime_history: List[str] = field(default_factory=list)
+
+    # QAOA state
+    qaoa_parameters: List[float] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize to dictionary."""
+        base = super().to_dict()
+        base.update({
+            "weights": self.weights,
+            "weights_history": self.weights_history,
+            "portfolio_value": self.portfolio_value,
+            "value_history": self.value_history,
+            "peak_value": self.peak_value,
+            "var": self.var,
+            "cvar": self.cvar,
+            "sharpe_ratio": self.sharpe_ratio,
+            "sortino_ratio": self.sortino_ratio,
+            "max_drawdown": self.max_drawdown,
+            "current_drawdown": self.current_drawdown,
+            "market_regime": self.market_regime,
+            "regime_history": self.regime_history,
+            "qaoa_parameters": self.qaoa_parameters,
+        })
+        return base
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "PortfolioState":
+        """Deserialize from dictionary."""
+        state = cls()
+        state.step = data.get("step", 0)
+        state.data = data.get("data", {})
+        state.metrics = data.get("metrics", {})
+        state.gradient_history = data.get("gradient_history", [])
+        state.weights = data.get("weights", [])
+        state.weights_history = data.get("weights_history", [])
+        state.portfolio_value = data.get("portfolio_value", 0.0)
+        state.value_history = data.get("value_history", [])
+        state.peak_value = data.get("peak_value", 0.0)
+        state.var = data.get("var", 0.0)
+        state.cvar = data.get("cvar", 0.0)
+        state.sharpe_ratio = data.get("sharpe_ratio", 0.0)
+        state.sortino_ratio = data.get("sortino_ratio", 0.0)
+        state.max_drawdown = data.get("max_drawdown", 0.0)
+        state.current_drawdown = data.get("current_drawdown", 0.0)
+        state.market_regime = data.get("market_regime", "sideways")
+        state.regime_history = data.get("regime_history", [])
+        state.qaoa_parameters = data.get("qaoa_parameters", [])
+        return state
+
+
+class PortfolioOptimizationPipeline(BasePipeline):
+    """
+    Pipeline for portfolio optimization using QAOA.
+
+    Features:
+    - QAOA-based portfolio optimization
+    - Risk metrics: VaR, CVaR, Sharpe, Sortino
+    - Market regime detection
+    - Auto-rollback on max drawdown breach
+    """
+
+    def __init__(
+        self,
+        name: str,
+        assets: List[str],
+        expected_returns: List[float],
+        covariance_matrix: Optional[List[List[float]]] = None,
+        initial_capital: float = 100000.0,
+        config: Optional[PortfolioConfig] = None,
+        **kwargs,
+    ):
+        """
+        Initialize portfolio optimization pipeline.
+
+        Args:
+            name: Pipeline name
+            assets: List of asset symbols
+            expected_returns: Expected annual returns
+            covariance_matrix: Return covariance matrix
+            initial_capital: Starting capital
+            config: Pipeline configuration
+        """
+        if config is None:
+            config = PortfolioConfig(
+                assets=assets,
+                expected_returns=expected_returns,
+                covariance_matrix=covariance_matrix or [],
+                initial_capital=initial_capital,
+            )
+
+        super().__init__(name=name, config=config, **kwargs)
+
+        self._assets = assets
+        self._returns = expected_returns
+        self._cov = covariance_matrix or self._generate_covariance(len(assets))
+        self._initial_capital = initial_capital
+
+        self._qaoa = None
+
+        # Setup anomaly detectors
+        self._setup_anomaly_detectors()
+
+    @property
+    def pipeline_type(self) -> str:
+        return "portfolio_optimization"
+
+    def _setup_anomaly_detectors(self):
+        """Configure domain-specific anomaly detectors."""
+        detector = AnomalyDetector()
+
+        config = self.config
+        if isinstance(config, PortfolioConfig):
+            # VaR breach detector
+            detector.register_detector(
+                "var_breach",
+                create_var_detector(max_var_breach=config.max_var),
+            )
+
+            # Drawdown detector
+            detector.register_detector(
+                "drawdown_breach",
+                create_drawdown_detector(max_drawdown=config.max_drawdown),
+            )
+
+        self.set_anomaly_detector(detector)
+
+    def _generate_covariance(self, n: int) -> List[List[float]]:
+        """Generate random positive semi-definite covariance matrix."""
+        # Generate random correlation-like matrix
+        cov = [[0.0] * n for _ in range(n)]
+
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    cov[i][j] = random.uniform(0.01, 0.04)  # Variance
+                elif i < j:
+                    cov[i][j] = random.uniform(-0.01, 0.02)  # Covariance
+                    cov[j][i] = cov[i][j]
+
+        return cov
+
+    def _get_qaoa(self):
+        """Get or create QAOA instance."""
+        if self._qaoa is None:
+            try:
+                from quantumflow.algorithms.optimization.qaoa import QuantumQAOA
+
+                config = self.config
+                n_qubits = config.n_qubits if isinstance(config, PortfolioConfig) else 8
+
+                self._qaoa = QuantumQAOA(
+                    n_qubits=n_qubits,
+                    backend=self.config.backend,
+                )
+            except ImportError:
+                logger.warning("QAOA not available, using classical optimization")
+
+        return self._qaoa
+
+    def initialize(self) -> PortfolioState:
+        """Initialize portfolio state."""
+        state = PortfolioState()
+
+        n_assets = len(self._assets)
+
+        # Equal weight initialization
+        state.weights = [1.0 / n_assets] * n_assets
+        state.weights_history.append(state.weights.copy())
+
+        # Initial values
+        state.portfolio_value = self._initial_capital
+        state.value_history.append(state.portfolio_value)
+        state.peak_value = state.portfolio_value
+
+        # Initialize QAOA parameters
+        config = self.config
+        depth = config.qaoa_depth if isinstance(config, PortfolioConfig) else 2
+        state.qaoa_parameters = [
+            random.uniform(0, 2 * math.pi) for _ in range(2 * depth)
+        ]
+
+        # Compute initial risk metrics
+        state = self._compute_risk_metrics(state)
+
+        # Detect initial regime
+        state.market_regime = self._detect_regime(state)
+        state.regime_history.append(state.market_regime)
+
+        # Update metrics
+        state.update_metrics(
+            portfolio_value=state.portfolio_value,
+            var=state.var,
+            sharpe_ratio=state.sharpe_ratio,
+            max_drawdown=state.max_drawdown,
+            regime=state.market_regime,
+        )
+
+        return state
+
+    def execute_step(self, step: int, state: PortfolioState) -> PortfolioState:
+        """Execute one optimization step."""
+        config = self.config
+        if not isinstance(config, PortfolioConfig):
+            config = PortfolioConfig()
+
+        # Get QAOA optimizer
+        qaoa = self._get_qaoa()
+
+        if qaoa:
+            try:
+                # Formulate portfolio optimization as QUBO
+                qubo = self._create_portfolio_qubo(state, config)
+
+                # Run QAOA
+                qaoa_result = qaoa.optimize(
+                    problem=qubo,
+                    p=config.qaoa_depth,
+                    initial_params=state.qaoa_parameters,
+                )
+
+                # Extract optimal weights
+                if "solution" in qaoa_result:
+                    state.weights = self._decode_weights(
+                        qaoa_result["solution"], len(self._assets)
+                    )
+
+                state.qaoa_parameters = qaoa_result.get(
+                    "optimal_params", state.qaoa_parameters
+                )
+
+                # Track gradient
+                if "gradient" in qaoa_result:
+                    grad_norm = math.sqrt(sum(g * g for g in qaoa_result["gradient"]))
+                    state.add_gradient(grad_norm)
+
+            except Exception as e:
+                logger.warning(f"QAOA optimization failed: {e}")
+                state = self._classical_optimization_step(state, config)
+        else:
+            state = self._classical_optimization_step(state, config)
+
+        # Normalize weights
+        state.weights = self._normalize_weights(state.weights)
+        state.weights_history.append(state.weights.copy())
+
+        # Simulate portfolio return for this step
+        step_return = self._simulate_step_return(state.weights)
+        state.portfolio_value *= (1 + step_return)
+        state.value_history.append(state.portfolio_value)
+
+        # Update peak value
+        if state.portfolio_value > state.peak_value:
+            state.peak_value = state.portfolio_value
+
+        # Compute drawdown
+        if state.peak_value > 0:
+            state.current_drawdown = (state.peak_value - state.portfolio_value) / state.peak_value
+            state.max_drawdown = max(state.max_drawdown, state.current_drawdown)
+
+        # Compute risk metrics
+        state = self._compute_risk_metrics(state)
+
+        # Detect market regime
+        state.market_regime = self._detect_regime(state)
+        state.regime_history.append(state.market_regime)
+
+        # Update metrics
+        state.update_metrics(
+            portfolio_value=state.portfolio_value,
+            var=state.var,
+            cvar=state.cvar,
+            sharpe_ratio=state.sharpe_ratio,
+            sortino_ratio=state.sortino_ratio,
+            max_drawdown=state.max_drawdown,
+            current_drawdown=state.current_drawdown,
+            regime=state.market_regime,
+        )
+
+        return state
+
+    def _classical_optimization_step(
+        self, state: PortfolioState, config: PortfolioConfig
+    ) -> PortfolioState:
+        """Perform classical mean-variance optimization step."""
+        n = len(self._assets)
+
+        # Simple gradient-based update
+        gradients = []
+
+        for i in range(n):
+            # Expected return contribution
+            ret_grad = self._returns[i] if i < len(self._returns) else 0.1
+
+            # Risk contribution (variance + covariance)
+            risk_grad = 0.0
+            for j in range(n):
+                if i < len(self._cov) and j < len(self._cov[i]):
+                    risk_grad += 2 * state.weights[j] * self._cov[i][j]
+
+            # Sharpe-like gradient (return / risk)
+            grad = ret_grad - 0.5 * risk_grad
+            gradients.append(grad)
+
+        # Update weights
+        learning_rate = 0.1
+        for i in range(n):
+            state.weights[i] += learning_rate * gradients[i]
+
+        # Track gradient
+        grad_norm = math.sqrt(sum(g * g for g in gradients))
+        state.add_gradient(grad_norm)
+
+        return state
+
+    def _normalize_weights(self, weights: List[float]) -> List[float]:
+        """Normalize weights to sum to 1, enforce non-negative."""
+        # Make non-negative
+        weights = [max(0, w) for w in weights]
+
+        total = sum(weights)
+        if total == 0:
+            # Equal weights if all zero
+            n = len(weights)
+            return [1.0 / n] * n
+
+        return [w / total for w in weights]
+
+    def _create_portfolio_qubo(
+        self, state: PortfolioState, config: PortfolioConfig
+    ) -> Dict[str, Any]:
+        """Create QUBO formulation for portfolio optimization."""
+        n = len(self._assets)
+
+        # Simplified QUBO: maximize return - lambda * risk
+        qubo = {}
+        risk_aversion = 2.0
+
+        for i in range(n):
+            # Linear term (expected return)
+            ret = self._returns[i] if i < len(self._returns) else 0.1
+            qubo[(i, i)] = -ret  # Negative because QAOA minimizes
+
+            # Quadratic term (covariance = risk)
+            for j in range(i, n):
+                if i < len(self._cov) and j < len(self._cov[i]):
+                    cov_val = self._cov[i][j]
+                    qubo[(i, j)] = qubo.get((i, j), 0) + risk_aversion * cov_val
+
+        return {
+            "type": "portfolio",
+            "qubo": qubo,
+            "n_assets": n,
+            "target_return": config.target_return,
+        }
+
+    def _decode_weights(self, solution: Any, n_assets: int) -> List[float]:
+        """Decode QAOA solution to portfolio weights."""
+        if isinstance(solution, list):
+            if len(solution) >= n_assets:
+                return solution[:n_assets]
+            else:
+                # Pad with zeros
+                return solution + [0.0] * (n_assets - len(solution))
+
+        if isinstance(solution, dict):
+            weights = [0.0] * n_assets
+            for key, value in solution.items():
+                if isinstance(key, int) and key < n_assets:
+                    weights[key] = value
+            return weights
+
+        # Fallback to equal weights
+        return [1.0 / n_assets] * n_assets
+
+    def _simulate_step_return(self, weights: List[float]) -> float:
+        """Simulate portfolio return for one step."""
+        # Generate random returns based on expected returns and covariance
+        n = len(weights)
+
+        # Simple: weighted average of expected returns + noise
+        expected = sum(
+            w * (self._returns[i] if i < len(self._returns) else 0.1) / 252  # Daily return
+            for i, w in enumerate(weights)
+        )
+
+        # Add volatility-based noise
+        vol = self._compute_portfolio_volatility(weights)
+        noise = random.gauss(0, vol / math.sqrt(252))  # Daily volatility
+
+        return expected + noise
+
+    def _compute_portfolio_volatility(self, weights: List[float]) -> float:
+        """Compute portfolio volatility."""
+        n = len(weights)
+        variance = 0.0
+
+        for i in range(n):
+            for j in range(n):
+                if i < len(self._cov) and j < len(self._cov[i]):
+                    variance += weights[i] * weights[j] * self._cov[i][j]
+
+        return math.sqrt(max(0, variance))
+
+    def _compute_risk_metrics(self, state: PortfolioState) -> PortfolioState:
+        """Compute risk metrics."""
+        if len(state.value_history) < 2:
+            return state
+
+        # Calculate returns
+        returns = []
+        for i in range(1, len(state.value_history)):
+            ret = (state.value_history[i] - state.value_history[i - 1]) / state.value_history[i - 1]
+            returns.append(ret)
+
+        if not returns:
+            return state
+
+        # Mean and std of returns
+        mean_return = sum(returns) / len(returns)
+        variance = sum((r - mean_return) ** 2 for r in returns) / len(returns)
+        std_return = math.sqrt(variance) if variance > 0 else 0.0001
+
+        # VaR (95% confidence)
+        sorted_returns = sorted(returns)
+        var_index = int(0.05 * len(sorted_returns))
+        state.var = -sorted_returns[var_index] if var_index < len(sorted_returns) else 0
+
+        # CVaR (Expected Shortfall)
+        if var_index > 0:
+            state.cvar = -sum(sorted_returns[:var_index]) / var_index
+        else:
+            state.cvar = state.var
+
+        # Sharpe Ratio
+        config = self.config
+        rf = config.risk_free_rate / 252 if isinstance(config, PortfolioConfig) else 0.02 / 252
+        state.sharpe_ratio = (mean_return - rf) / std_return if std_return > 0 else 0
+
+        # Sortino Ratio (downside deviation)
+        downside_returns = [r for r in returns if r < rf]
+        if downside_returns:
+            downside_var = sum((r - rf) ** 2 for r in downside_returns) / len(downside_returns)
+            downside_std = math.sqrt(downside_var)
+            state.sortino_ratio = (mean_return - rf) / downside_std if downside_std > 0 else 0
+        else:
+            state.sortino_ratio = state.sharpe_ratio
+
+        return state
+
+    def _detect_regime(self, state: PortfolioState) -> str:
+        """Detect market regime based on returns."""
+        if len(state.value_history) < 20:
+            return MarketRegime.SIDEWAYS.value
+
+        # Look at recent returns
+        recent_values = state.value_history[-20:]
+        returns = [
+            (recent_values[i] - recent_values[i - 1]) / recent_values[i - 1]
+            for i in range(1, len(recent_values))
+        ]
+
+        mean_return = sum(returns) / len(returns)
+        volatility = math.sqrt(sum((r - mean_return) ** 2 for r in returns) / len(returns))
+
+        # Classify regime
+        if mean_return > 0.001 and volatility < 0.02:
+            return MarketRegime.BULL.value
+        elif mean_return < -0.001 and volatility < 0.02:
+            return MarketRegime.BEAR.value
+        elif volatility > 0.03:
+            return MarketRegime.CRISIS.value
+        else:
+            return MarketRegime.SIDEWAYS.value
+
+    def get_state_for_checkpoint(self, state: PipelineState) -> Dict[str, Any]:
+        """Get state for checkpoint."""
+        if isinstance(state, PortfolioState):
+            return state.to_dict()
+        return state.to_dict()
+
+    def restore_state_from_checkpoint(self, checkpoint_data: Dict[str, Any]) -> PortfolioState:
+        """Restore state from checkpoint."""
+        return PortfolioState.from_dict(checkpoint_data)
+
+    def should_stop(self, state: PipelineState) -> bool:
+        """Check stopping criteria."""
+        if not isinstance(state, PortfolioState):
+            return False
+
+        # Stop if Sharpe ratio is good and stable
+        if state.sharpe_ratio > 2.0:
+            logger.info(f"Target Sharpe ratio achieved: {state.sharpe_ratio:.2f}")
+            return True
+
+        return False

quantumflow/pipeline/healthcare/__init__.py

@@ -0,0 +1,5 @@
+"""Healthcare domain pipelines."""
+
+from quantumflow.pipeline.healthcare.protein_folding import ProteinFoldingPipeline
+
+__all__ = ["ProteinFoldingPipeline"]