@@ -36,7 +36,7 @@ Examples

 Here are some examples of how Adaptive samples vs. homogeneous sampling. Click

 on the *Play* :fa:`play` button or move the sliders.

-.. execute::

+.. jupyter-execute::

     :hide-code:

     import itertools

@@ -52,7 +52,7 @@ on the *Play* :fa:`play` button or move the sliders.

 `adaptive.Learner1D`

 ~~~~~~~~~~~~~~~~~~~~

-.. execute::

+.. jupyter-execute::

     :hide-code:

     %%opts Layout [toolbar=None]

@@ -87,7 +87,7 @@ on the *Play* :fa:`play` button or move the sliders.

 `adaptive.Learner2D`

 ~~~~~~~~~~~~~~~~~~~~

-.. execute::

+.. jupyter-execute::

     :hide-code:

     def ring(xy):

@@ -116,7 +116,7 @@ on the *Play* :fa:`play` button or move the sliders.

 `adaptive.AverageLearner`

 ~~~~~~~~~~~~~~~~~~~~~~~~~

-.. execute::

+.. jupyter-execute::

     :hide-code:

     def g(n):

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

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`AverageLearner`

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

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: AverageLearner

     import adaptive

     adaptive.notebook_extension()

@@ -25,7 +24,7 @@ the learner must formally take a single parameter, which should be used

 like a “seed” for the (pseudo-) random variable (although in the current

 implementation the seed parameter can be ignored by the function).

-.. execute::

+.. jupyter-execute::

     def g(n):

         import random

@@ -38,20 +37,20 @@ implementation the seed parameter can be ignored by the function).

         random.setstate(state)

         return val

-.. execute::

+.. jupyter-execute::

     learner = adaptive.AverageLearner(g, atol=None, rtol=0.01)

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

-.. 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)

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

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`BalancingLearner`

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

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: BalancingLearner

     import adaptive

     adaptive.notebook_extension()

@@ -30,7 +29,7 @@ improvement.

 The balancing learner can for example be used to implement a poor-man’s

 2D learner by using the `~adaptive.Learner1D`.

-.. execute::

+.. jupyter-execute::

     def h(x, offset=0):

         a = 0.01

@@ -42,16 +41,16 @@ The balancing learner can for example be used to implement a poor-man’s

     bal_learner = adaptive.BalancingLearner(learners)

     runner = adaptive.Runner(bal_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::

     plotter = lambda learner: hv.Overlay([L.plot() for L in learner.learners])

     runner.live_plot(plotter=plotter, update_interval=0.1)

@@ -61,7 +60,7 @@ product of parameters. For that particular case we’ve added a

 ``classmethod`` called ``~adaptive.BalancingLearner.from_product``.

 See how it works below

-.. execute::

+.. jupyter-execute::

     from scipy.special import eval_jacobi

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

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`DataSaver`

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

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: DataSaver

     import adaptive

     adaptive.notebook_extension()

@@ -23,7 +22,7 @@ metadata, you can wrap your learner in an `adaptive.DataSaver`.

 In the following example the function to be learned returns its result

 and the execution time in a dictionary:

-.. execute::

+.. jupyter-execute::

     from operator import itemgetter

@@ -48,20 +47,20 @@ and the execution time in a dictionary:

 ``learner.learner`` is the original learner, so

 ``learner.learner.loss()`` will call the correct loss method.

-.. execute::

+.. jupyter-execute::

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

-.. 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(plotter=lambda l: l.learner.plot(), update_interval=0.1)

@@ -69,6 +68,6 @@ Now the ``DataSavingLearner`` will have an dictionary attribute

 ``extra_data`` that has ``x`` as key and the data that was returned by

 ``learner.function`` as values.

-.. execute::

+.. jupyter-execute::

     learner.extra_data

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

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`IntegratorLearner`

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

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: IntegratorLearner

     import adaptive

     adaptive.notebook_extension()

@@ -27,7 +26,7 @@ of the integral with it. It is based on Pedro Gonnet’s

 Let’s try the following function with cusps (that is difficult to

 integrate):

-.. execute::

+.. jupyter-execute::

     def f24(x):

         return np.floor(np.exp(x))

@@ -40,7 +39,7 @@ let’s try a familiar function integrator `scipy.integrate.quad`, which

 will give us warnings that it encounters difficulties (if we run it

 in a notebook.)

-.. execute::

+.. jupyter-execute::

     import scipy.integrate

     scipy.integrate.quad(f24, 0, 3)

@@ -50,7 +49,7 @@ we want to reach. Then in the `~adaptive.Runner` we pass

 ``goal=lambda l: l.done()`` where ``learner.done()`` is ``True`` when

 the relative tolerance has been reached.

-.. execute::

+.. jupyter-execute::

     from adaptive.runner import SequentialExecutor

@@ -61,24 +60,24 @@ the relative tolerance has been reached.

     # the overhead of evaluating the function in another process.

     runner = adaptive.Runner(learner, executor=SequentialExecutor(), goal=lambda l: l.done())

-.. execute::

+.. jupyter-execute::

     :hide-code:

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

-.. execute::

+.. jupyter-execute::

     runner.live_info()

 Now we could do the live plotting again, but lets just wait untill the

 runner is done.

-.. execute::

+.. jupyter-execute::

     if not runner.task.done():

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

-.. execute::

+.. jupyter-execute::

     print('The integral value is {} with the corresponding error of {}'.format(learner.igral, learner.err))

     learner.plot()

@@ -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)

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

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`Learner2D`

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

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: Learner2D

     import adaptive

     adaptive.notebook_extension()

