Repository: cornellius-gp/gpytorch
Pull request #783 (2019-07-12 21:45:20)

Implement polynomial kernel with derivative support (PolynomialKernelGrad)
Implements `PolynomialKernelGrad` which extends `PolynomialKernel` to have support for derivative observations.


Patch:
diff --git a/docs/source/kernels.rst b/docs/source/kernels.rst
index 7a97ce16..5d001c0c 100644
--- a/docs/source/kernels.rst
+++ b/docs/source/kernels.rst
@@ -59,6 +59,12 @@ Standard Kernels
 .. autoclass:: PolynomialKernel
    :members:
 
+:hidden:`PolynomialKernelGrad`
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. autoclass:: PolynomialKernelGrad
+   :members:
+
 :hidden:`RBFKernel`
 ~~~~~~~~~~~~~~~~~~~
 
diff --git a/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_1d_Polynomial_kernel.ipynb b/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_1d_Polynomial_kernel.ipynb
new file mode 100644
index 00000000..85834507
--- /dev/null
+++ b/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_1d_Polynomial_kernel.ipynb
@@ -0,0 +1,292 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# GPyTorch regression with derivative information\n",
+    "\n",
+    "## Introduction\n",
+    "In this notebook, we show how to train a GP regression model in GPyTorch of an unknown function given function value and derivative observations. We consider modeling the function:\n",
+    "\n",
+    "\\begin{align*}\n",
+    "              y &= \\sin(2x) + cos(x) + \\epsilon \\\\\n",
+    "  \\frac{dy}{dx} &= 2\\cos(2x) - \\sin(x) + \\epsilon \\\\  \n",
+    "       \\epsilon &\\sim \\mathcal{N}(0, 0.5)\n",
+    "\\end{align*}\n",
+    "\n",
+    "using 50 value and derivative observations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import gpytorch\n",
+    "import math\n",
+    "from matplotlib import pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "%matplotlib inline\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setting up the training data\n",
+    "We use 50 uniformly distributed points in the interval $[0, 5 \\pi]$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lb, ub = 0.0, 5*math.pi\n",
+    "n = 50\n",
+    "\n",
+    "train_x = torch.linspace(lb, ub, n).unsqueeze(-1)\n",
+    "train_y = torch.stack([\n",
+    "    torch.sin(2*train_x) + torch.cos(train_x), \n",
+    "    -torch.sin(train_x) + 2*torch.cos(2*train_x)\n",
+    "], -1).squeeze(1)\n",
+    "\n",
+    "train_y += 0.05 * torch.randn(n, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setting up the model\n",
+    "A GP prior on the function values implies a multi-output GP prior on the function values and the partial derivatives, see 9.4 in http://www.gaussianprocess.org/gpml/chapters/RW9.pdf for more details. This allows using a `MultitaskMultivariateNormal` and `MultitaskGaussianLikelihood` to train a GP model from both function values and gradients. The resulting RBF kernel that models the covariance between the values and partial derivatives has been implemented in `RBFKernelGrad` and the extension of a constant mean is implemented in `ConstantMeanGrad`.\n",
+    "\n",
+    "The `RBFKernelGrad` is generally worse conditioned than the `RBFKernel`, so we place a lower bound on the noise parameter to keep the smallest eigenvalues of the kernel matrix away from zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GPModelWithDerivatives(gpytorch.models.ExactGP):\n",
+    "    def __init__(self, train_x, train_y, likelihood):\n",
+    "        super(GPModelWithDerivatives, self).__init__(train_x, train_y, likelihood)\n",
+    "        self.mean_module = gpytorch.means.ConstantMeanGrad()\n",
+    "        self.base_kernel = gpytorch.kernels.PolynomialKernelGrad(power=2)\n",
+    "        self.covar_module = gpytorch.kernels.ScaleKernel(self.base_kernel)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        mean_x = self.mean_module(x)\n",
+    "        covar_x = self.covar_module(x)\n",
+    "        return gpytorch.distributions.MultitaskMultivariateNormal(mean_x, covar_x)\n",
+    "\n",
+    "likelihood = gpytorch.likelihoods.MultitaskGaussianLikelihood(num_tasks=2)  # Value + Derivative\n",
+    "model = GPModelWithDerivatives(train_x, train_y, likelihood)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training the model\n",
+    "The model training is similar to training a standard GP regression model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iter 1/50 - Loss: 93.724   offset: 0.693   noise: 0.693\n",
+      "Iter 2/50 - Loss: 92.825   offset: 0.644   noise: 0.744\n",
+      "Iter 3/50 - Loss: 92.090   offset: 0.598   noise: 0.798\n",
+      "Iter 4/50 - Loss: 91.469   offset: 0.554   noise: 0.852\n",
+      "Iter 5/50 - Loss: 90.969   offset: 0.513   noise: 0.907\n",
+      "Iter 6/50 - Loss: 90.599   offset: 0.474   noise: 0.961\n",
+      "Iter 7/50 - Loss: 90.282   offset: 0.438   noise: 1.013\n",
+      "Iter 8/50 - Loss: 90.035   offset: 0.404   noise: 1.062\n",
+      "Iter 9/50 - Loss: 89.839   offset: 0.373   noise: 1.107\n",
+      "Iter 10/50 - Loss: 89.683   offset: 0.344   noise: 1.147\n",
+      "Iter 11/50 - Loss: 89.550   offset: 0.317   noise: 1.180\n",
+      "Iter 12/50 - Loss: 89.449   offset: 0.292   noise: 1.206\n",
+      "Iter 13/50 - Loss: 89.356   offset: 0.269   noise: 1.226\n",
+      "Iter 14/50 - Loss: 89.259   offset: 0.248   noise: 1.238\n",
+      "Iter 15/50 - Loss: 89.167   offset: 0.228   noise: 1.243\n",
+      "Iter 16/50 - Loss: 89.065   offset: 0.210   noise: 1.243\n",
+      "Iter 17/50 - Loss: 88.967   offset: 0.194   noise: 1.237\n",
+      "Iter 18/50 - Loss: 88.869   offset: 0.178   noise: 1.226\n",
+      "Iter 19/50 - Loss: 88.776   offset: 0.164   noise: 1.212\n",
+      "Iter 20/50 - Loss: 88.686   offset: 0.151   noise: 1.194\n",
+      "Iter 21/50 - Loss: 88.599   offset: 0.139   noise: 1.174\n",
+      "Iter 22/50 - Loss: 88.512   offset: 0.129   noise: 1.153\n",
+      "Iter 23/50 - Loss: 88.433   offset: 0.119   noise: 1.132\n",
+      "Iter 24/50 - Loss: 88.361   offset: 0.109   noise: 1.110\n",
+      "Iter 25/50 - Loss: 88.299   offset: 0.101   noise: 1.090\n",
+      "Iter 26/50 - Loss: 88.242   offset: 0.093   noise: 1.071\n",
+      "Iter 27/50 - Loss: 88.192   offset: 0.086   noise: 1.054\n",
+      "Iter 28/50 - Loss: 88.142   offset: 0.079   noise: 1.041\n",
+      "Iter 29/50 - Loss: 88.098   offset: 0.073   noise: 1.030\n",
+      "Iter 30/50 - Loss: 88.058   offset: 0.068   noise: 1.022\n",
+      "Iter 31/50 - Loss: 88.012   offset: 0.063   noise: 1.018\n",
+      "Iter 32/50 - Loss: 87.968   offset: 0.058   noise: 1.017\n",
+      "Iter 33/50 - Loss: 87.922   offset: 0.054   noise: 1.019\n",
+      "Iter 34/50 - Loss: 87.876   offset: 0.051   noise: 1.023\n",
+      "Iter 35/50 - Loss: 87.832   offset: 0.047   noise: 1.030\n",
+      "Iter 36/50 - Loss: 87.789   offset: 0.044   noise: 1.039\n",
+      "Iter 37/50 - Loss: 87.746   offset: 0.041   noise: 1.049\n",
+      "Iter 38/50 - Loss: 87.707   offset: 0.039   noise: 1.059\n",
+      "Iter 39/50 - Loss: 87.672   offset: 0.036   noise: 1.070\n",
+      "Iter 40/50 - Loss: 87.639   offset: 0.034   noise: 1.081\n",
+      "Iter 41/50 - Loss: 87.608   offset: 0.032   noise: 1.090\n",
+      "Iter 42/50 - Loss: 87.580   offset: 0.031   noise: 1.099\n",
+      "Iter 43/50 - Loss: 87.553   offset: 0.029   noise: 1.106\n",
+      "Iter 44/50 - Loss: 87.526   offset: 0.028   noise: 1.111\n",
+      "Iter 45/50 - Loss: 87.500   offset: 0.027   noise: 1.115\n",
+      "Iter 46/50 - Loss: 87.475   offset: 0.025   noise: 1.116\n",
+      "Iter 47/50 - Loss: 87.449   offset: 0.024   noise: 1.116\n",
+      "Iter 48/50 - Loss: 87.424   offset: 0.023   noise: 1.115\n",
+      "Iter 49/50 - Loss: 87.399   offset: 0.023   noise: 1.112\n",
+      "Iter 50/50 - Loss: 87.375   offset: 0.022   noise: 1.108\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 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",
+    "n_iter = 50\n",
+    "for i in range(n_iter):\n",
+    "    optimizer.zero_grad()\n",
+    "    output = model(train_x)\n",
+    "    loss = -mll(output, train_y)\n",
+    "    loss.backward()\n",
+    "    print('Iter %d/%d - Loss: %.3f   offset: %.3f   noise: %.3f' % (\n",
+    "        i + 1, n_iter, loss.item(),\n",
+    "        model.covar_module.base_kernel.offset.item(),\n",
+    "        model.likelihood.noise.item()\n",
+    "    ))        \n",
+    "    optimizer.step()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Making predictions with the model\n",
+    "Model predictions are also similar to GP regression with only function values, butwe need more CG iterations to get accurate estimates of the predictive variance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Set into eval mode\n",
+    "model.train()\n",
+    "model.eval()\n",
+    "likelihood.eval()\n",
+    "\n",
+    "# Initialize plots\n",
+    "f, (y1_ax, y2_ax) = plt.subplots(1, 2, figsize=(12, 6))\n",
+    "\n",
+    "# Make predictions\n",
+    "with torch.no_grad(), gpytorch.settings.max_cg_iterations(50):\n",
+    "    test_x = torch.linspace(lb, ub, 500)\n",
+    "    predictions = likelihood(model(test_x))\n",
+    "    mean = predictions.mean\n",
+    "    lower, upper = predictions.confidence_region()\n",
+    "    \n",
+    "# Plot training data as black stars\n",
+    "y1_ax.plot(train_x.detach().numpy(), train_y[:, 0].detach().numpy(), 'k*')\n",
+    "# Predictive mean as blue line\n",
+    "y1_ax.plot(test_x.numpy(), mean[:, 0].numpy(), 'b')\n",
+    "# Shade in confidence \n",
+    "y1_ax.fill_between(test_x.numpy(), lower[:, 0].numpy(), upper[:, 0].numpy(), alpha=0.5)\n",
+    "y1_ax.legend(['Observed Values', 'Mean', 'Confidence'])\n",
+    "y1_ax.set_title('Function values')\n",
+    "\n",
+    "# Plot training data as black stars\n",
+    "y2_ax.plot(train_x.detach().numpy(), train_y[:, 1].detach().numpy(), 'k*')\n",
+    "# Predictive mean as blue line\n",
+    "y2_ax.plot(test_x.numpy(), mean[:, 1].numpy(), 'b')\n",
+    "# Shade in confidence \n",
+    "y2_ax.fill_between(test_x.numpy(), lower[:, 1].numpy(), upper[:, 1].numpy(), alpha=0.5)\n",
+    "y2_ax.legend(['Observed Derivatives', 'Mean', 'Confidence'])\n",
+    "y2_ax.set_title('Derivatives')\n",
+    "\n",
+    "None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_2d.ipynb b/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_2d.ipynb
index a8a0c8ce..852df5c8 100644
--- a/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_2d.ipynb
+++ b/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_2d.ipynb
@@ -351,7 +351,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.8"
+   "version": "3.7.3"
   }
  },
  "nbformat": 4,
