class07b_pagerank_python3_template.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CSX46 - Class Session 10 - Pagerank centrality\n",
    "\n",
    "In this class session we are going to compute the outgoing-edge PageRank centrality of each gene (vertex) in a human gene regulatory network (a directed graph) from a landmark paper on human gene regulation (Neph et al., Cell, volume 150, pages 1274-1286, 2012; see PDF on Canvas in `Files/Optional Reading`). We will also write our own PageRank function and compare it to the `igraph.Graph.pagerank` method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Pandas `read_csv`, read in the ifle `shared/neph_gene_network.txt`, which has two columns of text (first column is the regulator gene, second column is the target gene), into a data frame. The file has no header and is tab-delimited.  Assign the column names of the dataframe to be `regulator` and `target`, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's load the Python packages that we will need for this exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas\n",
    "import igraph\n",
    "import numpy\n",
    "import matplotlib.pyplot\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `pandas.read_csv`, read the file `shared/neph_gene_network.txt`; name the two columns of the resulting data frame, `regulator` and `target`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "edge_list_neph = pandas.read_csv(FILL IN HERE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the edge-list data into a directed `igraph.Graph` object `neph_graph`, using `igraph.Graph.TupleList`. NOTE: igraph's `igraph.Graph.pagerank` computes only *incoming* pagerank centrality, and we want *outgoing* pagerank centrality. So: *make sure to reverse the columns of the data frame when you input the data frame into `Graph.TupleList` since we want the outgoing pagerank centrality not incoming pagerank centrality.* Print out a summary of the graph, using the `igraph.Graph.summary` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'IGRAPH DN-- 538 47945 -- \\n+ attr: name (v)'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neph_graph = igraph.Graph.TupleList(FILL IN HERE)\n",
    "neph_graph.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the pagerank centrality measures of all vertices, using `igraph.Graph.pagerank`.  Use the resulting object to initialize a `numpy.array`, `pageranks`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "pageranks = numpy.array(FILL IN HERE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which vertex has highest pagerank centrality in the gene regulatory network, and what is its pagerank centrality value? (think `numpy.max` and `numpy.argmax`). Get a `VertexSet` sequence using the `igraph.Graph.vs` property, and then index into that sequence using Python indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00749112688039444\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "igraph.Vertex(<igraph.Graph object at 0x7f4349d3ec78>, 122, {'name': 'FOS'})"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate the in-degree of all vertices in the graph, and scatter plot `log(degree)` vs. `log(pagerank)`.  (Do you see why we used `in` here?  Note the column swapping we did earlier). Note-- you will have to eliminate one vertex that has zero in-degree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": [
    "import matplotlib.pyplot\n",
    "FILL IN HERE\n",
    "matplotlib.pyplot.ylim(3*1e-4, 1e-2)\n",
    "matplotlib.pyplot.xlim(0.8, 600)\n",
    "matplotlib.pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See if you can calculate the pagerank centrality yourself, using the matrix inversion (Eq. 7.19 from Newman). Test your function on a small directed graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pagerank(g):\n",
    "    # N is the number of vertices\n",
    "    N = len(g.vs)\n",
    "    \n",
    "    # alpha is the damping parameter\n",
    "    alpha = 0.85\n",
    "    \n",
    "    # beta = (1-alpha)/N\n",
    "    beta = (1-alpha)/N\n",
    "    \n",
    "    # compute the out-degree of each vertex\n",
    "    degree_values = g.degree(mode=\"out\")\n",
    "    \n",
    "    # get a floating-point adjacency matrix M in the Newman format (take transpose from igraph format)\n",
    "    M = \n",
    "    \n",
    "    # or each column in 0,N-1:\n",
    "    for j in range(0,N):\n",
    "        \n",
    "        # get the out degree of the vertex as a float\n",
    "        degree_value = \n",
    "        \n",
    "        # if degree is nonzero, normalize the column of M with degree_value\n",
    "        if degree_value > 0:\n",
    "            M[:,j] /= \n",
    "        else:\n",
    "            # set the column to zero\n",
    "            M[:,j] = \n",
    "            \n",
    "    # compute pagerank following Newman Eq. 7.19, where M = AD^(-1)\n",
    "    pr = \n",
    "    \n",
    "    # normalize pagerank centrality by its sum\n",
    "    pr /= \n",
    "    \n",
    "    retlist = pr.transpose().tolist()[0]\n",
    "    return(retlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test out your function on a small 5-vertex Barabasi-Albert graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.27786259541984737, 0.2778625954198473, 0.14809160305343513, 0.14809160305343513, 0.1480916030534351]\n",
      "[0.2778625954198473, 0.2778625954198473, 0.14809160305343513, 0.14809160305343513, 0.1480916030534351]\n"
     ]
    }
   ],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}