quant-pml 0.1.0__tar.gz

quant_pml-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Viacheslav Buchkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

quant_pml-0.1.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: quant-pml
+Version: 0.1.0
+Author: Viacheslav Buchkov
+License-Expression: MIT
+Keywords: quant,quantitative finance,machine learning
+Requires-Python: ==3.12.5
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: statsmodels>=0.14.4
+Requires-Dist: scikit-learn>=1.5.2
+Requires-Dist: numpy>=2.2.4
+Requires-Dist: pandas>=2.3.1
+Requires-Dist: matplotlib>=3.10.1
+Requires-Dist: qpsolvers>=4.5.0
+Requires-Dist: torch==2.8.0
+Requires-Dist: pyarrow==20.0.0
+Requires-Dist: fastparquet==2024.11.0
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: scipy>=1.16.1
+Requires-Dist: optuna==4.4.0
+Requires-Dist: plotly>=6.2.0
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: polars==1.34.0
+Dynamic: license-file
+
+# Quantitative Portfolio Machine Learning Library
+
+_Viacheslav Buchkov_ \
+ETH Zürich
+
+**Keywords**: quant; quantitative finance; portfolio management; machine learning; reinforcement learning.
+
+## Install
+
+```
+pip install quant-pml
+```
+
+
+## How To Run A Backtest
+
+```
+from quant_pml.config.trading_config import TradingConfig
+from quant_pml.config.russell_3000_experiment_config import Russell3000ExperimentConfig
+from quant_pml.hedge.market_futures_hedge import MarketFuturesHedge
+from quant_pml.runner import build_backtest
+from quant_pml.strategies.factors.momentum import Momentum
+
+# Specify the model hyperparameters
+REBAL_FREQ = "D" # Rebalance frequency (Month End)
+QUANTILE = 0.1 # Sorted portfolio quantile
+MODE = "long_short" # Trading mode
+
+# Specify the trading configurations
+trading_config = TradingConfig(
+    broker_fee=0, # Broker commission in decimals
+    bid_ask_spread=0, # Bid-ask spread in decimals
+    total_exposure=1, # Budget constraint
+    max_exposure=None, # Maximum weight constraint
+    min_exposure=None, # Minimum weight constraint
+    trading_lag_days=1, # Trading Lag
+)
+
+# Create a strategy with logic for weights selection
+strategy = Momentum(
+    mode=MODE,
+    quantile=QUANTILE,
+)
+
+# Initialize the hedger (can be set to `None` if no hedging is required)
+hedger = MarketFuturesHedge(market_name="spx")
+
+# Build the backtest pipeline
+preprocessor, runner = build_backtest(
+    experiment_config=Russell3000ExperimentConfig(),
+    trading_config=trading_config,
+    rebal_freq=REBAL_FREQ,
+)
+
+# Run the backtest
+res = runner(
+    feature_processor=preprocessor,
+    strategy=strategy,
+    hedger=hedger,
+)
+```
+
+## How To Create A New Strategy
+
+```
+import pandas as pd
+from quant_pml.strategies.base_strategy import BaseStrategy
+from quant_pml.strategies.optimization_data import TrainingData, PredictionData
+
+
+# Create a blueprint for your strategy
+class NewStrategy(BaseStrategy):
+    def __init__(self) -> None:
+        super().__init__()
+        
+        # Store the data across time, if needed
+
+    def _fit(self, training_data: TrainingData) -> None:
+        # Specify here your fitting logic
+        pass
+
+    def _get_weights(self, prediction_data: PredictionData, weights_: pd.DataFrame) -> pd.DataFrame:
+        # Specify here your prediction logic
+        
+        # Update the weights DataFrame by modifying the respective columns of stock_ids
+        return weights_
+```
+
+## How To Create A New Covariance Estimator
+
+```
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+from quant_pml.strategies.optimization_data import PredictionData, TrainingData
+from quant_pml.cov_estimators.base_cov_estimator import BaseCovEstimator
+
+
+class NewCovEstimator(BaseCovEstimator):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._fitted_cov = None
+
+    def _fit(self, training_data: TrainingData) -> None:
+        # Specify here your fitting logic (e.g., store a historical covmat)
+        ...
+
+    def _predict(self, prediction_data: PredictionData) -> pd.DataFrame:
+        # Specify here your prediction logic (e.g., get a stored estimate)
+        ...
+```
+
+## How To Create A New Data-Driven Covariance Estimator
+
+```
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+from quant_pml.cov_estimators.rl.base_rl_estimator import BaseRLCovEstimator
+
+
+class NewRLCovEstimator(BaseRLCovEstimator):
+    def __init__(self, shrinkage_type: str, window_size: int | None = None) -> None:
+        super().__init__(shrinkage_type=shrinkage_type, window_size=window_size)
+
+    def _fit_shrinkage(
+        self, features: pd.DataFrame, shrinkage_target: pd.Series
+    ) -> None:
+        # Specify here your model (might be classical ML / RL / etc.)
+        self.model = ...
+        self.model.fit(X=features, y=shrinkage_target)
+
+    def _predict_shrinkage(self, features: pd.DataFrame) -> float:
+        pred = self.model.predict(features).item()
+
+        return pred
+```

