RiskLabAI 1.0.2__tar.gz → 1.0.4__tar.gz

{risklabai-1.0.2 → risklabai-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RiskLabAI
-Version: 1.0.2
+Version: 1.0.4
 Summary: Financial AI using Python, based on 'Advances in Financial Machine Learning' and 'Machine Learning for Asset Managers'.
 Author-email: RiskLab <arian@risklab.ai>
 License: BSD 3-Clause License

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI/backtest/__init__.py

@@ -16,6 +16,7 @@ from .backtest_statistics import (
     calculate_hhi_concentration,
     calculate_hhi,
     compute_drawdowns_time_under_water,
+    sharpe_ratio as pbo_sharpe_ratio,
 )
 from .backtest_synthetic_data import synthetic_back_testing
 from .bet_sizing import (
@@ -52,7 +53,6 @@ from .test_set_overfitting import (
     strategy_type2_error_probability,
 )
 from .probability_of_backtest_overfitting import (
-    sharpe_ratio as pbo_sharpe_ratio, # aliased
     performance_evaluation,
     probability_of_backtest_overfitting,
 )

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI/backtest/backtest_overfitting_simulation.py

@@ -1,3 +1,19 @@
+"""
+Orchestrates complex backtest overfitting and simulation scenarios,
+including PBO, DSR, and hardware performance profiling.
+
+## TODO:
+- [ ] **Refactor Feature Generation:** Move hardcoded parameters in
+      `financial_features_backtest_overfitting_simulation`
+      (e.g., volatility=100, rolling=20, TA-lib windows)
+      to a configuration dictionary or function arguments.
+- [ ] **Refactor Profiling:** Move hardware/performance functions
+      (`get_cpu_info`, `format_cpu_info`,
+      `measure_computational_requirements`, etc.)
+      to a separate `RiskLabAI.utils.profiling` module
+      to reduce this module's responsibilities.
+"""
+
 import platform
 import time
 import numpy as np

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI/backtest/backtest_statistics.py

@@ -1,6 +1,12 @@
 """
 Calculates various backtest statistics like holding period,
 concentration, and drawdowns.
+
+## TODO:
+- [ ] Optimize `calculate_holding_period` with Numba (@jit)
+      to improve performance, similar to the `sharpe_ratio` function.
+- [ ] Add an `annualized_sharpe_ratio` helper function that
+      wraps the Numba `sharpe_ratio` and scales it by sqrt(freq).
 """
 
 from typing import Tuple, Optional

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI/backtest/bet_sizing.py

@@ -3,6 +3,14 @@ Functions for calculating bet size based on model probabilities and
 other strategy parameters.
 
 Includes implementations from de Prado (2018).
+
+## TODO:
+- [ ] **HPC Dependency:** The `mpPandasObj` placeholder in
+      `strategy_bet_sizing` and `avgActiveSignals` should be
+      hardened. If `RiskLabAI.hpc` is a core dependency,
+      consider raising an `ImportError` instead of using a
+      placeholder that returns an empty DataFrame, which could
+      fail silently.
 """
 
 from typing import Optional, Any

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI/backtest/probabilistic_sharpe_ratio.py

@@ -1,6 +1,12 @@
 """
 Implements the Probabilistic Sharpe Ratio (PSR) and related metrics
 as described by Marcos Lopez de Prado.
+
+## TODO:
+- [ ] Add a `compute_psr_curve` helper function (as seen in the
+      original notebook) that iterates `probabilistic_sharpe_ratio`
+      over a range of `observed_sharpe_ratio` values to
+      easily plot the PSR curve.
 """
 
 from typing import List

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI/backtest/probability_of_backtest_overfitting.py

@@ -1,5 +1,14 @@
 """
 Implements the Probability of Backtest Overfitting (PBO) calculation.
+
+## TODO:
+- [ ] Add a `get_pbo` wrapper function (as seen in the
+      original notebook) that simplifies the call to
+      `probability_of_backtest_overfitting` and returns
+      only the PBO value.
+- [ ] Add a `pbo_overfitting_plot` helper function to
+      visualize the logit distribution (as seen in the
+      original notebook).
 """
 
 from typing import Tuple, Callable, List, Optional

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI/backtest/validation/__init__.py

@@ -28,10 +28,10 @@ __all__ = [
     # Validators
     "KFold",
     "PurgedKFold",
-    "WalkForwardCrossValidator",
-    "CombinatorialPurgedKFold",
-    "BaggedCombinatorialPurgedKFold",
-    "AdaptiveCombinatorialPurgedKFold",
+    "WalkForward",  # <-- Fix
+    "CombinatorialPurged",  # <-- Fix
+    "BaggedCombinatorialPurged",  # <-- Fix
+    "AdaptiveCombinatorialPurged",  # <-- Fix
     
     # Utilities
     "CrossValidatorFactory",

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI/features/feature_importance/clustered_feature_importance_mda.py

@@ -18,11 +18,13 @@ class ClusteredFeatureImportanceMDA(FeatureImportanceStrategy):
     and measures the decrease in model performance.
     """
 
+
     def __init__(
         self,
         classifier: object,
         clusters: Dict[str, List[str]],
         n_splits: int = 10,
+        random_state: int = 42, # <-- ADD THIS
     ):
         """
         Initialize the strategy.
@@ -39,6 +41,8 @@ class ClusteredFeatureImportanceMDA(FeatureImportanceStrategy):
         self.classifier = classifier
         self.clusters = clusters
         self.n_splits = n_splits
+        self.random_state = random_state
+
 
     def compute(self, x: pd.DataFrame, y: pd.Series, **kwargs: Any) -> pd.DataFrame:
         """
@@ -68,8 +72,11 @@ class ClusteredFeatureImportanceMDA(FeatureImportanceStrategy):
         if score_weights is None:
             score_weights = np.ones(x.shape[0])
 
-        cv_generator = KFold(n_splits=self.n_splits)
+
+
+        cv_generator = KFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state)
         baseline_scores = pd.Series(dtype=float)
+
         shuffled_scores = pd.DataFrame(columns=self.clusters.keys(), dtype=float)   
 
         for i, (train_idx, test_idx) in enumerate(cv_generator.split(X=x)):
@@ -98,17 +105,21 @@ class ClusteredFeatureImportanceMDA(FeatureImportanceStrategy):
                 sample_weight=w_test,
             )
 
