{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Link prediction with GraphSAGE" ] }, { "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 Cora 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 node pairs (`citing-paper` -> `cited-paper`) corresponding to possible citation links, and outputs a pair of node embeddings for the `citing-paper` and `cited-paper` 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." ] }, { "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.1" ] }, { "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.1\")\n", "except AttributeError:\n", " raise ValueError(\n", " f\"This notebook requires StellarGraph version 1.2.1, but a different version {sg.__version__} is installed. Please see .\"\n", " ) from None" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import stellargraph as sg\n", "from stellargraph.data import EdgeSplitter\n", "from stellargraph.mapper import GraphSAGELinkGenerator\n", "from stellargraph.layer import GraphSAGE, HinSAGE, link_classification\n", "\n", "from tensorflow import keras\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", "%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": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dataset = datasets.Cora()\n", "display(HTML(dataset.description))\n", "G, _ = dataset.load(subject_as_feature=True)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "StellarGraph: Undirected multigraph\n", " Nodes: 2708, Edges: 5429\n", "\n", " Node types:\n", " paper: [2708]\n", " Features: float32 vector, length 1440\n", " Edge types: paper-cites->paper\n", "\n", " Edge types:\n", " paper-cites->paper: [5429]\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 test edges (true and false citation links) and the reduced graph G_test with the positive test edges removed:" ] }, { "cell_type": "code", "execution_count": 6, "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\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 training data for the model. From the reduced graph G_test, 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\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 1440\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": {}, "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 1440\n", " Edge types: paper-cites->paper\n", "\n", " Edge types:\n", " paper-cites->paper: [4887]\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 (`citing-paper`, `cited-paper`) to the input of GraphSAGE: they take minibatches of node pairs, sample 2-hop subgraphs with (`citing-paper`, `cited-paper`) 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": 10, "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": 11, "metadata": {}, "outputs": [], "source": [ "num_samples = [20, 10]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For training we create a generator on the `G_train` graph, and make an iterator over the training links using the generator's `flow()` method. The `shuffle=True` argument is given to the `flow` method to improve training." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "train_gen = GraphSAGELinkGenerator(G_train, batch_size, num_samples)\n", "train_flow = train_gen.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": 13, "metadata": {}, "outputs": [], "source": [ "test_gen = GraphSAGELinkGenerator(G_test, batch_size, num_samples)\n", "test_flow = test_gen.flow(edge_ids_test, edge_labels_test)" ] }, { "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 (`citing-paper`, `cited-paper`) node embeddings.\n", "\n", "GraphSAGE part of the model, with hidden layer sizes of 50 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", "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": 14, "metadata": {}, "outputs": [], "source": [ "layer_sizes = [20, 20]\n", "graphsage = GraphSAGE(\n", " layer_sizes=layer_sizes, generator=train_gen, bias=True, dropout=0.3\n", ")" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# Build the model and expose input and output sockets of graphsage model\n", "# for link prediction\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": 16, "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, and specify the loss" ] }, { "cell_type": "code", "execution_count": 17, "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=[\"acc\"],\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Evaluate the initial (untrained) model on the train and test set:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ['...']\n", " ['...']\n", "\n", "Train Set Metrics of the initial (untrained) model:\n", "\tloss: 0.9410\n", "\tacc: 0.6250\n", "\n", "Test Set Metrics of the initial (untrained) model:\n", "\tloss: 0.8328\n", "\tacc: 0.6356\n" ] } ], "source": [ "init_train_metrics = model.evaluate(train_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(\"\\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": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ['...']\n", " ['...']\n", "Train for 49 steps, validate for 55 steps\n", "Epoch 1/20\n", "49/49 - 10s - loss: 0.7426 - acc: 0.5379 - val_loss: 0.6572 - val_acc: 0.6181\n", "Epoch 2/20\n", "49/49 - 9s - loss: 0.5920 - acc: 0.7029 - val_loss: 0.5578 - val_acc: 0.6937\n", "Epoch 3/20\n", "49/49 - 9s - loss: 0.4685 - acc: 0.7971 - val_loss: 0.4985 - val_acc: 0.7592\n", "Epoch 4/20\n", "49/49 - 9s - loss: 0.3895 - acc: 0.8576 - val_loss: 0.4869 - val_acc: 0.7648\n", "Epoch 5/20\n", "49/49 - 9s - loss: 0.3421 - acc: 0.8832 - val_loss: 0.4524 - val_acc: 0.7832\n", "Epoch 6/20\n", "49/49 - 9s - loss: 0.3015 - acc: 0.9078 - val_loss: 0.4348 - val_acc: 0.7952\n", "Epoch 7/20\n", "49/49 - 9s - loss: 0.2760 - acc: 0.9027 - val_loss: 0.4401 - val_acc: 0.8072\n", "Epoch 8/20\n", "49/49 - 9s - loss: 0.2543 - acc: 0.9406 - val_loss: 0.4563 - val_acc: 0.7970\n", "Epoch 9/20\n", "49/49 - 10s - loss: 0.2277 - acc: 0.9467 - val_loss: 0.4392 - val_acc: 0.8054\n", "Epoch 10/20\n", "49/49 - 9s - loss: 0.2060 - acc: 0.9549 - val_loss: 0.4476 - val_acc: 0.8063\n", "Epoch 11/20\n", "49/49 - 9s - loss: 0.1916 - acc: 0.9641 - val_loss: 0.4440 - val_acc: 0.8081\n", "Epoch 12/20\n", "49/49 - 9s - loss: 0.1752 - acc: 0.9631 - val_loss: 0.4596 - val_acc: 0.8035\n", "Epoch 13/20\n", "49/49 - 9s - loss: 0.1648 - acc: 0.9734 - val_loss: 0.4625 - val_acc: 0.8164\n", "Epoch 14/20\n", "49/49 - 9s - loss: 0.1562 - acc: 0.9723 - val_loss: 0.4691 - val_acc: 0.8054\n", "Epoch 15/20\n", "49/49 - 9s - loss: 0.1506 - acc: 0.9816 - val_loss: 0.4497 - val_acc: 0.8081\n", "Epoch 16/20\n", "49/49 - 9s - loss: 0.1420 - acc: 0.9785 - val_loss: 0.4657 - val_acc: 0.8127\n", "Epoch 17/20\n", "49/49 - 9s - loss: 0.1264 - acc: 0.9857 - val_loss: 0.4590 - val_acc: 0.8090\n", "Epoch 18/20\n", "49/49 - 9s - loss: 0.1314 - acc: 0.9826 - val_loss: 0.4655 - val_acc: 0.8035\n", "Epoch 19/20\n", "49/49 - 9s - loss: 0.1234 - acc: 0.9877 - val_loss: 0.5028 - val_acc: 0.8035\n", "Epoch 20/20\n", "49/49 - 9s - loss: 0.1077 - acc: 0.9939 - val_loss: 0.4817 - val_acc: 0.7989\n" ] } ], "source": [ "history = model.fit(train_flow, epochs=epochs, validation_data=test_flow, verbose=2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Plot the training history:" ] }, { "cell_type": "code", "execution_count": 20, "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": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ['...']\n", " ['...']\n", "\n", "Train Set Metrics of the trained model:\n", "\tloss: 0.0544\n", "\tacc: 0.9959\n", "\n", "Test Set Metrics of the trained model:\n", "\tloss: 0.4899\n", "\tacc: 0.7970\n" ] } ], "source": [ "train_metrics = model.evaluate(train_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(\"\\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": "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.6.9" }, "mimetype": "text/x-python", "name": "python", "npconvert_exporter": "python", "pygments_lexer": "ipython3", "version": 3 }, "nbformat": 4, "nbformat_minor": 4 }