add SequenceLearner

Author: basnijholt

adaptive/__init__.py

@@ -14,6 +14,7 @@
     Learner2D,
     LearnerND,
     make_datasaver,
+    SequenceLearner,
 )
 from adaptive.notebook_integration import (
     active_plotting_tasks,
@@ -36,6 +37,7 @@
     "Learner2D",
     "LearnerND",
     "make_datasaver",
+    "SequenceLearner",
     "active_plotting_tasks",
     "live_plot",
     "notebook_extension",

adaptive/learner/__init__.py

@@ -10,6 +10,7 @@
 from adaptive.learner.learner1D import Learner1D
 from adaptive.learner.learner2D import Learner2D
 from adaptive.learner.learnerND import LearnerND
+from adaptive.learner.sequence_learner import SequenceLearner
 
 __all__ = [
     "AverageLearner",
@@ -21,6 +22,7 @@
     "Learner1D",
     "Learner2D",
     "LearnerND",
+    "SequenceLearner",
 ]
 
 with suppress(ImportError):

adaptive/learner/sequence_learner.py

@@ -0,0 +1,82 @@
+from copy import copy
+import sys
+
+from adaptive.learner.base_learner import BaseLearner
+
+inf = sys.float_info.max
+
+
+def ensure_hashable(x):
+    try:
+        hash(x)
+        return x
+    except TypeError:
+        return tuple(x)
+
+
+class SequenceLearner(BaseLearner):
+    def __init__(self, function, sequence):
+        self.function = function
+        self._to_do_seq = {ensure_hashable(x) for x in sequence}
+        self._npoints = len(sequence)
+        self.sequence = copy(sequence)
+        self.data = {}
+        self.pending_points = set()
+
+    def ask(self, n, tell_pending=True):
+        points = []
+        loss_improvements = []
+        i = 0
+        for point in self._to_do_seq:
+            if i > n:
+                break
+            points.append(point)
+            loss_improvements.append(inf / self._npoints)
+            i += 1
+
+        if tell_pending:
+            for p in points:
+                self.tell_pending(p)
+
+        return points, loss_improvements
+
+    def _get_data(self):
+        return self.data
+
+    def _set_data(self, data):
+        if data:
+            self.tell_many(*zip(*data.items()))
+
+    def loss(self, real=True):
+        if not (self._to_do_seq or self.pending_points):
+            return 0
+        else:
+            npoints = self.npoints + (0 if real else len(self.pending_points))
+            return inf / npoints
+
+    def remove_unfinished(self):
+        for p in self.pending_points:
+            self._to_do_seq.add(p)
+        self.pending_points = set()
+
+    def tell(self, point, value):
+        self.data[point] = value
+        self.pending_points.discard(point)
+        self._to_do_seq.discard(point)
+
+    def tell_pending(self, point):
+        self.pending_points.add(point)
+        self._to_do_seq.discard(point)
+
+    def done(self):
+        return not self._to_do_seq and not self.pending_points
+
+    def result(self):
+        """Get back the data in the same order as ``sequence``."""
+        if not self.done():
+            raise Exception("Learner is not yet complete.")
+        return [self.data[ensure_hashable(x)] for x in self.sequence]
+
+    @property
+    def npoints(self):
+        return len(self.data)

adaptive/tests/test_learners.py

@@ -24,6 +24,7 @@
     Learner1D,
     Learner2D,
     LearnerND,
+    SequenceLearner,
 )
 from adaptive.runner import simple
 
@@ -116,26 +117,30 @@ def quadratic(x, m: uniform(0, 10), b: uniform(0, 1)):
 
 
 @learn_with(Learner1D, bounds=(-1, 1))
+@learn_with(SequenceLearner, sequence=np.linspace(-1, 1, 201))
 def linear_with_peak(x, d: uniform(-1, 1)):
     a = 0.01
     return x + a ** 2 / (a ** 2 + (x - d) ** 2)
 
 
 @learn_with(LearnerND, bounds=((-1, 1), (-1, 1)))
 @learn_with(Learner2D, bounds=((-1, 1), (-1, 1)))
+@learn_with(SequenceLearner, sequence=np.random.rand(1000, 2))
 def ring_of_fire(xy, d: uniform(0.2, 1)):
     a = 0.2
     x, y = xy
     return x + math.exp(-(x ** 2 + y ** 2 - d ** 2) ** 2 / a ** 4)
 
 
 @learn_with(LearnerND, bounds=((-1, 1), (-1, 1), (-1, 1)))
+@learn_with(SequenceLearner, sequence=np.random.rand(1000, 3))
 def sphere_of_fire(xyz, d: uniform(0.2, 1)):
     a = 0.2
     x, y, z = xyz
     return x + math.exp(-(x ** 2 + y ** 2 + z ** 2 - d ** 2) ** 2 / a ** 4) + z ** 2
 
 
+@learn_with(SequenceLearner, sequence=range(1000))
 @learn_with(AverageLearner, rtol=1)
 def gaussian(n):
     return random.gauss(0, 1)
@@ -247,7 +252,7 @@ def f(x):
     simple(learner, goal=lambda l: l.npoints > 10)
 
 
-@run_with(Learner1D, Learner2D, LearnerND)
+@run_with(Learner1D, Learner2D, LearnerND, SequenceLearner)
 def test_adding_existing_data_is_idempotent(learner_type, f, learner_kwargs):
     """Adding already existing data is an idempotent operation.
 
@@ -283,7 +288,7 @@ def test_adding_existing_data_is_idempotent(learner_type, f, learner_kwargs):
 
 # XXX: This *should* pass (https://github.com/python-adaptive/adaptive/issues/55)
 #      but we xfail it now, as Learner2D will be deprecated anyway
-@run_with(Learner1D, xfail(Learner2D), LearnerND, AverageLearner)
+@run_with(Learner1D, xfail(Learner2D), LearnerND, AverageLearner, SequenceLearner)
 def test_adding_non_chosen_data(learner_type, f, learner_kwargs):
     """Adding data for a point that was not returned by 'ask'."""
     # XXX: learner, control and bounds are not defined
@@ -429,7 +434,12 @@ def test_learner_performance_is_invariant_under_scaling(
 
 
 @run_with(
-    Learner1D, Learner2D, LearnerND, AverageLearner, with_all_loss_functions=False
+    Learner1D,
+    Learner2D,
+    LearnerND,
+    AverageLearner,
+    SequenceLearner,
+    with_all_loss_functions=False,
 )
 def test_balancing_learner(learner_type, f, learner_kwargs):
     """Test if the BalancingLearner works with the different types of learners."""
@@ -474,6 +484,7 @@ def test_balancing_learner(learner_type, f, learner_kwargs):
     AverageLearner,
     maybe_skip(SKOptLearner),
     IntegratorLearner,
+    SequenceLearner,
     with_all_loss_functions=False,
 )
 def test_saving(learner_type, f, learner_kwargs):
@@ -504,6 +515,7 @@ def test_saving(learner_type, f, learner_kwargs):
     AverageLearner,
     maybe_skip(SKOptLearner),
     IntegratorLearner,
+    SequenceLearner,
     with_all_loss_functions=False,
 )
 def test_saving_of_balancing_learner(learner_type, f, learner_kwargs):
@@ -541,6 +553,7 @@ def fname(learner):
     AverageLearner,
     maybe_skip(SKOptLearner),
     IntegratorLearner,
+    SequenceLearner,
     with_all_loss_functions=False,
 )
 def test_saving_with_datasaver(learner_type, f, learner_kwargs):