Comparison SGPR models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2d150b22",
   "metadata": {},
   "source": [
    "# Sparse Gaussian Process: an exploration"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6de4057",
   "metadata": {},
   "source": [
    "**Computational Statistics Project (2021-22). Jaime Enríquez Ballesteros.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10b9456e",
   "metadata": {},
   "source": [
    "\"*Gaussian process (GP) models are flexible probabilistic nonparametric models for regression,\n",
    "classification and other tasks. Unfortunately they suffer from computational intractability for\n",
    "large data sets. Over the past decade there have been many different approximations\n",
    "developed to reduce this cost. Most of these can be termed global approximations, in that they\n",
    "try to summarize all the training data via a small set of support points. A different approach is\n",
    "that of local regression, where many local experts account for their own part of space. In this\n",
    "project we are interested to study the regimes in which these different approaches work well\n",
    "or fail, and then apply a new sparse GP approximation which is a combination of both the\n",
    "global and local approaches, and look extremely promising.*\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88436c0b",
   "metadata": {},
   "source": [
    "General imports:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "225283a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import GPflow.gpflow as gpflow\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from GPflow.gpflow.config import default_float, default_jitter\n",
    "from GPflow.gpflow.utilities import print_summary, set_trainable, to_default_float\n",
    "from GPflow.gpflow.models import maximum_log_likelihood_objective, training_loss_closure\n",
    "from GPflow.gpflow.ci_utils import ci_niter\n",
    "\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "from timeit import default_timer as timer\n",
    "\n",
    "import scipy.io"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a87cf5cf",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1fa7ec4",
   "metadata": {},
   "source": [
    "This project covers different techniques which might be used when wanting to use a Gaussian Process Regression while having a big dataset. As it will be shown, this is a big problem since as the dataset being used gets bigger, the problem becomes computationally intractable.\n",
    "\n",
    "The solution at hand is that of Sparse Gaussian Process Regression, which try to approximate the posterior distribution of the real Gaussian Process Regression model without loosing too much information about the data.Two main groups can be distinguished: local and global methods. Several models have been proposed which combine \"*the best of both worlds*\": a combination between both. All of these will be explained in the following sections.\n",
    "\n",
    "The project is focused in understanding GPR and SGPR, with the help of the articles by *Snelson and Ghahramani(2007)* and *Titsias (2009)* (found at the bottom of the document). The principal focus is made on the former. A reproducibility objective seems interesting with regard to this articles, as well as an expansion with an external database.\n",
    "\n",
    "The programming framework used to model Gaussian Processes is *GPFlow* (https://www.gpflow.org/): similar to GPyTorch, only implemented through TensorFlow.\n",
    "\n",
    "As a sidenote about the framework, we have to take into mind that not EVERY possibility is available among the huge world of Gaussian Processes. It is also a young framework, with little documentation.\n",
    "\n",
    "To compress these ideas in a single list of objectives, we have:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6ac2137",
   "metadata": {},
   "source": [
    "**Objectives of the project:**\n",
    "1. Understand Sparse Gaussian Process Regression on big volume datasets.\n",
    "2. Understand how they are implemented in GPFlow library and the different models we can find.\n",
    "3. Try to reproduce experimentation on *Snelson & Ghahramani* (2007) and *Titsias* (2009) to understand how these models work."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c7c96fa",
   "metadata": {},
   "source": [
    "### General Functions implemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e7b71360",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def plot_univariate(model, color, ax, lims=[-1,11], show_xs=True, show_ind_locations=True):\n",
    "    x = model.data[0]\n",
    "    y = model.data[1]\n",
    "    xx = np.linspace(lims[0], lims[1], 100).reshape(-1, 1)\n",
    "    mu, var = model.predict_y(xx)\n",
    "    ax.plot(xx, mu, color, lw=2)\n",
    "    ax.fill_between(\n",
    "        xx[:, 0],\n",
    "        mu[:, 0] - 1.96 * np.sqrt(var[:, 0]),\n",
    "        mu[:, 0] + 1.96 * np.sqrt(var[:, 0]),\n",
    "        color=color,\n",
    "        alpha=0.2,\n",
    "    )\n",
    "    if show_xs:\n",
    "        ax.plot(x, y, \"k,\", mew=2)\n",
    "    if show_ind_locations:\n",
    "        try:\n",
    "            ax.plot(np.array(model.inducing_variable.variables[0]),\n",
    "                    np.repeat(min(mu[:, 0] - 1.96 * np.sqrt(var[:, 0])) - 1, N_ind),\n",
    "                    'rx')\n",
    "        except:\n",
    "            pass\n",
    "    # Plot title\n",
    "    ax.set_title(type(model).__name__)\n",
    "    ax.set_xlim(lims[0], lims[1])\n",
    "\n",
    "\n",
    "def create_models(data,\n",
    "                  inducing_variable,\n",
    "                  optimize=True,\n",
    "                  opt=gpflow.optimizers.Scipy(),  # BFGS\n",
    "                  niter=100,\n",
    "                  verbose=False\n",
    "                  ):\n",
    "    n_dim=data[0].shape[1]\n",
    "    kernel = gpflow.kernels.Matern32(lengthscales=np.ones(n_dim))\n",
    "    m1 = gpflow.models.GPR(data, kernel=kernel)\n",
    "\n",
    "    kernel = gpflow.kernels.Matern32(lengthscales=np.ones(n_dim))\n",
    "    m2 = gpflow.models.SGPR(\n",
    "        data, kernel=kernel, inducing_variable=inducing_variable\n",
    "    )\n",
    "    set_trainable(m2.inducing_variable, False)\n",
    "\n",
    "    kernel = gpflow.kernels.Matern32(lengthscales=np.ones(n_dim))\n",
    "    m3 = gpflow.models.GPRFITC(\n",
    "        data, kernel=kernel, inducing_variable=inducing_variable\n",
    "    )\n",
    "    set_trainable(m3.inducing_variable, False)\n",
    "\n",
    "    kernel = gpflow.kernels.Matern32(lengthscales=np.ones(n_dim))\n",
    "    m4 = gpflow.models.GPRPITC(\n",
    "        data, kernel=kernel, inducing_variable=inducing_variable\n",
    "    )\n",
    "    set_trainable(m4.inducing_variable, False)\n",
    "\n",
    "\n",
    "    models = [m1,m2,m3, m4]\n",
    "\n",
    "    if verbose:\n",
    "        for model in models:\n",
    "            print_summary(model)\n",
    "\n",
    "    times = []\n",
    "    if optimize:\n",
    "        # Optimize models\n",
    "        for model in models:\n",
    "            print(\"Starting training of \", type(model).__name__)\n",
    "            loss_closure = training_loss_closure(model, data)\n",
    "            start = timer()\n",
    "            opt.minimize(\n",
    "                loss_closure,\n",
    "                variables=model.trainable_variables,\n",
    "                options=dict(maxiter=ci_niter(100))\n",
    "            )\n",
    "            end = timer()\n",
    "            print(\"Finished training of \", type(model).__name__)\n",
    "            times.append(end-start)\n",
    "\n",
    "\n",
    "    return models, times\n",
    "\n",
    "\n",
    "def create_models_md(data,\n",
    "                  inducing_variable,\n",
    "                  optimize=True,\n",
    "                  opt=gpflow.optimizers.Scipy(),  # BFGS\n",
    "                  niter=100,\n",
    "                  verbose=False\n",
    "                  ):\n",
    "    n_dim=data[0].shape[1]\n",
    "\n",
    "    kernel = gpflow.kernels.Matern32(lengthscales=np.ones(n_dim))\n",
    "    m2 = gpflow.models.SGPR(\n",
    "        data, kernel=kernel, inducing_variable=inducing_variable\n",
    "    )\n",
    "    set_trainable(m2.inducing_variable, False)\n",
    "\n",
    "    kernel = gpflow.kernels.Matern32(lengthscales=np.ones(n_dim))\n",
    "    m3 = gpflow.models.GPRFITC(\n",
    "        data, kernel=kernel, inducing_variable=inducing_variable\n",
    "    )\n",
    "    set_trainable(m3.inducing_variable, False)\n",
    "\n",
    "    models = [m2,m3]\n",
    "\n",
    "    if verbose:\n",
    "        for model in models:\n",
    "            print_summary(model)\n",
    "\n",
    "    times = []\n",
    "    if optimize:\n",
    "        # Optimize models\n",
    "        for model in models:\n",
    "            print(\"Starting training of \", type(model).__name__)\n",
    "            loss_closure = training_loss_closure(model, data)\n",
    "            start = timer()\n",
    "            opt.minimize(\n",
    "                loss_closure,\n",
    "                variables=model.trainable_variables,\n",
    "                options=dict(maxiter=ci_niter(100))\n",
    "            )\n",
    "            end = timer()\n",
    "            print(\"Finished training of \", type(model).__name__)\n",
    "            times.append(end-start)\n",
    "\n",
    "\n",
    "    return models, times\n",
    "\n",
    "\n",
    "# m.predict_f -> returns the mean and variance of 𝑓 at the points Xnew\n",
    "# m.predict_f_samples -> returns samples of the latent function.\n",
    "# m.predict_y -> returns the mean and variance of a new data point (that is, it includes the noise variance).\n",
    "def mse_test(model, test_data):\n",
    "    test_set, test_labels = test_data\n",
    "    X_t = tf.convert_to_tensor(test_set, dtype=default_float())\n",
    "    mean, var = model.predict_y(X_t)\n",
    "    return mean_squared_error(mean, test_labels)\n",
    "\n",
    "\n",
    "\n",
    "# m.predict_density -> returns the log density of the observations Ynew at Xnew.\n",
    "def nlpd_test(model, test_data):\n",
    "    N = test_data[0].shape[0]\n",
    "    return 1/N*np.sum(model.predict_log_density(test_data))\n",
    "\n",
    "\n",
    "def error_vs_time(times, mses, nlpds,\n",
    "                  markers=['.', '.', 'o', '+'],\n",
    "                  colors=['black', 'red', 'blue', 'black'],\n",
    "                  mfcs=[False, False, True, False],\n",
    "                  model_names=['SGPR', 'FITC', 'Local Method']):\n",
    "\n",
    "    fig, axs = plt.subplots(1, 2, figsize=(16,8))\n",
    "\n",
    "    # MSE vs time/s\n",
    "    for i in range(len(times)):\n",
    "        axs[0].scatter(times[i],\n",
    "                       mses[i],\n",
    "                       marker=markers[i],\n",
    "                       facecolors='none' if mfcs[i] else colors[i],\n",
    "                       edgecolors=colors[i],\n",
    "                       label=model_names[i])\n",
    "\n",
    "    axs[0].legend()\n",
    "    axs[0].set_ylabel(\"MSE\")\n",
    "    axs[0].set_xlabel(\"time/s\")\n",
    "    axs[0].set_title(\"MSE vs time\")\n",
    "\n",
    "    # NLPD vs time/s\n",
    "    for i in range(len(times)):\n",
    "        axs[1].scatter(times[i],\n",
    "                       nlpds[i],\n",
    "                       marker=markers[i],\n",
    "                       facecolors='none' if mfcs[i] else colors[i],\n",
    "                       edgecolors=colors[i],\n",
    "                       label=model_names[i])\n",
    "\n",
    "    axs[1].legend()\n",
    "    axs[1].set_ylabel(\"NLPD\")\n",
    "    axs[1].set_xlabel(\"time/s\")\n",
    "    axs[1].set_title(\"NLPD vs time\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0b38dc1",
   "metadata": {},
   "source": [
    "## Introduction to Sparse Gaussian Process Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e183fd4",
   "metadata": {},
   "source": [
    "### Why do we need Sparse GPR? A quick recap."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "034de61d",
   "metadata": {},
   "source": [
    "A Gaussian Process Regression model has the following prior and predictive distributions:\n",
    "\n",
    "![](img/Table_3.png)\n",
    "\n",
    "With a joint distribution of training and test outputs $p(y, y_T)=\\mathcal(N)(0, K_{N+T} + \\sigma^2 I)$ ($\\sigma^2$ being the variance of the noise).\n",
    "\n",
    "One can see that to compute both the mean and covariance for the predictive distribution, a big inversion must take place. When the data used to compute the covariance is big, the computational effort is excessive (it costs $\\mathcal{O}(N^3)$). If a precomputation step is done, such that the mean function is seen as a wighted sum of N basis functions, the mean has a cost of $\\mathcal{O}(N)$ while the covariance $\\mathcal{O}(N^2)$.\n",
    "\n",
    "This cost depending on the number of points in the data (N) is far too big. Sparse Gaussian Process Regression models, on the other hand, obtain a much smaller cost."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d7ce595",
   "metadata": {},
   "source": [
    "## Types of Sparse Gaussian Process Regression models."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41f3d136",
   "metadata": {},
   "source": [
    "From the multitude of papers and models one can find about Sparse GPR models, this project focuses on the proposals presented in *Snelson & Ghahramani (2007)*. Here, a distinction is made between:\n",
    "* **Global approaches**: where the idea behind is to use a set of support points which can summarize the whole dataset. A similar procedure to the original GPR is used using only the support points. This is the reason for the term *global*.\n",
    "\n",
    "* **Local approaches**: where data is grouped such that a GPR model is deployed for each of this blocks. The posterior distribution for a test point will correspond to the block to which this point belongs to. Such is, a *local* approach.\n",
    "\n",
    "In the paper mentioned above, a recap of two global methods are presented. These are the FIC (Fully Independent Conditional) and FITC (Fully Independent (Training) Conditional) approximations. Given a set of inducing points $\\overline{f}$, the GP prior is expressed as:\n",
    "\n",
    "$$\n",
    "p(f,f_t) = \\int d\\overline{f} \\text{  } p(f,f_T | \\overline{f})  \\text{  } p(\\overline{f})\n",
    "$$\n",
    "\n",
    "From here, it is assumed that $f$ and $f_T$ are independent given $\\overline{f}$:\n",
    "\n",
    "$$\n",
    "p(f,f_T) \\approx q(f,f_T) = \\int d\\overline{f} \\text{  } q(f_T | \\overline{f}) \\text{  } q(f | \\overline{f})  \\text{  } p(\\overline{f})\n",
    "$$\n",
    "\n",
    "The FITC and FIC differ on the different following assumptions made on the training and test conditionals."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13deb16b",
   "metadata": {},
   "source": [
    "### FIC\n",
    "For the first of the Fully Independent global approximations, the assumption is made that both the training and test conditionals are fully independent s.t. $q(f|\\overline{f})=\\prod\\limits_n{p(f_n|\\overline{f})}$ and $q(f_T|\\overline{f})=\\prod\\limits_t{p(f_t|\\overline{f})}$. \n",
    "\n",
    "As a result the prior and predictive distributions found are the ones found in the first row of Table 1.\n",
    "\n",
    "### FITC\n",
    "This second global approximation only considers the *training* data points to be independent. We find the same conditional for training points as before: $q(f|\\overline{f})=\\prod\\limits_n{p(f_n|\\overline{f})}$; but, now, the test conditional: $q(f_T|\\overline{f})=p(f_T|\\overline{f})$.\n",
    "\n",
    "This will transform into a different covariance prior in the testing points slots, as shown in Table 1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "977a84f7",
   "metadata": {},
   "source": [
    "![Table 1](img/Table_1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b30c08d7",
   "metadata": {},
   "source": [
    "## Global + Local approach"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9790d3b",
   "metadata": {},
   "source": [
    "Both global and local approaches present very good qualities. They also show disadvantages which are, somehow, complementary of each other. This is the main motivation to search for a method which combines both approaches.\n",
    "\n",
    "As a first proposal, in *Snelson & Ghahramani (2007)* we find the PITC (Partially Independent Training Conditional).\n",
    "\n",
    "### PITC\n",
    "\n",
    "First proposed in *Quiñonera and Rasmussen (2005)*, the PITC method follows the steps of FITC. As a first step, the training points are divided into blocks $  X_{B_s}, f_{B_s} $ being $s \\in S$ each of the blocks.\n",
    "\n",
    "PITC assumes *partial independence* for the training points. Independence is only considered for points which do not belong to the same block. Following the same notation as FI(T)C, the training and test conditionals are: $q(f|\\overline{f})=\\prod\\limits_s^S{p(f_{B_s}|\\overline{f})}$ and $q(f_T|\\overline{f})=p(f_T|\\overline{f})$.\n",
    "\n",
    "These conditionals probabilities make us understand that the covariance prior will have to be composed by a *block-diagonal* taken of the original training points. The blocks of the block-diagonal matrix being covariance sub-matrices of the original covariance matrix (minus the new sparse diagonal $Q_N$). The corresponding formulas for the predictive distribution (on test point $f_*$) are shown in Table 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4d48ff5",
   "metadata": {},
   "source": [
    "### PIC\n",
    "\n",
    "A new approach is developed in *Snelson & Ghahramani (2007)* following the steps of PITC. The motivation for it is that PITC is still to similar to FITC (as we can see by comparing the predictive distributions). One can not expect too much difference between the two. Another important issue is that the blocking scheme in the training points marginalizes the testing points into a block of their own. Meaning that the test points are related to the training points only through the inducing points. An issue we wanted to avoid when combining global and local methods.\n",
    "\n",
    "The new approach, named PIC, treats training and testing points and considers them jointly for the blocking scheme. This results in a joint conditional: $q(f, f_T|\\overline{f})=p(f_{B_s}, f_T|\\overline{f}) \\prod\\limits_s^{S-1}{p(f_{B_s}|\\overline{f})}$.\n",
    "\n",
    "The corresponding predictive distribution is shown in Table 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48e3963b",
   "metadata": {},
   "source": [
    "![](img/Table_2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecee06b7",
   "metadata": {},
   "source": [
    "Of course, two questions come to mind about the methods shown above.\n",
    "* **Where to put / How many inducing points** to obtain the best model possible?\n",
    "* **How big / How many blocks** should be appointed?\n",
    "\n",
    "Usually, the location of inducing points is decided randomly. Although an interesting proposal is choosing the corresopnding location of inducing points based on the clusters formed in the local-part of the method.\n",
    "\n",
    "Regarding how many inducing points to appoint, the only requirement is that this number should be much smaller than the original number of data points ($M<<N$).\n",
    "\n",
    "The size of the blocks is usually the same for every block. So the size and number of blocks usually have a direct relation. According to *Quiñonera and Rasmussen (2005)*, \"*A reasonable choice, recommended by Tresp (1999) may be to choose k = n/m blocks.*\" i.e. the number of total points divided by the number of inducing points.\n",
    "\n",
    "It is important to mention that when the number of inducing points or blocks in the model is increased greatly, it will tend to a GP Regresion model (since $Q=K$). \n",
    "On the other spectrum, when block sizes tend to one we obtain the FIC model. Furthermore, when the inducing points tend to zero, we are left with the original local GP predictor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "850c4f6b",
   "metadata": {},
   "source": [
    "## Variational Learning approaches"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60b5696c",
   "metadata": {},
   "source": [
    "In the article *Titsias (2009)*, a new Global method is proposed. It is based on Variational Learning, a family of techniques for approximating intractable integrals arising in Bayesian inference and machine learning.\n",
    "\n",
    "A in-depth explanation of it is given in the *bibliography/VariationalInference.pdf* document.\n",
    "\n",
    "But the main idea is that it largely solves two problems: scalability for large datasets and inferring the location of inducing points.\n",
    "\n",
    "A GPflow implementation of this method is present. It is can be found in *gpflow/models/sgpr.py* named SGPR.\n",
    "We will use it to compare it to the other Sparse models."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9204c2ad",
   "metadata": {},
   "source": [
    "## Implementation of Local, PITC and PIC methods in GPflow context"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61c5c06e",
   "metadata": {},
   "source": [
    "Unfortunetely, there exists no implementation of a Local method, nor PITC or PIC in GPflow.\n",
    "This is why, a possible implementation is carried out.\n",
    "\n",
    "The implementation for a Local method uses a K-means model to construct the blocks. For each of these blocks, a GPR model is created. The implementation can be found in the file *gpflow/models/sgpr.py*.\n",
    "A possible approach was tried, using the FITC model as the basis for each of the blocks, but the difference in both execution time and error was very little.\n",
    "\n",
    "Regarding the implementation for the PITC model, a new class is implemented, using the same methods as FITC, except changing the calculation of the prior distribution, since we now should take into account the dependence between points belonging to the same block. A new function is implemented, creating blocks from which a block-diagonal is calculated (as explained above).\n",
    "\n",
    "Unfortunetely, the method shows predictions with a much higher computational effort than expected, probably because of the way it has been implemented. Such is, we can clearly see that the implementation has big room for improvement. The implementation can be found in the file *gpflow/models/sgpr.py*.\n",
    "\n",
    "The fact that there is little documentation regarding the coding process of the GPR models of GPflow is also a big disadvantage when wanting to carry out something similar to a new implementation.\n",
    "\n",
    "As for the PIC model, a possible class was implemented. But no execution was done. The implementation can be found in the file *gpflow/models/sgpr.py*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaca0ab8",
   "metadata": {},
   "source": [
    "## Simple Guassian Regression Example (d=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7af89a81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "N = 1000\n",
    "N_t = 100\n",
    "N_ind = 10\n",
    "X = np.random.rand(N, 1) * 10\n",
    "Y = np.sin(X) + 0.9 * np.cos(X * 1.6) + np.random.randn(*X.shape) * 0.4\n",
    "Xtest = np.random.rand(N_t, 1) * 10\n",
    "_ = plt.plot(X, Y, \"kx\", mew=2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d9772038",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = (\n",
    "    tf.convert_to_tensor(X, dtype=default_float()),\n",
    "    tf.convert_to_tensor(Y, dtype=default_float()),\n",
    ")\n",
    "X_ind = X[0:N-1:int(N/N_ind)]\n",
    "inducing_variable = tf.convert_to_tensor(X_ind, dtype=default_float())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1d44b966",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting training of  GPR\n",
      "Finished training of  GPR\n",
      "Starting training of  SGPR\n",
      "Finished training of  SGPR\n",
      "Starting training of  GPRFITC\n",
      "Finished training of  GPRFITC\n",
      "Starting training of  GPRPITC\n",
      "Finished training of  GPRPITC\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.36447993099864107,\n",
       " 0.33804636199784,\n",
       " 0.3791656520043034,\n",
       " 0.37685600000259,\n",
       " 0.32929757500096457,\n",
       " 0.3397334379988024,\n",
       " 0.3669172050067573,\n",
       " 0.3776202450026176,\n",
       " 0.3148834759995225,\n",
       " 0.2719286159990588]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create models\n",
    "models, _ = create_models(data, inducing_variable)\n",
    "\n",
    "GPR, SGPR, FITC, PITC = models\n",
    "LocalGPR = gpflow.models.LocalGPR(data,gpflow.kernels.SquaredExponential(), num_blocks=10)\n",
    "LocalGPR.optimize()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5b8bd6ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x648 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results\n",
    "f, ax = plt.subplots(3, 2, figsize=(12, 9), sharex=True, sharey=True)\n",
    "plot_univariate(GPR, \"C0\", ax[0, 0], show_xs=True)\n",
    "plot_univariate(SGPR, \"C1\", ax[0, 1], show_xs=True)\n",
    "plot_univariate(FITC, \"C2\", ax[1, 0], show_xs=True)\n",
    "plot_univariate(PITC, \"C3\", ax[1, 1], show_xs=True)\n",
    "plot_univariate(LocalGPR, \"C5\", ax[2, 0], show_xs=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "493cfb5f",
   "metadata": {},
   "source": [
    "## Comparison between Guassian Process Models"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7acdfbf5",
   "metadata": {},
   "source": [
    "From the plot above, we can clearly see the differences between the models.\n",
    "For the GPR we can see a very well fitted posterior distribution, while for the SGPR and FITC models, it is clear that the error bands are larger.\n",
    "\n",
    "For the PITC model, we can a see a clear combination between the Local GPR model, with a small error band in the data domain, while a big increase at the two ends of the domain, like the FITC method.\n",
    "\n",
    "The local model is a clear combination of many GPR submodels on each block. One can see that there is very little smoothness in the predictive distribution, as one would expect."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "213293fd",
   "metadata": {},
   "source": [
    "## Reproduction of previous experiments found in *Snelson & Ghahramani* (2007) and *Titsias* (2009)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27315357",
   "metadata": {},
   "source": [
    "For the execution of the methods for some typical GP Regression datasets, we will just use the Local, FITC and SGPR (VFE) models.\n",
    "This is because the GPR and PITC methods cannot be run on a local computer, since their implementations carry big operations. The latter's innability to be executed with a huge dataset (when in theory it should) surely comes from the way it was implemented.\n",
    "\n",
    "So, in this section, a comparation between the Local approach, FITC and SGPR methods will be shown. Since no clear plotting is possible due to high dimensionality, the plots shown compare the models time of execution vs their respective errors. The errors used (as in the original article of *Snelson & Ghahramani (2007)* will be Mean Squared Error and Negative Log Predictive Density). At the top of the document can one find the corresponding implementation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82500347",
   "metadata": {},
   "source": [
    "### Kin40k dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31d880e8",
   "metadata": {},
   "source": [
    "40,000 records describing the location of a robotic arm as a function of an 8-dimensional control input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b2e68a8e",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting training of  SGPR\n",
      "Finished training of  SGPR\n",
      "Starting training of  GPRFITC\n",
      "Finished training of  GPRFITC\n"
     ]
    }
   ],
   "source": [
    "# Load data\n",
    "kin40k = np.loadtxt(\"data/kin40k/kin40k_train_data.asc\") # Toy example of kin40k\n",
    "kin40k_l = np.loadtxt(\"data/kin40k/kin40k_train_labels.asc\").reshape(-1, 1) # Toy example of kin40k\n",
    "kin40k_test = np.loadtxt(\"data/kin40k/kin40k_test_data.asc\", skiprows=29000) # Toy example of kin40k\n",
    "kin40k_test_l = np.loadtxt(\"data/kin40k/kin40k_test_labels.asc\", skiprows=29000).reshape(-1, 1) # Toy example of kin40k\n",
    "N = len(kin40k)\n",
    "N_t = len(kin40k_test)\n",
    "N_ind = len(kin40k) * 0.01  \n",
    "n_dim = kin40k.shape[1]\n",
    "\n",
    "kin40k_data = (\n",
    "    tf.convert_to_tensor(kin40k, dtype=default_float()),\n",
    "    tf.convert_to_tensor(kin40k_l, dtype=default_float()),\n",
    ")\n",
    "kin40k_test_data = (\n",
    "    tf.convert_to_tensor(kin40k_test, dtype=default_float()),\n",
    "    tf.convert_to_tensor(kin40k_test_l, dtype=default_float()),\n",
    ")\n",
    "kin40k_ind = kin40k[0:N-1:int(N/N_ind)]\n",
    "kin40k_ind = tf.convert_to_tensor(kin40k_ind, dtype=default_float())\n",
    "\n",
    "# https://github.com/GPflow/GPflow/issues/1606\n",
    "models, times = create_models_md(kin40k_data, kin40k_ind)\n",
    "SGPR, FITC = models\n",
    "\n",
    "LocalGPR = gpflow.models.LocalGPR(kin40k_data,  gpflow.kernels.SquaredExponential(lengthscales=np.ones(n_dim)), num_blocks=100)\n",
    "times.append(sum(LocalGPR.optimize()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "32e744fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Evaluation of kin40k\n",
    "kin40k_mses = [\n",
    "               mse_test(SGPR, kin40k_test_data),\n",
    "               mse_test(FITC, kin40k_test_data),\n",
    "               mse_test(LocalGPR, kin40k_test_data)]\n",
    "\n",
    "kin40k_nlpd = [nlpd_test(SGPR, kin40k_test_data),\n",
    "               nlpd_test(FITC, kin40k_test_data),\n",
    "               nlpd_test(LocalGPR, kin40k_test_data)]\n",
    "\n",
    "\n",
    "error_vs_time(times, kin40k_mses, kin40k_nlpd)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e3a8f0d",
   "metadata": {},
   "source": [
    "### Abalone dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2d30b10",
   "metadata": {},
   "source": [
    "Predicting the age of abalone from physical measurements. The age of abalone is determined by\n",
    "cutting the shell through the cone, staining it, and counting the number of rings through a\n",
    "microscope -- a boring and time-consuming task. Other measurements, which are easier to obtain,\n",
    "are used to predict the age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "acb4cf2e",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(3342, 7), dtype=float64, numpy=\n",
       " array([[0.45  , 0.35  , 0.13  , ..., 0.245 , 0.1405, 0.1405],\n",
       "        [0.47  , 0.375 , 0.12  , ..., 0.266 , 0.0935, 0.169 ],\n",
       "        [0.475 , 0.365 , 0.125 , ..., 0.229 , 0.1185, 0.172 ],\n",
       "        ...,\n",
       "        [0.6   , 0.475 , 0.205 , ..., 0.5255, 0.2875, 0.308 ],\n",
       "        [0.625 , 0.485 , 0.15  , ..., 0.531 , 0.261 , 0.296 ],\n",
       "        [0.71  , 0.555 , 0.195 , ..., 0.9455, 0.3765, 0.495 ]])>,\n",
       " <tf.Tensor: shape=(3342, 1), dtype=float64, numpy=\n",
       " array([[ 8.],\n",
       "        [ 8.],\n",
       "        [ 9.],\n",
       "        ...,\n",
       "        [ 9.],\n",
       "        [10.],\n",
       "        [12.]])>)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "abalone = pd.read_csv('data/abalone/abalone.data', header=None)\n",
    "N = len(abalone)\n",
    "test_pct = .2\n",
    "abalone_test = abalone.iloc[:int(N*test_pct),:]\n",
    "abalone_test_l = np.array(abalone_test.iloc[:,-1]).reshape(-1,1)\n",
    "abalone_test = abalone_test.iloc[:,:-1].drop(0, axis=1)\n",
    "\n",
    "abalone = abalone.iloc[int(N*test_pct):,:]\n",
    "abalone_l = np.array(abalone.iloc[:,-1]).reshape(-1,1)\n",
    "abalone = abalone.iloc[:,:-1].drop(0, axis=1)\n",
    "\n",
    "N = len(abalone)\n",
    "N_t = len(abalone_test)\n",
    "N_ind = len(abalone) * 0.01\n",
    "n_dim = abalone.shape[1]\n",
    "\n",
    "abalone_data = (\n",
    "    tf.convert_to_tensor(abalone, dtype=default_float()),\n",
    "    tf.convert_to_tensor(abalone_l, dtype=default_float()),\n",
    ")\n",
    "abalone_test_data = (\n",
    "    tf.convert_to_tensor(abalone_test, dtype=default_float()),\n",
    "    tf.convert_to_tensor(abalone_test_l, dtype=default_float()),\n",
    ")\n",
    "abalone_ind = abalone[0:N-1:int(N/N_ind)]\n",
    "abalone_ind = tf.convert_to_tensor(abalone_ind, dtype=default_float())\n",
    "\n",
    "abalone_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "63244621",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting training of  SGPR\n",
      "Finished training of  SGPR\n",
      "Starting training of  GPRFITC\n",
      "Finished training of  GPRFITC\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Training of SARCOS\n",
    "models, times = create_models_md(abalone_data, abalone_ind)\n",
    "SGPR, FITC = models\n",
    "\n",
    "LocalGPR = gpflow.models.LocalGPR(abalone_data,  gpflow.kernels.SquaredExponential(lengthscales=np.ones(n_dim)), num_blocks=100)\n",
    "times.append(sum(LocalGPR.optimize()))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4e8d58bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# Evaluation of SARCOS\n",
    "abalone_mses = [\n",
    "               mse_test(SGPR, abalone_test_data),\n",
    "               mse_test(FITC, abalone_test_data),\n",
    "               mse_test(LocalGPR, abalone_test_data)]\n",
    "\n",
    "abalone_nlpd = [\n",
    "               nlpd_test(SGPR, abalone_test_data),\n",
    "               nlpd_test(FITC, abalone_test_data),\n",
    "               nlpd_test(LocalGPR, abalone_test_data)]\n",
    "\n",
    "error_vs_time(times, abalone_mses, abalone_nlpd)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21164d51",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73039a31",
   "metadata": {},
   "source": [
    "During the project, a series of Sparse Gaussian Process Regression models have been explained, without too many details, as well as implemented through the GPflow library.\n",
    "\n",
    "Applied to big volume datasets, we have seen that the Sparse approximations allow for a much quicker and less computationally expensive approach.\n",
    "\n",
    "It is important to note that, as the articles mentioned, no variation of inducing point locations and block size was made, which is what was left to obtain a full reproduction of the experiments carried out in the articles."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ebddfc8",
   "metadata": {},
   "source": [
    "### References"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c568bc75",
   "metadata": {},
   "source": [
    "1. Snelson and Ghahramani. (2007). Local and global sparse Gaussian process approximations. Artificial Intelligence and Statistics 11 (AISTATS).http://proceedings.mlr.press/v2/snelson07a/snelson07a.pdf\n",
    "2. Titsias. (2009). Variational Learning of Inducing Variables in Sparse Gaussian Processes. Journal of Machine Learning Research - Proceedings Track. 5. 567-574. http://proceedings.mlr.press/v5/titsias09a/titsias09a.pdf\n",
    "3. Quiñonera and Rasmussen (2005). A Unifying View of Sparse Approximate Gaussian Process Regression.https://www.jmlr.org/papers/v6/quinonero-candela05a.html"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}