@@ -14,7 +14,7 @@ Tutorial `~adaptive.Learner1D`

     :hide-code:

     import adaptive

-    adaptive.notebook_extension(_inline_js=False)

+    adaptive.notebook_extension()

     import numpy as np

     from functools import partial

@@ -10,8 +10,6 @@ Tutorial `~adaptive.Learner1D`

     The complete source code of this tutorial can be found in

     :jupyter-download:notebook:`tutorial.Learner1D`

-.. thebe-button:: Run the code live inside the documentation!

-

 .. jupyter-execute::

     :hide-code:

@@ -10,6 +10,8 @@ Tutorial `~adaptive.Learner1D`

     The complete source code of this tutorial can be found in

     :jupyter-download:notebook:`tutorial.Learner1D`

+.. thebe-button:: Run the code live inside the documentation!

+

 .. jupyter-execute::

     :hide-code:

@@ -14,7 +14,7 @@ Tutorial `~adaptive.Learner1D`

     :hide-code:

     import adaptive

-    adaptive.notebook_extension()

+    adaptive.notebook_extension(_inline_js=False)

     import numpy as np

     from functools import partial

@@ -150,10 +150,10 @@ by specifying ``loss_per_interval``.

 .. jupyter-execute::

-    from adaptive.learner.learner1D import (get_curvature_loss,

+    from adaptive.learner.learner1D import (curvature_loss_function,

                                             uniform_loss,

                                             default_loss)

-    curvature_loss = get_curvature_loss()

+    curvature_loss = curvature_loss_function()

     learner = adaptive.Learner1D(f, bounds=(-1, 1), loss_per_interval=curvature_loss)

     runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)

@@ -137,3 +137,61 @@ functions:

 .. jupyter-execute::

     runner.live_plot(update_interval=0.1)

+

+

+Looking at curvature

+....................

+

+By default ``adaptive`` will sample more points where the (normalized)

+euclidean distance between the neighboring points is large.

+You may achieve better results sampling more points in regions with high

+curvature. To do this, you need to tell the learner to look at the curvature

+by specifying ``loss_per_interval``.

+

+.. jupyter-execute::

+

+    from adaptive.learner.learner1D import (get_curvature_loss,

+                                            uniform_loss,

+                                            default_loss)

+    curvature_loss = get_curvature_loss()

+    learner = adaptive.Learner1D(f, bounds=(-1, 1), loss_per_interval=curvature_loss)

+    runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)

+

+.. jupyter-execute::

+    :hide-code:

+

+    await runner.task  # This is not needed in a notebook environment!

+

+.. jupyter-execute::

+

+    runner.live_info()

+

+.. jupyter-execute::

+

+    runner.live_plot(update_interval=0.1)

+

+We may see the difference of homogeneous sampling vs only one interval vs

+including nearest neighboring intervals in this plot: We will look at 100 points.

+

+.. jupyter-execute::

+

+    def sin_exp(x):

+        from math import exp, sin

+        return sin(15 * x) * exp(-x**2*2)

+

+    learner_h = adaptive.Learner1D(sin_exp, (-1, 1), loss_per_interval=uniform_loss)

+    learner_1 = adaptive.Learner1D(sin_exp, (-1, 1), loss_per_interval=default_loss)

+    learner_2 = adaptive.Learner1D(sin_exp, (-1, 1), loss_per_interval=curvature_loss)

+

+    npoints_goal = lambda l: l.npoints >= 100

+    # adaptive.runner.simple is a non parallel blocking runner.

+    adaptive.runner.simple(learner_h, goal=npoints_goal)

+    adaptive.runner.simple(learner_1, goal=npoints_goal)

+    adaptive.runner.simple(learner_2, goal=npoints_goal)

+

+    (learner_h.plot().relabel('homogeneous')

+     + learner_1.plot().relabel('euclidean loss')

+     + learner_2.plot().relabel('curvature loss')).cols(2)

+

+More info about using custom loss functions can be found

+in :ref:`Custom adaptive logic for 1D and 2D`.

@@ -39,7 +39,7 @@ background with a sharp peak at a random location:

         a = 0.01

         if wait:

-            sleep(random())

+            sleep(random() / 10)

         return x + a**2 / (a**2 + (x - offset)**2)

 We start by initializing a 1D “learner”, which will suggest points to

@@ -8,11 +8,10 @@ Tutorial `~adaptive.Learner1D`

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`Learner1D`

+    :jupyter-download:notebook:`tutorial.Learner1D`

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: Learner1D

     import adaptive

     adaptive.notebook_extension()

@@ -30,7 +29,7 @@ We start with the most common use-case: sampling a 1D function

 We will use the following function, which is a smooth (linear)

 background with a sharp peak at a random location:

-.. execute::

+.. jupyter-execute::

     offset = random.uniform(-0.5, 0.5)

@@ -47,7 +46,7 @@ We start by initializing a 1D “learner”, which will suggest points to

 evaluate, and adapt its suggestions as more and more points are

 evaluated.

-.. execute::

+.. jupyter-execute::

     learner = adaptive.Learner1D(f, bounds=(-1, 1))

@@ -61,13 +60,13 @@ On Windows systems the runner will try to use a `distributed.Client`

 if `distributed` is installed. A `~concurrent.futures.ProcessPoolExecutor`

 cannot be used on Windows for reasons.

-.. execute::

+.. jupyter-execute::

     # The end condition is when the "loss" is less than 0.1. In the context of the

     # 1D learner this means that we will resolve features in 'func' with width 0.1 or wider.

     runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)

-.. execute::

+.. jupyter-execute::

     :hide-code:

     await runner.task  # This is not needed in a notebook environment!

