skfolio 0.0.1__py3-none-any.whl

skfolio/typing.py

@@ -0,0 +1,50 @@
+"""Custom typing module."""
+
+# Author: Hugo Delatte <delatte.hugo@gmail.com>
+# License: BSD 3 clause
+
+from collections.abc import Callable
+
+import cvxpy as cp
+import numpy as np
+import numpy.typing as npt
+import plotly.graph_objects as go
+
+from skfolio.measures import ExtraRiskMeasure, PerfMeasure, RatioMeasure, RiskMeasure
+
+__all__ = [
+    "Groups",
+    "Inequality",
+    "LinearConstraints",
+    "MultiInput",
+    "Target",
+    "ParametersValues",
+    "Factor",
+    "Result",
+    "RiskResult",
+    "ExpressionFunction",
+    "Measure",
+    "CvxMeasure",
+    "Names",
+    "Tags",
+]
+
+Measure = PerfMeasure | RiskMeasure | ExtraRiskMeasure | RatioMeasure
+CvxMeasure = PerfMeasure | RiskMeasure | RatioMeasure
+MultiInput = float | dict[str, float] | npt.ArrayLike
+Groups = dict[str, list[str]] | np.ndarray | list[list[str]]
+LinearConstraints = np.ndarray | list[str]
+Inequality = np.ndarray | list
+Target = float | np.ndarray
+ParametersValues = list[tuple[cp.Parameter, float | np.ndarray]]
+Factor = cp.Variable | cp.Constant
+Result = np.ndarray | tuple[float | tuple[float, float] | np.ndarray, np.ndarray]
+RiskResult = tuple[
+    cp.Expression | cp.Variable | cp.trace, list[cp.Expression | cp.SOC | cp.PSD]
+]
+ExpressionFunction = Callable[[cp.Variable, any], cp.Expression]
+Figure = go.Figure
+
+# Population
+Names = str | list[str]
+Tags = str | list[str]

skfolio/uncertainty_set/__init__.py

@@ -0,0 +1,23 @@
+from skfolio.uncertainty_set._base import (
+    BaseCovarianceUncertaintySet,
+    BaseMuUncertaintySet,
+    UncertaintySet,
+)
+from skfolio.uncertainty_set._bootstrap import (
+    BootstrapCovarianceUncertaintySet,
+    BootstrapMuUncertaintySet,
+)
+from skfolio.uncertainty_set._empirical import (
+    EmpiricalCovarianceUncertaintySet,
+    EmpiricalMuUncertaintySet,
+)
+
+__all__ = [
+    "UncertaintySet",
+    "BaseMuUncertaintySet",
+    "BaseCovarianceUncertaintySet",
+    "EmpiricalMuUncertaintySet",
+    "EmpiricalCovarianceUncertaintySet",
+    "BootstrapMuUncertaintySet",
+    "BootstrapCovarianceUncertaintySet",
+]

skfolio/uncertainty_set/_base.py

