diff --git a/doc/source/notebooks/advanced_usage.ipynb b/doc/source/notebooks/advanced_usage.ipynb
new file mode 100644
index 000000000..d47ed7cf1
--- /dev/null
+++ b/doc/source/notebooks/advanced_usage.ipynb
@@ -0,0 +1,638 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T10:53:12.620472Z",
+     "start_time": "2018-06-20T10:53:11.541346Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "from matplotlib import pyplot as plt\n",
+    "import gpflow\n",
+    "from gpflow.test_util import notebook_niter, is_continuous_integration\n",
+    "from scipy.cluster.vq import kmeans2\n",
+    "\n",
+    "float_type = gpflow.settings.float_type \n",
+    "\n",
+    "ITERATIONS = notebook_niter(1000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Mixing tensorflow models with gpflow\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Example 1: a convnet inside a gpflow model\n",
+    "Here we'll use the gpflow functionality, but we'll put a non-gpflow model inside the kernel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T10:53:16.316761Z",
+     "start_time": "2018-06-20T10:53:12.621686Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from tensorflow.examples.tutorials.mnist import input_data\n",
+    "mnist = input_data.read_data_sets(\"./data/MNIST_data/\", one_hot=False)\n",
+    "\n",
+    "class Mnist:\n",
+    "    input_dim = 784\n",
+    "    Nclasses = 10\n",
+    "    X = mnist.train.images.astype(float)\n",
+    "    Y = mnist.train.labels.astype(float)[:, None]\n",
+    "    Xtest = mnist.test.images.astype(float)\n",
+    "    Ytest = mnist.test.labels.astype(float)[:, None]\n",
+    "\n",
+    "if is_continuous_integration():\n",
+    "    mask = (Mnist.Y <= 1).squeeze()\n",
+    "    Mnist.X = Mnist.X[mask][:105, 300:305]\n",
+    "    Mnist.Y = Mnist.Y[mask][:105]\n",
+    "    mask = (Mnist.Ytest <= 1).squeeze()\n",
+    "    Mnist.Xtest = Mnist.Xtest[mask][:10, 300:305]\n",
+    "    Mnist.Ytest = Mnist.Ytest[mask][:10]\n",
+    "    Mnist.input_dim = 5\n",
+    "    Mnist.Nclasses = 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T10:53:16.335949Z",
+     "start_time": "2018-06-20T10:53:16.317967Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# a vanilla conv net\n",
+    "# this gets 97.3% accuracy on MNIST when used on its own (+ final linear layer) after 20K iterations\n",
+    "def cnn_fn(x, output_dim):\n",
+    "    \"\"\"\n",
+    "    Adapted from https://www.tensorflow.org/tutorials/layers\n",
+    "    \"\"\"\n",
+    "    conv1 = tf.layers.conv2d(\n",
+    "          inputs=tf.reshape(x, [-1, 28, 28, 1]),\n",
+    "          filters=32,\n",
+    "          kernel_size=[5, 5],\n",
+    "          padding=\"same\",\n",
+    "          activation=tf.nn.relu)\n",
+    "\n",
+    "    pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)\n",
+    "\n",
+    "    conv2 = tf.layers.conv2d(\n",
+    "          inputs=pool1,\n",
+    "          filters=64,\n",
+    "          kernel_size=[5, 5],\n",
+    "          padding=\"same\",\n",
+    "          activation=tf.nn.relu)\n",
+    "    \n",
+    "    pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)\n",
+    "\n",
+    "    pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])\n",
+    "    return tf.layers.dense(inputs=pool2_flat, units=output_dim, activation=tf.nn.relu)\n",
+    "\n",
+    "if is_continuous_integration():\n",
+    "    def cnn_fn(x, output_dim):\n",
+    "        return tf.layers.dense(inputs=tf.reshape(x, [-1, Mnist.input_dim]), units=output_dim)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T10:53:16.475537Z",
+     "start_time": "2018-06-20T10:53:16.337305Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class KernelWithNN(gpflow.kernels.Kernel):\n",
+    "    \"\"\"\n",
+    "    This kernel class allows for easily adding a NN (or other function) to a GP model.\n",
+    "    The kernel does not actually do anything with the NN.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def __init__(self, kern, f):\n",
+    "        \"\"\"\n",
+    "        kern.input_dim needs to be consistent with the output dimension of f\n",
+    "        \"\"\"\n",
+    "        super().__init__(kern.input_dim)\n",
+    "        self.kern = kern\n",
+    "        self._f = f\n",
+    "        \n",
+    "    def f(self, X):\n",
+    "        if X is not None:\n",
+    "            with tf.variable_scope('forward', reuse=tf.AUTO_REUSE):\n",
+    "                return self._f(X)\n",
+    "    \n",
+    "    def _get_f_vars(self):\n",
+    "        return tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='forward')\n",
+    "\n",
+    "    @gpflow.autoflow([gpflow.settings.float_type, [None,None]])\n",
+    "    def compute_f(self, X):\n",
+    "        return self.f(X)\n",
+    "    \n",
+    "    def K(self, X, X2=None):\n",
+    "        return self.kern.K(X, X2)\n",
+    "    \n",
+    "    def Kdiag(self, X):\n",
+    "        return self.kern.Kdiag(X)\n",
+    "\n",
+    "class KernelSpaceInducingPoints(gpflow.features.InducingPointsBase):\n",
+    "    pass\n",
+    "\n",
+    "# same Kuu as regular inducing points\n",
+    "gpflow.features.Kuu.register(KernelSpaceInducingPoints, KernelWithNN)(\n",
+    "    gpflow.features.Kuu.dispatch(gpflow.features.InducingPoints, gpflow.kernels.Kernel)\n",
+    ")\n",
+    "\n",
+    "# Kuf is in NN output space\n",
+    "@gpflow.features.dispatch(KernelSpaceInducingPoints, KernelWithNN, object)\n",
+    "def Kuf(feat, kern, Xnew):\n",
+    "    with gpflow.params_as_tensors_for(feat):\n",
+    "        return kern.K(feat.Z, kern.f(Xnew))\n",
+    "\n",
+    "class NNComposedKernel(KernelWithNN):\n",
+    "    \"\"\"\n",
+    "    This kernel class applies f() to X before calculating K\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def K(self, X, X2=None):\n",
+    "        return super().K(self.f(X), self.f(X2))\n",
+    "    \n",
+    "    def Kdiag(self, X):\n",
+    "        return super().Kdiag(self.f(X))\n",
+    "    \n",
+    "# we need to add these extra functions to the model so the tensorflow variables get picked up\n",
+    "class NN_SVGP(gpflow.models.SVGP):\n",
+    "    @property\n",
+    "    def trainable_tensors(self):\n",
+    "        return super().trainable_tensors + self.kern._get_f_vars()\n",
+    "\n",
+    "    @property\n",
+    "    def initializables(self):\n",
+    "        return super().initializables + self.kern._get_f_vars()\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:10:46.858524Z",
+     "start_time": "2018-06-20T10:53:16.477021Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "accuracy is 98.6800%\n"
+     ]
+    }
+   ],
+   "source": [
+    "def ex1():\n",
+    "    fX_dim = 5  \n",
+    "    M = 100\n",
+    "\n",
+    "    # annoyingly only float32 and lower is supported by the conv layers \n",
+    "    f = lambda x: tf.cast(cnn_fn(tf.cast(x, tf.float32), fX_dim), float_type)\n",
+    "    kern = NNComposedKernel(gpflow.kernels.Matern32(fX_dim), f)\n",
+    "\n",
+    "    # build the model \n",
+    "\n",
+    "    lik = gpflow.likelihoods.MultiClass(Mnist.Nclasses)\n",
+    "\n",
+    "    Z = kmeans2(Mnist.X, M, minit='points')[0]\n",
+    "\n",
+    "    model = NN_SVGP(Mnist.X, Mnist.Y, kern, lik, Z=Z, num_latent=Mnist.Nclasses, minibatch_size=1000)\n",
+    "\n",
+    "    # use gpflow wrappers to train. NB all session handling is done for us\n",
+    "    gpflow.training.AdamOptimizer(0.001).minimize(model, maxiter=ITERATIONS)\n",
+    "\n",
+    "    # predictions\n",
+    "    m, v = model.predict_y(Mnist.Xtest)\n",
+    "    preds = np.argmax(m, 1).reshape(Mnist.Ytest.shape)\n",
+    "    correct = preds == Mnist.Ytest.astype(int)\n",
+    "    acc = np.average(correct.astype(float)) * 100.\n",
+    "\n",
+    "    print('accuracy is {:.4f}%'.format(acc))\n",
+    "\n",
+    "gpflow.reset_default_graph_and_session()\n",
+    "ex1()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:25:46.165332Z",
+     "start_time": "2018-06-20T11:10:46.860361Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "accuracy is 97.5600%\n"
+     ]
+    }
+   ],
+   "source": [
+    "def ex2b():\n",
+    "    fX_dim = 5  \n",
+    "    minibatch_size = notebook_niter(1000, test_n=10)\n",
+    "    M = notebook_niter(100, test_n=5)\n",
+    "\n",
+    "    # annoyingly only float32 and lower is supported by the conv layers \n",
+    "    f = lambda x: tf.cast(cnn_fn(tf.cast(x, tf.float32), fX_dim), float_type)\n",
+    "    kern = KernelWithNN(gpflow.kernels.Matern32(fX_dim), f)\n",
+    "    \n",
+    "    ## reset inducing (they live in a different space as X, so need to be careful with this)\n",
+    "    ind = np.random.choice(Mnist.X.shape[0], minibatch_size, replace=False)\n",
+    "    \n",
+    "    # currently we need a hack due to model initialization.\n",
+    "    feat = KernelSpaceInducingPoints(np.empty((M, fX_dim)))\n",
+    "    #feat = FFeature(Z_0)  # ideally, we could move the calculation of Z_0\n",
+    "    \n",
+    "    # build the model \n",
+    "\n",
+    "    lik = gpflow.likelihoods.MultiClass(Mnist.Nclasses)\n",
+    "\n",
+    "    #Z = kmeans2(Mnist.X, M, minit='points')[0]\n",
+    "\n",
+    "    model = NN_SVGP(Mnist.X, Mnist.Y, kern, lik, feat=feat, num_latent=Mnist.Nclasses, minibatch_size=minibatch_size)\n",
+    "\n",
+    "    fZ = model.kern.compute_f(Mnist.X[ind])\n",
+    "    # Z_0 = kmeans2(fZ, M)[0] might fail\n",
+    "    Z_0 = fZ[np.random.choice(len(fZ), M, replace=False)]\n",
+    "    model.feature.Z = Z_0\n",
+    "\n",
+    "    # use gpflow wrappers to train. NB all session handling is done for us\n",
+    "    gpflow.training.AdamOptimizer(0.001).minimize(model, maxiter=ITERATIONS)\n",
+    "\n",
+    "    # predictions\n",
+    "    m, v = model.predict_y(Mnist.Xtest)\n",
+    "    preds = np.argmax(m, 1).reshape(Mnist.Ytest.shape)\n",
+    "    correct = preds == Mnist.Ytest.astype(int)\n",
+    "    acc = np.average(correct.astype(float)) * 100.\n",
+    "\n",
+    "    print('accuracy is {:.4f}%'.format(acc))\n",
+    "\n",
+    "gpflow.reset_default_graph_and_session()\n",
+    "ex2b()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Example 2: a gpflow model on top of a tensorflow model\n",
+    "Now we'll do things the other way: we'll take a model implemented in pure tensorflow, and show how we can put a gpflow model on the top"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:40:21.347439Z",
+     "start_time": "2018-06-20T11:25:46.167693Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "acc is 98.5900\n"
+     ]
+    }
+   ],
+   "source": [
+    "def ex2():\n",
+    "    minibatch_size = notebook_niter(1000, test_n=10)\n",
+    "    gp_dim = 5\n",
+    "    M = notebook_niter(100, test_n=5)\n",
+    "\n",
+    "    ## placeholders\n",
+    "    X = tf.placeholder(tf.float32, [minibatch_size, Mnist.input_dim])  # fixed shape so num_data works in SVGP\n",
+    "    Y = tf.placeholder(tf.float32, [minibatch_size, 1])\n",
+    "    Xtest = tf.placeholder(tf.float32, [None, Mnist.input_dim])\n",
+    "\n",
+    "    ## build graph\n",
+    "\n",
+    "    with tf.variable_scope('cnn'):\n",
+    "        f_X = tf.cast(cnn_fn(X, gp_dim), dtype=float_type)\n",
+    "\n",
+    "    with tf.variable_scope('cnn', reuse=True):\n",
+    "        f_Xtest = tf.cast(cnn_fn(Xtest, gp_dim), dtype=float_type)\n",
+    "\n",
+    "    gp_model = gpflow.models.SVGP(f_X, tf.cast(Y, dtype=float_type), \n",
+    "                                  gpflow.kernels.RBF(gp_dim), gpflow.likelihoods.MultiClass(Mnist.Nclasses), \n",
+    "                                  Z=np.zeros((M, gp_dim)), # we'll set this later\n",
+    "                                  num_latent=Mnist.Nclasses)\n",
+    "\n",
+    "    loss = -gp_model.likelihood_tensor\n",
+    "\n",
+    "    m, v = gp_model._build_predict(f_Xtest)\n",
+    "    my, yv = gp_model.likelihood.predict_mean_and_var(m, v)\n",
+    "\n",
+    "    with tf.variable_scope('adam'):\n",
+    "        opt_step = tf.train.AdamOptimizer(0.001).minimize(loss)\n",
+    "\n",
+    "    tf_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='adam')\n",
+    "    tf_vars += tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='cnn')\n",
+    "\n",
+    "    ## initialize\n",
+    "    sess = tf.Session()\n",
+    "    sess.run(tf.variables_initializer(var_list=tf_vars))\n",
+    "    gp_model.initialize(session=sess)\n",
+    "    \n",
+    "    ## reset inducing (they live in a different space as X, so need to be careful with this)\n",
+    "    ind = np.random.choice(Mnist.X.shape[0], minibatch_size, replace=False)\n",
+    "\n",
+    "    fZ = sess.run(f_X, feed_dict={X:Mnist.X[ind]})\n",
+    "    # Z_0 = kmeans2(fZ, M)[0] might fail\n",
+    "    Z_0 = fZ[np.random.choice(len(fZ), M, replace=False)]\n",
+    "\n",
+    "    def set_gp_param(param, value):\n",
+    "        sess.run(tf.assign(param.unconstrained_tensor, param.transform.backward(value)))\n",
+    "\n",
+    "    set_gp_param(gp_model.feature.Z, Z_0)\n",
+    "\n",
+    "    ## train\n",
+    "    for i in range(ITERATIONS):\n",
+    "        ind = np.random.choice(Mnist.X.shape[0], minibatch_size, replace=False)\n",
+    "        sess.run(opt_step, feed_dict={X:Mnist.X[ind], Y:Mnist.Y[ind]})\n",
+    "\n",
+    "    ## predict\n",
+    "    preds = np.argmax(sess.run(my, feed_dict={Xtest:Mnist.Xtest}), 1).reshape(Mnist.Ytest.shape)\n",
+    "    correct = preds == Mnist.Ytest.astype(int)\n",
+    "    acc = np.average(correct.astype(float)) * 100.\n",
+    "    print('acc is {:.4f}'.format(acc))\n",
+    "\n",
+    "gpflow.reset_default_graph_and_session()\n",
+    "ex2()\n",
+    "\n",
+    "gpflow.reset_default_graph_and_session()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Using feed dicts with autoflow\n",
+    "\n",
+    "We'll recreate something like Fig 5.5 from GPML, which is a plot of the marginal likelihood against hyperparameter configurations. We want to loop over a grid of hyperparameters, but it turns out gpflow can be very slow to do this using assign. We can get around this using a feed dict with autoflow. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:40:21.510889Z",
+     "start_time": "2018-06-20T11:40:21.349272Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "X = np.array((-6, -4, -2.1, -2, 2, 5.5, 6)).reshape(-1, 1)\n",
+    "Y = np.array((-0.5, -0.5, 1.7, 1.6, 1, 2, 1.9)).reshape(-1, 1)\n",
+    "\n",
+    "model = gpflow.models.GPR(X, Y, gpflow.kernels.RBF(1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:40:35.875839Z",
+     "start_time": "2018-06-20T11:40:21.512123Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.78 ms ± 159 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "# this is how long it takes to do the calculation with fixed parameters\n",
+    "model.compute_log_likelihood()\n",
+    "pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:40:43.636125Z",
+     "start_time": "2018-06-20T11:40:35.877115Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100 ms ± 14.1 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "# the assign method\n",
+    "model.kern.lengthscales = 1.\n",
+    "model.likelihood.variance = 0.1\n",
+    "model.compute_log_likelihood()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:40:43.640682Z",
+     "start_time": "2018-06-20T11:40:43.637867Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def make_feed(param, value):\n",
+    "    return {param.unconstrained_tensor : param.transform.backward(value)}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:40:56.972382Z",
+     "start_time": "2018-06-20T11:40:43.642145Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.64 ms ± 25.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "# the feed dict method\n",
+    "feed_dict = {}\n",
+    "feed_dict.update(make_feed(model.kern.lengthscales, 1.))\n",
+    "feed_dict.update(make_feed(model.likelihood.variance, 0.1))\n",
+    "model.compute_log_likelihood(feed_dict=feed_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:40:56.977340Z",
+     "start_time": "2018-06-20T11:40:56.973737Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def evaluate(func, param_feed_dict):\n",
+    "    tensor_feed_dict = {}\n",
+    "    for param, value in param_feed_dict.items():\n",
+    "        tensor_feed_dict.update(make_feed(param, value))\n",
+    "    return func(feed_dict=tensor_feed_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:40:58.371053Z",
+     "start_time": "2018-06-20T11:40:56.978641Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.66 ms ± 50.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "evaluate(model.compute_log_likelihood, {model.kern.lengthscales: 1., model.likelihood.variance: 0.1})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-06-20T11:41:02.717145Z",
+     "start_time": "2018-06-20T11:40:58.372035Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0x7f2dbd9d86d8>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# with the feed dict method this example is feasible\n",
+    "\n",
+    "log_noises = np.linspace(np.log(0.001), np.log(2.), 50)\n",
+    "log_lengthscales = np.linspace(np.log(0.1), np.log(20), 50)\n",
+    "\n",
+    "xx, yy = np.meshgrid(log_lengthscales, log_noises)\n",
+    "zz = []\n",
+    "\n",
+    "for lengthscale, noise in zip(np.exp(xx.flatten()), np.exp(yy.flatten())):\n",
+    "    feed_dict = {}\n",
+    "    feed_dict.update(make_feed(model.kern.lengthscales, lengthscale))\n",
+    "    feed_dict.update(make_feed(model.likelihood.variance, noise))\n",
+    "    # adapt GPflow so that we can use the following instead:\n",
+    "    #zz.append(model.evaluate(model.compute_log_likelihood,\n",
+    "    #                         {model.kern.lengthscales: lengthscale,\n",
+    "    #                          model.likelihood.variance: noise}\n",
+    "    #                        ))\n",
+    "    # to pass arguments e.g. for predict_f(XX), could use\n",
+    "    # model.evaluate(functools.partial(model.predict_f, XX), {...: ..., ...})\n",
+    "    zz.append(model.compute_log_likelihood(feed_dict=feed_dict))\n",
+    "    \n",
+    "plt.contour(xx, yy, np.array(zz).reshape(xx.shape),\n",
+    "           levels = np.linspace(np.max(zz)-4, np.max(zz), 25))\n",
+    "plt.colorbar()\n",
+    "plt.show()\n",
+    "\n",
+    "    "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.5.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/doc/source/notebooks/natural_gradients.ipynb b/doc/source/notebooks/natural_gradients.ipynb
index b63c87011..5864765d5 100644
--- a/doc/source/notebooks/natural_gradients.ipynb
+++ b/doc/source/notebooks/natural_gradients.ipynb
@@ -76,7 +76,12 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:57.799754Z",
+     "start_time": "2018-04-30T09:59:57.547423Z"
+    }
+   },
    "outputs": [],
    "source": [
     "vgp = VGP(X, Y, make_matern_kernel(), gpflow.likelihoods.Gaussian())\n",
@@ -93,7 +98,12 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:57.826302Z",
+     "start_time": "2018-04-30T09:59:57.800812Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -114,13 +124,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "* VGP likelihood is before natural gradient step:"
+    "* VGP likelihood before natural gradient step:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:57.863144Z",
+     "start_time": "2018-04-30T09:59:57.827383Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -147,7 +162,12 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:58.254414Z",
+     "start_time": "2018-04-30T09:59:57.864617Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -184,7 +204,12 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:58.259075Z",
+     "start_time": "2018-04-30T09:59:58.255558Z"
+    }
+   },
    "outputs": [],
    "source": [
     "def run_adam(model, lr, iterations, callback=None):\n",
@@ -198,13 +223,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Method for running Adam and Natural gradients optimizationon VGP. The hyperparameters at the end should match the GPR model."
+    "Method for running Adam and Natural gradients optimization on VGP. The hyperparameters at the end should match the GPR model."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:58.270623Z",
+     "start_time": "2018-04-30T09:59:58.260311Z"
+    }
+   },
    "outputs": [],
    "source": [
     "def run_nat_grads_with_adam(model, lr, gamma, iterations, var_list=None, callback=None):\n",
@@ -236,7 +266,12 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:58.664235Z",
+     "start_time": "2018-04-30T09:59:58.271714Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -264,7 +299,12 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:59.501684Z",
+     "start_time": "2018-04-30T09:59:58.665452Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -292,7 +332,12 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:59.505965Z",
+     "start_time": "2018-04-30T09:59:59.503129Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -306,7 +351,9 @@
     }
    ],
    "source": [
-    "\"GPR lengthscales = {0:.4f}, VGP lengthscales = {1:.4f}\".format(float(gpr.kern.lengthscales.read_value()), float(vgp.kern.lengthscales.read_value()))"
+    "\"GPR lengthscales = {:.4f}, VGP lengthscales = {:.4f}\".format(\n",
+    "    gpr.kern.lengthscales.read_value()[()],\n",
+    "    vgp.kern.lengthscales.read_value()[()])"
    ]
   },
   {
@@ -320,7 +367,12 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:59.946016Z",
+     "start_time": "2018-04-30T09:59:59.507143Z"
+    }
+   },
    "outputs": [],
    "source": [
     "svgp = SVGP(X, Y, make_matern_kernel(), gpflow.likelihoods.Gaussian(), Z=Z)\n",
@@ -340,7 +392,12 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T09:59:59.994121Z",
+     "start_time": "2018-04-30T09:59:59.947360Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -367,7 +424,12 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T10:00:00.052847Z",
+     "start_time": "2018-04-30T09:59:59.995545Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -394,7 +456,12 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T10:00:00.691979Z",
+     "start_time": "2018-04-30T10:00:00.053823Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -423,7 +490,12 @@
   {
    "cell_type": "code",
    "execution_count": 15,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T10:00:01.667254Z",
+     "start_time": "2018-04-30T10:00:00.692973Z"
+    }
+   },
    "outputs": [],
    "source": [
     "svgp = SVGP(X, Y, make_matern_kernel(), gpflow.likelihoods.Gaussian(), Z=Z, minibatch_size=50)\n",
@@ -442,7 +514,12 @@
   {
    "cell_type": "code",
    "execution_count": 16,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T10:00:03.742541Z",
+     "start_time": "2018-04-30T10:00:01.668715Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -469,13 +546,18 @@
     "\n",
     "Compared with doing SVGP with ordinary gradients with minibatches, the natural gradient optimizer is much faster in the Gaussian case. \n",
     "\n",
-    "Here we'll do hyperparameter learning together optimization of the variational parameters, comparing the interleaved nat grad approach and using ordinary gradients for the hyperparameters and variational parameters jointly "
+    "Here we'll do hyperparameter learning together with optimization of the variational parameters, comparing the interleaved nat grad approach and using ordinary gradients for the hyperparameters and variational parameters jointly."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 17,
-   "metadata": {},
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-04-30T10:00:07.102187Z",
+     "start_time": "2018-04-30T10:00:03.743831Z"
+    }
+   },
    "outputs": [],
    "source": [
     "gpflow.reset_default_graph_and_session()"
@@ -658,7 +740,7 @@
    "metadata": {},
    "source": [
     "We can also choose to run natural gradients in another parameterization. The \n",
-    "sensible choice might is the model parameters (q_mu, q_sqrt), which is already in gpflow."
+    "sensible choice is the model parameters (q_mu, q_sqrt), which is already in gpflow."
    ]
   },
   {
@@ -710,7 +792,7 @@
    "metadata": {},
    "source": [
     "With sufficiently small steps, it shouldn't make a difference which transform is used, but for large \n",
-    "step this can make a difference in practice."
+    "steps this can make a difference in practice."
    ]
   }
  ],
