From 0f1ed1994cf9cb8d298268747b3981da6c1a9197 Mon Sep 17 00:00:00 2001 From: Leo Klarner Date: Wed, 6 Dec 2023 17:30:20 +0000 Subject: [PATCH] Updated and polished Graph GP notebook. --- README.md | 2 +- notebooks/Training GPs on Graphs.ipynb | 489 +++++++++++++++++++++++++ 2 files changed, 490 insertions(+), 1 deletion(-) create mode 100644 notebooks/Training GPs on Graphs.ipynb diff --git a/README.md b/README.md index 5f338c2..2053b4d 100644 --- a/README.md +++ b/README.md @@ -86,7 +86,7 @@ The easiest way to get started with GAUCHE is to check out our tutorial notebook | [GP Regression on Molecules](https://leojklarner.github.io/gauche/notebooks/gp_regression_on_molecules.html) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/leojklarner/gauche/blob/main/notebooks/GP%20Regression%20on%20Molecules.ipynb) | | [Bayesian Optimisation Over Molecules](https://leojklarner.github.io/gauche/notebooks/bayesian_optimisation_over_molecules.html) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/leojklarner/gauche/blob/main/notebooks/Bayesian%20Optimisation%20Over%20Molecules.ipynb) | | [Multioutput Gaussian Processes for Multitask Learning](https://leojklarner.github.io/gauche/notebooks/multitask_gp_regression_on_molecules.html) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/leojklarner/gauche/blob/main/notebooks/Multitask%20GP%20Regression%20on%20Molecules.ipynb) | -| [Using GraKel Graph kernels](https://leojklarner.github.io/gauche/notebooks/external_graph_kernels.html) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/leojklarner/gauche/blob/main/notebooks/external_graph_kernels.ipynb) | +| [Training GPs on Graphs](https://leojklarner.github.io/gauche/notebooks/Training%20GPs%20on%20Graphs.html) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/leojklarner/gauche/blob/main/notebooks/Training%20GPs%20on%20Graphs.ipynb) | | [Sparse GP Regression for Big Molecular Data](https://leojklarner.github.io/gauche/notebooks/sparse_gp_regression_for_big_molecular_data.html) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/leojklarner/gauche/blob/main/notebooks/Sparse%20GP%20Regression%20for%20Big%20Molecular%20Data.ipynb) | |[Molecular Preference Learning](https://github.com/leojklarner/gauche/blob/main/notebooks/Molecular%20Preference%20Learning.ipynb)|[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/leojklarner/gauche/blob/main/notebooks/Molecular%20Preference%20Learning.ipynb) | |[Preferential Bayesian Optimisation](https://github.com/leojklarner/gauche/blob/main/notebooks/Preferential%20Bayesian%20Optimisation.ipynb)|[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/leojklarner/gauche/blob/main/notebooks/Preferential%20Bayesian%20Optimisation.ipynb) | diff --git a/notebooks/Training GPs on Graphs.ipynb b/notebooks/Training GPs on Graphs.ipynb new file mode 100644 index 0000000..d8c4a5b --- /dev/null +++ b/notebooks/Training GPs on Graphs.ipynb @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "213d6cca", + "metadata": {}, + "source": [ + "# Training Gaussian Processes on Graph-Structured Inputs\n", + "\n", + "**In this notebook, we will use Gauche to train Gaussian processes on molecular graphs.**\n", + "\n", + "GPs are powerful probabilistic models that can be used for regression, uncertainty quantification and Bayesian optimisation tasks. However, general-purpose Gaussian process and Bayesian optimisation libraries typically assume that their inputs are matrices of fixed dimensionality. Yet, in many real-world applications the inputs we care about are not vectors, but can be more faithfully represented as graphs. For example, in molecular design, we often work with molecular graphs, where the nodes represent atoms and the edges represent bonds. In the following, we will show how we can use the graph GP utilities of Gauche to convert SMILES strings to molecular graphs and train a Gaussian process on them.\n", + "\n", + "References:\n", + "- Gauche paper: [https://arxiv.org/abs/2212.04450](https://arxiv.org/abs/2212.04450)\n", + "- Gaussian Processes: [https://en.wikipedia.org/wiki/Gaussian_process](https://en.wikipedia.org/wiki/Gaussian_process)\n", + "- Graph-Structured Inputs: [https://en.wikipedia.org/wiki/Graph_(discrete_mathematics)](https://en.wikipedia.org/wiki/Graph_(discrete_mathematics))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9b75e9c0", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "from typing import List\n", + "\n", + "warnings.filterwarnings(\"ignore\") # Turn off Graphein warnings\n", + "\n", + "import torch\n", + "import gpytorch\n", + "import numpy as np\n", + "from tqdm import tqdm\n", + "import graphein.molecule as gm\n", + "from matplotlib import pyplot as plt\n", + "from botorch import fit_gpytorch_model\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\n", + "\n", + "# Import GAUCHE dataloader and label rescaling utils\n", + "from gauche.dataloader import MolPropLoader\n", + "from gauche.dataloader.data_utils import transform_data\n", + "\n", + "# Import GAUCHE utilities required for fitting GPs on graph-structured inputs \n", + "from gauche import SIGP, NonTensorialInputs\n", + "\n", + "# Import the Weisfeiler Lehman kernel\n", + "from gauche.kernels.graph_kernels import WeisfeilerLehmanKernel, VertexHistogramKernel\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "13a79b88", + "metadata": {}, + "source": [ + "## Defining the Graph GP Class\n", + "\n", + "The most important component of Gauche's graph functionalities is the `SIGP` class, which allows us to use kernels over discrete inputs with GPyTorch and BoTorch machinery. This class is specifically designed for training Gaussian processes on graph-structured inputs, which need to be wrapped in a `NonTensorialInputs` object. In the following, we define a `GraphGP` by creating a `SIGP` subclass that accepts graph-structured inputs and a corresponding kernel.\n", + "\n", + "Inside the `GraphGP` class, the mean function is set to `ConstantMean()` from GPyTorch, and the covariance function is set to the specified kernel function with the provided keyword arguments. The `forward` method of the `GraphGP` class takes an input `x` and returns a `MultivariateNormal` distribution representing the predictive posterior of the Gaussian process. It computes the mean and covariance of the predictive distribution using the mean and covariance functions defined earlier. To ensure numerical stability, a small jitter is added to the covariance matrix.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "856e6d07", + "metadata": {}, + "outputs": [], + "source": [ + "# Subclass the SIGP call that allows us to use kernels over\n", + "# discrete inputs with GPyTorch and BoTorch machinery\n", + "\n", + "\n", + "class GraphGP(SIGP):\n", + " def __init__(\n", + " self,\n", + " train_x: NonTensorialInputs,\n", + " train_y: torch.Tensor,\n", + " likelihood: gpytorch.likelihoods.Likelihood,\n", + " kernel: gpytorch.kernels.Kernel,\n", + " **kernel_kwargs,\n", + " ):\n", + " \"\"\"\n", + " A subclass of the SIGP class that allows us to use kernels over\n", + " discrete inputs with GPyTorch and BoTorch machinery.\n", + "\n", + " Parameters:\n", + " -----------\n", + " train_x: NonTensorialInputs\n", + " The training inputs for the model. These are graph objects.\n", + " train_y: torch.Tensor\n", + " The training labels for the model.\n", + " likelihood: gpytorch.likelihoods.Likelihood\n", + " The likelihood function for the model.\n", + " kernel: gpytorch.kernels.Kernel\n", + " The kernel function for the model.\n", + " **kernel_kwargs:\n", + " The keyword arguments for the kernel function.\n", + " \"\"\"\n", + "\n", + " super().__init__(train_x, train_y, likelihood)\n", + " self.mean = gpytorch.means.ConstantMean()\n", + " self.covariance = kernel(**kernel_kwargs)\n", + "\n", + " def forward(self, x):\n", + " \"\"\"\n", + " A forward pass through the model.\n", + " \"\"\"\n", + " mean = self.mean(torch.zeros(len(x), 1)).float()\n", + " covariance = self.covariance(x)\n", + "\n", + " # because graph kernels operate over discrete inputs it is beneficial\n", + " # to add some jitter for numerical stability\n", + " jitter = max(covariance.diag().mean().detach().item() * 1e-4, 1e-4)\n", + " covariance += torch.eye(len(x)) * jitter\n", + " return gpytorch.distributions.MultivariateNormal(mean, covariance)" + ] + }, + { + "cell_type": "markdown", + "id": "00ba6b8d", + "metadata": {}, + "source": [ + "## Loading and Featurising the Data\n", + "\n", + "In the following, we will use Gauche's built-in featurisation utilities to convert SMILES strings to molecular graphs. We will later use the `NonTensorialInputs` class to wrap the graphs in a `NonTensorialInputs` object, which can be used as input to the `GraphGP` class.\n", + "\n", + "For convenience, we use the MolProp dataloader to read in the Photoswitch dataset. The dataloader uses the molecular graph featurisation utils from Graphein to support a wide range of different node and edge featurisation schemes that will be saved as labels of the resulting graph. \n", + "\n", + "References:\n", + "- Photoswitch dataset: Griffiths et al. [Data-driven discovery of molecular photoswitches with multioutput Gaussian processes](https://pubs.rsc.org/en/content/articlehtml/2022/sc/d2sc04306h). Chemical Science 2022. \n", + "- Creating Molecular Graphs in Graphein: [https://graphein.ai/notebooks/molecule_tutorial.html](https://graphein.ai/notebooks/molecule_tutorial.html)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1023943b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 13 invalid labels [nan nan nan nan nan nan nan nan nan nan nan nan nan] at indices [41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 158]\n", + "To turn validation off, use dataloader.read_csv(..., validate=False).\n" + ] + } + ], + "source": [ + "loader = MolPropLoader()\n", + "loader.load_benchmark(\"Photoswitch\")\n", + "\n", + "# Define the graphein featurisation config\n", + "\n", + "graphein_config = gm.MoleculeGraphConfig(\n", + " node_metadata_functions=[gm.total_degree],\n", + " edge_metadata_functions=[gm.add_bond_type],\n", + ")\n", + "\n", + "loader.featurize(\"molecular_graphs\", graphein_config=graphein_config)" + ] + }, + { + "cell_type": "markdown", + "id": "97f34aff", + "metadata": { + "tags": [] + }, + "source": [ + "## Graph Kernel GP Regression on the Photoswitch Dataset ##\n", + "\n", + "We define our experiment parameters. In this case we are reproducing the results of the E isomer transition wavelength prediction task from https://arxiv.org/abs/2008.03226 using 20 random splits in the ratio 80/20. Note that a validation set is not necessary for GP regression.\n", + "\n", + "To enable an easy evaluation of different kernel functions and their hyperparameters on the Photoswitch dataset, we define the `evaluate_model` function takes in inputs `X` and labels `y`, as well as a kernel function and optionel kernel keyword arguments. It performs a random split of the data into training and test sets, trains a `GraphGP` model using the provided kernel, and evaluates the model's performance using various regression metrics such as R^2, RMSE, and MAE. Additionally, it computes a confidence-error curve plot to visualize the model's predictive uncertainty. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0826fcff", + "metadata": {}, + "outputs": [], + "source": [ + "# Set the expetimental parameters, including the number of random splits and split size\n", + "\n", + "n_trials = 20\n", + "test_set_size = 0.2\n", + "\n", + "# Define evaluation function that can be re-used with different kernels\n", + "\n", + "\n", + "def evaluate_model(\n", + " X: List,\n", + " y: np.array,\n", + " kernel: gpytorch.kernels.Kernel,\n", + " **kernel_kwargs: dict,\n", + ") -> (np.ndarray, np.ndarray):\n", + " \"\"\"\n", + " A function that trains and evaluates a graph GP model with a\n", + " given kernel and keyword arguments on a given dataset.\n", + " It also plots the confidence-error curves for the model.\n", + "\n", + " Parameters:\n", + " -----------\n", + " X: List\n", + " A list of Graphein graphs to train the GP on.\n", + " y: np.ndarray\n", + " The labels for the model.\n", + " kernel: gpytorch.kernels.Kernel\n", + " The kernel function for the model.\n", + " **kernel_kwargs:\n", + " The keyword arguments for the kernel function.\n", + "\n", + " Returns:\n", + " --------\n", + " r2_list: np.ndarray\n", + " The R^2 scores for each trial.\n", + " rmse_list: np.ndarray\n", + " The RMSE scores for each trial.\n", + " mae_list: np.ndarray\n", + " The MAE scores for each trial.\n", + " \"\"\"\n", + "\n", + " # Initialise performance metric lists\n", + " r2_list = []\n", + " rmse_list = []\n", + " mae_list = []\n", + "\n", + " # We pre-allocate array for plotting confidence-error curves\n", + " n_test = int(len(y) * test_set_size) + 1\n", + " mae_confidence_list = np.zeros((n_trials, n_test))\n", + "\n", + " progress_bar = tqdm(range(n_trials))\n", + "\n", + " for i in progress_bar:\n", + " progress_bar.set_description(f\"Running trial #{i}\")\n", + "\n", + " # Carry out the random split with the current random seed\n", + " # and standardise the outputs\n", + " X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=test_set_size, random_state=i\n", + " )\n", + " _, y_train, _, y_test, y_scaler = transform_data(\n", + " np.zeros_like(y_train), y_train, np.zeros_like(y_test), y_test\n", + " )\n", + "\n", + " # Convert graph-structured inputs to custom data class for\n", + " # non-tensorial inputs and convert labels to PyTorch tensors\n", + " X_train = NonTensorialInputs(X_train)\n", + " X_test = NonTensorialInputs(X_test)\n", + " y_train = torch.tensor(y_train).flatten().float()\n", + " y_test = torch.tensor(y_test).flatten().float()\n", + "\n", + " # Initialise GP likelihood and model\n", + " likelihood = gpytorch.likelihoods.GaussianLikelihood()\n", + " model = GraphGP(X_train, y_train, likelihood, kernel, **kernel_kwargs)\n", + "\n", + " # Define the marginal log likelihood used to optimise the model hyperparameters\n", + " mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)\n", + "\n", + " # Use the BoTorch utility for fitting GPs in order\n", + " # to use the LBFGS-B optimiser (recommended)\n", + " fit_gpytorch_model(mll)\n", + "\n", + " # Get into evaluation (predictive posterior) mode and compute predictions\n", + " model.eval()\n", + " likelihood.eval()\n", + " f_pred = model(X_test)\n", + " y_pred = f_pred.mean\n", + " y_var = f_pred.variance\n", + "\n", + " # Transform the predictions back to the original scale and calucalte eval metrics\n", + " y_pred = y_scaler.inverse_transform(y_pred.detach().unsqueeze(dim=1))\n", + " y_test = y_scaler.inverse_transform(y_test.detach().unsqueeze(dim=1))\n", + "\n", + " # Construct the MAE error for each level of confidence\n", + " ranked_confidence_list = np.argsort(y_var.detach(), axis=0).flatten()\n", + " for k in range(len(y_test)):\n", + " conf = ranked_confidence_list[0 : k + 1]\n", + " mae = mean_absolute_error(y_test[conf], y_pred[conf])\n", + " mae_confidence_list[i, k] = mae\n", + "\n", + " # Compute R^2, RMSE and MAE on Test set\n", + " score = r2_score(y_test, y_pred)\n", + " rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n", + " mae = mean_absolute_error(y_test, y_pred)\n", + "\n", + " r2_list.append(score)\n", + " rmse_list.append(rmse)\n", + " mae_list.append(mae)\n", + "\n", + " r2_list = np.array(r2_list)\n", + " rmse_list = np.array(rmse_list)\n", + " mae_list = np.array(mae_list)\n", + "\n", + " # Print mean and standard error of the mean for each metric\n", + "\n", + " print(\n", + " \"\\nmean R^2: {:.4f} +- {:.4f}\".format(\n", + " np.mean(r2_list), np.std(r2_list) / np.sqrt(len(r2_list))\n", + " )\n", + " )\n", + " print(\n", + " \"mean RMSE: {:.4f} +- {:.4f}\".format(\n", + " np.mean(rmse_list), np.std(rmse_list) / np.sqrt(len(rmse_list))\n", + " )\n", + " )\n", + " print(\n", + " \"mean MAE: {:.4f} +- {:.4f}\\n\".format(\n", + " np.mean(mae_list), np.std(mae_list) / np.sqrt(len(mae_list))\n", + " )\n", + " )\n", + "\n", + " # Plot the mean-absolute error/confidence-error curves\n", + " # with 1 sigma errorbars\n", + "\n", + " confidence_percentiles = np.arange(1e-14, 100, 100 / len(y_test))\n", + "\n", + " mae_mean = np.mean(mae_confidence_list, axis=0)\n", + " mae_mean = np.flip(mae_mean)\n", + " mae_std = np.std(mae_confidence_list, axis=0)\n", + " mae_std = np.flip(mae_std)\n", + " lower = mae_mean - mae_std\n", + " upper = mae_mean + mae_std\n", + "\n", + " plt.plot(confidence_percentiles, mae_mean, label=\"mean\")\n", + " plt.fill_between(confidence_percentiles, lower, upper, alpha=0.2)\n", + " plt.xlabel(\"Confidence Percentile\")\n", + " plt.ylabel(\"MAE (nm)\")\n", + " plt.ylim([0, np.max(upper) + 1])\n", + " plt.xlim([0, 100 * ((len(y_test) - 1) / len(y_test))])\n", + " plt.yticks(np.arange(0, np.max(upper) + 1, 5.0))\n", + " plt.show()\n", + "\n", + " return r2_list, rmse_list, mae_list" + ] + }, + { + "cell_type": "markdown", + "id": "9f71da40", + "metadata": {}, + "source": [ + "## Selecting a Graph Kernel ##\n", + "\n", + "Gauche provides a wide-range of kernels that can be used to quantify the similarity between graph-structured inputs and train Gaussian processes on them. These kernels are implemented in the `gauche.kernels.graph_kernels` module and can be used as drop-in replacements for any `gpytorch.kernels.Kernel`. These kernels mostly build on the GraKel library and currently include the:\n", + "\n", + "- [RandomWalkKernel](https://ysig.github.io/GraKeL/0.1a8/kernels/random_walk.html) for unlabelled graphs.\n", + "- [ShortestPathKernel](https://ysig.github.io/GraKeL/0.1a8/kernels/shortest_path.html) for unlabelled graphs.\n", + "- [GraphletSamplingKernel](https://ysig.github.io/GraKeL/0.1a8/kernels/graphlet_sampling.html) for unlabelled graphs.\n", + "- [VertexHistogramKernel](https://ysig.github.io/GraKeL/0.1a8/kernels/vertex_histogram.html) for node-labelled graphs.\n", + "- [NeighborhoodHashKernel](https://ysig.github.io/GraKeL/0.1a8/kernels/neighborhood_hash.html): for node-labelled graphs.\n", + "- [RandomWalkLabeledKernel](https://ysig.github.io/GraKeL/0.1a8/kernels/random_walk.html): for node-labelled graphs.\n", + "- [ShortestPathLabeledKernel](https://ysig.github.io/GraKeL/0.1a8/kernels/shortest_path.html): for node-labelled graphs.\n", + "- [WeisfeilerLehmanKernel](https://ysig.github.io/GraKeL/0.1a8/kernels/weisfeiler_lehman.html) for node-labelled and optionally edge-labelled graphs.\n", + "- [EdgeHistogramKernel](https://ysig.github.io/GraKeL/0.1a8/kernels/edge_histogram.html): for edge-labelled graphs.\n", + "\n", + "Any node and edge labels can be passed as a `node_label=...` or `edge_label=...` argument to the respective kernel function. These kernels already provide a powerful set of tools for quantifying the similarity between graphs and we plan to add additional kernels in the future.\n", + "\n", + "In the following, we will be training a graph GP model with a Weisfeiler-Lehman kernel (using element types as node labels), and compare it to the performance of the much simpler vertex histogram kernel. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fa469e07", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running trial #19: 100%|████████████████████████████████████████████████████████████████| 20/20 [00:12<00:00, 1.64it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "mean R^2: 0.8552 +- 0.0078\n", + "mean RMSE: 24.7731 +- 0.7579\n", + "mean MAE: 15.7633 +- 0.4203\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Evaluate the performance of the Weisfeiler Lehman kernel using element types as node labels\n", + "_, _, _, = evaluate_model(\n", + " loader.features, loader.labels, \n", + " WeisfeilerLehmanKernel, node_label=\"element\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "81ae1498-4a68-4540-ba3a-b616cbeb5873", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running trial #19: 100%|████████████████████████████████████████████████████████████████| 20/20 [00:12<00:00, 1.57it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "mean R^2: 0.3952 +- 0.0329\n", + "mean RMSE: 50.6839 +- 1.5627\n", + "mean MAE: 38.1607 +- 1.0446\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Compare it to the performance of a simple vertex histogram kernel\n", + "_, _, _, = evaluate_model(\n", + " loader.features, loader.labels, \n", + " VertexHistogramKernel, node_label=\"element\",\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gauche_pip", + "language": "python", + "name": "gauche_pip" + }, + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}