@@ -62,28 +62,34 @@ class SKOptLearner(Optimizer, BaseLearner):

     def npoints(self):

         return len(self.Xi)

-    def plot(self):

+    def plot(self, nsamples=200):

         hv = ensure_holoviews()

         if self.space.n_dims > 1:

             raise ValueError('Can only plot 1D functions')

         bounds = self.space.bounds[0]

         if not self.Xi:

-            p = hv.Scatter([]) * hv.Area([])

+            p = hv.Scatter([]) * hv.Curve([]) * hv.Area([])

         else:

             scatter = hv.Scatter(([p[0] for p in self.Xi], self.yi))

             if self.models:

-                # Plot 95% confidence interval as colored area around points

                 model = self.models[-1]

-                xs = np.linspace(*bounds, 201)

-                y_pred, sigma = model.predict(np.atleast_2d(xs).transpose(),

-                                              return_std=True)

+                xs = np.linspace(*bounds, nsamples)

+                xsp = self.space.transform(xs.reshape(-1, 1).tolist())

+                y_pred, sigma = model.predict(xsp, return_std=True)

+                # Plot model prediction for function

+                curve = hv.Curve(

+                    (xs, y_pred)

+                ).opts(style=dict(line_dash='dashed'))

+                # Plot 95% confidence interval as colored area around points

                 area = hv.Area(

                     (xs, y_pred - 1.96 * sigma, y_pred + 1.96 * sigma),

                     vdims=['y', 'y2'],

                 ).opts(style=dict(alpha=0.5, line_alpha=0))

+

             else:

                 area = hv.Area([])

-            p = scatter * area

+                curve = hv.Curve([])

+            p = scatter * curve * area

         # Plot with 5% empty margins such that the boundary points are visible

         margin = 0.05 * (bounds[1] - bounds[0])

@@ -764,9 +764,11 @@

    "outputs": [],

    "source": [

     "learner = adaptive.SKOptLearner(g, dimensions=[(-2., 2.)],\n",

-    "                                base_estimator=\"ET\",\n",

-    "                                acq_optimizer=\"sampling\")\n",

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

+    "                                base_estimator=\"GP\",\n",

+    "                                acq_func=\"gp_hedge\",\n",

+    "                                acq_optimizer=\"lbfgs\",\n",

+    "                               )\n",

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

     "runner.live_info()"

    ]

   },