notebooks/DegreeCentrality.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Degree Centrality\n",
    "Degree Centrality is the simplest of all the centrality algorithms.\n",
    "It measures the number of incoming and outgoing relationships from a node.\n",
    "\n",
    "The algorithm can help us find popular nodes in a graph.\n",
    "\n",
    "First we'll import the Neo4j driver and Pandas libraries:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from neo4j.v1 import GraphDatabase, basic_auth\n",
    "import pandas as pd\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next let's create an instance of the Neo4j driver which we'll use to execute our queries.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "host = os.environ.get(\"NEO4J_HOST\", \"bolt://localhost\") \n",
    "user = os.environ.get(\"NEO4J_USER\", \"neo4j\")\n",
    "password = os.environ.get(\"NEO4J_PASSWORD\", \"neo\")\n",
    "driver = GraphDatabase.driver(host, auth=basic_auth(user, password))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's create a sample graph that we'll run the algorithm against.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stats: {}\n"
     ]
    }
   ],
   "source": [
    "create_graph_query = '''\n",
    "MERGE (nAlice:User {id:'Alice'})\n",
    "MERGE (nBridget:User {id:'Bridget'})\n",
    "MERGE (nCharles:User {id:'Charles'})\n",
    "MERGE (nDoug:User {id:'Doug'})\n",
    "MERGE (nMark:User {id:'Mark'})\n",
    "MERGE (nMichael:User {id:'Michael'})\n",
    "\n",
    "MERGE (nAlice)-[:FOLLOWS]->(nDoug)\n",
    "MERGE (nAlice)-[:FOLLOWS]->(nBridget)\n",
    "MERGE (nAlice)-[:FOLLOWS]->(nCharles)\n",
    "MERGE (nMark)-[:FOLLOWS]->(nDoug)\n",
    "MERGE (nMark)-[:FOLLOWS]->(nMichael)\n",
    "MERGE (nBridget)-[:FOLLOWS]->(nDoug)\n",
    "MERGE (nCharles)-[:FOLLOWS]->(nDoug)\n",
    "MERGE (nMichael)-[:FOLLOWS]->(nDoug)\n",
    "'''\n",
    "\n",
    "with driver.session() as session:\n",
    "    result = session.write_transaction(lambda tx: tx.run(create_graph_query))\n",
    "    print(\"Stats: \" + str(result.consume().metadata.get(\"stats\", {})))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we can run the algorithm by executing the following query:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>follows</th>\n",
       "      <th>followers</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Alice</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bridget</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Charles</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Doug</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Mark</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Michael</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      name  follows  followers\n",
       "0    Alice        3          0\n",
       "1  Bridget        1          1\n",
       "2  Charles        1          1\n",
       "3     Doug        0          5\n",
       "4     Mark        2          0\n",
       "5  Michael        1          1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming_query = \"\"\"\n",
    "MATCH (u:User)\n",
    "RETURN u.id AS name,\n",
    "       size((u)-[:FOLLOWS]->()) AS follows,\n",
    "       size((u)<-[:FOLLOWS]-()) AS followers\n",
    "\"\"\"\n",
    "\n",
    "with driver.session() as session:\n",
    "    result = session.read_transaction(lambda tx: tx.run(streaming_query))        \n",
    "    df = pd.DataFrame([r.values() for r in result], columns=result.keys())\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that Doug is the most popular user in our imaginary Twitter graph with 5 followers - all other users follow him but he doesn't follow anybody back.\n",
    "In the real Twitter network celebrities have very high follower counts but tend to follow very few back people.\n",
    "We could therefore consider Doug a celebrity!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also call a version of the algorithm that will store the result as a property on a\n",
    "node. This is useful if we want to run future queries that use the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "write_query = \"\"\"\n",
    "MATCH (u:User)\n",
    "set u.followers = size((u)<-[:FOLLOWS]-())\n",
    "\"\"\"\n",
    "\n",
    "with driver.session() as session:\n",
    "    session.write_transaction(lambda tx: tx.run(write_query))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph Visualisation\n",
    "\n",
    "Sometimes a picture can tell more than a table of results and this is often the case with graph algorithms. \n",
    "Let's see how to create a graph visualization using neovis.js.\n",
    "\n",
    "First we'll create a div into which we will generate the visualisation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">                \n",
       ".output_wrapper, .output {\n",
       "    height:auto !important;\n",
       "    max-height:600px;\n",
       "}\n",
       ".output_scroll {\n",
       "    box-shadow:none !important;\n",
       "    webkit-box-shadow:none !important;\n",
       "}\n",
       "\n",
       "#viz {\n",
       "    width: 300px;\n",
       "    height: 350px;\n",
       "    font: 22pt arial;\n",
       "}\n",
       "</style>  \n",
       "<div id=\"viz\"></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style type=\"text/css\">                \n",
    ".output_wrapper, .output {\n",
    "    height:auto !important;\n",
    "    max-height:600px;\n",
    "}\n",
    ".output_scroll {\n",
    "    box-shadow:none !important;\n",
    "    webkit-box-shadow:none !important;\n",
    "}\n",
    "\n",
    "#viz {\n",
    "    width: 300px;\n",
    "    height: 350px;\n",
    "    font: 22pt arial;\n",
    "}\n",
    "</style>  \n",
    "<div id=\"viz\"></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we need to define the query that the visualization will be generated from, along with config \n",
    "that describes which properties will be used for node size, node colour, and relationship width. \n",
    "\n",
    "We'll then define a JavaScript variable that contains all our parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "window.jsonGraph={\"query\": \"MATCH (p1:User)-[r:FOLLOWS]->(p2:User) RETURN *\", \"labels\": {\"User\": {\"caption\": \"id\", \"size\": \"followers\"}}, \"relationships\": {\"FOLLOWS\": {\"thickness\": \"weight\", \"caption\": false}}, \"host\": \"bolt://localhost\", \"user\": \"neo4j\", \"password\": \"neo\"};"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import Javascript\n",
    "import json\n",
    "from scripts.algo import viz_config, render_image\n",
    "\n",
    "config = viz_config(\"Degree Centrality\")\n",
    "query = config[\"query\"]\n",
    "labels_json = config[\"labels_json\"]\n",
    "relationships_json = config[\"relationships_json\"]\n",
    "\n",
    "json_graph = {\n",
    "    \"query\": query,\n",
    "    \"labels\": labels_json,\n",
    "    \"relationships\": relationships_json,\n",
    "    \"host\": host,\n",
    "    \"user\": user,\n",
    "    \"password\": password\n",
    "}\n",
    "\n",
    "Javascript(\"\"\"window.jsonGraph={};\"\"\".format(json.dumps(json_graph)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we're ready to call neovis.js and generate our graph visualisation. \n",
    "The following code will create an interactive graph into the div defined above.\n",
    "It will also extract an image representation of the graph and display that in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "var output_area = this;\n",
       "requirejs(['neovis.js'], function(NeoVis){    \n",
       "    var config = {\n",
       "      container_id: \"viz\",\n",
       "      server_url: window.jsonGraph.host,\n",
       "      server_user: window.jsonGraph.user,\n",
       "      server_password: window.jsonGraph.password,\n",
       "      labels: window.jsonGraph.labels,\n",
       "      relationships: window.jsonGraph.relationships,\n",
       "      initial_cypher: window.jsonGraph.query\n",
       "    };\n",
       "        \n",
       "    let viz = new NeoVis.default(config);\n",
       "    viz.render();\n",
       "    \n",
       "    viz.onVisualizationRendered(function(ctx) {\n",
       "      let imageSrc = ctx.canvas.toDataURL();\n",
       "      let kernel = IPython.notebook.kernel;\n",
       "      let command = \"image_src = '\" + imageSrc + \"'\";\n",
       "      kernel.execute(command);\n",
       "      \n",
       "      var cell_element = output_area.element.parents('.cell');\n",
       "      var cell_idx = Jupyter.notebook.get_cell_elements().index(cell_element);\n",
       "      var cell = Jupyter.notebook.get_cell(cell_idx+1);\n",
       "      cell.set_text(\"render_image(image_src)\")\n",
       "      cell.execute();\n",
       "    });\n",
       "});"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript\n",
    "var output_area = this;\n",
    "requirejs(['neovis.js'], function(NeoVis){    \n",
    "    var config = {\n",
    "      container_id: \"viz\",\n",
    "      server_url: window.jsonGraph.host,\n",
    "      server_user: window.jsonGraph.user,\n",
    "      server_password: window.jsonGraph.password,\n",
    "      labels: window.jsonGraph.labels,\n",
    "      relationships: window.jsonGraph.relationships,\n",
    "      initial_cypher: window.jsonGraph.query\n",
    "    };\n",
    "        \n",
    "    let viz = new NeoVis.default(config);\n",
    "    viz.render();\n",
    "    \n",
    "    viz.onVisualizationRendered(function(ctx) {\n",
    "      let imageSrc = ctx.canvas.toDataURL();\n",
    "      let kernel = IPython.notebook.kernel;\n",
    "      let command = \"image_src = '\" + imageSrc + \"'\";\n",
    "      kernel.execute(command);\n",
    "      \n",
    "      var cell_element = output_area.element.parents('.cell');\n",
    "      var cell_idx = Jupyter.notebook.get_cell_elements().index(cell_element);\n",
    "      var cell = Jupyter.notebook.get_cell(cell_idx+1);\n",
    "      cell.set_text(\"render_image(image_src)\")\n",
    "      cell.execute();\n",
    "    });\n",
    "});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img id=\"viz-image\" width=\"300px\" src=\"data:image/png;base64,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\" />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "render_image(image_src)"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}