Merge remote-tracking branch 'origin/master' into average1d

Author: basnijholt

CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [Unreleased](https://github.com/python-adaptive/adaptive/tree/HEAD)
+
+[Full Changelog](https://github.com/python-adaptive/adaptive/compare/v0.12.2...HEAD)
+
+**Closed issues:**
+
+- Cryptic error when importing lmfit [\#314](https://github.com/python-adaptive/adaptive/issues/314)
+
+## [v0.12.2](https://github.com/python-adaptive/adaptive/tree/v0.12.2) (2021-03-23)
+
+[Full Changelog](https://github.com/python-adaptive/adaptive/compare/v0.12.1...v0.12.2)
+
+**Merged pull requests:**
+
+- raise an AttributeError when attribute doesn't exists, closes \#314 [\#315](https://github.com/python-adaptive/adaptive/pull/315) ([basnijholt](https://github.com/basnijholt))
+
 ## [v0.12.1](https://github.com/python-adaptive/adaptive/tree/v0.12.1) (2021-03-23)
 
 [Full Changelog](https://github.com/python-adaptive/adaptive/compare/v0.12.0...v0.12.1)

README.rst

@@ -11,9 +11,12 @@
 ``adaptive`` is an open-source Python library designed to
 make adaptive parallel function evaluation simple. With ``adaptive`` you
 just supply a function with its bounds, and it will be evaluated at the
-“best” points in parameter space. With just a few lines of code you can
-evaluate functions on a computing cluster, live-plot the data as it
-returns, and fine-tune the adaptive sampling algorithm.
+“best” points in parameter space, rather than unecessarily computing *all* points on a dense grid.
+With just a few lines of code you can evaluate functions on a computing cluster,
+live-plot the data as it returns, and fine-tune the adaptive sampling algorithm.
+
+``adaptive`` shines on computations where each evaluation of the function
+takes *at least* ≈100ms due to the overhead of picking potentially interesting points.
 
 Run the ``adaptive`` example notebook `live on
 Binder <https://mybinder.org/v2/gh/python-adaptive/adaptive/master?filepath=example-notebook.ipynb>`_

adaptive/learner/average_learner.py

@@ -56,6 +56,10 @@ def __init__(self, function, atol=None, rtol=None, min_npoints=2):
     def n_requested(self):
         return self.npoints + len(self.pending_points)
 
+    def to_numpy(self):
+        """Data as NumPy array of size (npoints, 2) with seeds and values."""
+        return np.array(sorted(self.data.items()))
+
     def ask(self, n, tell_pending=True):
         points = list(range(self.n_requested, self.n_requested + n))
 
@@ -114,9 +118,11 @@ def loss(self, real=True, *, n=None):
         if n < self.min_npoints:
             return np.inf
         standard_error = self.std / sqrt(n)
-        return max(
-            standard_error / self.atol, standard_error / abs(self.mean) / self.rtol
-        )
+        aloss = standard_error / self.atol
+        rloss = standard_error / self.rtol
+        if self.mean != 0:
+            rloss /= abs(self.mean)
+        return max(aloss, rloss)
 
     def _loss_improvement(self, n):
         loss = self.loss()

adaptive/learner/integrator_coeffs.py

@@ -186,5 +186,8 @@ def _coefficients():
     return locals()
 
 
-def __getattr__(attr):
-    return _coefficients()[attr]
+def __getattr__(name):
+    try:
+        return _coefficients()[name]
+    except KeyError:
+        raise AttributeError(f"module {__name__} has no attribute {name}")

adaptive/learner/integrator_learner.py

@@ -546,6 +546,10 @@ def plot(self):
         xs, ys = zip(*[(x, y) for ival in ivals for x, y in sorted(ival.data.items())])
         return hv.Path((xs, ys))
 
+    def to_numpy(self):
+        """Data as NumPy array of size (npoints, 2)."""
+        return np.array(sorted(self.data.items()))
+
     def _get_data(self):
         # Change the defaultdict of SortedSets to a normal dict of sets.
         x_mapping = {k: set(v) for k, v in self.x_mapping.items()}

adaptive/learner/learner1D.py

@@ -96,7 +96,7 @@ def resolution_loss_function(min_length=0, max_length=1):
     ...     return x**2
     >>>
     >>> loss = resolution_loss_function(min_length=0.01, max_length=1)
-    >>> learner = adaptive.Learner1D(f, bounds=[(-1, -1), (1, 1)], loss_per_triangle=loss)
+    >>> learner = adaptive.Learner1D(f, bounds=(-1, -1), loss_per_interval=loss)
     """
 
     @uses_nth_neighbors(0)
@@ -269,6 +269,11 @@ def vdim(self):
                 return 1
         return self._vdim
 
+    def to_numpy(self):
+        """Data as NumPy array of size ``(npoints, 2)`` if ``learner.function`` returns a scalar
+        and ``(npoints, 1+vdim)`` if ``learner.function`` returns a vector of length ``vdim``."""
+        return np.array([(x, *np.atleast_1d(y)) for x, y in sorted(self.data.items())])
+
     @property
     def npoints(self):
         """Number of evaluated points."""

adaptive/learner/learner2D.py

@@ -377,6 +377,13 @@ def xy_scale(self):
         else:
             return np.array([xy_scale[0], xy_scale[1] / self.aspect_ratio])
 
+    def to_numpy(self):
+        """Data as NumPy array of size ``(npoints, 3)`` if ``learner.function`` returns a scalar
+        and ``(npoints, 2+vdim)`` if ``learner.function`` returns a vector of length ``vdim``."""
+        return np.array(
+            [(x, y, *np.atleast_1d(z)) for (x, y), z in sorted(self.data.items())]
+        )
+
     def _scale(self, points):
         points = np.asarray(points, dtype=float)
         return (points - self.xy_mean) / self.xy_scale

adaptive/learner/learnerND.py

@@ -379,6 +379,12 @@ def vdim(self):
                 self._vdim = 1
         return self._vdim if self._vdim is not None else 1
 
+    def to_numpy(self):
+        """Data as NumPy array of size ``(npoints, dim+vdim)``, where ``dim`` is the
+        size of the input dimension and ``vdim`` is the length of the return value
+        of ``learner.function``."""
+        return np.array([(*p, *np.atleast_1d(v)) for p, v in sorted(self.data.items())])
+
     @property
     def bounds_are_done(self):
         return all(p in self.data for p in self._bounds_points)

adaptive/runner.py

@@ -412,6 +412,10 @@ def _run(self):
             remaining = self._remove_unfinished()
             if remaining:
                 concurrent.wait(remaining)
+                # Some futures get their result set, despite being cancelled.
+                # see https://github.com/python-adaptive/adaptive/issues/319
+                with_result = [f for f in remaining if not f.cancelled() and f.done()]
+                self._process_futures(with_result)
             self._cleanup()
 
     def elapsed_time(self):

adaptive/tests/test_average_learner.py

@@ -59,3 +59,11 @@ def constant_function(seed):
         )
         simple(learner, lambda l: l.loss() < 1)
         assert learner.npoints >= max(2, min_npoints)
+
+
+def test_zero_mean():
+    # see https://github.com/python-adaptive/adaptive/issues/275
+    learner = AverageLearner(None, rtol=0.01)
+    learner.tell(0, -1)
+    learner.tell(1, 1)
+    learner.loss()