rename 'choose_points' -> 'ask' and 'add_point' -> 'tell'

Author: basnijholt

adaptive/learner/average_learner.py

@@ -41,14 +41,14 @@ def __init__(self, function, atol=None, rtol=None):
     def n_requested(self):
         return len(self.data)
 
-    def choose_points(self, n, add_data=True):
+    def ask(self, n, add_data=True):
         points = list(range(self.n_requested, self.n_requested + n))
         loss_improvements = [self.loss_improvement(n) / n] * n
         if add_data:
             self.add_data(points, itertools.repeat(None))
         return points, loss_improvements
 
-    def add_point(self, n, value):
+    def tell(self, n, value):
         value_is_new = not (n in self.data and value == self.data[n])
         if not value_is_new:
             value_old = self.data[n]

adaptive/learner/balancing_learner.py

@@ -48,37 +48,37 @@ def __init__(self, learners):
             raise TypeError('A BalacingLearner can handle only one type'
                             'of learners.')
 
-    def _choose_and_add_points(self, n):
+    def _choose_and_tells(self, n):
         points = []
         for _ in range(n):
             loss_improvements = []
             pairs = []
             for index, learner in enumerate(self.learners):
                 if index not in self._points:
-                    self._points[index] = learner.choose_points(
+                    self._points[index] = learner.ask(
                         n=1, add_data=False)
                 point, loss_improvement = self._points[index]
                 loss_improvements.append(loss_improvement[0])
                 pairs.append((index, point[0]))
             x, _ = max(zip(pairs, loss_improvements), key=itemgetter(1))
             points.append(x)
-            self.add_point(x, None)
+            self.tell(x, None)
 
         return points, None
 
-    def choose_points(self, n, add_data=True):
+    def ask(self, n, add_data=True):
         """Chose points for learners."""
         if not add_data:
             with restore(*self.learners):
-                return self._choose_and_add_points(n)
+                return self._choose_and_tells(n)
         else:
-            return self._choose_and_add_points(n)
+            return self._choose_and_tells(n)
 
-    def add_point(self, x, y):
+    def tell(self, x, y):
         index, x = x
         self._points.pop(index, None)
         self._loss.pop(index, None)
-        self.learners[index].add_point(x, y)
+        self.learners[index].tell(x, y)
 
     def loss(self, real=True):
         losses = []

adaptive/learner/base_learner.py

@@ -37,12 +37,12 @@ def add_data(self, xvalues, yvalues):
         """
         if all(isinstance(i, collections.Iterable) for i in [xvalues, yvalues]):
             for x, y in zip(xvalues, yvalues):
-                self.add_point(x, y)
+                self.tell(x, y)
         else:
-            self.add_point(xvalues, yvalues)
+            self.tell(xvalues, yvalues)
 
     @abc.abstractmethod
-    def add_point(self, x, y):
+    def tell(self, x, y):
         """Add a single datapoint to the learner."""
         pass
 
@@ -64,7 +64,7 @@ def loss(self, real=True):
         """
 
     @abc.abstractmethod
-    def choose_points(self, n, add_data=True):
+    def ask(self, n, add_data=True):
         """Choose the next 'n' points to evaluate.
 
         Parameters

adaptive/learner/data_saver.py

@@ -28,7 +28,7 @@ def __init__(self, learner, arg_picker):
         self.arg_picker = arg_picker
 
         # The methods a subclass of the BaseLearner needs to implement
-        self.choose_points = self.learner.choose_points
+        self.ask = self.learner.ask
         self.loss = self.learner.loss
         self.remove_unfinished = self.learner.remove_unfinished
 
@@ -37,7 +37,7 @@ def __init__(self, learner, arg_picker):
         self.__getstate__ = self.learner.__getstate__
         self.__setstate__ = self.learner.__setstate__
 
-    def add_point(self, x, result):
+    def tell(self, x, result):
         y = self.arg_picker(result) if result is not None else None
         self.extra_data[x] = result
-        self.learner.add_point(x, y)
+        self.learner.tell(x, y)

adaptive/learner/integrator_learner.py

@@ -359,7 +359,7 @@ def __init__(self, function, bounds, tol):
     def approximating_intervals(self):
         return self.first_ival.done_leaves
 
-    def add_point(self, point, value):
+    def tell(self, point, value):
         if point not in self.x_mapping:
             raise ValueError("Point {} doesn't belong to any interval"
                              .format(point))
@@ -408,13 +408,13 @@ def add_ival(self, ival):
             # Update the mappings
             self.x_mapping[x].add(ival)
             if x in self.done_points:
-                self.add_point(x, self.done_points[x])
+                self.tell(x, self.done_points[x])
             elif x not in self.pending_points:
                 self.pending_points.add(x)
                 self._stack.append(x)
         self.ivals.add(ival)
 
-    def choose_points(self, n):
+    def ask(self, n):
         points, loss_improvements = self.pop_from_stack(n)
         n_left = n - len(points)
         while n_left > 0:

adaptive/learner/learner1D.py

@@ -214,7 +214,7 @@ def update_scale(self, x, y):
                 self._bbox[1][1] = max(self._bbox[1][1], y)
                 self._scale[1] = self._bbox[1][1] - self._bbox[1][0]
 
-    def add_point(self, x, y):
+    def tell(self, x, y):
         real = y is not None
 
         if real:
@@ -252,7 +252,7 @@ def add_point(self, x, y):
             self._oldscale = deepcopy(self._scale)
 
 
-    def choose_points(self, n, add_data=True):
+    def ask(self, n, add_data=True):
         """Return n points that are expected to maximally reduce the loss."""
         # Find out how to divide the n points over the intervals
         # by finding  positive integer n_i that minimize max(L_i / n_i) subject

adaptive/learner/learner2D.py

@@ -168,7 +168,7 @@ class Learner2D(BaseLearner):
         Sampled points and values.
     stack_size : int, default 10
         The size of the new candidate points stack. Set it to 1
-        to recalculate the best points at each call to `choose_points`.
+        to recalculate the best points at each call to `ask`.
 
     Methods
     -------
@@ -287,7 +287,7 @@ def ip_combined(self):
                                                                  values)
         return self._ip_combined
 
-    def add_point(self, point, value):
+    def tell(self, point, value):
         point = tuple(point)
 
         if value is None:
@@ -330,7 +330,7 @@ def _fill_stack(self, stack_till=1):
 
         return points_new, losses_new
 
-    def choose_points(self, n, add_data=True):
+    def ask(self, n, add_data=True):
         # Even if add_data is False we add the point such that _fill_stack
         # will return new points, later we remove these points if needed.
         points = list(self._stack.keys())

adaptive/runner.py

@@ -164,9 +164,9 @@ def _run(self):
                 # Launch tasks to replace the ones that completed
                 # on the last iteration.
                 if do_log:
-                    self.log.append(('choose_points', len(done)))
+                    self.log.append(('ask', len(done)))
 
-                points, _ = self.learner.choose_points(len(done))
+                points, _ = self.learner.ask(len(done))
                 for x in points:
                     xs[self._submit(x)] = x
 
@@ -185,8 +185,8 @@ def _run(self):
                             'See the top traceback for details.'
                         ) from e
                     if do_log:
-                        self.log.append(('add_point', x, y))
-                    self.learner.add_point(x, y)
+                        self.log.append(('tell', x, y))
+                    self.learner.tell(x, y)
 
         finally:
             # remove points with 'None' values from the learner
@@ -367,9 +367,9 @@ async def _run(self):
                 # Launch tasks to replace the ones that completed
                 # on the last iteration.
                 if do_log:
-                    self.log.append(('choose_points', len(done)))
+                    self.log.append(('ask', len(done)))
 
-                points, _ = self.learner.choose_points(len(done))
+                points, _ = self.learner.ask(len(done))
                 for x in points:
                     xs[self._submit(x)] = x
 
@@ -389,8 +389,8 @@ async def _run(self):
                             'See the top traceback for details.'
                         ) from e
                     if do_log:
-                        self.log.append(('add_point', x, y))
-                    self.learner.add_point(x, y)
+                        self.log.append(('tell', x, y))
+                    self.learner.tell(x, y)
         finally:
             # remove points with 'None' values from the learner
             self.learner.remove_unfinished()
@@ -429,10 +429,10 @@ def simple(learner, goal):
         learner as its sole argument, and return True if we should stop.
     """
     while not goal(learner):
-        xs, _ = learner.choose_points(1)
+        xs, _ = learner.ask(1)
         for x in xs:
             y = learner.function(x)
-            learner.add_point(x, y)
+            learner.tell(x, y)
 
 
 def replay_log(learner, log):

adaptive/tests/test_cquad.py

@@ -24,7 +24,7 @@ def rolling_shuffle(nums, size):
 def run_integrator_learner(f, a, b, tol, n):
     learner = IntegratorLearner(f, bounds=(a, b), tol=tol)
     for _ in range(n):
-        points, _ = learner.choose_points(1)
+        points, _ = learner.ask(1)
         learner.add_data(points, map(learner.function, points))
     return learner
 
@@ -120,48 +120,48 @@ def test_divergence():
 def test_choosing_and_adding_points_one_by_one():
     learner = IntegratorLearner(f24, bounds=(0, 3), tol=1e-10)
     for _ in range(1000):
-        xs, _ = learner.choose_points(1)
+        xs, _ = learner.ask(1)
         for x in xs:
-            learner.add_point(x, learner.function(x))
+            learner.tell(x, learner.function(x))
 
 
 def test_choosing_and_adding_multiple_points_at_once():
     learner = IntegratorLearner(f24, bounds=(0, 3), tol=1e-10)
-    xs, _ = learner.choose_points(100)
+    xs, _ = learner.ask(100)
     for x in xs:
-        learner.add_point(x, learner.function(x))
+        learner.tell(x, learner.function(x))
 
 
 def test_adding_points_and_skip_one_point():
     learner = IntegratorLearner(f24, bounds=(0, 3), tol=1e-10)
-    xs, _ = learner.choose_points(17)
+    xs, _ = learner.ask(17)
     skip_x = xs[1]
 
     for x in xs:
         if x != skip_x:
-            learner.add_point(x, learner.function(x))
+            learner.tell(x, learner.function(x))
 
     for i in range(1000):
-        xs, _ = learner.choose_points(1)
+        xs, _ = learner.ask(1)
         for x in xs:
             if x != skip_x:
-                learner.add_point(x, learner.function(x))
+                learner.tell(x, learner.function(x))
 
     # Now add the point that was skipped
-    learner.add_point(skip_x, learner.function(skip_x))
+    learner.tell(skip_x, learner.function(skip_x))
 
     # Create a learner with the same number of points, which should
     # give an identical igral value.
     learner2 = IntegratorLearner(f24, bounds=(0, 3), tol=1e-10)
     for i in range(1017):
-        xs, _ = learner2.choose_points(1)
+        xs, _ = learner2.ask(1)
         for x in xs:
-            learner2.add_point(x, learner2.function(x))
+            learner2.tell(x, learner2.function(x))
 
     np.testing.assert_almost_equal(learner.igral, learner2.igral)
 
 
-def test_add_points_in_random_order(first_add_33=False):
+def test_tells_in_random_order(first_add_33=False):
     from operator import attrgetter
     import random
     tol = 1e-10
@@ -176,16 +176,16 @@ def test_add_points_in_random_order(first_add_33=False):
             l = IntegratorLearner(f, bounds=(a, b), tol=tol)
 
             if first_add_33:
-                xs, _ = l.choose_points(33)
+                xs, _ = l.ask(33)
                 for x in xs:
-                    l.add_point(x, f(x))
+                    l.tell(x, f(x))
 
-            xs, _ = l.choose_points(10000)
+            xs, _ = l.ask(10000)
 
             if shuffle:
                 random.shuffle(xs)
             for x in xs:
-                l.add_point(x, f(x))
+                l.tell(x, f(x))
 
             learners.append(l)
 
@@ -220,18 +220,18 @@ def test_add_points_in_random_order(first_add_33=False):
             assert np.isfinite(l.err)
 
 
-def test_add_points_in_random_order_first_add_33():
-    test_add_points_in_random_order(first_add_33=True)
+def test_tells_in_random_order_first_add_33():
+    test_tells_in_random_order(first_add_33=True)
 
 
 def test_approximating_intervals():
     import random
     learner = IntegratorLearner(f24, bounds=(0, 3), tol=1e-10)
 
-    xs, _ = learner.choose_points(10000)
+    xs, _ = learner.ask(10000)
     random.shuffle(xs)
     for x in xs:
-        learner.add_point(x, f24(x))
+        learner.tell(x, f24(x))
 
     ivals = sorted(learner.approximating_intervals, key=lambda l: l.a)
     for i in range(len(ivals) - 1):
@@ -241,19 +241,19 @@ def test_approximating_intervals():
 def test_removed_choose_mutiple_points_at_once():
     learner = IntegratorLearner(np.exp, bounds=(0, 1), tol=1e-15)
     n = ns[-1] + 2 * (ns[0] - 2)  # first + two children (33+6=39)
-    xs, _ = learner.choose_points(n)
+    xs, _ = learner.ask(n)
     for x in xs:
-        learner.add_point(x, learner.function(x))
+        learner.tell(x, learner.function(x))
     assert list(learner.approximating_intervals)[0] == learner.first_ival
 
 
-def test_removed_choose_points_one_by_one():
+def test_removed_ask_one_by_one():
     with pytest.raises(RuntimeError):
         # This test should raise because integrating np.exp should be done
         # after the 33th point
         learner = IntegratorLearner(np.exp, bounds=(0, 1), tol=1e-15)
         n = ns[-1] + 2 * (ns[0] - 2)  # first + two children (33+6=39)
         for _ in range(n):
-            xs, _ = learner.choose_points(1)
+            xs, _ = learner.ask(1)
             for x in xs:
-                learner.add_point(x, learner.function(x))
+                learner.tell(x, learner.function(x))