+
             # Get scores for each shuffled *cluster*
+            rng = np.random.default_rng(self.random_state + i)
             for cluster_name in shuffled_scores.columns:
                 x_test_shuffled = x_test.copy(deep=True)
                 for feature in self.clusters[cluster_name]:
-                    np.random.shuffle(x_test_shuffled[feature].values)
+                    rng.shuffle(x_test_shuffled[feature].values) # <-- This is correct
                 
                 prob = classifier_fit.predict_proba(x_test_shuffled)
                 shuffled_scores.loc[i, cluster_name] = -log_loss(
-                    y_test, prob, labels=self.classifier.classes_
+                    y_test, prob, labels=self.classifier.classes_,
+                    sample_weight=w_test  
                 )
 
+
         # Calculate importance as the simple drop in score
         importances = shuffled_scores.rsub(baseline_scores, axis=0)
 

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI/features/feature_importance/feature_importance_mda.py

@@ -17,7 +17,8 @@ class FeatureImportanceMDA(FeatureImportanceStrategy):
     much the model's performance (e.g., log loss) decreases.
     """
 
-    def __init__(self, classifier: object, n_splits: int = 10):
+
+    def __init__(self, classifier: object, n_splits: int = 10, random_state: int = 42):
         """
         Initialize the strategy.
 
@@ -30,6 +31,8 @@ class FeatureImportanceMDA(FeatureImportanceStrategy):
         """
         self.classifier = classifier
         self.n_splits = n_splits
+        self.random_state = random_state
+
 
     def compute(self, x: pd.DataFrame, y: pd.Series, **kwargs: Any) -> pd.DataFrame:
         """
@@ -58,7 +61,8 @@ class FeatureImportanceMDA(FeatureImportanceStrategy):
         if score_weights is None:
             score_weights = np.ones(x.shape[0])
 
-        cv_generator = KFold(n_splits=self.n_splits)
+
+        cv_generator = KFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state)
         baseline_scores = pd.Series(dtype=float)
         shuffled_scores = pd.DataFrame(columns=x.columns, dtype=float)
 
@@ -90,11 +94,13 @@ class FeatureImportanceMDA(FeatureImportanceStrategy):
             )
 
             # Get scores for each shuffled feature
+            rng = np.random.default_rng(self.random_state + i) 
             for feature in x.columns:
                 x_test_shuffled = x_test.copy(deep=True)
-                np.random.shuffle(x_test_shuffled[feature].values)
-                
+                rng.shuffle(x_test_shuffled[feature].values) # <-- USE SEEDED SHUFFLE
+
                 shuffled_proba = fitted_classifier.predict_proba(x_test_shuffled)
