feat(families): score for builtins is implemented

Author: MyznikovFD

src/pysatl_core/families/builtins/continuous/exponential.py

@@ -223,6 +223,38 @@ def _support(_: Parametrization) -> ContinuousSupport:
         """Support of exponential distribution"""
         return ContinuousSupport(left=0.0)
 
+    def _base_score(parameters: Parametrization, x: NumericArray) -> NumericArray:
+        """
+        Compute the score (gradient of log‑PDF) for the base parametrization (rate λ).
+
+        For exponential distribution with rate λ > 0, log‑PDF is:
+            log f(x) = log λ - λ x   for x ≥ 0, else -∞.
+
+        The derivative with respect to λ is:
+            ∂/∂λ log f = 1/λ - x   (for x ≥ 0).
+
+        For points x < 0 the density is zero; we return 0 for numerical stability
+        (though the score is technically undefined there).
+
+        Parameters
+        ----------
+        parameters : Parametrization
+            Base parametrization instance (_Rate) with field lambda_.
+        x : NumericArray
+            Points at which to evaluate the gradient.
+
+        Returns
+        -------
+        NumericArray
+            Gradient array of shape (..., 1) where the last axis corresponds to
+            d(log f)/d(lambda_).
+        """
+        params = cast(_Rate, parameters)
+        lam = params.lambda_
+        inside = x >= 0
+        grad = np.where(inside, 1.0 / lam - x, 0.0)
+        return grad[..., np.newaxis]  # shape (..., 1)
+
     Exponential = ParametricFamily(
         name=FamilyName.EXPONENTIAL,
         distr_type=UnivariateContinuous,
@@ -239,6 +271,7 @@ def _support(_: Parametrization) -> ContinuousSupport:
             CharacteristicName.KURT: kurt_func,
         },
         support_by_parametrization=_support,
+        base_score=_base_score,
     )
     Exponential.__doc__ = EXPONENTIAL_DOC
 
@@ -289,4 +322,27 @@ def transform_to_base_parametrization(self) -> Parametrization:
             """
             return _Rate(lambda_=1.0 / self.beta)
 
+        def gradient_transform(self, grad_base: NumericArray) -> NumericArray:
+            """
+            Transform gradient from base parameter (rate λ) to scale β = 1/λ.
+
+            The transformation is: β = 1/λ.
+            Derivative: dβ/dλ = -1/λ².
+            Hence: grad_β = grad_λ * (-1/λ²) = -grad_λ / λ².
+
+            Parameters
+            ----------
+            grad_base : NumericArray
+                Gradient with respect to λ, shape (..., 1).
+
+            Returns
+            -------
+            NumericArray
+                Gradient with respect to β, shape (..., 1).
+            """
+            lam = 1.0 / self.beta  # λ = 1/β
+            grad_lam = grad_base[..., 0]
+            grad_beta = -grad_lam / (lam * lam)
+            return grad_beta[..., np.newaxis].astype(np.float64)
+
     ParametricFamilyRegister.register(Exponential)

src/pysatl_core/families/builtins/continuous/normal.py

@@ -232,6 +232,36 @@ def _support(_: Parametrization) -> ContinuousSupport:
         """Support of normal distribution"""
         return ContinuousSupport()
 
+    def _base_score(parameters: Parametrization, x: NumericArray) -> NumericArray:
+        """
+        Compute the score (gradient of log‑PDF) for the base parametrization.
+
+        The base parametrization uses parameters mu (mean) and sigma (standard deviation).
+        The returned gradient has shape (..., 2) with the last axis corresponding
+        to [d(log f)/d(mu), d(log f)/d(sigma)].
+
+        Parameters
+        ----------
+        parameters : Parametrization
+            Base parametrization instance (must be _MeanStd).
+        x : NumericArray
+            Points at which the gradient is evaluated.
+
+        Returns
+        -------
+        NumericArray
+            Gradient array of shape (..., 2).
+        """
+        params = cast(_MeanStd, parameters)
+        mu = params.mu
+        sigma = params.sigma
+
+        z = (x - mu) / sigma
+
+        grad_mu = z / sigma
+        grad_sigma = (z * z - 1) / sigma
+        return np.stack([grad_mu, grad_sigma], axis=-1)
+
     Normal = ParametricFamily(
         name=FamilyName.NORMAL,
         distr_type=UnivariateContinuous,
@@ -248,6 +278,7 @@ def _support(_: Parametrization) -> ContinuousSupport:
             CharacteristicName.KURT: kurt_func,
         },
         support_by_parametrization=_support,
+        base_score=_base_score,
     )
     Normal.__doc__ = NORMAL_DOC
 
@@ -305,6 +336,29 @@ def transform_to_base_parametrization(self) -> Parametrization:
             sigma = math.sqrt(self.var)
             return _MeanStd(mu=self.mu, sigma=sigma)
 
+        def gradient_transform(self, grad_base: NumericArray) -> NumericArray:
+            """
+            Transform gradient from base parameters (mu, sigma) to (mu, var).
+
+            The transformation is: var = sigma^2  →  d(var) = 2 sigma d(sigma).
+
+            Parameters
+            ----------
+            grad_base : NumericArray
+                Gradient with respect to (mu, sigma), shape (..., 2).
+
+            Returns
+            -------
+            NumericArray
+                Gradient with respect to (mu, var), shape (..., 2).
+            """
+            sigma = np.sqrt(self.var)
+
+            grad_mu = grad_base[..., 0]
+            grad_sigma = grad_base[..., 1]
+            grad_var = grad_sigma / (2 * sigma)
+            return np.stack([grad_mu, grad_var], axis=-1)
+
     @parametrization(family=Normal, name="meanPrec")
     class _MeanPrec(Parametrization):
         """