@@ -23,7 +22,7 @@ Tutorial `~adaptive.Learner2D`

 Besides 1D functions, we can also learn 2D functions:

 :math:`\ f: ℝ^2 → ℝ`.

-.. execute::

+.. jupyter-execute::

     def ring(xy, wait=True):

         import numpy as np

@@ -37,20 +36,20 @@ Besides 1D functions, we can also learn 2D functions:

     learner = adaptive.Learner2D(ring, bounds=[(-1, 1), (-1, 1)])

-.. execute::

+.. jupyter-execute::

     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::

     def plot(learner):

         plot = learner.plot(tri_alpha=0.2)

@@ -58,7 +57,7 @@ Besides 1D functions, we can also learn 2D functions:

     runner.live_plot(plotter=plot, update_interval=0.1)

-.. execute::

+.. jupyter-execute::

     %%opts EdgePaths (color='w')

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

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`LearnerND`

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

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: LearnerND

     import adaptive

     adaptive.notebook_extension()

@@ -33,7 +32,7 @@ Do keep in mind the speed and

 `effectiveness <https://en.wikipedia.org/wiki/Curse_of_dimensionality>`__

 of the learner drops quickly with increasing number of dimensions.

-.. execute::

+.. jupyter-execute::

     # this step takes a lot of time, it will finish at about 3300 points, which can take up to 6 minutes

     def sphere(xyz):