@@ -76,23 +75,23 @@ When instantiated in a Jupyter notebook the runner does its job in the

 background and does not block the IPython kernel. We can use this to

 create a plot that updates as new data arrives:

-.. execute::

+.. jupyter-execute::

     runner.live_info()

-.. execute::

+.. jupyter-execute::

     runner.live_plot(update_interval=0.1)

 We can now compare the adaptive sampling to a homogeneous sampling with

 the same number of points:

-.. execute::

+.. jupyter-execute::

     if not runner.task.done():

         raise RuntimeError('Wait for the runner to finish before executing the cells below!')

-.. execute::

+.. jupyter-execute::

     learner2 = adaptive.Learner1D(f, bounds=learner.bounds)

@@ -107,7 +106,7 @@ vector output: ``f:ℝ → ℝ^N``

 Sometimes you may want to learn a function with vector output:

-.. execute::

+.. jupyter-execute::

     random.seed(0)

     offsets = [random.uniform(-0.8, 0.8) for _ in range(3)]

@@ -121,20 +120,20 @@ Sometimes you may want to learn a function with vector output:

 ``adaptive`` has you covered! The ``Learner1D`` can be used for such

 functions:

-.. execute::

+.. jupyter-execute::

     learner = adaptive.Learner1D(f_levels, bounds=(-1, 1))

     runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)

-.. execute::

+.. jupyter-execute::

     :hide-code:

     await runner.task  # This is not needed in a notebook environment!

-.. execute::

+.. jupyter-execute::

     runner.live_info()

-.. execute::

+.. jupyter-execute::

     runner.live_plot(update_interval=0.1)

new file mode 100644

@@ -0,0 +1,140 @@

+Tutorial `~adaptive.Learner1D`

+------------------------------

+

+.. note::

+   Because this documentation consists of static html, the ``live_plot``

+   and ``live_info`` widget is not live. Download the notebook

+   in order to see the real behaviour.

+

+.. seealso::

+    The complete source code of this tutorial can be found in

+    :jupyter-download:notebook:`Learner1D`

+

+.. execute::

+    :hide-code:

+    :new-notebook: Learner1D

+

+    import adaptive

+    adaptive.notebook_extension()

+

+    import numpy as np

+    from functools import partial

+    import random

+

+scalar output: ``f:ℝ → ℝ``

+..........................

+

+We start with the most common use-case: sampling a 1D function

+:math:`\ f: ℝ → ℝ`.

+

+We will use the following function, which is a smooth (linear)

+background with a sharp peak at a random location:

+

+.. execute::

+

+    offset = random.uniform(-0.5, 0.5)

+

+    def f(x, offset=offset, wait=True):

+        from time import sleep

+        from random import random

+

+        a = 0.01

+        if wait:

+            sleep(random())

+        return x + a**2 / (a**2 + (x - offset)**2)

+

+We start by initializing a 1D “learner”, which will suggest points to

+evaluate, and adapt its suggestions as more and more points are

+evaluated.

+

+.. execute::

+

+    learner = adaptive.Learner1D(f, bounds=(-1, 1))

+

+Next we create a “runner” that will request points from the learner and

+evaluate ‘f’ on them.

+

+By default on Unix-like systems the runner will evaluate the points in

+parallel using local processes `concurrent.futures.ProcessPoolExecutor`.

+

+On Windows systems the runner will try to use a `distributed.Client`

+if `distributed` is installed. A `~concurrent.futures.ProcessPoolExecutor`

+cannot be used on Windows for reasons.

+

+.. execute::

+

+    # The end condition is when the "loss" is less than 0.1. In the context of the

+    # 1D learner this means that we will resolve features in 'func' with width 0.1 or wider.

+    runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)

+

+.. execute::

+    :hide-code:

+

+    await runner.task  # This is not needed in a notebook environment!

+

+When instantiated in a Jupyter notebook the runner does its job in the

+background and does not block the IPython kernel. We can use this to

+create a plot that updates as new data arrives:

+

+.. execute::

+

+    runner.live_info()

+

+.. execute::

+

+    runner.live_plot(update_interval=0.1)

+

+We can now compare the adaptive sampling to a homogeneous sampling with

+the same number of points:

+

+.. execute::

+

+    if not runner.task.done():

+        raise RuntimeError('Wait for the runner to finish before executing the cells below!')

+

+.. execute::

+

+    learner2 = adaptive.Learner1D(f, bounds=learner.bounds)

+

+    xs = np.linspace(*learner.bounds, len(learner.data))

+    learner2.tell_many(xs, map(partial(f, wait=False), xs))

+

+    learner.plot() + learner2.plot()

+

+

+vector output: ``f:ℝ → ℝ^N``

+............................

+

+Sometimes you may want to learn a function with vector output:

+

+.. execute::

+

+    random.seed(0)

+    offsets = [random.uniform(-0.8, 0.8) for _ in range(3)]

+

+    # sharp peaks at random locations in the domain

+    def f_levels(x, offsets=offsets):

+        a = 0.01

+        return np.array([offset + x + a**2 / (a**2 + (x - offset)**2)

+                         for offset in offsets])

+

+``adaptive`` has you covered! The ``Learner1D`` can be used for such

+functions:

+

+.. execute::

+

+    learner = adaptive.Learner1D(f_levels, bounds=(-1, 1))

+    runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 0.01)

+

+.. execute::

+    :hide-code:

+

+    await runner.task  # This is not needed in a notebook environment!

+

+.. execute::

+

+    runner.live_info()

+

+.. execute::

+

+    runner.live_plot(update_interval=0.1)