Merge branch 'main' into nm_g_estimation

Author: Desiment

jupiter_examples/nm_sigma_estimation_comparison.ipynb

@@ -1,6 +1,5 @@
 mypy~=1.10.0
 black~=24.4.2
 isort~=5.13.2
-mpmath~=1.3.0
 pytest~=7.4.4
 scikit-learn~=1.5.1

jupiter_examples/nmv_semiparametric_mixing_density_estimation_given_mu.ipynb

@@ -1,5 +1,7 @@
 numpy~=1.26.4
 scipy~=1.13.1
+sympy~=1.13.1
 matplotlib~=3.8.4
 numba~=0.59.0
 mpmath~=1.3.0
+sympy~=1.13.1

jupiter_examples/nv_mixing_density.ipynb

@@ -1,9 +1,27 @@
 from src.algorithms.semiparam_algorithms.nm_semi_param_algorithms.g_estimation_convolution import (
     NMSemiParametricGEstimation,
 )
+from src.algorithms.semiparam_algorithms.nm_semi_param_algorithms.sigma_estimation_eigenvalue_based import (
+    SemiParametricMeanSigmaEstimationEigenvalueBased,
+)
+from src.algorithms.semiparam_algorithms.nm_semi_param_algorithms.sigma_estimation_empirical import (
+    SemiParametricMeanSigmaEstimationEmpirical,
+)
+from src.algorithms.semiparam_algorithms.nv_semi_param_algorithms.g_estimation_given_mu import (
+    SemiParametricNVEstimation,
+)
+from src.algorithms.semiparam_algorithms.nv_semi_param_algorithms.g_estimation_post_widder import (
+    NVSemiParametricGEstimationPostWidder,
+)
 from src.algorithms.semiparam_algorithms.nvm_semi_param_algorithms.g_estimation_given_mu import (
     SemiParametricGEstimationGivenMu,
 )
+from src.algorithms.semiparam_algorithms.nvm_semi_param_algorithms.g_estimation_given_mu_rqmc_based import (
+    SemiParametricGEstimationGivenMuRQMCBased,
+)
+from src.algorithms.semiparam_algorithms.nvm_semi_param_algorithms.g_estimation_post_widder import (
+    SemiParametricGEstimationPostWidder,
+)
 from src.algorithms.semiparam_algorithms.nvm_semi_param_algorithms.mu_estimation import SemiParametricMuEstimation
 from src.register.algorithm_purpose import AlgorithmPurpose
 from src.register.register import Registry
@@ -14,3 +32,15 @@
     SemiParametricGEstimationGivenMu
 )
 ALGORITHM_REGISTRY.register("g_estimation_convolution", AlgorithmPurpose.NM_SEMIPARAMETRIC)(NMSemiParametricGEstimation)
+ALGORITHM_REGISTRY.register("sigma_estimation_eigenvalue_based", AlgorithmPurpose.NM_SEMIPARAMETRIC)(
+    SemiParametricMeanSigmaEstimationEigenvalueBased
+)
+ALGORITHM_REGISTRY.register("sigma_estimation_empirical", AlgorithmPurpose.NM_SEMIPARAMETRIC)(
+    SemiParametricMeanSigmaEstimationEmpirical
+)
+ALGORITHM_REGISTRY.register("g_estimation_given_mu_rqmc_based", AlgorithmPurpose.NMV_SEMIPARAMETRIC)(
+    SemiParametricGEstimationGivenMuRQMCBased
+)
+ALGORITHM_REGISTRY.register("g_estimation_post_widder", AlgorithmPurpose.NMV_SEMIPARAMETRIC)(
+    SemiParametricGEstimationPostWidder
+)

requirements.dev.txt