@@ -44,18 +43,18 @@ of the learner drops quickly with increasing number of dimensions.

     learner = adaptive.LearnerND(sphere, bounds=[(-1, 1), (-1, 1), (-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()

 Let’s plot 2D slices of the 3D function

-.. execute::

+.. jupyter-execute::

     def plot_cut(x, direction, learner=learner):

         cut_mapping = {'XYZ'.index(direction): x}

@@ -70,7 +69,7 @@ Let’s plot 2D slices of the 3D function

 Or we can plot 1D slices

-.. execute::

+.. jupyter-execute::

     %%opts Path {+framewise}

     def plot_cut(x1, x2, directions, learner=learner):

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

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`SKOptLearner`

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

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: SKOptLearner

     import adaptive

     adaptive.notebook_extension()

@@ -33,13 +32,13 @@ Although ``SKOptLearner`` can optimize functions of arbitrary

 dimensionality, we can only plot the learner if a 1D function is being

 learned.

-.. execute::

+.. jupyter-execute::

     def F(x, noise_level=0.1):

         return (np.sin(5 * x) * (1 - np.tanh(x ** 2))

                 + np.random.randn() * noise_level)

-.. execute::

+.. jupyter-execute::

     learner = adaptive.SKOptLearner(F, dimensions=[(-2., 2.)],

                                     base_estimator="GP",

@@ -48,16 +47,16 @@ learned.

                                    )

     runner = adaptive.Runner(learner, ntasks=1, goal=lambda l: l.npoints > 40)

-.. 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::

     %%opts Overlay [legend_position='top']

     xs = np.linspace(*learner.space.bounds[0])

@@ -8,11 +8,10 @@ Advanced Topics

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`advanced-topics`

+    :jupyter-download:notebook:`tutorial.advanced-topics`

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: advanced-topics

     import adaptive

     adaptive.notebook_extension()

@@ -45,7 +44,7 @@ The second way *must be used* when saving the ``learner``\s of a

 By default the resulting pickle files are compressed, to turn this off

 use ``learner.save(fname=..., compress=False)``

-.. execute::

+.. jupyter-execute::

     # Let's create two learners and run only one.

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

@@ -54,16 +53,16 @@ use ``learner.save(fname=..., compress=False)``

     # Let's only run the learner

     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::

     fname = 'data/example_file.p'

     learner.save(fname)

@@ -74,7 +73,7 @@ use ``learner.save(fname=..., compress=False)``

 Or just (without saving):

-.. execute::

+.. jupyter-execute::

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

     control.copy_from(learner)

@@ -82,7 +81,7 @@ Or just (without saving):

 One can also periodically save the learner while running in a

 `~adaptive.Runner`. Use it like:

-.. execute::

+.. jupyter-execute::

     def slow_f(x):

         from time import sleep

@@ -93,17 +92,17 @@ One can also periodically save the learner while running in a

     runner = adaptive.Runner(learner, goal=lambda l: l.npoints > 100)

     runner.start_periodic_saving(save_kwargs=dict(fname='data/periodic_example.p'), interval=6)

-.. execute::

+.. jupyter-execute::

     :hide-code:

     await asyncio.sleep(6)  # This is not needed in a notebook environment!

     runner.cancel()

-.. execute::

+.. jupyter-execute::

     runner.live_info()  # we cancelled it after 6 seconds

-.. execute::

+.. jupyter-execute::

     # See the data 6 later seconds with

     !ls -lah data  # only works on macOS and Linux systems

@@ -137,7 +136,7 @@ something until its done?

 The simplest way to accomplish this is to use

 `adaptive.BlockingRunner`:

-.. execute::

+.. jupyter-execute::

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

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

@@ -164,7 +163,7 @@ way with adaptive.

 The simplest way is to use `adaptive.runner.simple` to run your

 learner:

-.. execute::

+.. jupyter-execute::

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

@@ -180,7 +179,7 @@ If you want to enable determinism, want to continue using the

 non-blocking `adaptive.Runner`, you can use the

 `adaptive.runner.SequentialExecutor`:

-.. execute::

+.. jupyter-execute::

     from adaptive.runner import SequentialExecutor

@@ -188,16 +187,16 @@ non-blocking `adaptive.Runner`, you can use the

     runner = adaptive.Runner(learner, executor=SequentialExecutor(), 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)

@@ -215,29 +214,29 @@ cancelled.

 the runner. You can also stop the runner programatically using

 ``runner.cancel()``.

-.. execute::

+.. jupyter-execute::

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

     runner = adaptive.Runner(learner)

-.. execute::

+.. jupyter-execute::

     :hide-code:

     await asyncio.sleep(0.1)  # This is not needed in the notebook!

-.. execute::

+.. jupyter-execute::

     runner.cancel()  # Let's execute this after 0.1 seconds

-.. execute::

+.. jupyter-execute::

     runner.live_info()

-.. execute::

+.. jupyter-execute::

     runner.live_plot(update_interval=0.1)

-.. execute::

+.. jupyter-execute::

     print(runner.status())

@@ -253,7 +252,7 @@ gone wrong is that nothing will be happening.

 Let’s look at the following example, where the function to be learned

 will raise an exception 10% of the time.

-.. execute::

+.. jupyter-execute::

     def will_raise(x):

         from random import random

@@ -268,16 +267,16 @@ will raise an exception 10% of the time.

     runner = adaptive.Runner(learner)  # without 'goal' the runner will run forever unless cancelled

-.. execute::

+.. jupyter-execute::

     :hide-code:

     await asyncio.sleep(4)  # in 4 seconds it will surely have failed

-.. execute::

+.. jupyter-execute::

     runner.live_info()

-.. execute::

+.. jupyter-execute::

     runner.live_plot()

@@ -286,7 +285,7 @@ after a few points are evaluated.

 First we should check that the runner has really finished:

-.. execute::

+.. jupyter-execute::

     runner.task.done()

@@ -295,7 +294,7 @@ runner. This should be ``None`` if the runner stopped successfully. If

 the runner stopped due to an exception then asking for the result will

 raise the exception with the stack trace:

-.. execute::

+.. jupyter-execute::

     runner.task.result()

@@ -306,18 +305,18 @@ Runners do their job in the background, which makes introspection quite

 cumbersome. One way to inspect runners is to instantiate one with

 ``log=True``:

-.. execute::

+.. jupyter-execute::

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

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

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

                              log=True)

-.. execute::

+.. jupyter-execute::

     :hide-code:

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

-.. execute::

+.. jupyter-execute::

     runner.live_info()

@@ -329,12 +328,12 @@ non-deterministic order.

 This can be used with `adaptive.runner.replay_log` to perfom the same

 set of operations on another runner:

-.. execute::

+.. jupyter-execute::

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

     adaptive.runner.replay_log(reconstructed_learner, runner.log)

-.. execute::

+.. jupyter-execute::

     learner.plot().Scatter.I.opts(style=dict(size=6)) * reconstructed_learner.plot()

@@ -356,7 +355,7 @@ not do anything when the kernel is blocked.

 Therefore you need to create an ``async`` function and hook it into the

 ``ioloop`` like so:

-.. execute::

+.. jupyter-execute::

     import asyncio

@@ -373,12 +372,12 @@ Therefore you need to create an ``async`` function and hook it into the

     timer = ioloop.create_task(time(runner))

-.. execute::

+.. jupyter-execute::

     :hide-code:

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

-.. execute::

+.. jupyter-execute::

     # The result will only be set when the runner is done.

     timer.result()

@@ -8,11 +8,10 @@ Custom adaptive logic for 1D and 2D

 .. seealso::

     The complete source code of this tutorial can be found in

-    :jupyter-download:notebook:`custom-loss-function`

+    :jupyter-download:notebook:`tutorial.custom-loss-function`

-.. execute::

+.. jupyter-execute::

     :hide-code:

-    :new-notebook: custom-loss-function

     import adaptive

     adaptive.notebook_extension()

@@ -59,7 +58,7 @@ Uniform sampling

 Say we want to properly sample a function that contains divergences. A

 simple (but naive) strategy is to *uniformly* sample the domain:

-.. execute::

+.. jupyter-execute::

     def uniform_sampling_1d(interval, scale, function_values):

         # Note that we never use 'function_values'; the loss is just the size of the subdomain

@@ -75,7 +74,7 @@ simple (but naive) strategy is to *uniformly* sample the domain:

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

     learner.plot().select(y=(0, 10000))

-.. execute::

+.. jupyter-execute::

     %%opts EdgePaths (color='w') Image [logz=True colorbar=True]

@@ -95,16 +94,16 @@ simple (but naive) strategy is to *uniformly* sample the domain:

     # this takes a while, so use the async Runner so we know *something* is happening

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

-.. 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::

     plotter = lambda l: l.plot(tri_alpha=0.3).relabel(

             '1 / (x^2 + y^2) in log scale')

@@ -132,7 +131,7 @@ subdomains are appropriately small it will prioritise places where the

 function is very nonlinear, but will ignore subdomains that are too

 small (0 loss).

-.. execute::

+.. jupyter-execute::

     %%opts EdgePaths (color='w') Image [logz=True colorbar=True]