Week 11 - Network Visualisation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 11: Network Visualisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once your model has been created, you will need to visualise your work to your audiences. This week we will look into how to visualise network. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drill"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "What are the differences between `for` and `while` loop?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "* `while` loop requires a counter initiated, if applicable.\n",
    "* `while` loop requires the counter to be increased explicitly.\n",
    "* `for` loop does not change the objects inside the loop back to outside."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "What is the difference between supervised and unsupervised learning?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "Supervised learning trains with a target variable while unsupervised does not. So they look for patterns within data. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Terminologies of Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Network is a visual representation of linked objects. An example of network is shown in below: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/Network.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Network is composed of __nodes__ and connected by __links__ (sometimes called __edges__ from graph theory). For example, \n",
    "* A person represents a node\n",
    "* Relationships link each person"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "__Exercise:__ What would be nodes or links/ edges in the following situation? \n",
    "* During an epidemic. \n",
    "* Your friends and aquaintances on social media. \n",
    "* Organisation chart. \n",
    "* Genetic interations of E Coli. \n",
    "* Traffic flow of Sydney."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden"
   },
   "source": [
    "__Solution__\n",
    "\n",
    "| __Question__ | __Node__ | __Link__              |\n",
    "|--------------|----------|-----------------------|\n",
    "| 1            | Person   | Interactions          |\n",
    "| 2            | Person   | Relationships         |\n",
    "| 3            | Staff    | Work relationships    |\n",
    "| 4            | Operons  | Transcription factors |\n",
    "| 5            | Place    | Road/ rail/ air link  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also make variants to network links by adding weights into them. This is presented as numerical labels into the links. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/NetworkWeight.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see from the figure above, the left edge is heavier than the right edge. Weights are important when we would like to characterise the interactions and compare them. For example, it can mean how significant is our relationships compared to our other friends. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Network Types: Undirected, Directed, Multigraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links can be tailored to represent different types of relationships. For example, one way roads is represented as an arrow from onw node to another, but the opposite direction. This is a __directed graph__. The type of networks where its links does not have a direction are called __undirected__ graphs. These link represents the interactions are bidirectional. \n",
    "\n",
    "There is a type of network called multigraph, which means there are not only one way to link from a node to another. For example, from you can either walk or take a bus to university. Each modes of transport are represented by one link. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/NetworkType.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "__Exercise:__ Give examples if the following situations could be modelled as directed, multigraph or undirected networks?\n",
    "\n",
    "* Local road traffic network\n",
    "* State highway traffic network\n",
    "* Social relationships"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden"
   },
   "source": [
    "__Solution__\n",
    "\n",
    "| __Question__ | __Situation__                   | __Link__              |\n",
    "|--------------|---------------------------------|-----------------------|\n",
    "| 1            | Local road traffic network      | Directed              |\n",
    "| 2            | State highway traffic network   | Undirected            |\n",
    "| 3            | Social relationships            | Undirected            |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Network Science Quantities and Metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A network is complex in its topologies. So at its first glance it is not intuitive to describe a network quantitatively. Fortunately, network science has brought in many ideas from graph theory (from mathematics). The following summarises the quantative features from graph theory: \n",
    "* __Degree__ The number of links connected to a node. \n",
    "* __Distance__ We treat each link has length $1$. \n",
    "* __Diameter__ This is the longest shortest path from a node to another in one network/ graph. \n",
    "* __Complete graph__ All nodes are directly linked one another. \n",
    "* __Path__ All viable sequences between two nodes. For example, between nodes $A$ and $B$ is node $C$. So the paths between nodes $A$ and $B$ are $A\\;-\\;B$, $B\\;-\\;C$ and $A\\;-\\;C$. \n",
    "* __Cycle__ A composite path that will run back to the same node without other nodes bypassed twice (or more). \n",
    "\n",
    "These basic measurements are important to further infer from the network. Furthermore, we can interpolate more social aspects of network. For example, __homophily__ and __weak ties__ shows how close the people (nodes) are located. Homophily means the similarlity between people. Weak ties often describes two acquaintences, it is important because in reality we met much more acquaintences than close friends and family members. Acquaintences are very helpful in resource refer or sharing and this is one of the topic of the connections between social science and network science. We can also identify __communities__ with a social network. Communities are a group of people whom they share resources and membership of the same. In network science, we develop several metrics to infer these qualitative ideas. For example, \n",
    "\n",
    "* __Closeness__ This is to measure how near are all nodes. For example, if all nodes are directly linked, the network is obviously closed together. \n",
    "* __Betweenness__ Imagine the links have flow inside them. This measures how often the link is occupied by measure the number of shortest paths passing through the link. \n",
    "* __Assortativity__ This is to find out if people are prefered to attached to others. This metric measures the degrees of each node and measure how they correlated with their neighbours. \n",
    "* __PageRank__ Famous for the ranking search results by Google. One intuition is that imagine a person randomly pass through different pages, linked by hyperlinks. The page's popularity is measured by how many in-links to the page itself. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So let us start coding with network using `NetworkX` in below. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NetworkX"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NetworkX is a Python popular package in visualising and analysing data. To initiate the network analysis using NetworkX, we use \n",
    "```python\n",
    "import networkx as nx\n",
    "```\n",
    "When analysing networks, it is best to visualise them. To do so, we can use `matplotlib` to plot the network. This is done by \n",
    "```python\n",
    "from matlibplot import pyplot as plt\n",
    "%matplotlib inline \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, networks are its own data type. We start using `networkx` by creating the network object. This can be done by \n",
    "```python \n",
    "# Undirected graph\n",
    "undirected_graph = nx.Graph()\n",
    "\n",
    "# Directed graph\n",
    "directed_graph = nx.DiGraph()\n",
    "\n",
    "# Multigraph\n",
    "multi_graph = nx.MultiGraph()\n",
    "multi_digraph = nx.MultiDiGraph()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The empty bracket does not need to be blank. Rather, we can fill in the nodes and edges in the bracket. For example, if node $1$ is linked with node $2$. Then we write \n",
    "```python\n",
    "g = nx.Graph([(1,2)])\n",
    "```\n",
    "Where `g` is a conventional name for graphs when we coding in Python. \n",
    "\n",
    "If we have created the network already. That is fine, we can still add the edges by \n",
    "```python\n",
    "# Network `g` has created.\n",
    "g.add_nodes_from([(1,2)])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the network has more than one links, we input multiple tuples as additional edges. For example, nodes $1$ are linked with nodes $3$ and $4$. So we write \n",
    "```python\n",
    "# Using the same example\n",
    "# Create network from scratch\n",
    "g = nx.Graph([(1,2), (1,3), (1,4)])\n",
    "```\n",
    "\n",
    "```python\n",
    "# Using the same example\n",
    "# Add new links\n",
    "g.add_nodes_from([(1,3), (1,4)])\n",
    "```\n",
    "\n",
    "Of course, `networkx` has `Graph.add_node()` and `Graph.add_nodes_from([(u1,v1),(u2,v2)])` methods to add the nodes without connecting with the network. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/Network_Create.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code that create a network as shown in the figure above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code \n",
    "import networkx as nx\n",
    "\n",
    "g = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "import networkx as nx\n",
    "\n",
    "g = nx.Graph([(1,2),(1,3),(2,4),(3,4),(3,5),(2,6),(2,7)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's dig deep into a network object. If we simply print the `g` as in below, we can see that it is a `Graph` object. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "solution": "hidden"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<networkx.classes.graph.Graph at 0xeebf7b8>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "\n",
    "g = nx.Graph([(1,2),(1,3),(2,4),(3,4),(3,5),(2,6),(2,7)])\n",
    "\n",
    "g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So let's look at what is inside there by printing the contents within `g`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'node_dict_factory': dict,\n",
       " 'adjlist_outer_dict_factory': dict,\n",
       " 'adjlist_inner_dict_factory': dict,\n",
       " 'edge_attr_dict_factory': dict,\n",
       " 'graph': {},\n",
       " '_node': {1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 7: {}},\n",
       " '_adj': {1: {2: {}, 3: {}},\n",
       "  2: {1: {}, 4: {}, 6: {}, 7: {}},\n",
       "  3: {1: {}, 4: {}, 5: {}},\n",
       "  4: {2: {}, 3: {}},\n",
       "  5: {3: {}},\n",
       "  6: {2: {}},\n",
       "  7: {2: {}}}}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "\n",
    "g = nx.Graph([(1,2),(1,3),(2,4),(3,4),(3,5),(2,6),(2,7)])\n",
    "\n",
    "g.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see there is a dictionary printing the information of `g`. In particular: \n",
    "* `'_node'` represents what are the nodes inside `g`\n",
    "* `'_adj'`  prints the neighbours of each nodes connected to. \n",
    "\n",
    "These information are very useful in inferring networks. We will do some exercises later using these. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualising Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the help of `matplotlib`, we can visualise networks easily. This is done by the network methods in `networkx`. In particular, \n",
    "```python\n",
    "g = nx.Graph([(1,2), (2,3), (1,3)])\n",
    "nx.draw(g)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Try me\n",
    "import networkx as nx\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline \n",
    "\n",
    "g = nx.Graph([(1,2), (2,3), (1,3)])\n",
    "nx.draw(g, with_labels=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code that will visualise the given network `sample_network`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution \n",
    "\n",
    "# Libraries\n",
    "import networkx as nx\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline \n",
    "\n",
    "# Import data\n",
    "from files.sample_network import g as sample_network\n",
    "\n",
    "nx.draw(sample_network, with_labels=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Libraries\n",
    "import networkx as nx\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline \n",
    "\n",
    "# Import data\n",
    "from files.sample_network import g as sample_network\n",
    "\n",
    "# Your code below\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ After you have visualised `sample_network`. Write code to answer the following questions: \n",
    "* How many nodes are there?\n",
    "* What are the degrees for each node?\n",
    "* Which nodes are singletons (i.e. nodes with $1$ degree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 6 nodes. \n",
      "Degree distribution: [('Mary', 4), ('Sam', 2), ('Judy', 2), ('Tom', 2), ('Kirill', 1), ('Peter', 1)] \n",
      "There are 2 singleton(s).\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "## Number of nodes\n",
    "print('There are {} nodes. '.format(len(sample_network.nodes)))\n",
    "\n",
    "## Degree\n",
    "print('Degree distribution: {} '.format(sample_network.degree))\n",
    "\n",
    "## Number of singletons \n",
    "number_of_singletons = 0\n",
    "\n",
    "for degree_info in sample_network.degree: \n",
    "    if degree_info[1] == 1: \n",
    "        number_of_singletons += 1\n",
    "print('There are {} singleton(s).'.format(number_of_singletons))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`.draw()` and other similar methods have different options to customise the network. If you are interested, the following are the documentations regarding to these: \n",
    "\n",
    "* [`.draw_networkx()` documentation](https://networkx.github.io/documentation/stable/reference/generated/networkx.drawing.nx_pylab.draw_networkx.html#networkx.drawing.nx_pylab.draw_networkx)\n",
    "* [`networkx` graph examples](https://networkx.github.io/documentation/latest/auto_examples/index.html) Contains some styling examples for reference. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Infer Simple Network Quantities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Loop through all nodes in the provided network and print the name of each nodes. Each nodes are represented by an integer, so you can simply print the node itself. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "for node in g.nodes: \n",
    "    print(node.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Closeness "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Measure of how close are the nodes. In `networkx` this is calculated by \n",
    "```python\n",
    "from networkx.algorithms.centrality import closeness_centrality\n",
    "\n",
    "closeness_centrality(g)\n",
    "```\n",
    "\n",
    "You can check more information of the method on [official documentation](https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.centrality.closeness_centrality.html#networkx.algorithms.centrality.closeness_centrality). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can run a simple example below: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "solution": "hidden"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3de1xUdf4/8NfAIKMCIoiA4i1RMOUiMJOJCqmFYmkalqu2mJr6o75tdtvKblvLI0u/udl6aXVXt7V+udGGN7S8gbdVuQmaIJE3EEFQucoMcznfP4yJieEmzJy5vJ6Ph38058zh7cOHL999Pue8j0QQBBARkXk4iF0AEZE9YegSEZkRQ5eIyIwYukREZsTQJSIyI2lrB/v06SMMHjzYTKUQEdmGzMzMCkEQvIwdazV0Bw8ejIyMDNNURURkoyQSyZWWjnF5gYjIjBi6RERmxNAlIjKjVtd0iYisWUWtCkmZxcgvrUa1UgM3mRSBPm6YHe4HTxdnUWpi6BKRzckpqsS61EKkFZQDAFQanf6YTFqKNQcKEB3ghYQof4QMcDdrbQxdIrIp205eRmJKPpQaLYzN81L+EsA/nC/DkYIKrIgNxPwxg81WH0OXiGzG3cDNQ71a1+a5ggDUq7VITMkDALMFL0OXiGxCTlElElPyjQZu3fk0VB7//9BWl8OxZ294TnsRsgGjAAD1ah0SU/IR7OeOYD/TLzUwdInIJqxLLYRSo232ef2lbNxO3QqvGX9Et37Doa291ewcpUaL9amF2Dg/wuR1MnSJyOpV1KqQVlBudA236tiX6BX5Ozj3DwQASF37NDtHEIDDF8pxs1Zl8rsaeJ8uEVm9pMxio58LOi1U1wuhu1OFaxufRfG6eNz6YQN0alWzcyUAkrKMX6crMXSJyOrll1Yb3BbWSFtXCeg0uHPhOLznfwTfZ9aioewiqk5sb3auUqND/vUak9fK0CUiq1et1Bj9XOJ0d6nANfwxSF084NijF1zlj6P+Z+ODvKqVapPV2IihS0RWz01mfHvKUeYCRyNruC1fx6mrSmoRQ5eIrF6gjxucpcbjzCVoMmoyd0NbVwmtshY1GTvQw1/e7DyZ1AGBvq6mLpWhS0TWLy7cr8VjvSLnoJvvMFz721KUbFqGbt5D0WvsU83OEwDEhbV8na7CW8aIyOp59uyG+7orcb5KComDYS8pcZTCMyYBnjEJLX5fIgEeCvAyyxAcdrpEZNXKysowa9YsXEn5G2RO9xZpMqkjEqL9u7gy4xi6RGS1vvnmG4SEhCAwMBDZB5Px9qMj0b2DwdvdyQErYgPN8ggwwOUFIrJCN2/exHPPPYczZ84gOTkZY8aMAfDr0JrWpow1kkjudrjmnjLGTpeIrMrOnTsRFBSEfv36ITs7Wx+4jeaPGYztS8Yg5n5vOEsdIPvNXQ0yqQOcpQ6Iud8b25eMMWvgAux0ichKVFZW4sUXX8TRo0exfft2jB8/vsVzg/3csXF+BG7WqpCUVYz86zWoVqrhJnNCoK8r4sL45ggiohZ9//33WLx4MaZPn46cnBy4uLi063ueLs5YOmGoiavrGIYuEVmsmpoavPLKK9i3bx+2bNmCyZMni11Sp3FNl4gs0uHDhxEcHAytVouzZ8/aROAC7HSJyMLU1dXhjTfewH/+8x98/vnnmDZtmtgldSl2ukRkMU6cOIHQ0FDcvn0bubm5Nhe4ADtdIrIASqUSb7/9NrZt24b169dj5syZYpdkMgxdIhJVeno64uPjMXLkSOTm5sLLy0vskkyKoUtEomhoaMD777+PTZs24dNPP8VTTz0FiUQidlkmx9AlIrPLyclBfHw8Bg4ciJycHPj4+IhdktlwI42IzEatVuODDz7Aww8/jOXLl2PHjh12FbgAO10iMpPz588jPj4eHh4eyMrKgp+f6QeGWyJ2ukRkUlqtFqtWrUJUVBSeffZZ7Nu3z24DF2CnS0Qm9NNPP2HBggXo1q0bTp8+jSFDhohdkujY6RJRl9PpdFi7di3Gjh2LOXPm4ODBgwzcX7DTJaIudenSJSxcuBAqlQonTpzAsGHDxC7JorDTJaIuIQgCPv/8cygUCsTGxuLo0aMMXCPY6RJRpxUVFWHx4sW4desW0tLScP/994tdksVip0tE90wQBGzduhXh4eEYP348/vvf/zJw28BOl4juyfXr17F06VJcuXIF+/fvR0hIiNglWQV2ukTUIYIg4Ouvv0ZoaChCQkKQnp7OwO0AdrpE1G7l5eVISEjAjz/+iN27d0Mul4tdktVhp0tE7fLdd98hODgYQ4YMQVZWFgP3HrHTJaJW3b59G//zP/+D06dP49tvv8XYsWPFLsmqsdMlohalpKQgKCgInp6eOHPmDAO3C7DTJaJmqqqq8NJLL+HQoUP417/+hYceekjskmwGO10iMnDgwAEEBwdDKpUiNzeXgdvF2OkSEQCgtrYWr732Gnbt2oXNmzcjJiZG7JJsEjtdIsLRo0cREhKCO3fu4OzZswxcE2KnS2TH6uvrsWLFCmzfvh0bNmzA9OnTxS7J5rHTJbJTp06dwujRo3H9+nXk5uYycM2EnS6RnVGpVHjvvfewZcsWfPbZZ5g9e7bYJdkVhi6RHcnKykJ8fDyGDRuGnJwceHt7i12S3WHoElmZiloVkjKLkV9ajWqlBm4yKQJ93DA73A+eLs5Gv6NWq5GYmIj169djzZo1mDt3LiQSiZkrJ4ChS2Q1cooqsS61EGkF5QAAlUanPyaTlmLNgQJEB3ghIcofIQPc9cfOnj2L+Ph4+Pj4IDs7G/379zd77fQrbqQRWYFtJy9jzqaT2J9XBpVGZxC4AKD85bMfzpdhzqaT2HbyMjQaDT788ENMnDgRzz33HPbs2cPAtQDsdIks3LaTl5GYkod6ta7NcwUBqFdr8cHu8/jo44/hXV2AjIwMDBo0yAyVUnswdIksWE5RJRJT8g0CV9CocfOH9VBePgOdshZSd1/0jvo9ug+N0J+j0grQBk7F6mWJGDSwtxilUwu4vEBkwdalFkKp0Rp8Jui0kLr2gc/clRiwfDvcJ8xH+Y6PoKksMzhPCwdsPPKzOculdmDoElmoiloV0grKIQiGnzt0k8F9/DxI3b0hkTigh78C0l7eUJUWGpwnCMDhC+W4WasyY9XUFoYukYVKyixu13nauttQ37qGbl4Dmx2TAEjKat91yDwYukQWKr+0utldCr8laDWo2LkaLkGT4OQ5oNlxpUaH/Os1piqR7gFDl8hCVSs1rR4XBB0qdv8v4CiFx8PLWrmOuqtLo07g3QtEFqS6uhqZmZlIT0/HmSsywG2o0fMEQcDNlLXQ1lWi7+z3IHFs+a+ym8zJVOXSPWDoEomkoaEBubm5OH36NNLT03H69GlcvnwZISEhUCgUUAwfh0PlEjRohWbfvfX9OqhvFsF7zp/h4GT80V8AkEkdEOjrasrfBnUQQ5fIDHQ6HX766SecPn1a/+vcuXMYOnQoFAoFxowZgxdeeAGjRo2Ck9PdzrSiVoXIjw4BMAxdTdUN1J7ZBzg6ofizp/Wfe0x5Di4jDV+tIwCIC/Mz9W+POoChS2QC165dM+hgMzIy0Lt377sdrEKB2bNnIywsDC4uLi1eo4+LM6KGe2F/XpnBbWPSXn0x6PXdbdYgkQAPBXi1OASHxMHQJeqkyspKZGRkGIRsQ0MD5HI5FAoFXnrpJcjlcnh5eXX42s9F++PoTxWoV2vbPvk3ZFJHJET7d/h7ZFoMXaIOUCqVyMnJMVgmuHbtGsLCwqBQKDBnzhx88sknGDx4cJeMTgwZ4I4VsYHtnr3QSCZ1wIrYQAT7ubd9MpkVQ5eoBVqtFvn5+QYd7Pnz5xEQEACFQoHo6Gi8+uqruP/++yGVmu6v0vwxgwEAiSn5UGq0zZ5Qa0oiARx0WnTP/x5xK/jqdEskEVr5E4yIiBAyMjLMWA6ROARBQFFRkb57TU9PR2ZmJry9vfXLBAqFAqGhoejRo4coNeYWV2J9aiEOXyiHBHcffGgkkzpAwN013GUThmLla/8PWq0W27dvh4MDb8c3N4lEkikIQoTRYwxdske3bt3Sd6+NvyQSiT5c5XI5IiIi4OnpKXapzdysVSEpqxj512tQrVTDTeaEQF9XxIX9+uYIlUqFmJgYhIWF4ZNPPhG5YvvD0CW7dufOHWRnZxuE7I0bNxAeHm4QsgMGDLCpV9jcvn0b48ePx6JFi7B8+XKxy7ErrYUu13TJpmg0Gpw/f95gmeDChQsYOXIk5HI5HnnkEbz11lsICAiAo6Oj2OWaVO/evZGSkoLIyEj4+fnxrb8WgqFLVksQBFy6dMmgg83Ozoafn5++e120aBFCQkIgk8nELlcUAwcOxO7du/Hwww/D29sbEyZMELsku8fQJatx48YNpKenG4SsTCbTb3S99957CA8Ph7s7b5NqKiQkBF999RVmz56Nw4cP4/777xe7JLvG0CWLVFtbi6ysLINlgtu3b0Mul0Mul2PJkiXYtGkTX7TYTpMnT8bq1asRGxuLEydOoF+/fmKXZLcYuiQ6tVqNs2fPGnSwFy9eRFBQEBQKBaZPn44PPvgAw4YN4+1PnfD000+jqKgI06ZNQ1paGtzc3MQuyS7x7gUyK0EQUFhYaPDAQU5ODoYMGWJwP2xQUBC6desmdrk2RxAEJCQk4Oeff8aePXv0w3Woa/GWMRLN9evXDTrYjIwMuLq66je6FAoFwsPD4erK8YPmotFoMGvWLHh4eGDLli02dZucpWDoklk0DuBu+sBBXV2dvnttDFpvb2+xS7V7dXV1mDhxImJiYvD++++LXY7N4X261OVUKlWzAdxXr15FaGgo5HI54uLi8PHHH+O+++5jJ2WBevbsiV27dunv4V2yZInYJdkNhi61SafToaCgwOBOgnPnzsHf3x8KhQJjx47Fiy++iJEjR3KN0Ir07dsXe/fuxfjx49GvXz88+uijYpdkFxi6ZEAQBFy7dq3ZOqynp6d+iWDOnDkYPXo0evbsKXa51En+/v5ITk7GY489hj179kAul4tdks1j6Nq527dvNxvArdFo9Jtcr7zyCuRyOfr06SN2qWQiDzzwADZv3owZM2bg6NGjGDrU+MswqWswdO2IUqnEmTNnDJYJSkpK9AO4586di7/85S8YNGgQ12HtzPTp01FSUoKpU6fi+PHj9/SWC2ofhq6N0mq1yMvLM1gmyMvLw4gRIyCXyzFx4kS8/vrrGDFihM0PfqH2WbZsGa5evYrp06fj4MGDos0NtnW8ZcwGCIKAq1evGnSwWVlZ8PHxMbgfNjQ0FN27dxe7XLJggiAgPj4e1dXV+Pbbb/kP8j3ifbo25ubNmwYdbHp6OhwcHJoN4Pbw8BC7VLJCDQ0NiI2NRUBAAP76179yqekeMHSt2J07d5CVlWUQshUVFQYDuBUKBfr378+/HNRlqqqqMGHCBMybNw+vvfaa2OVYHT4cYURFrQpJmcXIL61GtVIDN5kUgT5umB3+6ytPzE2j0eDHH380uJOgoKAAo0aNgkKhwJQpU/DOO+8gICCAg1/IpHr16oWUlBSMHTsWfn5+mDt3rtgl2Qy7C92cokqsSy1EWkE5AEBl8HK/Uqw5UIDoAC8kRPkjZIDp5rI2DuBuukSQnZ2NAQMG6LvXxYsXIyQkBM7O4vwjQPatf//+SElJwcSJE+Hj44OJEyeKXZJNsKvlhW0nL7f7NdYyqSNWxAbqX3/dWY0DuJuGbPfu3Q0ma4WHh6NXr15d8vOIukpqaiqefPJJHDx4EEFBQWKXYxW4vIDGwM1DvVrX5rmCANSrtUhMyQOADgdvbW0tMjMzDUK2qqpKH7DLli3D3//+dw6SJqsQHR2NtWvXYtq0aThx4gT8/PzELsmq2UXo5hRVIjEl3yBwqzN3oe7sQTSUX0bPEVHo82jzt6XWq3VITMlHsJ87gv2MLzU0DuBu2sFevHgRwcHBUCgUmDFjBv785z/D39+f67BktebMmYPi4mJMnToVR48e5SuROsEuQnddaiGUGq3BZ1IXT/Qa+xTqL2VBUDe0+F2lRov1qYXYOD8COp0OhYWFBh1sbm4u7rvvPn0X+/zzz2PUqFEcwE025+WXX8bVq1cxc+ZM7Nu3j3sN98jm13QralWI/OiQwYZZU7eP/Ava6gqjnW4jB+gwOGczsv97BL169TK4HzYsLIwDuMluaLVazJ49GzKZDNu2beP/vbXArtd0kzKLO30NCQQEz1iCr7duQt++fbugKiLr5OjoiC+//BKTJ0/Gm2++iZUrV4pdktWx+X+m8kurW+xy20sLR0jc+zNwiQB0794dO3fuxHfffYd169aJXY7VsflOt1qp6aLrqLvkOkS2wNPTE/v27UNkZCT69euHmTNnil2S1bD50HWTdc1v0U3GNyIQNTVkyBDs3LkTU6dOhY+PDx588EGxS7IKNr+8EOjjBmdp89+moNNC0DQAOi0g6CBoGiDotEauAMikDgj05WYZ0W9FRETgiy++wMyZM1FQUCB2OVbB5kM3Ltz4jdxVx7/G1dWzUH0yCXU/HsbV1bNQdfxro+cKAOLCeEM4kTFTp05FYmIipk6dirKyMrHLsXg2v7zQx8UZUcO9sD+vzODRX/fx8+A+fl6b35dIgIcCvEQbgkNkDRYtWoSioiJMmzYNqampcHFxEbski2XzoQsAz0X74+hPFahXG18+aI1M6oiEaH8TVEVkW959911cvXoVTz31FHbs2AGp9Nd4scSpfmKx+YcjGnVk9kIjB0GDP80IwdMPDjZdYUQ2RK1W47HHHsPAgQPx+eefI7e4qpWpfg4QALNM9TM3u344olHj0Jr2ThlzdnSA5MweXHU9Bzy4wjxFElk5JycnfPPNN4iOjsa8dzcgG/e1+PdN+UsA/3C+DEcKKrp0qp8ls5vQBe4Gb7CfO9anFuLwhXJI8OsfPPDrv7wPBXghIdofXo6hiIyMhK+vLxYuXCha3UTWxNXVFQs/3IpV+38CpG0v6XV2qp+1savQBYBgP3dsnB+Bm7UqJGUVI/96DaqVarjJnBDo64q4sKZrTO7Yt28foqKi4O3tjWnTpolaO5E1yCmqxF+PXQOkHVurbc9UP1tgd6HbyNPFGUsnDG3zvOHDhyM5ORmPPfYYdu3ahQceeMAM1RFZL2NT/QCg9MvXoSq5AInD3TcMO7p6ov+Szw3OaTrVz1bZbeh2xAMPPICtW7dixowZSEtLQ0BAgNglEVmkiloV0grKW9wz8XhkGVxDYlr8viAAhy+U42atymbvarD5hyO6SmxsLFauXIkpU6agpKRE7HKILFLXTPUDkrI6fx1LxU63AxYsWICSkhLExsYiLS2N7zMj+o22pvpVpv4Tlan/hJNHf7hPeBqyQcHNzlFqdMi/XmPKMkXF0O2gN954AyUlJZg5cyb27t3L6flETbQ21a/3Q8/AyXMAJI5OqMs7ghvffgDfZ9bCqbevkevY7lQ/Li90kEQiwaeffgoPDw/8/ve/h07XuVm9RLZAqVTi1KlTuH7lYovnOPcLgINzD0ikTnAJmgTn/iNQ/7Pxh69seaofQ/ceODo6Ytu2bSgtLcVLL72E1p7qI7I1Wq0W586dw5YtW5CQkICIiAh4enpi2bJl0FRchlTSzkZEIsHdcVKGbH2qH5cX7pFMJsOOHTswfvx4rF69Gq+++qrYJRF1OUEQcPnyZf3LWNPT05GdnQ0fHx/9ewLnz5+P0NBQ9OjRQ/9OQs1v1nV1ylqoSi5ANjAIcHBEXd4RqIrOwWPSs81/Jmx7qh9DtxPc3d310/N9fHzw9NNPi10SUaeUlZUhPT3d4Fe3bt30Afv2228jPDwcvXv3Nvr9lqb6CTotKo9sg/pWMSBxgJOnH7xmvQUnT8NwtYepfgzdTurfvz/27t2L6Oho9O3bFzExLd+DSGRJqqurkZmZadDF1tTUICIiAnK5HEuXLsXmzZvRr1+/Dl3X2FQ/xx694LtgTZvftYepfnYzZczUjh8/jpkzZyIlJQUREbb7NA1ZJ5VKhZycHH24pqen4+rVqwgJCdF3sXK5HP7+/pBIJJ3+efcy1a+7kwNWxI6widkLnDJmBpGRkdi0aROmT5+OI0eOwN/ftv+1Jsul1WqRl5enD9fTp0/j/PnzCAgIgFwux7hx4/DSSy9h5MiRBjNvu1JHp/rJpI6cMkYdN2PGDJSVlSEmJgYnTpyAt7e32CWRjWtto0sul0OhUBhsdJlTR6f62fKQm6a4vGACf/rTn7Bz506kpqbC1dV2b30h82tro0sulyMiIqLFjS6xtG+qn+1obXmBoWsCgiBg2bJluHTpEnbv3o1u3bqJXRJZIWMbXdXV1fpwbQzajm50kekxdEWg0WgQFxcHFxcXfPHFF3Bw4HMo1LLWNrqaBmxXbXSRaTF0RVJfX4/JkycjMjISH3/8sdjlkIVoaaNr+PDhBssEI0eOhJOT7T4Oa8t494JIunfvjl27dmHcuHHw9fXF8uXLxS6JzKytja7fPtFFto+ha2IeHh76p9Z8fX0xZ84csUsiE7px44ZBwDZudDUuEbz11lsWudFF5sPQNYOBAwciJSUFkydPhpeXFyZNmiR2SdQFmm50NQZt042uJUuWYNOmTejfv7/YpZIF4ZquGaWlpWH27Nn4/vvvMXr0aLHLoQ5o3Ohq2sVyo4tawjVdCxEVFYUNGzbg0UcfxbFjxzBkyBCxSyIjtFot8vPzDZYIfvzxRwwfPlz/RNfy5cu50UX3hKFrZk888QTKysowZcoUHDt2DF5eXmKXZNeabnQ1drHZ2dnw9vbWd6/z5s3D6NGjudFFXYKhK4KEhASUlJTg0UcfxaFDh9CzZ0+xS7Ibxja6nJyc9AHLjS4yNa7pikQQBCxevBilpaVITk7m/6aaQEsbXREREQb3w3Kji7oaH46wUGq1Go8//jj69u2Lf/zjH9yA6QRjG11XrlxBaGiowWOzQ4cO5dOBZHIMXQtWV1eHiRMnYvLkyUhMTBS7HKvQ1kZXYxfLjS4SC+9esGA9e/bEnj179A9PPP/882KXZFG40UW2hqFrAfr06YN9+/Zh3Lhx8PHxQVxcnNgliYYbXWTrGLoWYsiQIdizZw8eeeQReHl5ISoqSuySTK61jS4+0UW2imu6FubQoUP43e9+hwMHDiAoKEjscrpMSxtdxt7RxY0usnZc07UiEydOxNq1axEbG4vjx49j4MCBYpfUYY0bXU0DtulGV2RkJJ/oIrvF0LVATz31FEpLSxETE4Njx47B09NTf6yiVoWkzGLkl1ajWqmBm0yKQB83zA4X57UngiDgypUrBmuwWVlZ8Pb21t9JwI0uol9xecGCvfbaazh27BgOHDiAn242YF1qIdIKygEAKiMv+IsO8EJClD9CBpjuBX+NG11Nu9imG12N7+jy8PAwWQ1Elo736VopnU6H+Ph4XHToj5uDoqDS6Mz6KuuamhpkZmYadLGVlZXN3tHFjS4iQ1zTtVIODg6YtPQ9HNt5FoJa1+b5ggDUq7VITMkDgA4Fb9ONrsYutnGjSy6X4/HHH0diYiI3uog6iaFrwXKKKvHRDz9BcDTcbKrYtRrKyznQqZVw7NkbbmOegGtIjP54vVqHxJR8BPu5I9iv+VJDSxtdw4YNg0KhwNixY/GHP/wBo0aN4kYXURdj6FqwdamFUGq0zT53GzMbnlP/AInUCeqbRSj96g108x4KZx9//TlKjRbrUwuxYV54s42uzMxMg3d0caOLyHwYuhaqolaFtIJyo2u43bwGNfkvCSSQQHP7ukHoCgLw/dlr6DvwSUg19VAoFFAoFHjzzTe50UUkIoauhUrKLG71+M3v16Pu7EEIGhW6eQ9F96HN1+wdHR3x6rokvPrYaE4wI7IQDF0LlV9abXBb2G95xiTA4+GlUF3Lh/LqWUgcm6+9agQJrtc7MHCJLAi3oS1UtVLT5jkSB0fIBoyEtqYCNdkpLVxH3dWlEVEnMHQtlJusA/8TotNBc/t6C9fh3QdEloSha6ECfdzgLG3+x6Otq0Td+TToGuoh6LSov5iJurw0yAaFNDtXJnVAoK+rOcolonbimq6Figv3w//+kN/8gESCmuy9uPn9ekDQQdqrL3pPehY9ho9pdqoAIC7Mz/TFElG7MXQtkEqlwpoP34fyojOkg8Mg4NeNMMceveAzb2Wb15BIgIcCvEQZgkNELePygoXJyspCREQEzp07h3/+cR5kTvf276JM6oiEaP+2TyQis2LoWoiGhga8++67mDJlCv74xz8iOTkZE0OHYkVsILo7deyPqbuTA1bEBhp9BJiIxMXlBQuQk5OD+Ph49O/fH2fOnEG/fv30xxqH1iSm5EOp0Zp1yhgRdT2GrojUajVWrlyJtWvXYtWqVYiPjzf6IMP8MYMR7OeO9amFOHyhHBIASiPzdB8K8EJCtD87XCILxtAVyblz5xAfHw8vLy9kZWVhwIABrZ4f7OeOjfMjcLNWhaSsYuRfr0G1Ug03mRMCfV0RFybOmyOIqGMYumam0WiwatUqfPLJJ/jwww+xaNGiDj2m6+nijKUThpqwQiIyJYauGeXl5SE+Ph5ubm7IyMjAoEGD2v4SEdkU3r1gBlqtFqtWrcL48eOxcOFC7N+/n4FLZKfY6ZrYhQsX8Mwzz8DZ2Rnp6ekYMmSI2CURkYjY6ZqIVqvFmjVrEBkZiblz5+LgwYMMXCJip2sKhYWFeOaZZwAAJ0+ehL8/nwwjorvY6XYhnU6Hzz77DGPGjMETTzyB1NRUBi4RGWCn20UuXbqEhQsXQqVS4fjx4wgICBC7JCKyQOx0O0kQBGzcuBEKhQLTpk3D0aNHGbhE1CJ2up1w5coVLF68GFVVVThy5AhGjBghdklEZOHY6d4DQRCwefNmREREYNKkSThx4gQDl4jahZ1uBxUXF2Px4sUoLy/H4cOHMWrUKLFLIiIrwk63nQRBwNatWxEWFoZx48bh5MmTDFwi6jB2uu1QUlKCJUuWoLi4GPv370dISPOXQBIRtQc73VYIgoBt27YhNDQU4eHhOH36NAOXiDqFnW4LSktLsWzZMvz888/Yt28fwsLCxC6JiGwAO93fEAQBX3/9NUJCQjBy5MFOvxEAAATLSURBVEhkZGQwcImoy7DTbeLGjRtISEjA+fPnsXv3bsjlcrFLIiIbw073F0lJSQgODsbQoUORlZXFwCUik7D7TreiogLPP/88srOz8d133+HBBx8UuyQismF23ekmJycjODhY/+pzBi4RmZpddrq3bt3CCy+8gFOnTuHf//43xo0bJ3ZJRGQn7K7T3b17N4KCguDp6YkzZ84wcInIrOym062srMSLL76II0eO4KuvvkJUVJTYJRGRHbKLTnfv3r0ICgpCz549kZuby8AlItHYdKdbVVWFl19+GQcOHMDWrVsxadIksUsiIjtns53u/v37ERwcDEdHR+Tm5jJwicgi2FynW1NTg1dffRUpKSnYvHkzHnnkEbFLIiLSs6lO99ChQwgODoZarcbZs2cZuERkcWyi062trcXrr7+O5ORk/O1vf0NsbKzYJRERGWX1ne6RI0cQEhKCmpoanD17loFLRBbNajvdO3fu4M0338Q333yDDRs2YPr06WKXRETUJlFDt6JWhaTMYuSXVqNaqYGbTIpAHzfMDveDp4tzi987ceIEFixYALlcjtzcXHh6epqxaiKieydK6OYUVWJdaiHSCsoBACqNTn9MJi3FmgMFiA7wQkKUP0IGuOuP1dfX45133sG2bduwbt06zJo1y+y1ExF1htlDd9vJy0hMyYdSo4UgND+u/CWAfzhfhiMFFVgRG4j5Ywbj1KlTWLBgAYKDg5GbmwsvLy8zV05E1HlmDd27gZuHerWuzXMFAahXa/HnlDwk70jGsS0rsXbtWjz55JNmqJSIyDTMdvdCTlElElPyWwxc9a1ruLJqJip2rTb4XKnWIUs3GF//cIKBS0RWz2yhuy61EEqNtsXjt37YCGffYUaPCY5O+Dr3lqlKIyIyG7OEbkWtCmkF5UbXcAGg7nwaHGQ9IRsUYvS4IACHL5TjZq3KhFUSEZmeWUI3KbO4xWM61R1UHv0SvScuavUaEgBJWS1fh4jIGpgldPNLqw1uC2uq8si/4BLyCKRurd+NoNTokH+9xhTlERGZjVlCt1qpMfp5Q9lFKK/kwE0+o53XUXdlWUREZmeWW8bcZMZ/jPLqWWiqylC8/hkAgNCgBAQdrlf8Ab7PfGrkOk4mrZOIyNTMErqBPm5wlpY2W2JwCY1BzxET9P9dffo/0FSVwSPmuWbXkEkdEOjravJaiYhMySzLC3HhfsZ/uJMMji699b8kTjJIpN3g2KNXs3MFAHFhxq9DRGQtzNLp9nFxRtRwL+zPK2vxtjEAcB8/z+jnEgnwUIBXq0NwiIisgdkejngu2h8yqeM9fVcmdURCtH8XV0REZH5mC92QAe5YERuI7k4d+5HdnRywIjYQwX7ubZ9MRGThzDrwZv6YwQDQ6pSxRhLJ3Q63ccoYEZEtMPtox/ljBiPYzx3rUwtx+EI5JPh1nCNw9y4FAXfXcBOi/dnhEpFNEWWIebCfOzbOj8DNWhWSsoqRf70G1Uo13GROCPR1RVxY62+OICKyVqK+rsfTxRlLJwwVswQiIrOy+rcBExFZE4YuEZEZMXSJiMxIIrRy35ZEIikHcMV85RAR2YRBgiAYnVfbaugSEVHX4vICEZEZMXSJiMyIoUtEZEYMXSIiM2LoEhGZ0f8BQweEwQN5GrYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The closeness centrality of g1 are:\n",
      " {1: 0.625, 2: 0.625, 3: 0.625, 5: 0.625, 4: 0.4166666666666667, 6: 0.4166666666666667}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The closeness centrality of g2 are:\n",
      " {1: 0.625, 2: 0.8333333333333334, 3: 0.8333333333333334, 5: 0.625, 4: 0.5, 6: 0.5}\n"
     ]
    }
   ],
   "source": [
    "# Run me\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import networkx as nx\n",
    "from networkx.algorithms.centrality import closeness_centrality\n",
    "\n",
    "g1 = nx.Graph([(1,2),(1,3),(2,5),(3,4),(3,5),(2,6)])\n",
    "value_01 = closeness_centrality(g1)\n",
    "\n",
    "g2 = nx.Graph([(1,2),(1,3),(2,3),(2,5),(3,4),(3,5),(2,6)])\n",
    "value_02 = closeness_centrality(g2)\n",
    "\n",
    "nx.draw_networkx(g1)\n",
    "plt.show()\n",
    "print('The closeness centrality of g1 are:\\n {}'.format(value_01))\n",
    "\n",
    "nx.draw_networkx(g2)\n",
    "plt.show()\n",
    "print('The closeness centrality of g2 are:\\n {}'.format(value_02))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see the values from closeness centrality is a dictionary of each node's closeness centrality. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Betweenness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Measure of how many shortest paths for the specific vertex has. In terms of traffic, we can think of how a road is popular because many cars can take this as the shortpath. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In `networkx` this is calculated by \n",
    "```python\n",
    "from networkx.algorithms.centrality import betweenness_centrality\n",
    "\n",
    "betweenness_centrality(g)\n",
    "```\n",
    "\n",
    "You can check more information of the method on [official documentation](https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.centrality.betweenness_centrality.html#networkx.algorithms.centrality.betweenness_centrality). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assortativity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Measure of how each nodes are mixed with other nodes. Technically speaking, how well nodes are connected with each other. It is a ranged value from $-1$ to $1$: \n",
    "* Negative values mean disortative, the network is likely to look radial. \n",
    "* $0$ means the newtork is neutral.\n",
    "* Positive values mean assortative. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In `networkx` this is calculated by \n",
    "```python\n",
    "from networkx.algorithms.assortativity import degree_assortativity_coefficient\n",
    "\n",
    "degree_assortativity_coefficient(g)\n",
    "```\n",
    "\n",
    "You can check more information of the method on [official documentation](https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.assortativity.degree_assortativity_coefficient.html#networkx.algorithms.assortativity.degree_assortativity_coefficient). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Instances to Nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In practice, these nodes represents a person or an object. This means in the code base, nodes have intrinsic meanings. We can encounter such fact by either: \n",
    "* renaming the nodes with the object\n",
    "* add attributes to the nodes. \n",
    "The second method is often suggested and it is a functionality provided by `networkx`. The first one becomes advantaged if the node itself has a pre-defined object representing it, and the second method is too cumbersome because it involves adding a lot of attributes to each nodes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often we start our code by creating the data structures. In this case the objects have been created. `networkx` has a `.relabel_nodes()` method where the nodes label can change themselves. The usage of this method is as follows: \n",
    "```python\n",
    "# Map the old labels (key) to the new labels (value)\n",
    "mapping = {old_node: new_label, ...}\n",
    "nx.relabel_nodes(g, mapping)\n",
    "```\n",
    "You can try this in the demonstration below: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Try this\n",
    "\n",
    "import networkx as nx\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline \n",
    "\n",
    "social_network = nx.Graph([(1,3), (2,3), (3,4), (4,5)])\n",
    "\n",
    "class Person: \n",
    "    def __init__(self, name, age, gender):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.gender = gender\n",
    "    \n",
    "population = [Person(\"Brendan\",43,\"M\"),Person(\"Julie\",80,\"F\"),Person(\"Hugo\",49,\"M\"),Person(\"Salma\",7,\"F\"),Person(\"Arham\",54,\"F\")]\n",
    "\n",
    "mapping = {1: population[0], 2: population[1], 3: population[2], 4: population[3], 5: population[4]}\n",
    "\n",
    "social_network = nx.relabel_nodes(social_network, mapping)\n",
    "\n",
    "nx.draw(social_network, with_labels=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ How can we change the labels so that they show the names of the people in the visualisation?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "There are 2 ways that we can show the names in the visualisations: \n",
    "\n",
    "__Method 1: Change the network completely__\n",
    "\n",
    "We could relabel the label with the names only. This means \n",
    "```python\n",
    "mapping = {1: population[0].name, 2: population[1].name, 3: population[2].name, 4: population[3].name, 5: population[4].name}\n",
    "\n",
    "social_network = nx.relabel_nodes(social_network, mapping)\n",
    "```\n",
    "\n",
    "__Method 2: Change the network completely__\n",
    "If you want to retain the network structure, then you can pause the `.draw()` method to show label then draw the labels separately. This is how you do it: \n",
    "```python\n",
    "# Need to set the positions first\n",
    "pos = nx.random_layout(social_network)\n",
    "nx.draw(social_network, pos=pos, with_labels=False)\n",
    "\n",
    "labels = {population[0]: population[0].name, population[1]: population[1].name, population[2]: population[2].name, population[3]: population[3].name, population[4]: population[4].name}\n",
    "\n",
    "nx.draw_networkx_labels(social_network,pos,labels)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the other method, which is about __attributes__ of the nodes. In week 6 we have looked into classes, where everything in Python are objects. Objects have attributes to describe them. For example, as a person we are described by our names, age, gender and et cetera. \n",
    "\n",
    "We can do the same thing with network nodes, and with `networkx` it is easier to do so with their built-in methods. But first, we can add node attributes when we create the nodes. \n",
    "```python\n",
    "social_network = nx.Graph()\n",
    "\n",
    "social_network.add_node(\"Brendan\", {'age': 43, gender: \"M\"})\n",
    "```\n",
    "Note, we must define the graph object first, then add the node attributes. The above example comes from previous exercise. We can easily see that: \n",
    "* The node is defined by the name of the person. In this case it is fine. However, in reality people share the same names. `network` identify the nodes by its name, it is recommended to create a unique identifer if possible. \n",
    "* The personal information are listed as dictionaries.\n",
    "    * The feature is shown as the keys. \n",
    "    * The values are listed under each keys, which belongs to each person. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Can you create the nodes with attributes followed from the previous exercise? The personal information of others are shown below. \n",
    "\n",
    "| Name  | Age | Gender |\n",
    "|-------|-----|--------|\n",
    "| Julie | 80  | F      |\n",
    "| Hugo  | 49  | M      |\n",
    "| Salma | 7   | F      |\n",
    "| Arham | 54  | F      |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Solution__\n",
    "\n",
    "```python\n",
    "social_network.add_node(\"Julie\", {'age': 80, gender: \"F\"})\n",
    "social_network.add_node(\"Hugo\", {'age': 49, gender: \"M\"})\n",
    "social_network.add_node(\"Salma\", {'age': 7, gender: \"F\"})\n",
    "social_network.add_node(\"Arham\", {'age': 54, gender: \"F\"})\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`networkx` also has a method called `.set_node_attributes()` which allows us to add/ edit nodes attributes if we wish. For example, if we appended a new person into the network, called Brian, without any information appended. We can simply write \n",
    "```python\n",
    "social_network.add_node(\"Brian\")\n",
    "```\n",
    "Later, we have learnt that Brian is a male and his age is $12$. We then can use `.set_node_attributes()` and write \n",
    "```python\n",
    "nx.set_node_attributes(social_network, {\"Brian\": {'age': 12, gender: \"M\"}})\n",
    "```\n",
    "Beware the syntax difference from adding nodes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ When you add a node, can you append incomplete attributes information?\n",
    "\n",
    "For example, if I want to add a new node called `\"Sally\"` but I do not know her age, can I still use `nx.add_node()`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Answer:__ Yes, you can. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ What if I realised Brian is aged $35$, can I simply change the attribute data with `nx.set_node_attributes()`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Answer:__ Yes, you can. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the attribute values, we use the dictionary syntax. For example, to get the age of Brendan we could write \n",
    "```python\n",
    "social_network.nodes['Brendan']['age']\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code that will print Brendan's gender. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution \n",
    "\n",
    "print(social_network.nodes['Brendan']['gender'])  # print() is fine in Jupyter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below \n",
    "\n",
    "print(???)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EDA on Network Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let us apply our skills by exploring the data and model them as networks. As a recap, EDA stands for exploratory data analysis. Which simply means we explore the dataset to extract the values and improve the data quality before finding useful patterns. \n",
    "\n",
    "In this section, we will look at 3 steps: \n",
    "1. Read the data files\n",
    "2. Clean the data set\n",
    "3. Explore the data, in particular\n",
    "    * Visualise the network\n",
    "    * Find statistical summaries from network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this exercise, we will look at a data set of pokemon data. Pokemon is a game where player controls creatures to fight with other players. It is the most popular franchise in the world to date. One of the features of this game is each Pokemon creatures has a type, and depending of the type your Pokemon may hit twice of the damage, so called strongly effective. \n",
    "\n",
    "Our aim is to visualise the types which are effective to each other. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One easy example is the 3 basic types: Fire is effective on grass type. Grass is effective on water type. Water is effective on fire type. The cyclic relationship looks like paper, scisors, rock: Each type is over the other, and so forth. In the following, we make a toy example out of adjacent matrix. Adjacent matrix represents nodes as columns and rows. In the following you can see red dot means fire. So the top red dot means the first column is when the fire type is being attacked. The first row represents the fire type is attacking therefore. \n",
    "\n",
    "Adjacent matrix has 1's and 0's, meaning there is a line from the node row to the node column. This is depicted below. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"fig/pokeType.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So you can see water type is effective to fire type and so on. Now we can try the network generation based on adjacent matrix below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "adj_matrix = np.array([[0, 0, 1], [1, 0, 0], [0, 1, 0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we have the data, we first create an empty graph and put the data into it. We use `nx.from_numpy_array()` where this accepts the adjacent matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "\n",
    "example_graph = nx.from_numpy_array(adj_matrix, create_using=nx.DiGraph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we can draw the network. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nx.draw(example_graph, node_color=[\"red\", \"blue\", \"green\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see above the nodes have been coloured using the option `node_color`. It accepts list and the order corresponds to the order of the nodes. We will look at this next. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Read the data file called `pokemon_Types.csv`. This data file is located in the `files` folder. It is a spreadsheet, so you may need `pd.read_csv()` for this exercise. After that, print all column names. \n",
    "\n",
    "Explain what each columns means. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "# Your code below \n",
    "\n",
    "types_df = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Type', 'Strong against', 'Inffective against', 'Inoffensible against'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "import pandas as pd\n",
    "types_df = pd.read_csv('files/pokemon_Types.csv')\n",
    "\n",
    "print(pokemon_df.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the purpose of this exercise, we do not require any data cleaning. We will need to filter the relevant columns. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then create the empty graph. This time because we are trying to see which type is effective than other so we use directional graph `nx.DiGraph()` where the edges have directions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "solution": "hidden"
   },
   "outputs": [],
   "source": [
    "# Run this\n",
    "types_net = nx.DiGraph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other types of graphs are:\n",
    "* `nx.Graph()` undirected graph. \n",
    "* `nx.MultiGraph()` undirected graph with self loops and parallel edges. \n",
    "* `nx.MultiDiGraph()` directed graph with self loops and parallel edges. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then try to add the nodes (i.e. pokemon types) into the graph. To do this, we need to fetch data from the data frame. The next exercise is where you develop the network. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try this\n",
    "types_net.add_node(\"Normal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many types and the best way is to write a loop with `.add_node()` method. \n",
    "\n",
    "Because this is a test, we shall remove the node as below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try this\n",
    "types_net.remove_node(\"Normal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are running out of ideas, that is fine. There is one solution and we will walk through this one. \n",
    "\n",
    "The main idea is to __create a list for all links__, then we can include all singletons into the network as well. Remember our `Graph()` object starts with nothing, so must consider different cases. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Write a loop to generate the nodes in the type network. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeView(('Normal', 'Fire', 'Water', 'Grass', 'Flying', 'Fighting', 'Poison', 'Electric', 'Ground', 'Rock', 'Psychic', 'Ice', 'Bug', 'Ghost', 'Steel', 'Dragon', 'Dark', 'Fairy'))"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "for type_name in types_df['Type']: \n",
    "    types_net.add_node(type_name,label=type_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let us create the edges (i.e. the links). There are 2 methods to add the edges:\n",
    "* `.add_edge()`\n",
    "* `.add_edges_from()`\n",
    "\n",
    "You can read the documentations from NetworkX official site. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise:__ Which one is the most effeicient to use? Read the data again if you need. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Answer:__ In column `\"Strong against\"` it is deliminated by space to show it is multi-value. So `.add_edges_from()` would save us time by looping each source type to what it is effectively against with. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can run the below code to generate the edges. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Normal' 'Fire' 'Water' 'Grass' 'Flying' 'Fighting' 'Poison' 'Electric'\n",
      " 'Ground' 'Rock' 'Psychic' 'Ice' 'Bug' 'Ghost' 'Steel' 'Dragon' 'Dark'\n",
      " 'Fairy']\n"
     ]
    }
   ],
   "source": [
    "# Run this\n",
    "types_ls = types_df['Type'].to_numpy()\n",
    "strong_at = [x.split(' ') for x in types_df['Strong against'].fillna('').to_numpy()]\n",
    "\n",
    "i = 0\n",
    "for type_name in types_ls: \n",
    "    types_net.add_node(type_name,label=type_name)\n",
    "    types_net.add_edges_from([(type_name,other_type_name) for other_type_name in strong_at[i]])\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next is we shall colour the nodes. What we will do is to create a dictionary to capture which type has which colour. After that we translate the colours to a list. \n",
    "\n",
    "We will need to use a loop here. The syntax of looping nodes is:\n",
    "```python\n",
    "g = nx.Graph()\n",
    "\n",
    "for node in g.nodes:\n",
    "    print(node)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "type_colours = {\"Normal\": \"#D2CBBE\", \"Fire\": \"#E5340E\", \"Water\": \"#0E7BE5\", \"Grass\": \"#82E150\", \"Flying\": \"#84ADFB\", \"Fighting\": \"#9E5F54\", \"Poison\": \"#601E62\", \"Electric\": \"#FBEA20\", \"Ground\": \"#E3D070\", \"Rock\": \"#E6AD2E\", \"Psychic\": \"#F62B99\", \"Ice\": \"#70F3F4\", \"Bug\": \"#D4E278\", \"Ghost\": \"#654FB2\", \"Steel\": \"#C0C0C0\", \"Dragon\": \"#6253E3\", \"Dark\": \"#827674\", \"Fairy\": \"#F9BCC8\"}\n",
    "\n",
    "color_map = []\n",
    "for node in types_net.nodes: \n",
    "    try:\n",
    "        color_map.append(type_colours[node])\n",
    "    except KeyError:\n",
    "        color_map.append('#1f78b4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can visualise the network itself. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "shown",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Visualise the network with the types as labels and colour them as well. Use the documentations to help you. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(20,20))\n",
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x2000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "plt.figure(figsize=(20,20))\n",
    "nx.draw_networkx(types_net, with_labels = True, node_color=color_map)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally you may do some analysis of the network. For example, you can find how many singletons in the network. You may also infer the centrality values from the network. The visualisation has many different customisations such as, layouts, node size etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In today's class we have looked at: \n",
    "* How to visualise networks in Python\n",
    "* Inferring Python with simple measures\n",
    "* Explore datasets and model them with network. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}