quant_pml-0.1.0/README.md

@@ -0,0 +1,146 @@
+# Quantitative Portfolio Machine Learning Library
+
+_Viacheslav Buchkov_ \
+ETH Zürich
+
+**Keywords**: quant; quantitative finance; portfolio management; machine learning; reinforcement learning.
+
+## Install
+
+```
+pip install quant-pml
+```
+
+
+## How To Run A Backtest
+
+```
+from quant_pml.config.trading_config import TradingConfig
+from quant_pml.config.russell_3000_experiment_config import Russell3000ExperimentConfig
+from quant_pml.hedge.market_futures_hedge import MarketFuturesHedge
+from quant_pml.runner import build_backtest
+from quant_pml.strategies.factors.momentum import Momentum
+
+# Specify the model hyperparameters
+REBAL_FREQ = "D" # Rebalance frequency (Month End)
+QUANTILE = 0.1 # Sorted portfolio quantile
+MODE = "long_short" # Trading mode
+
+# Specify the trading configurations
+trading_config = TradingConfig(
+    broker_fee=0, # Broker commission in decimals
+    bid_ask_spread=0, # Bid-ask spread in decimals
+    total_exposure=1, # Budget constraint
+    max_exposure=None, # Maximum weight constraint
+    min_exposure=None, # Minimum weight constraint
+    trading_lag_days=1, # Trading Lag
+)
+
+# Create a strategy with logic for weights selection
+strategy = Momentum(
+    mode=MODE,
+    quantile=QUANTILE,
+)
+
+# Initialize the hedger (can be set to `None` if no hedging is required)
+hedger = MarketFuturesHedge(market_name="spx")
+
+# Build the backtest pipeline
+preprocessor, runner = build_backtest(
+    experiment_config=Russell3000ExperimentConfig(),
+    trading_config=trading_config,
+    rebal_freq=REBAL_FREQ,
+)
+
+# Run the backtest
+res = runner(
+    feature_processor=preprocessor,
+    strategy=strategy,
+    hedger=hedger,
+)
+```
+
+## How To Create A New Strategy
+
+```
+import pandas as pd
+from quant_pml.strategies.base_strategy import BaseStrategy
+from quant_pml.strategies.optimization_data import TrainingData, PredictionData
+
+
+# Create a blueprint for your strategy
+class NewStrategy(BaseStrategy):
+    def __init__(self) -> None:
+        super().__init__()
+        
+        # Store the data across time, if needed
+
+    def _fit(self, training_data: TrainingData) -> None:
+        # Specify here your fitting logic
+        pass
+
+    def _get_weights(self, prediction_data: PredictionData, weights_: pd.DataFrame) -> pd.DataFrame:
+        # Specify here your prediction logic
+        
+        # Update the weights DataFrame by modifying the respective columns of stock_ids
+        return weights_
+```
+
+## How To Create A New Covariance Estimator
+
+```
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+from quant_pml.strategies.optimization_data import PredictionData, TrainingData
+from quant_pml.cov_estimators.base_cov_estimator import BaseCovEstimator
+
+
+class NewCovEstimator(BaseCovEstimator):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._fitted_cov = None
+
+    def _fit(self, training_data: TrainingData) -> None:
+        # Specify here your fitting logic (e.g., store a historical covmat)
+        ...
+
+    def _predict(self, prediction_data: PredictionData) -> pd.DataFrame:
+        # Specify here your prediction logic (e.g., get a stored estimate)
+        ...
+```
+
+## How To Create A New Data-Driven Covariance Estimator
+
+```
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+from quant_pml.cov_estimators.rl.base_rl_estimator import BaseRLCovEstimator
+
+
+class NewRLCovEstimator(BaseRLCovEstimator):
+    def __init__(self, shrinkage_type: str, window_size: int | None = None) -> None:
+        super().__init__(shrinkage_type=shrinkage_type, window_size=window_size)
+
+    def _fit_shrinkage(
+        self, features: pd.DataFrame, shrinkage_target: pd.Series
+    ) -> None:
+        # Specify here your model (might be classical ML / RL / etc.)
+        self.model = ...
+        self.model.fit(X=features, y=shrinkage_target)
+
+    def _predict_shrinkage(self, features: pd.DataFrame) -> float:
+        pred = self.model.predict(features).item()
+
+        return pred
+```

