class05_components_R.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CSX46 - Class Session 5 - Components\n",
    "\n",
    "In this class session we are going to find the number of proteins that are in the giant component of the (undirected) protein-protein interaction network, using igraph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "suppressPackageStartupMessages(library(igraph))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 1:  load in the SIF file as a data frame `sif_data`, using the `read.table` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sif_data <- read.table(\"shared/pathway_commons.sif\",\n",
    "                       sep=\"\\t\",\n",
    "                       header=FALSE,\n",
    "                       stringsAsFactors=FALSE,\n",
    "                       col.names=c(\"species1\",\n",
    "                                   \"interaction_type\",\n",
    "                                   \"species2\"),\n",
    "                       quote=\"\",\n",
    "                       comment.char=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 2:  restrict the interactions to protein-protein undirected (\"in-complex-with\", \"interacts-with\"), using the `%in%` operator and using array indexing `[`, and include only the two species columns. The restricted data frame should be called `interac_ppi`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "interac_ppi <- sif_data[sif_data$interaction_type %in% c(\"in-complex-with\",\n",
    "                                                         \"interacts-with\"), c(1,3)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 3: restrict the data frame to only the unique interaction pairs of proteins (ignoring the interaction type), using the `unique` function.  Make an igraph `Graph` object from the data frame, using `graph_from_data_frame`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "interac_ppi_unique <- unique(interac_ppi)\n",
    "ppi_igraph <- graph_from_data_frame(interac_ppi_unique, directed=FALSE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map the components of the graph `ppi_igraph` using the `igraph` function `components`.  That will return a list which you should assign to object name `component_res_list`.  Get the `csize` member of the list, which will be a vector of the sizes of the components of the graph.  Call `max` on that vector to get the size of the giant component of the PPI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## call the igraph function `components` on the `ppi_igraph` object; name\n",
    "## resulting object `component_res_list`\n",
    "component_res_list <- components(ppi_igraph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## obtain the list item in the slot named `csize`, and name the\n",
    "## resulting object `component_sizes_vec`\n",
    "component_sizes_vec <- component_res_list$csize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "16985"
      ],
      "text/latex": [
       "16985"
      ],
      "text/markdown": [
       "16985"
      ],
      "text/plain": [
       "[1] 16985"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## use the `max` function to find the size of the giant component\n",
    "max(component_sizes_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's print out all the component sizes, in reverse-sorted order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<ol class=list-inline>\n",
       "\t<li>16985</li>\n",
       "\t<li>10</li>\n",
       "\t<li>4</li>\n",
       "\t<li>4</li>\n",
       "\t<li>3</li>\n",
       "\t<li>3</li>\n",
       "\t<li>3</li>\n",
       "\t<li>2</li>\n",
       "\t<li>2</li>\n",
       "\t<li>2</li>\n",
       "\t<li>2</li>\n",
       "</ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 16985\n",
       "\\item 10\n",
       "\\item 4\n",
       "\\item 4\n",
       "\\item 3\n",
       "\\item 3\n",
       "\\item 3\n",
       "\\item 2\n",
       "\\item 2\n",
       "\\item 2\n",
       "\\item 2\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 16985\n",
       "2. 10\n",
       "3. 4\n",
       "4. 4\n",
       "5. 3\n",
       "6. 3\n",
       "7. 3\n",
       "8. 2\n",
       "9. 2\n",
       "10. 2\n",
       "11. 2\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       " [1] 16985    10     4     4     3     3     3     2     2     2     2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sort(component_sizes_vec, decreasing=TRUE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's get the vertex indices of the vertices that are in the giant component. Use the `membership` slot of the list `component_res_list`, and use `which.max(component_sizes_vec)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "inds_giant_component <- which(component_res_list$membership == which.max(component_sizes_vec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compute the vertex degrees, for all the vertices in the giant component. Use the `degree` function and pass the indices of the giant component vertices as the function argument `v`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "ppi_degrees_gc <- degree(ppi_igraph, v=inds_giant_component)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the highest degree vertex in the giant component, and what is its degree? Use `which.max` on `ppi_degrees_gc`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"Vertex number 6854 has maximum degree: 3600\"\n"
     ]
    }
   ],
   "source": [
    "ind_max <- which.max(ppi_degrees_gc)\n",
    "print(sprintf(\"Vertex number %d has maximum degree: %d\", ind_max, \n",
    "             ppi_degrees_gc[ind_max]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compute the shortest paths distance between highest-degree vertex of the giant component, and all the other vertices in the giant component, by calling the `distances` function on the `ppi_igraph` object. In that function call, you will want to specify as argument `v`the vertex index of the highest-degree vertex in the giant component, and as argument `to` the vertex indices of vertices in the giant component."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "apsp_dists <- distances(ppi_igraph, v=inds_giant_component[ind_max], to=inds_giant_component)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the average distance between the highest-degree vertex of the giant component and all the other vertices of the giant component?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] \"1.86\"\n"
     ]
    }
   ],
   "source": [
    "print(sprintf(\"%0.2f\", mean(apsp_dists)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Advanced code-spellunking question:  go to the GitHub repo for igraph (https://github.com/igraph), and find the code components.c.  For the weakly connected components, is it doing a BFS or DFS?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}