examples/01_Exact_GPs/Simple_GP_Regression.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "anaconda-cloud": {},
    "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.7.3"
    },
    "colab": {
      "name": "Simple_GP_Regression.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oH-9p-nlCM7J",
        "colab_type": "text"
      },
      "source": [
        "# GPyTorch Regression Tutorial\n",
        "\n",
        "<a href=\"https://colab.research.google.com/github/jwangjie/gpytorch/blob/master/examples/01_Exact_GPs/Simple_GP_Regression.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
        "\n",
        "## Introduction\n",
        "\n",
        "In this notebook, we demonstrate many of the design features of GPyTorch using the simplest example, training an RBF kernel Gaussian process on a simple function. We'll be modeling the function\n",
        "\n",
        "\\begin{align}\n",
        "y &= \\sin(2\\pi x) + \\epsilon \\\\\n",
        "  \\epsilon &\\sim \\mathcal{N}(0, 0.04) \n",
        "\\end{align}\n",
        "\n",
        "with 100 training examples, and testing on 51 test examples.\n",
        "\n",
        "**Note:** this notebook is not necessarily intended to teach the mathematical background of Gaussian processes, but rather how to train a simple one and make predictions in GPyTorch. For a mathematical treatment, Chapter 2 of Gaussian Processes for Machine Learning provides a very thorough introduction to GP regression (this entire text is highly recommended): http://www.gaussianprocess.org/gpml/chapters/RW2.pdf"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3NZkYMG9CSHY",
        "colab_type": "code",
        "outputId": "2e11f9d2-9938-45aa-9fcc-809a5bd83c1c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 185
        }
      },
      "source": [
        "# COMMENT this if not used in colab\n",
        "!pip3 install gpytorch"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting gpytorch\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/9c/5f/ce79e35c1a36deb25a0eac0f67bfe85fb8350eb8e19223950c3d615e5e9a/gpytorch-1.0.1.tar.gz (229kB)\n",
            "\u001b[K     |████████████████████████████████| 235kB 2.8MB/s \n",
            "\u001b[?25hBuilding wheels for collected packages: gpytorch\n",
            "  Building wheel for gpytorch (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for gpytorch: filename=gpytorch-1.0.1-py2.py3-none-any.whl size=390441 sha256=4c1c86a4228d2a6b7a30cf734f9a1b61de06c54de6177c0c84e34ae7d7b02939\n",
            "  Stored in directory: /root/.cache/pip/wheels/10/2f/7a/3328e5713d796daeec2ce8ded141d5f3837253fc3c2a5c62e0\n",
            "Successfully built gpytorch\n",
            "Installing collected packages: gpytorch\n",
            "Successfully installed gpytorch-1.0.1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vRuTAmukCM7K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import math\n",
        "import torch\n",
        "import gpytorch\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "%matplotlib inline\n",
        "%load_ext autoreload\n",
        "%autoreload 2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jGJW4y7sCM7R",
        "colab_type": "text"
      },
      "source": [
        "### Set up training data\n",
        "\n",
        "In the next cell, we set up the training data for this example. We'll be using 100 regularly spaced points on [0,1] which we evaluate the function on and add Gaussian noise to get the training labels."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jvktWT4cCM7S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Training data is 100 points in [0,1] inclusive regularly spaced\n",
        "train_x = torch.linspace(0, 1, 100)\n",
        "# True function is sin(2*pi*x) with Gaussian noise\n",
        "train_y = torch.sin(train_x * (2 * math.pi)) + torch.randn(train_x.size()) * math.sqrt(0.04)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CVL7OOtDQq94",
        "colab_type": "code",
        "outputId": "92f32261-5a36-477e-b251-bf7309bd50f4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        }
      },
      "source": [
        "plt.plot(train_x.numpy(), train_y.numpy())\n",
        "plt.show()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SFl2jcoMCM7X",
        "colab_type": "text"
      },
      "source": [
        "## Setting up the model\n",
        "\n",
        "The next cell demonstrates the most critical features of a user-defined Gaussian process model in GPyTorch. Building a GP model in GPyTorch is different in a number of ways.\n",
        "\n",
        "First in contrast to many existing GP packages, we do not provide full GP models for the user. Rather, we provide *the tools necessary to quickly construct one*. This is because we believe, analogous to building a neural network in standard PyTorch, it is important to have the flexibility to include whatever components are necessary. As can be seen in more complicated examples, this allows the user great flexibility in designing custom models.\n",
        "\n",
        "For most GP regression models, you will need to construct the following GPyTorch objects:\n",
        "\n",
        "1. A **GP Model** (`gpytorch.models.ExactGP`) -  This handles most of the inference.\n",
        "1. A **Likelihood** (`gpytorch.likelihoods.GaussianLikelihood`) - This is the most common likelihood used for GP regression.\n",
        "1. A **Mean** - This defines the prior mean of the GP.(If you don't know which mean to use, a `gpytorch.means.ConstantMean()` is a good place to start.)\n",
        "1. A **Kernel** - This defines the prior covariance of the GP.(If you don't know which kernel to use, a `gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())` is a good place to start).\n",
        "1. A **MultivariateNormal** Distribution (`gpytorch.distributions.MultivariateNormal`) - This is the object used to represent multivariate normal distributions.\n",
        "  \n",
        "  \n",
        "### The GP Model\n",
        "  \n",
        "The components of a user built (Exact, i.e. non-variational) GP model in GPyTorch are, broadly speaking:\n",
        "\n",
        "1. An `__init__` method that takes the training data and a likelihood, and constructs whatever objects are necessary for the model's `forward` method. This will most commonly include things like a mean module and a kernel module.\n",
        "\n",
        "2. A `forward` method that takes in some $n \\times d$ data `x` and returns a `MultivariateNormal` with the *prior* mean and covariance evaluated at `x`. In other words, we return the vector $\\mu(x)$ and the $n \\times n$ matrix $K_{xx}$ representing the prior mean and covariance matrix of the GP. \n",
        "\n",
        "This specification leaves a large amount of flexibility when defining a model. For example, to compose two kernels via addition, you can either add the kernel modules directly:\n",
        "\n",
        "```python\n",
        "self.covar_module = ScaleKernel(RBFKernel() + WhiteNoiseKernel())\n",
        "```\n",
        "\n",
        "Or you can add the outputs of the kernel in the forward method:\n",
        "\n",
        "```python\n",
        "covar_x = self.rbf_kernel_module(x) + self.white_noise_module(x)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gWqLQMrxCM7Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# We will use the simplest form of GP model, exact inference\n",
        "class ExactGPModel(gpytorch.models.ExactGP):\n",
        "    def __init__(self, train_x, train_y, likelihood):\n",
        "        super(ExactGPModel, self).__init__(train_x, train_y, likelihood)\n",
        "        self.mean_module = gpytorch.means.ConstantMean()\n",
        "        self.covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel())\n",
        "    \n",
        "    def forward(self, x):\n",
        "        mean_x = self.mean_module(x)\n",
        "        covar_x = self.covar_module(x)\n",
        "        return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)\n",
        "\n",
        "# initialize likelihood and model\n",
        "likelihood = gpytorch.likelihoods.GaussianLikelihood()\n",
        "model = ExactGPModel(train_x, train_y, likelihood)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fGNzFkFgr95H",
        "colab_type": "text"
      },
      "source": [
        "### Plot before optimizing the hyperparamters\n",
        "\n",
        "Let's take a look at the model parameters. More information is <a href=\"https://colab.research.google.com/github/jwangjie/gpytorch/blob/master/examples/00_Basic_Usage/Hyperparameters.ipynb\">here</a>."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kk2WBgZere5m",
        "colab_type": "code",
        "outputId": "ae1d5331-5cb5-4da7-854d-b536a73b871d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "model.state_dict()"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('likelihood.noise_covar.raw_noise', tensor([0.])),\n",
              "             ('mean_module.constant', tensor([0.])),\n",
              "             ('covar_module.raw_outputscale', tensor(0.)),\n",
              "             ('covar_module.base_kernel.raw_lengthscale', tensor([[0.]]))])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M5E_p1R8sNYI",
        "colab_type": "text"
      },
      "source": [
        "Goes to run [Make predictions with the model](https://colab.research.google.com/github/jwangjie/gpytorch/blob/master/examples/01_Exact_GPs/Simple_GP_Regression.ipynb#scrollTo=S1gMlb1TCM7i), and then run `Plot the model fit`. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7h-14WOcpdge",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 378
        },
        "outputId": "dbbe5d83-5bd7-44f1-ca1f-9dfd29241e87"
      },
      "source": [
        "# Get into evaluation (predictive posterior) mode\n",
        "model.eval()\n",
        "likelihood.eval()\n",
        "\n",
        "# Test points are regularly spaced along [0,1]\n",
        "# Make predictions by feeding model through likelihood\n",
        "with torch.no_grad(), gpytorch.settings.fast_pred_var():\n",
        "    test_x = torch.linspace(0, 1, 51)\n",
        "    observed_pred = likelihood(model(test_x))\n",
        "\n",
        "with torch.no_grad():\n",
        "    # Initialize plot\n",
        "    f, ax = plt.subplots(1, 1, figsize=(8, 6))\n",
        "\n",
        "    # Get upper and lower confidence bounds\n",
        "    lower, upper = observed_pred.confidence_region()\n",
        "    # Plot training data as black stars\n",
        "    ax.plot(train_x.numpy(), train_y.numpy(), 'k*')\n",
        "    # Plot predictive means as blue line\n",
        "    ax.plot(test_x.numpy(), observed_pred.mean.numpy(), 'r')\n",
        "    # Shade between the lower and upper confidence bounds\n",
        "    ax.fill_between(test_x.numpy(), lower.numpy(), upper.numpy(), alpha=0.3)\n",
        "    ax.set_ylim([-3, 3])\n",
        "    ax.legend(['Observed Data', 'Mean', 'Confidence'])"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bdnWsAh1CM7c",
        "colab_type": "text"
      },
      "source": [
        "### Model modes\n",
        "\n",
        "Like most PyTorch modules, the `ExactGP` has a `.train()` and `.eval()` mode.\n",
        "- `.train()` mode is for optimizing model hyperameters.\n",
        "- `.eval()` mode is for computing predictions through the model posterior."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FkClX5a7CM7d",
        "colab_type": "text"
      },
      "source": [
        "## Training the model\n",
        "\n",
        "In the next cell, we handle using Type-II MLE to train the hyperparameters of the Gaussian process.\n",
        "\n",
        "The most obvious difference here compared to many other GP implementations is that, as in standard PyTorch, the core training loop is written by the user. In GPyTorch, we make use of the standard PyTorch optimizers as from `torch.optim`, and all trainable parameters of the model should be of type `torch.nn.Parameter`. Because GP models directly extend `torch.nn.Module`, calls to methods like `model.parameters()` or `model.named_parameters()` function as you might expect coming from PyTorch.\n",
        "\n",
        "In most cases, the boilerplate code below will work well. It has the same basic components as the standard PyTorch training loop:\n",
        "\n",
        "1. Zero all parameter gradients\n",
        "2. Call the model and compute the loss\n",
        "3. Call backward on the loss to fill in gradients\n",
        "4. Take a step on the optimizer\n",
        "\n",
        "However, defining custom training loops allows for greater flexibility. For example, it is easy to save the parameters at each step of training, or use different learning rates for different parameters (which may be useful in deep kernel learning for example)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "fY58dyAYCM7e",
        "colab_type": "code",
        "outputId": "d512bf45-3911-47e1-e2ab-b4a8157395a3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 857
        }
      },
      "source": [
        "# this is for running the notebook in our testing framework\n",
        "import os\n",
        "smoke_test = ('CI' in os.environ)\n",
        "training_iter = 2 if smoke_test else 50\n",
        "\n",
        "\n",
        "# Find optimal model hyperparameters\n",
        "model.train()\n",
        "likelihood.train()\n",
        "\n",
        "# Use the adam optimizer\n",
        "optimizer = torch.optim.Adam([\n",
        "    {'params': model.parameters()},  # Includes GaussianLikelihood parameters\n",
        "], lr=0.1)\n",
        "\n",
        "# \"Loss\" for GPs - the marginal log likelihood\n",
        "mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)\n",
        "\n",
        "for i in range(training_iter):\n",
        "    # Zero gradients from previous iteration\n",
        "    optimizer.zero_grad()\n",
        "    # Output from model\n",
        "    output = model(train_x)\n",
        "    # Calc loss and backprop gradients\n",
        "    loss = -mll(output, train_y)\n",
        "    loss.backward()\n",
        "    print('Iter %d/%d - Loss: %.3f   lengthscale: %.3f   noise: %.3f' % (\n",
        "        i + 1, training_iter, loss.item(),\n",
        "        model.covar_module.base_kernel.lengthscale.item(),\n",
        "        model.likelihood.noise.item()\n",
        "    ))\n",
        "    optimizer.step()"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Iter 1/50 - Loss: 0.906   lengthscale: 0.693   noise: 0.693\n",
            "Iter 2/50 - Loss: 0.873   lengthscale: 0.644   noise: 0.644\n",
            "Iter 3/50 - Loss: 0.839   lengthscale: 0.598   noise: 0.598\n",
            "Iter 4/50 - Loss: 0.802   lengthscale: 0.554   noise: 0.554\n",
            "Iter 5/50 - Loss: 0.762   lengthscale: 0.513   noise: 0.513\n",
            "Iter 6/50 - Loss: 0.717   lengthscale: 0.475   noise: 0.474\n",
            "Iter 7/50 - Loss: 0.671   lengthscale: 0.438   noise: 0.437\n",
            "Iter 8/50 - Loss: 0.624   lengthscale: 0.404   noise: 0.402\n",
            "Iter 9/50 - Loss: 0.579   lengthscale: 0.371   noise: 0.370\n",
            "Iter 10/50 - Loss: 0.537   lengthscale: 0.341   noise: 0.339\n",
            "Iter 11/50 - Loss: 0.498   lengthscale: 0.315   noise: 0.311\n",
            "Iter 12/50 - Loss: 0.462   lengthscale: 0.292   noise: 0.284\n",
            "Iter 13/50 - Loss: 0.427   lengthscale: 0.273   noise: 0.260\n",
            "Iter 14/50 - Loss: 0.393   lengthscale: 0.258   noise: 0.237\n",
            "Iter 15/50 - Loss: 0.359   lengthscale: 0.247   noise: 0.216\n",
            "Iter 16/50 - Loss: 0.325   lengthscale: 0.238   noise: 0.197\n",
            "Iter 17/50 - Loss: 0.291   lengthscale: 0.233   noise: 0.180\n",
            "Iter 18/50 - Loss: 0.257   lengthscale: 0.229   noise: 0.163\n",
            "Iter 19/50 - Loss: 0.223   lengthscale: 0.228   noise: 0.149\n",
            "Iter 20/50 - Loss: 0.190   lengthscale: 0.229   noise: 0.135\n",
            "Iter 21/50 - Loss: 0.157   lengthscale: 0.232   noise: 0.123\n",
            "Iter 22/50 - Loss: 0.126   lengthscale: 0.236   noise: 0.112\n",
            "Iter 23/50 - Loss: 0.096   lengthscale: 0.241   noise: 0.102\n",
            "Iter 24/50 - Loss: 0.067   lengthscale: 0.248   noise: 0.093\n",
            "Iter 25/50 - Loss: 0.040   lengthscale: 0.256   noise: 0.084\n",
            "Iter 26/50 - Loss: 0.016   lengthscale: 0.264   noise: 0.077\n",
            "Iter 27/50 - Loss: -0.005   lengthscale: 0.274   noise: 0.070\n",
            "Iter 28/50 - Loss: -0.024   lengthscale: 0.283   noise: 0.064\n",
            "Iter 29/50 - Loss: -0.039   lengthscale: 0.292   noise: 0.059\n",
            "Iter 30/50 - Loss: -0.051   lengthscale: 0.300   noise: 0.054\n",
            "Iter 31/50 - Loss: -0.059   lengthscale: 0.307   noise: 0.050\n",
            "Iter 32/50 - Loss: -0.065   lengthscale: 0.311   noise: 0.046\n",
            "Iter 33/50 - Loss: -0.069   lengthscale: 0.312   noise: 0.043\n",
            "Iter 34/50 - Loss: -0.071   lengthscale: 0.310   noise: 0.040\n",
            "Iter 35/50 - Loss: -0.072   lengthscale: 0.306   noise: 0.038\n",
            "Iter 36/50 - Loss: -0.071   lengthscale: 0.300   noise: 0.036\n",
            "Iter 37/50 - Loss: -0.069   lengthscale: 0.293   noise: 0.034\n",
            "Iter 38/50 - Loss: -0.066   lengthscale: 0.285   noise: 0.033\n",
            "Iter 39/50 - Loss: -0.063   lengthscale: 0.278   noise: 0.032\n",
            "Iter 40/50 - Loss: -0.059   lengthscale: 0.271   noise: 0.031\n",
            "Iter 41/50 - Loss: -0.056   lengthscale: 0.265   noise: 0.030\n",
            "Iter 42/50 - Loss: -0.054   lengthscale: 0.260   noise: 0.030\n",
            "Iter 43/50 - Loss: -0.053   lengthscale: 0.256   noise: 0.029\n",
            "Iter 44/50 - Loss: -0.053   lengthscale: 0.253   noise: 0.029\n",
            "Iter 45/50 - Loss: -0.054   lengthscale: 0.251   noise: 0.030\n",
            "Iter 46/50 - Loss: -0.056   lengthscale: 0.250   noise: 0.030\n",
            "Iter 47/50 - Loss: -0.058   lengthscale: 0.250   noise: 0.031\n",
            "Iter 48/50 - Loss: -0.061   lengthscale: 0.251   noise: 0.031\n",
            "Iter 49/50 - Loss: -0.064   lengthscale: 0.252   noise: 0.032\n",
            "Iter 50/50 - Loss: -0.066   lengthscale: 0.253   noise: 0.033\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RiDmqGItrRyz",
        "colab_type": "code",
        "outputId": "8eab6948-103f-4504-feda-95eea87f0649",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        }
      },
      "source": [
        "model.state_dict()"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('likelihood.noise_covar.raw_noise', tensor([-3.3824])),\n",
              "             ('mean_module.constant', tensor([0.0588])),\n",
              "             ('covar_module.raw_outputscale', tensor(-0.4108)),\n",
              "             ('covar_module.base_kernel.raw_lengthscale',\n",
              "              tensor([[-1.2372]]))])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S1gMlb1TCM7i",
        "colab_type": "text"
      },
      "source": [
        "## Make predictions with the model\n",
        "\n",
        "In the next cell, we make predictions with the model. To do this, we simply put the model and likelihood in eval mode, and call both modules on the test data.\n",
        "\n",
        "Just as a user defined GP model returns a `MultivariateNormal` containing the prior mean and covariance from forward, a trained GP model in eval mode returns a `MultivariateNormal` containing the posterior mean and covariance. Thus, getting the predictive mean and variance, and then sampling functions from the GP at the given test points could be accomplished with calls like:\n",
        "\n",
        "```python\n",
        "f_preds = model(test_x)\n",
        "y_preds = likelihood(model(test_x))\n",
        "\n",
        "f_mean = f_preds.mean\n",
        "f_var = f_preds.variance\n",
        "f_covar = f_preds.covariance_matrix\n",
        "f_samples = f_preds.sample(sample_shape=torch.Size(1000,))\n",
        "```\n",
        "\n",
        "The `gpytorch.settings.fast_pred_var` context is not needed, but here we are giving a preview of using one of our cool features, getting faster predictive distributions using [LOVE](https://arxiv.org/abs/1803.06058)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m-uGslvNCM7j",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Get into evaluation (predictive posterior) mode\n",
        "model.eval()\n",
        "likelihood.eval()\n",
        "\n",
        "# Test points are regularly spaced along [0,1]\n",
        "# Make predictions by feeding model through likelihood\n",
        "with torch.no_grad(), gpytorch.settings.fast_pred_var():\n",
        "    test_x = torch.linspace(0, 1, 51)\n",
        "    observed_pred = likelihood(model(test_x))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yaRD80ENCM7m",
        "colab_type": "text"
      },
      "source": [
        "## Plot the model fit\n",
        "\n",
        "In the next cell, we plot the mean and confidence region of the Gaussian process model. The `confidence_region` method is a helper method that returns 2 standard deviations above and below the mean."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "aC29j3yLCM7n",
        "colab_type": "code",
        "outputId": "bba21f81-310f-4f9a-b081-8a3d0e67e318",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 378
        }
      },
      "source": [
        "with torch.no_grad():\n",
        "    # Initialize plot\n",
        "    f, ax = plt.subplots(1, 1, figsize=(8, 6))\n",
        "\n",
        "    # Get upper and lower confidence bounds\n",
        "    lower, upper = observed_pred.confidence_region()\n",
        "    # Plot training data as black stars\n",
        "    ax.plot(train_x.numpy(), train_y.numpy(), 'k*')\n",
        "    # Plot predictive means as blue line\n",
        "    ax.plot(test_x.numpy(), observed_pred.mean.numpy(), 'r')\n",
        "    # Shade between the lower and upper confidence bounds\n",
        "    ax.fill_between(test_x.numpy(), lower.numpy(), upper.numpy(), alpha=0.3)\n",
        "    ax.set_ylim([-3, 3])\n",
        "    ax.legend(['Observed Data', 'Mean', 'Confidence'])"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_8GvDdbbCM7t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}