superquantx 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

superquantx/algorithms/quantum_agents.py

@@ -19,7 +19,8 @@ without human intervention.
 import logging
 import time
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from collections.abc import Callable
+from typing import Any
 
 import numpy as np
 from sklearn.metrics import accuracy_score
@@ -36,11 +37,11 @@ logger = logging.getLogger(__name__)
 
 class QuantumAgent(BaseQuantumAlgorithm, ABC):
     """Base class for quantum agents.
-    
+
     Quantum agents are specialized combinations of quantum algorithms
     designed for specific problem domains. They provide high-level
     interfaces for complex quantum machine learning workflows.
-    
+
     Args:
         backend: Quantum backend for circuit execution
         agent_config: Configuration dictionary for the agent
@@ -51,8 +52,8 @@ class QuantumAgent(BaseQuantumAlgorithm, ABC):
 
     def __init__(
         self,
-        backend: Union[str, Any],
-        agent_config: Optional[Dict[str, Any]] = None,
+        backend: str | Any,
+        agent_config: dict[str, Any] | None = None,
         shots: int = 1024,
         **kwargs
     ) -> None:
@@ -75,18 +76,18 @@ class QuantumAgent(BaseQuantumAlgorithm, ABC):
     @abstractmethod
     def solve(self, problem_instance: Any, **kwargs) -> QuantumResult:
         """Solve a problem using the quantum agent.
-        
+
         Args:
             problem_instance: Problem data/specification
             **kwargs: Additional solving parameters
-            
+
         Returns:
             Solution result
 
         """
         pass
 
-    def get_agent_info(self) -> Dict[str, Any]:
+    def get_agent_info(self) -> dict[str, Any]:
         """Get information about the agent and its algorithms."""
         return {
             'agent_type': self.__class__.__name__,
@@ -98,11 +99,11 @@ class QuantumAgent(BaseQuantumAlgorithm, ABC):
 
 class QuantumPortfolioAgent(QuantumAgent):
     """Quantum agent for portfolio optimization.
-    
+
     This agent combines QAOA and VQE algorithms to solve portfolio
     optimization problems including mean-variance optimization,
     risk parity, and constrained optimization.
-    
+
     Args:
         backend: Quantum backend
         risk_model: Risk model to use ('mean_variance', 'black_litterman', 'factor')
@@ -110,7 +111,7 @@ class QuantumPortfolioAgent(QuantumAgent):
         constraints: List of constraint specifications
         rebalancing_frequency: How often to rebalance
         **kwargs: Additional parameters
