Session 1. Tutorial on PageRank - Part 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hands-on Tutorial for Link Analysis\n",
    "\n",
    "Welcome to hands-on tutorial for link analysis. \n",
    "In this tutorial, we will study several techniques for link analysis in graphs. \n",
    "This tutorial consists of four sessions, and each session will handle the following topic:\n",
    "\n",
    "* **Session 1**. Tutorial on PageRank - Part 1 (50 mins) <<<\n",
    "* **Session 2**. Tutorial on PageRank - Part 2 (50 mins)\n",
    "* **Session 3**. Tutorial on Topic-specific PageRank (50 mins)\n",
    "* **Session 4**. Tutorial on HITS (50 mins)\n",
    "\n",
    "We recommend fully understanding link analysis (or ranking) models such as PageRank, Topic-specific PageRank, and HITS before entering this tutorial since we will **NOT** explain the theoretical backgrounds on these techniques during the tutorial. \n",
    "We will mainly focus on how to implement the algorithms of those models and how to rank nodes in real-world graphs using those ranking models. \n",
    "\n",
    "The main contributor of this material is as follows:\n",
    "\n",
    "* Jinhong Jung (jinhongjung@snu.ac.kr)\n",
    "\n",
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Session 1. Tutorial on PageRank - Part 1 (50 mins)\n",
    "In this session, we will explore how to implement PageRank in Python. \n",
    "The main goals of this session are summarized as follows:\n",
    "* **Goal 1.** How to implement PageRank based on dense matrices using `numpy` in Python\n",
    "* **Goal 2.** How to verify your PageRank implementation\n",
    "* **Goal 3.** To understand the problem of the dense matrix version\n",
    "\n",
    "The outline of this session is as follows:\n",
    "* **Step 1.** Review PageRank\n",
    "* **Step 2.** Set up requirements for this tutorial\n",
    "* **Step 3.** Implement PageRank - the dense matrix version\n",
    "* **Step 4.** Validate your PageRank implementation\n",
    "* **Step 5.** What is the problem of the dense matrix version?\n",
    "\n",
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1. Review PageRank\n",
    "We will briefly review PageRank and its equation which are required for the implementation of PageRank in Python. \n",
    "Note that we will not touch the details on PageRank (e.g., how to derive PageRank equation). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before going further, let's check several mathematical notations used in this tutorial.\n",
    "* **Scalar**: lower case & regular face\n",
    "    - $\\alpha$, $\\beta$, and $\\gamma$\n",
    "* **Set**: upper case & regular face\n",
    "    - $A$, $B$, and $C$\n",
    "* **Vector** and **matrix**: smaller case for vectors & upper case for matrices & bold face\n",
    "    - $\\mathbf{x}$, $\\mathbf{A}$, and $\\mathbf{S}$\n",
    "    - $x_{i}$ is $i$-th element of vector $\\mathbf{x}$\n",
    "    - $A_{ij}$ is $(i, j)$-th element of matrix $\\mathbf{A}$\n",
    "* **Number domain**: blackboard bold\n",
    "    - $\\mathbb{R}$: set of real numbers\n",
    "    - $\\mathbb{R}^{n}$: $n$-dimensional space in real numbers\n",
    "        - set of $n$-dimensional vectors, i.e., $\\mathbf{x} \\in \\mathbb{R}^{n}$\n",
    "    - $\\mathbb{R}^{n \\times m}$: $n \\times m$-dimensional space in real numbers\n",
    "        - set of $n \\times m$ real number matrices, i.e., $\\mathbf{A}\\in \\mathbb{R}^{n \\times m}$\n",
    "\n",
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 1-1. Mathematical definitions of PageRank\n",
    "Now, let's look into the problem definition of PageRank to be implemented through this tutorial.\n",
    "##### Problem definition of PageRank\n",
    "* **Input**: adjacency matrix $\\mathbf{A} \\in \\mathbb{R}^{n \\times n}$ of a graph $G=(V,E)$, and teleport probability $\\beta$\n",
    "    - $V$ is the set of nodes\n",
    "    - $E$ is the set of edges\n",
    "    - $n$ is the number of nodes in the graph $G$, i.e., $n=|V|$\n",
    "    - $m$ is the number of edges in the graph $G$, i.e., $m=|E|$\n",
    "* **Output**: the PageRank score vector $\\mathbf{p} \\in \\mathbb{R}^{n}$ such that\n",
    "\n",
    "$$\\mathbf{p} = (1-\\beta)\\mathbf{\\tilde{A}}^{\\top}\\mathbf{p} + \\beta\\mathbf{q}$$\n",
    "\n",
    "- The above equation is called *PageRank equation*. The notations used in the PageRank equation are described below:\n",
    "    - $\\mathbf{\\tilde{A}}$ is the row-normalized adjacency matrix of the graph $G$, i.e., the sum of each row of $\\mathbf{\\tilde{A}}$ should be $1$\n",
    "    - $\\mathbf{q}=\\left[\\frac{1}{n}\\right]_{n}$ is $n$-dimensional vector whose entry is $1/n$. It is usually called a *query vector*.\n",
    "    - The PageRank score of node $u$ is denoted by $p_u$ indicating the importance of node $u$ in the graph $G.$\n",
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The definitions of adjacency matrix $\\mathbf{A}$ and row-normalized adjacency matrix $\\mathbf{\\tilde{A}}$ are described in the following definitions, respectively. \n",
    "\n",
    "##### Definition of adjacency matrix $\\mathbf{A}$\n",
    "For each edge $u \\rightarrow v$ in $E$, $A_{uv}=1$. Otherwise, $A_{uv}=0$ (i.e., if there is no edge between two nodes, the value of the adjacency matrix is zero).\n",
    "\n",
    "##### Definition of row-normalized adjacency matrix $\\mathbf{\\tilde{A}}$\n",
    "For each edge $u \\rightarrow v$ in $E$, $\\tilde{A}_{uv}=\\frac{1}{|O_{u}|}$ where $O_{u}$ is the set of out-neighbors of node $u$.\n",
    "Let $\\mathbf{D}$ be a diagonal matrix where $u$-th diagonal entry is $|O_{u}|$ (i.e., the out-degree of node $u$).\n",
    "Then, the row-normalized adjacency matrix $\\mathbf{\\tilde{A}}$ is easily obtained by the following equation:\n",
    "\n",
    "$$\\mathbf{\\tilde{A}} = \\mathbf{D}^{-1}\\mathbf{A}$$\n",
    "\n",
    "where $\\mathbf{D}^{-1}$ is the inverse of $\\mathbf{D}$ (i.e., $u$-th diagonal entry of $\\mathbf{D}^{-1}$ is $\\frac{1}{|O_{u}|}$).\n",
    "\n",
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 1-2. Iterative Algorithm for PageRank\n",
    "\n",
    "The PageRank score vector $\\mathbf{p}$ is obtained by iteratively computing the PageRank equation. \n",
    "The following pseudo-code represents the iterative algorithm for PageRank.\n",
    "\n",
    "<img src=\"./images/iterative-algorithm-pagerank.png\" width=\"400\">\n",
    "\n",
    "We will implement the iterative algorithm in Python. \n",
    "\n",
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2. Set up requirements for this tutorial\n",
    "\n",
    "Before going further, we need to check if several Python packages are installed. \n",
    "We will use `numpy`, `matplotlib`, and `pandas` in this session. \n",
    "Let's check the installation. \n",
    "If you encounter error messages, please install required packages. \n",
    "If there is no any message, you can move to the next step. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    import numpy\n",
    "except ImportError:\n",
    "    print(\"numpy is not installed, type pip install numpy\")\n",
    "\n",
    "try:\n",
    "    import matplotlib\n",
    "except ImportError:\n",
    "    print(\"matplotlib is not installed, type pip install matplotlib\")\n",
    "    \n",
    "try:\n",
    "    import pandas\n",
    "except ImportError:\n",
    "    print(\"pandas is not installed, type pip install pandas\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3. Implement PageRank - the dense matrix version\n",
    "\n",
    "In this step, we will implement the iterative algorithm for PageRank using dense matrices provided by *numpy* in Python. \n",
    "\n",
    "Note that we will test the dense version implementation using a small graph since it has a scalability issue, which will be discussed in Step 5 (and, we will resolve this issue in Session 2)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3-0. Description of a dataset used in this step\n",
    "\n",
    "We describe a small graph dataset used in this step. \n",
    "The name of the dataset is *SeventhGraders* which is a social network describing connections between students. \n",
    "More specifically, this directed network contains friendships between students from 29 seventh grade students from a school in Victoria. \n",
    "A node represents a student. \n",
    "An edge between two nodes shows that the left student picked the right student as his friend (e.g., $u \\rightarrow v$ indicates $u$ considers $v$ as his friend).\n",
    "The statistics of the dataset is as follows:\n",
    "\n",
    "| Statistic | Value |\n",
    "| --- | --- |\n",
    "| $n$: the number of nodes | 29 |\n",
    "| $m$: the number of edges | 376|\n",
    "| the number of female students | 17 |\n",
    "| the number of male students | 12 |\n",
    "\n",
    "The dataset is located at `./data/small` contatining `edges.tsv` and `node_labels.tsv`.\n",
    "The format of each file is is as follows:\n",
    "* `edges.tsv`: This file contains the list of (directed) edges with the format `source_node \\t target_node \\t weight`. The node index starts from `0`. The following is the top-5 head lines of the file.\n",
    "```\n",
    "0        1        1\n",
    "0        2        1\n",
    "0        3        1\n",
    "0        4        1\n",
    "0        5        1\n",
    "...\n",
    "```\n",
    "* `node_labels.tsv`: This file contains the list of node labels with the format `node \\t label`. Each label indicates the node's gender and (anonymous) name. The following is the top-5 head lines of the file. \n",
    "```\n",
    "0        male_noah\n",
    "1        male_liam\n",
    "2        male_william\n",
    "3        male_benjamin\n",
    "4        male_jacob\n",
    "...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3-1. Implement the phase for loading the graph dataset\n",
    "Your first job is to implement functions `load_graph_dataset` and `load_node_labels` to load the datasets `edges.tsv` and `node_labels.tsv`.\n",
    "These functions are given the directory path for the dataset (i.e., `./data/small`), and load the adjacency matrix $\\mathbf{A}$ and the list of nodes labels of the graph, respectively. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the below commands restrict the number of computation threads to 1\n",
    "import os\n",
    "os.environ[\"MKL_NUM_THREADS\"] = \"1\" \n",
    "os.environ[\"NUMEXPR_NUM_THREADS\"] = \"1\" \n",
    "os.environ[\"OMP_NUM_THREADS\"] = \"1\" \n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We briefly introduce several APIs in `numpy` used when implementing the below function which constructs the adjacency matrix of a graph.\n",
    "* `loadtxt`: this loads data from a text file\n",
    "    - https://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html\n",
    "* `amax`: this returns the maximum of an array\n",
    "    - https://docs.scipy.org/doc/numpy/reference/generated/numpy.amax.html\n",
    "* `shape`: this returns the dimension of an array (or matrix)\n",
    "    - `A.shape` will return `(m, n)` where m is # of rows, and n is # of columns \n",
    "    - https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.shape.html\n",
    "* `count_nonzero`: this returns the number of non-zeros of a matrix\n",
    "    - https://docs.scipy.org/doc/numpy/reference/generated/numpy.count_nonzero.html\n",
    "* slice: `edges[:, 0:2]` will return the first and second columns of `edges` matrix.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DensePageRank:\n",
    "    def load_graph_dataset(self, data_home, is_undirected=False):\n",
    "        '''\n",
    "        Load the graph dataset from the given directory (data_home)\n",
    "\n",
    "        inputs:\n",
    "            data_home: string\n",
    "                directory path conatining a dataset\n",
    "            is_undirected: bool\n",
    "                if the graph is undirected\n",
    "        '''\n",
    "        # Step 1. set file paths from data_home\n",
    "        edge_path = \"{}/edges.tsv\".format(data_home)\n",
    "\n",
    "        # Step 2. read the list of edges from edge_path\n",
    "        edges = np.loadtxt(edge_path, dtype=int)\n",
    "        n = int(np.amax(edges[:, 0:2])) + 1 # the current n is the maximum node id (starting from 0)\n",
    "\n",
    "        # Step 3. convert the edge list to the adjacency matrix\n",
    "        self.A = np.zeros((n, n))\n",
    "        for i in range(edges.shape[0]):\n",
    "            source, target, weight = edges[i, :]\n",
    "            self.A[(source, target)] = weight\n",
    "            if is_undirected:\n",
    "                self.A[(target, source)] = weight\n",
    "\n",
    "        # Step 4. set n (# of nodes) and m (# of edges)\n",
    "        self.n = n                         # number of nodes\n",
    "        self.m = np.count_nonzero(self.A)  # number of edges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we implement a function for loading the node labels using `pandas`. \n",
    "* `read_csv`: this reads a file into `DataFrame` (a table)\n",
    "    - https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DensePageRank(DensePageRank):\n",
    "    def load_node_labels(self, data_home):\n",
    "        '''\n",
    "        Load the node labels from the given directory (data_home)\n",
    "\n",
    "        inputs:\n",
    "            data_home: string\n",
    "                directory path conatining a dataset\n",
    "        '''\n",
    "        label_path = \"{}/node_labels.tsv\".format(data_home)\n",
    "        self.node_labels = pd.read_csv(label_path, sep=\"\\t\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check if the function is correctly implemented. \n",
    "Note that the dataset is a directed network; hence, you should set `is_unidrected` to `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number n of nodes: 29\n",
      "The number m of edges: 376\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>node_id</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>male_noah</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>male_liam</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>male_william</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>male_benjamin</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>male_jacob</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   node_id            label\n",
       "0         0       male_noah\n",
       "1         1       male_liam\n",
       "2         2    male_william\n",
       "3         3   male_benjamin\n",
       "4         4      male_jacob"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_home = './data/small'\n",
    "dpr = DensePageRank()\n",
    "dpr.load_graph_dataset(data_home, is_undirected=False)\n",
    "dpr.load_node_labels(data_home)\n",
    "\n",
    "# print the number of nodes and edges\n",
    "print(\"The number n of nodes: {}\".format(dpr.n))\n",
    "print(\"The number m of edges: {}\".format(dpr.m))\n",
    "\n",
    "# print the heads (5) of the node labels\n",
    "display(dpr.node_labels.head(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3-2. Implement the normalization phase\n",
    "Next, we need the row-normalized adjacency matrix $\\mathbf{\\tilde{A}}$ of the adjacency matrix $\\mathbf{A}$. \n",
    "We briefly introduce several APIs in `numpy` for this cell. \n",
    "* `sum`: this performs the summation of an arror or a matrix\n",
    "    * `A.sum(axis = 0)`: column-wise sum of matrix A (will be a vector)\n",
    "    * `A.sum(axis = 1)`: row-wise sum of matirx A (will be a vector)\n",
    "    * https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html\n",
    "* `dot`: this performs a matrix multiplication.\n",
    "    * given matrix `A` and vector `x`, `A.dot(x)` will perform the matrix-vector multiplication between `A` and `x`, i.e., `Ax`.\n",
    "    * https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.dot.html\n",
    "* `diag`: given a vector, this builds a diagonal matrix whose diagonal entries corresponds to the given vector. \n",
    "    * https://docs.scipy.org/doc/numpy/reference/generated/numpy.diag.html\n",
    "* `T`: this takes the transpose of a matrix, e.g., A.T is the transpose of matrix A\n",
    "\n",
    "In this phase, our goal is to implement the following operation: \n",
    "\n",
    "$$\\mathbf{\\tilde{A}} = \\mathbf{D}^{-1}\\mathbf{A}$$\n",
    "\n",
    "Here is one trick for the diagonal matrix $\\mathbf{D}$. \n",
    "One of mathematical properties of a diagonal matrix is that the inverse of the diagonal matrix is the matrix whose diagonal entries are inverted. \n",
    "Hence, we do not need to do matrix inversion explicitly for this. \n",
    "Let $\\text{diag}(d_1, \\cdots, d_n)$ be a diagonal matrix. \n",
    "Then, $\\text{diag}(d_1, \\cdots, d_n)^{-1} = \\text{diag}(d_1^{-1}, \\cdots, d_n^{-1})$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DensePageRank(DensePageRank):\n",
    "    def normalize(self):\n",
    "        '''\n",
    "        Perform the row-normalization of the given adjacency matrix\n",
    "        '''\n",
    "        # Step 1. obatin the out-degree vector d\n",
    "        d = self.A.sum(axis = 1)           # row-wise summation\n",
    "\n",
    "        # Step 2. obtain the inverse of the out-degree matrix\n",
    "        d = np.maximum(d, np.ones(self.n)) # handles zero out-degree nodes, `maximum` perform entry-wise maximum \n",
    "        invd = 1.0 / d                # entry-wise division\n",
    "        invD = np.diag(invd)          # convert invd vector to a diagonal matrix\n",
    "\n",
    "        # Step 3. compute the row-normalized adjacency matrix\n",
    "        self.nA = invD.dot(self.A)   # nA = invD * A\n",
    "        self.nAT = self.nA.T         # nAT is the transpose of nA\n",
    "        \n",
    "        self.out_degrees = d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check if the function is correctly implemented. \n",
    "Note that in the row-normalized matrix $\\mathbf{\\tilde{A}}$, the sum of each row should be $1$.\n",
    "Hence, check if the sum of each row of $\\mathbf{\\tilde{A}}$ is $1$. \n",
    "\n",
    "*CAUTION*: someone might encounter $0.99999...$ instead of exact $1.0$ due to floating point operations.\n",
    "In that case, you can ignore very small error in the values. This is not that critical for the final PageRank scores. \n",
    "If you see a value of a node much less than $1$ where the out-degree of the node is greater than $0$, then you need to inspect if there is an error in your implementation.\n",
    "If the out-degree of a node is $0$, then the row-wise sum should be $0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node:  0, out-degree: 14,  row_sum: 1.00\n",
      "node:  1, out-degree: 15,  row_sum: 1.00\n",
      "node:  2, out-degree: 17,  row_sum: 1.00\n",
      "node:  3, out-degree: 23,  row_sum: 1.00\n",
      "node:  4, out-degree: 27,  row_sum: 1.00\n",
      "node:  5, out-degree: 27,  row_sum: 1.00\n",
      "node:  6, out-degree: 12,  row_sum: 1.00\n",
      "node:  7, out-degree: 14,  row_sum: 1.00\n",
      "node:  8, out-degree: 16,  row_sum: 1.00\n",
      "node:  9, out-degree: 12,  row_sum: 1.00\n",
      "node: 10, out-degree: 14,  row_sum: 1.00\n",
      "node: 11, out-degree: 10,  row_sum: 1.00\n",
      "node: 12, out-degree: 13,  row_sum: 1.00\n",
      "node: 13, out-degree:  8,  row_sum: 1.00\n",
      "node: 14, out-degree:  9,  row_sum: 1.00\n",
      "node: 15, out-degree:  5,  row_sum: 1.00\n",
      "node: 16, out-degree:  6,  row_sum: 1.00\n",
      "node: 17, out-degree:  1,  row_sum: 1.00\n",
      "node: 18, out-degree:  6,  row_sum: 1.00\n",
      "node: 19, out-degree: 13,  row_sum: 1.00\n",
      "node: 20, out-degree: 15,  row_sum: 1.00\n",
      "node: 21, out-degree: 19,  row_sum: 1.00\n",
      "node: 22, out-degree: 12,  row_sum: 1.00\n",
      "node: 23, out-degree: 16,  row_sum: 1.00\n",
      "node: 24, out-degree: 11,  row_sum: 1.00\n",
      "node: 25, out-degree: 16,  row_sum: 1.00\n",
      "node: 26, out-degree: 15,  row_sum: 1.00\n",
      "node: 27, out-degree:  5,  row_sum: 1.00\n",
      "node: 28, out-degree:  5,  row_sum: 1.00\n"
     ]
    }
   ],
   "source": [
    "dpr = DensePageRank()\n",
    "dpr.load_graph_dataset('./data/small', is_undirected=False)\n",
    "dpr.normalize()\n",
    "\n",
    "# check the sum of each row in the row-normalized matrix nA\n",
    "row_sums = dpr.nA.sum(axis=1)\n",
    "for (i, degree, row_sum) in zip(range(dpr.n), dpr.out_degrees, row_sums):\n",
    "    print(\"node: {:2d}, out-degree: {:2d},  row_sum: {:.2f}\".format(i, int(degree), row_sum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3-3. Implement the iterative phase\n",
    "Now, we are ready to implement the iterative algorithm for PageRank. \n",
    "Based on Algorithm 1, we will fill the following function `iterate_PageRank`.\n",
    "For convenience, we provide the iterative algorithm in this cell again. \n",
    "\n",
    "<img src=\"./images/iterative-algorithm-pagerank.png\" width=\"400\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DensePageRank(DensePageRank):\n",
    "    def iterate_PageRank(self, b=0.15, epsilon=1e-9, maxIters=100):\n",
    "        '''\n",
    "        Iterate the PageRank equation to obatin the PageRank score vector\n",
    "\n",
    "        inputs:\n",
    "            b: float (between 0 and 1)\n",
    "                the teleport probability\n",
    "            epsilon : float\n",
    "                the error tolerance of the iteration\n",
    "            maxIters : int\n",
    "                the maximum number of iterations\n",
    "\n",
    "        outputs:\n",
    "            p: np.ndarray (n x 1 vector)\n",
    "                the final PageRank score vector\n",
    "            residuals: list\n",
    "                the list of residuals over the iteration\n",
    "        '''\n",
    "        q = np.ones(self.n)/self.n     # set the query vector q\n",
    "        old_p = q                      # set the previous PageRank score vector\n",
    "        residuals = []                 # set the list for residuals over iterations\n",
    "\n",
    "        for t in range(maxIters):\n",
    "            p = (1 - b) * (self.nAT.dot(old_p)) + (b * q)\n",
    "            residual = np.linalg.norm(p - old_p, 1)\n",
    "            residuals.append(residual)\n",
    "            old_p = p\n",
    "\n",
    "            if residual < epsilon:\n",
    "                break\n",
    "\n",
    "        return p, residuals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the result of the iterative algorithm. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node:  0, PageRank score: 0.0237\n",
      "node:  1, PageRank score: 0.0393\n",
      "node:  2, PageRank score: 0.0387\n",
      "node:  3, PageRank score: 0.0177\n",
      "node:  4, PageRank score: 0.0345\n",
      "node:  5, PageRank score: 0.0446\n",
      "node:  6, PageRank score: 0.0200\n",
      "node:  7, PageRank score: 0.0522\n",
      "node:  8, PageRank score: 0.0518\n",
      "node:  9, PageRank score: 0.0327\n",
      "node: 10, PageRank score: 0.0508\n",
      "node: 11, PageRank score: 0.0435\n",
      "node: 12, PageRank score: 0.0466\n",
      "node: 13, PageRank score: 0.0454\n",
      "node: 14, PageRank score: 0.0420\n",
      "node: 15, PageRank score: 0.0334\n",
      "node: 16, PageRank score: 0.0214\n",
      "node: 17, PageRank score: 0.0203\n",
      "node: 18, PageRank score: 0.0183\n",
      "node: 19, PageRank score: 0.0437\n",
      "node: 20, PageRank score: 0.0478\n",
      "node: 21, PageRank score: 0.0243\n",
      "node: 22, PageRank score: 0.0449\n",
      "node: 23, PageRank score: 0.0274\n",
      "node: 24, PageRank score: 0.0346\n",
      "node: 25, PageRank score: 0.0350\n",
      "node: 26, PageRank score: 0.0255\n",
      "node: 27, PageRank score: 0.0187\n",
      "node: 28, PageRank score: 0.0211\n"
     ]
    }
   ],
   "source": [
    "data_home = './data/small'\n",
    "dpr = DensePageRank()\n",
    "dpr.load_graph_dataset(data_home, is_undirected=False)\n",
    "dpr.load_node_labels(data_home)\n",
    "dpr.normalize()\n",
    "p, residuals = dpr.iterate_PageRank(b=0.15, epsilon=1e-9, maxIters=100)\n",
    "\n",
    "# print the PageRank score of each node\n",
    "for (i, score) in zip(range(dpr.n), p):\n",
    "    print(\"node: {:2d}, PageRank score: {:.4f}\".format(i, score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4. Validate your PageRank implementation\n",
    "\n",
    "In this step, we will verify if the implementation for PageRank is correctly done. \n",
    "There are two ways to perform the validation. \n",
    "First, we need to check if the residuals over the iteration decrease monotonically. \n",
    "Second, we should check if the solution from the iteration phase is equal (very close) to the exact solution from the closed form of the PageRank equation.\n",
    "We will describe the details on the closed form in Step 4-2. \n",
    "After checking these, we will implement a function for ranking nodes in the order of PageRank scores in Step 4-3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 4-1. Check if the residuals monotonically decrease\n",
    "\n",
    "Note that we stored the residuals into `residuals` returned by `iterate_PageRank` as the second argument. \n",
    "In other words, by plotting `residuals`, we can check the tendency of the residuals over the iterations. \n",
    "For this, we first import `matplotlib` as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams.update({'font.size': 13}) # set the font-size in the figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will implement a function `plot_residuals` for the plot since it will be used for validating the implementations for other models such as Topic-specific PageRank and HITS. \n",
    "Let's fill the following function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_residuals(residuals, title):\n",
    "    plt.semilogy(residuals, marker='o', markersize=5)\n",
    "    plt.title(title)\n",
    "    plt.ylim(bottom=1e-10, top=1e-0)\n",
    "    plt.ylabel('Residual')\n",
    "    plt.xlabel('# of iterations')\n",
    "    plt.grid(True)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the plot for the residuals using `plot_residuals`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_residuals(residuals, 'Change of Residuals from PageRank')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the residual should decrease monotonically as the number of iterations increases, and the line should be terminated when the residual is less than the given error tolerance (e.g., $\\epsilon=10^{-9}$ in this example).\n",
    "\n",
    "The residual indicates the difference between the current PageRank score vector and the previous one. \n",
    "In other words, the difference decreases as the number of iterations increases. \n",
    "Theoretically, they become the same when we infinitely repeat the iteration, and we call this situation *convergence*. \n",
    "When the residual behaves as in the figure, we say the PageRank score vector converges. \n",
    "\n",
    "One remaining question is then, *is the converged PageRank score vector really true value?* Note that since the residual is the difference of the consecutive score vectors, we cannot answer the question with only this plot. \n",
    "\n",
    "One short answer is *YES*, it always converges to the true PageRank score vector, which has been proved theoretically. \n",
    "We won't handle the theoretical proofs since it is too complex to cover during the tutorial. \n",
    "Instead, we will check this point empirically in the following step. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 4-2. Check if the iterative solution is equal to the exact solution of PageRank\n",
    "\n",
    "We first derive the closed form of the PageRank equation as follows:\n",
    "\n",
    "$$\n",
    "\\mathbf{p} = (1-\\beta)\\mathbf{\\tilde{A}}^{\\top}\\mathbf{p} + \\beta\\mathbf{q} \\\\\n",
    "\\Leftrightarrow \\mathbf{p} - (1-\\beta)\\mathbf{\\tilde{A}}^{\\top}\\mathbf{p} = \\beta\\mathbf{q} \\\\\n",
    "\\Leftrightarrow \\left(\\mathbf{I} - (1-\\beta)\\mathbf{\\tilde{A}}^{\\top}\\right)\\mathbf{p} = \\beta\\mathbf{q} \\\\\n",
    "\\Leftrightarrow \\mathbf{p} = \\beta\\left(\\mathbf{I} - (1-\\beta)\\mathbf{\\tilde{A}}^{\\top}\\right)^{-1}\\mathbf{q} \\\\\n",
    "$$\n",
    "\n",
    "where $\\mathbf{I}$ is the identity matrix whose dimension is $n$. \n",
    "According to the derivation, we are able to directly compute the PageRank score without the iteration. \n",
    "And, the solution from the closed form is called the *exact solution*.\n",
    "The reason why we implement the iterative phase is that the matrix inversion is a very expensive operation; \n",
    "hence, it is intractable to compute the PageRank score on a large-scale graphs via matrix inversion. \n",
    "However, for a small graph, we can perform the matrix inversion to obtain the exact solution in a reasonable time, and use the solution to compare with the iterative solution.\n",
    "\n",
    "For this, we implement a function `compute_exact_PageRank` based on the closed form. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DensePageRank(DensePageRank):\n",
    "    def compute_exact_PageRank(self, b=0.15):\n",
    "        '''\n",
    "        Compute the exact PageRank score vector from the closed form\n",
    "\n",
    "        inputs:\n",
    "            b: float (between 0 and 1)\n",
    "                the teleport probability\n",
    "        outputs:\n",
    "            p: np.ndarray (n x 1 vector)\n",
    "                the final PageRank score vector\n",
    "        '''\n",
    "        q = np.ones(self.n)/self.n          # set the query vector q\n",
    "\n",
    "        H = np.eye(self.n) - (1.0 - b)*self.nAT\n",
    "        invH = np.linalg.inv(H)\n",
    "\n",
    "        p = b*(invH.dot(q))\n",
    "\n",
    "        return p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's compare the exact PageRank score vector and the iterative one. \n",
    "One convenient way is to measure the difference between them using L1-norm as\n",
    "\n",
    "$$\n",
    "error = \\lVert \\mathbf{p}_{exact} - \\mathbf{p}_{iter}\\rVert_{1}\n",
    "$$\n",
    "\n",
    "where $\\mathbf{p}_{exact}$ is the exact PageRank score vector, and $\\mathbf{p}_{iter}$ is the iterative one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error between exact and iterative PageRank scores: 5.964698e-10\n"
     ]
    }
   ],
   "source": [
    "data_home = './data/small'\n",
    "dpr = DensePageRank()\n",
    "dpr.load_graph_dataset(data_home, is_undirected=False)\n",
    "dpr.load_node_labels(data_home)\n",
    "dpr.normalize()\n",
    "\n",
    "p_exact = dpr.compute_exact_PageRank(b=0.15)\n",
    "p_iter, _ = dpr.iterate_PageRank(b=0.15, epsilon=1e-9, maxIters=100)\n",
    "\n",
    "error = np.linalg.norm(p_exact - p_iter, 1)\n",
    "print(\"Error between exact and iterative PageRank scores: {:e}\".format(error))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the error between them is very small, e.g., less than $10^{-10}$ which is considered as zero in practice. \n",
    "We can check each score node by node as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node:  0, exact_score: 0.0237413, iter_score: 0.0237413\n",
      "node:  1, exact_score: 0.0393204, iter_score: 0.0393204\n",
      "node:  2, exact_score: 0.0387131, iter_score: 0.0387131\n",
      "node:  3, exact_score: 0.0177171, iter_score: 0.0177171\n",
      "node:  4, exact_score: 0.0345046, iter_score: 0.0345046\n",
      "node:  5, exact_score: 0.0445602, iter_score: 0.0445602\n",
      "node:  6, exact_score: 0.0199576, iter_score: 0.0199576\n",
      "node:  7, exact_score: 0.0521591, iter_score: 0.0521591\n",
      "node:  8, exact_score: 0.0517924, iter_score: 0.0517924\n",
      "node:  9, exact_score: 0.0326633, iter_score: 0.0326633\n",
      "node: 10, exact_score: 0.0508263, iter_score: 0.0508263\n",
      "node: 11, exact_score: 0.0434542, iter_score: 0.0434542\n",
      "node: 12, exact_score: 0.0466453, iter_score: 0.0466453\n",
      "node: 13, exact_score: 0.0453634, iter_score: 0.0453634\n",
      "node: 14, exact_score: 0.0419984, iter_score: 0.0419984\n",
      "node: 15, exact_score: 0.0333760, iter_score: 0.0333760\n",
      "node: 16, exact_score: 0.0214356, iter_score: 0.0214356\n",
      "node: 17, exact_score: 0.0203439, iter_score: 0.0203439\n",
      "node: 18, exact_score: 0.0182682, iter_score: 0.0182682\n",
      "node: 19, exact_score: 0.0437339, iter_score: 0.0437339\n",
      "node: 20, exact_score: 0.0478166, iter_score: 0.0478166\n",
      "node: 21, exact_score: 0.0243393, iter_score: 0.0243393\n",
      "node: 22, exact_score: 0.0449098, iter_score: 0.0449098\n",
      "node: 23, exact_score: 0.0274438, iter_score: 0.0274438\n",
      "node: 24, exact_score: 0.0345592, iter_score: 0.0345592\n",
      "node: 25, exact_score: 0.0350438, iter_score: 0.0350438\n",
      "node: 26, exact_score: 0.0254514, iter_score: 0.0254514\n",
      "node: 27, exact_score: 0.0187322, iter_score: 0.0187322\n",
      "node: 28, exact_score: 0.0211295, iter_score: 0.0211295\n"
     ]
    }
   ],
   "source": [
    "for (i, exact_score, iter_score) in zip(range(dpr.n), p_exact, p_iter):\n",
    "    print(\"node: {:2d}, exact_score: {:.7f}, iter_score: {:.7f}\".format(i, exact_score, iter_score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check there is no difference between their scores up to 7 decimal places."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 4-3. Check the ranking result from the PageRank scores\n",
    "We will implement a function `rank_nodes` to rank nodes in order of given ranking scores. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DensePageRank(DensePageRank):\n",
    "    def rank_nodes(self, ranking_scores, topk=-1):\n",
    "        '''\n",
    "        Rank nodes in the order of given ranking scores. \n",
    "        This function reports top-k rankings. \n",
    "\n",
    "        inputs:\n",
    "            ranking_scores: np.ndarray\n",
    "                ranking score vector\n",
    "            topk: int\n",
    "                top-k ranking parameter, default is -1 indicating report all ranks\n",
    "        '''\n",
    "        sorted_nodes = np.flipud(np.argsort(ranking_scores)) # argsort in the descending order\n",
    "        sorted_scores = ranking_scores[sorted_nodes]         # sort the ranking scores\n",
    "        ranks = range(1, self.n+1) # 0~n-1\n",
    "\n",
    "        result_labels = self.node_labels.iloc[sorted_nodes][0:topk]\n",
    "        result_labels.insert(0, \"rank\", ranks[0:topk])\n",
    "        result_labels[\"score\"] = sorted_scores[0:topk]\n",
    "        result_labels.reset_index(drop = True, inplace = True)\n",
    "        return result_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see the ranking results from the function. \n",
    "We are going to check top-10 ranks in the order of PageRank scores in the graph. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>rank</th>\n",
       "      <th>node_id</th>\n",
       "      <th>label</th>\n",
       "      <th>score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>female_emma</td>\n",
       "      <td>0.052159</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "      <td>female_olivia</td>\n",
       "      <td>0.051792</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>10</td>\n",
       "      <td>female_isabella</td>\n",
       "      <td>0.050826</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>20</td>\n",
       "      <td>female_emily</td>\n",
       "      <td>0.047817</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>12</td>\n",
       "      <td>female_mia</td>\n",
       "      <td>0.046645</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>13</td>\n",
       "      <td>female_amelia</td>\n",
       "      <td>0.045363</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>7</td>\n",
       "      <td>22</td>\n",
       "      <td>female_harper</td>\n",
       "      <td>0.044910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>8</td>\n",
       "      <td>5</td>\n",
       "      <td>male_elijah</td>\n",
       "      <td>0.044560</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>9</td>\n",
       "      <td>19</td>\n",
       "      <td>female_abigail</td>\n",
       "      <td>0.043734</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "      <td>female_sophia</td>\n",
       "      <td>0.043454</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   rank  node_id              label     score\n",
       "0     1         7       female_emma  0.052159\n",
       "1     2         8     female_olivia  0.051792\n",
       "2     3        10   female_isabella  0.050826\n",
       "3     4        20      female_emily  0.047817\n",
       "4     5        12        female_mia  0.046645\n",
       "5     6        13     female_amelia  0.045363\n",
       "6     7        22     female_harper  0.044910\n",
       "7     8         5       male_elijah  0.044560\n",
       "8     9        19    female_abigail  0.043734\n",
       "9    10        11     female_sophia  0.043454"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_home = './data/small'\n",
    "dpr = DensePageRank()\n",
    "dpr.load_graph_dataset(data_home, is_undirected=False)\n",
    "dpr.load_node_labels(data_home)\n",
    "dpr.normalize()\n",
    "p, _ = dpr.iterate_PageRank(b=0.15, epsilon=1e-9, maxIters=100)\n",
    "\n",
    "# display top-10 ranking in the order of PageRank scores\n",
    "display(dpr.rank_nodes(p, topk=10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that there are $9$ female students among top-$10$ rankings in the graph. \n",
    "This implies that there would be a strong tie between female students with many connections from other students (remind the intuition behind PageRank that more important students are likely to receive more links from other students)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 5. What is the problem of the dense matrix version?\n",
    "\n",
    "Before finishing this session, let's check the problem of the dense matrix version of PageRank `iterate_PageRank`. \n",
    "The main issue of the dense matrix version is a *scalability*, i.e., when we need to handle a large-scale network, that function requires intractable running time and memory space. \n",
    "More specifically, the function requires $O(n^{2})$ space from the row-normalized adjacency matrix `nA`, an $n \\times n$ matrix where $n$ is the number of nodes. \n",
    "Also, for each iteration, it requires $O(n^{2})$ time due to the dense matrix-vector multiplication `nAT.dot(old_p)`.\n",
    "\n",
    "One notable thing is that a (large) real-world network is extremely sparse. \n",
    "From many real-world networks, we can notice that the number $m$ of edges is constantly linear to the number $n$ of nodes, i.e., $m = cn$ where $c$ is a certain constant. \n",
    "If we can ignore storing $0$ values in a matrix (or only store non-zero values), we are able to reduce the time and space complexities to $O(m)$, which is much smaller than $O(n^2)$.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check this point using another real-world network.\n",
    "First, open a medium size dataset at `./data/medium` which is another directed graph (we will not explain the details on this graph since we want to just check the sparsity of the real-world graph). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number n of nodes: 2539\n",
      "The number m of edges: 12969\n"
     ]
    }
   ],
   "source": [
    "dpr = DensePageRank()\n",
    "dpr.load_graph_dataset('./data/medium', is_undirected=False)\n",
    "print(\"The number n of nodes: {}\".format(dpr.n))\n",
    "print(\"The number m of edges: {}\".format(dpr.m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the number of edges are linearly proportional to that of nodes (i.e., $m \\simeq 5.1n$).\n",
    "According to the result, we can easily check $O(m)$ is much less than $O(n^2)$.\n",
    "To measure the sparsity of the network, we define the sparsity as follows:\n",
    "\n",
    "$$\n",
    "\\text{sparsity} = 1.0 - \\frac{m}{n^2}\n",
    "$$\n",
    "\n",
    "which is the portion of the empty area in the adjacency matrix with width $n$. \n",
    "Let's see the sparsity of the network using the above metric. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sparsity of the network: 0.9980\n"
     ]
    }
   ],
   "source": [
    "class DensePageRank(DensePageRank):\n",
    "    def compute_sparsity(self):\n",
    "        sparsity = 1.0 - self.m/(self.n*self.n)\n",
    "        return sparsity\n",
    "\n",
    "dpr = DensePageRank()\n",
    "dpr.load_graph_dataset('./data/medium', is_undirected=False)    \n",
    "sparsity = dpr.compute_sparsity()\n",
    "print(\"The sparsity of the network: {:.4f}\".format(sparsity))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the network is extremely sparse; there are many empty values in the adjacency matrix. \n",
    "We can visualize the adjacency matrix to inspect the sparsity pattern of the matrix using `spy` function of `matplotlib`. \n",
    "Let's check the following cell. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,10))      # resize the figure to be presented\n",
    "plt.spy(dpr.A, markersize=0.1)   # sparsity pattern of the matrix \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown in the above figure, the matrix has a small number of non-zero entries, i.e., it is sparse. \n",
    "The point is that we do not need to store all those zero values when constructing a matrix. \n",
    "We will learn how to ignore zero values in the next session. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Session 1. Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In this session, we implemented PageRank (the dense matrix version) in Python. \n",
    "More specifically, we are able to answer the following goals now. \n",
    "* **Goal 1.** How to implement PageRank based on dense matrices using `numpy` in Python\n",
    "    - We implemented the iterative algorithm for PageRank based on dense matrices.\n",
    "* **Goal 2.** How to verify your PageRank implementation\n",
    "    - We learned several techniques (e.g., residual check and comparison with the exact solution) for this. \n",
    "* **Goal 3.** To understand the problem of the dense matrix version\n",
    "    - We explored how real-world networks are sparse quantitatively and visually. \n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}