diff --git a/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_2d_Polynomial_kernel.ipynb b/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_2d_Polynomial_kernel.ipynb
new file mode 100644
index 00000000..b2ba17dd
--- /dev/null
+++ b/examples/10_GP_Regression_Derivative_Information/Simple_GP_Regression_Derivative_Information_2d_Polynomial_kernel.ipynb
@@ -0,0 +1,358 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# GPyTorch regression with derivative information in 2d\n",
+    "\n",
+    "## Introduction\n",
+    "In this notebook, we show how to train a GP regression model in GPyTorch of a 2-dimensional function given function values and derivative observations. We consider modeling the Franke function where the values and derivatives are contaminated with independent $\\mathcal{N}(0, 0.5)$ distributed noise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import gpytorch\n",
+    "import math\n",
+    "from matplotlib import cm\n",
+    "from matplotlib import pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "%matplotlib inline\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Franke function\n",
+    "The following is a vectorized implementation of the 2-dimensional Franke function (https://www.sfu.ca/~ssurjano/franke2d.html)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def franke(X, Y):\n",
+    "    term1 = .75*torch.exp(-((9*X - 2).pow(2) + (9*Y - 2).pow(2))/4)\n",
+    "    term2 = .75*torch.exp(-((9*X + 1).pow(2))/49 - (9*Y + 1)/10)\n",
+    "    term3 = .5*torch.exp(-((9*X - 7).pow(2) + (9*Y - 3).pow(2))/4)\n",
+    "    term4 = .2*torch.exp(-(9*X - 4).pow(2) - (9*Y - 7).pow(2))\n",
+    "    \n",
+    "    f = term1 + term2 + term3 - term4\n",
+    "    dfx = -2*(9*X - 2)*9/4 * term1 - 2*(9*X + 1)*9/49 * term2 + \\\n",
+    "          -2*(9*X - 7)*9/4 * term3 + 2*(9*X - 4)*9 * term4\n",
+    "    dfy = -2*(9*Y - 2)*9/4 * term1 - 9/10 * term2 + \\\n",
+    "          -2*(9*Y - 3)*9/4 * term3 + 2*(9*Y - 7)*9 * term4\n",
+    "    \n",
+    "    return f, dfx, dfy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setting up the training data\n",
+    "We use a grid with 100 points in $[0,1] \\times [0,1]$ with 10 uniformly distributed points per dimension."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "xv, yv = torch.meshgrid([torch.linspace(0, 1, 10), torch.linspace(0, 1, 10)])\n",
+    "train_x = torch.cat((\n",
+    "    xv.contiguous().view(xv.numel(), 1), \n",
+    "    yv.contiguous().view(yv.numel(), 1)),\n",
+    "    dim=1\n",
+    ")\n",
+    "\n",
+    "f, dfx, dfy = franke(train_x[:, 0], train_x[:, 1])\n",
+    "train_y = torch.stack([f, dfx, dfy], -1).squeeze(1)\n",
+    "\n",
+    "train_y += 0.05 * torch.randn(train_y.size()) # Add noise to both values and gradients"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setting up the model\n",
+    "A GP prior on the function values implies a multi-output GP prior on the function values and the partial derivatives, see 9.4 in http://www.gaussianprocess.org/gpml/chapters/RW9.pdf for more details. This allows using a `MultitaskMultivariateNormal` and `MultitaskGaussianLikelihood` to train a GP model from both function values and gradients. The resulting RBF kernel that models the covariance between the values and partial derivatives has been implemented in `RBFKernelGrad` and the extension of a constant mean is implemented in `ConstantMeanGrad`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "class GPModelWithDerivatives(gpytorch.models.ExactGP):\n",
+    "    def __init__(self, train_x, train_y, likelihood):\n",
+    "        super(GPModelWithDerivatives, self).__init__(train_x, train_y, likelihood)\n",
+    "        self.mean_module = gpytorch.means.ConstantMeanGrad()\n",
+    "        self.base_kernel = gpytorch.kernels.PolynomialKernelGrad(power=2)\n",
+    "        self.covar_module = gpytorch.kernels.ScaleKernel(self.base_kernel)\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        mean_x = self.mean_module(x)\n",
+    "        covar_x = self.covar_module(x)\n",
+    "        return gpytorch.distributions.MultitaskMultivariateNormal(mean_x, covar_x)\n",
+    "\n",
+    "likelihood = gpytorch.likelihoods.MultitaskGaussianLikelihood(num_tasks=3)  # Value + x-derivative + y-derivative\n",
+    "model = GPModelWithDerivatives(train_x, train_y, likelihood)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training the model\n",
+    "The model training is similar to training a standard GP regression model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iter 1/100 - Loss: 133.388   offset: 0.693   noise: 0.693\n",
+      "Iter 2/100 - Loss: 133.050   offset: 0.668   noise: 0.669\n",
+      "Iter 3/100 - Loss: 132.400   offset: 0.645   noise: 0.645\n",
+      "Iter 4/100 - Loss: 130.977   offset: 0.622   noise: 0.621\n",
+      "Iter 5/100 - Loss: 129.276   offset: 0.600   noise: 0.598\n",
+      "Iter 6/100 - Loss: 128.238   offset: 0.578   noise: 0.576\n",
+      "Iter 7/100 - Loss: 128.037   offset: 0.558   noise: 0.555\n",
+      "Iter 8/100 - Loss: 127.009   offset: 0.537   noise: 0.534\n",
+      "Iter 9/100 - Loss: 125.708   offset: 0.517   noise: 0.514\n",
+      "Iter 10/100 - Loss: 125.870   offset: 0.498   noise: 0.495\n",
+      "Iter 11/100 - Loss: 124.483   offset: 0.479   noise: 0.476\n",
+      "Iter 12/100 - Loss: 123.123   offset: 0.460   noise: 0.458\n",
+      "Iter 13/100 - Loss: 123.445   offset: 0.442   noise: 0.441\n",
+      "Iter 14/100 - Loss: 121.856   offset: 0.425   noise: 0.424\n",
+      "Iter 15/100 - Loss: 122.067   offset: 0.408   noise: 0.409\n",
+      "Iter 16/100 - Loss: 121.626   offset: 0.392   noise: 0.394\n",
+      "Iter 17/100 - Loss: 120.576   offset: 0.376   noise: 0.379\n",
+      "Iter 18/100 - Loss: 120.080   offset: 0.360   noise: 0.366\n",
+      "Iter 19/100 - Loss: 119.255   offset: 0.345   noise: 0.352\n",
+      "Iter 20/100 - Loss: 117.712   offset: 0.330   noise: 0.340\n",
+      "Iter 21/100 - Loss: 117.911   offset: 0.316   noise: 0.328\n",
+      "Iter 22/100 - Loss: 118.118   offset: 0.303   noise: 0.317\n",
+      "Iter 23/100 - Loss: 117.196   offset: 0.290   noise: 0.306\n",
+      "Iter 24/100 - Loss: 115.636   offset: 0.278   noise: 0.296\n",
+      "Iter 25/100 - Loss: 115.403   offset: 0.265   noise: 0.285\n",
+      "Iter 26/100 - Loss: 114.443   offset: 0.254   noise: 0.276\n",
+      "Iter 27/100 - Loss: 114.576   offset: 0.244   noise: 0.266\n",
+      "Iter 28/100 - Loss: 113.681   offset: 0.233   noise: 0.257\n",
+      "Iter 29/100 - Loss: 112.765   offset: 0.223   noise: 0.248\n",
+      "Iter 30/100 - Loss: 112.422   offset: 0.214   noise: 0.240\n",
+      "Iter 31/100 - Loss: 110.949   offset: 0.205   noise: 0.231\n",
+      "Iter 32/100 - Loss: 110.494   offset: 0.196   noise: 0.223\n",
+      "Iter 33/100 - Loss: 110.101   offset: 0.189   noise: 0.214\n",
+      "Iter 34/100 - Loss: 109.204   offset: 0.181   noise: 0.206\n",
+      "Iter 35/100 - Loss: 108.897   offset: 0.174   noise: 0.198\n",
+      "Iter 36/100 - Loss: 107.919   offset: 0.167   noise: 0.191\n",
+      "Iter 37/100 - Loss: 107.100   offset: 0.161   noise: 0.183\n",
+      "Iter 38/100 - Loss: 106.777   offset: 0.155   noise: 0.175\n",
+      "Iter 39/100 - Loss: 106.262   offset: 0.149   noise: 0.168\n",
+      "Iter 40/100 - Loss: 105.564   offset: 0.144   noise: 0.161\n",
+      "Iter 41/100 - Loss: 106.274   offset: 0.140   noise: 0.154\n",
+      "Iter 42/100 - Loss: 103.915   offset: 0.134   noise: 0.147\n",
+      "Iter 43/100 - Loss: 102.595   offset: 0.130   noise: 0.141\n",
+      "Iter 44/100 - Loss: 102.076   offset: 0.126   noise: 0.134\n",
+      "Iter 45/100 - Loss: 101.620   offset: 0.121   noise: 0.128\n",
+      "Iter 46/100 - Loss: 101.127   offset: 0.118   noise: 0.122\n",
+      "Iter 47/100 - Loss: 99.758   offset: 0.114   noise: 0.116\n",
+      "Iter 48/100 - Loss: 99.445   offset: 0.110   noise: 0.111\n",
+      "Iter 49/100 - Loss: 99.830   offset: 0.107   noise: 0.106\n",
+      "Iter 50/100 - Loss: 99.104   offset: 0.103   noise: 0.101\n",
+      "Iter 51/100 - Loss: 97.977   offset: 0.100   noise: 0.096\n",
+      "Iter 52/100 - Loss: 97.119   offset: 0.096   noise: 0.091\n",
+      "Iter 53/100 - Loss: 96.406   offset: 0.093   noise: 0.087\n",
+      "Iter 54/100 - Loss: 96.264   offset: 0.091   noise: 0.082\n",
+      "Iter 55/100 - Loss: 94.711   offset: 0.088   noise: 0.078\n",
+      "Iter 56/100 - Loss: 94.982   offset: 0.086   noise: 0.075\n",
+      "Iter 57/100 - Loss: 93.965   offset: 0.084   noise: 0.071\n",
+      "Iter 58/100 - Loss: 92.833   offset: 0.082   noise: 0.068\n",
+      "Iter 59/100 - Loss: 92.222   offset: 0.081   noise: 0.064\n",
+      "Iter 60/100 - Loss: 92.347   offset: 0.080   noise: 0.061\n",
+      "Iter 61/100 - Loss: 91.647   offset: 0.078   noise: 0.058\n",
+      "Iter 62/100 - Loss: 90.827   offset: 0.077   noise: 0.056\n",
+      "Iter 63/100 - Loss: 89.901   offset: 0.076   noise: 0.053\n",
+      "Iter 64/100 - Loss: 89.392   offset: 0.075   noise: 0.050\n",
+      "Iter 65/100 - Loss: 88.490   offset: 0.075   noise: 0.048\n",
+      "Iter 66/100 - Loss: 88.222   offset: 0.074   noise: 0.046\n",
+      "Iter 67/100 - Loss: 88.573   offset: 0.073   noise: 0.044\n",
+      "Iter 68/100 - Loss: 87.199   offset: 0.073   noise: 0.042\n",
+      "Iter 69/100 - Loss: 87.355   offset: 0.073   noise: 0.040\n",
+      "Iter 70/100 - Loss: 86.861   offset: 0.072   noise: 0.038\n",
+      "Iter 71/100 - Loss: 85.874   offset: 0.072   noise: 0.036\n",
+      "Iter 72/100 - Loss: 85.730   offset: 0.072   noise: 0.035\n",
+      "Iter 73/100 - Loss: 84.800   offset: 0.072   noise: 0.033\n",
+      "Iter 74/100 - Loss: 84.612   offset: 0.072   noise: 0.032\n",
+      "Iter 75/100 - Loss: 84.215   offset: 0.072   noise: 0.031\n",
+      "Iter 76/100 - Loss: 84.063   offset: 0.072   noise: 0.029\n",
+      "Iter 77/100 - Loss: 84.007   offset: 0.073   noise: 0.028\n",
+      "Iter 78/100 - Loss: 83.099   offset: 0.074   noise: 0.027\n",
+      "Iter 79/100 - Loss: 83.234   offset: 0.075   noise: 0.026\n",
+      "Iter 80/100 - Loss: 82.187   offset: 0.076   noise: 0.025\n",
+      "Iter 81/100 - Loss: 82.020   offset: 0.077   noise: 0.024\n",
+      "Iter 82/100 - Loss: 82.789   offset: 0.077   noise: 0.023\n",
+      "Iter 83/100 - Loss: 82.131   offset: 0.078   noise: 0.022\n",
+      "Iter 84/100 - Loss: 81.481   offset: 0.079   noise: 0.021\n",
+      "Iter 85/100 - Loss: 81.546   offset: 0.079   noise: 0.021\n",
+      "Iter 86/100 - Loss: 80.771   offset: 0.080   noise: 0.020\n",
+      "Iter 87/100 - Loss: 80.939   offset: 0.080   noise: 0.019\n",
+      "Iter 88/100 - Loss: 80.208   offset: 0.081   noise: 0.019\n",
+      "Iter 89/100 - Loss: 81.250   offset: 0.082   noise: 0.018\n",
+      "Iter 90/100 - Loss: 80.921   offset: 0.083   noise: 0.018\n",
+      "Iter 91/100 - Loss: 81.127   offset: 0.084   noise: 0.017\n",
+      "Iter 92/100 - Loss: 79.736   offset: 0.085   noise: 0.017\n",
+      "Iter 93/100 - Loss: 81.718   offset: 0.085   noise: 0.016\n",
+      "Iter 94/100 - Loss: 80.228   offset: 0.086   noise: 0.016\n",
+      "Iter 95/100 - Loss: 79.738   offset: 0.086   noise: 0.015\n",
+      "Iter 96/100 - Loss: 80.034   offset: 0.087   noise: 0.015\n",
+      "Iter 97/100 - Loss: 80.193   offset: 0.089   noise: 0.015\n",
+      "Iter 98/100 - Loss: 80.248   offset: 0.090   noise: 0.014\n",
+      "Iter 99/100 - Loss: 79.778   offset: 0.090   noise: 0.014\n",
+      "Iter 100/100 - Loss: 79.247   offset: 0.091   noise: 0.014\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 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.05)\n",
+    "\n",
+    "# \"Loss\" for GPs - the marginal log likelihood\n",
+    "mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)\n",
+    "\n",
+    "n_iter = 100\n",
+    "for i in range(n_iter):\n",
+    "    optimizer.zero_grad()\n",
+    "    output = model(train_x)\n",
+    "    loss = -mll(output, train_y)\n",
+    "    loss.backward()\n",
+    "    print(\"Iter %d/%d - Loss: %.3f   offset: %.3f   noise: %.3f\" % (\n",
+    "        i + 1, n_iter, loss.item(),\n",
+    "        model.covar_module.base_kernel.offset.item(),\n",
+    "        model.likelihood.noise.item()\n",
+    "    ))\n",
+    "    optimizer.step()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Making predictions with the model\n",
+    "Model predictions are also similar to GP regression with only function values, but we need more CG iterations to get accurate estimates of the predictive variance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x720 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Set into eval mode\n",
+    "model.eval()\n",
+    "likelihood.eval()\n",
+    "\n",
+    "# Initialize plots\n",
+    "fig, ax = plt.subplots(2, 3, figsize=(14, 10))\n",
+    "\n",
+    "# Test points\n",
+    "n1, n2 = 50, 50\n",
+    "xv, yv = torch.meshgrid([torch.linspace(0, 1, n1), torch.linspace(0, 1, n2)])\n",
+    "f, dfx, dfy = franke(xv, yv)\n",
+    "\n",
+    "# Make predictions\n",
+    "with torch.no_grad(), gpytorch.settings.fast_computations(log_prob=False, covar_root_decomposition=False):\n",
+    "    test_x = torch.stack([xv.reshape(n1*n2, 1), yv.reshape(n1*n2, 1)], -1).squeeze(1)\n",
+    "    predictions = likelihood(model(test_x))\n",
+    "    mean = predictions.mean\n",
+    "\n",
+    "extent = (xv.min(), xv.max(), yv.max(), yv.min())\n",
+    "ax[0, 0].imshow(f, extent=extent, cmap=cm.jet)\n",
+    "ax[0, 0].set_title('True values')\n",
+    "ax[0, 1].imshow(dfx, extent=extent, cmap=cm.jet)\n",
+    "ax[0, 1].set_title('True x-derivatives')\n",
+    "ax[0, 2].imshow(dfy, extent=extent, cmap=cm.jet)\n",
+    "ax[0, 2].set_title('True y-derivatives')\n",
+    "\n",
+    "ax[1, 0].imshow(mean[:, 0].detach().numpy().reshape(n1, n2), extent=extent, cmap=cm.jet)\n",
+    "ax[1, 0].set_title('Predicted values')\n",
+    "ax[1, 1].imshow(mean[:, 1].detach().numpy().reshape(n1, n2), extent=extent, cmap=cm.jet)\n",
+    "ax[1, 1].set_title('Predicted x-derivatives')\n",
+    "ax[1, 2].imshow(mean[:, 2].detach().numpy().reshape(n1, n2), extent=extent, cmap=cm.jet)\n",
+    "ax[1, 2].set_title('Predicted y-derivatives')\n",
+    "\n",
+    "None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/10_GP_Regression_Derivative_Information/index.rst b/examples/10_GP_Regression_Derivative_Information/index.rst
index c4aa053e..aeb36b08 100644
--- a/examples/10_GP_Regression_Derivative_Information/index.rst
+++ b/examples/10_GP_Regression_Derivative_Information/index.rst
@@ -6,4 +6,6 @@
    :hidden:
 
    Simple_GP_Regression_Derivative_Information_1d.ipynb
