{ "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.2.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.2.0\")\n", "except AttributeError:\n", " raise ValueError(\n", " f\"This notebook requires StellarGraph version 1.2.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", " Weights: all 1 (default)\n", " Features: none\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": [ "** 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": [ "** 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": [ "** 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", " Weights: all 1 (default)\n", " Features: none\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", " Weights: all 1 (default)\n", " Features: none\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", " Weights: all 1 (default)\n", " Features: none\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": [ "242/242 [==============================] - 10s 42ms/step - loss: 0.6927 - binary_accuracy: 0.5013\n", "302/302 [==============================] - 12s 41ms/step - loss: 0.6910 - binary_accuracy: 0.5014\n", "266/266 [==============================] - 11s 42ms/step - loss: 0.6897 - binary_accuracy: 0.5023 5s - loss: 0.4428 - bi\n", "\n", "Train Set Metrics of the initial (untrained) model:\n", "\tloss: 0.6927\n", "\tbinary_accuracy: 0.5013\n", "\n", "Validation Set Metrics of the initial (untrained) model:\n", "\tloss: 0.6910\n", "\tbinary_accuracy: 0.5014\n", "\n", "Test Set Metrics of the initial (untrained) model:\n", "\tloss: 0.6897\n", "\tbinary_accuracy: 0.5023\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": [], "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": [ "242/242 [==============================] - 9s 39ms/step - loss: 0.4645 - binary_accuracy: 0.8843\n", "302/302 [==============================] - 12s 38ms/step - loss: 0.5583 - binary_accuracy: 0.7356\n", "266/266 [==============================] - 10s 38ms/step - loss: 0.5583 - binary_accuracy: 0.7299 1s - loss: 0.5264 - binary_accuracy: 0.771 - ETA: 1s - loss: 0.5280 - binar - ETA: 0s - loss: 0.5542 - binary_accuracy: 0.\n", "\n", "Train Set Metrics of the trained model:\n", "\tloss: 0.4645\n", "\tbinary_accuracy: 0.8843\n", "\n", "Validation Set Metrics of the trained model:\n", "\tloss: 0.5583\n", "\tbinary_accuracy: 0.7356\n", "\n", "Test Set Metrics of the trained model:\n", "\tloss: 0.5583\n", "\tbinary_accuracy: 0.7299\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 [==============================] - 12s 45ms/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.3758\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 [==============================] - 12s 38ms/step\n", "266/266 [==============================] - 11s 40ms/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": 33, "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": 36, "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": 39, "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.0174\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.73\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.83\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 }