mcli-framework 7.12.2__py3-none-any.whl → 7.12.4__py3-none-any.whl

mcli/ml/models/base_models.py

@@ -1,4 +1,4 @@
-"""Base classes for ML models"""
+"""Base classes for ML models."""
 
 import logging
 from abc import ABC, abstractmethod
@@ -15,7 +15,7 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class ModelMetrics:
-    """Container for model performance metrics"""
+    """Container for model performance metrics."""
 
     accuracy: float
     precision: float
@@ -30,7 +30,7 @@ class ModelMetrics:
     avg_loss: Optional[float] = None
 
     def to_dict(self) -> Dict[str, float]:
-        """Convert metrics to dictionary"""
+        """Convert metrics to dictionary."""
         return {
             "accuracy": self.accuracy,
             "precision": self.precision,
@@ -48,7 +48,7 @@ class ModelMetrics:
 
 @dataclass
 class ValidationResult:
-    """Container for validation results"""
+    """Container for validation results."""
 
     train_metrics: ModelMetrics
     val_metrics: ModelMetrics
@@ -60,7 +60,7 @@ class ValidationResult:
 
 
 class BaseStockModel(nn.Module, ABC):
-    """Abstract base class for all stock prediction models"""
+    """Abstract base class for all stock prediction models."""
 
     def __init__(self, input_dim: int, config: Optional[Dict[str, Any]] = None):
         super().__init__()
@@ -73,21 +73,21 @@ class BaseStockModel(nn.Module, ABC):
 
     @abstractmethod
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass through the model"""
+        """Forward pass through the model."""
         pass
 
     @abstractmethod
     def predict_proba(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Predict class probabilities"""
+        """Predict class probabilities."""
         pass
 
     def predict(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Make binary predictions"""
+        """Make binary predictions."""
         probas = self.predict_proba(X)
         return (probas[:, 1] > 0.5).astype(int)
 
     def preprocess_input(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> torch.Tensor:
-        """Preprocess input data for model"""
+        """Preprocess input data for model."""
         if isinstance(X, pd.DataFrame):
             X = X.values
 
@@ -102,13 +102,13 @@ class BaseStockModel(nn.Module, ABC):
         return X.to(self.device)
 
     def get_feature_importance(self) -> Optional[Dict[str, float]]:
-        """Get feature importance scores"""
+        """Get feature importance scores."""
         # Base implementation returns None
         # Override in specific models that support feature importance
         return None
 
     def save_model(self, path: str) -> None:
-        """Save model state"""
+        """Save model state."""
         state = {
             "model_state_dict": self.state_dict(),
             "config": self.config,
@@ -121,7 +121,7 @@ class BaseStockModel(nn.Module, ABC):
         logger.info(f"Model saved to {path}")
 
     def load_model(self, path: str) -> None:
-        """Load model state"""
+        """Load model state."""
         state = torch.load(path, map_location=self.device)
         self.load_state_dict(state["model_state_dict"])
         self.config = state["config"]
@@ -134,7 +134,7 @@ class BaseStockModel(nn.Module, ABC):
     def calculate_metrics(
         self, y_true: np.ndarray, y_pred: np.ndarray, y_proba: Optional[np.ndarray] = None
     ) -> ModelMetrics:
-        """Calculate comprehensive model metrics"""
+        """Calculate comprehensive model metrics."""
         from sklearn.metrics import (
             accuracy_score,
             f1_score,
@@ -173,13 +173,13 @@ class BaseStockModel(nn.Module, ABC):
         )
 
     def to(self, device):
-        """Move model to device and update internal device reference"""
+        """Move model to device and update internal device reference."""
         self.device = device
         return super().to(device)
 
 
 class MLPBaseModel(BaseStockModel):
-    """Basic Multi-Layer Perceptron base model"""
+    """Basic Multi-Layer Perceptron base model."""
 
     def __init__(
         self,
@@ -220,18 +220,18 @@ class MLPBaseModel(BaseStockModel):
         self.apply(self._init_weights)
 
     def _init_weights(self, module):
-        """Initialize model weights"""
+        """Initialize model weights."""
         if isinstance(module, nn.Linear):
             torch.nn.init.xavier_uniform_(module.weight)
             if module.bias is not None:
                 torch.nn.init.zeros_(module.bias)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass"""
+        """Forward pass."""
         return self.network(x)
 
     def predict_proba(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Predict class probabilities"""
+        """Predict class probabilities."""
         self.eval()
         with torch.no_grad():
             X_tensor = self.preprocess_input(X)
@@ -241,7 +241,7 @@ class MLPBaseModel(BaseStockModel):
 
 
 class ResidualBlock(nn.Module):
-    """Residual block for deeper networks"""
+    """Residual block for deeper networks."""
 
     def __init__(self, dim: int, dropout_rate: float = 0.1):
         super().__init__()
@@ -263,7 +263,7 @@ class ResidualBlock(nn.Module):
 
 
 class ResNetModel(BaseStockModel):
-    """ResNet-style model for tabular data"""
+    """ResNet-style model for tabular data."""
 
     def __init__(
         self,
@@ -300,14 +300,14 @@ class ResNetModel(BaseStockModel):
         self.apply(self._init_weights)
 
     def _init_weights(self, module):
-        """Initialize weights"""
+        """Initialize weights."""
         if isinstance(module, nn.Linear):
             torch.nn.init.kaiming_normal_(module.weight, mode="fan_out", nonlinearity="relu")
             if module.bias is not None:
                 torch.nn.init.zeros_(module.bias)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass"""
+        """Forward pass."""
         x = self.input_proj(x)
 
         for block in self.blocks:
@@ -316,7 +316,7 @@ class ResNetModel(BaseStockModel):
         return self.output_layer(x)
 
     def predict_proba(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Predict class probabilities"""
+        """Predict class probabilities."""
         self.eval()
         with torch.no_grad():
             X_tensor = self.preprocess_input(X)

mcli/ml/models/ensemble_models.py

@@ -1,4 +1,4 @@
-"""Ensemble models for stock prediction"""
+"""Ensemble models for stock prediction."""
 
 import logging
 from dataclasses import dataclass
@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class ModelConfig:
-    """Configuration for individual models"""
+    """Configuration for individual models."""
 
     model_type: str
     hidden_dims: List[int]
@@ -30,7 +30,7 @@ class ModelConfig:
 
 @dataclass
 class EnsembleConfig:
-    """Configuration for ensemble model"""
+    """Configuration for ensemble model."""
 
     base_models: List[ModelConfig]
     ensemble_method: str = "weighted_average"  # weighted_average, stacking, voting
@@ -41,7 +41,7 @@ class EnsembleConfig:
 
 
 class AttentionStockPredictor(BaseStockModel):
-    """Attention-based stock predictor"""
+    """Attention-based stock predictor."""
 
     def __init__(
         self,
@@ -104,7 +104,7 @@ class AttentionStockPredictor(BaseStockModel):
         self.softmax = nn.Softmax(dim=1)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass with attention mechanism"""
+        """Forward pass with attention mechanism."""
         # Project input
         x = self.input_proj(x)
 
@@ -131,7 +131,7 @@ class AttentionStockPredictor(BaseStockModel):
         return self.output_layer(x)
 
     def predict_proba(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Predict class probabilities"""
+        """Predict class probabilities."""
         self.eval()
         with torch.no_grad():
             X_tensor = self.preprocess_input(X)
@@ -141,7 +141,7 @@ class AttentionStockPredictor(BaseStockModel):
 
 
 class TransformerStockModel(BaseStockModel):
-    """Transformer model for stock prediction"""
+    """Transformer model for stock prediction."""
 
     def __init__(
         self,
@@ -185,7 +185,7 @@ class TransformerStockModel(BaseStockModel):
         self.softmax = nn.Softmax(dim=1)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass through transformer"""
+        """Forward pass through transformer."""
         # Embed input
         x = self.input_embedding(x)
 
@@ -205,7 +205,7 @@ class TransformerStockModel(BaseStockModel):
         return self.classifier(x)
 
     def predict_proba(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Predict class probabilities"""
+        """Predict class probabilities."""
         self.eval()
         with torch.no_grad():
             X_tensor = self.preprocess_input(X)
@@ -215,7 +215,7 @@ class TransformerStockModel(BaseStockModel):
 
 
 class PositionalEncoding(nn.Module):
-    """Positional encoding for transformer"""
+    """Positional encoding for transformer."""
 
     def __init__(self, d_model: int, dropout: float = 0.1, max_len: int = 5000):
         super().__init__()
@@ -235,7 +235,7 @@ class PositionalEncoding(nn.Module):
 
 
 class LSTMStockPredictor(BaseStockModel):
-    """LSTM-based stock predictor"""
+    """LSTM-based stock predictor."""
 
     def __init__(
         self,
@@ -272,7 +272,7 @@ class LSTMStockPredictor(BaseStockModel):
         self.softmax = nn.Softmax(dim=1)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass through LSTM"""
+        """Forward pass through LSTM."""
         # Add sequence dimension if needed
         if x.dim() == 2:
             x = x.unsqueeze(1)
@@ -286,7 +286,7 @@ class LSTMStockPredictor(BaseStockModel):
         return self.classifier(x)
 
     def predict_proba(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Predict class probabilities"""
+        """Predict class probabilities."""
         self.eval()
         with torch.no_grad():
             X_tensor = self.preprocess_input(X)
@@ -296,7 +296,7 @@ class LSTMStockPredictor(BaseStockModel):
 
 
 class CNNFeatureExtractor(BaseStockModel):
-    """CNN-based feature extractor for tabular data"""
+    """CNN-based feature extractor for tabular data."""
 
     def __init__(
         self,
@@ -350,8 +350,8 @@ class CNNFeatureExtractor(BaseStockModel):
         self.softmax = nn.Softmax(dim=1)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass through CNN"""
-        batch_size = x.size(0)
+        """Forward pass through CNN."""
+        batch_size = x.size(0)  # noqa: F841
 
         # Apply padding if needed
         if self.input_padding is not None:
@@ -373,7 +373,7 @@ class CNNFeatureExtractor(BaseStockModel):
         return self.classifier(x)
 
     def predict_proba(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Predict class probabilities"""
+        """Predict class probabilities."""
         self.eval()
         with torch.no_grad():
             X_tensor = self.preprocess_input(X)
@@ -383,7 +383,7 @@ class CNNFeatureExtractor(BaseStockModel):
 
 
 class DeepEnsembleModel(BaseStockModel):
-    """Deep ensemble combining multiple models"""
+    """Deep ensemble combining multiple models."""
 
     def __init__(self, input_dim: int, config: EnsembleConfig):
         super().__init__(input_dim, config.__dict__)
@@ -406,7 +406,7 @@ class DeepEnsembleModel(BaseStockModel):
         self.softmax = nn.Softmax(dim=1)
 
     def _create_model(self, model_config: ModelConfig, input_dim: int) -> BaseStockModel:
-        """Create individual model based on configuration"""
+        """Create individual model based on configuration."""
         if model_config.model_type == "attention":
             return AttentionStockPredictor(
                 input_dim=input_dim,
@@ -442,7 +442,7 @@ class DeepEnsembleModel(BaseStockModel):
             )
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Forward pass through ensemble"""
+        """Forward pass through ensemble."""
         model_outputs = []
 
         for model in self.models:
@@ -480,7 +480,7 @@ class DeepEnsembleModel(BaseStockModel):
         return ensemble_output
 
     def predict_proba(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Predict class probabilities"""
+        """Predict class probabilities."""
         self.eval()
         with torch.no_grad():
             X_tensor = self.preprocess_input(X)
@@ -489,13 +489,13 @@ class DeepEnsembleModel(BaseStockModel):
             return probas.cpu().numpy()
 
     def set_model_weights(self, weights: List[float]):
-        """Set weights for weighted ensemble"""
+        """Set weights for weighted ensemble."""
         self.model_weights = torch.FloatTensor(weights)
 
     def get_individual_predictions(
         self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]
     ) -> List[np.ndarray]:
-        """Get predictions from individual models"""
+        """Get predictions from individual models."""
         predictions = []
         self.eval()
 
@@ -508,7 +508,7 @@ class DeepEnsembleModel(BaseStockModel):
 
 
 class EnsembleTrainer:
-    """Trainer for ensemble models"""
+    """Trainer for ensemble models."""
 
     def __init__(self, ensemble_model: DeepEnsembleModel, config: EnsembleConfig):
         self.ensemble_model = ensemble_model
@@ -523,7 +523,7 @@ class EnsembleTrainer:
         X_val: Optional[np.ndarray] = None,
         y_val: Optional[np.ndarray] = None,
     ) -> ValidationResult:
-        """Train the ensemble model"""
+        """Train the ensemble model."""
         logger.info("Training ensemble model...")
 
         # Train individual models first
@@ -568,7 +568,7 @@ class EnsembleTrainer:
     def _create_subset(
         self, X: np.ndarray, y: np.ndarray, model_config: ModelConfig
     ) -> Tuple[np.ndarray, np.ndarray]:
-        """Create data subset for individual model training"""
+        """Create data subset for individual model training."""
         if self.config.bootstrap_samples:
             # Bootstrap sampling
             n_samples = len(X)
@@ -586,7 +586,7 @@ class EnsembleTrainer:
         X_val: Optional[np.ndarray],
         y_val: Optional[np.ndarray],
     ) -> Dict[str, Any]:
-        """Train individual model"""
+        """Train individual model."""
         from torch.utils.data import DataLoader, TensorDataset
 
         # Convert to tensors
@@ -629,7 +629,7 @@ class EnsembleTrainer:
         return {"train_losses": train_losses}
 
     def _calculate_ensemble_weights(self, X_val: np.ndarray, y_val: np.ndarray):
-        """Calculate optimal ensemble weights based on validation performance"""
+        """Calculate optimal ensemble weights based on validation performance."""
         individual_predictions = self.ensemble_model.get_individual_predictions(X_val)
 
         # Calculate individual model accuracies
@@ -653,21 +653,21 @@ class EnsembleTrainer:
         X_val: Optional[np.ndarray],
         y_val: Optional[np.ndarray],
     ):
-        """Train meta-learner for stacking ensemble"""
+        """Train meta-learner for stacking ensemble."""
         # Get predictions from base models
         train_predictions = self.ensemble_model.get_individual_predictions(X_train)
         meta_X_train = np.concatenate(train_predictions, axis=1)
 
         # Train meta-learner
         meta_config = self.config.meta_learner_config
-        result = self._train_individual_model(
+        result = self._train_individual_model(  # noqa: F841
             self.ensemble_model.meta_learner, meta_config, meta_X_train, y_train, None, None
         )
 
         logger.info("Meta-learner training completed")
 
     def _evaluate(self, X: np.ndarray, y: np.ndarray) -> ModelMetrics:
-        """Evaluate ensemble model"""
+        """Evaluate ensemble model."""
         if X is None or y is None:
             return ModelMetrics(0, 0, 0, 0, 0)
 

mcli/ml/models/recommendation_models.py

@@ -1,25 +1,24 @@
-"""Stock recommendation models"""
+"""Stock recommendation models."""
 
 import logging
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Union
 
 import numpy as np
 import pandas as pd
 import torch
 import torch.nn as nn
-import torch.nn.functional as F
 
 from mcli.ml.models.base_models import BaseStockModel, ModelMetrics, ValidationResult
-from mcli.ml.models.ensemble_models import DeepEnsembleModel, EnsembleConfig, ModelConfig
+from mcli.ml.models.ensemble_models import DeepEnsembleModel, EnsembleConfig
 
 logger = logging.getLogger(__name__)
 
 
 @dataclass
 class RecommendationConfig:
-    """Configuration for recommendation model"""
+    """Configuration for recommendation model."""
 
     ensemble_config: EnsembleConfig
     risk_adjustment: bool = True
@@ -32,7 +31,7 @@ class RecommendationConfig:
 
 @dataclass
 class PortfolioRecommendation:
-    """Portfolio recommendation result"""
+    """Portfolio recommendation result."""
 
     ticker: str
     recommendation_score: float
@@ -59,7 +58,7 @@ class PortfolioRecommendation:
 
 
 class StockRecommendationModel(BaseStockModel):
-    """Main stock recommendation model combining ensemble prediction with portfolio optimization"""
+    """Main stock recommendation model combining ensemble prediction with portfolio optimization."""
 
     def __init__(self, input_dim: int, config: RecommendationConfig):
         super().__init__(input_dim, config.__dict__)
@@ -104,7 +103,7 @@ class StockRecommendationModel(BaseStockModel):
         self.softmax = nn.Softmax(dim=1)
 
     def forward(self, x: torch.Tensor) -> Dict[str, torch.Tensor]:
-        """Forward pass returning multiple outputs"""
+        """Forward pass returning multiple outputs."""
         # Main prediction
         main_prediction = self.ensemble_model(x)
 
@@ -132,7 +131,7 @@ class StockRecommendationModel(BaseStockModel):
         }
 
     def predict_proba(self, X: Union[torch.Tensor, np.ndarray, pd.DataFrame]) -> np.ndarray:
-        """Predict class probabilities"""
+        """Predict class probabilities."""
         self.eval()
         with torch.no_grad():
             X_tensor = self.preprocess_input(X)
@@ -146,7 +145,7 @@ class StockRecommendationModel(BaseStockModel):
         tickers: List[str],
         market_data: Optional[pd.DataFrame] = None,
     ) -> List[PortfolioRecommendation]:
-        """Generate portfolio recommendations"""
+        """Generate portfolio recommendations."""
         self.eval()
         recommendations = []
 
@@ -187,7 +186,7 @@ class StockRecommendationModel(BaseStockModel):
         features: np.ndarray,
         market_data: Optional[pd.DataFrame],
     ) -> PortfolioRecommendation:
-        """Create individual stock recommendation"""
+        """Create individual stock recommendation."""
 
         # Basic recommendation score (probability of positive outcome)
         recommendation_score = main_prob[1]  # Assuming class 1 is positive
@@ -253,7 +252,7 @@ class StockRecommendationModel(BaseStockModel):
     def _generate_recommendation_reason(
         self, score: float, risk: str, confidence: float, expected_return: float
     ) -> str:
-        """Generate human-readable recommendation reason"""
+        """Generate human-readable recommendation reason."""
         if score > 0.7:
             strength = "Strong"
         elif score > 0.6:
@@ -267,12 +266,12 @@ class StockRecommendationModel(BaseStockModel):
         )
 
     def _extract_key_features(self, features: np.ndarray) -> List[str]:
-        """Extract key features driving the recommendation"""
+        """Extract key features driving the recommendation."""
         # Simplified implementation - would use feature importance in practice
         return ["technical_indicators", "political_influence", "market_regime"]
 
     def _generate_warnings(self, risk_level: str, confidence: float, score: float) -> List[str]:
-        """Generate warnings for the recommendation"""
+        """Generate warnings for the recommendation."""
         warnings = []
 
         if confidence < 0.5:
@@ -289,7 +288,7 @@ class StockRecommendationModel(BaseStockModel):
     def _optimize_portfolio(
         self, recommendations: List[PortfolioRecommendation]
     ) -> List[PortfolioRecommendation]:
-        """Apply portfolio-level optimization"""
+        """Apply portfolio-level optimization."""
         # Sort by risk-adjusted score
         recommendations.sort(key=lambda x: x.risk_adjusted_score, reverse=True)
 
@@ -319,7 +318,7 @@ class StockRecommendationModel(BaseStockModel):
 
 
 class RecommendationTrainer:
-    """Trainer for recommendation model"""
+    """Trainer for recommendation model."""
 
     def __init__(self, model: StockRecommendationModel, config: RecommendationConfig):
         self.model = model
@@ -340,7 +339,7 @@ class RecommendationTrainer:
         epochs: int = 100,
         batch_size: int = 64,
     ) -> ValidationResult:
-        """Train the recommendation model"""
+        """Train the recommendation model."""
 
         from torch.utils.data import DataLoader, TensorDataset
 
@@ -442,7 +441,7 @@ class RecommendationTrainer:
         returns_val: np.ndarray,
         risk_labels_val: np.ndarray,
     ) -> float:
-        """Validate model during training"""
+        """Validate model during training."""
         self.model.eval()
 
         with torch.no_grad():
@@ -466,7 +465,7 @@ class RecommendationTrainer:
             return total_loss.item()
 
     def _evaluate(self, X: np.ndarray, y: np.ndarray) -> ModelMetrics:
-        """Evaluate model performance"""
+        """Evaluate model performance."""
         if X is None or y is None:
             return ModelMetrics(0, 0, 0, 0, 0)