deepsensor 0.3.7__tar.gz → 0.3.8__tar.gz

{deepsensor-0.3.7 → deepsensor-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepsensor
-Version: 0.3.7
+Version: 0.3.8
 Summary: A Python package for modelling xarray and pandas data with neural processes.
 Home-page: https://github.com/alan-turing-institute/deepsensor
 Author: Tom R. Andersson
@@ -44,7 +44,7 @@ data with neural processes</p>
 
 -----------
 
-[![release](https://img.shields.io/badge/release-v0.3.7-green?logo=github)](https://github.com/alan-turing-institute/deepsensor/releases)
+[![release](https://img.shields.io/badge/release-v0.3.8-green?logo=github)](https://github.com/alan-turing-institute/deepsensor/releases)
 [![Latest Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://alan-turing-institute.github.io/deepsensor/)
 ![Tests](https://github.com/alan-turing-institute/deepsensor/actions/workflows/tests.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/alan-turing-institute/deepsensor/badge.svg?branch=main)](https://coveralls.io/github/alan-turing-institute/deepsensor?branch=main)

{deepsensor-0.3.7 → deepsensor-0.3.8}/README.md

@@ -11,7 +11,7 @@ data with neural processes</p>
 
 -----------
 
-[![release](https://img.shields.io/badge/release-v0.3.7-green?logo=github)](https://github.com/alan-turing-institute/deepsensor/releases)
+[![release](https://img.shields.io/badge/release-v0.3.8-green?logo=github)](https://github.com/alan-turing-institute/deepsensor/releases)
 [![Latest Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://alan-turing-institute.github.io/deepsensor/)
 ![Tests](https://github.com/alan-turing-institute/deepsensor/actions/workflows/tests.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/alan-turing-institute/deepsensor/badge.svg?branch=main)](https://coveralls.io/github/alan-turing-institute/deepsensor?branch=main)

{deepsensor-0.3.7 → deepsensor-0.3.8}/deepsensor/data/processor.py

@@ -97,7 +97,7 @@ class DataProcessor:
         self.verbose = verbose
 
         # List of valid normalisation method names
-        self.valid_methods = ["mean_std", "min_max"]
+        self.valid_methods = ["mean_std", "min_max", "positive_semidefinite"]
 
     def save(self, folder: str):
         """Save DataProcessor config to JSON in `folder`"""
@@ -293,6 +293,8 @@ class DataProcessor:
                 params = {"mean": float(data.mean()), "std": float(data.std())}
             elif method == "min_max":
                 params = {"min": float(data.min()), "max": float(data.max())}
+            elif method == "positive_semidefinite":
+                params = {"min": float(data.min()), "std": float(data.std())}
             if self.verbose:
                 print(f"Done. {var_ID} {method} params={params}")
             self.add_to_config(
@@ -498,33 +500,25 @@ class DataProcessor:
 
         params = self.get_config(var_ID, data, method)
 
+        # Linear transformation:
+        # - Inverse normalisation: y_unnorm = m * y_norm + c
+        # - Inverse normalisation: y_norm = (1/m) * y_unnorm - c/m
         if method == "mean_std":
-            std = params["std"]
-            mean = params["mean"]
-            if unnorm:
-                scale = std
-                offset = mean
-            else:
-                scale = 1 / std
-                offset = -mean / std
-            data = data * scale
-            if add_offset:
-                data = data + offset
-            return data
-
+            m = params["std"]
+            c = params["mean"]
         elif method == "min_max":
-            minimum = params["min"]
-            maximum = params["max"]
-            if unnorm:
-                scale = (maximum - minimum) / 2
-                offset = (maximum + minimum) / 2
-            else:
-                scale = 2 / (maximum - minimum)
-                offset = -(maximum + minimum) / (maximum - minimum)
-            data = data * scale
-            if add_offset:
-                data = data + offset
-            return data
+            m = (params["max"] - params["min"]) / 2
+            c = (params["max"] + params["min"]) / 2
+        elif method == "positive_semidefinite":
+            m = params["std"]
+            c = params["min"]
+        if not unnorm:
+            c = -c / m
+            m = 1 / m
+        data = data * m
+        if add_offset:
+            data = data + c
+        return data
 
     def map(
         self,
@@ -610,6 +604,7 @@ class DataProcessor:
             method (str, optional): Normalisation method. Options include:
                 - "mean_std": Normalise to mean=0 and std=1 (default)
                 - "min_max": Normalise to min=-1 and max=1
+                - "positive_semidefinite": Normalise to min=0 and std=1
 
         Returns:
             :class:`xarray.DataArray` | :class:`xarray.Dataset` | :class:`pandas.DataFrame` | List[:class:`xarray.DataArray` | :class:`xarray.Dataset` | :class:`pandas.DataFrame`]:

{deepsensor-0.3.7 → deepsensor-0.3.8}/deepsensor/model/convnp.py

@@ -539,10 +539,10 @@ class ConvNP(DeepSensorModel):
     def alpha(
         self, dist: AbstractMultiOutputDistribution
     ) -> Union[np.ndarray, List[np.ndarray]]:
-        if self.config["likelihood"] not in ["spikes-beta", "bernoulli-gamma"]:
+        if self.config["likelihood"] not in ["spikes-beta"]:
             raise NotImplementedError(
                 f"ConvNP.alpha method not supported for likelihood {self.config['likelihood']}. "
-                f"Try changing the likelihood to a mixture model, e.g. 'spikes-beta' or 'bernoulli-gamma'."
+                f"Valid likelihoods: 'spikes-beta'."
             )
         alpha = dist.slab.alpha
         alpha = self._cast_numpy_and_squeeze(alpha)
@@ -576,10 +576,10 @@ class ConvNP(DeepSensorModel):
     def beta(
         self, dist: AbstractMultiOutputDistribution
     ) -> Union[np.ndarray, List[np.ndarray]]:
-        if self.config["likelihood"] not in ["spikes-beta", "bernoulli-gamma"]:
+        if self.config["likelihood"] not in ["spikes-beta"]:
             raise NotImplementedError(
                 f"ConvNP.beta method not supported for likelihood {self.config['likelihood']}. "
-                f"Try changing the likelihood to a mixture model, e.g. 'spikes-beta' or 'bernoulli-gamma'."
+                f"Valid likelihoods: 'spikes-beta'."
             )
         beta = dist.slab.beta
         beta = self._cast_numpy_and_squeeze(beta)
@@ -608,6 +608,80 @@ class ConvNP(DeepSensorModel):
         dist = self(task)
         return self.beta(dist)
 
+    @dispatch
+    def k(
+        self, dist: AbstractMultiOutputDistribution
+    ) -> Union[np.ndarray, List[np.ndarray]]:
+        if self.config["likelihood"] not in ["bernoulli-gamma"]:
+            raise NotImplementedError(
+                f"ConvNP.k method not supported for likelihood {self.config['likelihood']}. "
+                f"Valid likelihoods: 'bernoulli-gamma'."
+            )
+        k = dist.slab.k
+        k = self._cast_numpy_and_squeeze(k)
+        return self._maybe_concat_multi_targets(k)
+
+    @dispatch
+    def k(self, task: Task) -> Union[np.ndarray, List[np.ndarray]]:
+        """
+        k parameter values of model's distribution at target locations in task.
+
+        Returned numpy arrays have shape ``(N_features, *N_targets)``.
+
+        .. note::
+            This method only works for models that return a distribution with
+            a ``dist.slab.k`` attribute, e.g. models with a Beta or
+            Bernoulli-Gamma likelihood, where it returns the k values of
+            the slab component of the mixture model.
+
+        Args:
+            task (:class:`~.data.task.Task`):
+                The task containing the context and target data.
+
+        Returns:
+            :class:`numpy:numpy.ndarray` | List[:class:`numpy:numpy.ndarray`]:
+                k values.
+        """
+        dist = self(task)
+        return self.k(dist)
+
+    @dispatch
+    def scale(
+        self, dist: AbstractMultiOutputDistribution
+    ) -> Union[np.ndarray, List[np.ndarray]]:
+        if self.config["likelihood"] not in ["bernoulli-gamma"]:
+            raise NotImplementedError(
+                f"ConvNP.scale method not supported for likelihood {self.config['likelihood']}. "
+                f"Valid likelihoods: 'bernoulli-gamma'."
+            )
+        scale = dist.slab.scale
+        scale = self._cast_numpy_and_squeeze(scale)
+        return self._maybe_concat_multi_targets(scale)
+
+    @dispatch
+    def scale(self, task: Task) -> Union[np.ndarray, List[np.ndarray]]:
+        """
+        Scale parameter values of model's distribution at target locations in task.
+
+        Returned numpy arrays have shape ``(N_features, *N_targets)``.
+
+        .. note::
+            This method only works for models that return a distribution with
+            a ``dist.slab.scale`` attribute, e.g. models with a Beta or
+            Bernoulli-Gamma likelihood, where it returns the scale values of
+            the slab component of the mixture model.
+
+        Args:
+            task (:class:`~.data.task.Task`):
+                The task containing the context and target data.
+
+        Returns:
+            :class:`numpy:numpy.ndarray` | List[:class:`numpy:numpy.ndarray`]:
+                Scale values.
+        """
+        dist = self(task)
+        return self.scale(dist)
+
     @dispatch
     def mixture_probs(self, dist: AbstractMultiOutputDistribution):
         if self.N_mixture_components == 1:

{deepsensor-0.3.7 → deepsensor-0.3.8}/deepsensor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepsensor
-Version: 0.3.7
+Version: 0.3.8
 Summary: A Python package for modelling xarray and pandas data with neural processes.
 Home-page: https://github.com/alan-turing-institute/deepsensor
 Author: Tom R. Andersson
@@ -44,7 +44,7 @@ data with neural processes</p>
 
 -----------
 
-[![release](https://img.shields.io/badge/release-v0.3.7-green?logo=github)](https://github.com/alan-turing-institute/deepsensor/releases)
+[![release](https://img.shields.io/badge/release-v0.3.8-green?logo=github)](https://github.com/alan-turing-institute/deepsensor/releases)
 [![Latest Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://alan-turing-institute.github.io/deepsensor/)
 ![Tests](https://github.com/alan-turing-institute/deepsensor/actions/workflows/tests.yml/badge.svg)
 [![Coverage Status](https://coveralls.io/repos/github/alan-turing-institute/deepsensor/badge.svg?branch=main)](https://coveralls.io/github/alan-turing-institute/deepsensor?branch=main)

{deepsensor-0.3.7 → deepsensor-0.3.8}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = deepsensor
-version = 0.3.7
+version = 0.3.8
 author = Tom R. Andersson
 author_email = tomandersson3@gmail.com
 description = A Python package for modelling xarray and pandas data with neural processes.

{deepsensor-0.3.7 → deepsensor-0.3.8}/tests/test_active_learning.py

@@ -26,9 +26,6 @@ from deepsensor.data.processor import DataProcessor, xarray_to_coord_array_norma
 from deepsensor.model.convnp import ConvNP
 
 
-# from deepsensor.active_learning.acquisition_fns import
-
-
 class TestActiveLearning(unittest.TestCase):
 
     @classmethod

{deepsensor-0.3.7 → deepsensor-0.3.8}/tests/test_model.py

@@ -193,7 +193,7 @@ class TestModel(unittest.TestCase):
                             n_targets * dim_y_combined * n_target_dims,
                         ),
                     )
-                if likelihood in ["cnp-spikes-beta"]:
+                if likelihood in ["cnp-spikes-beta", "bernoulli-gamma"]:
                     mixture_probs = model.mixture_probs(task)
                     if isinstance(mixture_probs, (list, tuple)):
                         for p, dim_y in zip(mixture_probs, tl.target_dims):
@@ -215,6 +215,7 @@ class TestModel(unittest.TestCase):
                             ),
                         )
 
+                if likelihood in ["cnp-spikes-beta"]:
                     x = model.alpha(task)
                     if isinstance(x, (list, tuple)):
                         for p, dim_y in zip(x, tl.target_dims):
@@ -229,6 +230,21 @@ class TestModel(unittest.TestCase):
                     else:
                         assert_shape(x, (dim_y_combined, *expected_obs_shape))
 
+                if likelihood in ["bernoulli-gamma"]:
+                    x = model.k(task)
+                    if isinstance(x, (list, tuple)):
+                        for p, dim_y in zip(x, tl.target_dims):
+                            assert_shape(p, (dim_y, *expected_obs_shape))
+                    else:
+                        assert_shape(x, (dim_y_combined, *expected_obs_shape))
+
+                    x = model.scale(task)
+                    if isinstance(x, (list, tuple)):
+                        for p, dim_y in zip(x, tl.target_dims):
+                            assert_shape(p, (dim_y, *expected_obs_shape))
+                    else:
+                        assert_shape(x, (dim_y_combined, *expected_obs_shape))
+
                 # Scalars
                 if likelihood in ["cnp", "gnp"]:
                     # Methods for Gaussian likelihoods only
@@ -451,61 +467,75 @@ class TestModel(unittest.TestCase):
     def test_highlevel_predict_with_pred_params_pandas(self):
         """
         Test that passing ``pred_params`` to ``.predict`` works with
-        a spikes-beta likelihood for prediction to pandas.
+        mixture model likelihoods for off-grid prediction to pandas.
         """
         tl = TaskLoader(context=self.da, target=self.da)
-        model = ConvNP(
-            self.dp,
-            tl,
-            unet_channels=(5, 5, 5),
-            verbose=False,
-            likelihood="cnp-spikes-beta",
-        )
-        task = tl("2020-01-01", context_sampling=10, target_sampling=10)
 
-        # Off-grid prediction
-        X_t = np.array([[0.0, 0.5, 1.0], [0.0, 0.5, 1.0]])
+        likelihoods = ["cnp-spikes-beta", "bernoulli-gamma"]
+        expected_pred_params = [
+            ["mean", "std", "variance", "alpha", "beta"],
+            ["mean", "std", "variance", "k", "scale"],
+        ]
 
-        # Check that nothing breaks and the correct parameters are returned
-        pred_params = ["mean", "std", "variance", "alpha", "beta"]
-        pred = model.predict(task, X_t=X_t, pred_params=pred_params)
-        for pred_param in pred_params:
-            assert pred_param in pred["var"]
+        for likelihood, pred_params in zip(likelihoods, expected_pred_params):
+            model = ConvNP(
+                self.dp,
+                tl,
+                unet_channels=(5, 5, 5),
+                verbose=False,
+                likelihood=likelihood,
+            )
+            task = tl("2020-01-01", context_sampling=10)
+
+            # Off-grid prediction
+            X_t = np.array([[0.0, 0.5, 1.0], [0.0, 0.5, 1.0]])
 
-        # Test mixture probs special case
-        pred_params = ["mixture_probs"]
-        pred = model.predict(task, X_t=self.da, pred_params=pred_params)
-        for component in range(model.N_mixture_components):
-            pred_param = f"mixture_probs_{component}"
-            assert pred_param in pred["var"]
+            # Check that nothing breaks and the correct parameters are returned
+            pred = model.predict(task, X_t=X_t, pred_params=pred_params)
+            for pred_param in pred_params:
+                assert pred_param in pred["var"]
+
+            # Test mixture probs special case
+            pred_params = ["mixture_probs"]
+            pred = model.predict(task, X_t=self.da, pred_params=pred_params)
+            for component in range(model.N_mixture_components):
+                pred_param = f"mixture_probs_{component}"
+                assert pred_param in pred["var"]
 
     def test_highlevel_predict_with_pred_params_xarray(self):
         """
         Test that passing ``pred_params`` to ``.predict`` works with
-        a spikes-beta likelihood for prediction to xarray.
+        mixture model likelihoods for gridded prediction to xarray.
         """
         tl = TaskLoader(context=self.da, target=self.da)
-        model = ConvNP(
-            self.dp,
-            tl,
-            unet_channels=(5, 5, 5),
-            verbose=False,
-            likelihood="cnp-spikes-beta",
-        )
-        task = tl("2020-01-01", context_sampling=10, target_sampling=10)
 
-        # Check that nothing breaks and the correct parameters are returned
-        pred_params = ["mean", "std", "variance", "alpha", "beta"]
-        pred = model.predict(task, X_t=self.da, pred_params=pred_params)
-        for pred_param in pred_params:
-            assert pred_param in pred["var"]
-
-        # Test mixture probs special case
-        pred_params = ["mixture_probs"]
-        pred = model.predict(task, X_t=self.da, pred_params=pred_params)
-        for component in range(model.N_mixture_components):
-            pred_param = f"mixture_probs_{component}"
-            assert pred_param in pred["var"]
+        likelihoods = ["cnp-spikes-beta", "bernoulli-gamma"]
+        expected_pred_params = [
+            ["mean", "std", "variance", "alpha", "beta"],
+            ["mean", "std", "variance", "k", "scale"],
+        ]
+
+        for likelihood, pred_params in zip(likelihoods, expected_pred_params):
+            model = ConvNP(
+                self.dp,
+                tl,
+                unet_channels=(5, 5, 5),
+                verbose=False,
+                likelihood=likelihood,
+            )
+            task = tl("2020-01-01", context_sampling=10)
+
+            # Check that nothing breaks and the correct parameters are returned
+            pred = model.predict(task, X_t=self.da, pred_params=pred_params)
+            for pred_param in pred_params:
+                assert pred_param in pred["var"]
+
+            # Test mixture probs special case
+            pred_params = ["mixture_probs"]
+            pred = model.predict(task, X_t=self.da, pred_params=pred_params)
+            for component in range(model.N_mixture_components):
+                pred_param = f"mixture_probs_{component}"
+                assert pred_param in pred["var"]
 
     def test_highlevel_predict_with_invalid_pred_params(self):
         """Test that passing ``pred_params`` to ``.predict`` works."""