Learner1D: return inf loss when the bounds aren't done

adaptive/learner/learner1D.py

@@ -1,7 +1,7 @@
 import collections.abc
 import itertools
 import math
-from copy import deepcopy
+from copy import copy, deepcopy
 from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Union
 
 import cloudpickle
@@ -290,6 +290,7 @@ def __init__(
         self._dx_eps = 2 * max(np.abs(bounds)) * np.finfo(float).eps
 
         self.bounds = list(bounds)
+        self.__missing_bounds = set(self.bounds)  # cache of missing bounds
 
         self._vdim: Optional[int] = None
 
@@ -325,6 +326,8 @@ def npoints(self) -> int:
 
     @cache_latest
     def loss(self, real: bool = True) -> float:
+        if self._missing_bounds():
+            return np.inf
         losses = self.losses if real else self.losses_combined
         if not losses:
             return np.inf
@@ -604,6 +607,15 @@ def ask(self, n: int, tell_pending: bool = True) -> Tuple[List[float], List[floa
 
         return points, loss_improvements
 
+    def _missing_bounds(self) -> List[Real]:
+        missing_bounds = []
+        for b in copy(self.__missing_bounds):
+            if b in self.data:
+                self.__missing_bounds.remove(b)
+            elif b not in self.pending_points:
+                missing_bounds.append(b)
+        return sorted(missing_bounds)
+
     def _ask_points_without_adding(self, n: int) -> Tuple[List[float], List[float]]:
         """Return 'n' points that are expected to maximally reduce the loss.
         Without altering the state of the learner"""
@@ -619,12 +631,7 @@ def _ask_points_without_adding(self, n: int) -> Tuple[List[float], List[float]]:
             return [], []
 
         # If the bounds have not been chosen yet, we choose them first.
-        missing_bounds = [
-            b
-            for b in self.bounds
-            if b not in self.data and b not in self.pending_points
-        ]
-
+        missing_bounds = self._missing_bounds()
         if len(missing_bounds) >= n:
             return missing_bounds[:n], [np.inf] * n
 

adaptive/tests/test_learner1d.py

@@ -1,11 +1,21 @@
 import random
+import time
 
 import flaky
 import numpy as np
 
 from adaptive.learner import Learner1D
 from adaptive.learner.learner1D import curvature_loss_function
-from adaptive.runner import simple
+from adaptive.runner import BlockingRunner, simple
+
+
+def flat_middle(x):
+    x *= 1e7
+    xs = np.array([0.0, 0.1, 0.9, 1.0])
+    ys = [0, 1, 1, 0]
+    if x < xs[1] or x > xs[-2]:
+        time.sleep(1)
+    return np.interp(x, xs, ys)
 
 
 def test_pending_loss_intervals():
@@ -389,3 +399,15 @@ def f(x):
 
     learner = Learner1D(f, bounds=(-1, 1))
     simple(learner, lambda l: l.npoints > 100)
+
+
+def test_inf_loss_with_missing_bounds():
+    learner = Learner1D(
+        flat_middle,
+        bounds=(0, 1e-7),
+        loss_per_interval=curvature_loss_function(),
+    )
+    # must be done in parallel because otherwise the bounds will be evaluated first
+    BlockingRunner(learner, goal=lambda learner: learner.loss() < 0.01)
+
+    learner.npoints > 20