notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "import collections\n",
    "import seaborn as sns\n",
    "from bokeh.io import output_file, output_notebook, show\n",
    "from bokeh.plotting import figure, from_networkx\n",
    "from bokeh.palettes import Spectral4\n",
    "from bokeh.models import (Plot, Range1d, Circle, EdgesAndLinkedNodes, MultiLine,\n",
    "                          NodesAndLinkedEdges, HoverTool, BoxZoomTool, TapTool,\n",
    "                          WheelZoomTool, PanTool, ResetTool)\n",
    "import random\n",
    "from fractions import Fraction\n",
    "\n",
    "import statistics\n",
    "import time\n",
    "from scipy import stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task A\n",
    "\n",
    "* Task A: analysis of cost. You can take two approaches (and preferably both) for this: (a) an algorithmic/complexity analysis of your algorithm, for example using Big O notation with respect to the input size; and (b) an experimental measurement of how long it takes for your code to build the network. For the latter, you can use any additional libraries you need for timing execution time of functions or cells, and then calculate averages, standard deviations, etc. It would be good if your experimental analysis shows these timings with respect to different input sizes, e.g. taking 10, 100, 1000 or 10000 input observations; and then plot how the cost changes with increasing input size. You can use that plot to justify if your algorithm is logarithmic, linear, quadratic, exponential, etc.\n",
    "* Task A: data structures. This is just to explain how you decided to encode your network (e.g. adjacency matrix, adjacency list, edge list, etc.) and the limitations of that encoding. For example, an edge list of integer nodes cannot store user names on itself. If you used additional data structures to store any supplemental information to the network, please describe them here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>thread_subject</th>\n",
       "      <th>username</th>\n",
       "      <th>page_name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>How to distinguish federal-level powers</td>\n",
       "      <td>Arctic.gnome</td>\n",
       "      <td>PropertytalkP1001.json</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>RFC</td>\n",
       "      <td>Circeus</td>\n",
       "      <td>PropertytalkP1001.json</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>RFC</td>\n",
       "      <td>Jane023</td>\n",
       "      <td>PropertytalkP1001.json</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Use for public offices</td>\n",
       "      <td>Jura1</td>\n",
       "      <td>PropertytalkP1001.json</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Use for non-public offices</td>\n",
       "      <td>Arctic.gnome</td>\n",
       "      <td>PropertytalkP1001.json</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13393</th>\n",
       "      <td>Merging with [[Property:P7]]</td>\n",
       "      <td>23PowerZ</td>\n",
       "      <td>PropertytalkP9.json</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13394</th>\n",
       "      <td>Merging with [[Property:P7]]</td>\n",
       "      <td>Haplology</td>\n",
       "      <td>PropertytalkP9.json</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13395</th>\n",
       "      <td>Merging with [[Property:P7]]</td>\n",
       "      <td>SPQRobin</td>\n",
       "      <td>PropertytalkP9.json</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13396</th>\n",
       "      <td>Merging with [[Property:P7]]</td>\n",
       "      <td>Andrew Gray</td>\n",
       "      <td>PropertytalkP9.json</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13397</th>\n",
       "      <td>Deprecated rank for legitimate son(s) of the ...</td>\n",
       "      <td>Jura1</td>\n",
       "      <td>PropertytalkP9.json</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>13398 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                          thread_subject      username  \\\n",
       "0               How to distinguish federal-level powers   Arctic.gnome   \n",
       "1                                                   RFC        Circeus   \n",
       "2                                                   RFC        Jane023   \n",
       "3                                Use for public offices          Jura1   \n",
       "4                            Use for non-public offices   Arctic.gnome   \n",
       "...                                                  ...           ...   \n",
       "13393                      Merging with [[Property:P7]]       23PowerZ   \n",
       "13394                      Merging with [[Property:P7]]      Haplology   \n",
       "13395                      Merging with [[Property:P7]]       SPQRobin   \n",
       "13396                      Merging with [[Property:P7]]    Andrew Gray   \n",
       "13397   Deprecated rank for legitimate son(s) of the ...         Jura1   \n",
       "\n",
       "                    page_name  \n",
       "0      PropertytalkP1001.json  \n",
       "1      PropertytalkP1001.json  \n",
       "2      PropertytalkP1001.json  \n",
       "3      PropertytalkP1001.json  \n",
       "4      PropertytalkP1001.json  \n",
       "...                       ...  \n",
       "13393     PropertytalkP9.json  \n",
       "13394     PropertytalkP9.json  \n",
       "13395     PropertytalkP9.json  \n",
       "13396     PropertytalkP9.json  \n",
       "13397     PropertytalkP9.json  \n",
       "\n",
       "[13398 rows x 3 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "properties_df = pd.read_csv(\"PROPERTIES.csv\")\n",
    "properties_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "thread_subject    5833\n",
       "username          1942\n",
       "page_name         2544\n",
       "dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "properties_df.nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_graph_time_complexity(df):\n",
    "    \n",
    "    test_sizes = [10, 100, 1000, 10000]\n",
    "    \n",
    "    for size in test_sizes:\n",
    "        \n",
    "        list_init = []\n",
    "\n",
    "        for loop in range(250):\n",
    "            \n",
    "            sample = df.sample(n=size)\n",
    "            \n",
    "            # Define two dictionaries to store the network representation\n",
    "            netwrk_dict = {}\n",
    "            ids = {} # names as keys\n",
    "            nodes = []\n",
    "\n",
    "            start_time = time.time()\n",
    "\n",
    "            # Iterate over each row in the dataframe\n",
    "            for _, row in df.iterrows():\n",
    "\n",
    "                # Create a candidate key made up of the thread subject and page name\n",
    "                candidate_key = row[\"thread_subject\"] + row[\"page_name\"]\n",
    "                username = row[\"username\"]\n",
    "\n",
    "                # Check if the user name is in the \"ids\" dictionary\n",
    "                # If not, assign a new unique ID and add to the \"ids\" dictionary\n",
    "                if username not in ids.keys():\n",
    "                    ids[username] = len(ids)\n",
    "\n",
    "                # Check if the candidate key is in the \"netwrk_dict\" dictionary\n",
    "                # If not, create a new entry with the user's ID as its first value\n",
    "                if candidate_key not in netwrk_dict.keys():\n",
    "                    netwrk_dict[candidate_key] = [ids[username]]\n",
    "\n",
    "                # If the candidate key exists, check if the user's ID is in its value list\n",
    "                # If not, add it to the list\n",
    "                else:\n",
    "                    if ids[username] not in netwrk_dict[candidate_key]:\n",
    "                        netwrk_dict[candidate_key].append(ids[username])\n",
    "\n",
    "                # Check if the user's ID is in the \"nodes\" list\n",
    "                # If not, add it to the list\n",
    "                if ids[username] not in nodes:\n",
    "                    nodes.append(ids[username])\n",
    "\n",
    "\n",
    "            edges=[]\n",
    "            for lst in netwrk_dict.values():\n",
    "                if len(lst) > 1:\n",
    "                    for subset in itertools.combinations(lst, 2):\n",
    "                        if tuple(sorted(subset)) not in edges:\n",
    "                            edges.append(tuple(sorted(subset)))\n",
    "\n",
    "\n",
    "            G = nx.Graph()\n",
    "            G.add_nodes_from(nodes)\n",
    "            G.add_edges_from(edges)\n",
    "            \n",
    "            list_init.append(time.time() - start_time)\n",
    "            \n",
    "        print(\"\\nSample Size: {}\".format(size))\n",
    "        print(\"Mean: {}\".format(statistics.mean(list_init)))\n",
    "        print(\"Standard Deviation: {}\".format(statistics.stdev(list_init)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Sample Size: 10\n",
      "Mean: 1.4765601511001587\n",
      "Standard Deviation: 0.12930048453384274\n",
      "\n",
      "Sample Size: 100\n",
      "Mean: 1.3920201864242554\n",
      "Standard Deviation: 0.03112434685655249\n",
      "\n",
      "Sample Size: 1000\n",
      "Mean: 1.3913463726043702\n",
      "Standard Deviation: 0.01646970672753604\n",
      "\n",
      "Sample Size: 10000\n",
      "Mean: 1.4011884746551513\n",
      "Standard Deviation: 0.017334325759895873\n"
     ]
    }
   ],
   "source": [
    "create_graph_time_complexity(properties_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define two dictionaries to store the network representation\n",
    "netwrk_dict = {}\n",
    "ids = {} # names as keys\n",
    "nodes = []\n",
    "\n",
    "# Iterate over each row in the dataframe\n",
    "for _, row in properties_df.iterrows():\n",
    "    \n",
    "    # Create a candidate key made up of the thread subject and page name\n",
    "    candidate_key = row[\"thread_subject\"] + row[\"page_name\"]\n",
    "    username = row[\"username\"]\n",
    "    \n",
    "    # Check if the user name is in the \"ids\" dictionary\n",
    "    # If not, assign a new unique ID and add to the \"ids\" dictionary\n",
    "    if username not in ids.keys():\n",
    "        ids[username] = len(ids)\n",
    "    \n",
    "    # Check if the candidate key is in the \"netwrk_dict\" dictionary\n",
    "    # If not, create a new entry with the user's ID as its first value\n",
    "    if candidate_key not in netwrk_dict.keys():\n",
    "        netwrk_dict[candidate_key] = [ids[username]]\n",
    "    \n",
    "    # If the candidate key exists, check if the user's ID is in its value list\n",
    "    # If not, add it to the list\n",
    "    else:\n",
    "        if ids[username] not in netwrk_dict[candidate_key]:\n",
    "            netwrk_dict[candidate_key].append(ids[username])\n",
    "            \n",
    "    # Check if the user's ID is in the \"nodes\" list\n",
    "    # If not, add it to the list\n",
    "    if ids[username] not in nodes:\n",
    "        nodes.append(ids[username])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "edges=[]\n",
    "for lst in netwrk_dict.values():\n",
    "    if len(lst) > 1:\n",
    "        for subset in itertools.combinations(lst, 2):\n",
    "            if tuple(sorted(subset)) not in edges:\n",
    "                edges.append(tuple(sorted(subset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = nx.Graph()\n",
    "G.add_nodes_from(nodes)\n",
    "G.add_edges_from(edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define two dictionaries to store the network representation\n",
    "netwrk2_dict = {}\n",
    "\n",
    "# Iterate over each row in the dataframe\n",
    "for _, row in properties_df.iterrows():\n",
    "    \n",
    "    # Create a candidate key made up of the thread subject and page name\n",
    "    candidate_key = row[\"page_name\"]\n",
    "    username = row[\"username\"]\n",
    "    \n",
    "    # Check if the candidate key is in the \"netwrk_dict\" dictionary\n",
    "    # If not, create a new entry with the user's ID as its first value\n",
    "    if candidate_key not in netwrk2_dict.keys():\n",
    "        netwrk2_dict[candidate_key] = [ids[username]]\n",
    "    \n",
    "    # If the candidate key exists, check if the user's ID is in its value list\n",
    "    # If not, add it to the list\n",
    "    else:\n",
    "        if ids[username] not in netwrk2_dict[candidate_key]:\n",
    "            netwrk2_dict[candidate_key].append(ids[username])\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "edges2=[]\n",
    "for lst in netwrk2_dict.values():\n",
    "    if len(lst) > 1:\n",
    "        for subset in itertools.combinations(lst, 2):\n",
    "            if tuple(sorted(subset)) not in edges2:\n",
    "                edges2.append(tuple(sorted(subset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "G2 = nx.Graph()\n",
    "G2.add_nodes_from(nodes)\n",
    "G2.add_edges_from(edges2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bokeh.io import export_png\n",
    "\n",
    "plot1 = Plot(width=1600, height=800,\n",
    "            x_range=Range1d(-1.1,1.1), y_range=Range1d(-1.1,1.1))\n",
    "plot1.title.text = \"Interactive plot demo\"\n",
    "\n",
    "plot1.add_tools(\n",
    "    HoverTool(tooltips=None),\n",
    "    TapTool(), BoxZoomTool(), WheelZoomTool(), PanTool(), ResetTool())\n",
    "graph_renderer = from_networkx(\n",
    "    G, nx.spring_layout, scale=2, center=(0,0))\n",
    "\n",
    "graph_renderer.node_renderer.glyph = Circle(size=2, fill_color=Spectral4[0])\n",
    "graph_renderer.node_renderer.selection_glyph = Circle(size=3, fill_color=Spectral4[2])\n",
    "graph_renderer.node_renderer.hover_glyph = Circle(size=2, fill_color=Spectral4[1])\n",
    "\n",
    "graph_renderer.edge_renderer.glyph = MultiLine(line_color=\"#CCCCCC\", line_alpha=0.8, line_width=1)\n",
    "graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2], line_width=1)\n",
    "graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1], line_width=1)\n",
    "\n",
    "graph_renderer.selection_policy = NodesAndLinkedEdges()\n",
    "graph_renderer.inspection_policy = EdgesAndLinkedNodes()\n",
    "\n",
    "plot1.renderers.append(graph_renderer)\n",
    "\n",
    "show(plot1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot2 = Plot(width=1600, height=800,\n",
    "            x_range=Range1d(-1.1,1.1), y_range=Range1d(-1.1,1.1))\n",
    "plot2.title.text = \"Interactive plot demo\"\n",
    "\n",
    "plot2.add_tools(\n",
    "    HoverTool(tooltips=None),\n",
    "    TapTool(), BoxZoomTool(), WheelZoomTool(), PanTool(), ResetTool())\n",
    "graph_renderer = from_networkx(\n",
    "    G2, nx.spring_layout, scale=2, center=(0,0))\n",
    "\n",
    "graph_renderer.node_renderer.glyph = Circle(size=2, fill_color=Spectral4[0])\n",
    "graph_renderer.node_renderer.selection_glyph = Circle(size=3, fill_color=Spectral4[2])\n",
    "graph_renderer.node_renderer.hover_glyph = Circle(size=2, fill_color=Spectral4[1])\n",
    "\n",
    "graph_renderer.edge_renderer.glyph = MultiLine(line_color=\"#CCCCCC\", line_alpha=0.8, line_width=1)\n",
    "graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2], line_width=1)\n",
    "graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1], line_width=1)\n",
    "\n",
    "graph_renderer.selection_policy = NodesAndLinkedEdges()\n",
    "graph_renderer.inspection_policy = EdgesAndLinkedNodes()\n",
    "\n",
    "plot2.renderers.append(graph_renderer)\n",
    "\n",
    "#output_file(\"interactive_graphs2.html\")\n",
    "show(plot2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What data structures did you choose to represent this network? How do you keep additional information that cannot be directly encoded as nodes and edges?\n",
    "- What was your algorithmic approach for building the network?\n",
    "- What was the cost (in time, with respect to the input size, etc.) of building the network?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- basic metric calculations\n",
    "- random network of same node size\n",
    "- small world network of same node size\n",
    "- rebuild network with a different definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_graph_statistics(graph):\n",
    "\n",
    "    print(\"Number of edges: {}\".format(\n",
    "        graph.number_of_edges()\n",
    "    ))\n",
    "    print(\"Number of nodes: {}\".format(\n",
    "        graph.number_of_nodes()\n",
    "    ))\n",
    "    print(\"Number of connected components: {}\".format(\n",
    "        nx.number_connected_components(graph)\n",
    "    ))\n",
    "    print(\"Clustering coefficient: {}\".format(\n",
    "        nx.algorithms.cluster.average_clustering(graph)\n",
    "    ))\n",
    "    print(\"Average Degree: {}\".format(\n",
    "        sum(degree[1] for degree in graph.degree)/graph.number_of_nodes()\n",
    "    ))\n",
    "    \n",
    "    Gcc = sorted(nx.connected_components(graph), key=len, reverse=True)\n",
    "    G0 = graph.subgraph(Gcc[0])\n",
    "    \n",
    "    print(\"-------------------------------------\\nMetrics of Largest Connected Component\\n-------------------------------------\")\n",
    "    \n",
    "    print(\"Number of edges: {}\".format(\n",
    "        G0.number_of_edges()\n",
    "    ))\n",
    "    print(\"Number of nodes: {}\".format(\n",
    "        G0.number_of_nodes()\n",
    "    ))\n",
    "    print(\"{}% of the nodes within the entire network are in the largest connected component\".format(\n",
    "        round((G0.number_of_nodes()/graph.number_of_nodes())*100, 2)\n",
    "    ))\n",
    "    \n",
    "    print(\"Average path length: {}\".format(\n",
    "        nx.average_shortest_path_length(G0)\n",
    "    ))\n",
    "    \n",
    "    print(\"Clustering coefficient: {}\".format(\n",
    "        nx.algorithms.cluster.average_clustering(G0)\n",
    "    ))\n",
    "    print(\"Average Degree: {}\".format(\n",
    "        sum(degree[1] for degree in G0.degree)/G0.number_of_nodes()\n",
    "    ))\n",
    "    \n",
    "    try:  # attempt to compute the diameter of the graph\n",
    "        diam1 = nx.algorithms.approximation.distance_measures.diameter(G0)\n",
    "        print(\"Graph diameter (approximated): {}\".format(diam1))\n",
    "    except:  # an error has  occurred\n",
    "        print(\"\\nERROR: Could not compute the diameter of the graph.\")\n",
    "        \n",
    "    try:  # attempt to compute the diameter of the graph\n",
    "        diam2 = nx.algorithms.distance_measures.diameter(G0)\n",
    "        print(\"Graph diameter (calculated): {}\".format(diam2))\n",
    "    except:  # an error has  occurred\n",
    "        print(\"\\nERROR: Could not compute the diameter of the graph.\")\n",
    "        \n",
    "    degs = sorted(graph.degree, key=lambda x: x[1], reverse=True)\n",
    "    print(\"Node {} has the largest degree in the network of {}.\".format(\n",
    "        degs[0][0], degs[0][1]\n",
    "    ))\n",
    "\n",
    "    degree_sequence = [d for n, d in graph.degree()]\n",
    "    sum(degree_sequence)/len(degree_sequence)\n",
    "\n",
    "    degree_count = collections.Counter(degree_sequence)\n",
    "    deg, cnt = zip(*degree_count.items())\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(15,5))\n",
    "\n",
    "    plt.bar(deg, cnt, width=1.2, color=\"b\")\n",
    "    plt.title(\"Degree Histogram\")\n",
    "    plt.ylabel(\"Count\")\n",
    "    plt.xlabel(\"Degree\")\n",
    "    plt.show()\n",
    "\n",
    "#- What is the degree distribution of the network?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def centrality_df(input_list):\n",
    "    input_list.sort(key=lambda a: a[1], reverse=True)\n",
    "    df = pd.DataFrame(input_list[0:9])\n",
    "    df.rename(columns={0: 'nodes', 1: 'Centrality'}, inplace=True)\n",
    "    \n",
    "    df[\"nodes\"]=df[\"nodes\"].values.astype('str')\n",
    "    df[\"Centrality\"] = df[\"Centrality\"].round(decimals=4)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def centrality_measures(graph):\n",
    "    \n",
    "    deg_cent_df = centrality_df(list(nx.degree_centrality(graph).items()))\n",
    "    eigen_cent_df = centrality_df(list(nx.eigenvector_centrality(graph).items()))\n",
    "    close_cent_df = centrality_df(list(nx.closeness_centrality(graph).items()))\n",
    "    between_cent_df = centrality_df(list(nx.betweenness_centrality(graph).items()))\n",
    "\n",
    "    fig, axs = plt.subplots(2, 2, figsize=(15,15))\n",
    "\n",
    "    sns.barplot(ax=axs[0,0], x='Centrality', y='nodes', color='steelblue', data=deg_cent_df, orient=\"h\")\n",
    "    axs[0,0].bar_label(axs[0,0].containers[0])\n",
    "    axs[0,0].set_title(\"Degree Centrality\")\n",
    "\n",
    "    sns.barplot(ax=axs[0,1], x='Centrality', y='nodes', color='steelblue', data=eigen_cent_df, orient=\"h\")\n",
    "    axs[0,1].bar_label(axs[0,1].containers[0])\n",
    "    axs[0,1].set_title(\"EigenVector Centrality\")\n",
    "\n",
    "    sns.barplot(ax=axs[1,0], x='Centrality', y='nodes', color='steelblue', data=close_cent_df, orient=\"h\")\n",
    "    axs[1,0].bar_label(axs[1,0].containers[0])\n",
    "    axs[1,0].set_title(\"Closeness Centrality\")\n",
    "\n",
    "    sns.barplot(ax=axs[1,1], x='Centrality', y='nodes', color='steelblue', data=between_cent_df, orient=\"h\")\n",
    "    axs[1,1].bar_label(axs[1,1].containers[0])\n",
    "    axs[1,1].set_title(\"Betweenness Centrality\")\n",
    "\n",
    "    fig.suptitle('Centrality Measures', fontsize=24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = 9189 / (1942*1941/2)\n",
    "ER_graph = nx.erdos_renyi_graph(n=1942, p=p)\n",
    "WS_graph = nx.watts_strogatz_graph(n=1942, k=2, p=0.1)\n",
    "SF_graph = nx.Graph(nx.scale_free_graph(n=1942, delta_in=0, delta_out=0).to_undirected())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of edges: 9198\n",
      "Number of nodes: 1942\n",
      "Number of connected components: 304\n",
      "Clustering coefficient: 0.4705452909451652\n",
      "Average Degree: 9.472708547888775\n",
      "-------------------------------------\n",
      "Metrics of Largest Connected Component\n",
      "-------------------------------------\n",
      "Number of edges: 9174\n",
      "Number of nodes: 1618\n",
      "83.32% of the nodes within the entire network are in the largest connected component\n",
      "Average path length: 2.900909908856227\n",
      "Clustering coefficient: 0.5592082540268917\n",
      "Average Degree: 11.339925834363411\n",
      "\n",
      "ERROR: Could not compute the diameter of the graph.\n",
      "Graph diameter (calculated): 7\n",
      "Node 3 has the largest degree in the network of 627.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_graph_statistics(G)\n",
    "centrality_measures(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of edges: 47326\n",
      "Number of nodes: 1942\n",
      "Number of connected components: 64\n",
      "Clustering coefficient: 0.7466001178572761\n",
      "Average Degree: 48.739443872296604\n",
      "-------------------------------------\n",
      "Metrics of Largest Connected Component\n",
      "-------------------------------------\n",
      "Number of edges: 47318\n",
      "Number of nodes: 1872\n",
      "96.4% of the nodes within the entire network are in the largest connected component\n",
      "Average path length: 2.305505305906161\n",
      "Clustering coefficient: 0.7729152932045033\n",
      "Average Degree: 50.5534188034188\n",
      "\n",
      "ERROR: Could not compute the diameter of the graph.\n",
      "Graph diameter (calculated): 4\n",
      "Node 3 has the largest degree in the network of 1292.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_graph_statistics(G2)\n",
    "centrality_measures(G2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of edges: 9214\n",
      "Number of nodes: 1942\n",
      "Number of connected components: 1\n",
      "Clustering coefficient: 0.0042581740760025575\n",
      "Average Degree: 9.489186405767251\n",
      "-------------------------------------\n",
      "Metrics of Largest Connected Component\n",
      "-------------------------------------\n",
      "Number of edges: 9214\n",
      "Number of nodes: 1942\n",
      "100.0% of the nodes within the entire network are in the largest connected component\n",
      "Average path length: 3.616603818834824\n",
      "Clustering coefficient: 0.0042581740760025575\n",
      "Average Degree: 9.489186405767251\n",
      "\n",
      "ERROR: Could not compute the diameter of the graph.\n",
      "Graph diameter (calculated): 6\n",
      "Node 756 has the largest degree in the network of 20.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_graph_statistics(ER_graph)\n",
    "centrality_measures(ER_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of edges: 1942\n",
      "Number of nodes: 1942\n",
      "Number of connected components: 1\n",
      "Clustering coefficient: 0.0\n",
      "Average Degree: 2.0\n",
      "-------------------------------------\n",
      "Metrics of Largest Connected Component\n",
      "-------------------------------------\n",
      "Number of edges: 1942\n",
      "Number of nodes: 1942\n",
      "100.0% of the nodes within the entire network are in the largest connected component\n",
      "Average path length: 111.63178386500635\n",
      "Clustering coefficient: 0.0\n",
      "Average Degree: 2.0\n",
      "\n",
      "ERROR: Could not compute the diameter of the graph.\n",
      "Graph diameter (calculated): 297\n",
      "Node 30 has the largest degree in the network of 4.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "PowerIterationFailedConvergence",
     "evalue": "(PowerIterationFailedConvergence(...), 'power iteration failed to converge within 100 iterations')",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mPowerIterationFailedConvergence\u001B[0m           Traceback (most recent call last)",
      "\u001B[0;32m<ipython-input-21-d5de42084569>\u001B[0m in \u001B[0;36m<module>\u001B[0;34m\u001B[0m\n\u001B[1;32m      1\u001B[0m \u001B[0mprint_graph_statistics\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mWS_graph\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 2\u001B[0;31m \u001B[0mcentrality_measures\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mWS_graph\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m",
      "\u001B[0;32m<ipython-input-16-1a9cda7bb035>\u001B[0m in \u001B[0;36mcentrality_measures\u001B[0;34m(graph)\u001B[0m\n\u001B[1;32m      2\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      3\u001B[0m     \u001B[0mdeg_cent_df\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mcentrality_df\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mlist\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mnx\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mdegree_centrality\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mgraph\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mitems\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 4\u001B[0;31m     \u001B[0meigen_cent_df\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mcentrality_df\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mlist\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mnx\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0meigenvector_centrality\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mgraph\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mitems\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m      5\u001B[0m     \u001B[0mclose_cent_df\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mcentrality_df\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mlist\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mnx\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcloseness_centrality\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mgraph\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mitems\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      6\u001B[0m     \u001B[0mbetween_cent_df\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mcentrality_df\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mlist\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mnx\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mbetweenness_centrality\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mgraph\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mitems\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;32m<decorator-gen-285>\u001B[0m in \u001B[0;36meigenvector_centrality\u001B[0;34m(G, max_iter, tol, nstart, weight)\u001B[0m\n",
      "\u001B[0;32m/usr/lib/python3/dist-packages/networkx/utils/decorators.py\u001B[0m in \u001B[0;36m_not_implemented_for\u001B[0;34m(not_implement_for_func, *args, **kwargs)\u001B[0m\n\u001B[1;32m     80\u001B[0m             \u001B[0;32mraise\u001B[0m \u001B[0mnx\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mNetworkXNotImplemented\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mmsg\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     81\u001B[0m         \u001B[0;32melse\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 82\u001B[0;31m             \u001B[0;32mreturn\u001B[0m \u001B[0mnot_implement_for_func\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0margs\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkwargs\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m     83\u001B[0m     \u001B[0;32mreturn\u001B[0m \u001B[0m_not_implemented_for\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     84\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;32m/usr/lib/python3/dist-packages/networkx/algorithms/centrality/eigenvector.py\u001B[0m in \u001B[0;36meigenvector_centrality\u001B[0;34m(G, max_iter, tol, nstart, weight)\u001B[0m\n\u001B[1;32m    147\u001B[0m         \u001B[0;32mif\u001B[0m \u001B[0msum\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mabs\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mx\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mn\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;34m-\u001B[0m \u001B[0mxlast\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mn\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mfor\u001B[0m \u001B[0mn\u001B[0m \u001B[0;32min\u001B[0m \u001B[0mx\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;34m<\u001B[0m \u001B[0mnnodes\u001B[0m \u001B[0;34m*\u001B[0m \u001B[0mtol\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    148\u001B[0m             \u001B[0;32mreturn\u001B[0m \u001B[0mx\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 149\u001B[0;31m     \u001B[0;32mraise\u001B[0m \u001B[0mnx\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mPowerIterationFailedConvergence\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mmax_iter\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m    150\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    151\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;31mPowerIterationFailedConvergence\u001B[0m: (PowerIterationFailedConvergence(...), 'power iteration failed to converge within 100 iterations')"
     ]
    }
   ],
   "source": [
    "print_graph_statistics(WS_graph)\n",
    "centrality_measures(WS_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of edges: 2829\n",
      "Number of nodes: 1942\n",
      "Number of connected components: 1\n",
      "Clustering coefficient: 0.1691443422736807\n",
      "Average Degree: 2.913491246138002\n",
      "-------------------------------------\n",
      "Metrics of Largest Connected Component\n",
      "-------------------------------------\n",
      "Number of edges: 2829\n",
      "Number of nodes: 1942\n",
      "100.0% of the nodes within the entire network are in the largest connected component\n",
      "Average path length: 2.7964717137004027\n",
      "Clustering coefficient: 0.1691443422736807\n",
      "Average Degree: 2.913491246138002\n",
      "\n",
      "ERROR: Could not compute the diameter of the graph.\n",
      "Graph diameter (calculated): 8\n",
      "Node 0 has the largest degree in the network of 932.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_graph_statistics(SF_graph)\n",
    "centrality_measures(SF_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What are the characteristic properties and relevant metrics and distributions of this Wikidata editor network?\n",
    "- How different is this network from a random network?\n",
    "- If you take this network as a complete and representative description of editor networks in collaborative knowledge projects like Wikipedia and Wikidata, what does it tell you about the way editors talk among themselves and their social activity and connections?\n",
    "- How does your analysis change (metrics, comparison to random, social behaviour) if we now consider that two editors are connected iff they have both contributed to any thread in the same page, but not necessarily to the same thread?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task C\n",
    "\n",
    "A few additional clarifications about CW1, in particular regarding Task C:\n",
    "\n",
    "* There is no additional \"time\" information that we'll supply besides the CSVs (and the entailed networks you've extracted from them). When we say in the instructions that users have \"commented more than usual on the same day\", we really mean any definition of \"trolling\" that you think makes sense to consider. Some valid examples here are, for example, to count how many times two users have interacted in different threads and pages in a weighted graph, as a reflection of these two users possibly fighting and chasing each other over Wikidata; or to consider if two users have both many comments in different threads in the same page. You can be as creative as you like, as long as you can argue your choice.\n",
    "* To answer the questions, think about metrics and characteristics of Lesson 5 (homophily, similarity in metrics such as centrality, degree, etc.) as well as the parameters we have seen in cascading (e.g. network topology, choice of initial adopters, value of the threshold q). Try to give both theoretical and empirical justifications (e.g. via epidemic models), and make all the assumptions that you consider necessary (e.g. \"I assume that the threshold q<=1/2\") but it will be valuable if you can give different results over different assumptions.\n",
    "\n",
    "We hope this helps in clarifying. This task is purposefully ambiguous to allow you to be creative in your responses, so please be as concise and explicit as you can in your reports to reflect your choices and justifications."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "weighted graph, weight determines probability of trolling\n",
    "no way to judge baseline - although would be nice. You could determin probability as a function of the percentage over baseline and common comments\n",
    "also, if someone is a troll they are more likely to troll everyday"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_weight(source_edge, target_edge, graph):\n",
    "    decimal_object = Fraction(graph.get_edge_data(source_edge,target_edge)[\"weight\"]).limit_denominator(max_denominator=100000)    \n",
    "    _, denominator = decimal_object.as_integer_ratio()\n",
    "    \n",
    "    return denominator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_network_dict = netwrk_dict\n",
    "id_pairs = {}\n",
    "\n",
    "# Iterate over each thread and the list of IDs that commented on it\n",
    "for _, id_s in weighted_network_dict.items():\n",
    "    \n",
    "    # Iterate over all pairs of IDs in the list\n",
    "    for i, id1 in enumerate(id_s):\n",
    "        for j, id2 in enumerate(id_s[i+1:], start=i+1):\n",
    "            \n",
    "            # If this pair of IDs has not been seen before, add it to the dictionary with a weight of 1\n",
    "            if (id1, id2) not in id_pairs and (id2, id1) not in id_pairs:\n",
    "                id_pairs[(id1, id2)] = 1\n",
    "            \n",
    "            # If this pair of IDs has been seen before, increment its weight by 1\n",
    "            else:\n",
    "                if (id1, id2) in id_pairs:\n",
    "                    id_pairs[(id1, id2)] += 1\n",
    "                else:\n",
    "                    id_pairs[(id2, id1)] += 1\n",
    "\n",
    "# Convert the dictionary to a list of lists\n",
    "weighted_edges = [(id1, id2, 1/weight) for (id1, id2), weight in id_pairs.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "weighted_G = nx.Graph()\n",
    "weighted_G.add_nodes_from(nodes)\n",
    "weighted_G.add_weighted_edges_from(weighted_edges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot3 = Plot(width=1600, height=800,\n",
    "            x_range=Range1d(-1.1,1.1), y_range=Range1d(-1.1,1.1))\n",
    "plot3.title.text = \"Interactive plot demo\"\n",
    "\n",
    "plot3.add_tools(\n",
    "    HoverTool(tooltips=None),\n",
    "    TapTool(), BoxZoomTool(), WheelZoomTool(), PanTool(), ResetTool())\n",
    "graph_renderer = from_networkx(\n",
    "    weighted_G, nx.spring_layout, scale=2, center=(0,0))\n",
    "\n",
    "graph_renderer.node_renderer.glyph = Circle(size=2, fill_color=Spectral4[0])\n",
    "graph_renderer.node_renderer.selection_glyph = Circle(size=3, fill_color=Spectral4[2])\n",
    "graph_renderer.node_renderer.hover_glyph = Circle(size=2, fill_color=Spectral4[1])\n",
    "\n",
    "graph_renderer.edge_renderer.glyph = MultiLine(line_color=\"#CCCCCC\", line_alpha=0.8, line_width=1)\n",
    "graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2], line_width=1)\n",
    "graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1], line_width=1)\n",
    "\n",
    "graph_renderer.selection_policy = NodesAndLinkedEdges()\n",
    "graph_renderer.inspection_policy = EdgesAndLinkedNodes()\n",
    "\n",
    "plot3.renderers.append(graph_renderer)\n",
    "\n",
    "#output_file(\"interactive_graphs2.html\")\n",
    "show(plot3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_weight = sorted(nx.connected_components(weighted_G), key=len, reverse=True)\n",
    "weighted_largest_component = weighted_G.subgraph(sorted_weight[0])\n",
    "\n",
    "sorted_weight = sorted(nx.connected_components(G), key=len, reverse=True)\n",
    "unweighted_largest_component = G.subgraph(sorted_weight[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance in unweighted graph: 3\n",
      "Distance in weighted graph: 2.0625\n"
     ]
    }
   ],
   "source": [
    "random_node_1, random_node_2 = random.sample(list(unweighted_largest_component.nodes()), 2)\n",
    "\n",
    "# Calculate distance in unweighted graph\n",
    "unweighted_distance = nx.shortest_path_length(unweighted_largest_component, source=random_node_1, target=random_node_2)\n",
    "\n",
    "# Calculate distance in weighted graph\n",
    "weighted_distance = nx.bellman_ford_path_length(weighted_largest_component, source=random_node_1, target=random_node_2, weight='weight')\n",
    "\n",
    "print(\"Distance in unweighted graph:\", unweighted_distance)\n",
    "print(\"Distance in weighted graph:\", weighted_distance)\n",
    "#print(\"From: {}, To: {}\".format(list(ids.keys())[list(ids.values()).index(random_node_1)], list(ids.keys())[list(ids.values()).index(random_node_2)]))\n",
    "#print(\"Distance in weighted graph:\", weighted_distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The path from 1122 -> 658\n",
      "1122 -> 156, weight:1\n",
      "156 -> 3, weight:16\n",
      "3 -> 658, weight:1\n",
      "\n",
      "The path from 1122 -> 658\n",
      "1122 -> 156, weight:1\n",
      "156 -> 16, weight:7\n",
      "16 -> 658, weight:1\n",
      "\n",
      "The path from 1122 -> 658\n",
      "1122 -> 358, weight:1\n",
      "358 -> 3, weight:1\n",
      "3 -> 658, weight:1\n",
      "\n",
      "The path from 1122 -> 658\n",
      "1122 -> 218, weight:1\n",
      "218 -> 3, weight:3\n",
      "3 -> 658, weight:1\n",
      "\n",
      "The path from 1122 -> 658\n",
      "1122 -> 218, weight:1\n",
      "218 -> 16, weight:1\n",
      "16 -> 658, weight:1\n",
      "\n",
      "The path from 1122 -> 658\n",
      "1122 -> 351, weight:1\n",
      "351 -> 3, weight:9\n",
      "3 -> 658, weight:1\n",
      "\n",
      "\n",
      "[[1122, 156, 3, 658], [1122, 156, 16, 658], [1122, 358, 3, 658], [1122, 218, 3, 658], [1122, 218, 16, 658], [1122, 351, 3, 658]]\n",
      "0.16666666666666666\n"
     ]
    }
   ],
   "source": [
    "paths = list(nx.all_simple_paths(unweighted_largest_component, source=random_node_1, target=random_node_2, cutoff=unweighted_distance))\n",
    "\n",
    "for path in paths:   \n",
    "    past_edge = -1\n",
    "    print(\"\\nThe path from {} -> {}\".format(random_node_1, random_node_2))\n",
    "\n",
    "\n",
    "    for edge in path:\n",
    "        current_edge = edge\n",
    "        if past_edge != -1:\n",
    "            \n",
    "            \n",
    "            print(\"{} -> {}, weight:{}\".format(past_edge, current_edge, find_weight(past_edge,current_edge, weighted_largest_component)))\n",
    "        \n",
    "        past_edge = current_edge\n",
    "        \n",
    "print(\"\\n\")\n",
    "print(list(paths))\n",
    "print(weighted_largest_component.get_edge_data(308,3)[\"weight\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(3, 16, 16), (264, 16, 15), (530, 16, 14), (167, 16, 13), (1581, 16, 12), (1351, 16, 11), (1907, 16, 1), (1908, 16, 1), (1909, 16, 1), (1910, 16, 1), (1911, 16, 1), (1912, 16, 1), (1913, 16, 1), (1914, 16, 1), (1915, 16, 1), (1917, 16, 1)]\n"
     ]
    }
   ],
   "source": [
    "random_node = random.choice(list(unweighted_largest_component.nodes()))\n",
    "centrality_dict = nx.betweenness_centrality(unweighted_largest_component)\n",
    "\n",
    "priority_list = []\n",
    "nodes_to_rank = []\n",
    "weights_to_rank = []\n",
    "centrality_to_rank = [] \n",
    "    \n",
    "for node in weighted_largest_component[random_node]:\n",
    "    nodes_to_rank.append(node)\n",
    "    weights_to_rank.append(find_weight(random_node, node, weighted_largest_component))\n",
    "    centrality_to_rank.append(centrality_dict[node])\n",
    "\n",
    "weight_ranks = stats.rankdata(weights_to_rank, method='max')\n",
    "centrality_ranks = stats.rankdata(centrality_to_rank, method='min')\n",
    "\n",
    "for i in range(len(nodes_to_rank)):\n",
    "    priority_list.append((nodes_to_rank[i], weight_ranks[i], centrality_ranks[i]))\n",
    "\n",
    "priority_list.sort(key=lambda a: a[1]+a[2], reverse=True)\n",
    "print(priority_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}