Merge remote-tracking branch 'origin/master' into typing-sequence-learner

Author: basnijholt

adaptive/learner/average_learner.py

@@ -74,6 +74,10 @@ def __init__(
         self.sum_f: Real = 0.0
         self.sum_f_sq: Real = 0.0
 
+    def new(self) -> AverageLearner:
+        """Create a copy of `~adaptive.AverageLearner` without the data."""
+        return AverageLearner(self.function, self.atol, self.rtol, self.min_npoints)
+
     @property
     def n_requested(self) -> int:
         return self.npoints + len(self.pending_points)

adaptive/learner/average_learner1D.py

@@ -125,6 +125,20 @@ def __init__(
         # {xii: error[xii]/min(_distances[xi], _distances[xii], ...}
         self.rescaled_error: dict[Real, float] = decreasing_dict()
 
+    def new(self) -> AverageLearner1D:
+        """Create a copy of `~adaptive.AverageLearner1D` without the data."""
+        return AverageLearner1D(
+            self.function,
+            self.bounds,
+            self.loss_per_interval,
+            self.delta,
+            self.alpha,
+            self.neighbor_sampling,
+            self.min_samples,
+            self.max_samples,
+            self.min_error,
+        )
+
     @property
     def nsamples(self) -> int:
         """Returns the total number of samples"""

adaptive/learner/balancing_learner.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import itertools
 from collections import defaultdict
 from collections.abc import Iterable
@@ -96,6 +98,14 @@ def __init__(self, learners, *, cdims=None, strategy="loss_improvements"):
 
         self.strategy = strategy
 
+    def new(self) -> BalancingLearner:
+        """Create a new `BalancingLearner` with the same parameters."""
+        return BalancingLearner(
+            [learner.new() for learner in self.learners],
+            cdims=self._cdims_default,
+            strategy=self.strategy,
+        )
+
     @property
     def data(self):
         data = {}

adaptive/learner/base_learner.py

@@ -149,6 +149,11 @@ def _get_data(self):
     def _set_data(self):
         pass
 
+    @abc.abstractmethod
+    def new(self):
+        """Return a new learner with the same function and parameters."""
+        pass
+
     def copy_from(self, other):
         """Copy over the data from another learner.
 

adaptive/learner/data_saver.py

@@ -45,6 +45,10 @@ def __init__(self, learner, arg_picker):
         self.function = learner.function
         self.arg_picker = arg_picker
 
+    def new(self) -> DataSaver:
+        """Return a new `DataSaver` with the same `arg_picker` and `learner`."""
+        return DataSaver(self.learner.new(), self.arg_picker)
+
     def __getattr__(self, attr):
         return getattr(self.learner, attr)
 

adaptive/learner/integrator_learner.py

@@ -1,4 +1,5 @@
 # Based on an adaptive quadrature algorithm by Pedro Gonnet
+from __future__ import annotations
 
 import sys
 from collections import defaultdict
@@ -381,6 +382,10 @@ def __init__(self, function, bounds, tol):
         self.add_ival(ival)
         self.first_ival = ival
 
+    def new(self) -> IntegratorLearner:
+        """Create a copy of `~adaptive.Learner2D` without the data."""
+        return IntegratorLearner(self.function, self.bounds, self.tol)
+
     @property
     def approximating_intervals(self):
         return self.first_ival.done_leaves

adaptive/learner/learner1D.py

@@ -22,6 +22,12 @@
     partial_function_from_dataframe,
 )
 
+try:
+    from typing import TypeAlias
+except ImportError:
+    # Remove this when we drop support for Python 3.9
+    from typing_extensions import TypeAlias
+
 try:
     import pandas
 
@@ -33,21 +39,21 @@
 # -- types --
 
 # Commonly used types
-Interval = Union[Tuple[float, float], Tuple[float, float, int]]
-NeighborsType = Dict[float, List[Union[float, None]]]
+Interval: TypeAlias = Union[Tuple[float, float], Tuple[float, float, int]]
+NeighborsType: TypeAlias = Dict[float, List[Union[float, None]]]
 
 # Types for loss_per_interval functions
-NoneFloat = Union[Float, None]
-NoneArray = Union[np.ndarray, None]
-XsType0 = Tuple[Float, Float]
-YsType0 = Union[Tuple[Float, Float], Tuple[np.ndarray, np.ndarray]]
-XsType1 = Tuple[NoneFloat, NoneFloat, NoneFloat, NoneFloat]
-YsType1 = Union[
+NoneFloat: TypeAlias = Union[Float, None]
+NoneArray: TypeAlias = Union[np.ndarray, None]
+XsType0: TypeAlias = Tuple[Float, Float]
+YsType0: TypeAlias = Union[Tuple[Float, Float], Tuple[np.ndarray, np.ndarray]]
+XsType1: TypeAlias = Tuple[NoneFloat, NoneFloat, NoneFloat, NoneFloat]
+YsType1: TypeAlias = Union[
     Tuple[NoneFloat, NoneFloat, NoneFloat, NoneFloat],
     Tuple[NoneArray, NoneArray, NoneArray, NoneArray],
 ]
-XsTypeN = Tuple[NoneFloat, ...]
-YsTypeN = Union[Tuple[NoneFloat, ...], Tuple[NoneArray, ...]]
+XsTypeN: TypeAlias = Tuple[NoneFloat, ...]
+YsTypeN: TypeAlias = Union[Tuple[NoneFloat, ...], Tuple[NoneArray, ...]]
 
 
 __all__ = [
@@ -303,11 +309,15 @@ def __init__(
         # The precision in 'x' below which we set losses to 0.
         self._dx_eps = 2 * max(np.abs(bounds)) * np.finfo(float).eps
 
-        self.bounds = list(bounds)
+        self.bounds = tuple(bounds)
         self.__missing_bounds = set(self.bounds)  # cache of missing bounds
 
         self._vdim: int | None = None
 
+    def new(self) -> Learner1D:
+        """Create a copy of `~adaptive.Learner1D` without the data."""
+        return Learner1D(self.function, self.bounds, self.loss_per_interval)
+
     @property
     def vdim(self) -> int:
         """Length of the output of ``learner.function``.

adaptive/learner/learner2D.py

@@ -384,6 +384,9 @@ def __init__(self, function, bounds, loss_per_triangle=None):
 
         self.stack_size = 10
 
+    def new(self) -> Learner2D:
+        return Learner2D(self.function, self.bounds, self.loss_per_triangle)
+
     @property
     def xy_scale(self):
         xy_scale = self._xy_scale

adaptive/learner/learnerND.py

@@ -376,6 +376,10 @@ def __init__(self, func, bounds, loss_per_simplex=None):
         # _pop_highest_existing_simplex
         self._simplex_queue = SortedKeyList(key=_simplex_evaluation_priority)
 
+    def new(self) -> LearnerND:
+        """Create a new learner with the same function and bounds."""
+        return LearnerND(self.function, self.bounds, self.loss_per_simplex)
+
     @property
     def npoints(self):
         """Number of evaluated points."""

adaptive/learner/sequence_learner.py

@@ -86,6 +86,10 @@ def __init__(self, function, sequence):
         self.data = SortedDict()
         self.pending_points = set()
 
+    def new(self) -> SequenceLearner:
+        """Return a new `~adaptive.SequenceLearner` without the data."""
+        return SequenceLearner(self._original_function, self.sequence)
+
     def ask(
         self, n: int, tell_pending: bool = True
     ) -> tuple[list[PointType], list[float]]:
@@ -186,7 +190,7 @@ def to_dataframe(
         df.attrs["inputs"] = [index_name]
         df.attrs["output"] = y_name
         if with_default_function_args:
-            assign_defaults(self.function, df, function_prefix)
+            assign_defaults(self._original_function, df, function_prefix)
         return df
 
     def load_dataframe(
@@ -223,7 +227,7 @@ def load_dataframe(
         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
+                self._original_function, df, function_prefix
             )
 
     def _get_data(self) -> dict[int, Any]:

adaptive/learner/skopt_learner.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import collections
 
 import numpy as np
@@ -27,8 +29,13 @@ def __init__(self, function, **kwargs):
         self.function = function
         self.pending_points = set()
         self.data = collections.OrderedDict()
+        self._kwargs = kwargs
         super().__init__(**kwargs)
 
+    def new(self) -> SKOptLearner:
+        """Return a new `~adaptive.SKOptLearner` without the data."""
+        return SKOptLearner(self.function, **self._kwargs)
+
     def tell(self, x, y, fit=True):
         if isinstance(x, collections.abc.Iterable):
             self.pending_points.discard(tuple(x))

adaptive/tests/test_learners.py

@@ -294,7 +294,7 @@ def test_adding_existing_data_is_idempotent(learner_type, f, learner_kwargs):
     """
     f = generate_random_parametrization(f)
     learner = learner_type(f, **learner_kwargs)
-    control = learner_type(f, **learner_kwargs)
+    control = learner.new()
     if learner_type in (Learner1D, AverageLearner1D):
         learner._recompute_losses_factor = 1
         control._recompute_losses_factor = 1
@@ -345,7 +345,7 @@ def test_adding_non_chosen_data(learner_type, f, learner_kwargs):
     # XXX: learner, control and bounds are not defined
     f = generate_random_parametrization(f)
     learner = learner_type(f, **learner_kwargs)
-    control = learner_type(f, **learner_kwargs)
+    control = learner.new()
 
     if learner_type is Learner2D:
         # If the stack_size is bigger then the number of points added,
@@ -395,7 +395,7 @@ def test_point_adding_order_is_irrelevant(learner_type, f, learner_kwargs):
     """
     f = generate_random_parametrization(f)
     learner = learner_type(f, **learner_kwargs)
-    control = learner_type(f, **learner_kwargs)
+    control = learner.new()
 
     if learner_type in (Learner1D, AverageLearner1D):
         learner._recompute_losses_factor = 1
@@ -581,7 +581,7 @@ def test_balancing_learner(learner_type, f, learner_kwargs):
 def test_saving(learner_type, f, learner_kwargs):
     f = generate_random_parametrization(f)
     learner = learner_type(f, **learner_kwargs)
-    control = learner_type(f, **learner_kwargs)
+    control = learner.new()
     if learner_type in (Learner1D, AverageLearner1D):
         learner._recompute_losses_factor = 1
         control._recompute_losses_factor = 1
@@ -614,7 +614,7 @@ def test_saving(learner_type, f, learner_kwargs):
 def test_saving_of_balancing_learner(learner_type, f, learner_kwargs):
     f = generate_random_parametrization(f)
     learner = BalancingLearner([learner_type(f, **learner_kwargs)])
-    control = BalancingLearner([learner_type(f, **learner_kwargs)])
+    control = learner.new()
 
     if learner_type in (Learner1D, AverageLearner1D):
         for l, c in zip(learner.learners, control.learners):
@@ -654,7 +654,7 @@ def test_saving_with_datasaver(learner_type, f, learner_kwargs):
     g = lambda x: {"y": f(x), "t": random.random()}  # noqa: E731
     arg_picker = operator.itemgetter("y")
     learner = DataSaver(learner_type(g, **learner_kwargs), arg_picker)
-    control = DataSaver(learner_type(g, **learner_kwargs), arg_picker)
+    control = learner.new()
 
     if learner_type in (Learner1D, AverageLearner1D):
         learner.learner._recompute_losses_factor = 1
@@ -742,7 +742,7 @@ def test_to_dataframe(learner_type, f, learner_kwargs):
         assert len(df) == learner.npoints
 
     # Add points from the DataFrame to a new empty learner
-    learner2 = learner_type(learner.function, **learner_kwargs)
+    learner2 = learner.new()
     learner2.load_dataframe(df, **kw)
     assert learner2.npoints == learner.npoints
 
@@ -787,8 +787,7 @@ def test_to_dataframe(learner_type, f, learner_kwargs):
         assert len(df) == data_saver.npoints
 
     # Test loading from a DataFrame into a new DataSaver
-    learner2 = learner_type(learner.function, **learner_kwargs)
-    data_saver2 = DataSaver(learner2, operator.itemgetter("result"))
+    data_saver2 = data_saver.new()
     data_saver2.load_dataframe(df, **kw)
     assert data_saver2.extra_data.keys() == data_saver.extra_data.keys()
     assert all(

adaptive/types.py

@@ -2,6 +2,12 @@
 
 import numpy as np
 
-Float = Union[float, np.float_]
-Int = Union[int, np.int_]
-Real = Union[Float, Int]
+try:
+    from typing import TypeAlias
+except ImportError:
+    # Remove this when we drop support for Python 3.9
+    from typing_extensions import TypeAlias
+
+Float: TypeAlias = Union[float, np.float_]
+Int: TypeAlias = Union[int, np.int_]
+Real: TypeAlias = Union[Float, Int]

adaptive/utils.py

@@ -4,6 +4,7 @@
 import inspect
 import os
 import pickle
+import warnings
 from contextlib import contextmanager
 from itertools import product
 
@@ -135,4 +136,19 @@ def partial_function_from_dataframe(function, df, function_prefix: str = "functi
             kwargs[k] = v
     if not kwargs:
         return function
+
+    sig = inspect.signature(function)
+    for k, v in kwargs.items():
+        if k not in sig.parameters:
+            raise ValueError(
+                f"The DataFrame contains a default parameter"
+                f" ({k}={v}) but the function does not have that parameter."
+            )
+        default = sig.parameters[k].default
+        if default != inspect._empty and kwargs[k] != default:
+            warnings.warn(
+                f"The DataFrame contains a default parameter"
+                f" ({k}={v}) but the function already has a default ({k}={default})."
+                " The DataFrame's value will be used."
+            )
     return functools.partial(function, **kwargs)

setup.py

@@ -31,6 +31,8 @@ def get_version_and_cmdclass(package_name):
     "cloudpickle",
     "loky >= 2.9",
 ]
+if sys.version_info < (3, 10):
+    install_requires.append("typing_extensions")
 
 extras_require = {
     "notebook": [
@@ -78,6 +80,7 @@ def get_version_and_cmdclass(package_name):
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
     ],
     packages=find_packages("."),
     install_requires=install_requires,