@@ -159,17 +159,29 @@

    "cell_type": "markdown",

    "metadata": {},

    "source": [

-    "# Averaging learner"

+    "# 2D function learner"

    ]

   },

   {

    "cell_type": "markdown",

    "metadata": {},

    "source": [

-    "The next type of learner averages a function until the uncertainty in the average meets some condition.\n",

+    "Besides 1D functions, we can also learn 2D functions: $\\ f: ℝ^2 → ℝ$"

+   ]

+  },

+  {

+   "cell_type": "code",

+   "execution_count": null,

+   "metadata": {},

+   "outputs": [],

+   "source": [

+    "def func(xy):\n",

+    "    import numpy as np\n",

+    "    x, y = xy\n",

+    "    a = 0.2\n",

+    "    return x + np.exp(-(x**2 + y**2 - 0.75**2)**2/a**4)\n",

     "\n",

-    "This is useful for sampling a random variable. The function passed to the learner must formally take a single parameter,\n",

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

+    "learner = adaptive.learner.Learner2D(func, bounds=[(-1, 1), (-1, 1)])"

    ]

   },

   {

@@ -178,16 +190,7 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "def g(n):\n",

-    "    import random\n",

-    "    from time import sleep\n",

-    "    sleep(random.random() / 5)\n",

-    "    # Properly save and restore the RNG state\n",

-    "    state = random.getstate()\n",

-    "    random.seed(n)\n",

-    "    val = random.gauss(0.5, 1)\n",

-    "    random.setstate(state)\n",

-    "    return val"

+    "runner = adaptive.Runner(learner, goal=lambda l: l.loss() > 1500)"

    ]

   },

   {

@@ -196,25 +199,38 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "learner = adaptive.AverageLearner(g, None, 0.01)\n",

-    "runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 1)\n",

     "adaptive.live_plot(runner)"

    ]

   },

+  {

+   "cell_type": "code",

+   "execution_count": null,

+   "metadata": {},

+   "outputs": [],

+   "source": [

+    "import numpy as np\n",

+    "learner2 = adaptive.learner.Learner2D(func, bounds=[(-1, 1), (-1, 1)])\n",

+    "lin = np.linspace(-1, 1, len(learner.points)**0.5)\n",

+    "xy = [(x, y) for x in lin for y in lin]\n",

+    "learner2.add_data(xy, map(func, xy))\n",

+    "learner2.plot().relabel('Homogeneous grid') + learner.plot().relabel('With adaptive')"

+   ]

+  },

   {

    "cell_type": "markdown",

    "metadata": {},

    "source": [

-    "# Balancing learner"

+    "# Averaging learner"

    ]

   },

   {

    "cell_type": "markdown",

    "metadata": {},

    "source": [

-    "The balancing learner is a \"meta-learner\" that takes a list of multiple leaners. The runner wil find find out which points of which child learner will improve the loss the most and send those to the executor.\n",

+    "The next type of learner averages a function until the uncertainty in the average meets some condition.\n",

     "\n",

-    "The balancing learner can for example be used to implement a poor-man's 2D learner by using the `Learner1D`."

+    "This is useful for sampling a random variable. The function passed to the learner must formally take a single parameter,\n",

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

    ]

   },

   {

@@ -223,11 +239,16 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "from adaptive.learner import Learner1D, BalancingLearner\n",

-    "\n",

-    "learners = [Learner1D(partial(f, offset=2*random()-1, wait=False), bounds=(-1.0, 1.0)) for i in range(10)]\n",

-    "learner = BalancingLearner(learners)\n",

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

+    "def g(n):\n",

+    "    import random\n",

+    "    from time import sleep\n",

+    "    sleep(random.random() / 5)\n",

+    "    # Properly save and restore the RNG state\n",

+    "    state = random.getstate()\n",

+    "    random.seed(n)\n",

+    "    val = random.gauss(0.5, 1)\n",

+    "    random.setstate(state)\n",

+    "    return val"

    ]

   },

   {

@@ -236,41 +257,25 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "import holoviews as hv\n",

-    "adaptive.live_plot(runner, plotter=lambda learner: hv.Overlay([L.plot() for L in learner.learners]))"

+    "learner = adaptive.AverageLearner(g, None, 0.01)\n",

+    "runner = adaptive.Runner(learner, goal=lambda l: l.loss() < 1)\n",

+    "adaptive.live_plot(runner)"

    ]

   },

   {

    "cell_type": "markdown",

    "metadata": {},

    "source": [

-    "# 2D learner"

+    "# Balancing learner"

    ]

   },

   {

-   "cell_type": "code",

-   "execution_count": null,

+   "cell_type": "markdown",

    "metadata": {},

-   "outputs": [],

    "source": [

-    "def func(xy):\n",

-    "    import numpy as np\n",

-    "    x, y = xy\n",

-    "    a = 0.2\n",

-    "    return x + np.exp(-(x**2 + y**2 - 0.75**2)**2/a**4)\n",

+    "The balancing learner is a \"meta-learner\" that takes a list of multiple leaners. The runner wil find find out which points of which child learner will improve the loss the most and send those to the executor.\n",

     "\n",

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

-   ]

-  },

-  {

-   "cell_type": "code",

-   "execution_count": null,

-   "metadata": {},

-   "outputs": [],

-   "source": [

-    "from concurrent.futures import ProcessPoolExecutor\n",

-    "executor = ProcessPoolExecutor(max_workers=48)\n",

-    "runner = adaptive.Runner(learner, executor, goal=lambda l: l.loss() > 1500, log=True)"

+    "The balancing learner can for example be used to implement a poor-man's 2D learner by using the `Learner1D`."

    ]

   },

   {

@@ -279,7 +284,11 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "adaptive.live_plot(runner)"

+    "from adaptive.learner import Learner1D, BalancingLearner\n",

+    "\n",

+    "learners = [Learner1D(partial(f, offset=2*random()-1, wait=False), bounds=(-1.0, 1.0)) for i in range(10)]\n",

+    "learner = BalancingLearner(learners)\n",

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

    ]

   },

   {

@@ -288,12 +297,8 @@

    "metadata": {},

    "outputs": [],

    "source": [

-    "import numpy as np\n",

-    "learner2 = adaptive.learner.Learner2D(func, bounds=[(-1, 1), (-1, 1)])\n",

-    "lin = np.linspace(-1, 1, len(learner.points)**0.5)\n",

-    "xy = [(x, y) for x in lin for y in lin]\n",

-    "learner2.add_data(xy, map(func, xy))\n",

-    "learner2.plot().relabel('Homogeneous grid') + learner.plot().relabel('With adaptive')"

+    "import holoviews as hv\n",

+    "adaptive.live_plot(runner, plotter=lambda learner: hv.Overlay([L.plot() for L in learner.learners]))"

    ]

   },

   {