notebooks/WeightedConnectedComponents.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Weighted Connected Components\n",
    "The _Connected Components_ or _UnionFind_ algorithm finds sets of connected nodes in an undirected graph where each node is reachable from any other node in the same set.\n",
    "It differs from the SCC algorithm because it only needs a path to exist between pairs of nodes in one direction, whereas SCC needs a path to exist in both directions.\n",
    "As with SCC, UnionFind is often used early in an analysis to understand a graph's structure.\n",
    "\n",
    "First we'll import the Neo4j driver and Pandas libraries:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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": 21,
   "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": 22,
   "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)-[:FRIEND {weight:0.5}]->(nBridget)\n",
    "MERGE (nAlice)-[:FRIEND {weight:4}]->(nCharles)\n",
    "MERGE (nMark)-[:FRIEND {weight:1}]->(nDoug)\n",
    "MERGE (nMark)-[:FRIEND {weight:2}]->(nMichael);\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": 23,
   "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>user</th>\n",
       "      <th>setId</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Alice</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bridget</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Charles</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Doug</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Mark</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Michael</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      user  setId\n",
       "0    Alice      0\n",
       "1  Bridget      1\n",
       "2  Charles      0\n",
       "3     Doug      4\n",
       "4     Mark      4\n",
       "5  Michael      4"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "streaming_query = \"\"\"\n",
    "CALL algo.unionFind.stream('User', 'FRIEND', {weightProperty:'weight', defaultValue:0.0, threshold:1.0, concurrency: 1})\n",
    "YIELD nodeId,setId\n",
    "\n",
    "MATCH (u:User) WHERE id(u) = nodeId\n",
    "\n",
    "RETURN u.id AS user, setId\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": [
    "In this case we can see that because the weight of the relationship betwen Bridget and Alice is only 0.5, the relationship is ignored by the algorithm and Bridget ends up in her own component."
   ]
  },
  {
   "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": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "write_query = \"\"\"\n",
    "CALL algo.unionFind('User', 'FRIEND', {write:true, partitionProperty:\"partition\",weightProperty:'weight', defaultValue:0.0, threshold:1.0, concurrency: 1})\n",
    "YIELD nodes, setCount, loadMillis, computeMillis, writeMillis;\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": 25,
   "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": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "window.jsonGraph={\"query\": \"MATCH (p1:User)-[r:FRIEND]->(p2:User) RETURN *\", \"labels\": {\"User\": {\"caption\": \"id\", \"community\": \"partition\"}}, \"relationships\": {\"FRIEND\": {\"thickness\": \"weight\", \"caption\": false}}, \"host\": \"bolt://localhost\", \"user\": \"neo4j\", \"password\": \"neo\"};"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "execution_count": 26,
     "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(\"Weighted Connected Components\")\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": 27,
   "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": 29,
   "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": 29,
     "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
}