@@ -0,0 +1,107 @@
+import math
+from typing import Optional, Tuple, TypedDict
+
+import numpy as np
+from scipy.linalg import eigh
+
+from src.estimators.estimate_result import EstimateResult
+
+L_DEFAULT_VALUE = 5
+K_DEFAULT_VALUE = 10
+EPS_DEFAULT_VALUE = 0.1
+SEARCH_AREA_DEFAULT_VALUE = 10
+SEARCH_DENSITY_DEFAULT_VALUE = 1000
+PARAMETER_KEYS = ["l", "k", "eps", "search_area", "search_density"]
+
+
+class SemiParametricMeanSigmaEstimationEigenvalueBased:
+    """Estimation of sigma parameter of NM mixture represented in canonical form Y = xi + sigma*N.
+
+    Args:
+        sample: Sample of the analyzed distribution.
+        params: Parameters of the algorithm.
+    """
+
+    class ParamsAnnotation(TypedDict, total=False):
+        l: float
+        k: float
+        eps: float
+        search_area: float
+        search_density: int
+
+    def __init__(self, sample: Optional[np.ndarray] = None, **kwargs: ParamsAnnotation):
+        self.sample: np.ndarray = np.array([]) if sample is None else np.asarray(sample)
+        self.n: int = len(self.sample)
+        (
+            self.l,
+            self.k,
+            self.eps,
+            self.search_area,
+            self.search_density,
+        ) = self._validate_kwargs(**kwargs)
+
+    @staticmethod
+    def _validate_kwargs(**kwargs: ParamsAnnotation) -> Tuple[float, float, float, float, int]:
+        """Validate and extract parameters.
+
+        Args:
+            kwargs: Parameters of the algorithm.
+
+        Returns:
+            Tuple[float, float, float, float, int]: Validated parameters.
+        """
+        if any(key not in PARAMETER_KEYS for key in kwargs):
+            raise ValueError("Got unexpected parameter.")
+        l = kwargs.get("l", L_DEFAULT_VALUE)
+        k = kwargs.get("k", K_DEFAULT_VALUE)
+        eps = kwargs.get("eps", EPS_DEFAULT_VALUE)
+        search_area = kwargs.get("search_area", SEARCH_AREA_DEFAULT_VALUE)
+        search_density = kwargs.get("search_density", SEARCH_DENSITY_DEFAULT_VALUE)
+        if not isinstance(l, float) or l <= 0:
+            raise ValueError("Expected positive float as parameter 'l'.")
+        if not isinstance(k, float) or k <= 0:
+            raise ValueError("Expected positive float as parameter 'k'.")
+        if not isinstance(eps, float) or eps <= 0:
+            raise ValueError("Expected positive float as parameter 'eps'.")
+        if not isinstance(search_area, float) or search_area <= 0:
+            raise ValueError("Expected positive float as parameter 'search_area'.")
+        if not isinstance(search_density, int) or search_density <= 0:
+            raise ValueError("Expected positive integer as parameter 'search_density'.")
+        return l, k, eps, search_area, search_density
+
+    def _alpha(self, zeta: float, tau: float) -> complex:
+        return (1 / self.n) * np.sum(np.exp(1j * zeta * self.sample)) * math.exp(zeta**2 * tau**2 / 2)
+
+    def _generate_t(self) -> np.ndarray:
+        k_values = np.arange(-self.l, self.l + 1)
+        return k_values / self.k
+
+    def _build_matrix(self, tau: float) -> np.ndarray:
+        """Build the matrix for eigenvalue computation."""
+        t = self._generate_t()
+        t_len = len(t)
+        matrix = np.zeros((t_len, t_len), dtype=np.complex128)
+        for i in range(t_len):
+            for j in range(t_len):
+                matrix[i, j] = self._alpha(t[i] - t[j], tau)
+        return matrix
+
+    def algorithm(self, sample: np.ndarray) -> EstimateResult:
+        """Estimate sigma.
+
+        Args:
+            sample: Sample of the analyzed distribution.
+
+        Returns:
+            EstimateResult: Object with estimated sigma value.
+        """
+        if sample.size == 0:
+            raise ValueError("Sample cannot be empty.")
+        tau_values = np.linspace(0, self.search_area, self.search_density)
+        for tau in tau_values:
+            matrix = self._build_matrix(tau)
+            eigenvalues = eigh(matrix, eigvals_only=True)
+            lambda_min = np.min(eigenvalues)
+            if lambda_min < -self.eps:
+                return EstimateResult(value=tau, success=True)
+        return EstimateResult(success=False)

requirements.txt

@@ -0,0 +1,66 @@
+import math
+from typing import Optional, TypedDict
+
+import numpy as np
+
+from src.estimators.estimate_result import EstimateResult
+
+T_DEFAULT_VALUE = 7.5
+PARAMETER_KEYS = ["t"]
+
+
+class SemiParametricMeanSigmaEstimationEmpirical:
+    """Estimation of sigma parameter of NM mixture represented in canonical form Y = xi + sigma*N.
+
+    Args:
+        sample (Optional[np.ndarray]): Sample of the analyzed distribution.
+        params (Optional[dict]): Parameters of the algorithm.
+    """
+
+    class ParamsAnnotation(TypedDict, total=False):
+        t: float
+
+    def __init__(
+        self,
+        sample: Optional[np.ndarray] = None,
+        **kwargs: ParamsAnnotation,
+    ):
+        self.sample: np.ndarray = np.array([]) if sample is None else sample
+        self.n: int = len(self.sample)
+        self.t: float = self._validate_kwargs(**kwargs)
+
+    @staticmethod
+    def _validate_kwargs(**kwargs: ParamsAnnotation) -> float:
+        """Validate and extract parameters.
+
+        Args:
+            kwargs (dict): Parameters of the algorithm.
+
+        Returns:
+            float: Validated parameter `t`.
+        """
+        if any(key not in PARAMETER_KEYS for key in kwargs):
+            raise ValueError("Got unexpected parameter.")
+
+        t_value = kwargs.get("t", T_DEFAULT_VALUE)
+        if not isinstance(t_value, (float, int)):
+            raise ValueError("Expected a numeric value (float or int) as parameter `t`.")
+
+        t = float(t_value)
+        if t <= 0:
+            raise ValueError("Expected a positive float as parameter `t`.")
+        return t
+
+    def algorithm(self, sample: np.ndarray) -> EstimateResult:
+        """Estimate the sigma parameter.
+
+        Args:
+            sample (np.ndarray): Sample of the analyzed distribution.
+
+        Returns:
+            EstimateResult: An object containing the estimated sigma value.
+        """
+        if sample.size == 0:
+            raise ValueError("Sample can't be empty.")
+        sigma = ((2 / (self.t**2)) * math.log((1 / self.n) * sum([math.exp(self.t * x) for x in self.sample]))) ** 0.5
+        return EstimateResult(value=sigma, success=True)