demos/ensembles/ensemble-link-prediction-example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ensemble models for link prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbsphinx": "hidden",
    "tags": [
     "CloudRunner"
    ]
   },
   "source": [
    "<table><tr><td>Run the latest release of this notebook:</td><td><a href=\"https://mybinder.org/v2/gh/stellargraph/stellargraph/master?urlpath=lab/tree/demos/ensembles/ensemble-link-prediction-example.ipynb\" alt=\"Open In Binder\" target=\"_parent\"><img src=\"https://mybinder.org/badge_logo.svg\"/></a></td><td><a href=\"https://colab.research.google.com/github/stellargraph/stellargraph/blob/master/demos/ensembles/ensemble-link-prediction-example.ipynb\" alt=\"Open In Colab\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\"/></a></td></tr></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we use `stellargraph`s `BaggingEnsemble` class of [GraphSAGE](http://snap.stanford.edu/graphsage/) models to predict citation links in the Cora dataset (see below). The `BaggingEnsemble` class brings ensemble learning to `stellargraph`'s graph neural network models, e.g., `GraphSAGE`, quantifying prediction variance and potentially improving prediction accuracy. \n",
    "\n",
    "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 a base `GraphSAGE` 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",
    "Finally, using our base model, we create an ensemble with each model in the ensemble trained on a bootstrapped sample of the training data. \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."
   ]
  },
  {
   "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.1.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.1.0\")\n",
    "except AttributeError:\n",
    "    raise ValueError(\n",
    "        f\"This notebook requires StellarGraph version 1.1.0, but a different version {sg.__version__} is installed.  Please see <https://github.com/stellargraph/stellargraph/issues/1172>.\"\n",
    "    ) from None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from tensorflow import keras\n",
    "import os\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.ensemble import BaggingEnsemble\n",
    "\n",
    "from sklearn import preprocessing, feature_extraction, model_selection\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": [
    "## Loading the CORA 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": 4,
   "metadata": {
    "tags": [
     "DataLoading"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "The Cora dataset consists of 2708 scientific publications classified into one of seven classes. The citation network consists of 5429 links. Each publication in the dataset is described by a 0/1-valued word vector indicating the absence/presence of the corresponding word from the dictionary. The dictionary consists of 1433 unique words."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataset = datasets.Cora()\n",
    "display(HTML(dataset.description))\n",
    "G, _subjects = dataset.load()"
   ]
  },
  {
   "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 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",
    "\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 test edges (true and false citation links) and the reduced graph G_test with the positive test edges removed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "** Sampled 542 positive and 542 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=0.1, method=\"global\", keep_connected=True, seed=42\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 validation data that we are going to use for early stopping in order to prevent overfitting. 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 validation edges removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "** Sampled 488 positive and 488 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=0.1, method=\"global\", keep_connected=True, seed=100\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We repeat this procedure one last time in order to obtain the training data for the model.\n",
    "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": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "** Sampled 488 positive and 488 negative edges. **\n"
     ]
    }
   ],
   "source": [
    "# Define an edge splitter on the reduced graph G_test:\n",
    "edge_splitter_train = 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_train, edge_ids_train, edge_labels_train = edge_splitter_train.train_test_split(\n",
    "    p=0.1, method=\"global\", keep_connected=True, seed=42\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 and G_test - note that they have the same set of nodes, only differing in their edge sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "StellarGraph: Undirected multigraph\n",
      " Nodes: 2708, Edges: 4399\n",
      "\n",
      " Node types:\n",
      "  paper: [2708]\n",
      "    Features: float32 vector, length 1433\n",
      "    Edge types: paper-cites->paper\n",
      "\n",
      " Edge types:\n",
      "    paper-cites->paper: [4399]\n"
     ]
    }
   ],
   "source": [
    "print(G_train.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "StellarGraph: Undirected multigraph\n",
      " Nodes: 2708, Edges: 4887\n",
      "\n",
      " Node types:\n",
      "  paper: [2708]\n",
      "    Features: float32 vector, length 1433\n",
      "    Edge types: paper-cites->paper\n",
      "\n",
      " Edge types:\n",
      "    paper-cites->paper: [4887]\n"
     ]
    }
   ],
   "source": [
    "print(G_test.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "StellarGraph: Undirected multigraph\n",
      " Nodes: 2708, Edges: 4399\n",
      "\n",
      " Node types:\n",
      "  paper: [2708]\n",
      "    Features: float32 vector, length 1433\n",
      "    Edge types: paper-cites->paper\n",
      "\n",
      " Edge types:\n",
      "    paper-cites->paper: [4399]\n"
     ]
    }
   ],
   "source": [
    "print(G_val.info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specify global parameters\n",
    "\n",
    "Here we specify some important parameters that control the type of ensemble model we are going to use. For example, we specify the number of models in the ensemble and the number of predictions per query point per model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_estimators = 5  # Number of models in the ensemble\n",
    "n_predictions = 10  # Number of predictions per query point per model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we create 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.\n",
    "\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": 12,
   "metadata": {
    "tags": [
     "parameters"
    ]
   },
   "outputs": [],
   "source": [
    "batch_size = 20\n",
    "epochs = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specify the sizes of 1- and 2-hop neighbour samples for GraphSAGE. 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 = [20, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the generators for training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For training we create a generator on the `G_train` graph. The `shuffle=True` argument is given to the `flow` method to improve training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = GraphSAGELinkGenerator(G_train, batch_size, num_samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_gen = generator.flow(edge_ids_train, edge_labels_train, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At test time we use the `G_test` graph and don't specify the `shuffle` argument (it defaults to `False`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_gen = GraphSAGELinkGenerator(G_test, batch_size, num_samples).flow(\n",
    "    edge_ids_test, edge_labels_test\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_gen = GraphSAGELinkGenerator(G_val, batch_size, num_samples).flow(\n",
    "    edge_ids_val, edge_labels_val\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the base GraphSAGE model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build the model: a 2-layer GraphSAGE model acting as node representation learner, with a link classification layer on concatenated `(paper1, paper2)` node embeddings.\n",
    "\n",
    "GraphSAGE part of the model, with hidden layer sizes of 20 for both GraphSAGE layers, a bias term, and no dropout. (Dropout can be switched on by specifying a positive dropout rate, 0 < dropout < 1)\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": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_sizes = [20, 20]\n",
    "assert len(layer_sizes) == len(num_samples)\n",
    "\n",
    "graphsage = GraphSAGE(\n",
    "    layer_sizes=layer_sizes, generator=generator, bias=True, dropout=0.5\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the model and expose the input and output tensors.\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": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "link_classification: using 'ip' method to combine node embeddings into edge embeddings\n"
     ]
    }
   ],
   "source": [
    "prediction = link_classification(\n",
    "    output_dim=1, output_act=\"relu\", edge_embedding_method=\"ip\"\n",
    ")(x_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stack the GraphSAGE and prediction layers into a Keras model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_model = keras.Model(inputs=x_inp, outputs=prediction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we create the ensemble based on `base_model` we just created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = BaggingEnsemble(\n",
    "    model=base_model, n_estimators=n_estimators, n_predictions=n_predictions\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to `compile` the model specifying the optimiser, loss function, and metrics to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(\n",
    "    optimizer=keras.optimizers.Adam(lr=1e-3),\n",
    "    loss=keras.losses.binary_crossentropy,\n",
    "    weighted_metrics=[\"acc\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the initial (untrained) ensemble of models on the train and test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ['...']\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",
      "  ['...']\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",
      "  ['...']\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",
      "Train Set Metrics of the initial (untrained) model:\n",
      "\tloss: 0.6999±0.0411\n",
      "\tacc: 0.6063±0.0191\n",
      "\n",
      "Test Set Metrics of the initial (untrained) model:\n",
      "\tloss: 0.7105±0.0467\n",
      "\tacc: 0.6152±0.0269\n"
     ]
    }
   ],
   "source": [
    "init_train_metrics_mean, init_train_metrics_std = model.evaluate(train_gen)\n",
    "init_test_metrics_mean, init_test_metrics_std = model.evaluate(test_gen)\n",
    "\n",
    "print(\"\\nTrain Set Metrics of the initial (untrained) model:\")\n",
    "for name, m, s in zip(\n",
    "    model.metrics_names, init_train_metrics_mean, init_train_metrics_std\n",
    "):\n",
    "    print(\"\\t{}: {:0.4f}±{:0.4f}\".format(name, m, s))\n",
    "\n",
    "print(\"\\nTest Set Metrics of the initial (untrained) model:\")\n",
    "for name, m, s in zip(model.metrics_names, init_test_metrics_mean, init_test_metrics_std):\n",
    "    print(\"\\t{}: {:0.4f}±{:0.4f}\".format(name, m, s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the ensemble model\n",
    "\n",
    "We are going to use **bootstrap samples** of the training dataset to train each model in the ensemble. For this purpose, we need to pass `generator`, `edge_ids_train`, and `edge_labels_train` to the `fit` method.\n",
    "\n",
    "Note that training time will vary based on computer speed. Set `verbose=1` for reporting of training progress."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ['...']\n",
      "  ['...']\n",
      "  ['...']\n",
      "  ['...']\n",
      "  ['...']\n",
      "  ['...']\n",
      "  ['...']\n",
      "  ['...']\n",
      "  ['...']\n",
      "  ['...']\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(\n",
    "    generator=generator,\n",
    "    train_data=edge_ids_train,\n",
    "    train_targets=edge_labels_train,\n",
    "    epochs=epochs,\n",
    "    validation_data=val_gen,\n",
    "    verbose=0,\n",
    "    use_early_stopping=True,  # Enable early stopping\n",
    "    early_stopping_monitor=\"val_acc\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the training history:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x576 with 2 Axes>"
      ]
     },
     "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. After training the model, performance should be better than before training (shown above):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ['...']\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",
      "  ['...']\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",
      "  ['...']\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",
      "Train Set Metrics of the trained model:\n",
      "\tloss: 0.3113±0.0447\n",
      "\tacc: 0.9111±0.0099\n",
      "\n",
      "Test Set Metrics of the trained model:\n",
      "\tloss: 0.6903±0.1061\n",
      "\tacc: 0.7785±0.0141\n"
     ]
    }
   ],
   "source": [
    "train_metrics_mean, train_metrics_std = model.evaluate(train_gen)\n",
    "test_metrics_mean, test_metrics_std = model.evaluate(test_gen)\n",
    "\n",
    "print(\"\\nTrain Set Metrics of the trained model:\")\n",
    "for name, m, s in zip(model.metrics_names, train_metrics_mean, train_metrics_std):\n",
    "    print(\"\\t{}: {:0.4f}±{:0.4f}\".format(name, m, s))\n",
    "\n",
    "print(\"\\nTest Set Metrics of the trained model:\")\n",
    "for name, m, s in zip(model.metrics_names, test_metrics_mean, test_metrics_std):\n",
    "    print(\"\\t{}: {:0.4f}±{:0.4f}\".format(name, m, s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make predictions with the model\n",
    "\n",
    "Now let's get the predictions for all the edges in the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_predictions = model.predict(generator=test_gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These predictions will be the output of the last layer in the model with `sigmoid` activation.\n",
    "\n",
    "The array `test_predictions` has dimensionality $MxKxNxF$ where $M$ is the number of estimators in the ensemble (`n_estimators`); $K$ is the number of predictions per query point per estimator (`n_predictions`); $N$ is the number of query points (`len(test_predictions)`); and $F$ is the output dimensionality of the specified layer determined by the shape of the output layer (in this case it is equal to 1 since we are performing binary classification)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, (5, 10, 1084, 1))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(test_predictions), test_predictions.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For demonstration, we are going to select one of the edges in the test set, and plot the ensemble's predictions for that edge.\n",
    "\n",
    "Change the value of `selected_query_point` (valid values are in the range of `0` to `len(test_predictions)`) to visualise the results for another test point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_query_point = -10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 10, 1)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select the predictios for the point specified by selected_query_point\n",
    "qp_predictions = test_predictions[:, :, selected_query_point, :]\n",
    "# The shape should be n_estimators x n_predictions x size_output_layer\n",
    "qp_predictions.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, to facilitate plotting the predictions using either a density plot or a box plot, we are going to reshape `qp_predictions` to $R\\times F$ where $R$ is equal to $M\\times K$ as above and $F$ is the output dimensionality of the output layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50, 1)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qp_predictions = qp_predictions.reshape(\n",
    "    np.product(qp_predictions.shape[0:-1]), qp_predictions.shape[-1]\n",
    ")\n",
    "qp_predictions.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model returns the probability of edge, the class to predict. The probability of no edge is just the complement of the latter. Let's calculate it so that we can plot the distribution of predictions for both outcomes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "qp_predictions = np.hstack((qp_predictions, 1.0 - qp_predictions,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'd like to assess the ensemble's confidence in its predictions in order to decide if we can trust them or not. Utilising a box plot, we can visually inspect the ensemble's distribution of prediction probabilities for a point in the test set.\n",
    "\n",
    "If the spread of values for the predicted point class is well separated from those of the other class with little overlap then we can be confident that the prediction is correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Class')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "correct_label = \"Edge\"\n",
    "if edge_labels_test[selected_query_point] == 0:\n",
    "    correct_label = \"No Edge\"\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12, 6))\n",
    "ax.boxplot(x=qp_predictions)\n",
    "ax.set_xticklabels([\"Edge\", \"No Edge\"])\n",
    "ax.tick_params(axis=\"x\", rotation=45)\n",
    "plt.title(\"Correct label is \" + correct_label)\n",
    "plt.ylabel(\"Predicted Probability\")\n",
    "plt.xlabel(\"Class\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the selected pair of nodes (query point), the ensemble is not certain as to whether an edge between these two nodes should exist. This can be inferred by the large spread of values as indicated in the above figure.\n",
    "\n",
    "(Note that due to the stochastic nature of training neural network algorithms, the above conclusion may not be valid if you re-run the notebook; however, the general conclusion that the use of ensemble learning can be used to quantify the model's uncertainty about its prediction still holds.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The below image shows an example of the classifier making a correct prediction with higher confidence than the above example. The results is for the setting `selected_query_point=0`."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbsphinx": "hidden",
    "tags": [
     "CloudRunner"
    ]
   },
   "source": [
    "<table><tr><td>Run the latest release of this notebook:</td><td><a href=\"https://mybinder.org/v2/gh/stellargraph/stellargraph/master?urlpath=lab/tree/demos/ensembles/ensemble-link-prediction-example.ipynb\" alt=\"Open In Binder\" target=\"_parent\"><img src=\"https://mybinder.org/badge_logo.svg\"/></a></td><td><a href=\"https://colab.research.google.com/github/stellargraph/stellargraph/blob/master/demos/ensembles/ensemble-link-prediction-example.ipynb\" alt=\"Open In Colab\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\"/></a></td></tr></table>"
   ]
  }
 ],
 "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
}