@@ -0,0 +1,108 @@
+"""Base Uncertainty estimator"""
+
+# Author: Hugo Delatte <delatte.hugo@gmail.com>
+# License: BSD 3 clause
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+import numpy as np
+import numpy.typing as npt
+import sklearn.base as skb
+
+
+# frozen=True with eq=False will lead to an id-based hashing which is needed for
+# caching CVX models in Optimization without impacting performance
+@dataclass(frozen=True, eq=False)
+class UncertaintySet:
+    r"""Ellipsoidal uncertainty set dataclass.
+
+    An ellipsoidal uncertainty set is defined by its size :math:`\kappa` and
+    shape :math:`S`. Ellipsoidal uncertainty set can be used with both expected returns
+    and covariance:
+
+    Expected returns ellipsoidal uncertainty set:
+
+    .. math:: U_{\mu}=\left\{\mu\,|\left(\mu-\hat{\mu}\right)S^{-1}\left(\mu-\hat{\mu}\right)^{T}\leq\kappa^{2}\right\}
+
+    Covariance ellipsoidal uncertainty set:
+
+    .. math:: U_{\Sigma}=\left\{\Sigma\,|\left(\text{vec}(\Sigma)-\text{vec}(\hat{\Sigma})\right)S^{-1}\left(\text{vec}(\Sigma)-\text{vec}(\hat{\Sigma})\right)^{T}\leq k^{2}\,,\,\Sigma\succeq 0\right\}
+
+    Attributes
+    ----------
+    k : float
+        Size of the ellipsoid  :math:`\kappa` that defines the confidence region
+
+    sigma : ndarray of shape (n_assets)
+        Shape of the ellipsoid :math:`S`
+    """
+    k: float
+    sigma: np.ndarray
+
+
+class BaseMuUncertaintySet(skb.BaseEstimator, ABC):
+    """Base class for all Mu Uncertainty Set estimators in `skfolio`.
+
+    Notes
+    -----
+    All estimators should specify all the parameters that can be set
+    at the class level in their ``__init__`` as explicit keyword
+    arguments (no ``*args`` or ``**kwargs``).
+    """
+
+    uncertainty_set_: UncertaintySet
+
+    @abstractmethod
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def fit(self, X: npt.ArrayLike, y=None):
+        pass
+
+
+class BaseCovarianceUncertaintySet(skb.BaseEstimator, ABC):
+    """Base class for all Covariance Uncertainty Set estimators in `skfolio`.
+
+    Notes
+    -----
+    All estimators should specify all the parameters that can be set
+    at the class level in their ``__init__`` as explicit keyword
+    arguments (no ``*args`` or ``**kwargs``).
+    """
+
+    uncertainty_set_: UncertaintySet
+
+    @abstractmethod
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def fit(self, X: npt.ArrayLike, y=None):
+        pass
+
+    def _validate_X_y(self, X: npt.ArrayLike, y: npt.ArrayLike | None = None):
+        """Validate X and y if provided.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_observations, n_assets)
+            Price returns of the assets.
+
+        y : array-like of shape (n_observations, n_targets), optional
+            Price returns of factors or a target benchmark.
+            The default is `None`.
+
+        Returns
+        -------
+        X : ndarray of shape (n_observations, n_assets)
+            Validated price returns of the assets.
+        y : ndarray of shape (n_observations, n_targets), optional
+            Validated price returns of factors or a target benchmark if provided.
+        """
+        if y is None:
+            X = self._validate_data(X)
+        else:
+            X, y = self._validate_data(X, y, multi_output=True)
+        return X, y

skfolio/uncertainty_set/_bootstrap.py