quant_pml-0.1.0/pyproject.toml

@@ -0,0 +1,179 @@
+[project]
+name = "quant-pml"
+version = "0.1.0"
+description = ""
+requires-python = "==3.12.5"
+readme = "README.md"
+dependencies = [
+    "statsmodels>=0.14.4",
+    "scikit-learn>=1.5.2",
+    "numpy>=2.2.4",
+    "pandas>=2.3.1",
+    "matplotlib>=3.10.1",
+    "qpsolvers>=4.5.0",
+    "torch==2.8.0",
+    "pyarrow==20.0.0",
+    "fastparquet==2024.11.0",
+    "tqdm>=4.67.1",
+    "scipy>=1.16.1",
+    "optuna==4.4.0",
+    "plotly>=6.2.0",
+    "openpyxl>=3.1.5",
+    "polars==1.34.0",
+]
+authors = [{name = "Viacheslav Buchkov"}]
+keywords = ["quant", "quantitative finance", "machine learning"]
+license = "MIT"
+
+[tool.uv.workspace]
+members = [
+    "src/",
+    "backtesting_checks/dummy",
+    "backtesting_checks/timing_strategy",
+    "backtesting_checks/low_beta",
+    "backtesting_checks/spx_reconstr",
+    "backtests/enhanced_momentum",
+    "backtests/fractional_momentum",
+]
+
+[dependency-groups]
+dev = [
+    "basedpyright>=1.31.6",
+    "deptry>=0.23.1",
+    "ipykernel>=6.30.1",
+    "ruff>=0.13.3",
+]
+
+
+[tool.ruff]
+line-length = 130
+fix = true
+
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+    "__init__.py",
+    "libraries/pmplib/pmplib/optimization", # V added this but (?)
+    "check_dependencies.py" # scripts, maybe should move to tools later
+]
+
+target-version = "py312"
+
+extend-exclude = [".venv"]
+
+# See: https://github.com/charliermarsh/ruff#supported-rules
+[tool.ruff.lint]
+select = [
+    "F", # Pyflakes
+    "E", # pycodestyle Error
+    "W", # pycodestyle Warning
+    "C90", # mccabe
+    "I", # isort
+    "D", # pydocstyle
+    "UP", # pyupgrade
+    "N", # pep8-naming
+    "YTT", # flake8-2020
+    "ASYNC", # flake8-async
+    "ANN", # flake8-annotations
+    "S", # flake8-bandit
+    "BLE", # flake8-blind-except
+    "FBT", # flake8-boolean-trap
+    "B", # flake8-bugbear
+    "A", # flake8-builtins
+    "C4", # flake8-comprehensions
+    "T10", # flake8-debugger
+    "DJ", # flake8-django
+    "EM", # flake8-errmsg
+    "ISC", # flake8-implicit-str-concat
+    "ICN", # flake8-import-conventions
+    "T20", # flake8-print
+    "PYI", # flake8-pyi
+    "R", # refactor
+    "Q", # flake8-quotes
+    "RET", # flake8-return
+    "SLF", # flake8-self
+    "PT", # flake8-pytest-style
+    "SIM", # flake8-simplify
+    "TID", # flake8-tidy-imports
+    "ARG", # flake8-unused-arguments
+    "DTZ", # flake8-datetimez
+    "ERA", # eradicate
+    "PD", # pandas-vet
+    "PGH", # pygrep-hooks
+    "PLC", # Pylint Convention
+    "PLE", # Pylint Error
+    "PLR", # Pylint Refactor
+    "PLW", # Pylint Warning
+    "PIE", # flake8-pie
+    "COM", # flake8-commas
+    "INP", # flake8-no-pep420
+    "EXE", # flake8-executable
+    "TCH", # flake8-type-checking
+    "ARG", # flake8-unused-arguments
+    "TRY", # tryceratops
+    "PTH", # flake8-use-pathlib
+    "RUF", # Ruff-specific rules
+    "RSE", # flake8-raise
+    "SLOT", # flake8-slots
+    "TD", # flake8-todos
+    "FLY", # flynt
+    "NPY", # NumPy-specific rules
+    "PERF", # Perflint
+    "G", # flake8-logging-format
+    "PL", # Pylint
+    "FURB", # refurb
+]
+
+ignore = [
+    "D100", # Missing docstring in public module
+    "D101", # Missing docstring in public class
+    "D102", # Missing docstring in public method
+    "D103", # Missing docstring in public function
+    "D104", # Missing docstring in public package
+    "D105", # Missing docstring in magic method
+    "D106", # Missing docstring in public nested class
+    "D107", # Missing docstring in __init__
+    "TD003", # Missing issue link on the line following this TODORuffTD003
+    "D211", # No blank lines allowed before class docstring
+    "D213", # Multi-line docstring summary should start at the second line
+    "G004", # Logging statement uses string formatting
+    "D203", # 1 blank line required before class docstring
+    "COM812", # Trailing comma missing (conflicts with formatter)
+    "DTZ011", # Use `datetime.datetime.now(tz=...).date()` instead
+    "DTZ005", # datetime.datetime.now()` called without a `tz` argument
+    "S101", #Use of `assert` detected
+    "PD010", #`.pivot_table` is preferred to `.pivot` or `.unstack`; provides same functionality
+]
+
+unfixable = ["F401"]
+
+[tool.ruff.lint.per-file-ignores]
+"**/*.ipynb" = [
+    "E501", # ignore line-length in all notebooks
+    "F404", # ignore `from __future__` imports must occur at the beginning of the file
+    "T201" # ignore print statements
+]

