stellargraph/stellargraph

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0",
   "metadata": {},
   "source": [
    "# Cluster GCN on Neo4j"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1",
   "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/connector/neo4j/cluster-gcn-on-cora-neo4j-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/connector/neo4j/cluster-gcn-on-cora-neo4j-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",
   "id": "2",
   "metadata": {},
   "source": [
    "This example demonstrates how to run Cluster GCN on a dataset stored entirely on disk with Neo4j. Our Neo4j Cluster GCN implementation iterates through user specified graph clusters and only ever stores the edges and features of one cluster in memory at any given time. This enables Cluster GCN to be used on extremely large datasets that don't fit into memory. \n",
    "\n",
    "\n",
    "We use Cora here as an example, see [this notebook](./load-cora-into-neo4j.ipynb) for instructions on how to load the Cora dataset into Neo4j. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3",
   "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.3.0b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4",
   "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.3.0b\")\n",
    "except AttributeError:\n",
    "    raise ValueError(\n",
    "        f\"This notebook requires StellarGraph version 1.3.0b, 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,
   "id": "5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import stellargraph as sg\n",
    "from stellargraph.connector.neo4j import Neo4jStellarGraph\n",
    "from stellargraph.layer import GCN\n",
    "from stellargraph.mapper import ClusterNodeGenerator\n",
    "import tensorflow as tf\n",
    "import py2neo\n",
    "import os\n",
    "from sklearn import preprocessing, feature_extraction, model_selection\n",
    "\n",
    "import numpy as np\n",
    "import scipy.sparse as sps\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6",
   "metadata": {},
   "source": [
    "## Connect to Neo4j\n",
    "\n",
    "First we connect to the Neo4j with `py2neo`, we then create a `Neo4jStellarGraph` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7",
   "metadata": {},
   "outputs": [],
   "source": [
    "default_host = os.environ.get(\"STELLARGRAPH_NEO4J_HOST\")\n",
    "\n",
    "# Create the Neo4j Graph database object; port, user, password parameters can be add to specify location and authentication\n",
    "graph = py2neo.Graph(host=default_host)\n",
    "neo4j_sg = Neo4jStellarGraph(graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8",
   "metadata": {},
   "source": [
    "## Data labels\n",
    "\n",
    "Here we get the node labels. Cluster GCN is semi-supervised and requires labels to be specified for some nodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# read the node labels from a seperate file\n",
    "# note this function also returns a StellarGraph\n",
    "# which we won't be using for this demo - we only need Neo4jStellarGraph!\n",
    "_, labels = sg.datasets.Cora().load()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "10",
   "metadata": {},
   "outputs": [],
   "source": [
    "# split the node labels into train/test/val\n",
    "\n",
    "train_labels, test_labels = model_selection.train_test_split(\n",
    "    labels, train_size=140, test_size=None, stratify=labels\n",
    ")\n",
    "val_labels, test_labels = model_selection.train_test_split(\n",
    "    test_labels, train_size=500, test_size=None, stratify=test_labels\n",
    ")\n",
    "\n",
    "target_encoding = preprocessing.LabelBinarizer()\n",
    "\n",
    "train_targets = target_encoding.fit_transform(train_labels)\n",
    "val_targets = target_encoding.transform(val_labels)\n",
    "test_targets = target_encoding.transform(test_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11",
   "metadata": {},
   "source": [
    "## Neo4j Clustering\n",
    "\n",
    "We use one of the Neo4j Data Science Library's community detection algorithms to split our graph into clusters for ClusterGCN.\n",
    "\n",
    "We can use:\n",
    "\n",
    "- `louvain`: https://neo4j.com/docs/graph-data-science/current/algorithms/louvain/\n",
    "- `labelPropagation`: https://neo4j.com/docs/graph-data-science/current/algorithms/label-propagation/="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "12",
   "metadata": {},
   "outputs": [],
   "source": [
    "clusters = neo4j_sg.clusters(method=\"louvain\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13",
   "metadata": {},
   "source": [
    "## Keras sequences\n",
    "\n",
    "We now use `StellarGraph` to create Keras sequences for training, testing, and validation. Under the hood, these sequences connect to your Neo4j database and lazily load data for each cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of clusters 173\n",
      "0 cluster has size 118\n",
      "1 cluster has size 413\n",
      "2 cluster has size 167\n",
      "3 cluster has size 38\n",
      "4 cluster has size 67\n",
      "5 cluster has size 226\n",
      "6 cluster has size 18\n",
      "7 cluster has size 68\n",
      "8 cluster has size 26\n",
      "9 cluster has size 60\n",
      "10 cluster has size 83\n",
      "11 cluster has size 118\n",
      "12 cluster has size 73\n",
      "13 cluster has size 3\n",
      "14 cluster has size 22\n",
      "15 cluster has size 36\n",
      "16 cluster has size 237\n",
      "17 cluster has size 12\n",
      "18 cluster has size 1\n",
      "19 cluster has size 128\n",
      "20 cluster has size 41\n",
      "21 cluster has size 11\n",
      "22 cluster has size 60\n",
      "23 cluster has size 5\n",
      "24 cluster has size 3\n",
      "25 cluster has size 100\n",
      "26 cluster has size 27\n",
      "27 cluster has size 1\n",
      "28 cluster has size 39\n",
      "29 cluster has size 2\n",
      "30 cluster has size 18\n",
      "31 cluster has size 11\n",
      "32 cluster has size 3\n",
      "33 cluster has size 5\n",
      "34 cluster has size 8\n",
      "35 cluster has size 14\n",
      "36 cluster has size 3\n",
      "37 cluster has size 2\n",
      "38 cluster has size 51\n",
      "39 cluster has size 2\n",
      "40 cluster has size 5\n",
      "41 cluster has size 4\n",
      "42 cluster has size 10\n",
      "43 cluster has size 5\n",
      "44 cluster has size 15\n",
      "45 cluster has size 5\n",
      "46 cluster has size 1\n",
      "47 cluster has size 4\n",
      "48 cluster has size 3\n",
      "49 cluster has size 6\n",
      "50 cluster has size 1\n",
      "51 cluster has size 3\n",
      "52 cluster has size 6\n",
      "53 cluster has size 8\n",
      "54 cluster has size 2\n",
      "55 cluster has size 2\n",
      "56 cluster has size 1\n",
      "57 cluster has size 13\n",
      "58 cluster has size 1\n",
      "59 cluster has size 6\n",
      "60 cluster has size 1\n",
      "61 cluster has size 10\n",
      "62 cluster has size 10\n",
      "63 cluster has size 5\n",
      "64 cluster has size 2\n",
      "65 cluster has size 4\n",
      "66 cluster has size 12\n",
      "67 cluster has size 3\n",
      "68 cluster has size 2\n",
      "69 cluster has size 5\n",
      "70 cluster has size 1\n",
      "71 cluster has size 2\n",
      "72 cluster has size 1\n",
      "73 cluster has size 2\n",
      "74 cluster has size 2\n",
      "75 cluster has size 2\n",
      "76 cluster has size 2\n",
      "77 cluster has size 1\n",
      "78 cluster has size 2\n",
      "79 cluster has size 2\n",
      "80 cluster has size 9\n",
      "81 cluster has size 1\n",
      "82 cluster has size 2\n",
      "83 cluster has size 2\n",
      "84 cluster has size 1\n",
      "85 cluster has size 2\n",
      "86 cluster has size 2\n",
      "87 cluster has size 2\n",
      "88 cluster has size 1\n",
      "89 cluster has size 1\n",
      "90 cluster has size 2\n",
      "91 cluster has size 2\n",
      "92 cluster has size 1\n",
      "93 cluster has size 1\n",
      "94 cluster has size 2\n",
      "95 cluster has size 1\n",
      "96 cluster has size 2\n",
      "97 cluster has size 2\n",
      "98 cluster has size 2\n",
      "99 cluster has size 2\n",
      "100 cluster has size 3\n",
      "101 cluster has size 5\n",
      "102 cluster has size 5\n",
      "103 cluster has size 4\n",
      "104 cluster has size 1\n",
      "105 cluster has size 13\n",
      "106 cluster has size 1\n",
      "107 cluster has size 3\n",
      "108 cluster has size 3\n",
      "109 cluster has size 2\n",
      "110 cluster has size 2\n",
      "111 cluster has size 3\n",
      "112 cluster has size 2\n",
      "113 cluster has size 1\n",
      "114 cluster has size 1\n",
      "115 cluster has size 1\n",
      "116 cluster has size 2\n",
      "117 cluster has size 3\n",
      "118 cluster has size 2\n",
      "119 cluster has size 2\n",
      "120 cluster has size 2\n",
      "121 cluster has size 2\n",
      "122 cluster has size 12\n",
      "123 cluster has size 1\n",
      "124 cluster has size 4\n",
      "125 cluster has size 1\n",
      "126 cluster has size 2\n",
      "127 cluster has size 2\n",
      "128 cluster has size 1\n",
      "129 cluster has size 2\n",
      "130 cluster has size 1\n",
      "131 cluster has size 2\n",
      "132 cluster has size 8\n",
      "133 cluster has size 2\n",
      "134 cluster has size 2\n",
      "135 cluster has size 2\n",
      "136 cluster has size 1\n",
      "137 cluster has size 2\n",
      "138 cluster has size 1\n",
      "139 cluster has size 2\n",
      "140 cluster has size 3\n",
      "141 cluster has size 1\n",
      "142 cluster has size 2\n",
      "143 cluster has size 4\n",
      "144 cluster has size 2\n",
      "145 cluster has size 2\n",
      "146 cluster has size 2\n",
      "147 cluster has size 2\n",
      "148 cluster has size 2\n",
      "149 cluster has size 2\n",
      "150 cluster has size 2\n",
      "151 cluster has size 2\n",
      "152 cluster has size 1\n",
      "153 cluster has size 4\n",
      "154 cluster has size 1\n",
      "155 cluster has size 3\n",
      "156 cluster has size 2\n",
      "157 cluster has size 2\n",
      "158 cluster has size 1\n",
      "159 cluster has size 1\n",
      "160 cluster has size 3\n",
      "161 cluster has size 2\n",
      "162 cluster has size 1\n",
      "163 cluster has size 2\n",
      "164 cluster has size 2\n",
      "165 cluster has size 2\n",
      "166 cluster has size 2\n",
      "167 cluster has size 1\n",
      "168 cluster has size 2\n",
      "169 cluster has size 2\n",
      "170 cluster has size 1\n",
      "171 cluster has size 2\n",
      "172 cluster has size 2\n"
     ]
    }
   ],
   "source": [
    "# create the Neo4jClusterNodeGenerator\n",
    "# and the keras sequence objects\n",
    "\n",
    "generator = ClusterNodeGenerator(neo4j_sg, clusters=clusters)\n",
    "\n",
    "train_gen = generator.flow(train_labels.index, targets=train_targets)\n",
    "val_gen = generator.flow(val_labels.index, targets=val_targets)\n",
    "test_gen = generator.flow(test_labels.index, targets=test_targets)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15",
   "metadata": {},
   "source": [
    "## Create and train your model!\n",
    "\n",
    "Now we create and train the Cluster GCN model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the model\n",
    "cluster_gcn = GCN(\n",
    "    layer_sizes=[32, 32], generator=generator, activations=[\"relu\", \"relu\"], dropout=0.5,\n",
    ")\n",
    "\n",
    "x_in, x_out = cluster_gcn.in_out_tensors()\n",
    "predictions = tf.keras.layers.Dense(units=val_targets.shape[1], activation=\"softmax\")(\n",
    "    x_out\n",
    ")\n",
    "model = tf.keras.Model(x_in, predictions)\n",
    "model.compile(\n",
    "    optimizer=tf.keras.optimizers.Adam(lr=0.01),\n",
    "    loss=tf.keras.losses.categorical_crossentropy,\n",
    "    metrics=[\"acc\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ['...']\n",
      "  ['...']\n",
      "Train for 173 steps, validate for 173 steps\n",
      "Epoch 1/10\n",
      "173/173 [==============================] - 9s 50ms/step - loss: 0.4474 - acc: 0.2357 - val_loss: 0.8697 - val_acc: 0.3040\n",
      "Epoch 2/10\n",
      "173/173 [==============================] - 7s 41ms/step - loss: 0.3968 - acc: 0.3786 - val_loss: 0.6322 - val_acc: 0.6740\n",
      "Epoch 3/10\n",
      "173/173 [==============================] - 7s 42ms/step - loss: 0.2307 - acc: 0.5500 - val_loss: 0.7893 - val_acc: 0.4980\n",
      "Epoch 4/10\n",
      "173/173 [==============================] - 7s 41ms/step - loss: 0.1732 - acc: 0.6214 - val_loss: 0.7399 - val_acc: 0.5860\n",
      "Epoch 5/10\n",
      "173/173 [==============================] - 7s 42ms/step - loss: 0.1245 - acc: 0.8000 - val_loss: 0.8939 - val_acc: 0.6680\n",
      "Epoch 6/10\n",
      "173/173 [==============================] - 7s 41ms/step - loss: 0.1719 - acc: 0.8500 - val_loss: 1.3818 - val_acc: 0.5820\n",
      "Epoch 7/10\n",
      "173/173 [==============================] - 7s 41ms/step - loss: 0.1494 - acc: 0.8357 - val_loss: 0.9496 - val_acc: 0.7220\n",
      "Epoch 8/10\n",
      "173/173 [==============================] - 7s 41ms/step - loss: 0.1257 - acc: 0.8929 - val_loss: 0.7883 - val_acc: 0.7200\n",
      "Epoch 9/10\n",
      "173/173 [==============================] - 7s 40ms/step - loss: 0.1114 - acc: 0.9286 - val_loss: 0.6892 - val_acc: 0.7140\n",
      "Epoch 10/10\n",
      "173/173 [==============================] - 7s 42ms/step - loss: 0.1298 - acc: 0.8929 - val_loss: 0.7618 - val_acc: 0.7320\n"
     ]
    }
   ],
   "source": [
    "# train the model!\n",
    "history = model.fit(train_gen, validation_data=val_gen, epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  ['...']\n",
      "173/173 [==============================] - 4s 21ms/step - loss: 1.4353 - acc: 0.7689\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1.4352797645499302, 0.7688588]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# evaluate the model\n",
    "model.evaluate(test_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "19",
   "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",
   "id": "20",
   "metadata": {},
   "source": [
    "And that's it! We've trained a graph neural network without ever loading the whole graph into memory.\n",
    "\n",
    "Please refer to [cluster-gcn-node-classification](./../../node-classification/cluster-gcn-node-classification.ipynb) for **node embedding visualization**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21",
   "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/connector/neo4j/cluster-gcn-on-cora-neo4j-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/connector/neo4j/cluster-gcn-on-cora-neo4j-example.ipynb\" alt=\"Open In Colab\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\"/></a></td></tr></table>"
   ]
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}