@@ -0,0 +1,281 @@
+"""Bootstrap Uncertainty Set estimators."""
+
+# Author: Hugo Delatte <delatte.hugo@gmail.com>
+# License: BSD 3 clause
+
+import numpy as np
+import numpy.typing as npt
+import scipy.stats as st
+
+from skfolio.prior import BasePrior, EmpiricalPrior
+from skfolio.uncertainty_set._base import (
+    BaseCovarianceUncertaintySet,
+    BaseMuUncertaintySet,
+    UncertaintySet,
+)
+from skfolio.utils.bootstrap import stationary_bootstrap
+from skfolio.utils.tools import check_estimator
+
+
+class BootstrapMuUncertaintySet(BaseMuUncertaintySet):
+    r"""Bootstrap Mu Uncertainty set.
+
+    Compute the expected returns ellipsoidal uncertainty set using circular bootstrap:
+
+    .. math:: U_{\mu}=\left\{\mu\,|\left(\mu-\hat{\mu}\right)S^{-1}\left(\mu-\hat{\mu}\right)^{T}\leq\kappa^{2}\right\}
+
+    The size of the ellipsoid  :math:`\kappa` (confidence region), is computed using:
+
+    .. math:: \kappa^2 = \chi^2_{n\_assets} (\beta)
+
+    with :math:`\chi^2_{n\_assets}(\beta)` the inverse cumulative distribution function
+    of the chi-squared distribution with `n_assets` degrees of freedom at the
+    :math:`\beta` confidence level.
+
+    The Shape of the ellipsoid :math:`S` is computed using stationary bootstrap with
+    the option to force the non-diagonal elements of the covariance matrix to zero.
+
+    Parameters
+    ----------
+    prior_estimator : BasePrior, optional
+        The :ref:`prior estimator <prior>` used to estimate the assets covariance
+        matrix. The default (`None`) is to use :class:`~skfolio.prior.EmpiricalPrior`.
+
+    confidence_level : float , default=0.95
+        Confidence level :math:`\beta` of the inverse cumulative distribution function
+        of the chi-squared distribution. The default value is `0.95`.
+
+    diagonal : bool, default=True
+        If this is set to True, the non-diagonal elements of the covariance matrix are
+        set to zero.
+
+    n_bootstrap_samples : int, default=1000
+        Number of bootstrap samples to generate. The default value is `1000`.
+
+    block_size : float, optional
+        Bootstrap block size. The default (`None`) is to estimate the optimal block size
+        using Politis & White algorithm for all individual assets.
+
+    seed : int, optional
+        Random seed used to initialize the pseudo-random number generator.
+
+    Attributes
+    ----------
+    uncertainty_set_ : UncertaintySet
+        Mu Uncertainty set :class:`~skfolio.uncertainty_set.UncertaintySet`.
+
+    prior_estimator_ : BasePrior
+        Fitted `prior_estimator`.
+
+    References
+    ----------
+    .. [1]  "Robustness properties of mean-variance portfolios",
+        Optimization: A Journal of Mathematical Programming and Operations Research,
+        Schöttle & Werner (2009).
+
+    .. [2]  "Automatic Block-Length Selection for the Dependent Bootstrap",
+        Politis & White (2004).
+
+    .. [3]  "Correction to Automatic Block-Length Selection for the Dependent
+        Bootstrap",
+        Patton, Politis & White (2009).
+    """
+    prior_estimator_: BasePrior
+
+    def __init__(
+        self,
+        prior_estimator: BasePrior | None = None,
+        confidence_level: float = 0.95,
+        diagonal: bool = True,
+        n_bootstrap_samples: int = 1000,
+        block_size: float | None = None,
+        seed: int | None = None,
+    ):
+        self.prior_estimator = prior_estimator
+        self.confidence_level = confidence_level
+        self.diagonal = diagonal
+        self.n_bootstrap_samples = n_bootstrap_samples
+        self.block_size = block_size
+        self.seed = seed
+
+    def fit(
+        self, X: npt.ArrayLike, y: npt.ArrayLike | None = None
+    ) -> "BootstrapMuUncertaintySet":
+        """Fit the Bootstrap Mu Uncertainty set estimator.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_observations, n_assets)
+            Price returns of the assets.
+
+        y : array-like of shape (n_observations, n_factors), optional
+            Price returns of factors.
+            The default is `None`.
+
+        Returns
+        -------
+        self : BootstrapMuUncertaintySet
+            Fitted estimator.
+        """
+        self.prior_estimator_ = check_estimator(
+            self.prior_estimator,
+            default=EmpiricalPrior(),
+            check_type=BasePrior,
+        )
+        # fitting estimators
+        self.prior_estimator_.fit(X, y)
+        mu = self.prior_estimator_.prior_model_.mu
+        returns = self.prior_estimator_.prior_model_.returns
+        n_assets = returns.shape[1]
+        k = np.sqrt(st.chi2.ppf(q=self.confidence_level, df=n_assets))
+        samples = stationary_bootstrap(
+            returns=returns,
+            block_size=self.block_size,
+            n_bootstrap_samples=self.n_bootstrap_samples,
+            seed=self.seed,
+        )
+        mus = np.mean(samples, axis=1)
+        covs = np.zeros((self.n_bootstrap_samples, n_assets, n_assets))
+        for i in range(self.n_bootstrap_samples):
+            covs[i] = np.cov(samples[i].T)
+
+        sigma = np.cov((mus - mu).T)
+        if self.diagonal:
+            sigma = np.diag(np.diag(sigma))
+
+        self.uncertainty_set_ = UncertaintySet(k=k, sigma=sigma)
+        return self
+
+
+class BootstrapCovarianceUncertaintySet(BaseCovarianceUncertaintySet):
+    r"""Bootstrap Covariance Uncertainty set.
+
+    Compute the covariance ellipsoidal uncertainty set using circular bootstrap:
+
+    .. math:: U_{\Sigma}=\left\{\Sigma\,|\left(\text{vec}(\Sigma)-\text{vec}(\hat{\Sigma})\right)S^{-1}\left(\text{vec}(\Sigma)-\text{vec}(\hat{\Sigma})\right)^{T}\leq k^{2}\,,\,\Sigma\succeq 0\right\}
+
+    The size of the ellipsoid :math:`\kappa` (confidence region), is computed using:
+
+    .. math:: \kappa^2 = \chi^2_{n\_assets^2} (\beta)
+
+    with :math:`\chi^2_{n\_assets^2}(\beta)` the inverse cumulative distribution
+    function of the chi-squared distribution with `n_assets` degrees of freedom at the
+    :math:`\beta` confidence level.
+
+    The Shape of the ellipsoid :math:`S` is computed using stationary bootstrap with the
+    option to force the non-diagonal elements of the covariance matrix to zero.
+
+    Parameters
+    ----------
+    prior_estimator : BasePrior, optional
+        The :ref:`prior estimator <prior>` used to estimate the assets covariance
+        matrix. The default (`None`) is to use :class:`~skfolio.prior.EmpiricalPrior`.
+
+    confidence_level : float , default=0.95
+        Confidence level :math:`\beta` of the inverse cumulative distribution function
+        of the chi-squared distribution. The default value is `0.95`.
+
+    diagonal : bool, default=True
+        If this is set to True, the non-diagonal elements of the covariance matrix are
+        set to zero.
+
+    n_bootstrap_samples : int, default=1000
+        Number of bootstrap samples to generate. The default value is `1000`.
+
+    block_size : float, optional
+        Bootstrap block size. The default (`None`) is to estimate the optimal block size
+        using Politis & White algorithm for all individual assets.
+
+    seed : int, optional
+        Random seed used to initialize the pseudo-random number generator
+
+    Attributes
+    ----------
+    uncertainty_set_ : UncertaintySet
+        Covariance Uncertainty set :class:`~skfolio.uncertainty_set.UncertaintySet`.
+
+    prior_estimator_ : BasePrior
+        Fitted `prior_estimator`.
+
+    References
+    ----------
+    .. [1]  "Robustness properties of mean-variance portfolios",
+        Optimization: A Journal of Mathematical Programming and Operations Research,
+        Schöttle & Werner (2009).
+
+    .. [2]  "Automatic Block-Length Selection for the Dependent Bootstrap",
+        Politis & White (2004).
+
+    .. [3]  "Correction to Automatic Block-Length Selection for the Dependent
+        Bootstrap",
+        Patton, Politis & White (2009).
+    """
+
+    prior_estimator_: BasePrior
+
+    def __init__(
+        self,
+        prior_estimator: BasePrior | None = None,
+        confidence_level: float = 0.95,
+        diagonal: bool = True,
+        n_bootstrap_samples: int = 1000,
+        block_size: float | None = None,
+        seed: int | None = None,
+    ):
+        self.prior_estimator = prior_estimator
+        self.confidence_level = confidence_level
+        self.diagonal = diagonal
+        self.n_bootstrap_samples = n_bootstrap_samples
+        self.block_size = block_size
+        self.seed = seed
+
+    def fit(self, X: npt.ArrayLike, y=None) -> "BootstrapCovarianceUncertaintySet":
+        """Fit the Bootstrap Covariance Uncertainty set estimator.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_observations, n_assets)
+            Price returns of the assets.
+
+        y : array-like of shape (n_observations, n_factors), optional
+            Price returns of factors.
+            The default is `None`.
+
+        Returns
+        -------
+        self : EmpiricalCovarianceUncertaintySet
+            Fitted estimator.
+        """
+
+        self.prior_estimator_ = check_estimator(
+            self.prior_estimator,
+            default=EmpiricalPrior(),
+            check_type=BasePrior,
+        )
+        # fitting estimators
+        self.prior_estimator_.fit(X, y)
+        covariance = self.prior_estimator_.prior_model_.covariance
+        returns = self.prior_estimator_.prior_model_.returns
+        n_assets = returns.shape[1]
+        k = np.sqrt(st.chi2.ppf(q=self.confidence_level, df=n_assets**2))
+
+        samples = stationary_bootstrap(
+            returns=returns,
+            block_size=self.block_size,
+            n_bootstrap_samples=self.n_bootstrap_samples,
+            seed=self.seed,
+        )
+        covs = np.zeros((self.n_bootstrap_samples, n_assets, n_assets))
+        for i in range(self.n_bootstrap_samples):
+            covs[i] = np.cov(samples[i].T)
+
+        sigma = np.cov(
+            (covs - covariance)
+            .reshape((self.n_bootstrap_samples, n_assets**2), order="F")
+            .T
+        )
+        if self.diagonal:
+            sigma = np.diag(np.diag(sigma))
+
+        self.uncertainty_set_ = UncertaintySet(k=k, sigma=sigma)
+        return self

