{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Calibrating a GraphSAGE link prediction model" ] }, { "cell_type": "markdown", "metadata": { "nbsphinx": "hidden", "tags": [ "CloudRunner" ] }, "source": [ "
Run the latest release of this notebook:
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this example, we use our implementation of the [GraphSAGE](http://snap.stanford.edu/graphsage/) algorithm to build a model that predicts citation links in the PubMed-Diabetes dataset (see below). The problem is treated as a supervised link prediction problem on a homogeneous citation network with nodes representing papers (with attributes such as binary keyword indicators and categorical subject) and links corresponding to paper-paper citations. \n", "\n", "To address this problem, we build a model with the following architecture. First we build a two-layer GraphSAGE model that takes labeled `(paper1, paper2)` node pairs corresponding to possible citation links, and outputs a pair of node embeddings for the `paper1` and `paper2` nodes of the pair. These embeddings are then fed into a link classification layer, which first applies a binary operator to those node embeddings (e.g., concatenating them) to construct the embedding of the potential link. Thus obtained link embeddings are passed through the dense link classification layer to obtain link predictions - probability for these candidate links to actually exist in the network. The entire model is trained end-to-end by minimizing the loss function of choice (e.g., binary cross-entropy between predicted link probabilities and true link labels, with true/false citation links having labels 1/0) using stochastic gradient descent (SGD) updates of the model parameters, with minibatches of 'training' links fed into the model.\n", "\n", "Lastly, we investigate the nature of prediction probabilities. We want to know if GraphSAGE's prediction probabilities are well calibrated or not. In the latter case, we present two methods for calibrating the model's output.\n", "\n", "**References**\n", "\n", "1. Inductive Representation Learning on Large Graphs. W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216 \n", "[cs.SI], 2017. ([link](http://snap.stanford.edu/graphsage/))\n", "\n", "2. On Calibration of Modern Neural Networks. C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger. \n", "ICML 2017. ([link](https://geoffpleiss.com/nn_calibration))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Loading the PubMed Diabetes network data" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "nbsphinx": "hidden", "tags": [ "CloudRunner" ] }, "outputs": [], "source": [ "# install StellarGraph if running on Google Colab\n", "import sys\n", "if 'google.colab' in sys.modules:\n", " %pip install -q stellargraph[demos]==1.0.0" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "nbsphinx": "hidden", "tags": [ "VersionCheck" ] }, "outputs": [], "source": [ "# verify that we're using the correct version of StellarGraph for this notebook\n", "import stellargraph as sg\n", "\n", "try:\n", " sg.utils.validate_notebook_version(\"1.0.0\")\n", "except AttributeError:\n", " raise ValueError(\n", " f\"This notebook requires StellarGraph version 1.0.0, but a different version {sg.__version__} is installed. Please see .\"\n", " ) from None" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import networkx as nx\n", "import pandas as pd\n", "import numpy as np\n", "import itertools\n", "import os\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "import stellargraph as sg\n", "from stellargraph.data import EdgeSplitter\n", "from stellargraph.mapper import GraphSAGELinkGenerator\n", "from stellargraph.layer import GraphSAGE, link_classification\n", "from stellargraph.calibration import expected_calibration_error, plot_reliability_diagram\n", "from stellargraph.calibration import IsotonicCalibration, TemperatureCalibration\n", "\n", "from tensorflow import keras\n", "from sklearn import preprocessing, feature_extraction, model_selection\n", "from sklearn.calibration import calibration_curve\n", "from sklearn.isotonic import IsotonicRegression\n", "\n", "from sklearn.metrics import accuracy_score\n", "\n", "from stellargraph import globalvar\n", "from stellargraph import datasets\n", "from IPython.display import display, HTML\n", "\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Global parameters\n", "Specify the minibatch size (number of node pairs per minibatch) and the number of epochs for training the model:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "tags": [ "parameters" ] }, "outputs": [], "source": [ "batch_size = 50\n", "epochs = 20 # The number of training epochs for training the GraphSAGE model.\n", "\n", "# train, test, validation split\n", "train_size = 0.2\n", "test_size = 0.15\n", "val_size = 0.2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Loading the PubMed Diabetes network data" ] }, { "cell_type": "markdown", "metadata": { "tags": [ "DataLoadingLinks" ] }, "source": [ "(See [the \"Loading from Pandas\" demo](../basics/loading-pandas.ipynb) for details on how data can be loaded.)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "tags": [ "DataLoading" ] }, "outputs": [ { "data": { "text/html": [ "The PubMed Diabetes dataset consists of 19717 scientific publications from PubMed database pertaining to diabetes classified into one of three classes. The citation network consists of 44338 links. Each publication in the dataset is described by a TF/IDF weighted word vector from a dictionary which consists of 500 unique words." ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dataset = datasets.PubMedDiabetes()\n", "display(HTML(dataset.description))\n", "G, _subjects = dataset.load()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "StellarGraph: Undirected multigraph\n", " Nodes: 19717, Edges: 44338\n", "\n", " Node types:\n", " paper: [19717]\n", " Features: float32 vector, length 500\n", " Edge types: paper-cites->paper\n", "\n", " Edge types:\n", " paper-cites->paper: [44338]\n" ] } ], "source": [ "print(G.info())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We aim to train a link prediction model, hence we need to prepare the train and test sets of links and the corresponding graphs with those links removed.\n", "\n", "We are going to split our input graph into a train and test graphs using the EdgeSplitter class in `stellargraph.data`. We will use the train graph for training the model (a binary classifier that, given two nodes, predicts whether a link between these two nodes should exist or not) and the test graph for evaluating the model's performance on hold out data.\n", "Each of these graphs will have the same number of nodes as the input graph, but the number of links will differ (be reduced) as some of the links will be removed during each split and used as the positive samples for training/testing the link prediction classifier." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From the original graph G, extract a randomly sampled subset of validation edges (true and false citation links) and the reduced graph G_test with the positive test edges removed:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Removed 1000 edges\n", "Removed 2000 edges\n", "Removed 3000 edges\n", "Removed 4000 edges\n", "Removed 5000 edges\n", "Removed 6000 edges\n", "Sampled 1000 negative examples\n", "Sampled 2000 negative examples\n", "Sampled 3000 negative examples\n", "Sampled 4000 negative examples\n", "Sampled 5000 negative examples\n", "Sampled 6000 negative examples\n", "** Sampled 6650 positive and 6650 negative edges. **\n" ] } ], "source": [ "# Define an edge splitter on the original graph G:\n", "edge_splitter_test = EdgeSplitter(G)\n", "\n", "# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G, and obtain the\n", "# reduced graph G_test with the sampled links removed:\n", "G_test, edge_ids_test, edge_labels_test = edge_splitter_test.train_test_split(\n", " p=test_size, method=\"global\", keep_connected=True\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The reduced graph G_test, together with the test ground truth set of links (edge_ids_test, edge_labels_test), will be used for testing the model.\n", "\n", "Now repeat this procedure to obtain the validation data for the model. From the reduced graph G_test, extract a randomly sampled subset of validation edges (true and false citation links) and the reduced graph G_val with the positive train edges removed:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Removed 1000 edges\n", "Removed 2000 edges\n", "Removed 3000 edges\n", "Removed 4000 edges\n", "Removed 5000 edges\n", "Removed 6000 edges\n", "Removed 7000 edges\n", "Sampled 1000 negative examples\n", "Sampled 2000 negative examples\n", "Sampled 3000 negative examples\n", "Sampled 4000 negative examples\n", "Sampled 5000 negative examples\n", "Sampled 6000 negative examples\n", "Sampled 7000 negative examples\n", "** Sampled 7537 positive and 7537 negative edges. **\n" ] } ], "source": [ "# Define an edge splitter on the reduced graph G_test:\n", "edge_splitter_val = EdgeSplitter(G_test)\n", "\n", "# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G_test, and obtain the\n", "# reduced graph G_train with the sampled links removed:\n", "G_val, edge_ids_val, edge_labels_val = edge_splitter_val.train_test_split(\n", " p=val_size, method=\"global\", keep_connected=True\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The reduced graph G_val, together with the validation ground truth set of links (edge_ids_val, edge_labels_val), will be used for validating the model (can also be used to tune the model parameters).\n", "\n", "Now repeat this procedure to obtain the training data for the model. From the reduced graph G_val, extract a randomly sampled subset of train edges (true and false citation links) and the reduced graph G_train with the positive train edges removed:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Removed 1000 edges\n", "Removed 2000 edges\n", "Removed 3000 edges\n", "Removed 4000 edges\n", "Removed 5000 edges\n", "Removed 6000 edges\n", "Sampled 1000 negative examples\n", "Sampled 2000 negative examples\n", "Sampled 3000 negative examples\n", "Sampled 4000 negative examples\n", "Sampled 5000 negative examples\n", "Sampled 6000 negative examples\n", "** Sampled 6030 positive and 6030 negative edges. **\n" ] } ], "source": [ "# Define an edge splitter on the reduced graph G_test:\n", "edge_splitter_train = EdgeSplitter(G_val)\n", "\n", "# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G_test, and obtain the\n", "# reduced graph G_train with the sampled links removed:\n", "G_train, edge_ids_train, edge_labels_train = edge_splitter_train.train_test_split(\n", " p=train_size, method=\"global\", keep_connected=True\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "G_train, together with the train ground truth set of links (edge_ids_train, edge_labels_train), will be used for training the model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Summary of G_train, G_val and G_test - note that they have the same set of nodes, only differing in their edge sets:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "StellarGraph: Undirected multigraph\n", " Nodes: 19717, Edges: 24121\n", "\n", " Node types:\n", " paper: [19717]\n", " Features: float32 vector, length 500\n", " Edge types: paper-cites->paper\n", "\n", " Edge types:\n", " paper-cites->paper: [24121]\n" ] } ], "source": [ "print(G_train.info())" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "StellarGraph: Undirected multigraph\n", " Nodes: 19717, Edges: 30151\n", "\n", " Node types:\n", " paper: [19717]\n", " Features: float32 vector, length 500\n", " Edge types: paper-cites->paper\n", "\n", " Edge types:\n", " paper-cites->paper: [30151]\n" ] } ], "source": [ "print(G_val.info())" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "StellarGraph: Undirected multigraph\n", " Nodes: 19717, Edges: 37688\n", "\n", " Node types:\n", " paper: [19717]\n", " Features: float32 vector, length 500\n", " Edge types: paper-cites->paper\n", "\n", " Edge types:\n", " paper-cites->paper: [37688]\n" ] } ], "source": [ "print(G_test.info())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we create the link generators for sampling and streaming train and test link examples to the model. The link generators essentially \"map\" pairs of nodes `(paper1, paper2)` to the input of GraphSAGE: they take minibatches of node pairs, sample 2-hop subgraphs with `(paper1, paper2)` head nodes extracted from those pairs, and feed them, together with the corresponding binary labels indicating whether those pairs represent true or false citation links, to the input layer of the GraphSAGE model, for SGD updates of the model parameters." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "Specify the sizes of 1- and 2-hop neighbour samples for GraphSAGE:\n", "\n", "Note that the length of `num_samples` list defines the number of layers/iterations in the GraphSAGE model. In this example, we are defining a 2-layer GraphSAGE model." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "num_samples = [10, 5]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "train_gen = GraphSAGELinkGenerator(G_train, batch_size, num_samples)\n", "val_gen = GraphSAGELinkGenerator(G_val, batch_size, num_samples)\n", "test_gen = GraphSAGELinkGenerator(G_test, batch_size, num_samples)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "GraphSAGE part of the model, with hidden layer sizes of 50 for both GraphSAGE layers, a bias term, and dropout.\n", "\n", "Note that the length of layer_sizes list must be equal to the length of num_samples, as len(num_samples) defines the number of hops (layers) in the GraphSAGE model." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "layer_sizes = [32, 32]\n", "graphsage = GraphSAGE(\n", " layer_sizes=layer_sizes, generator=train_gen, bias=True, dropout=0.2\n", ")" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# Build the model and expose input and output sockets of graphsage, for node pair inputs:\n", "x_inp, x_out = graphsage.in_out_tensors()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Final link classification layer that takes a pair of node embeddings produced by graphsage, applies a binary operator to them to produce the corresponding link embedding ('ip' for inner product; other options for the binary operator can be seen by running a cell with `?link_classification` in it), and passes it through a dense layer:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "link_classification: using 'ip' method to combine node embeddings into edge embeddings\n" ] } ], "source": [ "logits = link_classification(\n", " output_dim=1, output_act=\"linear\", edge_embedding_method=\"ip\"\n", ")(x_out)\n", "\n", "prediction = keras.layers.Activation(keras.activations.sigmoid)(logits)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Stack the GraphSAGE and prediction layers into a Keras model, and specify the loss" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "model = keras.Model(inputs=x_inp, outputs=prediction)\n", "\n", "model.compile(\n", " optimizer=keras.optimizers.Adam(lr=1e-3),\n", " loss=keras.losses.binary_crossentropy,\n", " metrics=[keras.metrics.binary_accuracy],\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Evaluate the initial (untrained) model on the train, val and test sets:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "train_flow = train_gen.flow(edge_ids_train, edge_labels_train, shuffle=True)\n", "val_flow = val_gen.flow(edge_ids_val, edge_labels_val)\n", "test_flow = test_gen.flow(edge_ids_test, edge_labels_test)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ['...']\n", "242/242 [==============================] - 12s 50ms/step - loss: 0.6779 - binary_accuracy: 0.5118\n", " ['...']\n", "302/302 [==============================] - 17s 57ms/step - loss: 0.6753 - binary_accuracy: 0.5125 2s -\n", " ['...']\n", "266/266 [==============================] - 17s 64ms/step - loss: 0.6748 - binary_accuracy: 0.5102\n", "\n", "Train Set Metrics of the initial (untrained) model:\n", "\tloss: 0.6779\n", "\tbinary_accuracy: 0.5118\n", "\n", "Validation Set Metrics of the initial (untrained) model:\n", "\tloss: 0.6753\n", "\tbinary_accuracy: 0.5125\n", "\n", "Test Set Metrics of the initial (untrained) model:\n", "\tloss: 0.6748\n", "\tbinary_accuracy: 0.5102\n" ] } ], "source": [ "init_train_metrics = model.evaluate(train_flow)\n", "init_val_metrics = model.evaluate(val_flow)\n", "init_test_metrics = model.evaluate(test_flow)\n", "\n", "print(\"\\nTrain Set Metrics of the initial (untrained) model:\")\n", "for name, val in zip(model.metrics_names, init_train_metrics):\n", " print(\"\\t{}: {:0.4f}\".format(name, val))\n", "\n", "print(\"\\nValidation Set Metrics of the initial (untrained) model:\")\n", "for name, val in zip(model.metrics_names, init_val_metrics):\n", " print(\"\\t{}: {:0.4f}\".format(name, val))\n", "\n", "print(\"\\nTest Set Metrics of the initial (untrained) model:\")\n", "for name, val in zip(model.metrics_names, init_test_metrics):\n", " print(\"\\t{}: {:0.4f}\".format(name, val))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Train the model:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ['...']\n", " ['...']\n" ] } ], "source": [ "history = model.fit(\n", " train_flow, epochs=epochs, validation_data=val_flow, verbose=0, shuffle=True,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Plot the training history:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "sg.utils.plot_history(history)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Evaluate the trained model on test citation links:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ['...']\n", "242/242 [==============================] - 13s 53ms/step - loss: 0.4606 - binary_accuracy: 0.8850\n", " ['...']\n", "302/302 [==============================] - 17s 58ms/step - loss: 0.5606 - binary_accuracy: 0.7306\n", " ['...']\n", "266/266 [==============================] - 17s 66ms/step - loss: 0.5574 - binary_accuracy: 0.7349\n", "\n", "Train Set Metrics of the trained model:\n", "\tloss: 0.4606\n", "\tbinary_accuracy: 0.8850\n", "\n", "Validation Set Metrics of the trained model:\n", "\tloss: 0.5606\n", "\tbinary_accuracy: 0.7306\n", "\n", "Test Set Metrics of the trained model:\n", "\tloss: 0.5574\n", "\tbinary_accuracy: 0.7349\n" ] } ], "source": [ "train_metrics = model.evaluate(train_flow)\n", "val_metrics = model.evaluate(val_flow)\n", "test_metrics = model.evaluate(test_flow)\n", "\n", "print(\"\\nTrain Set Metrics of the trained model:\")\n", "for name, val in zip(model.metrics_names, train_metrics):\n", " print(\"\\t{}: {:0.4f}\".format(name, val))\n", "\n", "print(\"\\nValidation Set Metrics of the trained model:\")\n", "for name, val in zip(model.metrics_names, val_metrics):\n", " print(\"\\t{}: {:0.4f}\".format(name, val))\n", "\n", "print(\"\\nTest Set Metrics of the trained model:\")\n", "for name, val in zip(model.metrics_names, test_metrics):\n", " print(\"\\t{}: {:0.4f}\".format(name, val))" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "num_tests = 1 # the number of times to generate predictions" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "266/266 [==============================] - 18s 67ms/step\n" ] } ], "source": [ "all_test_predictions = [\n", " model.predict(test_flow, verbose=True) for _ in np.arange(num_tests)\n", "]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Diagnosing model miscalibration\n", "\n", "We are going to use method from scikit-learn.calibration module to calibrate the binary classifier." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "calibration_data = [\n", " calibration_curve(\n", " y_prob=test_predictions, y_true=edge_labels_test, n_bins=10, normalize=True\n", " )\n", " for test_predictions in all_test_predictions\n", "]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let' calculate the expected calibration error on the test set before calibration." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ECE: (before calibration) 0.3583\n" ] } ], "source": [ "for fraction_of_positives, mean_predicted_value in calibration_data:\n", " ece_pre_calibration = expected_calibration_error(\n", " prediction_probabilities=all_test_predictions[0],\n", " accuracy=fraction_of_positives,\n", " confidence=mean_predicted_value,\n", " )\n", " print(\"ECE: (before calibration) {:.4f}\".format(ece_pre_calibration))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's plot the reliability diagram. This is a visual aid for the diagnosis of a poorly calibrated binary classifier." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_reliability_diagram(\n", " calibration_data, np.array(all_test_predictions[0]), ece=[ece_pre_calibration]\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Model Calibration \n", "\n", "Next, we are going to use our validation set to calibrate the model.\n", "\n", "We will consider two different approaches for calibrating a binary classifier, Platt scaling and Isotonic regression.\n", "\n", "## Platt Scaling\n", "\n", "$q_i = \\sigma(\\alpha z_i+\\beta)$ where $z_i$ is the GraphSAGE output (before the last layer's activation function is applied), $q_i$ is the calibrated probability, and $\\sigma()$ is the sigmoid function. \n", "\n", "$\\alpha$ and $\\beta$ are the model's trainable parameters.\n", "\n", "For more information see:\n", "- https://en.wikipedia.org/wiki/Platt_scaling\n", "\n", "## Isotonic Regression\n", "\n", "Isotonic Regression is a regression technique that fits a piece-wise, non-decreasing, linear function to data. For more information see:\n", "- https://scikit-learn.org/stable/modules/generated/sklearn.isotonic.IsotonicRegression.html#sklearn.isotonic.IsotonicRegression\n", "- https://en.wikipedia.org/wiki/Isotonic_regression" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Select the calibration method." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "use_platt = False # True for Platt scaling or False for Isotonic Regression" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For simplicity, we are going to calibrate using a single prediction per query point." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "num_tests = 1" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "score_model = keras.Model(inputs=x_inp, outputs=logits)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "302/302 [==============================] - 18s 59ms/step\n", "266/266 [==============================] - 15s 55ms/step\n" ] } ], "source": [ "if use_platt:\n", " all_val_score_predictions = [\n", " score_model.predict(val_flow, verbose=True) for _ in np.arange(num_tests)\n", " ]\n", " all_test_score_predictions = [\n", " score_model.predict(test_flow, verbose=True) for _ in np.arange(num_tests)\n", " ]\n", " all_test_probabilistic_predictions = [\n", " model.predict(test_flow, verbose=True) for _ in np.arange(num_tests)\n", " ]\n", "else:\n", " all_val_score_predictions = [\n", " model.predict(val_flow, verbose=True) for _ in np.arange(num_tests)\n", " ]\n", " all_test_probabilistic_predictions = [\n", " model.predict(test_flow, verbose=True) for _ in np.arange(num_tests)\n", " ]" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(15074, 1)" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "val_predictions = np.mean(np.array(all_val_score_predictions), axis=0)\n", "val_predictions.shape" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "# These are the uncalibrated prediction probabilities.\n", "if use_platt:\n", " test_predictions = np.mean(np.array(all_test_score_predictions), axis=0)\n", " test_predictions.shape\n", "else:\n", " test_predictions = np.mean(np.array(all_test_probabilistic_predictions), axis=0)\n", " test_predictions.shape" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "if use_platt:\n", " # for binary classification this class performs Platt Scaling\n", " lr = TemperatureCalibration()\n", "else:\n", " lr = IsotonicCalibration()" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((15074, 1), (15074,))" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "val_predictions.shape, edge_labels_val.shape" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "lr.fit(val_predictions, edge_labels_val)" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "lr_test_predictions = lr.predict(test_predictions)" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(13300, 1)" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lr_test_predictions.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's check if these predictions are calibrated!\n", "\n", "If calibration is successful then the ECE after calibration will be lower and the calibration curve will track the ideal diagonal line more closely." ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "scrolled": true }, "outputs": [], "source": [ "calibration_data = [\n", " calibration_curve(\n", " y_prob=lr_test_predictions, y_true=edge_labels_test, n_bins=10, normalize=True\n", " )\n", "]" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ECE (after calibration): 0.0128\n" ] } ], "source": [ "for fraction_of_positives, mean_predicted_value in calibration_data:\n", " ece_post_calibration = expected_calibration_error(\n", " prediction_probabilities=lr_test_predictions,\n", " accuracy=fraction_of_positives,\n", " confidence=mean_predicted_value,\n", " )\n", " print(\"ECE (after calibration): {:.4f}\".format(ece_post_calibration))" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plot_reliability_diagram(\n", " calibration_data, lr_test_predictions, ece=[ece_post_calibration]\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a final test, check if the accuracy of the model changes after calibration." ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy of model before calibration: 0.74\n" ] } ], "source": [ "y_pred = np.zeros(len(test_predictions))\n", "if use_platt:\n", " # the true predictions are the probabilistic outputs\n", " test_predictions = np.mean(np.array(all_test_probabilistic_predictions), axis=0)\n", "y_pred[test_predictions.reshape(-1) > 0.5] = 1\n", "print(\n", " \"Accuracy of model before calibration: {:.2f}\".format(\n", " accuracy_score(y_pred=y_pred, y_true=edge_labels_test)\n", " )\n", ")" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy for model after calibration: 0.82\n" ] } ], "source": [ "y_pred = np.zeros(len(lr_test_predictions))\n", "y_pred[lr_test_predictions[:, 0] > 0.5] = 1\n", "print(\n", " \"Accuracy for model after calibration: {:.2f}\".format(\n", " accuracy_score(y_pred=y_pred, y_true=edge_labels_test)\n", " )\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusion\n", "\n", "This notebook demonstrated how to use Platt scaling and isotonic regression to calibrate a GraphSAGE model used for link prediction in a paper citation network. Importantly, it showed that using calibration can improve the classification model's accuracy." ] }, { "cell_type": "markdown", "metadata": { "nbsphinx": "hidden", "tags": [ "CloudRunner" ] }, "source": [ "
Run the latest release of this notebook:
" ] } ], "metadata": { "file_extension": ".py", "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.5" }, "mimetype": "text/x-python", "name": "python", "npconvert_exporter": "python", "pygments_lexer": "ipython3", "version": 3 }, "nbformat": 4, "nbformat_minor": 4 }