diff --git a/README.md b/README.md index c3defa3..df2f618 100644 --- a/README.md +++ b/README.md @@ -4,46 +4,46 @@ This repository is a collection of notebooks about *Bayesian Machine Learning*. The following links display some of the notebooks via [nbviewer](https://nbviewer.jupyter.org/) to ensure a proper rendering of formulas. +Dependencies are specified in `requirements.txt` files in subdirectories. - [Bayesian regression with linear basis function models](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/bayesian-linear-regression/bayesian_linear_regression.ipynb). - Introduction to Bayesian linear regression. Implementation from scratch with plain NumPy as well as usage of scikit-learn - for comparison. See also - [PyMC4 implementation](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/bayesian-linear-regression/bayesian_linear_regression_pymc4.ipynb) and + Introduction to Bayesian linear regression. Implementation with plain NumPy and scikit-learn. See also [PyMC3 implementation](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/bayesian-linear-regression/bayesian_linear_regression_pymc3.ipynb). - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/krasserm/bayesian-machine-learning/blob/dev/gaussian-processes/gaussian_processes.ipynb) [Gaussian processes](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/gaussian-processes/gaussian_processes.ipynb?flush_cache=true). - Introduction to Gaussian processes for regression. Example implementations with plain NumPy/SciPy as well as with libraries - scikit-learn and GPy ([requirements.txt](gaussian-processes/requirements.txt)). + Introduction to Gaussian processes for regression. Implementation with plain NumPy/SciPy as well as with scikit-learn and GPy. - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/krasserm/bayesian-machine-learning/blob/dev/gaussian-processes/gaussian_processes_classification.ipynb) [Gaussian processes for classification](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/gaussian-processes/gaussian_processes_classification.ipynb). - Introduction to Gaussian processes for classification. Example implementations with plain NumPy/SciPy as well as with - scikit-learn ([requirements.txt](gaussian-processes/requirements.txt)). + Introduction to Gaussian processes for classification. Implementation with plain NumPy/SciPy as well as with scikit-learn. + +- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/krasserm/bayesian-machine-learning/blob/dev/gaussian-processes/gaussian_processes_sparse.ipynb) + [Sparse Gaussian processes](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/gaussian-processes/gaussian_processes_sparse.ipynb). + Introduction to sparse Gaussian processes using a variational approach. Example implementation with JAX. - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/krasserm/bayesian-machine-learning/blob/dev/bayesian-optimization/bayesian_optimization.ipynb) [Bayesian optimization](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/bayesian-optimization/bayesian_optimization.ipynb). - Introduction to Bayesian optimization. Example implementations with plain NumPy/SciPy as well as with libraries - scikit-optimize and GPyOpt. Hyper-parameter tuning as application example. + Introduction to Bayesian optimization. Implementation with plain NumPy/SciPy as well as with libraries scikit-optimize + and GPyOpt. Hyper-parameter tuning as application example. - [Variational inference in Bayesian neural networks](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/bayesian-neural-networks/bayesian_neural_networks.ipynb). - Demonstrates how to implement a Bayesian neural network and variational inference of network parameters. Example implementation - with Keras ([requirements.txt](bayesian-neural-networks/requirements.txt)). See also - [PyMC4 implementation](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/bayesian-neural-networks/bayesian_neural_networks_pymc4.ipynb). + Demonstrates how to implement a Bayesian neural network and variational inference of weights. Example implementation + with Keras. - [Reliable uncertainty estimates for neural network predictions](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/noise-contrastive-priors/ncp.ipynb). - Uses noise contrastive priors in Bayesian neural networks to get more reliable uncertainty estimates for OOD data. - Implemented with Tensorflow 2 and Tensorflow Probability ([requirements.txt](noise-contrastive-priors/requirements.txt)). + Uses noise contrastive priors for Bayesian neural networks to get more reliable uncertainty estimates for OOD data. + Implemented with Tensorflow 2 and Tensorflow Probability. - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/krasserm/bayesian-machine-learning/blob/dev/latent-variable-models/latent_variable_models_part_1.ipynb) [Latent variable models, part 1: Gaussian mixture models and the EM algorithm](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/latent-variable-models/latent_variable_models_part_1.ipynb). - Introduction to the expectation maximization (EM) algorithm and its application to Gaussian mixture models. Example - implementation with plain NumPy/SciPy and scikit-learn for comparison. See also + Introduction to the expectation maximization (EM) algorithm and its application to Gaussian mixture models. + Implementation with plain NumPy/SciPy and scikit-learn. See also [PyMC3 implementation](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/latent-variable-models/latent_variable_models_part_1_pymc3.ipynb). - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/krasserm/bayesian-machine-learning/blob/dev/latent-variable-models/latent_variable_models_part_2.ipynb) [Latent variable models, part 2: Stochastic variational inference and variational autoencoders](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/latent-variable-models/latent_variable_models_part_2.ipynb). - Introduction to stochastic variational inference with variational autoencoder as application example. Implementation + Introduction to stochastic variational inference with a variational autoencoder as application example. Implementation with Tensorflow 2.x. - [Deep feature consistent variational autoencoder](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/autoencoder-applications/variational_autoencoder_dfc.ipynb). diff --git a/gaussian-processes/gaussian_processes.ipynb b/gaussian-processes/gaussian_processes.ipynb index fa60a46..2888fb3 100644 --- a/gaussian-processes/gaussian_processes.ipynb +++ b/gaussian-processes/gaussian_processes.ipynb @@ -400,7 +400,8 @@ } ], "source": [ - "from numpy.linalg import cholesky, det, lstsq\n", + "from numpy.linalg import cholesky, det\n", + "from scipy.linalg import solve_triangular\n", "from scipy.optimize import minimize\n", "\n", "def nll_fn(X_train, Y_train, noise, naive=True):\n", @@ -437,14 +438,15 @@ " # in http://www.gaussianprocess.org/gpml/chapters/RW2.pdf, Section\n", " # 2.2, Algorithm 2.1.\n", " \n", - " def ls(a, b):\n", - " return lstsq(a, b, rcond=-1)[0]\n", - " \n", " K = kernel(X_train, X_train, l=theta[0], sigma_f=theta[1]) + \\\n", " noise**2 * np.eye(len(X_train))\n", " L = cholesky(K)\n", + " \n", + " S1 = solve_triangular(L, Y_train, lower=True)\n", + " S2 = solve_triangular(L.T, S1, lower=False)\n", + " \n", " return np.sum(np.log(np.diagonal(L))) + \\\n", - " 0.5 * Y_train.dot(ls(L.T, ls(L, Y_train))) + \\\n", + " 0.5 * Y_train.dot(S2) + \\\n", " 0.5 * len(X_train) * np.log(2*np.pi)\n", "\n", " if naive:\n", diff --git a/gaussian-processes/gaussian_processes_sparse.ipynb b/gaussian-processes/gaussian_processes_sparse.ipynb new file mode 100644 index 0000000..ef60c00 --- /dev/null +++ b/gaussian-processes/gaussian_processes_sparse.ipynb @@ -0,0 +1,51250 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/krasserm/bayesian-machine-learning/blob/dev/gaussian-processes/gaussian_processes_sparse.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " # Check if notebook is running in Google Colab\n", + " import google.colab\n", + " # Get additional files from Github\n", + " !wget https://raw.githubusercontent.com/krasserm/bayesian-machine-learning/dev/gaussian-processes/gaussian_processes_util.py\n", + "except:\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sparse Gaussian processes\n", + "\n", + "## Introduction\n", + "\n", + "Exact Gaussian processes cannot be applied to larger training datasets because their time complexity scales with $O(n^3)$ where $n$ is the size of the training set. Approximate or sparse Gaussian processes are based on a small set of $m$ inducing variables that reduce the time complexity to $O(nm^2)$. \n", + "\n", + "In this article I give an introduction to sparse Gaussian processes as described in \\[1\\] and provide a simple implementation with [JAX](https://github.com/google/jax). The main reason for using JAX instead of plain NumPy was the need to compute gradients of the variational lower bound. The mathematical descriptions in this article are kept on a rather high level so that the focus is on intuition rather than on a detailed derivation of equations. \n", + "\n", + "### Exact Gaussian processes\n", + "\n", + "In a [previous article](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/gaussian-processes/gaussian_processes_classification.ipynb) I introduced exact Gaussian processes for regression. A Gaussian process is a [random process](https://en.wikipedia.org/wiki/Stochastic_process) where any point $\\mathbf{x} \\in \\mathbb{R}^d$ is assigned a random variable $f(\\mathbf{x})$ and where the joint distribution of a finite number of these variables $p(f(\\mathbf{x}_1),...,f(\\mathbf{x}_N)) = p(\\mathbf{f} \\mid \\mathbf{X}) = \\mathcal{N}(\\mathbf{f} \\mid \\boldsymbol\\mu, \\mathbf{K})$ is itself Gaussian. Covariance matrix $\\mathbf{K}$ is defined by a kernel function $\\kappa$ where $\\mathbf{K} = \\kappa(\\mathbf{X},\\mathbf{X})$. Mean $\\boldsymbol\\mu$ is often set to $\\mathbf{0}$. A GP can be used to define a prior over functions.\n", + "\n", + "A GP prior can be converted into a posterior by conditioning on a training dataset $\\mathbf{X}, \\mathbf{y}$ where $\\mathbf{y}$ are noisy realizations of function values $\\mathbf{f}$. For independent Gaussian noise we have $y_i = f(\\mathbf{x}_i) + \\epsilon_i$ where $\\epsilon_i \\sim \\mathcal{N}(0, \\sigma_y^2)$. Noise-free training function values $\\mathbf{f}$ are not directly observed i.e. are latent variables. The posterior over function values $\\mathbf{f}_*$ at inputs $\\mathbf{X}_*$ conditioned on training data is given by\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "p(\\mathbf{f}_* \\mid \\mathbf{X}_*,\\mathbf{X},\\mathbf{y}) &= \\mathcal{N}(\\mathbf{f}_* \\mid \\boldsymbol{\\mu}_*, \\boldsymbol{\\Sigma}_*)\\tag{1} \\\\\n", + "\\boldsymbol{\\mu}_* &= \\mathbf{K}_*^T \\mathbf{K}_y^{-1} \\mathbf{y}\\tag{2} \\\\\n", + "\\boldsymbol{\\Sigma}_* &= \\mathbf{K}_{**} - \\mathbf{K}_*^T \\mathbf{K}_y^{-1} \\mathbf{K}_*\\tag{3}\n", + "\\end{align*}\n", + "$$\n", + "\n", + "where $\\mathbf{K}_y = \\mathbf{K} + \\sigma_y^2\\mathbf{I}$, $\\mathbf{K}_* = \\kappa(\\mathbf{X},\\mathbf{X}_*)$ and $\\mathbf{K}_{**} = \\kappa(\\mathbf{X}_*,\\mathbf{X}_*)$. It can be used to predict function values $\\mathbf{f}_*$ at new inputs $\\mathbf{X}_*$. Computation of $\\boldsymbol{\\mu}_*$ and $\\boldsymbol{\\Sigma}_*$ requires the inversion of $\\mathbf{K}_y$, an $n \\times n$ matrix, where $n$ is the size of the training set. Matrix inversion becomes computationally intractable for larger $n$. To outline a solution to this problem, we note that the posterior can also be defined as\n", + "\n", + "$$\n", + "p(\\mathbf{f}_* \\mid \\mathbf{y}) = \\int p(\\mathbf{f}_* \\mid \\mathbf{f}) p(\\mathbf{f} \\mid \\mathbf{y}) d\\mathbf{f} \\tag{4}\n", + "$$\n", + "\n", + "where the conditioning on inputs $\\mathbf{X}$ and $\\mathbf{X}_*$ has been made implicit. The second term inside the integral is the posterior over the training latent variables $\\mathbf{f}$ conditioned on observations $\\mathbf{y}$, the first term is the posterior over predictions $\\mathbf{f}_*$ conditioned on latent training variables $\\mathbf{f}$ (see also equation $(3)$ in [this article](https://nbviewer.jupyter.org/github/krasserm/bayesian-machine-learning/blob/dev/gaussian-processes/gaussian_processes_classification.ipynb)). Both terms are intractable to compute for larger training datasets for reasons explained above.\n", + "\n", + "### Sparse Gaussian processes\n", + "\n", + "Suppose there is a small set of $m$ inducing variables $\\mathbf{f}_m$ evaluated at inputs $\\mathbf{X}_m$ that describe the function to be modeled \"sufficiently well\" then we could use them as approximation to $\\mathbf{f}$ and $\\mathbf{X}$ and define an approximate posterior:\n", + "\n", + "$$\n", + "q(\\mathbf{f}_*) = \\int p(\\mathbf{f}_* \\mid \\mathbf{f}_m) \\phi(\\mathbf{f}_m) d\\mathbf{f}_m \\tag{5}\n", + "$$\n", + "\n", + "where $\\phi(\\mathbf{f}_m)$ is an approximation to the intractable $p(\\mathbf{f}_m \\mid \\mathbf{y})$:\n", + "\n", + "$$\n", + "\\phi(\\mathbf{f}_m) = \\mathcal{N}(\\mathbf{f}_m \\mid \\boldsymbol{\\mu}_m, \\mathbf{A}_m) \\tag{6}\n", + "$$\n", + "\n", + "Goal is to find optimal values for mean $\\boldsymbol{\\mu}_m$ and covariance matrix $\\mathbf{A}_m$. The quality of $\\phi(\\mathbf{f}_m)$ also depends on the location of the inducing inputs $\\mathbf{X}_m$, hence, our goal is to find their optimal values as well. The mean and covariance matrix of the Gaussian approximate posterior $q(\\mathbf{f}_*)$ are defined in terms of $\\boldsymbol{\\mu}_m$, $\\mathbf{A}_m$ and $\\mathbf{X}_m$:\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "q(\\mathbf{f}_*) &= \\mathcal{N}(\\mathbf{f}_* \\mid \\boldsymbol{\\mu}_*^q, \\boldsymbol{\\Sigma}_*^q) \\tag{7} \\\\\n", + "\\boldsymbol{\\mu}_*^q &= \\mathbf{K}_{*m} \\mathbf{K}_{mm}^{-1} \\boldsymbol{\\mu}_m \\tag{8} \\\\\n", + "\\boldsymbol{\\Sigma}_*^q &= \\mathbf{K}_{**} - \\mathbf{K}_{*m} \\mathbf{K}_{mm}^{-1} \\mathbf{K}_{m*} + \\mathbf{K}_{*m} \\mathbf{K}_{mm}^{-1} \\mathbf{A}_m \\mathbf{K}_{mm}^{-1} \\mathbf{K}_{m*} \\tag{9}\n", + "\\end{align*}\n", + "$$\n", + "\n", + "where $\\mathbf{K}_{mm} = \\kappa(\\mathbf{X}_m, \\mathbf{X}_m)$, $\\mathbf{K}_{*m} = \\kappa(\\mathbf{X}_*, \\mathbf{X}_m)$ and $\\mathbf{K}_{m*} = \\mathbf{K}_{*m}^T$. For a single test input, this approximate posterior can be computed in $O(nm^2)$ after having found optimal values for $\\boldsymbol{\\mu}_m$, $\\mathbf{A}_m$ and $\\mathbf{X}_m$. \\[1\\] uses a variational approach for optimizing $\\boldsymbol{\\mu}_m$, $\\mathbf{A}_m$ and $\\mathbf{X}_m$ by minimizing the Kullback-Leibler (KL) divergence between the approximate posterior $q(\\mathbf{f})$ and the exact posterior $p(\\mathbf{f} \\mid \\mathbf{y})$ over training latent variables $\\mathbf{f}$.\n", + "\n", + "Minimization of this KL divergence is equivalent to maximization of a lower bound $\\mathcal{L}(\\boldsymbol{\\mu}_m, \\mathbf{A}_m, \\mathbf{X}_m)$ on the true log marginal likelihood $\\log p(\\mathbf{y})$. This lower bound can be optimized by analytically solving for $\\boldsymbol{\\mu}_m$ and $\\mathbf{A}_m$. The resulting lower bound after optimization is a function of $\\mathbf{X}_m$:\n", + "\n", + "$$\n", + "\\mathcal{L}(\\mathbf{X}_m) = \\log \\mathcal{N} (\\mathbf{y} \\mid \\mathbf{0}, \\sigma_y^2 \\mathbf{I} + \\mathbf{Q}_{nn}) - \\frac{1}{2 \\sigma_y^2} \\mathrm{Tr}(\\mathbf{K}_{nn} - \\mathbf{Q}_{nn}) \\tag{10}\n", + "$$\n", + "\n", + "\n", + "where $\\mathbf{Q}_{nn} = \\mathbf{K}_{nm} \\mathbf{K}_{mm}^{-1} \\mathbf{K}_{mn}$, $\\mathbf{K}_{nn} = \\kappa(\\mathbf{X},\\mathbf{X})$, $\\mathbf{K}_{nm} = \\kappa(\\mathbf{X},\\mathbf{X}_m)$ and $\\mathbf{K}_{mn} = \\mathbf{K}_{nm}^T$. Equation $(10)$ can be computed in $O(nm^2)$, as shown in section [Optimization](#Optimization), and used to optimize inducing inputs $\\mathbf{X}_m$ jointly with kernel hyperparamaters using a numeric optimization method. The first term on the RHS is an approximate log likelihood term. Optimizing this term alone could lead to overfitting.\n", + "\n", + "The second term is a regularization term which is a result of using a variational approach. This term can be interpreted as minimizing the error predicting $\\mathbf{f}$ from inducing variables $\\mathbf{f}_m$. The better the variables $\\mathbf{f}_m$ represent the function to be modeled the smaller this error will be. Hence, optimization will try to find optimal positions for inducing inputs $\\mathbf{X}_m$. With optimal values for $\\mathbf{X}_m$, we can optimize $\\boldsymbol{\\mu}_m$ and $\\mathbf{A}_m$ i.e. the parameters of $\\phi(\\mathbf{f}_m)$ analytically with \n", + "\n", + "$$\n", + "\\begin{align*}\n", + "\\boldsymbol{\\mu}_m &= \\frac{1}{\\sigma_y^2} \\mathbf{K}_{mm} \\boldsymbol{\\Sigma} \\mathbf{K}_{mn} \\mathbf{y} \\tag{11} \\\\\n", + "\\mathbf{A}_m &= \\mathbf{K}_{mm} \\boldsymbol{\\Sigma} \\mathbf{K}_{mm} \\tag{12}\n", + "\\end{align*}\n", + "$$\n", + "\n", + "where $\\boldsymbol{\\Sigma} = (\\mathbf{K}_{mm} + \\sigma_y^{-2} \\mathbf{K}_{mn} \\mathbf{K}_{nm})^{-1}$. $\\boldsymbol{\\mu}_m$ and $\\mathbf{A}_m$ are then substituted into equations $(8)$ and $(9)$ to compute the approximate posterior $q(\\mathbf{f}_*)$ at new inputs $\\mathbf{X}_*$. This is the minimum we need to know for implementing sparse Gaussian processes for regression. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import jax.numpy as jnp\n", + "import jax.scipy as jsp\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from jax import random, jit, value_and_grad\n", + "from jax.config import config\n", + "from scipy.optimize import minimize\n", + "\n", + "config.update(\"jax_enable_x64\", True)\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training dataset\n", + "\n", + "The training dataset is taken from [this example](https://gpflow.readthedocs.io/en/master/notebooks/advanced/gps_for_big_data.html#Generating-data) of the [GPflow](https://gpflow.readthedocs.io/)\\[2\\] project. We'll use `n` noisy training examples drawn from `func` with Gaussian noise `sigma_y`. The number of inducing variables is `m`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def func(x):\n", + " \"\"\"Latent function.\"\"\"\n", + " return 1.0 * jnp.sin(x * 3 * jnp.pi) + \\\n", + " 0.3 * jnp.cos(x * 9 * jnp.pi) + \\\n", + " 0.5 * jnp.sin(x * 7 * jnp.pi)\n", + "\n", + "\n", + "# Number of training examples\n", + "n = 1000\n", + "\n", + "# Number of inducing variables\n", + "m = 30\n", + "\n", + "# Noise\n", + "sigma_y = 0.2\n", + "\n", + "# Noisy training data\n", + "X = jnp.linspace(-1.0, 1.0, n).reshape(-1, 1)\n", + "y = func(X) + sigma_y * random.normal(random.PRNGKey(0), shape=(n, 1))\n", + "\n", + "# Test data\n", + "X_test = np.linspace(-1.5, 1.5, 1000).reshape(-1, 1)\n", + "f_true = func(X_test)\n", + "\n", + "# Inducing inputs\n", + "X_m = jnp.linspace(-0.4, 0.4, m).reshape(-1, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X, y, label='Training examples', marker='x', color='blue', alpha=0.1)\n", + "plt.plot(X_test, f_true, label='Latent function', c='k', lw=0.5)\n", + "plt.title('Dataset')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A useful initial placement of inducing inputs `X_m` would be to uniformly distribute them across the entire training data region. Here, they are placed in a narrower interval for better [visualization of the optimization process](#Visualizing-the-optimization-process) later.\n", + "\n", + "### Kernel\n", + "\n", + "As in previous articles, we'll again use an isotropic squared exponential kernel with length parameter `theta[0]` and multiplicative constant `theta[1]`. These parameters will be optimized together with inducing inputs `X_m` as shown in the next section." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def kernel(X1, X2, theta):\n", + " \"\"\"\n", + " Isotropic squared exponential kernel.\n", + " \n", + " Args:\n", + " X1: Array of m points (m, d).\n", + " X2: Array of n points (n, d).\n", + " theta: kernel parameters (2,)\n", + " \"\"\"\n", + "\n", + " sqdist = jnp.sum(X1 ** 2, 1).reshape(-1, 1) + jnp.sum(X2 ** 2, 1) - 2 * jnp.dot(X1, X2.T)\n", + " return theta[1] ** 2 * jnp.exp(-0.5 / theta[0] ** 2 * sqdist)\n", + "\n", + "\n", + "def kernel_diag(d, theta):\n", + " \"\"\"\n", + " Isotropic squared exponential kernel (computes diagonal elements only).\n", + " \"\"\"\n", + " return jnp.full(shape=d, fill_value=theta[1] ** 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Optimization\n", + "\n", + "A naive implementation of lower bound $\\mathcal{L}(\\mathbf{X}_m)$ as defined in equation $(10)$ is numerically unstable. A numerically stable approach is described [here](https://gpflow.readthedocs.io/en/master/notebooks/theory/SGPR_notes.html#Marginal-likelihood-bound) which derives the following expression for the lower bound:\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "\\mathcal{L}(\\mathbf{X}_m) = \n", + "&- \\frac{n}{2} \\log 2 \\pi\n", + "- \\frac{1}{2} \\log \\begin{vmatrix}\\mathbf{B}\\end{vmatrix}\n", + "- \\frac{n}{2} \\log \\sigma_y^2\n", + "- \\frac{1}{2 \\sigma_y^2} \\mathbf{y}^T \\mathbf{y} \\\\\n", + "&+ \\frac{1}{2} \\mathbf{c}^T \\mathbf{c}\n", + "- \\frac{1}{2 \\sigma_y^2} \\mathrm{Tr}(\\mathbf{K}_{nn})\n", + "+ \\frac{1}{2} \\mathrm{Tr}(\\mathbf{A}\\mathbf{A}^T) \\tag{13}\n", + "\\end{align*}\n", + "$$\n", + "\n", + "where $\\mathbf{c} = \\mathbf{L_B}^{-1} \\mathbf{A} \\mathbf{y} \\sigma_y^{-1}$, $\\mathbf{B} = \\mathbf{I} + \\mathbf{A}\\mathbf{A}^T$ and $\\mathbf{A} = \\mathbf{L}^{-1} \\mathbf{K}_{mn} \\sigma_y^{-1}$. Lower-triangular matrices $\\mathbf{L_B}$ and $\\mathbf{L}$ are obtained from a [Cholesky decomposition](https://en.wikipedia.org/wiki/Cholesky_decomposition) of $\\mathbf{B} = \\mathbf{L_B} \\mathbf{L_B}^T$ and $\\mathbf{K}_{mm} = \\mathbf{L} \\mathbf{L}^T$, respectively. $\\mathbf{c}$ and $\\mathbf{A}$ are obtained by solving the equations $\\mathbf{L_B} \\mathbf{c} = \\mathbf{A} \\mathbf{y} \\sigma_y^{-1}$ and $\\mathbf{L} \\mathbf{A} = \\mathbf{K}_{mn} \\sigma_y^{-1}$, respectively. Using these definitions, a numerically stable implementation of a negative lower bound (`nlb`) is straightforward." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def jitter(d, value=1e-6):\n", + " return jnp.eye(d) * value\n", + "\n", + "\n", + "def softplus(X):\n", + " return jnp.log(1 + jnp.exp(X))\n", + "\n", + "\n", + "def softplus_inv(X):\n", + " return jnp.log(jnp.exp(X) - 1)\n", + "\n", + "\n", + "def pack_params(theta, X_m):\n", + " return jnp.concatenate([softplus_inv(theta), X_m.ravel()])\n", + "\n", + "\n", + "def unpack_params(params):\n", + " return softplus(params[:2]), jnp.array(params[2:].reshape(-1, 1))\n", + "\n", + "\n", + "def nlb_fn(X, y, sigma_y):\n", + " n = X.shape[0]\n", + "\n", + " def nlb(params):\n", + " \"\"\"\n", + " Negative lower bound on log marginal likelihood.\n", + " \n", + " Args:\n", + " params: kernel parameters `theta` and inducing inputs `X_m`\n", + " \"\"\"\n", + " \n", + " theta, X_m = unpack_params(params)\n", + "\n", + " K_mm = kernel(X_m, X_m, theta) + jitter(X_m.shape[0])\n", + " K_mn = kernel(X_m, X, theta)\n", + "\n", + " L = jnp.linalg.cholesky(K_mm) # m x m\n", + " A = jsp.linalg.solve_triangular(L, K_mn, lower=True) / sigma_y # m x n \n", + " AAT = A @ A.T # m x m\n", + " B = jnp.eye(X_m.shape[0]) + AAT # m x m\n", + " LB = jnp.linalg.cholesky(B) # m x m\n", + " c = jsp.linalg.solve_triangular(LB, A.dot(y), lower=True) / sigma_y # m x 1\n", + "\n", + " # Equation (13)\n", + " lb = - n / 2 * jnp.log(2 * jnp.pi)\n", + " lb -= jnp.sum(jnp.log(jnp.diag(LB)))\n", + " lb -= n / 2 * jnp.log(sigma_y ** 2)\n", + " lb -= 0.5 / sigma_y ** 2 * y.T.dot(y)\n", + " lb += 0.5 * c.T.dot(c)\n", + " lb -= 0.5 / sigma_y ** 2 * jnp.sum(kernel_diag(n, theta))\n", + " lb += 0.5 * jnp.trace(AAT)\n", + "\n", + " return -lb[0, 0]\n", + "\n", + " # nlb_grad returns the negative lower bound and \n", + " # its gradient w.r.t. params i.e. theta and X_m.\n", + " nlb_grad = jit(value_and_grad(nlb))\n", + "\n", + " def nlb_grad_wrapper(params):\n", + " value, grads = nlb_grad(params)\n", + " # scipy.optimize.minimize cannot handle\n", + " # JAX DeviceArray directly. a conversion\n", + " # to Numpy ndarray is needed.\n", + " return np.array(value), np.array(grads)\n", + "\n", + " return nlb_grad_wrapper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The parameters to be optimized are passed as `params` to function `nlb`. These are a concatenation of kernel hyperparameters `theta` and inducing inputs `X_m`. To enable an unconstrained optimization, the kernel hyperparameters are transformed with a [softplus](https://en.wikipedia.org/wiki/Rectifier_(neural_networks)#Softplus) function. The noise variance `sigma_y ** 2` is used as constant here but it is trivial make it an additional parameter to be optimized.\n", + "\n", + "Function `nlb_grad` does not only return the negative lower bound value for a given value of `params` but also its gradient w.r.t. `params`. The gradient can be readily obtained in addition to the lower bound value by transforming `nlb` with JAX's `value_and_grad`. Providing the gradients to the optimizer leads to a much faster convergence compared to letting the optimizer estimate the gradients itself.\n", + "\n", + "JAX doesn't seem to provide an implementation of the L-BFGS-B optimizer yet, therefore, we use SciPy's implementation of `minimize(..., method='L-BFGS-B')`. Since this optimizer cannot handle JAX `DeviceArray`s the result of `nlb` must be converted to plain NumPy `ndarray`s with `nlb_grad_wrapper`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Run optimization\n", + "res = minimize(fun=nlb_fn(X, y, sigma_y),\n", + " x0=pack_params(jnp.array([1.0, 1.0]), X_m),\n", + " method='L-BFGS-B',\n", + " jac=True)\n", + "\n", + "# Optimized kernel parameters and inducing inputs\n", + "theta_opt, X_m_opt = unpack_params(res.x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With optimal values for kernel hyperparameters `theta_opt` and inducing inputs `X_m_opt`, we can now optimize $\\boldsymbol{\\mu}_m$ and $\\mathbf{A}_m$ analytically using equations $(11)$ and $(12)$ to obtain `mu_m_opt` and `A_m_opt`, respectively. We use a naive implementation here i.e. directly invert matrices with `jnp.linalg.inv`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "@jit\n", + "def phi_opt(theta, X_m, X, y, sigma_y):\n", + " \"\"\"Optimize mu_m and A_m using Equations (11) and (12).\"\"\"\n", + " precision = (1.0 / sigma_y ** 2)\n", + "\n", + " K_mm = kernel(X_m, X_m, theta) + jitter(X_m.shape[0])\n", + " K_mm_inv = jnp.linalg.inv(K_mm)\n", + " K_nm = kernel(X, X_m, theta)\n", + " K_mn = K_nm.T\n", + " \n", + " Sigma = jnp.linalg.inv(K_mm + precision * K_mn @ K_nm)\n", + " \n", + " mu_m = precision * (K_mm @ Sigma @ K_mn).dot(y)\n", + " A_m = K_mm @ Sigma @ K_mm \n", + " \n", + " return mu_m, A_m, K_mm_inv\n", + "\n", + "mu_m_opt, A_m_opt, K_mm_inv = phi_opt(theta_opt, X_m_opt, X, y, sigma_y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After plotting the results, one can clearly see that the optimized inducing variables represent the function to be modeled reasonably well." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(X_test, f_true, label='Latent function', c='k', lw=0.5)\n", + "plt.scatter(X_m_opt, mu_m_opt, label='Inducing variables', c='m')\n", + "plt.title('Optimized inducing variables')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.xlim(-1.5, 1.5)\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prediction\n", + "\n", + "The parameters of the approximate posterior $q(\\mathbf{f}_*)$ can now be computed with equations $(8)$ and $(9)$.\n", + "An approach for an implementation that scales with $O(nm^2)$ is described [here](https://gpflow.readthedocs.io/en/develop/notebooks/theory/SGPR_notes.html#Prediction) (note that their notation uses $q(\\mathbf{u})$ instead of our $\\phi(\\mathbf{f}_m)$ and $p(\\mathbf{f}^*)$ instead of our $q(\\mathbf{f}_*)$). Here, we use a naive implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "@jit\n", + "def q(X_test, theta, X_m, mu_m, A_m, K_mm_inv):\n", + " \"\"\"\n", + " Approximate posterior. \n", + " \n", + " Computes mean and covariance of latent \n", + " function values at test inputs X_test.\n", + " \"\"\"\n", + " \n", + " K_ss = kernel(X_test, X_test, theta)\n", + " K_sm = kernel(X_test, X_m, theta)\n", + " K_ms = K_sm.T\n", + "\n", + " f_q = (K_sm @ K_mm_inv).dot(mu_m)\n", + " f_q_cov = K_ss - K_sm @ K_mm_inv @ K_ms + K_sm @ K_mm_inv @ A_m @ K_mm_inv @ K_ms\n", + " \n", + " return f_q, f_q_cov" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Predicting function values at inputs `X_test` shows that the sparse Gaussian process is a good approximation to the true latent function inside the training data region. Predictions outside the training data region converge to $0$ and have high variance." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f_test, f_test_cov = q(X_test, theta_opt, X_m_opt, mu_m_opt, A_m_opt, K_mm_inv)\n", + "f_test_var = np.diag(f_test_cov)\n", + "f_test_std = np.sqrt(f_test_var)\n", + "\n", + "plt.plot(X_test, f_true, label='Latent function', c='k', lw=0.5)\n", + "plt.plot(X_test, f_test, label='Prediction', c='b')\n", + "plt.fill_between(X_test.ravel(), \n", + " f_test.ravel() + 2 * f_test_std, \n", + " f_test.ravel() - 2 * f_test_std,\n", + " label='Epistemic uncertainty',\n", + " color='r', alpha=0.1)\n", + "plt.title('Approximate posterior')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.ylim(None, 3.0)\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The predicted variance covers model uncertainty or epistemic uncertainty only. To represent the uncertainty of noisy predictions we would aditionally have to include aleatoric uncertainty by adding `sigma_y ** 2` to predicted variances `f_test_var` (not shown here).\n", + "\n", + "### Visualizing the optimization process\n", + "\n", + "The following animation visualizes the optimization of a sparse Gaussian process. At each optimization step it shows the updated placement of inducing variables together with predictions made by the approximate posterior. One can clearly see how the optimization process stretches the initially narrow interval of inducing inputs so that prediction accuracy can increase over time." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "theta_0 = jnp.array([1.0, 1.0])\n", + "theta_steps = [theta_0]\n", + "\n", + "X_m_0 = X_m\n", + "X_m_steps = [X_m_0]\n", + "\n", + "def callback(xk):\n", + " theta, X_m = unpack_params(xk)\n", + " theta_steps.append(theta)\n", + " X_m_steps.append(X_m)\n", + " return False\n", + "\n", + "# Run optimization of kernel parameters and\n", + "# inducing inputs again and store their values\n", + "# at each step in global variables theta_steps\n", + "# and X_m_steps.\n", + "minimize(fun=nlb_fn(X, y, sigma_y),\n", + " x0=pack_params(theta_0, X_m_0),\n", + " method='L-BFGS-B', jac=True, \n", + " callback=callback);" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from gaussian_processes_util import generate_animation\n", + "from IPython.display import HTML\n", + "\n", + "# Generate animation with one frame per optimization step\n", + "anim = generate_animation(theta_steps, X_m_steps, X_test, f_true, X, y, sigma_y, phi_opt, q)\n", + "\n", + "# Show animation widget\n", + "HTML(anim.to_jshtml())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Related\n", + "\n", + "A Tensorflow-based implementation of \\[1\\] is provided by the GPflow project with the [SGPR](https://gpflow.readthedocs.io/en/master/gpflow/models/index.html#gpflow.models.SGPR) model. One limitation of the algorithm described in \\[1\\] is that it cannot be applied to mini-batches of training data. A stochastic variational inference approach that additionally supports training with mini-batches is described in \\[3\\], for example. These two papers have strongly influenced further papers on scalable Gaussian processes.\n", + "\n", + "## References\n", + "\n", + "\\[1\\] Titsias, M. (2009). [Variational learning of inducing variables in sparse Gaussian processes](http://proceedings.mlr.press/v5/titsias09a.html). In International Conference on Artificial Intelligence and Statistics (pp. 567–574).\n", + "\n", + "\\[2\\] Matthews, A., Wilk, M., Nickson, T., Fujii, K., Boukouvalas, A., León-Villagrá, P., Ghahramani, Z., & Hensman, J. (2017). [GPflow: A Gaussian process library using TensorFlow](https://jmlr.org/papers/v18/16-537.html). Journal of Machine Learning Research 18(40), 1-6.\n", + "\n", + "\\[3\\] Hensman, J., Fusi, N., & Lawrence, N. (2013). [Gaussian Processes for Big Data](https://arxiv.org/abs/1309.6835). In Proceedings of the Twenty-Ninth Conference on Uncertainty in Artificial Intelligence (pp. 282–290)." + ] + } + ], + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/gaussian-processes/gaussian_processes_util.py b/gaussian-processes/gaussian_processes_util.py index dc147db..e565eb2 100644 --- a/gaussian-processes/gaussian_processes_util.py +++ b/gaussian-processes/gaussian_processes_util.py @@ -1,7 +1,7 @@ import numpy as np import matplotlib.pyplot as plt -from matplotlib import cm +from matplotlib import animation, cm from mpl_toolkits.mplot3d import Axes3D @@ -64,3 +64,53 @@ def plot_db_2D(grid_x, grid_y, grid_z, decision_boundary=0.5): levels = [decision_boundary] cs = plt.contour(grid_x, grid_y, grid_z, levels=levels, colors='black', linestyles='dashed', linewidths=2) plt.clabel(cs, fontsize=20) + + +# ------------------------------------------ +# Sparse GP utils +# ------------------------------------------ + + +def generate_animation(theta_steps, X_m_steps, X_test, f_true, X, y, sigma_y, phi_opt, q, interval=100): + fig, ax = plt.subplots() + + line_func, = ax.plot(X_test, f_true, label='Latent function', c='k', lw=0.5) + pnts_ind = ax.scatter([], [], label='Inducing variables', c='m') + + line_pred, = ax.plot([], [], label='Prediction', c='b') + area_pred = ax.fill_between([], [], [], label='Epistemic uncertainty', color='r', alpha=0.1) + + ax.set_title('Optimization of a sparse Gaussian process') + ax.set_xlabel('x') + ax.set_ylabel('y') + ax.set_xlim(-1.5, 1.5) + ax.set_ylim(-3, 3.5) + ax.legend(loc='upper right') + + def plot_step(i): + theta = theta_steps[i] + X_m = X_m_steps[i] + + mu_m, A_m, K_mm_inv = phi_opt(theta, X_m, X, y, sigma_y) + f_test, f_test_cov = q(X_test, theta, X_m, mu_m, A_m, K_mm_inv) + f_test_var = np.diag(f_test_cov) + f_test_std = np.sqrt(f_test_var) + + ax.collections.clear() + pnts_ind = ax.scatter(X_m, mu_m, c='m') + + line_pred.set_data(X_test, f_test.ravel()) + area_pred = ax.fill_between(X_test.ravel(), + f_test.ravel() + 2 * f_test_std, + f_test.ravel() - 2 * f_test_std, + color='r', alpha=0.1) + + return line_func, pnts_ind, line_pred, area_pred + + result = animation.FuncAnimation(fig, plot_step, frames=len(theta_steps), interval=interval) + + # Prevent output of last frame as additional plot + plt.close() + + return result + diff --git a/gaussian-processes/requirements.txt b/gaussian-processes/requirements.txt index 0eb0125..e981c94 100644 --- a/gaussian-processes/requirements.txt +++ b/gaussian-processes/requirements.txt @@ -3,3 +3,5 @@ numpy==1.19.2 scipy==1.5.2 scikit-learn==0.23.2 GPy==1.9.8 +jax==0.2.6 +jaxlib==0.1.57