-        
+
     Example:
         >>> agent = QuantumPortfolioAgent(
         ...     backend='pennylane',
@@ -124,10 +125,10 @@ class QuantumPortfolioAgent(QuantumAgent):
 
     def __init__(
         self,
-        backend: Union[str, Any],
+        backend: str | Any,
         risk_model: str = 'mean_variance',
         optimization_objective: str = 'sharpe',
-        constraints: Optional[List[Dict]] = None,
+        constraints: list[dict] | None = None,
         rebalancing_frequency: str = 'monthly',
         **kwargs
     ) -> None:
@@ -191,7 +192,7 @@ class QuantumPortfolioAgent(QuantumAgent):
 
         return H
 
-    def _encode_constraints(self, constraints: List[Dict], n_assets: int) -> List[Callable]:
+    def _encode_constraints(self, constraints: list[dict], n_assets: int) -> list[Callable]:
         """Encode portfolio constraints as quantum operators."""
         quantum_constraints = []
 
@@ -212,30 +213,30 @@ class QuantumPortfolioAgent(QuantumAgent):
 
             elif constraint_type == 'max_weight':
                 # Maximum weight constraint
-                max_weight = constraint.get('value', 0.3)
-                def max_weight_constraint(weights):
+                max_weight_value = constraint.get('value', 0.3)
+                def max_weight_constraint(weights, max_weight=max_weight_value):
                     return np.sum(np.maximum(0, weights - max_weight) ** 2)
                 quantum_constraints.append(max_weight_constraint)
 
             elif constraint_type == 'sector_limit':
                 # Sector exposure limit
-                sector_assets = constraint.get('assets', [])
-                max_exposure = constraint.get('value', 0.5)
-                def sector_constraint(weights):
+                sector_assets_list = constraint.get('assets', [])
+                max_exposure_value = constraint.get('value', 0.5)
+                def sector_constraint(weights, sector_assets=sector_assets_list, max_exposure=max_exposure_value):
                     sector_exposure = np.sum(weights[sector_assets])
                     return np.maximum(0, sector_exposure - max_exposure) ** 2
                 quantum_constraints.append(sector_constraint)
 
         return quantum_constraints
 
-    def fit(self, X: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> 'QuantumPortfolioAgent':
+    def fit(self, X: np.ndarray, y: np.ndarray | None = None, **kwargs) -> 'QuantumPortfolioAgent':
         """Fit the portfolio agent to historical data.
-        
+
         Args:
             X: Historical returns data (samples x assets)
             y: Not used
             **kwargs: Additional parameters
-            
+
         Returns:
             Self
 
@@ -275,11 +276,11 @@ class QuantumPortfolioAgent(QuantumAgent):
 
     def solve(self, problem_instance: np.ndarray, **kwargs) -> QuantumResult:
         """Solve portfolio optimization problem.
-        
+
         Args:
             problem_instance: Returns data or problem specification
             **kwargs: Solving parameters
-            
+
         Returns:
             Portfolio optimization result
 
@@ -300,7 +301,7 @@ class QuantumPortfolioAgent(QuantumAgent):
 
             elif method == 'qaoa':
                 # Use QAOA for discrete optimization
-                qaoa_result = self.algorithms['qaoa'].optimize(lambda x: self._portfolio_objective(x))
+                self.algorithms['qaoa'].optimize(lambda x: self._portfolio_objective(x))
                 optimal_solution = self.algorithms['qaoa'].predict(problem_instance)
 
                 # Convert binary solution to weights
@@ -398,11 +399,11 @@ class QuantumPortfolioAgent(QuantumAgent):
 
 class QuantumClassificationAgent(QuantumAgent):
     """Quantum agent for classification tasks.
-    
+
     This agent combines multiple quantum classifiers and provides
     automatic model selection, hyperparameter optimization, and
     ensemble methods for robust classification.
-    
+
     Args:
         backend: Quantum backend
         algorithms: List of algorithms to include ('quantum_svm', 'quantum_nn', 'hybrid')
@@ -414,8 +415,8 @@ class QuantumClassificationAgent(QuantumAgent):
 
     def __init__(
         self,
-        backend: Union[str, Any],
-        algorithms: Optional[List[str]] = None,
+        backend: str | Any,
+        algorithms: list[str] | None = None,
         ensemble_method: str = 'voting',
         auto_tune: bool = False,
         **kwargs
@@ -502,7 +503,7 @@ class QuantumClassificationAgent(QuantumAgent):
             best_algo = max(self.performance_metrics.items(), key=lambda x: x[1])[0]
             return predictions.get(best_algo, list(predictions.values())[0])
 
-    def _majority_voting(self, predictions: Dict[str, np.ndarray]) -> np.ndarray:
+    def _majority_voting(self, predictions: dict[str, np.ndarray]) -> np.ndarray:
         """Majority voting ensemble."""
         pred_arrays = list(predictions.values())
         n_samples = len(pred_arrays[0])
@@ -515,7 +516,7 @@ class QuantumClassificationAgent(QuantumAgent):
 
         return np.array(final_predictions)
 
-    def _weighted_voting(self, predictions: Dict[str, np.ndarray]) -> np.ndarray:
+    def _weighted_voting(self, predictions: dict[str, np.ndarray]) -> np.ndarray:
         """Weighted voting based on performance."""
         weights = {}
         total_weight = 0
@@ -548,7 +549,7 @@ class QuantumClassificationAgent(QuantumAgent):
 
         return np.array(final_predictions)
 
-    def solve(self, problem_instance: Tuple[np.ndarray, np.ndarray], **kwargs) -> QuantumResult:
+    def solve(self, problem_instance: tuple[np.ndarray, np.ndarray], **kwargs) -> QuantumResult:
         """Solve classification problem."""
         import time
 
@@ -595,11 +596,11 @@ class QuantumClassificationAgent(QuantumAgent):
 
 class QuantumTradingAgent(QuantumAgent):
     """Autonomous quantum trading agent for financial markets.
-    
+
     This agent combines quantum portfolio optimization, quantum risk analysis,
     and quantum-enhanced pattern recognition to make autonomous trading
     decisions with potential quantum advantages in complex market scenarios.
-    
+
     Args:
         backend: Quantum backend for computations
         strategy: Trading strategy ('momentum', 'mean_reversion', 'quantum_portfolio')
@@ -612,11 +613,11 @@ class QuantumTradingAgent(QuantumAgent):
 
     def __init__(
         self,
-        backend: Union[str, Any] = 'auto',
+        backend: str | Any = 'auto',
         strategy: str = 'quantum_portfolio',
         risk_tolerance: float = 0.5,
         quantum_advantage_threshold: float = 0.05,
-        markets: Optional[List[str]] = None,
+        markets: list[str] | None = None,
         **kwargs
     ) -> None:
         super().__init__(backend=backend, **kwargs)
@@ -640,7 +641,7 @@ class QuantumTradingAgent(QuantumAgent):
         """Initialize the trading agent."""
         self.is_fitted = True  # Agents are pre-configured
 
-    def fit(self, X: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> 'QuantumTradingAgent':
+    def fit(self, X: np.ndarray, y: np.ndarray | None = None, **kwargs) -> 'QuantumTradingAgent':
         """Fit the trading agent (optional for pre-configured agents)."""
         return self
 
@@ -653,7 +654,7 @@ class QuantumTradingAgent(QuantumAgent):
         """Solve trading optimization problem."""
         return self.deploy(problem_instance, **kwargs)
 
-    def deploy(self, market_data: Optional[Any] = None, **kwargs) -> QuantumResult:
+    def deploy(self, market_data: Any | None = None, **kwargs) -> QuantumResult:
         """Deploy the trading agent and return performance metrics."""
         start_time = time.time()
 
@@ -693,7 +694,7 @@ class QuantumTradingAgent(QuantumAgent):
                 error=str(e),
             )
 
-    def _quantum_portfolio_optimization(self, market_data: Any, **kwargs) -> Dict[str, Any]:
+    def _quantum_portfolio_optimization(self, market_data: Any, **kwargs) -> dict[str, Any]:
         """Perform quantum portfolio optimization."""
         # Placeholder implementation
         return {
@@ -702,7 +703,7 @@ class QuantumTradingAgent(QuantumAgent):
             'sharpe_ratio': 0.8 + np.random.normal(0, 0.1),
         }
 
-    def _quantum_momentum_strategy(self, market_data: Any, **kwargs) -> Dict[str, Any]:
+    def _quantum_momentum_strategy(self, market_data: Any, **kwargs) -> dict[str, Any]:
         """Quantum-enhanced momentum trading strategy."""
         return {
             'expected_return': 0.10 + np.random.normal(0, 0.03),
@@ -710,7 +711,7 @@ class QuantumTradingAgent(QuantumAgent):
             'sharpe_ratio': 0.6 + np.random.normal(0, 0.1),
         }
 
-    def _basic_trading_strategy(self, market_data: Any, **kwargs) -> Dict[str, Any]:
+    def _basic_trading_strategy(self, market_data: Any, **kwargs) -> dict[str, Any]:
         """Basic trading strategy fallback."""
         return {
             'expected_return': 0.08 + np.random.normal(0, 0.02),
@@ -718,7 +719,7 @@ class QuantumTradingAgent(QuantumAgent):
             'sharpe_ratio': 0.4 + np.random.normal(0, 0.05),
         }
 
-    def _calculate_quantum_advantage(self, result: Dict[str, Any]) -> float:
+    def _calculate_quantum_advantage(self, result: dict[str, Any]) -> float:
         """Calculate quantum advantage over classical methods."""
         # Simplified quantum advantage calculation
         base_performance = 0.08  # Classical baseline
@@ -728,11 +729,11 @@ class QuantumTradingAgent(QuantumAgent):
 
 class QuantumResearchAgent(QuantumAgent):
     """Autonomous quantum research agent for scientific discovery.
-    
-    This agent combines quantum simulation, quantum machine learning, and 
+
+    This agent combines quantum simulation, quantum machine learning, and
     automated hypothesis generation to accelerate scientific research across
     domains like materials science, drug discovery, and physics.
-    
+
     Args:
         backend: Quantum backend for simulations
         domain: Research domain ('materials_science', 'drug_discovery', 'physics')
@@ -745,7 +746,7 @@ class QuantumResearchAgent(QuantumAgent):
 
     def __init__(
         self,
-        backend: Union[str, Any] = 'auto',
+        backend: str | Any = 'auto',
         domain: str = 'materials_science',
         hypothesis_generation: bool = True,
         experiment_design: bool = True,
@@ -784,7 +785,7 @@ class QuantumResearchAgent(QuantumAgent):
         """Initialize the research agent."""
         self.is_fitted = True  # Agents are pre-configured
 
-    def fit(self, X: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> 'QuantumResearchAgent':
+    def fit(self, X: np.ndarray, y: np.ndarray | None = None, **kwargs) -> 'QuantumResearchAgent':
         """Fit the research agent (optional for pre-configured agents)."""
         return self
 
@@ -800,7 +801,7 @@ class QuantumResearchAgent(QuantumAgent):
     def investigate(
         self,
         research_question: str,
-        constraints: Optional[Dict[str, Any]] = None,
+        constraints: dict[str, Any] | None = None,
         **kwargs
     ) -> QuantumResult:
         """Investigate a research question and return research plan."""
@@ -841,7 +842,7 @@ class QuantumResearchAgent(QuantumAgent):
                 error=str(e),
             )
 
-    def _generate_research_plan(self, question: str, constraints: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    def _generate_research_plan(self, question: str, constraints: dict[str, Any] | None) -> dict[str, Any]:
         """Generate a research plan using quantum-enhanced methods."""
         constraints = constraints or {}
 
@@ -859,7 +860,7 @@ class QuantumResearchAgent(QuantumAgent):
             'expected_quantum_advantage': 'Exponential speedup for molecular simulations',
         }
 
-    def _generate_hypothesis(self, question: str) -> Dict[str, Any]:
+    def _generate_hypothesis(self, question: str) -> dict[str, Any]:
         """Generate research hypotheses using quantum ML."""
         return {
             'primary_hypothesis': f"Quantum effects in {self.domain} can be leveraged to solve: {question}",
@@ -873,7 +874,7 @@ class QuantumResearchAgent(QuantumAgent):
             ]
         }
 
-    def _design_experiments(self, question: str) -> List[Dict[str, Any]]:
+    def _design_experiments(self, question: str) -> list[dict[str, Any]]:
         """Design quantum experiments for research validation."""
         return [
             {
@@ -894,11 +895,11 @@ class QuantumResearchAgent(QuantumAgent):
 
 class QuantumOptimizationAgent(QuantumAgent):
     """Quantum agent for optimization problems.
-    
+
     This agent provides a unified interface for solving various
     optimization problems using QAOA, VQE, and other quantum
     optimization algorithms.
-    
+
     Args:
         backend: Quantum backend
         problem_type: Type of optimization ('combinatorial', 'continuous', 'mixed')
@@ -909,9 +910,9 @@ class QuantumOptimizationAgent(QuantumAgent):
 
     def __init__(
         self,
-        backend: Union[str, Any],
+        backend: str | Any,
         problem_type: str = 'combinatorial',
-        algorithms: Optional[List[str]] = None,
+        algorithms: list[str] | None = None,
         **kwargs
     ) -> None:
         agent_config = {
@@ -940,7 +941,7 @@ class QuantumOptimizationAgent(QuantumAgent):
                 shots=self.shots
             )
 
-    def fit(self, X: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> 'QuantumOptimizationAgent':
+    def fit(self, X: np.ndarray, y: np.ndarray | None = None, **kwargs) -> 'QuantumOptimizationAgent':
         """Fit optimization algorithms to problem."""
         for name, algorithm in self.algorithms.items():
             algorithm.fit(X, y)

superquantx/algorithms/quantum_kmeans.py

@@ -5,7 +5,7 @@ quantum distance calculations and quantum amplitude estimation approaches.
 """
 
 import logging
-from typing import Any, Dict, Optional, Union
+from typing import Any
 
 import numpy as np
 from sklearn.cluster import KMeans
@@ -19,17 +19,17 @@ logger = logging.getLogger(__name__)
 
 class QuantumKMeans(UnsupervisedQuantumAlgorithm):
     """Quantum K-Means clustering algorithm.
-    
+
     This implementation uses quantum algorithms to perform K-means clustering,
     potentially offering speedup for high-dimensional data through quantum
     distance calculations and amplitude estimation.
-    
+
     The algorithm can use different quantum approaches:
     - Quantum Distance Calculation: Use quantum circuits to compute distances
     - Quantum Amplitude Estimation: For probabilistic distance measurements
     - Variational Quantum Clustering: Use VQC for cluster optimization
     - Quantum Annealing: For global cluster optimization
-    
+
     Args:
         backend: Quantum backend for circuit execution
         n_clusters: Number of clusters (k)
@@ -42,7 +42,7 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
         shots: Number of measurement shots
         classical_fallback: Use classical K-means if quantum fails
         **kwargs: Additional parameters
-        
+
     Example:
         >>> qkmeans = QuantumKMeans(backend='pennylane', n_clusters=3, method='distance')
         >>> qkmeans.fit(X_train)
@@ -53,7 +53,7 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
 
     def __init__(
         self,
-        backend: Union[str, Any],
+        backend: str | Any,
         n_clusters: int = 3,
         method: str = 'distance',
         distance_metric: str = 'euclidean',
@@ -64,7 +64,7 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
         shots: int = 1024,
         classical_fallback: bool = True,
         normalize_data: bool = True,
-        random_state: Optional[int] = None,
+        random_state: int | None = None,
         **kwargs
     ) -> None:
         super().__init__(backend=backend, shots=shots, **kwargs)
@@ -326,14 +326,14 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
         centroid_shift = np.max(np.linalg.norm(new_centroids - old_centroids, axis=1))
         return centroid_shift < self.tolerance
 
-    def fit(self, X: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> 'QuantumKMeans':
+    def fit(self, X: np.ndarray, y: np.ndarray | None = None, **kwargs) -> 'QuantumKMeans':
         """Fit quantum K-means to the data.
-        
+
         Args:
             X: Training data
             y: Ignored (unsupervised learning)
             **kwargs: Additional fitting parameters
-            
+
         Returns:
             Self for method chaining
 
@@ -401,11 +401,11 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
 
     def predict(self, X: np.ndarray, **kwargs) -> np.ndarray:
         """Predict cluster labels for new data.
-        
+
         Args:
             X: Data to cluster
             **kwargs: Additional parameters
-            
+
         Returns:
             Cluster labels
 
@@ -423,7 +423,7 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
         # Assign to nearest cluster
         return self._assign_clusters(distances)
 
-    def fit_predict(self, X: np.ndarray, y: Optional[np.ndarray] = None) -> np.ndarray:
+    def fit_predict(self, X: np.ndarray, y: np.ndarray | None = None) -> np.ndarray:
         """Fit K-means and return cluster labels."""
         return self.fit(X, y).labels_
 
@@ -439,7 +439,7 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
         # Return distances to all centroids
         return self._compute_distances_batch(X, self.cluster_centers_)
 
-    def get_quantum_advantage_metrics(self) -> Dict[str, Any]:
+    def get_quantum_advantage_metrics(self) -> dict[str, Any]:
         """Analyze potential quantum advantage."""
         if not self.is_fitted:
             raise ValueError("Must fit model first")
@@ -467,7 +467,7 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
 
         return metrics
 
-    def compare_with_classical(self, X: np.ndarray, y_true: Optional[np.ndarray] = None) -> Dict[str, Any]:
+    def compare_with_classical(self, X: np.ndarray, y_true: np.ndarray | None = None) -> dict[str, Any]:
         """Compare quantum K-means results with classical K-means."""
         if not self.is_fitted or not hasattr(self.classical_kmeans, 'cluster_centers_'):
             raise ValueError("Both quantum and classical K-means must be fitted")
@@ -531,7 +531,7 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
 
         return comparison
 
-    def analyze_convergence(self) -> Dict[str, Any]:
+    def analyze_convergence(self) -> dict[str, Any]:
         """Analyze convergence properties."""
         if not self.convergence_history:
             return {'message': 'No convergence history available'}
@@ -548,7 +548,7 @@ class QuantumKMeans(UnsupervisedQuantumAlgorithm):
             'inertia_variance': np.var(inertias[-10:]) if len(inertias) >= 10 else np.var(inertias),
         }
 
-    def get_params(self, deep: bool = True) -> Dict[str, Any]:
+    def get_params(self, deep: bool = True) -> dict[str, Any]:
         """Get quantum K-means parameters."""
         params = super().get_params(deep)
         params.update({

superquantx/algorithms/quantum_nn.py

@@ -5,7 +5,7 @@ tasks using parameterized quantum circuits as trainable layers.
 """
 
 import logging
-from typing import Any, Dict, List, Union
+from typing import Any
 
 import numpy as np
 from sklearn.metrics import accuracy_score
@@ -18,15 +18,15 @@ logger = logging.getLogger(__name__)
 
 class QuantumNN(SupervisedQuantumAlgorithm):
     """Quantum Neural Network for classification and regression.
-    
+
     This implementation uses parameterized quantum circuits as neural network
     layers, with classical optimization to train the quantum parameters.
-    
+
     The network can be configured with different architectures:
     - Pure quantum: Only quantum layers
-    - Hybrid: Combination of quantum and classical layers  
+    - Hybrid: Combination of quantum and classical layers
     - Variational: Variational quantum circuits with measurement
-    
+
     Args:
         backend: Quantum backend for circuit execution
         n_layers: Number of quantum layers
@@ -39,7 +39,7 @@ class QuantumNN(SupervisedQuantumAlgorithm):
         batch_size: Training batch size
         shots: Number of measurement shots
         **kwargs: Additional parameters
-        
+
     Example:
         >>> qnn = QuantumNN(backend='pennylane', n_layers=3, architecture='hybrid')
         >>> qnn.fit(X_train, y_train)
@@ -50,7 +50,7 @@ class QuantumNN(SupervisedQuantumAlgorithm):
 
     def __init__(
         self,
-        backend: Union[str, Any],
+        backend: str | Any,
         n_layers: int = 3,
         architecture: str = 'hybrid',
         encoding: str = 'angle',
@@ -225,11 +225,11 @@ class QuantumNN(SupervisedQuantumAlgorithm):
 
     def _forward_pass(self, x: np.ndarray, weights: np.ndarray) -> np.ndarray:
         """Perform forward pass through the quantum neural network.
-        
+
         Args:
             x: Input data
             weights: Network weights
-            
+
         Returns:
             Network output
 
@@ -324,12 +324,12 @@ class QuantumNN(SupervisedQuantumAlgorithm):
 
     def fit(self, X: np.ndarray, y: np.ndarray, **kwargs) -> 'QuantumNN':
         """Train the quantum neural network.
-        
+
         Args:
             X: Training data features
             y: Training data labels
             **kwargs: Additional training parameters
-            
+
         Returns:
             Self for method chaining
 
@@ -429,11 +429,11 @@ class QuantumNN(SupervisedQuantumAlgorithm):
 
     def predict(self, X: np.ndarray, **kwargs) -> np.ndarray:
         """Make predictions using the trained quantum neural network.
-        
+
         Args:
             X: Input data for prediction
             **kwargs: Additional prediction parameters
-            
+
         Returns:
             Predicted labels or values
 
@@ -459,11 +459,11 @@ class QuantumNN(SupervisedQuantumAlgorithm):
 
     def predict_proba(self, X: np.ndarray, **kwargs) -> np.ndarray:
         """Predict class probabilities.
-        
+
         Args:
             X: Input data for prediction
             **kwargs: Additional parameters
-            
+
         Returns:
             Predicted class probabilities
 
@@ -487,14 +487,14 @@ class QuantumNN(SupervisedQuantumAlgorithm):
         else:
             return self.n_layers * 2  # Estimate
 
-    def get_training_history(self) -> Dict[str, List[float]]:
+    def get_training_history(self) -> dict[str, list[float]]:
         """Get training history."""
         history = {'loss': self.loss_history}
         if self.accuracy_history:
             history['accuracy'] = self.accuracy_history
         return history
 
-    def analyze_expressivity(self) -> Dict[str, Any]:
+    def analyze_expressivity(self) -> dict[str, Any]:
         """Analyze the expressivity of the quantum neural network."""
         analysis = {
             'n_qubits': self.n_qubits,
@@ -514,7 +514,7 @@ class QuantumNN(SupervisedQuantumAlgorithm):
 
         return analysis
 
-    def get_params(self, deep: bool = True) -> Dict[str, Any]:
+    def get_params(self, deep: bool = True) -> dict[str, Any]:
         """Get quantum neural network parameters."""
         params = super().get_params(deep)
         params.update({