quant_pml-0.1.0/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+description-file = README.md
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

quant_pml-0.1.0/setup.py

@@ -0,0 +1,6 @@
+from setuptools import find_packages, setup
+
+setup(
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+)

quant_pml-0.1.0/src/quant_pml/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

quant_pml-0.1.0/src/quant_pml/ap/base_asset_pricer.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+class BaseAssetPricer(ABC):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @abstractmethod
+    def fit(self, test_assets_xs_r: pd.DataFrame, factors: pd.DataFrame) -> pd.DataFrame:
+        raise NotImplementedError
+
+    @abstractmethod
+    def predict(self, factors: pd.DataFrame) -> pd.DataFrame:
+        raise NotImplementedError
+
+    def _get_deviations(self, test_assets_xs_r: pd.DataFrame, factors: pd.DataFrame) -> tuple[pd.Series, pd.Series]:
+        pred_xs_r = self.predict(factors)
+
+        ts_average = test_assets_xs_r.mean(axis=0)
+
+        model_deviation = ts_average - pred_xs_r.mean(axis=1)
+        baseline_deviation = ts_average - ts_average.mean() * np.ones(len(ts_average))
+
+        return model_deviation, baseline_deviation
+
+    def r2_score(self, test_assets_xs_r: pd.DataFrame, factors: pd.DataFrame) -> float:
+        model_deviation, baseline_deviation = self._get_deviations(test_assets_xs_r, factors)
+
+        mse_model = model_deviation.T @ model_deviation
+        mse_baseline = baseline_deviation.T @ baseline_deviation
+
+        return 1 - mse_model / mse_baseline
+
+    def r2_gls_score(self, test_assets_xs_r: pd.DataFrame, factors: pd.DataFrame) -> float:
+        model_deviation, baseline_deviation = self._get_deviations(test_assets_xs_r, factors)
+
+        var_r_inv = np.linalg.inv(test_assets_xs_r.cov())
+
+        mse_model = model_deviation.T @ var_r_inv @ model_deviation
+        mse_baseline = baseline_deviation.T @ var_r_inv @ baseline_deviation
+
+        return 1 - mse_model / mse_baseline
+
+    def implied_sharpe_ratio(self, test_assets_xs_r: pd.DataFrame, factors: pd.DataFrame) -> float:
+        raise NotImplementedError
+
+    def rmse_score(self, test_assets_xs_r: pd.DataFrame, factors: pd.DataFrame) -> float:
+        model_deviation, _baseline_deviation = self._get_deviations(test_assets_xs_r, factors)
+
+        return np.sqrt(model_deviation.T @ model_deviation / len(model_deviation))

