Add getting learnerto pandas; add learner.as_dataframe

Author: basnijholt

adaptive/learner/average_learner.py

@@ -9,7 +9,15 @@
 from adaptive.learner.base_learner import BaseLearner
 from adaptive.notebook_integration import ensure_holoviews
 from adaptive.types import Float, Real
-from adaptive.utils import cache_latest
+from adaptive.utils import cache_latest, default_parameters
+
+try:
+    import pandas
+
+    with_pandas = True
+
+except ModuleNotFoundError:
+    with_pandas = False
 
 
 class AverageLearner(BaseLearner):
@@ -70,6 +78,21 @@ def to_numpy(self):
         """Data as NumPy array of size (npoints, 2) with seeds and values."""
         return np.array(sorted(self.data.items()))
 
+    def to_dataframe(
+        self,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        seed_name: str = "seed",
+        y_name: str = "y",
+    ) -> pandas.DataFrame:
+        if not with_pandas:
+            raise ImportError("pandas is not installed.")
+        df = pandas.DataFrame(sorted(self.data.items()), columns=[seed_name, y_name])
+        if with_default_function_args:
+            defaults = default_parameters(self.function, function_prefix)
+            df = df.assign(**defaults)
+        return df
+
     def ask(self, n: int, tell_pending: bool = True) -> tuple[list[int], list[Float]]:
         points = list(range(self.n_requested, self.n_requested + n))
 

adaptive/learner/average_learner1D.py

@@ -15,6 +15,15 @@
 from adaptive.learner.learner1D import Learner1D, _get_intervals
 from adaptive.notebook_integration import ensure_holoviews
 from adaptive.types import Real
+from adaptive.utils import default_parameters
+
+try:
+    import pandas
+
+    with_pandas = True
+
+except ModuleNotFoundError:
+    with_pandas = False
 
 Point = Tuple[int, Real]
 Points = List[Point]
@@ -127,6 +136,45 @@ def min_samples_per_point(self) -> int:
             return 0
         return min(self._number_samples.values())
 
+    def to_numpy(self, mean: bool = True) -> np.ndarray:
+        if mean:
+            return super().to_numpy()
+        else:
+            return np.array(
+                [
+                    (seed, x, *np.atleast_1d(y))
+                    for x, seed_y in self._data_samples.items()
+                    for seed, y in seed_y.items()
+                ]
+            )
+
+    def to_dataframe(
+        self,
+        mean: bool = True,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        seed_name: str = "seed",
+        x_name: str = "x",
+        y_name: str = "y",
+    ) -> pandas.DataFrame:
+        if not with_pandas:
+            raise ImportError("pandas is not installed.")
+        if mean:
+            data = sorted(self.data.items())
+            columns = [x_name, y_name]
+        else:
+            data = [
+                (seed, x, y)
+                for x, seed_y in sorted(self._data_samples.items())
+                for seed, y in sorted(seed_y.items())
+            ]
+            columns = [seed_name, x_name, y_name]
+        df = pandas.DataFrame(data, columns=columns)
+        if with_default_function_args:
+            defaults = default_parameters(self.function, function_prefix)
+            df = df.assign(**defaults)
+        return df
+
     def ask(self, n: int, tell_pending: bool = True) -> tuple[Points, list[float]]:
         """Return 'n' points that are expected to maximally reduce the loss."""
         # If some point is undersampled, resample it

adaptive/learner/integrator_learner.py

@@ -13,7 +13,15 @@
 from adaptive.learner import integrator_coeffs as coeff
 from adaptive.learner.base_learner import BaseLearner
 from adaptive.notebook_integration import ensure_holoviews
-from adaptive.utils import cache_latest, restore
+from adaptive.utils import cache_latest, default_parameters, restore
+
+try:
+    import pandas
+
+    with_pandas = True
+
+except ModuleNotFoundError:
+    with_pandas = False
 
 
 def _downdate(c, nans, depth):
@@ -550,6 +558,21 @@ def to_numpy(self):
         """Data as NumPy array of size (npoints, 2)."""
         return np.array(sorted(self.data.items()))
 
