Assignment+1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "_You are currently looking at **version 1.1** of this notebook. To download notebooks and datafiles, as well as get help on Jupyter notebooks in the Coursera platform, visit the [Jupyter Notebook FAQ](https://www.coursera.org/learn/python-social-network-analysis/resources/yPcBs) course resource._\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment 1 - Creating and Manipulating Graphs\n",
    "\n",
    "Eight employees at a small company were asked to choose 3 movies that they would most enjoy watching for the upcoming company movie night. These choices are stored in the file `Employee_Movie_Choices.txt`.\n",
    "\n",
    "A second file, `Employee_Relationships.txt`, has data on the relationships between different coworkers. \n",
    "\n",
    "The relationship score has value of `-100` (Enemies) to `+100` (Best Friends). A value of zero means the two employees haven't interacted or are indifferent.\n",
    "\n",
    "Both files are tab delimited."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from networkx.algorithms import bipartite\n",
    "\n",
    "\n",
    "# This is the set of employees\n",
    "employees = set(['Pablo',\n",
    "                 'Lee',\n",
    "                 'Georgia',\n",
    "                 'Vincent',\n",
    "                 'Andy',\n",
    "                 'Frida',\n",
    "                 'Joan',\n",
    "                 'Claude'])\n",
    "\n",
    "# This is the set of movies\n",
    "movies = set(['The Shawshank Redemption',\n",
    "              'Forrest Gump',\n",
    "              'The Matrix',\n",
    "              'Anaconda',\n",
    "              'The Social Network',\n",
    "              'The Godfather',\n",
    "              'Monty Python and the Holy Grail',\n",
    "              'Snakes on a Plane',\n",
    "              'Kung Fu Panda',\n",
    "              'The Dark Knight',\n",
    "              'Mean Girls'])\n",
    "\n",
    "\n",
    "# you can use the following function to plot graphs\n",
    "# make sure to comment it out before submitting to the autograder\n",
    "def plot_graph(G, weight_name=None):\n",
    "    '''\n",
    "    G: a networkx G\n",
    "    weight_name: name of the attribute for plotting edge weights (if G is weighted)\n",
    "    '''\n",
    "    %matplotlib notebook\n",
    "    import matplotlib.pyplot as plt\n",
    "    \n",
    "    plt.figure()\n",
    "    pos = nx.spring_layout(G)\n",
    "    edges = G.edges()\n",
    "    weights = None\n",
    "    \n",
    "    if weight_name:\n",
    "        weights = [int(G[u][v][weight_name]) for u,v in edges]\n",
    "        labels = nx.get_edge_attributes(G,weight_name)\n",
    "        nx.draw_networkx_edge_labels(G,pos,edge_labels=labels)\n",
    "        nx.draw_networkx(G, pos, edges=edges, width=weights);\n",
    "    else:\n",
    "        nx.draw_networkx(G, pos, edges=edges);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 1\n",
    "\n",
    "Using NetworkX, load in the bipartite graph from `Employee_Movie_Choices.txt` and return that graph.\n",
    "\n",
    "*This function should return a networkx graph with 19 nodes and 24 edges*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#cat Employee_Movie_Choices.txt\n",
    "\n",
    "def answer_one():\n",
    "        \n",
    "    return nx.read_edgelist('Employee_Movie_Choices.txt', delimiter=\"\\t\")\n",
    "#plot_graph(answer_one())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2\n",
    "\n",
    "Using the graph from the previous question, add nodes attributes named `'type'` where movies have the value `'movie'` and employees have the value `'employee'` and return that graph.\n",
    "\n",
    "*This function should return a networkx graph with node attributes `{'type': 'movie'}` or `{'type': 'employee'}`*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def answer_two():\n",
    "    \n",
    "    B = answer_one()\n",
    "    for node in B.nodes():\n",
    "        if node in employees:\n",
    "            B.add_node(node, type=\"employee\")\n",
    "        else:\n",
    "            B.add_node(node, type=\"movie\")\n",
    "    \n",
    "    return B\n",
    "#plot_graph(answer_two())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Question 3\n",
    "\n",
    "Find a weighted projection of the graph from `answer_two` which tells us how many movies different pairs of employees have in common.\n",
    "\n",
    "*This function should return a weighted projected graph.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def answer_three():\n",
    "        \n",
    "    B = answer_two()\n",
    "    weighted_proj = bipartite.weighted_projected_graph(B, employees)\n",
    "    return weighted_proj\n",
    "#plot_graph(answer_three())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Question 4\n",
    "\n",
    "Suppose you'd like to find out if people that have a high relationship score also like the same types of movies.\n",
    "\n",
    "Find the Pearson correlation ( using `DataFrame.corr()` ) between employee relationship scores and the number of movies they have in common. If two employees have no movies in common it should be treated as a 0, not a missing value, and should be included in the correlation calculation.\n",
    "\n",
    "*This function should return a float.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def answer_four():\n",
    "    Rel = nx.read_edgelist('Employee_Relationships.txt' ,data=[('relationship_score', int)])\n",
    "    Rel_df = pd.DataFrame(Rel.edges(data=True), columns=['From', 'To', 'relationship_score'])\n",
    "    G = answer_three()\n",
    "    G_df = pd.DataFrame(G.edges(data=True), columns=['From', 'To', 'movies_score'])\n",
    "    G_copy_df = G_df.copy()\n",
    "    G_copy_df.rename(columns={\"From\":\"From1\", \"To\":\"From\"}, inplace=True)\n",
    "    G_copy_df.rename(columns={\"From1\":\"To\"}, inplace=True)\n",
    "    G_final_df = pd.concat([G_df, G_copy_df])\n",
    "    final_df = pd.merge(G_final_df, Rel_df, on = ['From', 'To'], how='right')\n",
    "    final_df['movies_score'] = final_df['movies_score'].map(lambda x: x['weight'] if type(x)==dict else None)\n",
    "    final_df['relationship_score'] = final_df['relationship_score'].map(lambda x: x['relationship_score'])\n",
    "    final_df['movies_score'].fillna(value=0, inplace=True)\n",
    "    return final_df['movies_score'].corr(final_df['relationship_score'])\n",
    "#answer_four()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "python-social-network-analysis",
   "graded_item_id": "YNa9b",
   "launcher_item_id": "hvNc1",
   "part_id": "VbyiB"
  },
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}