+                
                 shuffled_scores.loc[i, feature] = -log_loss(
                     y_test,
                     shuffled_proba,

risklabai-1.0.4/RiskLabAI/utils/publication_plots.py

@@ -0,0 +1,180 @@
+"""
+Utilities for creating publication-quality plots with Matplotlib
+and Seaborn, using Times New Roman font and high DPI.
+
+Provides 6 themes and a configuration-based saving function.
+"""
+
+import matplotlib.pyplot as plt
+import matplotlib.figure as fig  # For type hinting
+import seaborn as sns
+import os
+from typing import Optional, Dict, Any
+
+# [THEMES dictionary remains the same]
+THEMES: Dict[str, Dict[str, Any]] = {
+    'light': {
+        'figure.facecolor': '#FFFFFF',
+        'axes.facecolor': '#FFFFFF',
+        'text.color': '#000000',
+        'axes.labelcolor': '#000000',
+        'axes.edgecolor': '#000000',
+        'xtick.color': '#000000',
+        'ytick.color': '#000000',
+        'grid.color': '#CCCCCC',
+        'legend.facecolor': '#FFFFFF',
+        'legend.edgecolor': '#B0B0B0',
+    },
+    'medium': {
+        'figure.facecolor': '#B0B0B0',  # A more solid, medium grey
+        'axes.facecolor': '#B0B0B0',
+        'text.color': '#FFFFFF',         # White text (like the dark theme)
+        'axes.labelcolor': '#FFFFFF',
+        'axes.edgecolor': '#FFFFFF',
+        'xtick.color': '#FFFFFF',
+        'ytick.color': '#FFFFFF',
+        'grid.color': '#E0E0E0',         # Lighter grid lines on medium bg
+        'legend.facecolor': '#B0B0B0',
+        'legend.edgecolor': '#FFFFFF',
+    },
+    'dark': {
+        'figure.facecolor': '#2E2E2E',
+        'axes.facecolor': '#2E2E2E',
+        'text.color': '#F0F0F0',
+        'axes.labelcolor': '#F0F0F0',
+        'axes.edgecolor': '#F0F0F0',
+        'xtick.color': '#F0F0F0',
+        'ytick.color': '#F0F0F0',
+        'grid.color': '#6A6A6A',
+        'legend.facecolor': '#2E2E2E',
+        'legend.edgecolor': '#F0F0F0',
+    }
+}
+
+# --- MODULE-LEVEL CONFIGURATION ---
+# This dictionary will store the settings from setup_publication_style
+_CONFIG = {
+    'save_plots': False,
+    'save_dir': 'figs'
+}
+
+# --- UPDATED FUNCTION ---
+def setup_publication_style(
+    theme: str = 'light',
+    quality: int = 300,
+    save_plots: bool = False,  # <-- New parameter
+    save_dir: str = 'figs'       # <-- New parameter
+) -> None:
+    """
+    Sets the global Matplotlib rcParams and saving configuration.
+    
+    Call this function once at the beginning of your notebook.
+
+    Parameters
+    ----------
+    theme : str, optional
+        The theme to apply. Defaults to 'light'.
+    quality : int, optional
+        The DPI for the figures. Defaults to 300.
+    save_plots : bool, optional
+        Global switch to enable/disable saving plots. Defaults to False.
+    save_dir : str, optional
+        The directory to save figures in. Defaults to 'figs'.
+    """
+    
+    # [All the theme parsing and styling code remains the same]
+    # ... (omitted for brevity) ...
+    is_transparent = False
+    base_theme_name = theme
+    if theme.endswith('-transparent'):
+        is_transparent = True
+        base_theme_name = theme.replace('-transparent', '')
+    if base_theme_name not in THEMES:
+        base_theme_name = 'light'
+    params = THEMES[base_theme_name].copy()
+    common_params = {
+        'font.size': 12, 'axes.labelsize': 12, 'axes.titlesize': 14,
+        'axes.titleweight': 'bold', 'xtick.labelsize': 12, 'ytick.labelsize': 12,
+        'legend.fontsize': 12, 'legend.title_fontsize': 13,
+        'figure.dpi': quality, 'savefig.dpi': quality, 'axes.grid': True,
+        'grid.linestyle': '--', 'grid.alpha': 0.7, 'axes.linewidth': 1.2,
+    }
+    params.update(common_params)
+    if is_transparent:
+        params['figure.facecolor'] = (0, 0, 0, 0)
+        params['axes.facecolor'] = (0, 0, 0, 0)
+        params['savefig.transparent'] = True
+        params['legend.facecolor'] = (0, 0, 0, 0) 
+    else:
+        params['savefig.transparent'] = False
+    try:
+        plt.rc('font', family='Times New Roman')
+    except:
+        print("Warning: Times New Roman not found. Defaulting to serif.")
+        plt.rc('font', family='serif')
+    plt.rcParams.update(params)
+    sns_style = "darkgrid" if base_theme_name == 'dark' else "whitegrid"
+    sns.set_style(sns_style, rc=params)
+    
+    # --- Store saving configuration ---
+    _CONFIG['save_plots'] = save_plots
+    _CONFIG['save_dir'] = save_dir
+    
+    print(f"Matplotlib style updated. Theme: '{theme}', Quality: {quality} DPI.")
+    if save_plots:
+        print(f"Plot saving enabled. Saving to: '{save_dir}'")
+    else:
+        print("Plot saving disabled.")
+
+# [apply_plot_style function remains exactly the same]
+def apply_plot_style(
+    ax: plt.Axes,
+    title: str,
+    xlabel: str,
+    ylabel: str,
+    legend_title: Optional[str] = None
+) -> None:
+    ax.set_title(title)
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    if ax.get_legend() and legend_title is not None:
+        ax.legend(title=legend_title)
+
+# --- UPDATED FUNCTION ---
+def finalize_plot(
+    fig: fig.Figure,
+    filename: str
+) -> None:
+    """
+    Shows the plot and saves it *if* saving was enabled in
+    setup_publication_style.
+
+    Parameters
+    ----------
+    fig : plt.Figure
+        The figure object to save.
+    filename : str
+        The name of the file (e.g., 'model_performance.png').
+        This is required, but only used if saving is enabled.
+    """
+    
+    # --- 1. Save the figure if global switch is on ---
+    if _CONFIG['save_plots']:
+        save_dir = _CONFIG['save_dir']
+        
+        # Create the directory if it doesn't exist
+        os.makedirs(save_dir, exist_ok=True)
+        
+        # Construct the full path
+        full_path = os.path.join(save_dir, filename)
+        
+        # Save the figure
+        fig.savefig(full_path, bbox_inches='tight')
+        
+        print(f"Figure saved to: {full_path}")
+    
+    # --- 2. Always show the plot ---
+    plt.show()
+    
+    # --- 3. Close the figure object ---
+    plt.close(fig)

{risklabai-1.0.2 → risklabai-1.0.4}/RiskLabAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RiskLabAI
-Version: 1.0.2
+Version: 1.0.4
 Summary: Financial AI using Python, based on 'Advances in Financial Machine Learning' and 'Machine Learning for Asset Managers'.
 Author-email: RiskLab <arian@risklab.ai>
 License: BSD 3-Clause License

{risklabai-1.0.2 → risklabai-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "RiskLabAI"
-version = "1.0.2"
+version = "1.0.4"
 authors = [
     { name = "RiskLab", email = "arian@risklab.ai" },
 ]

risklabai-1.0.2/RiskLabAI/utils/publication_plots.py

@@ -1,75 +0,0 @@
-"""
-Utilities for creating publication-quality plots with Matplotlib
-and Seaborn, using Times New Roman font and high DPI.
-"""
-
-import matplotlib.pyplot as plt
-import seaborn as sns
-from typing import Optional, List
-
-def setup_publication_style() -> None:
-    """
-    Sets the global Matplotlib rcParams for a consistent,
-    publication-quality (Times New Roman, 300 DPI) style.
-    
-    Call this function once at the beginning of your notebook.
-    """
-    
-    # Check if Times New Roman is available
-    try:
-        plt.rc('font', family='Times New Roman')
-    except:
-        print("Warning: Times New Roman not found. Defaulting to serif.")
-        plt.rc('font', family='serif')
-
-    params = {
-        'font.size': 12,
-        'axes.labelsize': 12,
-        'axes.titlesize': 14,
-        'xtick.labelsize': 12,
-        'ytick.labelsize': 12,
-        'legend.fontsize': 12,
-        'figure.dpi': 300,
-        'savefig.dpi': 300,
-        'savefig.transparent': True,
-        'axes.grid': True,
-        'grid.linestyle': '--',
-        'grid.alpha': 0.5,
-        'axes.edgecolor': 'black',
-        'axes.linewidth': 1.2,
-    }
-    
-    plt.rcParams.update(params)
-    sns.set_style("whitegrid", params)
-    print("Matplotlib style updated for publication.")
-
-
-def apply_plot_style(
-    ax: plt.Axes,
-    title: str,
-    xlabel: str,
-    ylabel: str,
-    legend_title: Optional[str] = None
-) -> None:
-    """
-    Applies the standardized style to a specific Matplotlib Axes object.
-
-    Parameters
-    ----------
-    ax : plt.Axes
-        The Matplotlib axes to style.
-    title : str
-        The title for the plot.
-    xlabel : str
-        The label for the x-axis.
-    ylabel : str
-        The label for the y-axis.
-    legend_title : str, optional
-        Title for the legend, if any.
-    """
-    ax.set_title(title, fontsize=14, fontweight='bold')
-    ax.set_xlabel(xlabel, fontsize=12)
-    ax.set_ylabel(ylabel, fontsize=12)
-    
-    if ax.get_legend():
-        ax.legend(title=legend_title, fontsize=12)