Add learner.load_dataframe

Author: basnijholt

adaptive/learner/average_learner.py

@@ -9,7 +9,11 @@
 from adaptive.learner.base_learner import BaseLearner
 from adaptive.notebook_integration import ensure_holoviews
 from adaptive.types import Float, Real
-from adaptive.utils import assign_defaults, cache_latest
+from adaptive.utils import (
+    assign_defaults,
+    cache_latest,
+    partial_function_from_dataframe,
+)
 
 try:
     import pandas
@@ -92,6 +96,20 @@ def to_dataframe(
             assign_defaults(self.function, df, function_prefix)
         return df
 
+    def load_dataframe(
+        self,
+        df,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        seed_name: str = "seed",
+        y_name: str = "y",
+    ):
+        self.tell_many(df[seed_name].values, df[y_name].values)
+        if with_default_function_args:
+            self.function = partial_function_from_dataframe(
+                self.function, df, function_prefix
+            )
+
     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,7 +15,7 @@
 from adaptive.learner.learner1D import Learner1D, _get_intervals
 from adaptive.notebook_integration import ensure_holoviews
 from adaptive.types import Real
-from adaptive.utils import assign_defaults
+from adaptive.utils import assign_defaults, partial_function_from_dataframe
 
 try:
     import pandas
@@ -174,6 +174,21 @@ def to_dataframe(
             assign_defaults(self.function, df, function_prefix)
         return df
 
+    def load_dataframe(
+        self,
+        df,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        seed_name: str = "seed",
+        x_name: str = "x",
+        y_name: str = "y",
+    ):
+        self.tell_many(df[[seed_name, x_name]].values, df[y_name].values)
+        if with_default_function_args:
+            self.function = partial_function_from_dataframe(
+                self.function, df, function_prefix
+            )
+
     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/learner1D.py

@@ -16,7 +16,11 @@
 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 assign_defaults, cache_latest
+from adaptive.utils import (
+    assign_defaults,
+    cache_latest,
+    partial_function_from_dataframe,
+)
 
 try:
     import pandas
@@ -339,12 +343,26 @@ def to_dataframe(
         if not with_pandas:
             raise ImportError("pandas is not installed.")
         xs, ys = zip(*sorted(self.data.items())) if self.data else ([], [])
-        df = pandas.DataFrame(xs, columns=["x"])
+        df = pandas.DataFrame(xs, columns=[x_name])
         df[y_name] = ys
         if with_default_function_args:
             assign_defaults(self.function, df, function_prefix)
         return df
 
+    def load_dataframe(
+        self,
+        df,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        x_name: str = "x",
+        y_name: str = "y",
+    ):
+        self.tell_many(df[x_name].values, df[y_name].values)
+        if with_default_function_args:
+            self.function = partial_function_from_dataframe(
+                self.function, df, function_prefix
+            )
+
     @property
     def npoints(self) -> int:
         """Number of evaluated points."""

adaptive/learner/learner2D.py

@@ -11,7 +11,11 @@
 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 assign_defaults, cache_latest
+from adaptive.utils import (
+    assign_defaults,
+    cache_latest,
+    partial_function_from_dataframe,
+)
 
 try:
     import pandas
@@ -409,6 +413,21 @@ def to_dataframe(
             assign_defaults(self.function, df, function_prefix)
         return df
 
+    def load_dataframe(
+        self,
+        df,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        x_name: str = "x",
+        y_name: str = "y",
+        z_name: str = "z",
+    ):
+        self.tell_many(df[[x_name, y_name]].values, df[z_name].values)
+        if with_default_function_args:
+            self.function = partial_function_from_dataframe(
+                self.function, df, function_prefix
+            )
+
     def _scale(self, points):
         points = np.asarray(points, dtype=float)
         return (points - self.xy_mean) / self.xy_scale

adaptive/learner/learnerND.py

@@ -21,7 +21,12 @@
     simplex_volume_in_embedding,
 )
 from adaptive.notebook_integration import ensure_holoviews, ensure_plotly
-from adaptive.utils import assign_defaults, cache_latest, restore
+from adaptive.utils import (
+    assign_defaults,
+    cache_latest,
+    partial_function_from_dataframe,
+    restore,
+)
 
 try:
     import pandas
@@ -418,6 +423,20 @@ def to_dataframe(
             assign_defaults(self.function, df, function_prefix)
         return df
 
+    def load_dataframe(
+        self,
+        df,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        point_names: tuple[str, ...] = ("x", "y", "z"),
+        value_name: str = "value",
+    ):
+        self.tell_many(df[list(point_names)].values, df[value_name].values)
+        if with_default_function_args:
+            self.function = partial_function_from_dataframe(
+                self.function, df, function_prefix
+            )
+
     @property
     def bounds_are_done(self):
         return all(p in self.data for p in self._bounds_points)

adaptive/learner/sequence_learner.py

@@ -4,7 +4,7 @@
 from sortedcontainers import SortedDict, SortedSet
 
 from adaptive.learner.base_learner import BaseLearner
-from adaptive.utils import assign_defaults
+from adaptive.utils import assign_defaults, partial_function_from_dataframe
 
 try:
     import pandas
@@ -148,6 +148,21 @@ def to_dataframe(
             assign_defaults(self.function, df, function_prefix)
         return df
 
+    def load_dataframe(
+        self,
+        df,
+        with_default_function_args: bool = True,
+        function_prefix: str = "function.",
+        index_name: str = "i",
+        x_name: str = "x",
+        y_name: str = "y",
+    ):
+        self.tell_many(df[[index_name, x_name]].values, df[y_name].values)
+        if with_default_function_args:
+            self.function = partial_function_from_dataframe(
+                self.function, df, function_prefix
+            )
+
     def _get_data(self):
         return self.data
 

adaptive/tests/test_learners.py

@@ -722,22 +722,7 @@ def test_to_dataframe(learner_type, f, learner_kwargs):
 
     # Add points from the DataFrame to a new empty learner
     learner2 = learner_type(generate_random_parametrization(f), **learner_kwargs)
-
-    if learner_type is Learner1D:
-        learner2.tell_many(df["x"], df["y"])
-    elif learner_type is Learner2D:
-        learner2.tell_many(df[["x", "y"]].values, df["z"])
-    elif learner_type is LearnerND:
-        point_names = list(kw["point_names"])
-        learner2.tell_many(df[point_names].values, df["value"])
-    elif learner_type is AverageLearner:
-        learner2.tell_many(df["seed"].values, df["y"])
-    elif learner_type is AverageLearner1D:
-        learner2.tell_many(df[["seed", "x"]].values, df["y"])
-    elif learner_type is SequenceLearner:
-        learner2.tell_many(df[["i", "x"]].values, df["y"])
-    else:
-        raise NotImplementedError()
+    learner2.load_dataframe(df, **kw)
 
     # Test this for a learner in a BalancingLearner
     learners = [

adaptive/utils.py

@@ -101,7 +101,7 @@ def __call__(self, *args, **kwargs):
         return obj
 
 
-def _default_parameters(function, function_prefix="", start_index=1):
+def _default_parameters(function, function_prefix: str = "", start_index: int = 1):
     sig = inspect.signature(function)
     defaults = {
         f"{function_prefix}{k}": v.default
@@ -111,7 +111,22 @@ def _default_parameters(function, function_prefix="", start_index=1):
     return defaults
 
 
-def assign_defaults(function, df, function_prefix="", start_index=1):
+def assign_defaults(function, df, function_prefix: str = "", start_index: int = 1):
     defaults = _default_parameters(function, function_prefix, start_index)
     for k, v in defaults.items():
         df[k] = len(df) * [v]
+
+
+def partial_function_from_dataframe(function, df, function_prefix: str = ""):
+    kwargs = {}
+    for col in df.columns:
+        if col.startswith(function_prefix):
+            k = col.split(function_prefix, 1)[1]
+            vs = df[col]
+            v, *rest = vs.unique()
+            if rest:
+                raise ValueError(f"The column '{col}' can only have one value.")
+            kwargs[k] = v
+    if not kwargs:
+        return function
+    return functools.partial(function, **kwargs)