Make params_names an instance-level property (#55)

* Make fit an instance method and deprecate fit_instance

* Update documentation

* Make params_names an instance-level property

* Feedback from copilot

Author: jonathanberthias

pykelihood/distributions/custom.py

@@ -30,12 +30,15 @@ class Exponential(ScipyDistribution):
         Rate parameter, by default 1.0.
     """
 
-    params_names = ("loc", "rate")
     _base_module = _stats.expon
 
     def __init__(self, loc=0.0, rate=1.0):
         super().__init__(loc, rate)
 
+    @property
+    def params_names(self):
+        return ("loc", "rate")
+
     def _to_scipy_args(self, loc=None, rate=None):
         """
         Convert to scipy arguments.
@@ -71,12 +74,15 @@ class Gamma(ScipyDistribution):
         Shape parameter, by default 0.0.
     """
 
-    params_names = ("loc", "scale", "shape")
     _base_module = _stats.gamma
 
     def __init__(self, loc=0.0, scale=1.0, shape=0.0):
         super().__init__(loc, scale, shape)
 
+    @property
+    def params_names(self):
+        return ("loc", "scale", "shape")
+
     def _to_scipy_args(self, loc=None, scale=None, shape=None):
         """
         Convert to scipy arguments.
@@ -116,12 +122,15 @@ class Pareto(ScipyDistribution):
         Shape parameter, by default 1.0.
     """
 
-    params_names = ("loc", "scale", "alpha")
     _base_module = _stats.pareto
 
     def __init__(self, loc=0.0, scale=1.0, alpha=1.0):
         super().__init__(loc, scale, alpha)
 
+    @property
+    def params_names(self):
+        return ("loc", "scale", "alpha")
+
     def _to_scipy_args(self, loc=None, scale=None, alpha=None):
         """
         Convert to scipy arguments.
@@ -163,12 +172,15 @@ class Beta(ScipyDistribution):
         Beta parameter, by default 1.0.
     """
 
-    params_names = ("loc", "scale", "alpha", "beta")
     _base_module = _stats.beta
 
     def __init__(self, loc=0.0, scale=1.0, alpha=2.0, beta=1.0):
         super().__init__(loc, scale, alpha, beta)
 
+    @property
+    def params_names(self):
+        return ("loc", "scale", "alpha", "beta")
+
     def _to_scipy_args(self, loc=None, scale=None, alpha=None, beta=None):
         """
         Convert to scipy arguments.
@@ -217,12 +229,15 @@ class GEV(ScipyDistribution):
     is `-c`.
     """
 
-    params_names = ("loc", "scale", "shape")
     _base_module = _stats.genextreme
 
     def __init__(self, loc=0.0, scale=1.0, shape=0.0):
         super().__init__(loc, scale, shape)
 
+    @property
+    def params_names(self):
+        return ("loc", "scale", "shape")
+
     def lb_shape(self, data):
         """
         Calculate the lower bound of the shape parameter.
@@ -310,12 +325,15 @@ class GPD(ScipyDistribution):
         Shape parameter, by default 0.0.
     """
 
-    params_names = ("loc", "scale", "shape")
     _base_module = _stats.genpareto
 
     def __init__(self, loc=0.0, scale=1.0, shape=0.0):
         super().__init__(loc, scale, shape)
 
+    @property
+    def params_names(self):
+        return ("loc", "scale", "shape")
+
     def _to_scipy_args(self, loc=None, scale=None, shape=None):
         """
         Convert to scipy arguments.
@@ -360,8 +378,6 @@ class TruncatedDistribution(Distribution):
         If the lower and upper bounds are equal.
     """
 
-    params_names = ("distribution",)
-
     def __init__(
         self, distribution: Distribution, lower_bound=-np.inf, upper_bound=np.inf
     ):
@@ -374,7 +390,11 @@ def __init__(
         upper_cdf = self.distribution.cdf(self.upper_bound)
         self._normalizer = upper_cdf - lower_cdf
 
-    def _build_instance(self, **new_params):
+    @property
+    def params_names(self):
+        return ("distribution",)
+
+    def _build_instance(self, distribution: Distribution, **new_params):
         """
         Build a new instance with the given parameters.
 
@@ -388,7 +408,6 @@ def _build_instance(self, **new_params):
         TruncatedDistribution
             The new instance.
         """
-        distribution = new_params.pop("distribution")
         if new_params:
             raise ValueError(f"Unexpected arguments: {new_params}")
         return type(self)(distribution, self.lower_bound, self.upper_bound)

pykelihood/distributions/scipy.py

@@ -45,12 +45,12 @@ def format_param_docstring(param: str) -> str:
 
     class Wrapper(ScipyDistribution):
         _base_module = scipy_dist
-        params_names = dist_params_names
         __doc__ = docstring
 
         def __init__(self, loc=0.0, scale=1.0, **kwargs):
-            assert self.params_names[:2] == ("loc", "scale")
-            shape_args = self.params_names[2:]
+            self._params_names = dist_params_names
+            assert self._params_names[:2] == ("loc", "scale")
+            shape_args = self._params_names[2:]
             for arg in shape_args:
                 if arg not in kwargs:
                     raise ValueError(
@@ -59,6 +59,11 @@ def __init__(self, loc=0.0, scale=1.0, **kwargs):
             args = [kwargs[a] for a in shape_args]
             super().__init__(loc, scale, *args)
 
+        @property
+        def params_names(self) -> tuple[str, ...]:
+            """Return the names of the parameters."""
+            return self._params_names
+
         def _to_scipy_args(self, **kwargs):
             return {k: kwargs.get(k, getattr(self, k)()) for k in self.params_names}
 

pykelihood/kernels.py

@@ -178,11 +178,6 @@ def wrapped(x, **param_values) -> Kernel:
     return wrapper
 
 
-"""
-Simple kernels with one covariate
-"""
-
-
 @kernel(a=0.0, b=0.0)
 def linear(X, a, b):
     r"""
@@ -290,12 +285,10 @@ def exponential_ratio(X, a, b, c):
     array-like
         Exponential ratio kernel output.
     """
-    inner = a * X
-    inner = inner / b
-    return c * np.exp(inner)
+    return c * np.exp(a * X / b)
 
 
-@kernel(mu=0.0, sigma=1.0, scaling=0.0)
+@kernel(mu=0.0, sigma=1.0, scaling=1.0)
 def gaussian(X, mu, sigma, scaling):
     r"""
     Gaussian kernel function.

pykelihood/parameters.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import abc
 from collections import ChainMap
 from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any, Callable, TypeVar
@@ -37,13 +38,11 @@ def ensure_parametrized(x: Any, constant=False) -> Parametrized:
     return cls(x)
 
 
-class Parametrized:
+class Parametrized(abc.ABC):
     """
     Base class for parametrized objects.
     """
 
-    params_names: tuple[str, ...]
-
     def __init__(self, *params: Parametrized | Any):
         """
         Initialize the `Parametrized` object.
@@ -55,6 +54,19 @@ def __init__(self, *params: Parametrized | Any):
         """
         self._params = tuple(ensure_parametrized(p) for p in params)
 
+    @property
+    @abc.abstractmethod
+    def params_names(self) -> tuple[str, ...]:
+        """
+        Get the names of the parameters.
+
+        Returns
+        -------
+        tuple[str, ...]
+            The parameter names.
+        """
+        raise NotImplementedError()
+
     def _build_instance(self, **new_params) -> Self:
         """
         Build a new instance with the given parameters.
@@ -72,7 +84,7 @@ def _build_instance(self, **new_params) -> Self:
         return type(self)(**new_params)
 
     @property
-    def params(self) -> tuple[Parametrized]:
+    def params(self) -> tuple[Parametrized, ...]:
         """
         Get parameters in their parametrized format, e.g. how they were defined.
 
@@ -96,7 +108,7 @@ def param_dict(self) -> dict[str, Parametrized]:
         return dict(zip(self.params_names, self.params))
 
     @property
-    def flattened_params(self) -> tuple[Parametrized]:
+    def flattened_params(self) -> tuple[Parametrized, ...]:
         """
         Get a horizontal view of all parameters in the final state of their
         respective tree of dependence.
@@ -220,14 +232,6 @@ def __call__(self, *args, **kwargs):
         raise NotImplementedError("A generic Parametrized object has no value!")
 
     def __repr__(self):
-        """
-        Get the string representation of the `Parametrized` object.
-
-        Returns
-        -------
-        str
-            The string representation.
-        """
         args = [f"{a}={v!r}" for a, v in zip(self.params_names, self._params)]
         return f"{type(self).__name__}({', '.join(args)})"
 
@@ -327,6 +331,10 @@ def __init__(self, value: npt.ArrayLike) -> None:
         """
         self._value = np.asarray(value, dtype=np.float64)
 
+    @property
+    def params_names(self) -> tuple[()]:
+        return ()
+
     @property
     def params(self):
         """
@@ -497,10 +505,22 @@ def __init__(self, f: Callable, *, fname=None, **params: Parametrized):
             Parameters for the function.
         """
         super().__init__(*params.values())
-        self.params_names = tuple(params.keys())
+        self._params_names = tuple(params.keys())
         self.f = f
         self.fname = fname or f.__qualname__
 
+    @property
+    def params_names(self) -> tuple[str, ...]:
+        """
+        Get the names of the parameters.
+
+        Returns
+        -------
+        tuple[str, ...]
+            The parameter names.
+        """
+        return self._params_names
+
     def __call__(self, *args, **kwargs):
         """
         Call the parametrized function with the given arguments.

tests/test_parameters.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import pytest
 
 from pykelihood import parameters
@@ -13,14 +15,21 @@ def test_parameter_with_params():
     assert p.with_params([5.0])() == 5.0
 
 
+class BareParametrized(parameters.Parametrized):
+    def __init__(self, *p: parameters.Parametrized | float, names: list[str]):
+        super().__init__(*p)
+        self._params_names = names
+
+    @property
+    def params_names(self):
+        return self._params_names
+
+
 def test_flattened_params():
     p1 = parameters.Parameter(1)
     p2 = parameters.ConstantParameter(2)
-    a = parameters.Parametrized(p1, 2)
-    a.params_names = ("x", "m")
-    repr(a)
-    b = parameters.Parametrized(a, p2)
-    b.params_names = ("y", "n")
+    a = BareParametrized(p1, 2, names=["x", "m"])
+    b = BareParametrized(a, p2, names=["y", "n"])
     assert set(a.flattened_param_dict.keys()) == {"x", "m"}
     assert len(a.flattened_params) == 2
     assert set(b.flattened_param_dict.keys()) == {"y_x", "y_m", "n"}
@@ -30,15 +39,13 @@ def test_flattened_params():
 def test_flattened_params_with_embedded_constant():
     p1 = parameters.Parameter(1)
     p2 = parameters.ConstantParameter(2)
-    a = parameters.Parametrized(p1, p2)
-    a.params_names = ("x", "m")
-    b = parameters.Parametrized(a)
-    b.params_names = "y"
-    assert set(a.flattened_param_dict.keys()) == {"x", "m"}
+    a = BareParametrized(p1, p2, names=["x", "m"])
+    b = BareParametrized(a, names=["y"])
+    assert set(a.flattened_param_dict) == {"x", "m"}
     assert len(a.flattened_params) == 2
-    assert set(b.flattened_param_dict.keys()) == {"y_x", "y_m"}
+    assert set(b.flattened_param_dict) == {"y_x", "y_m"}
     assert len(b.flattened_params) == 2
-    assert set(b.optimisation_param_dict.keys()) == {"y_x"}
+    assert set(b.optimisation_param_dict) == {"y_x"}
     assert len(b.optimisation_params) == 1