+   Simple_GP_Regression_Derivative_Information_1d_Polynomial_kernel.ipynb
    Simple_GP_Regression_Derivative_Information_2d.ipynb
+   Simple_GP_Regression_Derivative_Information_2d_Polynomial_kernel.ipynb
diff --git a/gpytorch/kernels/__init__.py b/gpytorch/kernels/__init__.py
index c553bdea..46563a1d 100644
--- a/gpytorch/kernels/__init__.py
+++ b/gpytorch/kernels/__init__.py
@@ -15,6 +15,7 @@ from .matern_kernel import MaternKernel
 from .multitask_kernel import MultitaskKernel
 from .periodic_kernel import PeriodicKernel
 from .polynomial_kernel import PolynomialKernel
+from .polynomial_kernel_grad import PolynomialKernelGrad
 from .product_structure_kernel import ProductStructureKernel
 from .rbf_kernel import RBFKernel
 from .rbf_kernel_grad import RBFKernelGrad
@@ -40,6 +41,7 @@ __all__ = [
     "MultitaskKernel",
     "PeriodicKernel",
     "PolynomialKernel",
+    "PolynomialKernelGrad",
     "ProductKernel",
     "ProductStructureKernel",
     "RBFKernel",
diff --git a/gpytorch/kernels/polynomial_kernel_grad.py b/gpytorch/kernels/polynomial_kernel_grad.py
new file mode 100644
index 00000000..0c837f1c
--- /dev/null
+++ b/gpytorch/kernels/polynomial_kernel_grad.py
@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+
+import torch
+from .polynomial_kernel import PolynomialKernel
+from typing import Optional
+
+
+class PolynomialKernelGrad(PolynomialKernel):
+    def forward(
+        self,
+        x1: torch.Tensor,
+        x2: torch.Tensor,
+        diag: Optional[bool] = False,
+        last_dim_is_batch: Optional[bool] = False,
+        **params
+    ) -> torch.Tensor:
+        offset = self.offset.view(*self.batch_shape, 1, 1)
+
+        batch_shape = x1.shape[:-2]
+        n1, d = x1.shape[-2:]
+        n2 = x2.shape[-2]
+
+        if diag:
+            base_diag = (x1 * x2).sum(dim=-1) + self.offset
+            K11_diag = base_diag.pow(self.power)
+
+            all_outers_diag = (x1 * x2).transpose(-2, -1).contiguous().view(*batch_shape, -1)
+            K22_base_diag = self.power * (self.power - 1) * base_diag.pow(self.power - 2)
+            K12_base_diag = self.power * base_diag.pow(self.power - 1)
+
+            K22_diag = all_outers_diag * K22_base_diag.repeat(d) + K12_base_diag.repeat(d)
+
+            return torch.cat([K11_diag, K22_diag], dim=-1)
+        else:
+            base_inner_prod = torch.matmul(x1, x2.transpose(-2, -1)) + offset
+            K11 = base_inner_prod.pow(self.power)
+
+            K12_base = self.power * base_inner_prod.pow(self.power - 1)
+            K12 = torch.zeros(*batch_shape, n1, n2 * d)
+
+            ones_ = torch.ones(*batch_shape, d, 1, n2, dtype=K12.dtype, device=K12.device)
+            K12_outer_prods = torch.matmul(x1.transpose(-2, -1).unsqueeze(-1), ones_)
+            K12 = (
+                (K12_base.unsqueeze(-3) * K12_outer_prods).transpose(-3, -2).contiguous().view(*batch_shape, n1, d * n2)
+            )
+
+            ones_ = torch.ones(*batch_shape, d, n1, 1, dtype=K12.dtype, device=K12.device)
+            K21_outer_prods = torch.matmul(ones_, x2.transpose(-2, -1).unsqueeze(-2))
+            K21 = (K12_base.unsqueeze(-3) * K21_outer_prods).view(*batch_shape, d * n1, n2)
+
+            K22_base = self.power * (self.power - 1) * base_inner_prod.pow(self.power - 2)
+            K22 = torch.zeros(*batch_shape, n1 * d, n2 * d)
+            all_outers = x1.unsqueeze(-2).unsqueeze(-2).transpose(-2, -1).matmul(x2.unsqueeze(-3).unsqueeze(-2))
+            all_outers = all_outers.transpose(-4, -2).transpose(-3, -1)
+            K22 = K22_base.unsqueeze(-3).unsqueeze(-3) * all_outers  # d x d x n1 x n2
+
+            # Can't avoid this for loop without unnecessary memory duplication, which is worse.
+            for i in range(d):
+                K22[..., i, i, :, :] = K22[..., i, i, :, :] + K12_base
+
+            K22 = K22.transpose(-4, -3).transpose(-3, -2).contiguous().view(*batch_shape, n1 * d, n2 * d)
+
+            K = torch.cat([torch.cat([K11, K12], dim=-1), torch.cat([K21, K22], dim=-1)], dim=-2)
+
+            # Apply perfect shuffle
+            pi1 = torch.arange(n1 * (d + 1)).view(d + 1, n1).t().contiguous().view((n1 * (d + 1)))
+            pi2 = torch.arange(n2 * (d + 1)).view(d + 1, n2).t().contiguous().view((n2 * (d + 1)))
+            K = K[..., pi1, :][..., :, pi2]
+
+            return K
+
+    def num_outputs_per_input(self, x1, x2):
+        return x1.size(-1) + 1


Test patch:
diff --git a/test/kernels/test_polynomial_kernel_grad.py b/test/kernels/test_polynomial_kernel_grad.py
new file mode 100644
index 00000000..9a6dc64f
--- /dev/null
+++ b/test/kernels/test_polynomial_kernel_grad.py
@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+
+import unittest
+from gpytorch.kernels import PolynomialKernelGrad
+from gpytorch.test.base_kernel_test_case import BaseKernelTestCase
+
+
+class TestPolynomialKernel(unittest.TestCase, BaseKernelTestCase):
+    def create_kernel_no_ard(self, **kwargs):
+        return PolynomialKernelGrad(power=2, **kwargs)
+
+
+if __name__ == "__main__":
+    unittest.main()