{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Node representation learning with GraphSAGE and UnsupervisedSampler\n"
   ]
  },
  {
   "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/embeddings/graphsage-unsupervised-sampler-embeddings.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/embeddings/graphsage-unsupervised-sampler-embeddings.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": [
    "Stellargraph Unsupervised GraphSAGE is the implementation of GraphSAGE method outlined in the paper: [Inductive Representation Learning on Large Graphs.](http://snap.stanford.edu/graphsage/) W.L. Hamilton, R. Ying, and J. Leskovec arXiv:1706.02216\n",
    "[cs.SI], 2017. \n",
    "\n",
    "This notebook is a short demo of how Stellargraph Unsupervised GraphSAGE can be used to learn embeddings of the nodes representing papers in the [CORA citation network](https://linqs-data.soe.ucsc.edu/public/lbc/cora.tgz). Furthermore, this notebook demonstrates the use of the learnt embeddings in a downstream node classification task (classifying papers by subject). Note that the node embeddings can also be used in other graph machine learning tasks, such as link prediction, community detection, etc.\n",
    "\n",
    "## Unsupervised GraphSAGE:\n",
    "\n",
    "A high-level explanation of the unsupervised GraphSAGE method of graph representation learning is as follows.\n",
    "\n",
    "Objective: *Given a graph, learn embeddings of the nodes using only the graph structure and the node features, without using any known node class labels* (hence \"unsupervised\"; for semi-supervised learning of node embeddings, see this [demo](../node-classification/graphsage-node-classification.ipynb))\n",
    "\n",
    "**Unsupervised GraphSAGE model:** In the Unsupervised GraphSAGE model, node embeddings are learnt by solving a simple classification task: given a large set of \"positive\" `(target, context)` node pairs generated from random walks performed on the graph (i.e., node pairs that co-occur within a certain context window in random walks), and an equally large set of \"negative\" node pairs that are randomly selected from the graph according to a certain distribution, learn a binary classifier that predicts whether arbitrary node pairs are likely to co-occur in a random walk performed on the graph. Through learning this simple binary node-pair-classification task, the model automatically learns an inductive mapping from attributes of nodes and their neighbors to node embeddings in a high-dimensional vector space, which preserves structural and feature similarities of the nodes. Unlike embeddings obtained by algorithms such as [Node2Vec](https://snap.stanford.edu/node2vec), this mapping is inductive: given a new node (with attributes) and its links to other nodes in the graph (which was unseen during model training), we can evaluate its embeddings without having to re-train the model. \n",
    "\n",
    "In our implementation of Unsupervised GraphSAGE, the training set of node pairs is composed of an equal number of positive and negative `(target, context)` pairs from the graph. The positive `(target, context)` pairs are the node pairs co-occurring on random walks over the graph whereas the negative node pairs are sampled randomly from a global node degree distribution of the graph.\n",
    "\n",
    "The architecture of the node pair classifier is the following. Input node pairs (with node features) are fed, together with the graph structure, into a pair of identical GraphSAGE encoders, producing a pair of node embeddings. These embeddings are then fed into a node pair classification layer, which applies a binary operator to those node embeddings (e.g., concatenating them), and passes the resulting node pair embeddings through a linear transform followed by a binary activation (e.g., sigmoid), thus predicting a binary label for the node pair. \n",
    "\n",
    "The entire model is trained end-to-end by minimizing the loss function of choice (e.g., binary cross-entropy between predicted node pair labels and true link labels) using stochastic gradient descent (SGD) updates of the model parameters, with minibatches of 'training' links generated on demand and fed into the model.\n",
    "\n",
    "Node embeddings obtained from the encoder part of the trained classifier can be used in various downstream tasks. In this demo, we show how these can be used for predicting node labels."
   ]
  },
  {
   "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 <https://github.com/stellargraph/stellargraph/issues/1172>.\"\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 os\n",
    "import random\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.data import UniformRandomWalk\n",
    "from stellargraph.data import UnsupervisedSampler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from tensorflow import keras\n",
    "from sklearn import preprocessing, feature_extraction, model_selection\n",
    "from sklearn.linear_model import LogisticRegressionCV, LogisticRegression\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "from stellargraph import globalvar\n",
    "\n",
    "from stellargraph import datasets\n",
    "from IPython.display import display, HTML"
   ]
  },
  {
   "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, node_subjects = dataset.load()"
   ]
  },
  {
   "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",
      "    Edge types: paper-cites->paper\n",
      "\n",
      " Edge types:\n",
      "    paper-cites->paper: [5429]\n"
     ]
    }
   ],
   "source": [
    "print(G.info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unsupervised GraphSAGE  with on demand sampling\n",
    "The Unsupervised GraphSAGE requires a training sample that can be either provided as a list of `(target, context)` node pairs or it can be provided with an `UnsupervisedSampler` instance that takes care of generating positive and negative samples of node pairs on demand. In this demo we discuss the latter technique. \n",
    "\n",
    "### UnsupervisedSampler:\n",
    "The `UnsupervisedSampler` class takes in a `Stellargraph` graph instance. The `generator` method in the `UnsupervisedSampler`  is responsible for generating equal number of positive and negative node pair samples from the graph  for training. The samples are generated by performing uniform random walks over the graph, using `UniformRandomWalk` object. Positive `(target, context)` node pairs are extracted from the walks, and for each \n",
    "positive pair a corresponding negative pair `(target, node)` is generated by randomly sampling `node` from the degree distribution of the graph. Once the `batch_size` number of samples is accumulated, the generator yields a list of positive and negative node pairs along with their respective 1/0 labels.  \n",
    "\n",
    "In the current implementation, we use uniform random walks to explore the graph structure. The length and number of walks, as well as the root nodes for starting the walks can be user-specified. The default list for root nodes is all nodes of the graph, default `number_of_walks` is 1 (at least one walk per root node), and the default `length` of walks is 2 (need at least one node beyond the root node on the walk as a potential positive context)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Specify the other optional parameter values: root nodes, the number of walks to take per node, the length of each walk, and random seed.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodes = list(G.nodes())\n",
    "number_of_walks = 1\n",
    "length = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Create the UnsupervisedSampler instance with the relevant parameters passed to it.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "unsupervised_samples = UnsupervisedSampler(\n",
    "    G, nodes=nodes, length=length, number_of_walks=number_of_walks\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The graph G together with the unsupervised sampler will be used to generate samples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Create a node pair generator:**\n",
    "\n",
    "Next, create the node pair generator for sampling and streaming the training data to the model. The node pair generator essentially \"maps\" pairs of nodes `(target, context)` to the input of GraphSAGE: it either takes minibatches of node pairs, or an `UnsupervisedSampler` instance which generates the minibatches of node pairs on demand. The generator samples 2-hop subgraphs with `(target, context)` head nodes extracted from those pairs, and feeds them, together with the corresponding binary labels indicating which pair represent positive or negative sample, to the input layer of the node pair classifier with GraphSAGE node encoder, for SGD updates of the model parameters.\n",
    "\n",
    "Specify:\n",
    "1. The minibatch size (number of node pairs per minibatch).\n",
    "2. The number of epochs for training the model.\n",
    "3. The sizes of 1- and 2-hop neighbor samples for GraphSAGE:\n",
    "\n",
    "Note that the length of `num_samples` list defines the number of layers/iterations in the GraphSAGE encoder. In this example, we are defining a 2-layer GraphSAGE encoder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 50\n",
    "epochs = 4\n",
    "num_samples = [10, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following we show the working of node pair generator with the UnsupervisedSampler, which will generate samples on demand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = GraphSAGELinkGenerator(G, batch_size, num_samples)\n",
    "train_gen = generator.flow(unsupervised_samples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build the model: a 2-layer GraphSAGE encoder 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 encoder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_sizes = [50, 50]\n",
    "graphsage = GraphSAGE(\n",
    "    layer_sizes=layer_sizes, generator=generator, bias=True, dropout=0.0, normalize=\"l2\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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 node pair classification layer that takes a pair of nodes' embeddings produced by `graphsage` encoder, applies a binary operator to them to produce the corresponding node pair 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": 12,
   "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=\"sigmoid\", edge_embedding_method=\"ip\"\n",
    ")(x_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stack the GraphSAGE encoder and prediction layer into a Keras model, and specify the loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": [
    "**4. Train the model.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/4\n",
      "434/434 [==============================] - 35s 80ms/step - loss: 0.5668 - binary_accuracy: 0.7413\n",
      "Epoch 2/4\n",
      "434/434 [==============================] - 33s 77ms/step - loss: 0.5404 - binary_accuracy: 0.7739\n",
      "Epoch 3/4\n",
      "434/434 [==============================] - 34s 78ms/step - loss: 0.5378 - binary_accuracy: 0.7823\n",
      "Epoch 4/4\n",
      "434/434 [==============================] - 34s 78ms/step - loss: 0.5383 - binary_accuracy: 0.7815\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(\n",
    "    train_gen,\n",
    "    epochs=epochs,\n",
    "    verbose=1,\n",
    "    use_multiprocessing=False,\n",
    "    workers=4,\n",
    "    shuffle=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that multiprocessing is switched off, since with a large training set of node pairs, multiprocessing can considerably slow down the training process with the data being transferred between various processes. \n",
    "\n",
    "Also, multiple workers can be used with `Keras version 2.2.4` and above, and it speeds up the training process considerably due to multi-threading."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extracting node embeddings\n",
    "Now that the node pair classifier is trained, we can use its node encoder part as node embeddings evaluator. Below we evaluate node embeddings as activations of the output of GraphSAGE layer stack, and visualise them, coloring nodes by their subject label."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "from sklearn.manifold import TSNE\n",
    "from stellargraph.mapper import GraphSAGENodeGenerator\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Building a new node-based model**\n",
    "\n",
    "The `(src, dst)` node pair classifier `model` has two identical node encoders: one for source nodes in the node pairs, the other for destination nodes in the node pairs passed to the model. We can use either of the two identical encoders to evaluate node embeddings. Below we create an embedding model by defining a new Keras model with `x_inp_src` (a list of odd elements in `x_inp`) and `x_out_src` (the 1st element in `x_out`) as input and output, respectively. Note that this model's weights are the same as those of the corresponding node encoder in the previously trained node pair classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_inp_src = x_inp[0::2]\n",
    "x_out_src = x_out[0]\n",
    "embedding_model = keras.Model(inputs=x_inp_src, outputs=x_out_src)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also need a node generator to feed graph nodes to `embedding_model`. We want to evaluate node embeddings for all nodes in the graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "node_ids = node_subjects.index\n",
    "node_gen = GraphSAGENodeGenerator(G, batch_size, num_samples).flow(node_ids)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now use `node_gen` to feed all nodes into the embedding model and extract their embeddings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55/55 [==============================] - 1s 19ms/step\n"
     ]
    }
   ],
   "source": [
    "node_embeddings = embedding_model.predict(node_gen, workers=4, verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize the node embeddings \n",
    "Next we visualize the node embeddings in 2D using t-SNE. Colors of the nodes depict their true classes (subject in the case of Cora dataset) of the nodes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "node_subject = node_subjects.astype(\"category\").cat.codes\n",
    "\n",
    "X = node_embeddings\n",
    "if X.shape[1] > 2:\n",
    "    transform = TSNE  # PCA\n",
    "\n",
    "    trans = transform(n_components=2)\n",
    "    emb_transformed = pd.DataFrame(trans.fit_transform(X), index=node_ids)\n",
    "    emb_transformed[\"label\"] = node_subject\n",
    "else:\n",
    "    emb_transformed = pd.DataFrame(X, index=node_ids)\n",
    "    emb_transformed = emb_transformed.rename(columns={\"0\": 0, \"1\": 1})\n",
    "    emb_transformed[\"label\"] = node_subject"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alpha = 0.7\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7, 7))\n",
    "ax.scatter(\n",
    "    emb_transformed[0],\n",
    "    emb_transformed[1],\n",
    "    c=emb_transformed[\"label\"].astype(\"category\"),\n",
    "    cmap=\"jet\",\n",
    "    alpha=alpha,\n",
    ")\n",
    "ax.set(aspect=\"equal\", xlabel=\"$X_1$\", ylabel=\"$X_2$\")\n",
    "plt.title(\n",
    "    \"{} visualization of GraphSAGE embeddings for cora dataset\".format(transform.__name__)\n",
    ")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The observation that same-colored nodes in the embedding space are concentrated together is indicative  of similarity of embeddings of papers on the same topics. We would emphasize here again that the node embeddings are learnt in unsupervised way, without using true class labels. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Downstream task\n",
    "\n",
    "The node embeddings calculated using the unsupervised GraphSAGE can be used as node feature vectors in a downstream task such as node classification. \n",
    "\n",
    "In this example, we will use the  node embeddings to train a simple Logistic Regression classifier to predict paper subjects in Cora dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X will hold the 50 input features (node embeddings)\n",
    "X = node_embeddings\n",
    "# y holds the corresponding target values\n",
    "y = np.array(node_subject)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Splitting\n",
    "\n",
    "We split the data into train and test sets. \n",
    "\n",
    "We use 5% of the data for training and the remaining 95% for testing as a hold out test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, y, train_size=0.05, test_size=None, stratify=y\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classifier Training\n",
    "\n",
    "We train a Logistic Regression classifier on the training data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
       "                   intercept_scaling=1, l1_ratio=None, max_iter=100,\n",
       "                   multi_class='auto', n_jobs=None, penalty='l2',\n",
       "                   random_state=None, solver='lbfgs', tol=0.0001, verbose=0,\n",
       "                   warm_start=False)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf = LogisticRegression(verbose=0, solver=\"lbfgs\", multi_class=\"auto\")\n",
    "clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Predict the hold out test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate the accuracy of the classifier on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7427127866303925"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The obtained accuracy is pretty decent, better than that obtained by using node embeddings obtained by `node2vec` that ignores node attributes, only taking into account the graph structure (see this [demo](node2vec-embeddings.ipynb)). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Predicted classes**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    831\n",
       "1    428\n",
       "6    406\n",
       "3    356\n",
       "0    334\n",
       "4    195\n",
       "5     23\n",
       "dtype: int64"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(y_pred).value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**True classes**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    818\n",
       "3    426\n",
       "1    418\n",
       "6    351\n",
       "0    298\n",
       "4    217\n",
       "5    180\n",
       "dtype: int64"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(y).value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uses for unsupervised graph representation learning\n",
    "1. Unsupervised GraphSAGE learns embeddings of unlabeled graph nodes. This is highly useful as most of the real-world data is typically either unlabeled, or have noisy, unreliable, or sparse labels. In such scenarios unsupervised techniques that learn low-dimensional meaningful representation of nodes in a graph by leveraging the graph structure and features of the nodes is useful.\n",
    "2. Moreover, GraphSAGE is an inductive technique that allows us to obtain embeddings of unseen nodes, without the need to re-train the embedding model. That is, instead of training individual embeddings for each node (as in algorithms such as `node2vec` that learn a look-up table of node embeddings), GraphSAGE learns a function that generates embeddings by sampling and aggregating attributes from each node's local neighborhood, and combining those with the node's own attributes."
   ]
  },
  {
   "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/embeddings/graphsage-unsupervised-sampler-embeddings.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/embeddings/graphsage-unsupervised-sampler-embeddings.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.6.9"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 4
}