+    def to_dataframe(
+        self,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        x_name: str = "x",
+        y_name: str = "y",
+    ) -> pandas.DataFrame:
+        if not with_pandas:
+            raise ImportError("pandas is not installed.")
+        df = pandas.DataFrame(sorted(self.data.items()), columns=[x_name, y_name])
+        if with_default_function_args:
+            defaults = default_parameters(self.function, function_prefix)
+            df = df.assign(**defaults)
+        return df
+
     def _get_data(self):
         # Change the defaultdict of SortedSets to a normal dict of sets.
         x_mapping = {k: set(v) for k, v in self.x_mapping.items()}

adaptive/learner/learner1D.py

@@ -16,7 +16,15 @@
 from adaptive.learner.triangulation import simplex_volume_in_embedding
 from adaptive.notebook_integration import ensure_holoviews
 from adaptive.types import Float, Int, Real
-from adaptive.utils import cache_latest
+from adaptive.utils import cache_latest, default_parameters
+
+try:
+    import pandas
+
+    with_pandas = True
+
+except ModuleNotFoundError:
+    with_pandas = False
 
 # -- types --
 
@@ -321,6 +329,21 @@ def to_numpy(self):
         and ``(npoints, 1+vdim)`` if ``learner.function`` returns a vector of length ``vdim``."""
         return np.array([(x, *np.atleast_1d(y)) for x, y in sorted(self.data.items())])
 
+    def to_dataframe(
+        self,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        x_name: str = "x",
+        y_name: str = "y",
+    ) -> pandas.DataFrame:
+        if not with_pandas:
+            raise ImportError("pandas is not installed.")
+        df = pandas.DataFrame(sorted(self.data.items()), columns=[x_name, y_name])
+        if with_default_function_args:
+            defaults = default_parameters(self.function, function_prefix)
+            df = df.assign(**defaults)
+        return df
+
     @property
     def npoints(self) -> int:
         """Number of evaluated points."""

adaptive/learner/learner2D.py

@@ -11,7 +11,15 @@
 from adaptive.learner.base_learner import BaseLearner
 from adaptive.learner.triangulation import simplex_volume_in_embedding
 from adaptive.notebook_integration import ensure_holoviews
-from adaptive.utils import cache_latest
+from adaptive.utils import cache_latest, default_parameters
+
+try:
+    import pandas
+
+    with_pandas = True
+
+except ModuleNotFoundError:
+    with_pandas = False
 
 # Learner2D and helper functions.
 
@@ -385,6 +393,23 @@ def to_numpy(self):
             [(x, y, *np.atleast_1d(z)) for (x, y), z in sorted(self.data.items())]
         )
 
+    def to_dataframe(
+        self,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        x_name: str = "x",
+        y_name: str = "y",
+        z_name: str = "z",
+    ) -> pandas.DataFrame:
+        if not with_pandas:
+            raise ImportError("pandas is not installed.")
+        data = sorted((x, y, z) for (x, y), z in self.data.items())
+        df = pandas.DataFrame(data, columns=[x_name, y_name, z_name])
+        if with_default_function_args:
+            defaults = default_parameters(self.function, function_prefix)
+            df = df.assign(**defaults)
+        return df
+
     def _scale(self, points):
         points = np.asarray(points, dtype=float)
         return (points - self.xy_mean) / self.xy_scale

adaptive/utils.py

@@ -1,6 +1,7 @@
 import abc
 import functools
 import gzip
+import inspect
 import os
 import pickle
 from contextlib import contextmanager
@@ -98,3 +99,13 @@ def __call__(self, *args, **kwargs):
                     msg = f"The attribute '{name}' should be of type {type_}, not {type(x)}."
                     raise TypeError(msg)
         return obj
+
+
+def default_parameters(function, function_prefix="", start_index=1):
+    sig = inspect.signature(function)
+    defaults = {
+        f"{function_prefix}{k}": v.default
+        for i, (k, v) in enumerate(sig.parameters.items())
+        if v.default != inspect._empty and i >= start_index
+    }
+    return defaults