Gaussian Process Regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1><center>Gaussian Process Regression</center></h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='https://juanitorduz.github.io/gaussian_process_reg/' style=\"color:blue;font-size:18px;\"><strong>Tutorial Blog </strong></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set_style(\n",
    "    style='darkgrid', \n",
    "    rc={'axes.facecolor': '.9', 'grid.color': '.8'}\n",
    ")\n",
    "sns.set_palette(palette='deep')\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = [12, 6]\n",
    "plt.rcParams['figure.dpi'] = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate Data Samples\n",
    "\n",
    "We consider the model y = f(x) + ε, where ε∼N(0,σn). Here f does not need to be a linear function of x. As a concrete example, let us consider (1-dim problem)\n",
    "f(x)= sin(4πx)+sin(7πx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define dimension.\n",
    "d = 1\n",
    "# Number of samples (training set). \n",
    "n = 500\n",
    "\n",
    "x = np.linspace(start=0, stop=1, num=n)\n",
    "\n",
    "def f(x):\n",
    "    f = np.sin((4*np.pi)*x) + np.sin((7*np.pi)*x)\n",
    "    return(f)\n",
    "\n",
    "f_x = f(x)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "# Plot function f. \n",
    "sns.lineplot(x=x, y=f_x, color='red', label = 'f(x)', ax=ax)\n",
    "# Plot function components.\n",
    "sns.lineplot(x=x, y=np.sin((4*np.pi)*x), color='orange', label='$\\sin(4 \\pi x)$', alpha=0.3, ax=ax)\n",
    "sns.lineplot(x=x, y=np.sin((7*np.pi)*x), color='purple', label='$\\sin(7 \\pi x)$', alpha=0.3, ax=ax)\n",
    "ax.legend(loc='upper right')\n",
    "ax.set_title(r'Graph of $f(x) = \\sin(4\\pi x) + \\sin(7\\pi x)$')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Next, we generate some training sample observations:\n",
    "\n",
    "# Error standard deviation. \n",
    "sigma_n = 0.4\n",
    "# Errors.\n",
    "epsilon = np.random.normal(loc=0, scale=sigma_n, size=n)\n",
    "# Observed target variable. \n",
    "y = f_x + epsilon\n",
    "# Let us see the error distribution.\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "# Plot errors. \n",
    "sns.distplot(epsilon, ax=ax)\n",
    "ax.set(title='Error Distribution');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now visualize the sample data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "# Plot training data.\n",
    "sns.scatterplot(x=x, y=y, label='training data', ax=ax);\n",
    "# Plot \"true\" linear fit.\n",
    "sns.lineplot(x=x, y=f_x, color='red', label='f(x)', ax=ax);\n",
    "\n",
    "ax.set(title='Sample Data')\n",
    "ax.legend(loc='upper right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now consider test data points on which we want to generate predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_star = 100\n",
    "\n",
    "x_star = np.linspace(start=0, stop=1, num=n_star)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kernel Function\n",
    "Recall that a gaussian process is completely specified by its mean and covariance functions (we usually take the mean equal to zero, although it is not necessary). A common choice is the squared exponential,\n",
    "\n",
    "$$cov(f(x_p),f(x_q))=k_{σf,ℓ}(x_p,x_q)=σ_f \\exp(−\\frac{1}{2ℓ^2}||x_p−x_q||^2) $$\n",
    "\n",
    "where $σ_f$,$ℓ$ > 0 are hyperparameters. Observe that the covariance between two samples are modeled as a function of the inputs.\n",
    "\n",
    "Remark: “It can be shown that the squared exponential covariance function corresponds to a Bayesian linear regression model with an infinite basis functions number of basis function.” ([Gaussian Processes for Machine Learning, Ch 2.2](http://www.gaussianprocess.org/gpml/chapters/RW.pdf))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kernel_function(x, y, sigma_f=1, l=1):\n",
    "    \"\"\"Define squared exponential kernel function.\"\"\"\n",
    "    kernel = sigma_f * np.exp(- (np.linalg.norm(x - y)**2) / (2 * l**2))\n",
    "    return kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = 0.1\n",
    "sigma_f = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute Covariance Matrices\n",
    "\n",
    "A key observation, as illustrated in [Regularized Bayesian Regression as a Gaussian Process](https://juanitorduz.github.io/reg_bayesian_regression/), is that the specification of the covariance function implies a distribution over functions.\n",
    "\n",
    "Let us denote by $K(X,X)∈ M_n(\\mathbb{R}), K(X_∗,X)∈ M_{n_∗ × n}(\\mathbb{R})$ and $K(X_∗,X_∗)∈ M_{n∗}(\\mathbb{R})$ the covariance matrices applies to \n",
    "$x$  and $x_∗$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "\n",
    "def compute_cov_matrices(x, x_star, sigma_f=1, l=1):\n",
    "    \"\"\"\n",
    "    Compute components of the covariance matrix of the joint distribution.\n",
    "    \n",
    "    We follow the notation:\n",
    "    \n",
    "        - K = K(X, X) \n",
    "        - K_star = K(X_*, X)\n",
    "        - K_star2 = K(X_*, X_*)\n",
    "    \"\"\"\n",
    "    n = x.shape[0]\n",
    "    n_star = x_star.shape[0]\n",
    "\n",
    "    K = [kernel_function(i, j, sigma_f=sigma_f, l=l) for (i, j) in itertools.product(x, x)]\n",
    "\n",
    "    K = np.array(K).reshape(n, n)\n",
    "    \n",
    "    K_star2 = [kernel_function(i, j, sigma_f=sigma_f, l=l) for (i, j) in itertools.product(x_star, x_star)]\n",
    "\n",
    "    K_star2 = np.array(K_star2).reshape(n_star, n_star)\n",
    "    \n",
    "    K_star = [kernel_function(i, j, sigma_f=sigma_f, l=l) for (i, j) in itertools.product(x_star, x)]\n",
    "\n",
    "    K_star = np.array(K_star).reshape(n_star, n)\n",
    "    \n",
    "    return (K, K_star2, K_star)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "K, K_star2, K_star = compute_cov_matrices(x, x_star, sigma_f=sigma_f, l=l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "sns.heatmap(data=K, cmap='Blues', ax=ax)\n",
    "ax.set(title='Components of the Kernel Matrix K');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "sns.heatmap(data=K_star2, cmap='Blues', ax=ax)\n",
    "ax.set(title='Components of the Kernel Matrix K_star2');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "sns.heatmap(data=K_star, cmap='Blues', ax=ax)\n",
    "ax.set(title='Components of the Kernel Matrix K_star');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the highest values of the support of all these matrices is localized around the diagonal.\n",
    "\n",
    "### Joint Distribution\n",
    "\n",
    "The joint distribution of $y$  and $f_∗$  is given by\n",
    "\n",
    "## $$ \\begin{pmatrix}\n",
    "\ty\\\\\n",
    "\tf_*\n",
    "\\end{pmatrix}\n",
    " \\sim \\mathcal{N}(0, C) $$\n",
    "\n",
    "\n",
    "where\n",
    "\n",
    "$$ C = \\begin{pmatrix}\n",
    "\tK(X, X) + \\sigma_n^2 I & K(X, X_*)\\\\\n",
    "\tK(X_*, X) & K(X_*, X_*)\n",
    "\\end{pmatrix} $$\n",
    "\n",
    "Observe that we need to add the term $σ^2_nI$ to the upper left component to account for noise (assuming additive independent identically distributed Gaussian noise). We now compute the matrix \n",
    "C\n",
    "."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.concatenate((K + (sigma_n**2)*np.eye(n), K_star), axis=0)\n",
    "b = np.concatenate((K_star.T, K_star2), axis=0)\n",
    "C = np.concatenate((a, b), axis=1)\n",
    "# C.shape == (n + n_star, n + n_star)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us verify that C is symmetric."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.all(C.T == C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also see this visually:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "sns.heatmap(data=C, cmap='Blues', ax=ax)\n",
    "ax.set(title='Components of the Covariance Matrix C')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prior Distribution\n",
    "From the consistency requirement of gaussian processes we know that the prior distribution for $f_∗$ is $\\mathcal{N}(0, K(X_*, X_*))$. Let us visualize some sample functions from this prior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "for i in range(0, 100):\n",
    "    # Sample from prior distribution. \n",
    "    z_star = np.random.multivariate_normal(mean=np.zeros(n_star), cov=K_star2)\n",
    "    # Plot function.\n",
    "    sns.lineplot(x=x_star, y=z_star, color='blue', alpha=0.2, ax=ax)\n",
    "    \n",
    "# Plot \"true\" linear fit.\n",
    "sns.lineplot(x=x, y=f_x, color='red', label='f(x)', ax=ax)\n",
    "ax.set(title='Samples of Prior Distribution')\n",
    "ax.legend(loc='lower right');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Conditional Distribution</h2>\n",
    "<p>As described in our main reference, <em>to get the posterior distribution over functions we need to restrict this joint\n",
    "prior distribution to contain only those functions which agree with the observed\n",
    "data points</em>, that is, we are interested in computing <span class=\"math inline\">\\(f_*|X, y, X_*\\)</span>. Using the results of <a href=\"http://www.gaussianprocess.org/gpml/chapters/RWA.pdf\">Gaussian Processes for Machine Learning, Appendinx A.2</a>, one can show that</p>\n",
    "<p><span class=\"math display\">\\[\n",
    "f_*|X, y, X_* \n",
    "\\sim\n",
    "N(\\bar{f}_*, \\text{cov}(f_*))\n",
    "\\]</span></p>\n",
    "<p>where</p>\n",
    "<p><span class=\"math display\">\\[\n",
    "\\bar{f}_* = K(X_*, X)(K(X, X) + \\sigma^2_n I)^{-1} y \\in \\mathbb{R}^{n_*}\n",
    "\\]</span></p>\n",
    "<p>and</p>\n",
    "<p><span class=\"math display\">\\[\n",
    "\\text{cov}(f_*) = K(X_*, X_*) - K(X_*, X)(K(X, X) + \\sigma^2_n I)^{-1} K(X, X_*) \\in M_{n_*}(\\mathbb{R})\n",
    "\\]</span></p>\n",
    "<p>We now calculate the parameters of the posterior distribution:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gpr_parameters(K, K_star2, K_star, sigma_n):\n",
    "    \"\"\"Compute gaussian regression parameters.\"\"\"\n",
    "    n = K.shape[0]\n",
    "    # Mean.\n",
    "    f_bar_star = np.dot(K_star, np.dot(np.linalg.inv(K + (sigma_n**2)*np.eye(n)), y.reshape([n, d])))\n",
    "    # Covariance.\n",
    "    cov_f_star = K_star2 - np.dot(K_star, np.dot(np.linalg.inv(K + (sigma_n**2)*np.eye(n)), K_star.T))\n",
    "    \n",
    "    return (f_bar_star, cov_f_star)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_bar_star, cov_f_star = compute_gpr_parameters(K, K_star2, K_star, sigma_n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "sns.heatmap(data=cov_f_star, cmap='Blues', ax=ax)\n",
    "ax.set_title('Components of the Covariance Matrix cov_f_star')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now sample from the posterior distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "for i in range(0, 100):\n",
    "    # Sample from posterior distribution. \n",
    "    z_star = np.random.multivariate_normal(mean=f_bar_star.squeeze(), cov=cov_f_star)\n",
    "    # Plot function.\n",
    "    sns.lineplot(x=x_star, y=z_star, color=\"blue\", alpha=0.2, ax=ax);\n",
    "    \n",
    "# Plot \"true\" linear fit.\n",
    "sns.lineplot(x=x, y=f_x, color='red', label = 'f(x)', ax=ax)\n",
    "ax.set(title=f'Samples of Posterior Distribution, sigma_f = {sigma_f} and l = {l}')\n",
    "ax.legend(loc='upper right');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Hyperparameters</h2>\n",
    "<p>We now study the effect of the hyperparameters <span class=\"math inline\">\\(\\sigma_f\\)</span> and <span class=\"math inline\">\\(\\ell\\)</span> of the kernel function defined above.</p>\n",
    "<ul>\n",
    "<li><p>The hyperparameter <span class=\"math inline\">\\(\\sigma_f\\)</span> describes the amplitude of the function.</p></li>\n",
    "<li><p>The hyperparameter <span class=\"math inline\">\\(\\ell\\)</span> is a locality parameter, i.e. how far the points interact.</p></li>\n",
    "</ul>\n",
    "<p>Let us see some concrete examples:</p>\n",
    "<ul>\n",
    "<li><span class=\"math inline\">\\(\\sigma_f = 2\\)</span> and <span class=\"math inline\">\\(\\ell = 1\\)</span></li>\n",
    "</ul>\n",
    "<pre class=\"python\"><code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = 1\n",
    "l = 1\n",
    "sigma_f = 2\n",
    "\n",
    "# Compute covariance matrices. \n",
    "K, K_star2, K_star = compute_cov_matrices(x, x_star, sigma_f=sigma_f, l=l)\n",
    "# Compute gaussian process parameters. \n",
    "f_bar_star, cov_f_star = compute_gpr_parameters(K, K_star2, K_star, sigma_n)\n",
    "\n",
    "# Plot posterior covariance matrix components. \n",
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "sns.heatmap(data=cov_f_star, cmap='Blues', ax=ax)\n",
    "ax.set(title=f'Components of the Covariance Matrix cov_f_star, sigma_f = {sigma_f} and l = {l}');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case the values of the posterior covariance matrix are not that localized. This means that we expect points far away can still have some interaction, i.e. the fit becomes more global. Let us plot the resulting fit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "K, K_star2, K_star = compute_cov_matrices(x, x_star, sigma_f=sigma_f, l=l)\n",
    "\n",
    "f_bar_star, cov_f_star = compute_gpr_parameters(K, K_star2, K_star, sigma_n)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "for i in range(0, 100):\n",
    "    # Sample from posterior distribution. \n",
    "    z_star = np.random.multivariate_normal(mean=f_bar_star.squeeze(), cov=cov_f_star)\n",
    "    # Plot function.\n",
    "    sns.lineplot(x=x_star, y=z_star, color='blue', alpha=0.2, ax=ax);\n",
    "    \n",
    "# Plot \"true\" linear fit.\n",
    "sns.lineplot(x=x, y=f_x, color='red', label='f(x)', ax=ax)\n",
    "ax.set(title=f'Samples of Posterior Distribution, sigma_f = {sigma_f} and l = {l}')\n",
    "ax.legend(loc='upper right');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* σf=2 and ℓ=0.001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "l = 0.001\n",
    "sigma_f = 2\n",
    "\n",
    "# Compute covariance matrices. \n",
    "K, K_star2, K_star = compute_cov_matrices(x, x_star, sigma_f=sigma_f, l=l)\n",
    "# Compute gaussian process parameters. \n",
    "f_bar_star, cov_f_star = compute_gpr_parameters(K, K_star2, K_star, sigma_n)\n",
    "# Plot posterior covariance matrix components. \n",
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "sns.heatmap(data=cov_f_star, cmap='Blues', ax=ax)\n",
    "ax.set(title=f'Components of the Covariance Matrix cov_f_star, sigma_f = {sigma_f} and l = {l}');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In contrast, we see that for these set of hyper parameters the higher values of the posterior covariance matrix are concentrated along the diagonal. This means that we expect points far away to have no effect on each other, i.e. the fit becomes more local. Let us plot the resulting fit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "for i in range(0, 100):\n",
    "    # Sample from posterior distribution. \n",
    "    z_star = np.random.multivariate_normal(mean=f_bar_star.squeeze(), cov=cov_f_star)\n",
    "    # Plot function.\n",
    "    sns.lineplot(x=x_star, y=z_star, color='blue', alpha=0.2, ax=ax);\n",
    "    \n",
    "# Plot \"true\" linear fit.\n",
    "sns.lineplot(x=x, y=f_x, color='red', label='f(x)', ax=ax)\n",
    "ax.set(title=f'Samples of Posterior Distribution, sigma_f = {sigma_f} and l = {l}')\n",
    "ax.legend(loc='upper right');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>GaussianProcessRegressor from Scikit-Learn</h2>\n",
    "<p>Note that in the examples above he had to compute the inverse of <span class=\"math inline\">\\(K(X,X) + \\sigma_n^2 I\\)</span>, which can be computationally expensive for larger data sets. A better approach is to use the Cholesky decomposition of <span class=\"math inline\">\\(K(X,X) + \\sigma_n^2 I\\)</span> as described in <a href=\"http://www.gaussianprocess.org/gpml/chapters/RW2.pdf\">Gaussian Processes for Machine Learning, Ch 2 Algorithm 2.1</a>. This is actually the implementation used by <a href=\"https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.GaussianProcessRegressor.html#sklearn.gaussian_process.GaussianProcessRegressor\">Scikit-Learn</a>. We now describe how to fit a GaussianProcessRegressor model using Scikit-Learn and compare it with the results obtained above. Please refer to the <a href=\"https://scikit-learn.org/stable/auto_examples/gaussian_process/plot_gpr_noisy_targets.html\">docomentation example</a> to get more detailed information.</p>\n",
    "<div id=\"kernel-object\" class=\"section level3\">\n",
    "<h3>Kernel Object</h3>\n",
    "<p>There are my <a href=\"https://scikit-learn.org/stable/modules/classes.html#module-sklearn.gaussian_process\">kernel functions</a> implemented in Scikit-Learn. Let us see how define the squared exponential:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "from sklearn.gaussian_process.kernels import ConstantKernel, RBF\n",
    "\n",
    "# Define kernel parameters. \n",
    "l = 0.1\n",
    "sigma_f = 2\n",
    "\n",
    "# Define kernel object. \n",
    "kernel = ConstantKernel(constant_value=sigma_f,constant_value_bounds=(1e-3, 1e3)) \\\n",
    "            * RBF(length_scale=l, length_scale_bounds=(1e-3, 1e3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ConstantKernel(constant_value=1,constant_value_bounds=(1e-3, 1e3)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>The tuples on each kernel component represent the lower and upper bound of the hyperparameters. The gaussian process fit automatically selects the best hyperparameters which maximize the log-marginal likelihood. The marginal likelihood is the integral of the likelihood times the prior.</p>\n",
    "</div>\n",
    "<div id=\"gaussianprocessregressor\" class=\"section level3\">\n",
    "<h3>GaussianProcessRegressor</h3>\n",
    "<p>Now we define de <a href=\"https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.GaussianProcessRegressor.html\"><code>GaussianProcessRegressor</code></a> object.</p>\n",
    "<pre class=\"python\"><code>\n",
    "\n",
    "**Note:** GaussianProcessRegressor does not allow the specification of mean function which is assumed to be the zero function\n",
    "\n",
    "**Another Resource**\n",
    "[Domino Data Lab](https://blog.dominodatalab.com/fitting-gaussian-process-models-python/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "# Define GaussianProcessRegressor object. \n",
    "# gp = GaussianProcessRegressor(kernel=kernel, alpha=sigma_n**2, n_restarts_optimizer=10)\n",
    "gp = GaussianProcessRegressor(alpha=0.16000000000000003, copy_X_train=True,\n",
    "                         kernel=kernel * RBF(length_scale=0.1),\n",
    "                         n_restarts_optimizer=10, normalize_y=False,\n",
    "                         optimizer='fmin_l_bfgs_b', random_state=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = x.reshape(n, d)\n",
    "X_star = x_star.reshape(n_star, d)\n",
    "# Fit to data using Maximum Likelihood Estimation of the parameters.\n",
    "gp.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make the prediction on test set.\n",
    "y_pred = gp.predict(X_star)\n",
    "# y_pred, sigma = gp.predict(X_star, return_std=True)\n",
    "\n",
    "# Let us plot the prediction.\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "# Plot \"true\" linear fit.\n",
    "sns.lineplot(x=x, y=f_x, color='red', label='f(x)', ax=ax)\n",
    "# Plot prediction. \n",
    "sns.lineplot(x=x_star, y=y_pred, color='green', label='pred', ax=ax)\n",
    "ax.set(title=f'Prediction GaussianProcessRegressor, sigma_f = {sigma_f} and l = {l}')\n",
    "ax.legend(loc='upper right');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we plot this prediction against many samples from the posterior distribution obtained above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "K, K_star2, K_star = compute_cov_matrices(x, x_star, sigma_f = sigma_f, l = l)\n",
    "\n",
    "f_bar_star, cov_f_star = compute_gpr_parameters(K, K_star2, K_star, sigma_n)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "for i in range(0, 100):\n",
    "    # Sample from posterior distribution. \n",
    "    z_star = np.random.multivariate_normal(mean=f_bar_star.squeeze(), cov=cov_f_star)\n",
    "    # Plot function.\n",
    "    sns.lineplot(x=x_star, y=z_star, color='blue', alpha=0.05, ax=ax);\n",
    "    \n",
    "# Plot \"true\" linear fit.\n",
    "sns.lineplot(x=x, y=f_x, color='red', label='f(x)', ax=ax);\n",
    "# Plot prediction. \n",
    "sns.lineplot(x=x_star, y=y_pred, color='green', label='pred', ax=ax);\n",
    "ax.set(title=f'Prediction GaussianProcessRegressor, sigma_f = {sigma_f} and l = {l}')\n",
    "ax.legend(loc='upper right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Credible Interval Interval\n",
    "Let us compute the credible intervals:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate samples from posterior distribution. \n",
    "y_hat_samples = np.random.multivariate_normal(mean=f_bar_star.squeeze(), cov=cov_f_star, size=100)\n",
    "# Compute the mean of the sample. \n",
    "y_hat = np.apply_over_axes(func=np.mean, a=y_hat_samples, axes=0).squeeze()\n",
    "# Compute the standard deviation of the sample. \n",
    "y_hat_sd = np.apply_over_axes(func=np.std, a=y_hat_samples, axes=0).squeeze()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now plot the confidence interval corresponding to a corridor associated with two standard deviations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "# Plot training data.\n",
    "sns.scatterplot(x=x, y=y, label='training data', ax=ax)\n",
    "# Plot corridor. \n",
    "ax.fill_between(\n",
    "    x=x_star, \n",
    "    y1=(y_hat - 2*y_hat_sd), \n",
    "    y2=(y_hat + 2*y_hat_sd), \n",
    "    color='green', \n",
    "    alpha = 0.3, \n",
    "    label='Credible Interval'\n",
    ")\n",
    "# Plot \"true\" linear fit.\n",
    "sns.lineplot(x=x, y=f_x, color='red', label='f(x)', ax=ax);\n",
    "# Plot prediction. \n",
    "sns.lineplot(x=x_star, y=y_pred, color='green', label='pred', ax=ax)\n",
    "ax.set_title('Prediction & Credible Interval, sigma_f = {} and l = {}'.format(sigma_f, l))\n",
    "ax.legend(loc='upper right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary & Final Example\n",
    "In this post we have studied and experimented the fundamentals of gaussian process regression with the intention to gain some intuition about it. Let us finalize with a self-contain example where we only use the tools from Scikit-Learn.\n",
    "\n",
    "**Construct Training Set**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set dimension. \n",
    "d = 1\n",
    "# Number of training points.\n",
    "n = 1000\n",
    "# Length of the training set. \n",
    "L = 2\n",
    "# Generate training features.\n",
    "x = np.linspace(start=0, stop=L, num=n)\n",
    "X = x.reshape(n, d)\n",
    "# Error standar deviation. \n",
    "sigma_n = 0.4\n",
    "# Errors.\n",
    "epsilon = np.random.normal(loc=0, scale=sigma_n, size=n)\n",
    "\n",
    "# Generate non-linear function.\n",
    "def f(x):\n",
    "    f = np.sin((4*np.pi)*x) + np.sin((7*np.pi)*x) + np.sin((3*np.pi)*x) \n",
    "    return(f)\n",
    "\n",
    "f_x = f(x)\n",
    "\n",
    "# Observed target variable. \n",
    "y = f_x + epsilon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Construct Test Set**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_star = n + 300\n",
    "x_star = np.linspace(start=0, stop=(L + 0.5), num=n_star)\n",
    "\n",
    "X_star = x_star.reshape(n_star, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Define Kernel and Model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define kernel parameters. \n",
    "l = 0.1\n",
    "sigma_f = 2\n",
    "\n",
    "# Define kernel object. \n",
    "kernel = ConstantKernel(constant_value=sigma_f, constant_value_bounds=(1e-2, 1e2)) \\\n",
    "            * RBF(length_scale=l, length_scale_bounds=(1e-2, 1e2))\n",
    "# Define GaussianProcessRegressor object. \n",
    "gp = GaussianProcessRegressor(kernel=kernel, alpha=sigma_n**2, n_restarts_optimizer=10, )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Model Fit + Predictions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit to data using Maximum Likelihood Estimation of the parameters.\n",
    "gp.fit(X, y)\n",
    "# Make the prediction on test set.\n",
    "y_pred = gp.predict(X_star)\n",
    "# Generate samples from posterior distribution. \n",
    "y_hat_samples = gp.sample_y(X_star, n_samples=n_star)\n",
    "# Compute the mean of the sample. \n",
    "y_hat = np.apply_over_axes(func=np.mean, a=y_hat_samples, axes=1).squeeze()\n",
    "# Compute the standard deviation of the sample. \n",
    "y_hat_sd = np.apply_over_axes(func=np.std, a=y_hat_samples, axes=1).squeeze()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Visualize Results**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(15, 8))\n",
    "# Plot training data.\n",
    "sns.scatterplot(x=x, y=y, label='training data', ax=ax);\n",
    "# Plot \"true\" linear fit.\n",
    "sns.lineplot(\n",
    "    x=x_star, \n",
    "    y=f(x_star), \n",
    "    color='red', \n",
    "    label='f(x)', \n",
    "    ax=ax\n",
    ")\n",
    "# Plot corridor. \n",
    "ax.fill_between(\n",
    "    x=x_star, \n",
    "    y1=(y_hat - 2*y_hat_sd), \n",
    "    y2=(y_hat + 2*y_hat_sd), \n",
    "    color='green',\n",
    "    alpha=0.3, \n",
    "    label='Credible Interval'\n",
    ")\n",
    "# Plot prediction. \n",
    "sns.lineplot(x=x_star, y=y_pred, color='green', label='pred')\n",
    "ax.set(title='Prediction & Credible Interval')\n",
    "ax.legend(loc='lower left');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Another Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exponential_cov(x, y, params):\n",
    "    return params[0] * np.exp( -0.5 * params[1] * np.subtract.outer(x, y)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conditioning**\n",
    "$$p(x|y) = \\mathcal{N}(\\mu_x + \\Sigma_{xy}\\Sigma_y^{-1}(y - \\mu_y), ~\\Sigma_x - \\Sigma_{xy}\\Sigma_y^{-1}\\Sigma_{xy}^T)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conditional(x_new, x, y, params):\n",
    " \n",
    "    B = exponential_cov(x_new, x, params)  # \\Sigma_xy\n",
    "    C = exponential_cov(x, x, params)  # \\Sigma_y\n",
    "    A = exponential_cov(x_new, x_new, params)  # \\Sigma_x\n",
    "\n",
    "    mu = np.linalg.inv(C).dot(B.T).T.dot(y)\n",
    "    sigma = A - B.dot(np.linalg.inv(C).dot(B.T))\n",
    "\n",
    "    return(mu.squeeze(), sigma.squeeze())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<ErrorbarContainer object of 3 artists>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pylab as plt\n",
    " \n",
    "θ = [1, 10]  # hyperparameters\n",
    "σ_0 = exponential_cov(0, 0, θ)\n",
    "xpts = np.arange(-3, 3, step=0.01)\n",
    "plt.errorbar(xpts, np.zeros(len(xpts)), yerr=σ_0, capsize=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "σ_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.8825059246951147]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1.]\n",
    "y = [np.random.normal(scale=σ_0)]\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f8e330aeb38>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "σ_1 = exponential_cov(x, x, θ)\n",
    " \n",
    "def predict(x, data, kernel, params, sigma, t):\n",
    "    k = [kernel(x, y, params) for y in data]\n",
    "    Sinv = np.linalg.inv(sigma)\n",
    "    y_pred = np.dot(k, Sinv).dot(t)\n",
    "    sigma_new = kernel(x, x, params) - np.dot(k, Sinv).dot(k)\n",
    "    return y_pred, sigma_new\n",
    " \n",
    "x_pred = np.linspace(-3, 3, 1000)\n",
    "predictions = [predict(i, x, exponential_cov, θ, σ_1, y) for i in x_pred]\n",
    "\n",
    "y_pred, sigmas = np.transpose(predictions)\n",
    "plt.errorbar(x_pred, y_pred, yerr=sigmas, capsize=0)\n",
    "plt.plot(x_pred, y_pred, 'g^')\n",
    "plt.plot(x, y, \"ro\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.where(x_pred==1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred[666]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1000,), (1000,))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigmas.shape, y_pred.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# zz = np.zeros(100)\n",
    "# for i in range(100):\n",
    "#     zz[i] = np.random.normal(loc=y_pred.squeeze(), scale=sigmas)\n",
    "# plt.plot(x_pred, zz, 'r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.036494498073746"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m, s = conditional([-0.7], x, y, θ)\n",
    "y2 = np.random.normal(m, s)\n",
    "y2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.append(-0.7)\n",
    "y.append(y2)\n",
    " \n",
    "σ_2 = exponential_cov(x, x, θ)\n",
    "predictions = [predict(i, x, exponential_cov, θ, σ_2, y) for i in x_pred]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f8e32e178d0>]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred, sigmas = np.transpose(predictions)\n",
    "plt.errorbar(x_pred, y_pred, yerr=sigmas, capsize=0)\n",
    "plt.plot(x, y, \"ro\")\n",
    "plt.plot(x_pred, y_pred, 'g^')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.5561484 ,  0.43085762, -0.6150391 , -0.82350262,  0.48581688])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_more = [-2.1, -1.5, 0.3, 1.8, 2.5]\n",
    "mu, s = conditional(x_more, x, y, θ)\n",
    "y_more = np.random.multivariate_normal(mu, s)\n",
    "y_more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f8e3291c2e8>]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x += x_more\n",
    "y += y_more.tolist()\n",
    " \n",
    "σ_new = exponential_cov(x, x, θ)\n",
    "predictions = [predict(i, x, exponential_cov, θ, σ_new, y) for i in x_pred]\n",
    " \n",
    "y_pred, sigmas = np.transpose(predictions)\n",
    "plt.errorbar(x_pred, y_pred, yerr=sigmas, capsize=0)\n",
    "plt.plot(x, y, \"ro\")\n",
    "# plt.plot(x_pred, y_pred, 'g^')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venvTF2",
   "language": "python",
   "name": "venvtf2"
  },
  "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}