graph analysis quickstart.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quickstart: Graph Databases in Python\n",
    "### Working with Neo4j and NetworkX\n",
    "\n",
    "Graph databases are a powerful tool for modeling complex relationships, detecting trends across networks, and querying information in ways simply unachievable with traditional relational databases.\n",
    "\n",
    "At present, Neo4j is the industry leading graph database engine, utilizing the flexible and intuitive <em>Cypher</em> language to run sophisticated queries. Neo4j excels at storing and interacting with large scale graph databases.\n",
    "\n",
    "That said, Neo4j is an imperfect product. Its documentation is often disjointed and opaque--particularly if you are looking to connect to a graph via Python or R. Major changes are frequently implemented without updates to the official guides, and most of the information available on StackOverflow or similar sites is out-of-date after recent changes. I love this platform--and am excited about its future--but its current form isn't exactly straightforward.\n",
    "\n",
    "Neo4j also disappoints as an analysis platform, requiring clunky (and often buggy) commands to run basic algorithms. The recently released Graph Algorithms plugin shows promise, but is currently an inconsistent experience.\n",
    "\n",
    "To fill in the gaps, I prefer Python's NetworkX module for analysis and the Gephi visualization tool to present results. This is hardly a perfect workflow, but at least its a reliable one.\n",
    "\n",
    "If you have any questions (or if you find better way of doing this) hit me up at gray.ian.hunter@gmail or on Twitter @IanHGray. I by no means consider myself an expert in graph analysis, but I *do* have a high threshold for pain when it comes to reading documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import dependencies\n",
    "from py2neo import Graph, Node, Relationship\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Open connection to the Neo4j graph via bolt. In this case, we're using Neo4j desktop.\n",
    "graph = Graph(\"bolt://localhost:7687\", auth=('neo4j', 'PASSWORD HERE'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading Data into Neo4j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we'll create some dummy data. In this case, we're looking at bands that spun off from the Yardbirds, one of rock & roll's first power groups and the precursor to Led Zeppelin. (Fun fact, did you know that Eric Clapton is the only triple inductee to the Rock & Roll hall of fame? He was awarded for his work in the Yardbirds, Cream, and as a solo artist.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           Musician             Band Instrument\n",
      "0      Eric Clapton        Yardbirds     Guitar\n",
      "1         Jeff Beck        Yardbirds     Guitar\n",
      "2        Jimmy Page        Yardbirds     Guitar\n",
      "3      Eric Clapton            Cream     Guitar\n",
      "4      Ginger Baker            Cream       Bass\n",
      "5        Jack Bruce            Cream      Drums\n",
      "6         Jeff Beck  Jeff Beck Group     Guitar\n",
      "7        Tim Bogert  Jeff Beck Group       Bass\n",
      "8    Carmine Appice  Jeff Beck Group      Drums\n",
      "9        Jimmy Page     Led Zeppelin     Guitar\n",
      "10     Robert Plant     Led Zeppelin      Vocal\n",
      "11  John Paul Jones     Led Zeppelin   Keyboard\n",
      "12      John Bonham     Led Zeppelin      Drums\n"
     ]
    }
   ],
   "source": [
    "dataframe = pd.DataFrame({'Musician':['Eric Clapton','Jeff Beck','Jimmy Page',\\\n",
    " 'Eric Clapton','Ginger Baker','Jack Bruce','Jeff Beck','Tim Bogert','Carmine Appice',\\\n",
    " 'Jimmy Page','Robert Plant','John Paul Jones','John Bonham'],\n",
    "\n",
    "'Band':['Yardbirds','Yardbirds','Yardbirds','Cream','Cream','Cream',\\\n",
    "'Jeff Beck Group','Jeff Beck Group','Jeff Beck Group','Led Zeppelin','Led Zeppelin',\\\n",
    "'Led Zeppelin','Led Zeppelin'],\n",
    "                             \n",
    "'Instrument':['Guitar','Guitar','Guitar','Guitar','Bass','Drums',\\\n",
    "'Guitar','Bass','Drums','Guitar','Vocal','Keyboard','Drums']})\n",
    "\n",
    "#Lets print the dataframe to see how it looks in tabular form.\n",
    "print (dataframe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A powerful feature of graph databases is their ability to assign uniqueness to properties.\n",
    "We call that explicitly here, as there is only one instance of a musician and a band, although they can\n",
    "have different arrangements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph.schema.create_uniqueness_constraint('musician', 'musician_name')\n",
    "graph.schema.create_uniqueness_constraint('band', 'band_name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because this is a relatively small dataset, we can iterate over its elements to insert into the graph.\n",
    "For larger datasets, it may be necessary to use Neo4j's native data loading procedures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "for index, rows in dataframe.iterrows():\n",
    "    musician_name = rows['Musician']\n",
    "    band_name = rows['Band']\n",
    "    instrument = rows['Instrument']\n",
    "    \n",
    "    #Create a Node object with information about the musician. Note that in this newer version of\n",
    "    #py2neo, we have to explicitly declare primarylabel and primarykey.\n",
    "    musician = Node('musician', musician_name = musician_name, instrument = instrument)\n",
    "    musician.__primarylabel__='musician'\n",
    "    musician.__primarykey__='musician_name'\n",
    "    \n",
    "    #Create a Node object for the band\n",
    "    band = Node('band', band_name = band_name)\n",
    "    band.__primarylabel__='band'\n",
    "    band.__primarykey='band_name'\n",
    "    \n",
    "    #Create a Relationship object, describing the connection\n",
    "    PLAYED_IN = Relationship.type(\"PLAYED_IN\")\n",
    "    \n",
    "    #Now insert nodes and relationship to the graph\n",
    "    graph.merge(PLAYED_IN(musician, band), 'musician_name', 'band_name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that the data is stored in Neo4j, we can run cypher queries against it, returning the results as\n",
    "pandas dataframe. In this case, we'll look for musicians who played in both the Yardbirds and Cream."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  m.instrument m.musician_name\n",
      "0       Guitar    Eric Clapton\n"
     ]
    }
   ],
   "source": [
    "neo_df = pd.DataFrame(graph.run(\n",
    "\"MATCH (m:musician)-[:PLAYED_IN]->(y:band {band_name:'Yardbirds'})\\\n",
    "MATCH (m)-[:PLAYED_IN]->(c:band {band_name:'Cream'})\\\n",
    "RETURN m.musician_name, m.instrument\").data())\n",
    "print (neo_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is Eric Clapton, because he's the best. But what if we want to add data from another source, which\n",
    "pairs the bands with the albums they released? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                  album  year             band\n",
      "0                         For Your Love  1965        Yardbirds\n",
      "1   Having a Rave Up with The Yardbirds  1965        Yardbirds\n",
      "2                             Yardbirds  1966        Yardbirds\n",
      "3              Over Under Sideways Down  1966        Yardbirds\n",
      "4                          Little Games  1967        Yardbirds\n",
      "5                           Fresh Cream  1966            Cream\n",
      "6                        Disraeli Gears  1967            Cream\n",
      "7                        Wheels of Fire  1968            Cream\n",
      "8                               Goodbye  1969            Cream\n",
      "9                          Led Zeppelin  1969     Led Zeppelin\n",
      "10                      Led Leppelin II  1969     Led Zeppelin\n",
      "11                     Led Zeppelin III  1970     Led Zeppelin\n",
      "12                      Led Zeppelin IV  1971     Led Zeppelin\n",
      "13                   Houses of the Holy  1973     Led Zeppelin\n",
      "14                    Physical Graffiti  1975     Led Zeppelin\n",
      "15                             Presence  1976     Led Zeppelin\n",
      "16              In Through the Out Door  1979     Led Zeppelin\n",
      "17                                Truth  1968  Jeff Beck Group\n",
      "18                             Beck-Ola  1969  Jeff Beck Group\n",
      "19                      Rough and Ready  1971  Jeff Beck Group\n",
      "20                      Jeff Beck Group  1972  Jeff Beck Group\n"
     ]
    }
   ],
   "source": [
    "albums_df = pd.DataFrame({'album':['For Your Love', 'Having a Rave Up with The Yardbirds',\\\n",
    "                                   'Yardbirds', 'Over Under Sideways Down', 'Little Games',\\\n",
    "                                 'Fresh Cream', 'Disraeli Gears', 'Wheels of Fire', 'Goodbye',\\\n",
    "                                 'Led Zeppelin', 'Led Leppelin II', 'Led Zeppelin III',\\\n",
    "                                   'Led Zeppelin IV', 'Houses of the Holy', 'Physical Graffiti',\\\n",
    "                                 'Presence', 'In Through the Out Door', 'Truth', 'Beck-Ola', 'Rough and Ready',\\\n",
    "                                  'Jeff Beck Group'],\n",
    "                        'year':[1965, 1965, 1966, 1966, 1967, 1966, 1967, 1968, 1969,\\\n",
    "                               1969, 1969, 1970, 1971, 1973, 1975, 1976, 1979, 1968, 1969, 1971, 1972],\n",
    "                          \n",
    "                        'band':['Yardbirds', 'Yardbirds', 'Yardbirds', 'Yardbirds', 'Yardbirds',\\\n",
    "                               'Cream', 'Cream', 'Cream', 'Cream', 'Led Zeppelin', 'Led Zeppelin',\\\n",
    "                                'Led Zeppelin', 'Led Zeppelin', 'Led Zeppelin', 'Led Zeppelin',\\\n",
    "                               'Led Zeppelin', 'Led Zeppelin', 'Jeff Beck Group', 'Jeff Beck Group',\\\n",
    "                               'Jeff Beck Group', 'Jeff Beck Group']})\n",
    "print(albums_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can merge the above dataset into the graph using the same technique as before.\n",
    "The MERGE operation will check to see if a node already exists, and then connect new data to it, or it will\n",
    "create a new node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph.schema.create_uniqueness_constraint('album', 'album_name')\n",
    "\n",
    "for index, rows in albums_df.iterrows():\n",
    "    album_name = rows['album']\n",
    "    band_name = rows['band']\n",
    "    year = rows['year']\n",
    "    \n",
    "    band = Node('band', band_name = band_name)\n",
    "    band.__primarylabel__='band'\n",
    "    band.__primarykey__='band_name'\n",
    "    \n",
    "    album = Node('album', album_name = album_name, year = year)\n",
    "    album.__primarylabel__='album'\n",
    "    album.__primarykey__='album_name'\n",
    "    \n",
    "    RELEASED = Relationship.type(\"RELEASED\")\n",
    "    \n",
    "    graph.merge(RELEASED(band, album), 'band_name', 'album')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final product should look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"yardbirds_network.png\", width = 1000, height=800>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"yardbirds_network.png\", width = 1000, height=800>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Cypher, we can calculate basic statistics about the network, for instance, the musicians who have the greatest number\n",
    "of connections within the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   degree         musician\n",
      "0       2     Eric Clapton\n",
      "1       2        Jeff Beck\n",
      "2       2       Jimmy Page\n",
      "3       1     Ginger Baker\n",
      "4       1       Jack Bruce\n",
      "5       1       Tim Bogert\n",
      "6       1   Carmine Appice\n",
      "7       1     Robert Plant\n",
      "8       1  John Paul Jones\n",
      "9       1      John Bonham\n"
     ]
    }
   ],
   "source": [
    "degree_df = pd.DataFrame(graph.run(\"MATCH (m:musician)\\\n",
    "                            RETURN m.musician_name as musician, size((m)-[]-()) AS degree\\\n",
    "                            ORDER BY degree DESC\").data())\n",
    "print(degree_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exporting Neo4j to NetworkX\n",
    "\n",
    "Now that our data is stored in Neo4j, we can take full advantage of its storage and querying capabilities. However, if we want to run more advanced analysis or create more customized visualizations, it is often best to pull the data out of the Neo4j environment.\n",
    "\n",
    "Unfortunately, there is no particularly elegant way to accomplish this. (Yes, there are some *theoretical* options you can find on github, but they seem to be more trouble than they're worth.) The best bet is to pull relevant data out of Neo4j as a Pandas DataFrame object, then reconstruct the graph in NetworkX. \n",
    "\n",
    "(For smaller/straightforward datasets, you can probably skip Neo4j entirely and just run everything in NetworkX. Neo4j is best used in situations where you're storing lots of data, or need advanced querying options.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import dependencies\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll start by reading our data out of Neo4j as a Pandas Dataframe object. This can be any query, but in this case we'll just pull everything.\n",
    "\n",
    "Note that we need to run separate queries for different relationship types. If you have a very complicated graph with many different relationship types, then you have my condolences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_musicians = pd.DataFrame(graph.run(\"MATCH (m:musician)-[:PLAYED_IN]->(b:band)\\\n",
    "                            RETURN m.musician_name as musician, b.band_name as band,\\\n",
    "                            m.instrument as instrument\").data())\n",
    "df_albums = pd.DataFrame(graph.run(\"MATCH (b:band)-[:RELEASED]->(a:album)\\\n",
    "                                    RETURN b.band_name as band, a.album_name as album, a.year as year\").data())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now load the dataframes into NetworkX. This process is almost identical to loading data into Neo4j. (There *are* more efficient ways of doing this, but for our purposes, we'll use the trusty for-loop)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Start by creating a blank networkX graph called \"G\". In this case, we're creating a directional graph (DiGraph).\n",
    "G = nx.DiGraph()\n",
    "\n",
    "#As before, iterate over each row in the dataframe and create the nodes and relationships.\n",
    "#Note that there *is* a nx.from_pandas_dataframe() function that should make this easier, \n",
    "#but it doesn't always import properly. Life is suffering.\n",
    "for index, rows in df_musicians.iterrows():\n",
    "    musician = rows['musician']\n",
    "    instrument = rows['instrument']\n",
    "    band = rows['band']\n",
    "    \n",
    "    G.add_node(musician, instrument=instrument, node_type='musician')\n",
    "    G.add_node(band, node_type='band')\n",
    "    G.add_edge(musician, band)\n",
    "\n",
    "#Now do the same with the albums dataframe.\n",
    "for index, rows in df_albums.iterrows():\n",
    "    band = rows['band']\n",
    "    album = rows['album']\n",
    "    year = rows['year']\n",
    "    G.add_node(album, node_type='album', year=year)\n",
    "    G.add_edge(band, album)\n",
    "\n",
    "#Note that I have created a new node attribute, *node_type*, that wasn't in the Neo4j graph.\n",
    "#NetworkX doesn't automatically differentiate between node types, so this will be helpful later\n",
    "#in the visualziation step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets take a quick look at the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: \n",
      "Type: DiGraph\n",
      "Number of nodes: 32\n",
      "Number of edges: 34\n",
      "Average in degree:   1.0625\n",
      "Average out degree:   1.0625\n"
     ]
    }
   ],
   "source": [
    "print(nx.info(G))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with Neo4j, we can call out individual nodes to examine their attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'instrument': 'Guitar', 'node_type': 'musician'}\n"
     ]
    }
   ],
   "source": [
    "print (G.node['Eric Clapton'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Visualization\n",
    "\n",
    "Now that our data is loaded, we have a few different choices on how to visualize the graph's structure.\n",
    "\n",
    "The first option is to use NetworkX's built in graph function, which calls on the Matplotlib library to produce a simple graph. This is useful in situations where we want just a quick glance at our results. \n",
    "\n",
    "But <b>*wow*<b> is it ugly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "nx.draw_networkx(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The pyvis module offers a better option--with the added benefit of interactivity--and requires minimal setup. It includes a helpful \"from_nx\" function that reads NetworkX graphs, and can then display them as an HTML object in Jupyter. (If the interactive visualization does not appear, try downloading and running this notebook)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"750px\"\n",
       "            src=\"example.html\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1d038a89748>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pyvis.network import Network\n",
    "net = Network(notebook=True, height=\"750px\", width=\"100%\")\n",
    "net.from_nx(G)\n",
    "net.show('example.html')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result should look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"static_pyvis_graph.png\", width = 1000, height=800>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"static_pyvis_graph.png\", width = 1000, height=800>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The third, and arguably best option is to export the network data from python and plot the results in Gephi or Cytoscape--two open source network visualization tools designed for this purpose. The following snippet will export the NetworkX graph as a .gexf file, which can be read by Gephi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.write_gexf(G, 'gephi_data.gexf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performing Network Analysis\n",
    "\n",
    "As shown below, running network analysis in NetworkX is pretty straightforward. We simply call the function on the graph object, and NetworkX returns a dictionary of each node and its associated score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Jimmy Page': 0.06451612903225806, 'Yardbirds': 0.29032258064516125, 'Jeff Beck': 0.06451612903225806, 'Eric Clapton': 0.06451612903225806, 'Jack Bruce': 0.03225806451612903, 'Cream': 0.22580645161290322, 'Ginger Baker': 0.03225806451612903, 'Carmine Appice': 0.03225806451612903, 'Jeff Beck Group': 0.25806451612903225, 'Tim Bogert': 0.03225806451612903, 'John Bonham': 0.03225806451612903, 'Led Zeppelin': 0.4193548387096774, 'John Paul Jones': 0.03225806451612903, 'Robert Plant': 0.03225806451612903, 'Little Games': 0.03225806451612903, 'Over Under Sideways Down': 0.03225806451612903, 'Having a Rave Up with The Yardbirds': 0.03225806451612903, 'For Your Love': 0.03225806451612903, 'Goodbye': 0.03225806451612903, 'Wheels of Fire': 0.03225806451612903, 'Disraeli Gears': 0.03225806451612903, 'Fresh Cream': 0.03225806451612903, 'Rough and Ready': 0.03225806451612903, 'Beck-Ola': 0.03225806451612903, 'Truth': 0.03225806451612903, 'In Through the Out Door': 0.03225806451612903, 'Presence': 0.03225806451612903, 'Physical Graffiti': 0.03225806451612903, 'Houses of the Holy': 0.03225806451612903, 'Led Zeppelin IV': 0.03225806451612903, 'Led Zeppelin III': 0.03225806451612903, 'Led Leppelin II': 0.03225806451612903}\n"
     ]
    }
   ],
   "source": [
    "degree_centrality = nx.degree_centrality(G)\n",
    "print(degree_centrality)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make this a little easier to work with, we can run the analysis and return the results in a pandas dataframe, indexed by Node. Below, each of the major centrality scores -- Degree, Betweenness, Closeness, and Eigenvector -- is returned as its own dataframe object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "degree_centrality = pd.DataFrame((nx.degree_centrality(G)).items(), columns = ['Node', 'Degree_Centrality']).set_index('Node')\n",
    "betweenness_centrality = pd.DataFrame((nx.betweenness_centrality(G)).items(), columns = ['Node', 'Betweenness_Centrality']).set_index('Node')\n",
    "closeness_centrality = pd.DataFrame((nx.closeness_centrality(G)).items(), columns = ['Node', 'Closeness_Centrality']).set_index('Node')\n",
    "eigenvector_centrality = pd.DataFrame((nx.eigenvector_centrality(G)).items(), columns = ['Node', 'Eigenvector_Centrality']).set_index('Node')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can combine the dataframes into a single view, and sort based on their degree centrality (or any other metric)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               Node  Degree_Centrality  Betweenness_Centrality  \\\n",
      "11     Led Zeppelin           0.419355                0.030108   \n",
      "1         Yardbirds           0.290323                0.012903   \n",
      "8   Jeff Beck Group           0.258065                0.009677   \n",
      "5             Cream           0.225806                0.012903   \n",
      "0        Jimmy Page           0.064516                0.000000   \n",
      "\n",
      "    Closeness_Centrality  Eigenvector_Centrality  \n",
      "11              0.129032            2.695824e-01  \n",
      "1               0.096774            2.156659e-01  \n",
      "8               0.096774            2.156659e-01  \n",
      "5               0.096774            4.499142e-07  \n",
      "0               0.000000            6.427346e-09  \n"
     ]
    }
   ],
   "source": [
    "results = degree_centrality.join(betweenness_centrality, how = 'inner').join(closeness_centrality, how ='inner')\\\n",
    "                            .join(eigenvector_centrality, how = 'inner').reset_index()\n",
    "results = results.sort_values(by=['Degree_Centrality'], ascending = False)\n",
    "print (results.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These results make sense, as Led Zeppelin has the most band members in the dataset, and produced the greatest number of albums. Since it has the most connections, it has the highest Degree Centrality. The other bands follow suit, based on the number of members they had and albums they released.\n",
    "\n",
    "If we instead sort by Eigenvector Centrality, we again find Led Zeppelin at the top, but this time its albums take the next highest places. This is because the Eigenvector algorithm (similar to PageRank) measures the closeness of a given node to other, highly influential nodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                       Node  Degree_Centrality  Betweenness_Centrality  \\\n",
      "11             Led Zeppelin           0.419355                0.030108   \n",
      "25  In Through the Out Door           0.032258                0.000000   \n",
      "30         Led Zeppelin III           0.032258                0.000000   \n",
      "28       Houses of the Holy           0.032258                0.000000   \n",
      "26                 Presence           0.032258                0.000000   \n",
      "\n",
      "    Closeness_Centrality  Eigenvector_Centrality  \n",
      "11              0.129032                0.269582  \n",
      "25              0.089606                0.269582  \n",
      "30              0.089606                0.269582  \n",
      "28              0.089606                0.269582  \n",
      "26              0.089606                0.269582  \n"
     ]
    }
   ],
   "source": [
    "results = results.sort_values(by=['Eigenvector_Centrality'], ascending = False)\n",
    "print (results.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And those are the basics. Beautiful and efficient, no, but it'll get the job done for small-to-medium sized projects. Neo4j is making great strides in evangelizing and democratizing graph databases, but there's still a ways to go before it is a frictionless experience.\n",
    "\n",
    "Also, go check out the Yardbirds."
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}