skfolio/uncertainty_set/_empirical.py

@@ -0,0 +1,237 @@
+"""Empirical Uncertainty Set estimators."""
+
+# Author: Hugo Delatte <delatte.hugo@gmail.com>
+# License: BSD 3 clause
+
+import numpy as np
+import numpy.typing as npt
+import scipy.stats as st
+
+from skfolio.prior import BasePrior, EmpiricalPrior
+from skfolio.uncertainty_set._base import (
+    BaseCovarianceUncertaintySet,
+    BaseMuUncertaintySet,
+    UncertaintySet,
+)
+from skfolio.utils.stats import commutation_matrix
+from skfolio.utils.tools import check_estimator
+
+
+class EmpiricalMuUncertaintySet(BaseMuUncertaintySet):
+    r"""Empirical Mu Uncertainty Set.
+
+    Compute the expected returns ellipsoidal uncertainty set [1]_:
+
+    .. math:: U_{\mu}=\left\{\mu\,|\left(\mu-\hat{\mu}\right)S^{-1}\left(\mu-\hat{\mu}\right)^{T}\leq\kappa^{2}\right\}
+
+    Under the assumption that :math:`\Sigma` is given, the distribution of the sample
+    estimator :math:`\hat{\mu}` based on an i.i.d. sample
+    :math:`R_{t}\sim N(\mu, \Sigma), t=1,...,T` is given by
+    :math:`\hat{\mu}\sim N(\mu, \frac{1}{T}\Sigma)`.
+
+    The size of the ellipsoid  :math:`\kappa` (confidence region), is computed using:
+
+    .. math:: \kappa^2 = \chi^2_{n\_assets} (\beta)
+
+    with :math:`\chi^2_{n\_assets}(\beta)` the inverse cumulative distribution function
+    of the chi-squared distribution with `n_assets` degrees of freedom at the
+    :math:`\beta` confidence level.
+
+    The Shape of the ellipsoid :math:`S` is computed using:
+
+    .. math:: S = \frac{1}{T}\Sigma
+
+    with the option to force the non-diagonal elements of the covariance matrix to zero.
+
+    Parameters
+    ----------
+    prior_estimator : BasePrior, optional
+        The :ref:`prior estimator <prior>` used to estimate the assets covariance
+        matrix. The default (`None`) is to use :class:`~skfolio.prior.EmpiricalPrior`.
+
+    confidence_level : float , default=0.95
+        Confidence level :math:`\beta` of the inverse cumulative distribution function
+        of the chi-squared distribution. The default value is `0.95`.
+
+    diagonal : bool, default=True
+        If this is set to True, the non-diagonal elements of the covariance matrix are
+        set to zero.
+
+    Attributes
+    ----------
+    uncertainty_set_ : UncertaintySet
+        Mu Uncertainty set :class:`~skfolio.uncertainty_set.UncertaintySet`.
+
+    prior_estimator_ : BasePrior
+        Fitted `prior_estimator`.
+
+    References
+    ----------
+    .. [1]  "Robustness properties of mean-variance portfolios",
+        Optimization: A Journal of Mathematical Programming and Operations Research,
+        Schöttle & Werner (2009).
+    """
+    prior_estimator_: BasePrior
+
+    def __init__(
+        self,
+        prior_estimator: BasePrior | None = None,
+        confidence_level: float = 0.95,
+        diagonal: bool = True,
+    ):
+        self.prior_estimator = prior_estimator
+        self.confidence_level = confidence_level
+        self.diagonal = diagonal
+
+    def fit(
+        self, X: npt.ArrayLike, y: npt.ArrayLike | None = None
+    ) -> "EmpiricalMuUncertaintySet":
+        """Fit the Empirical Mu Uncertainty set estimator.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_observations, n_assets)
+            Price returns of the assets.
+
+        y : array-like of shape (n_observations, n_factors), optional
+            Price returns of factors.
+            The default is `None`.
+
+        Returns
+        -------
+        self : EmpiricalMuUncertaintySet
+            Fitted estimator.
+        """
+        self.prior_estimator_ = check_estimator(
+            self.prior_estimator,
+            default=EmpiricalPrior(),
+            check_type=BasePrior,
+        )
+        # fitting estimators
+        self.prior_estimator_.fit(X, y)
+
+        prior_model = self.prior_estimator_.prior_model_
+        n_observations, n_assets = prior_model.returns.shape
+        k = np.sqrt(st.chi2.ppf(q=self.confidence_level, df=n_assets))
+
+        sigma = prior_model.covariance / n_observations
+        if self.diagonal:
+            sigma = np.diag(np.diag(sigma))
+
+        self.uncertainty_set_ = UncertaintySet(k=k, sigma=sigma)
+        return self
+
+
+class EmpiricalCovarianceUncertaintySet(BaseCovarianceUncertaintySet):
+    r"""Empirical Covariance Uncertainty set.
+
+    Compute the covariance ellipsoidal uncertainty set [1]_:
+
+    .. math:: U_{\Sigma}=\left\{\Sigma\,|\left(\text{vec}(\Sigma)-\text{vec}(\hat{\Sigma})\right)S^{-1}\left(\text{vec}(\Sigma)-\text{vec}(\hat{\Sigma})\right)^{T}\leq k^{2}\,,\,\Sigma\succeq 0\right\}
+
+    We consider the Wishart distribution for the covariance matrix:
+
+    .. math:: \hat{\Sigma}\sim W(\frac{1}{T-1}\Sigma, T-1)
+
+    The size of the ellipsoid  :math:`\kappa` (confidence region), is computed using:
+
+    .. math:: \kappa^2 = \chi^2_{n\_assets^2} (\beta)
+
+    with :math:`\chi^2_{n\_assets^2}(\beta)` the inverse cumulative distribution
+    function of the chi-squared distribution with `n_assets` degrees of freedom at the
+    :math:`\beta` confidence level.
+
+    The Shape of the ellipsoid :math:`S` is based on a closed form solution of the
+    covariance matrix of the Wishart distributed random variable by using the vector
+    notation :math:`vec(x)`:
+
+    .. math:: Cov[vec(\hat{\Sigma})]=\frac{1}{T-1}(I_{n^2} + K_{nn})(\Sigma \otimes \Sigma)
+
+    with :math:`K_{nn}` denoting a commutation matrix and :math:`\otimes` representing
+    the Kronecker product.
+
+    Parameters
+    ----------
+    prior_estimator : BasePrior, optional
+        The :ref:`prior estimator <prior>` used to estimate the assets covariance
+        matrix. The default (`None`) is to use :class:`~skfolio.prior.EmpiricalPrior`.
+
+    confidence_level : float , default=0.95
+        Confidence level :math:`\beta` of the inverse cumulative distribution function
+        of the chi-squared distribution. The default value is `0.95`.
+
+    diagonal : bool, default=True
+        If this is set to True, the non-diagonal elements of the covariance matrix are
+        set to zero.
+
+    Attributes
+    ----------
+    uncertainty_set_ : UncertaintySet
+        Covariance Uncertainty set :class:`~skfolio.uncertainty_set.UncertaintySet`.
+
+    prior_estimator_ : BasePrior
+        Fitted `prior_estimator`.
+
+    References
+    ----------
+    .. [1]  "Robustness properties of mean-variance portfolios",
+        Optimization: A Journal of Mathematical Programming and Operations Research,
+        Schöttle & Werner (2009).
+    """
+    prior_estimator_: BasePrior
+
+    def __init__(
+        self,
+        prior_estimator: BasePrior | None = None,
+        confidence_level: float = 0.95,
+        diagonal: bool = True,
+    ):
+        self.prior_estimator = prior_estimator
+        self.confidence_level = confidence_level
+        self.diagonal = diagonal
+
+    def fit(
+        self, X: npt.ArrayLike, y: npt.ArrayLike | None = None
+    ) -> "EmpiricalCovarianceUncertaintySet":
+        """Fit the Empirical Covariance Uncertainty set estimator.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_observations, n_assets)
+            Price returns of the assets.
+
+        y : array-like of shape (n_observations, n_factors), optional
+            Price returns of factors.
+            The default is `None`.
+
+        Returns
+        -------
+        self : EmpiricalCovarianceUncertaintySet
+            Fitted estimator.
+        """
+        self.prior_estimator_ = check_estimator(
+            self.prior_estimator,
+            default=EmpiricalPrior(),
+            check_type=BasePrior,
+        )
+        # fitting estimators
+        self.prior_estimator_.fit(X, y)
+
+        prior_model = self.prior_estimator_.prior_model_
+        n_observations, n_assets = prior_model.returns.shape
+        k = np.sqrt(st.chi2.ppf(q=self.confidence_level, df=n_assets**2))
+
+        sigma = prior_model.covariance / n_observations
+        if self.diagonal:
+            sigma = np.diag(np.diag(sigma))
+
+        sigma = np.diag(
+            np.diag(
+                n_observations
+                * (np.identity(n_assets**2) + commutation_matrix(sigma))
+                @ np.kron(sigma, sigma)
+            )
+        )
+
+        self.uncertainty_set_ = UncertaintySet(k=k, sigma=sigma)
+        return self