@@ -338,6 +392,30 @@ def transform_to_base_parametrization(self) -> Parametrization:
             sigma = math.sqrt(1 / self.tau)
             return _MeanStd(mu=self.mu, sigma=sigma)
 
+        def gradient_transform(self, grad_base: NumericArray) -> NumericArray:
+            """
+            Transform gradient from base parameters (mu, sigma) to (mu, tau).
+
+            The transformation is: tau = 1/sigma^2  →  d(tau) = -2 / sigma^3 d(sigma).
+
+            Parameters
+            ----------
+            grad_base : NumericArray
+                Gradient with respect to (mu, sigma), shape (..., 2).
+
+            Returns
+            -------
+            NumericArray
+                Gradient with respect to (mu, tau), shape (..., 2).
+            """
+
+            sigma = 1.0 / np.sqrt(self.tau)
+
+            grad_mu = grad_base[..., 0]
+            grad_sigma = grad_base[..., 1]
+            grad_tau = -grad_sigma * sigma**3 / 2.0
+            return np.stack([grad_mu, grad_tau], axis=-1)
+
     @parametrization(family=Normal, name="exponential")
     class _Exp(Parametrization):
         """
@@ -384,4 +462,36 @@ def transform_to_base_parametrization(self) -> Parametrization:
             sigma = math.sqrt(-1 / (2 * self.a))
             return _MeanStd(mu=mu, sigma=sigma)
 
+        def gradient_transform(self, grad_base: NumericArray) -> NumericArray:
+            """
+            Transform gradient from base parameters (mu, sigma) to (a, b).
+
+            The transformation is:
+                mu = -b/(2a),  sigma = sqrt(-1/(2a)).
+            The Jacobian is applied via the chain rule.
+
+            Parameters
+            ----------
+            grad_base : NumericArray
+                Gradient with respect to (mu, sigma), shape (..., 2).
+
+            Returns
+            -------
+            NumericArray
+                Gradient with respect to (a, b), shape (..., 2).
+            """
+            a = self.a
+            b = self.b
+
+            dmu_da = b / (2 * a * a)
+            dmu_db = -1 / (2 * a)
+            dsigma_da = 1 / (2 * np.sqrt(-2 * a**3))
+            dsigma_db = 0.0
+
+            grad_mu = grad_base[..., 0]
+            grad_sigma = grad_base[..., 1]
+            grad_a = grad_mu * dmu_da + grad_sigma * dsigma_da
+            grad_b = grad_mu * dmu_db + grad_sigma * dsigma_db
+            return np.stack([grad_a, grad_b], axis=-1)
+
     ParametricFamilyRegister.register(Normal)

src/pysatl_core/families/builtins/continuous/uniform.py

@@ -260,6 +260,44 @@ def _support(parameters: Parametrization) -> ContinuousSupport:
             right_closed=True,
         )
 
+    def _base_score(parameters: Parametrization, x: NumericArray) -> NumericArray:
+        """
+        Compute the score (gradient of log‑PDF) for the base
+        parametrization (lower_bound, upper_bound).
+
+        For uniform distribution on [a, b] with a < b, log‑PDF is:
+            log f(x) = -log(b - a)   for a ≤ x ≤ b, else -∞.
+
+        The gradient with respect to a and b (where defined, i.e., inside the support) is:
+            ∂/∂a log f =  1/(b - a)
+            ∂/∂b log f = -1/(b - a)
+
+        For points outside the support, the gradient is set to 0 (since density is zero,
+        but the score is typically considered undefined; we return 0 for numerical safety).
+
+        Parameters
+        ----------
+        parameters : Parametrization
+            Base parametrization instance (_Standard) with fields lower_bound, upper_bound.
+        x : NumericArray
+            Points at which to evaluate the gradient.
+
+        Returns
+        -------
+        NumericArray
+            Gradient array of shape (..., 2) where last axis corresponds to
+            [d(log f)/d(lower_bound), d(log f)/d(upper_bound)].
+        """
+        params = cast(_Standard, parameters)
+        a = params.lower_bound
+        b = params.upper_bound
+        width = b - a
+
+        inside = (x >= a) & (x <= b)
+        grad_a = np.where(inside, 1.0 / width, 0.0)
+        grad_b = np.where(inside, -1.0 / width, 0.0)
+        return np.stack([grad_a, grad_b], axis=-1)
+
     Uniform = ParametricFamily(
         name=FamilyName.CONTINUOUS_UNIFORM,
         distr_type=UnivariateContinuous,
@@ -276,6 +314,7 @@ def _support(parameters: Parametrization) -> ContinuousSupport:
             CharacteristicName.KURT: kurt_func,
         },
         support_by_parametrization=_support,
+        base_score=_base_score,
     )
     Uniform.__doc__ = UNIFORM_DOC
 
@@ -333,6 +372,38 @@ def transform_to_base_parametrization(self) -> Parametrization:
             half_width = self.width / 2
             return _Standard(lower_bound=self.mean - half_width, upper_bound=self.mean + half_width)
 
+        def gradient_transform(self, grad_base: NumericArray) -> NumericArray:
+            """
+            Transform gradient from base parameters (a, b) to (mean, width).
+
+            The transformation is:
+                mean = (a + b) / 2
+                width = b - a
+
+            The Jacobian matrix:
+                d(mean)/da = 0.5,   d(mean)/db = 0.5
+                d(width)/da = -1,    d(width)/db = 1
+
+            Hence:
+                grad_mean = 0.5 * (grad_a + grad_b)
+                grad_width = -grad_a + grad_b
+
+            Parameters
+            ----------
+            grad_base : NumericArray
+                Gradient with respect to (a, b), shape (..., 2).
+
+            Returns
+            -------
+            NumericArray
+                Gradient with respect to (mean, width), shape (..., 2).
+            """
+            grad_a = grad_base[..., 0]
+            grad_b = grad_base[..., 1]
+            grad_mean = 0.5 * (grad_a + grad_b)
+            grad_width = -grad_a + grad_b
+            return np.stack([grad_mean, grad_width], axis=-1)
+
     @parametrization(family=Uniform, name="minRange")
     class _MinRange(Parametrization):
         """
@@ -365,4 +436,36 @@ def transform_to_base_parametrization(self) -> Parametrization:
             """
             return _Standard(lower_bound=self.minimum, upper_bound=self.minimum + self.range_val)
 
+        def gradient_transform(self, grad_base: NumericArray) -> NumericArray:
+            """
+            Transform gradient from base parameters (a, b) to (minimum, range_val).
+
+            The transformation is:
+                minimum = a
+                range_val = b - a
+
+            The Jacobian matrix:
+                d(minimum)/da = 1,    d(minimum)/db = 0
+                d(range_val)/da = -1,  d(range_val)/db = 1
+
+            Hence:
+                grad_minimum = grad_a
+                grad_range = -grad_a + grad_b
+
+            Parameters
+            ----------
+            grad_base : NumericArray
+                Gradient with respect to (a, b), shape (..., 2).
+
+            Returns
+            -------
+            NumericArray
+                Gradient with respect to (minimum, range_val), shape (..., 2).
+            """
+            grad_a = grad_base[..., 0]
+            grad_b = grad_base[..., 1]
+            grad_minimum = grad_a
+            grad_range = -grad_a + grad_b
+            return np.stack([grad_minimum, grad_range], axis=-1)
+
     ParametricFamilyRegister.register(Uniform)