Use loss_goal and npoints_goal

Author: basnijholt

README.md

@@ -75,7 +75,7 @@ def peak(x, a=0.01):
 
 
 learner = Learner1D(peak, bounds=(-1, 1))
-runner = Runner(learner, goal=0.01)
+runner = Runner(learner, loss_goal=0.01)
 runner.live_info()
 runner.live_plot()
 ```

adaptive/runner.py

@@ -14,13 +14,19 @@
 import warnings
 from contextlib import suppress
 from datetime import datetime, timedelta
-from typing import Any, Callable
+from typing import Any, Callable, Union
 
 import loky
 
 from adaptive import BalancingLearner, BaseLearner, IntegratorLearner, SequenceLearner
 from adaptive.notebook_integration import in_ipynb, live_info, live_plot
 
+try:
+    from typing import TypeAlias
+except ModuleNotFoundError:
+    # Python <3.10
+    from typing_extensions import TypeAlias
+
 try:
     import ipyparallel
 
@@ -60,6 +66,10 @@
     # and https://github.com/python-adaptive/adaptive/issues/301
     _default_executor = loky.get_reusable_executor
 
+GoalTypes: TypeAlias = Union[
+    Callable[[BaseLearner], bool], int, float, datetime, timedelta, None
+]
+
 
 class BaseRunner(metaclass=abc.ABCMeta):
     r"""Base class for runners that use `concurrent.futures.Executors`.
@@ -120,8 +130,10 @@ class BaseRunner(metaclass=abc.ABCMeta):
     def __init__(
         self,
         learner,
-        goal,
         *,
+        goal: GoalTypes = None,
+        loss_goal: float | None = None,
+        npoints_goal: int | None = None,
         executor=None,
         ntasks=None,
         log=False,
@@ -132,7 +144,7 @@ def __init__(
     ):
 
         self.executor = _ensure_executor(executor)
-        self.goal = auto_goal(goal, learner, allow_running_forever)
+        self.goal = _goal(learner, goal, loss_goal, npoints_goal, allow_running_forever)
 
         self._max_tasks = ntasks
 
@@ -376,8 +388,10 @@ class BlockingRunner(BaseRunner):
     def __init__(
         self,
         learner,
-        goal,
         *,
+        goal: GoalTypes = None,
+        loss_goal: float | None = None,
+        npoints_goal: int | None = None,
         executor=None,
         ntasks=None,
         log=False,
@@ -389,7 +403,9 @@ def __init__(
             raise ValueError("Coroutine functions can only be used with 'AsyncRunner'.")
         super().__init__(
             learner,
-            goal,
+            goal=goal,
+            loss_goal=loss_goal,
+            npoints_goal=npoints_goal,
             executor=executor,
             ntasks=ntasks,
             log=log,
@@ -508,8 +524,10 @@ class AsyncRunner(BaseRunner):
     def __init__(
         self,
         learner,
-        goal=None,
         *,
+        goal: GoalTypes = None,
+        loss_goal: float | None = None,
+        npoints_goal: int | None = None,
         executor=None,
         ntasks=None,
         log=False,
@@ -537,7 +555,9 @@ def __init__(
 
         super().__init__(
             learner,
-            goal,
+            goal=goal,
+            loss_goal=loss_goal,
+            npoints_goal=npoints_goal,
             executor=executor,
             ntasks=ntasks,
             log=log,
@@ -717,7 +737,13 @@ async def _saver():
 Runner = AsyncRunner
 
 
-def simple(learner, goal):
+def simple(
+    learner,
+    *,
+    goal: GoalTypes = None,
+    loss_goal: float | None = None,
+    npoints_goal: int | None = None,
+):
     """Run the learner until the goal is reached.
 
     Requests a single point from the learner, evaluates
@@ -736,7 +762,7 @@ def simple(learner, goal):
         The end condition for the calculation. This function must take the
         learner as its sole argument, and return True if we should stop.
     """
-    goal = auto_goal(goal, learner)
+    goal = _goal(learner, goal, loss_goal, npoints_goal, allow_running_forever=False)
     while not goal(learner):
         xs, _ = learner.ask(1)
         for x in xs:
@@ -871,14 +897,13 @@ def __call__(self, _):
             if self.start_time is None:
                 self.start_time = datetime.now()
             return datetime.now() - self.start_time > self.dt
-        elif isinstance(self.dt, datetime):
+        if isinstance(self.dt, datetime):
             return datetime.now() > self.dt
-        else:
-            raise TypeError(f"`dt={self.dt}` is not a datetime or timedelta.")
+        raise TypeError(f"`dt={self.dt}` is not a datetime or timedelta.")
 
 
 def auto_goal(
-    goal: Callable[[BaseLearner], bool] | int | float | datetime | timedelta | None,
+    goal: GoalTypes,
     learner: BaseLearner,
     allow_running_forever: bool = True,
 ):
@@ -935,12 +960,28 @@ def auto_goal(
             return SequenceLearner.done
         if isinstance(learner, IntegratorLearner):
             return IntegratorLearner.done
-        warnings.warn("Goal is None which means the learners continue forever!")
-        if allow_running_forever:
-            return lambda _: False
-        else:
+        if not allow_running_forever:
             raise ValueError(
                 "Goal is None which means the learners"
                 " continue forever and this is not allowed."
             )
+        warnings.warn("Goal is None which means the learners continue forever!")
+        return lambda _: False
     raise ValueError("Cannot determine goal from {goal}.")
+
+
+def _goal(
+    learner: BaseLearner,
+    goal: GoalTypes,
+    loss_goal: float | None,
+    npoints_goal: int | None,
+    allow_running_forever: bool,
+):
+    # goal, loss_goal, npoints_goal are mutually exclusive, only one can be not None
+    if goal is not None and (loss_goal is not None or npoints_goal is not None):
+        raise ValueError("Either goal, loss_goal, or npoints_goal can be specified.")
+    if loss_goal is not None:
+        goal = float(loss_goal)
+    if npoints_goal is not None:
+        goal = int(npoints_goal)
+    return auto_goal(goal, learner, allow_running_forever)

adaptive/tests/test_average_learner.py

@@ -61,7 +61,7 @@ def constant_function(seed):
         learner = AverageLearner(
             constant_function, atol=0.01, rtol=0.01, min_npoints=min_npoints
         )
-        simple(learner, 1.0)
+        simple(learner, loss_goal=1.0)
         assert learner.npoints >= max(2, min_npoints)
 
 

adaptive/tests/test_learner1d.py

@@ -298,7 +298,7 @@ def test_equal(l1, l2):
     for function in [f, f_vec]:
         learner = Learner1D(function, bounds=(-1, 1))
         learner2 = Learner1D(function, bounds=(-1, 1))
-        simple(learner, goal=200)
+        simple(learner, npoints_goal=200)
         xs, ys = zip(*learner.data.items())
 
         # Make the scale huge to no get a scale doubling
@@ -374,7 +374,7 @@ def f(x):
     loss = curvature_loss_function()
     assert loss.nth_neighbors == 1
     learner = Learner1D(f, (-1, 1), loss_per_interval=loss)
-    simple(learner, goal=100)
+    simple(learner, npoints_goal=100)
     assert learner.npoints >= 100
 
 
@@ -385,7 +385,7 @@ def f(x):
     loss = curvature_loss_function()
     assert loss.nth_neighbors == 1
     learner = Learner1D(f, (-1, 1), loss_per_interval=loss)
-    simple(learner, goal=100)
+    simple(learner, npoints_goal=100)
     assert learner.npoints >= 100
 
 
@@ -398,7 +398,7 @@ def f(x):
         return x + a**2 / (a**2 + x**2)
 
     learner = Learner1D(f, bounds=(-1, 1))
-    simple(learner, 100)
+    simple(learner, npoints_goal=100)
 
 
 def test_inf_loss_with_missing_bounds():
@@ -408,6 +408,6 @@ def test_inf_loss_with_missing_bounds():
         loss_per_interval=curvature_loss_function(),
     )
     # must be done in parallel because otherwise the bounds will be evaluated first
-    BlockingRunner(learner, goal=0.01)
+    BlockingRunner(learner, loss_goal=0.01)
 
     learner.npoints > 20

adaptive/tests/test_learnernd.py

@@ -33,8 +33,8 @@ def test_interior_vs_bbox_gives_same_result():
     hull = scipy.spatial.ConvexHull(control._bounds_points)
     learner = LearnerND(f, bounds=hull)
 
-    simple(control, goal=0.1)
-    simple(learner, goal=0.1)
+    simple(control, loss_goal=0.1)
+    simple(learner, loss_goal=0.1)
 
     assert learner.data == control.data
 
@@ -47,4 +47,4 @@ def test_vector_return_with_a_flat_layer():
     h3 = lambda xy: np.array([0 * f(xy), g(xy)])  # noqa: E731
     for function in [h1, h2, h3]:
         learner = LearnerND(function, bounds=[(-1, 1), (-1, 1)])
-        simple(learner, goal=0.1)
+        simple(learner, loss_goal=0.1)

adaptive/tests/test_learners.py

@@ -103,7 +103,7 @@ def goal():
             return get_goal(learner.learner)
         return get_goal(learner)
 
-    simple(learner, goal())
+    simple(learner, goal=goal())
 
 
 # Library of functions and associated learners.

adaptive/tests/test_pickling.py

@@ -94,7 +94,7 @@ def test_serialization_for(learner_type, learner_kwargs, serializer, f):
 
     learner = learner_type(f, **learner_kwargs)
 
-    simple(learner, goal_1)
+    simple(learner, goal=goal_1)
     learner_bytes = serializer.dumps(learner)
     loss = learner.loss()
     asked = learner.ask(10)
@@ -113,5 +113,5 @@ def test_serialization_for(learner_type, learner_kwargs, serializer, f):
     # load again to undo the ask
     learner_loaded = serializer.loads(learner_bytes)
 
-    simple(learner_loaded, goal_2)
+    simple(learner_loaded, goal=goal_2)
     assert learner_loaded.npoints == 20

adaptive/tests/test_runner.py

@@ -19,22 +19,18 @@
 OPERATING_SYSTEM = platform.system()
 
 
-def blocking_runner(learner, goal):
-    BlockingRunner(learner, goal, executor=SequentialExecutor())
+def blocking_runner(learner, **kw):
+    BlockingRunner(learner, executor=SequentialExecutor(), **kw)
 
 
-def async_runner(learner, goal):
-    runner = AsyncRunner(learner, goal, executor=SequentialExecutor())
+def async_runner(learner, **kw):
+    runner = AsyncRunner(learner, executor=SequentialExecutor(), **kw)
     asyncio.get_event_loop().run_until_complete(runner.task)
 
 
 runners = [simple, blocking_runner, async_runner]
 
 
-def trivial_goal(learner):
-    return learner.npoints > 10
-
-
 @pytest.mark.parametrize("runner", runners)
 def test_simple(runner):
     """Test that the runners actually run."""
@@ -43,7 +39,7 @@ def f(x):
         return x
 
     learner = Learner1D(f, (-1, 1))
-    runner(learner, 10)
+    runner(learner, npoints_goal=10)
     assert len(learner.data) >= 10
 
 
@@ -57,15 +53,15 @@ def test_nonconforming_output(runner):
     def f(x):
         return [0]
 
-    runner(Learner2D(f, ((-1, 1), (-1, 1))), trivial_goal)
+    runner(Learner2D(f, ((-1, 1), (-1, 1))), npoints_goal=10)
 
 
 def test_aync_def_function():
     async def f(x):
         return x
 
     learner = Learner1D(f, (-1, 1))
-    runner = AsyncRunner(learner, trivial_goal)
+    runner = AsyncRunner(learner, npoints_goal=10)
     asyncio.get_event_loop().run_until_complete(runner.task)
 
 
@@ -88,15 +84,15 @@ def test_concurrent_futures_executor():
 
     BlockingRunner(
         Learner1D(linear, (-1, 1)),
-        trivial_goal,
+        npoints_goal=10,
         executor=ProcessPoolExecutor(max_workers=1),
     )
 
 
 def test_stop_after_goal():
     seconds_to_wait = 0.2  # don't make this too large or the test will take ages
     start_time = time.time()
-    BlockingRunner(Learner1D(linear, (-1, 1)), stop_after(seconds=seconds_to_wait))
+    BlockingRunner(Learner1D(linear, (-1, 1)), goal=stop_after(seconds=seconds_to_wait))
     stop_time = time.time()
     assert stop_time - start_time > seconds_to_wait
 
@@ -119,7 +115,7 @@ def test_ipyparallel_executor():
     child.expect("Engines appear to have started successfully", timeout=35)
     ipyparallel_executor = Client()
     learner = Learner1D(linear, (-1, 1))
-    BlockingRunner(learner, trivial_goal, executor=ipyparallel_executor)
+    BlockingRunner(learner, npoints_goal=10, executor=ipyparallel_executor)
 
     assert learner.npoints > 0
 
@@ -137,20 +133,20 @@ def test_distributed_executor():
 
     learner = Learner1D(linear, (-1, 1))
     client = Client(n_workers=1)
-    BlockingRunner(learner, trivial_goal, executor=client)
+    BlockingRunner(learner, npoints_goal=10, executor=client)
     client.shutdown()
     assert learner.npoints > 0
 
 
 def test_loky_executor(loky_executor):
     learner = Learner1D(lambda x: x, (-1, 1))
     BlockingRunner(
-        learner, trivial_goal, executor=loky_executor, shutdown_executor=True
+        learner, npoints_goal=10, executor=loky_executor, shutdown_executor=True
     )
     assert learner.npoints > 0
 
 
 def test_default_executor():
     learner = Learner1D(linear, (-1, 1))
-    runner = AsyncRunner(learner, goal=10)
+    runner = AsyncRunner(learner, npoints_goal=10)
     asyncio.get_event_loop().run_until_complete(runner.task)

adaptive/tests/test_sequence_learner.py

@@ -19,8 +19,6 @@ def test_fail_with_sequence_of_unhashable():
     # https://github.com/python-adaptive/adaptive/issues/265
     seq = [{1: 1}]  # unhashable
     learner = SequenceLearner(FailOnce(), sequence=seq)
-    runner = Runner(
-        learner, goal=SequenceLearner.done, retries=1, executor=SequentialExecutor()
-    )
+    runner = Runner(learner, retries=1, executor=SequentialExecutor())
     asyncio.get_event_loop().run_until_complete(runner.task)
     assert runner.status() == "finished"