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

Author: basnijholt

AUTHORS.md

@@ -2,15 +2,18 @@
 
 The current maintainers of Adaptive are:
 
-+ [Bas Nijholt](<http://nijho.lt>)
-+ [Joseph Weston](<https://joseph.weston.cloud>)
-+ [Anton Akhmerov](<https://antonakhmerov.org>)
+- [Bas Nijholt](<http://nijho.lt>)
+- [Joseph Weston](<https://joseph.weston.cloud>)
+- [Anton Akhmerov](<https://antonakhmerov.org>)
 
 Other contributors to Adaptive include:
 
-+ Andrey E. Antipov
-+ [Christoph Groth](<http://inac.cea.fr/Pisp/christoph.groth/>)
-+ Jorn Hoofwijk
-+ Philippe Solodov (@philippeitis)
-+ Victor Negîrneac (@caenrigen)
-+ Thomas A Caswell (@tacaswell)
+- Andrey E. Antipov
+- [Christoph Groth](<http://inac.cea.fr/Pisp/christoph.groth/>)
+- Jorn Hoofwijk
+- Philippe Solodov (@philippeitis)
+- Victor Negîrneac (@caenrigen)
+- Thomas A Caswell (@tacaswell)
+- Álvaro Gómez Iñesta (@AlvaroGI)
+- Sultan Orazbayev (@SultanOrazbayev)
+- Thomas Aarholt (@thomasaarholt)

CHANGELOG.md

@@ -1,12 +1,35 @@
 # Changelog
 
-## [Unreleased](https://github.com/python-adaptive/adaptive/tree/HEAD)
+## [v0.13.0](https://github.com/python-adaptive/adaptive/tree/v0.13.0) (2021-09-10)
 
-[Full Changelog](https://github.com/python-adaptive/adaptive/compare/v0.12.2...HEAD)
+[Full Changelog](https://github.com/python-adaptive/adaptive/compare/v0.12.2...v0.13.0)
+
+**Fixed bugs:**
+
+- AverageLearner doesn't work with 0 mean [\#275](https://github.com/python-adaptive/adaptive/issues/275)
+- call self.\_process\_futures on canceled futures when BlockingRunner is done [\#320](https://github.com/python-adaptive/adaptive/pull/320) ([basnijholt](https://github.com/basnijholt))
+- AverageLearner: fix zero mean [\#276](https://github.com/python-adaptive/adaptive/pull/276) ([basnijholt](https://github.com/basnijholt))
 
 **Closed issues:**
 
+- Runners should tell learner about remaining points at end of run [\#319](https://github.com/python-adaptive/adaptive/issues/319)
 - Cryptic error when importing lmfit [\#314](https://github.com/python-adaptive/adaptive/issues/314)
+- change CHANGELOG to KeepAChangelog format [\#306](https://github.com/python-adaptive/adaptive/issues/306)
+- jupyter notebook kernels dead after running "import adaptive" [\#298](https://github.com/python-adaptive/adaptive/issues/298)
+- Emphasis on when to use adaptive in docs [\#297](https://github.com/python-adaptive/adaptive/issues/297)
+- GPU acceleration [\#296](https://github.com/python-adaptive/adaptive/issues/296)
+
+**Merged pull requests:**
+
+- Learner1D type hints and add typeguard to pytest tests [\#325](https://github.com/python-adaptive/adaptive/pull/325) ([basnijholt](https://github.com/basnijholt))
+- AverageLearner type hints [\#324](https://github.com/python-adaptive/adaptive/pull/324) ([basnijholt](https://github.com/basnijholt))
+- Update doc string for resolution\_loss\_function [\#323](https://github.com/python-adaptive/adaptive/pull/323) ([SultanOrazbayev](https://github.com/SultanOrazbayev))
+- Update Readme to emphasise when adaptive should be used [\#318](https://github.com/python-adaptive/adaptive/pull/318) ([thomasaarholt](https://github.com/thomasaarholt))
+- add to\_numpy methods [\#317](https://github.com/python-adaptive/adaptive/pull/317) ([basnijholt](https://github.com/basnijholt))
+- lazily evaluate the integrator coefficients [\#311](https://github.com/python-adaptive/adaptive/pull/311) ([basnijholt](https://github.com/basnijholt))
+- AverageLearner1D added [\#283](https://github.com/python-adaptive/adaptive/pull/283) ([AlvaroGI](https://github.com/AlvaroGI))
+- Make LearnerND pickleable [\#272](https://github.com/python-adaptive/adaptive/pull/272) ([basnijholt](https://github.com/basnijholt))
+- add a FAQ [\#242](https://github.com/python-adaptive/adaptive/pull/242) ([basnijholt](https://github.com/basnijholt))
 
 ## [v0.12.2](https://github.com/python-adaptive/adaptive/tree/v0.12.2) (2021-03-23)
 

LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2017-2020, Adaptive authors
+Copyright (c) 2017-2021, Adaptive authors
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

README.rst

@@ -8,10 +8,12 @@
 
   *Adaptive*: parallel active learning of mathematical functions.
 
+.. include:: logo.rst
+
 ``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, rather than unecessarily computing *all* points on a dense grid.
+“best” points in parameter space, rather than unnecessarily 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.
 
@@ -25,10 +27,6 @@ to see examples of how to use ``adaptive`` or visit the
 
 .. summary-end
 
-**WARNING: adaptive is still in a beta development stage**
-
-.. not-in-documentation-start
-
 Implemented algorithms
 ----------------------
 
@@ -44,6 +42,8 @@ but the details of the adaptive sampling are completely customizable.
 
 The following learners are implemented:
 
+.. not-in-documentation-start
+
 - ``Learner1D``, for 1D functions ``f: ℝ → ℝ^N``,
 - ``Learner2D``, for 2D functions ``f: ℝ^2 → ℝ^N``,
 - ``LearnerND``, for ND functions ``f: ℝ^N → ℝ^M``,
@@ -52,10 +52,16 @@ The following learners are implemented:
 - ``AverageLearner1D``, for stochastic 1D functions where you want to
   estimate the mean value of the function at each point,
 - ``IntegratorLearner``, for
-  when you want to intergrate a 1D function ``f: ℝ → ℝ``,
+  when you want to intergrate a 1D function ``f: ℝ → ℝ``.
 - ``BalancingLearner``, for when you want to run several learners at once,
   selecting the “best” one each time you get more points.
 
+Meta-learners (to be used with other learners):
+
+- ``BalancingLearner``, for when you want to run several learners at once,
+  selecting the “best” one each time you get more points,
+- ``DataSaver``, for when your function doesn't just return a scalar or a vector.
+
 In addition to the learners, ``adaptive`` also provides primitives for
 running the sampling across several cores and even several machines,
 with built-in support for

adaptive/learner/average_learner1D.py

@@ -1,11 +1,19 @@
-from __future__ import annotations
-
 import math
 import sys
 from collections import defaultdict
 from copy import deepcopy
 from math import hypot
-from typing import Callable, DefaultDict, List, Sequence, Tuple
+from typing import (
+    Callable,
+    DefaultDict,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+)
 
 import numpy as np
 import scipy.stats
@@ -19,17 +27,17 @@
 Point = Tuple[int, Real]
 Points = List[Point]
 
-__all__: list[str] = ["AverageLearner1D"]
+__all__: List[str] = ["AverageLearner1D"]
 
 
 class AverageLearner1D(Learner1D):
-    """Learns and predicts a noisy function 'f:ℝ → ℝ^N'.
+    """Learns and predicts a noisy function 'f:ℝ → ℝ'.
 
     Parameters
     ----------
     function : callable
         The function to learn. Must take a tuple of ``(seed, x)`` and
-        return a real number or vector.
+        return a real number.
     bounds : pair of reals
         The bounds of the interval on which to learn 'function'.
     loss_per_interval: callable, optional
@@ -67,10 +75,11 @@ class AverageLearner1D(Learner1D):
 
     def __init__(
         self,
-        function: Callable[[tuple[int, Real]], Real],
-        bounds: tuple[Real, Real],
-        loss_per_interval: None
-        | (Callable[[Sequence[Real], Sequence[Real]], float]) = None,
+        function: Callable[[Tuple[int, Real]], Real],
+        bounds: Tuple[Real, Real],
+        loss_per_interval: Optional[
+            Callable[[Sequence[Real], Sequence[Real]], float]
+        ] = None,
         delta: float = 0.2,
         alpha: float = 0.005,
         neighbor_sampling: float = 0.3,
@@ -106,15 +115,15 @@ def __init__(
         self._number_samples = SortedDict()
         # This set contains the points x that have less than min_samples
         # samples or less than a (neighbor_sampling*100)% of their neighbors
-        self._undersampled_points: set[Real] = set()
+        self._undersampled_points: Set[Real] = set()
         # Contains the error in the estimate of the
         # mean at each point x in the form {x0: error(x0), ...}
-        self.error: ItemSortedDict[Real, float] = decreasing_dict()
+        self.error: Dict[Real, float] = decreasing_dict()
         #  Distance between two neighboring points in the
         # form {xi: ((xii-xi)^2 + (yii-yi)^2)^0.5, ...}
-        self._distances: ItemSortedDict[Real, float] = decreasing_dict()
+        self._distances: Dict[Real, float] = decreasing_dict()
         # {xii: error[xii]/min(_distances[xi], _distances[xii], ...}
-        self.rescaled_error: ItemSortedDict[Real, float] = decreasing_dict()
+        self.rescaled_error: Dict[Real, float] = decreasing_dict()
 
     @property
     def nsamples(self) -> int:
@@ -127,7 +136,7 @@ def min_samples_per_point(self) -> int:
             return 0
         return min(self._number_samples.values())
 
-    def ask(self, n: int, tell_pending: bool = True) -> tuple[Points, list[float]]:
+    def ask(self, n: int, tell_pending: bool = True) -> Tuple[Points, List[float]]:
         """Return 'n' points that are expected to maximally reduce the loss."""
         # If some point is undersampled, resample it
         if len(self._undersampled_points):
@@ -156,7 +165,7 @@ def ask(self, n: int, tell_pending: bool = True) -> tuple[Points, list[float]]:
 
         return points, loss_improvements
 
-    def _ask_for_more_samples(self, x: Real, n: int) -> tuple[Points, list[float]]:
+    def _ask_for_more_samples(self, x: Real, n: int) -> Tuple[Points, List[float]]:
         """When asking for n points, the learner returns n times an existing point
         to be resampled, since in general n << min_samples and this point will
         need to be resampled many more times"""
@@ -175,7 +184,7 @@ def _ask_for_more_samples(self, x: Real, n: int) -> tuple[Points, list[float]]:
         loss_improvements = [loss_improvement / n] * n
         return points, loss_improvements
 
-    def _ask_for_new_point(self, n: int) -> tuple[Points, list[float]]:
+    def _ask_for_new_point(self, n: int) -> Tuple[Points, List[float]]:
         """When asking for n new points, the learner returns n times a single
         new point, since in general n << min_samples and this point will need
         to be resampled many more times"""
@@ -357,7 +366,7 @@ def _update_losses_resampling(self, x: Real, real=True) -> None:
         if (b is not None) and right_loss_is_unknown:
             self.losses_combined[x, b] = float("inf")
 
-    def _calc_error_in_mean(self, ys: Sequence[Real], y_avg: Real, n: int) -> float:
+    def _calc_error_in_mean(self, ys: Iterable[Real], y_avg: Real, n: int) -> float:
         variance_in_mean = sum((y - y_avg) ** 2 for y in ys) / (n - 1)
         t_student = scipy.stats.t.ppf(1 - self.alpha, df=n - 1)
         return t_student * (variance_in_mean / n) ** 0.5
@@ -389,7 +398,7 @@ def tell_many(self, xs: Points, ys: Sequence[Real]) -> None:
                 # simultaneously, before we move on to a new x
                 self.tell_many_at_point(x, seed_y_mapping)
 
-    def tell_many_at_point(self, x: Real, seed_y_mapping: dict[int, Real]) -> None:
+    def tell_many_at_point(self, x: Real, seed_y_mapping: Dict[int, Real]) -> None:
         """Tell the learner about many samples at a certain location x.
 
         Parameters
@@ -445,10 +454,10 @@ def tell_many_at_point(self, x: Real, seed_y_mapping: dict[int, Real]) -> None:
                     self._update_interpolated_loss_in_interval(*interval)
                 self._oldscale = deepcopy(self._scale)
 
-    def _get_data(self) -> SortedDict[Real, Real]:
+    def _get_data(self) -> Dict[Real, Real]:
         return self._data_samples
 
-    def _set_data(self, data: SortedDict[Real, Real]) -> None:
+    def _set_data(self, data: Dict[Real, Real]) -> None:
         if data:
             for x, samples in data.items():
                 self.tell_many_at_point(x, samples)
@@ -482,7 +491,7 @@ def plot(self):
         return p.redim(x=dict(range=plot_bounds))
 
 
-def decreasing_dict() -> ItemSortedDict:
+def decreasing_dict() -> Dict:
     """This initialization orders the dictionary from large to small values"""
 
     def sorting_rule(key, value):

adaptive/learner/base_learner.py

@@ -2,9 +2,10 @@
 
 import abc
 from contextlib import suppress
-from copy import deepcopy
 from typing import Any, Callable
 
+import cloudpickle
+
 from adaptive.utils import _RequireAttrsABCMeta, load, save
 
 
@@ -15,7 +16,7 @@ def uses_nth_neighbors(n: int) -> Callable:
     with ``n`` nearest neighbors
 
     The loss function will then receive the data of the N nearest neighbors
-    (``nth_neighbors``) aling with the data of the interval itself in a dict.
+    (``nth_neighbors``) along with the data of the interval itself in a dict.
     The `~adaptive.Learner1D` will also make sure that the loss is updated
     whenever one of the ``nth_neighbors`` changes.
 
@@ -196,7 +197,7 @@ def load(self, fname: str, compress: bool = True) -> None:
             self._set_data(data)
 
     def __getstate__(self) -> dict[str, Any]:
-        return deepcopy(self.__dict__)
+        return cloudpickle.dumps(self.__dict__)
 
     def __setstate__(self, state: dict[str, Any]) -> None:
-        self.__dict__ = state
+        self.__dict__ = cloudpickle.loads(state)