quant_pml-0.1.0/src/quant_pml/ap/ipca_factor_model.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+import pandas as pd
+from ipca import InstrumentedPCA
+
+from quant_pml.ap.base_asset_pricer import BaseAssetPricer
+
+warnings.filterwarnings("ignore")
+
+
+class IPCAFactorModel(BaseAssetPricer):
+    def __init__(
+        self,
+        n_factors: int = 4,
+        *,
+        fit_alpha: bool = True,
+    ) -> None:
+        super().__init__()
+
+        self.n_factors = n_factors
+        self.fit_alpha = fit_alpha
+
+        self.ipca = None
+        self.gamma = None
+        self.factors = None
+
+    def fit(self, test_assets_xs_r: pd.Series, ranks: pd.DataFrame) -> None:
+        self.ipca = InstrumentedPCA(
+            n_factors=self.n_factors,
+            intercept=self.fit_alpha,
+            max_iter=10_000,
+        )
+        self.ipca = self.ipca.fit(X=ranks, y=test_assets_xs_r)
+        self.gamma, self.factors = self.ipca.get_factors(label_ind=True)
+
+    def predict(self, ranks: pd.DataFrame) -> pd.DataFrame:
+        pred = self.ipca.predict(X=ranks)
+        pred = pd.DataFrame(pred, index=ranks.index, columns=["pred"])
+        return pd.pivot_table(pred, index="date", columns="portfolio", values="pred")
+
+    def _get_deviations(self, test_assets_xs_r: pd.DataFrame, ranks: pd.DataFrame) -> tuple[pd.Series, pd.Series]:
+        pred_xs_r = self.predict(ranks)
+
+        ts_average = test_assets_xs_r.mean(axis=0)
+
+        model_deviation = ts_average - pred_xs_r.mean(axis=0)
+        baseline_deviation = ts_average - ts_average.mean() * np.ones(len(ts_average))
+
+        return model_deviation, baseline_deviation
+
+    def r2_score(self, test_assets_xs_r: pd.DataFrame, ranks: pd.DataFrame) -> float:
+        model_deviation, baseline_deviation = self._get_deviations(test_assets_xs_r, ranks)
+
+        mse_model = model_deviation.T @ model_deviation
+        mse_baseline = baseline_deviation.T @ baseline_deviation
+
+        return 1 - mse_model / mse_baseline
+
+    def r2_gls_score(self, test_assets_xs_r: pd.DataFrame, ranks: pd.DataFrame) -> float:
+        model_deviation, baseline_deviation = self._get_deviations(test_assets_xs_r, ranks)
+
+        var_r_inv = np.linalg.inv(test_assets_xs_r.cov())
+
+        mse_model = model_deviation.T @ var_r_inv @ model_deviation
+        mse_baseline = baseline_deviation.T @ var_r_inv @ baseline_deviation
+
+        return 1 - mse_model / mse_baseline
+
+    def get_mv_weights(self, test_assets_xs_r: pd.DataFrame, ranks: pd.DataFrame) -> float:
+        z_t = ranks
+        gamma_b = self.gamma.iloc[:, :-1] if self.fit_alpha else self.gamma
+        var = gamma_b.T @ z_t.T @ z_t @ gamma_b
+        var_inv = np.linalg.inv(var)
+
+        weights = (var_inv @ gamma_b.T @ z_t.T).T
+
+        factors_mu = self.factors.mean(axis=1)
+        factors_cov = self.factors.T.cov()
+
+        mv_weights = np.linalg.inv(factors_cov) @ factors_mu
+
+        factor_rets = pd.DataFrame(
+            index=test_assets_xs_r.index,
+            columns=[f"Factor{k}" for k in range(1, self.n_factors + 1)],
+        )
+        for factor in range(self.n_factors):
+            factor_weights = pd.pivot_table(
+                weights.iloc[:, factor].to_frame("weights"),
+                index="date",
+                columns="portfolio",
+                values="weights",
+            )
+            factor_ret = (factor_weights.to_numpy() * test_assets_xs_r.to_numpy()).sum(axis=1)
+            factor_rets[f"Factor{factor + 1}"] = factor_ret
+
+        return factor_rets @ mv_weights
+
+    def rmse_score(self, test_assets_xs_r: pd.DataFrame, ranks: pd.DataFrame) -> float:
+        model_deviation, _baseline_deviation = self._get_deviations(test_assets_xs_r, ranks)
+
+        return np.sqrt(model_deviation.T @ model_deviation / len(model_deviation))