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": {
    "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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code \n",
    "import networkx as nx\n",
    "\n",
    "g = "
   ]
  },
  {
   "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": "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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 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. The data is quite comprehensive and includes all pokemons up to gneration 8. First, we should identify what columns are located in the data file. So we should read the data file and read them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Read the data file called `Pokemon_Gen_1-8.xlsx`. This data file is located in the `files` folder. It is an Excel file, so you may need `pd.read_excel()` for this exercise. After that, print all column names. \n",
    "\n",
    "Explain what each columns means. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true,
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['#', 'Name', 'Type 1', 'Type 2', 'HP', 'Attack', 'Defense',\n",
      "       'Sp. Attack', 'Sp. Defense', 'Speed', 'Total', 'Average', 'Generation',\n",
      "       'Legendary', 'Evolve From'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "import pandas as pd\n",
    "pokemon_df = pd.read_excel('files/Pokemon_Gen_1-8.xlsx')\n",
    "\n",
    "print(pokemon_df.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "# Your code below \n",
    "\n",
    "pokemon_df = pd.read_excel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the purpose of the exercise, we need the last column `\"Evolve From\"`. Which links between pokemons species if one may evolve to the other. We also need the Pokedex number, a unique numbering system of all pokemons, in our analysis. This means we should filter the other columns out from the data frame. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Write a code to filter out the other columns. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   #  Evolve From\n",
      "0  1          NaN\n",
      "1  2          1.0\n",
      "2  3          2.0\n",
      "3  3          2.0\n",
      "4  4          NaN\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "# You can either `DataFrame.drop()` all other columns, if you know their names. Or, reassign the two columns we need into the same data frame. \n",
    "# The latter solution is cleaner. To refrain double operation, we commented the first method. \n",
    "\n",
    "# Method 1: `DataFrame.drop()`\n",
    "# pokemon_df = pokemon_df.drop(['Name', 'Type 1', 'Type 2', 'HP', 'Attack', 'Defense',\n",
    "#        'Sp. Attack', 'Sp. Defense', 'Speed', 'Total', 'Average', 'Generation',\n",
    "#        'Legendary'], axis = 1)\n",
    "# Remember `axis = 1` means column data. \n",
    "\n",
    "# Method 2: Redefine the data frame\n",
    "pokemon_df = pokemon_df.loc[:,['#', 'Evolve From']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we arrive to the phase on cleaning data. Before proceeding to data analysis, we should not assume our data are all correct. In the filtered data frame, we expect each pokemon species may or may not entail a pokemon species that they are evolved from. Either you know much about pokemons or not, it is fine. We should learn about what we are analysing from the [pokedex of evolution families](https://bulbapedia.bulbagarden.net/wiki/List_of_Pok%C3%A9mon_by_evolution_family). This is where the pokemons are grouped by lines of evolution. Take some time to read them and think about the patterns of evolution. \n",
    "\n",
    "After your reading, you should found that: \n",
    "* One pokemon evolutes to another, but not in reverse direction. \n",
    "* One pokemon species may have several options to evolute. \n",
    "* It is unlikely that many pokemons may evolute to one species. \n",
    "* Pokemon can have different forms, and this affects how their evolution line. \n",
    "\n",
    "This will give you an idea that the network is a directed one. Moreover, the overall network should look like many singletons (_Nodes with no connections_) with some trees (_A special type of graphs that nodes will branch out but no cycles_). You should use this to validate if your network works.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "__Exercise:__ Think about what could be the source of errors in the dataset. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden"
   },
   "source": [
    "Here are the few items are possible sources of errors: \n",
    "* One pokemon in the `'#'` column has multiple `\"Evolve From\"` values. \n",
    "* Missing values.\n",
    "* The pokemon from the `\"Evolve From\"` column is either the pokemon itself, or the pokemon should be evolved to (i.e. wrong order). \n",
    "\n",
    "We should check if these exists, case by case. In the below cells(s), check the data quality and inegrity of the dataset. You may need to create new cells for each functionality. Use the __+__ button at the toolbar on the top to add cell. When we are checking each part of the cell, make sure you explain what are you doing. Either by commenting or using a markdown. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Check the data integrity from this cell. \n",
    "\n",
    "Make sure: \n",
    "- Create new cells for each functionality\n",
    "- Explain what you do by commenting or markdown\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now we may visualise the network. So let's start to do them. First, we create the `Graph()` object. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden"
   },
   "outputs": [],
   "source": [
    "# Run this\n",
    "evolution_net = Graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then try to add the nodes (i.e. pokemons) or the evolution pathway 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": "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": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ We need to model with the columns needed. As a recap, what are the column names we needed? \n",
    "\n",
    "Write a code that will show these __two__ columns. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Solution__\n",
    "\n",
    "The columns we needed are `'#'` and `'Evolve From'`. We can show them by writing \n",
    "```python\n",
    "pokemon_df[['#', 'Evolve From']]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our thinking process is to first extract the Pokemons whom may evolve, and find the rest as singletons. At this point, we will need to filter the rows that values for the `'#'` and `'Evolve From'`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Using your answer from the previous exercise, how do you query the rows that have both `'#'` and `'Evolve From'` values. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "shown",
    "solution2": "hidden"
   },
   "source": [
    "__Solution__ \n",
    "\n",
    "Using code, \n",
    "```python\n",
    "pokemon_df[['#', 'Evolve From']][pokemon_df['Evolve From'].notna()]\n",
    "```\n",
    "It means we filter values from both `'#'` and `'Evolve From'` columns (i.e. the double square braket) and then query for the not missing values in `'Evolve From'` (using `.notna()`). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution contains two more methods: `.to_records(index=False)` and `.to_list()`. Can you explain why is that?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember we have said to add edges, they must be in a list. So the `.to_list()` is what we after. \n",
    "\n",
    "`.to_records(index=False)` is important when we want our list delete the index. So that the list now contains only tuples of __2__ values. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Remember__ you will need to add the two methods `.to_records(index=False).to_list()` at the end of your solution, and assign them with a variable. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now focus on the Pokemons that does not evolve. Since we are looking for individuals. One method is to include all species in Python sets. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set is a mathematical object that includes all the objects inside it. For example, \n",
    "```python\n",
    "{1, 2, 3}\n",
    "```\n",
    "Is a set that includes numbers $1$, $2$ and $3$. Note that a set only includes unique values, so if we have two $3$s, it does not change anything. So the set looks like \n",
    "```python\n",
    "{1, 2, 3}  # The extra 3 is absorbed\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create our set using 2 things: \n",
    "* `set()`, and \n",
    "* list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start from list comprehension. We can view list comprehension as one-line loops. For example, instead of writing \n",
    "```python\n",
    "for x in range(3): \n",
    "    print(x)\n",
    "```\n",
    "We now write \n",
    "```python\n",
    "[print(x) for x in range(3)]\n",
    "```\n",
    "To do the same thing. \n",
    "\n",
    "A list comprehension means \n",
    "* Everything is inside a square braket. \n",
    "* The content of each iteration (i.e. `print(x)`) is first, then the declaration of the `for` loop. \n",
    "\n",
    "Note that there is no list comprehension for `while` loops. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means we should create our set using list comprehension in creating a set. For example, you can try the following: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try me\n",
    "print(set([x for x in range(3)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have created a set now. If you look into the list for edges to add previously. You should see there is a format there, Which is: \n",
    "```python\n",
    "ls = [(1,2), (2,3), ...]\n",
    "```\n",
    "Our job is to create the set with Pokemons (species numbers) that hasn't appeared. Note we are adding the data inside the tuple, which is within a list. So this means we will need to create a set that extracts from the values inside the tuple. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ How can we do it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Solution:__\n",
    "\n",
    "Using the above example, we assume your list is stored in `ls`. Then your code should look like \n",
    "```python\n",
    "set([x[0] for x in ls])\n",
    "```\n",
    "This means we find all the first elements in the tuple in `ls` and add them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now want to focus on aggregating the data from the second element in the tuples. Remember that repeated elements are absorbed in a set? We can add them by making the second elements as a new set, and join them together. This is done by union. \n",
    "\n",
    "Union in set theory means we join the two sets together. Let us see an example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this\n",
    "set01 = {1, 2, 3}\n",
    "set02 = {3, 4, 5}\n",
    "print(set01.union(set02))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will see that the elements from the set 01 and 02 are merged in the new union set. But the common element $3$ is not repeated in the new set. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ How can you create a union set of the sets from first and second elements in the tuple? Remember to assign a variable after this. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Solution:__\n",
    "\n",
    "Let us say the list is called `ls`. We can write \n",
    "\n",
    "```python\n",
    "evoluting_pokemons = set([x[0] for x in ls]).union(set([int(x[1]) for x in ls]))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we are creating a set of Pokemons that may evolve, this is opposite to what we aimed! Don't worry. There is another set operation (such as union) that can find the elements that are not in there. This is called __complementary set__. To do that, we will need to create a set with all Pokemons numbers and find the complement of the set we've created. So we have the set of Pokemons that are singletons. \n",
    "\n",
    "To create complementary sets, we write \n",
    "```python\n",
    "set('All Pokemons') - set('Pokemons may Evolve')\n",
    "```\n",
    "The `-` operation means we subtract from the full set, which is finding the complementary set of the ones may evolve. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Find the set of Pokemons without evolving, using complementary set operation. \n",
    "\n",
    "_Remember:_ \n",
    "* What is your full set?\n",
    "* The data frame we imported is called `pokemon_df`, this will be helpful. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "source": [
    "__Solution:__\n",
    "```python\n",
    "singleton_pokemons = set(pokemon_df['#'].tolist()) - evoluting_pokemons\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After all the instructions, how many have you've been absorbed? If not, it is fine. The solution is in below. You can run that one with your code. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden",
    "solution2_first": true,
    "solution_first": true
   },
   "source": [
    "__Exercise:__ Add the nodes (i.e. pokemons) or the evolution pathway into the graph. \n",
    "\n",
    "_Hint:_ If you choose to add nodes first. You will then read from the data frame and add from the `'Name'` feature. You will then read the `'Name'` and `'Evolve From'` values and add the edges. \n",
    "\n",
    "If you choose the second path, it is esentially the other order. However, at the end make sure you have added all the singletons. `.add_edge()` or `.add_edges_from([...])` are helpful. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "edges_add = pokemon_df[['#', 'Evolve From']][pokemon_df['Evolve From'].notna()].to_records(index=False).tolist()\n",
    "evoluting_pokemons = set([x[0] for x in edges_add]).union(set([int(x[1]) for x in edges_add]))\n",
    "singleton_pokemons = set(pokemon_df['#'].tolist()) - evoluting_pokemons\n",
    "\n",
    "family_tree.add_edges_from(edges_add)\n",
    "family_tree.add_nodes_from(singleton_pokemons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code below\n"
   ]
  },
  {
   "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. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution": "hidden",
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "plt.figure(figsize=(20,20))\n",
    "nx.draw_networkx(evolution_net)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(20,20))\n",
    "# Your code below\n"
   ]
  },
  {
   "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. "
   ]
  },
  {
   "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",
   "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.8"
  },
  "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": 2
}