@@ -730,7 +812,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.5.2"
   }
  },
  "nbformat": 4,
diff --git a/tests/test_notebooks.py b/tests/test_notebooks.py
index c541e1031..b3d822e83 100644
--- a/tests/test_notebooks.py
+++ b/tests/test_notebooks.py
@@ -26,26 +26,26 @@
 from nbconvert.preprocessors.execute import CellExecutionError
 
 NOTEBOOK_FILES = [
+    "advanced_usage.ipynb",
     "classification.ipynb",
     "coreg_demo.ipynb",
+    "FITCvsVFE.ipynb",
+    "GPLVM.ipynb",
     "kernels.ipynb",
     "mcmc.ipynb",
-    "ordinal.ipynb",
-    "Sanity_check.ipynb",
-    "settings.ipynb",
-    "SGPR_notes.ipynb",
-    "vgp_notes.ipynb",
     "models.ipynb",
+    "monitor-tensorboard.ipynb",
     "multiclass.ipynb",
-    "classification.ipynb",
     "multioutput.ipynb",
-    "monitor-tensorboard.ipynb",
-    "FITCvsVFE.ipynb",
     "natural_gradients.ipynb",
-    "upper_bound.ipynb",
-    "GPLVM.ipynb",
+    "ordinal.ipynb",
     "regression.ipynb",
+    "Sanity_check.ipynb",
+    "settings.ipynb",
+    "SGPR_notes.ipynb",
     "svi_test.ipynb",
+    "upper_bound.ipynb",
+    "vgp_notes.ipynb",
 ]
 
 BLACKLISTED_NOTEBOOKS = [