ContinousEnronEmployees.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# node2vec\n",
    "---\n",
    "[node2vec](http://snap.stanford.edu/node2vec/) for link prediction:\n",
    "1. Perform train-test split\n",
    "1. Train skip-gram model on random walks within training graph\n",
    "2. Get node embeddings from skip-gram model\n",
    "3. Create bootstrapped edge embeddings by taking the Hadamard product of node embeddings\n",
    "4. Train a logistic regression classifier on these edge embeddings (possible edge --> edge score between 0-1)\n",
    "5. Evaluate these edge embeddings on the validation and test edge sets\n",
    "\n",
    "node2vec source code: https://github.com/aditya-grover/node2vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataset: Dynamic Enron employees\n",
    "Number of nodes: 151\n",
    "Number of edges: 1588\n",
    "Number of time frames: 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Read in Graph Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import scipy as scp\n",
    "import scipy.sparse as sp\n",
    "import numpy as np\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import average_precision_score\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "import pickle\n",
    "import random\n",
    "import csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 1: Load in the networks, make the training and test edge lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "151\n",
      "1588\n"
     ]
    }
   ],
   "source": [
    "MasterGraph = nx.read_edgelist(\"Enron-employees/m_enron_employees.csv\", nodetype=int, delimiter=\",\")\n",
    "for edge in MasterGraph.edges():\n",
    "    MasterGraph[edge[0]][edge[1]]['weight'] = 1\n",
    "\n",
    "print MasterGraph.number_of_nodes()\n",
    "print MasterGraph.number_of_edges()\n",
    "\n",
    "with open('Enron-employees/m_enron_employees_17_weighted.csv', 'rb') as f:\n",
    "    weighted_edges_17 = [[int(x) for x in rec] for rec in csv.reader(f, delimiter=',')]\n",
    "    weighted_edges_17 = map(tuple, weighted_edges_17)\n",
    "\n",
    "G17 = nx.MultiGraph()\n",
    "G17.add_weighted_edges_from(weighted_edges_17)\n",
    "\n",
    "\n",
    "G8 = nx.read_edgelist(\"Enron-employees/m_enron_employees_8.csv\", nodetype = int, delimiter = \",\")\n",
    "for edge in G8.edges():\n",
    "    G8[edge[0]][edge[1]]['weight'] = 1\n",
    "    \n",
    "#G8 = nx.MultiGraph(G8)\n",
    "#G17 = nx.read_edgelist(\"Enron-employees/m_enron_employees_17.csv\", nodetype = int, delimiter = \",\")\n",
    "#for edge in G17.edges():\n",
    "#    G17[edge[0]][edge[1]]['weight'] = 1\n",
    "#\n",
    "    \n",
    "    \n",
    "## All the nodes are in MasterNodes    \n",
    "MasterNodes = MasterGraph.nodes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Training - Test split  \n",
    "'''''\n",
    "first add all the nodes that are in MasterGraph but not in \n",
    "G8\n",
    "'''''\n",
    "for i in MasterNodes:\n",
    "    if i not in G8.nodes():\n",
    "        G8.add_node(i)\n",
    "        \n",
    "adj_sparse = nx.to_scipy_sparse_matrix(G8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gae.preprocessing import mask_test_edges\n",
    "np.random.seed(0) # make sure train-test split is consistent between notebooks\n",
    "\n",
    "adj_sparse = nx.to_scipy_sparse_matrix(G8)\n",
    "\n",
    "adj_train_del_del, train_edges, train_edges_false, val_edges, val_edges_false, \\\n",
    "    test_edges, test_edges_false = mask_test_edges(adj_sparse, test_frac=.3, val_frac=.0, prevent_disconnect = True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total nodes last snapshot: 151\n",
      "Total edges last snapshot: 758\n",
      "Training edges (positive): 516\n",
      "Training edges (negative): 516\n",
      "Validation edges (positive): 0\n",
      "Validation edges (negative): 0\n",
      "Test edges (positive): 220\n",
      "Test edges (negative): 220\n"
     ]
    }
   ],
   "source": [
    "# Inspect train/test split\n",
    "print \"Total nodes last snapshot:\", adj_sparse.shape[0]\n",
    "print \"Total edges last snapshot:\", int(adj_sparse.nnz/2) # adj is symmetric, so nnz (num non-zero) = 2*num_edges\n",
    "print \"Training edges (positive):\", len(train_edges)\n",
    "print \"Training edges (negative):\", len(train_edges_false)\n",
    "print \"Validation edges (positive):\", len(val_edges)\n",
    "print \"Validation edges (negative):\", len(val_edges_false)\n",
    "print \"Test edges (positive):\", len(test_edges)\n",
    "print \"Test edges (negative):\", len(test_edges_false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The positive training edges are in the edgelist \"train_edges\".\n",
    "\n",
    "The negative training edges are in the edgelist \"train_edges_false\".\n",
    "\n",
    "The positive test edges are in the edgelist \"test_edges\".\n",
    "\n",
    "The negative test edges are in the edgelist \"test_edges_false\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Step 2: add all the nodes in G1, G2, G3,..,G7 that are not present"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "add all the nodes that are in the MasterGraph but not in \n",
    "G1, G2 and G3,..,G7 \n",
    "G17 => Graph with all edges G1 to G7\n",
    "'''\n",
    "for i in MasterNodes:\n",
    "    if i not in G17.nodes():\n",
    "        G17.add_node(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Edges before removal: \n",
      "G17:   34314\n",
      "Edges after removal: \n",
      "G17:   33435\n"
     ]
    }
   ],
   "source": [
    "print \"Edges before removal: \"\n",
    "print \"G17:  \", G17.number_of_edges()\n",
    "\n",
    "\n",
    "'''\n",
    "for every snapshot, delete all the edges that occur in the \n",
    "test set, this is important because the training of node2vec\n",
    "can only be done on the training network and not on edges that\n",
    "are used for testing\n",
    "'''\n",
    "for i in range(0,len(test_edges)):\n",
    "        if G17.has_edge(test_edges[i, 0], test_edges[i, 1]):\n",
    "            G17.remove_edges_from([(test_edges[i, 0], test_edges[i, 1])]*len(G17[test_edges[i, 0]][test_edges[i, 1]]))\n",
    "            \n",
    "print \"Edges after removal: \"\n",
    "print \"G17:  \", G17.number_of_edges()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Train node2vec (Learn Node Embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Tim_Dell_XPS\\AppData\\Local\\Continuum\\anaconda2\\lib\\site-packages\\gensim\\utils.py:1197: UserWarning: detected Windows; aliasing chunkize to chunkize_serial\n",
      "  warnings.warn(\"detected Windows; aliasing chunkize to chunkize_serial\")\n"
     ]
    }
   ],
   "source": [
    "import node2vecWeight_bidirectional as node2vec\n",
    "from gensim.models import Word2Vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# node2vec settings\n",
    "# NOTE: When p = q = 1, this is equivalent to DeepWalk\n",
    "\n",
    "P = 1 # Return hyperparameter\n",
    "Q = 1 # In-out hyperparameter\n",
    "WINDOW_SIZE = 10 # Context size for optimization\n",
    "NUM_WALKS = 10 # Number of walks per source\n",
    "WALK_LENGTH = 80 # Length of walk per source\n",
    "DIMENSIONS = 128 # Embedding dimension\n",
    "DIRECTED = False # Graph directed/undirected\n",
    "WORKERS = 8 # Num. parallel workers\n",
    "ITER = 1 # SGD epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Walk iteration:\n",
      "1 / 10\n",
      "2 / 10\n",
      "3 / 10\n",
      "4 / 10\n",
      "5 / 10\n",
      "6 / 10\n",
      "7 / 10\n",
      "8 / 10\n",
      "9 / 10\n",
      "10 / 10\n"
     ]
    }
   ],
   "source": [
    "# Preprocessing, generate walks\n",
    "G17_n2v = node2vec.Graph(G17, DIRECTED, P, Q)\n",
    "G17_n2v.preprocess_transition_probs()\n",
    "\n",
    "walksG17 = G17_n2v.simulate_walks(NUM_WALKS, WALK_LENGTH)\n",
    "\n",
    "walksG17 = [map(str, walk) for walk in walksG17]\n",
    "\n",
    "# Train skip-gram model\n",
    "modelG17 = Word2Vec(walksG17, size=DIMENSIONS, window=WINDOW_SIZE, min_count=0, sg=1, workers=WORKERS, iter=ITER)\n",
    "\n",
    "\n",
    "# Store embeddings mapping\n",
    "emb_mappingsG17 = modelG17.wv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Create Edge Embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create node embeddings matrix (rows = nodes, columns = embedding features)\n",
    "emb_listG17 = []\n",
    "\n",
    "for node_index in range(1, adj_sparse.shape[0]+1):\n",
    "    node_str = str(node_index)\n",
    "    \n",
    "    node_embG17 = emb_mappingsG17[node_str]\n",
    "    emb_listG17.append(node_embG17)\n",
    "    \n",
    "emb_matrixG17 = np.vstack(emb_listG17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_edge_embeddings_static(edge_list):\n",
    "    embs_s = []\n",
    "    for edge in edge_list:\n",
    "        \n",
    "        node1 = edge[0]\n",
    "        node2 = edge[1]\n",
    "        \n",
    "        embG17_1 = emb_matrixG17[node1]\n",
    "        embG17_2 = emb_matrixG17[node2]\n",
    "        \n",
    "        edge_embG17 = np.multiply(embG17_1, embG17_2)\n",
    "        embs_s.append(edge_embG17)\n",
    "        \n",
    "    embs_s = np.array(embs_s)\n",
    "    \n",
    "    return embs_s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "## STATIC\n",
    "# Train-set edge embeddings\n",
    "pos_train_edge_embs_s = get_edge_embeddings_static(train_edges)\n",
    "neg_train_edge_embs_s = get_edge_embeddings_static(train_edges_false)\n",
    "train_edge_embs_s = np.concatenate([pos_train_edge_embs_s, neg_train_edge_embs_s])\n",
    "\n",
    "# Create train-set edge labels: 1 = real edge, 0 = false edge\n",
    "train_edge_labels = np.concatenate([np.ones(len(train_edges)), np.zeros(len(train_edges_false))])\n",
    "\n",
    "# Val-set edge embeddings, labels\n",
    "pos_val_edge_embs_s = get_edge_embeddings_static(val_edges)\n",
    "neg_val_edge_embs_s = get_edge_embeddings_static(val_edges_false)\n",
    "val_edge_embs_s = np.concatenate([pos_val_edge_embs_s, neg_val_edge_embs_s])\n",
    "val_edge_labels = np.concatenate([np.ones(len(val_edges)), np.zeros(len(val_edges_false))])\n",
    "\n",
    "# Test-set edge embeddings, labels\n",
    "pos_test_edge_embs_s = get_edge_embeddings_static(test_edges)\n",
    "neg_test_edge_embs_s = get_edge_embeddings_static(test_edges_false)\n",
    "test_edge_embs_s = np.concatenate([pos_test_edge_embs_s, neg_test_edge_embs_s])\n",
    "\n",
    "# Create val-set edge labels: 1 = real edge, 0 = false edge\n",
    "test_edge_labels = np.concatenate([np.ones(len(test_edges)), np.zeros(len(test_edges_false))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Evaluate Edge Embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, the basic topological classifiers are calculated for the test and training set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "            max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, n_estimators=50, n_jobs=1,\n",
       "            oob_score=False, random_state=None, verbose=0,\n",
       "            warm_start=False)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train logistic regression classifier on train-set edge embeddings\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.datasets import make_classification\n",
    "\n",
    "\n",
    "edge_classifier_lr_stat = LogisticRegression(random_state=0)\n",
    "edge_classifier_lr_stat.fit(train_edge_embs_s, train_edge_labels)\n",
    "\n",
    "\n",
    "edge_classifier_RF_stat = RandomForestClassifier(n_estimators = 50)\n",
    "edge_classifier_RF_stat.fit(train_edge_embs_s, train_edge_labels)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "##  Gradient Boosted Regression Trees\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "edge_classifier_gb_stat = GradientBoostingClassifier(n_estimators=50, learning_rate=0.5, max_depth=8, random_state=0).fit(train_edge_embs_s, train_edge_labels)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predicted edge scores: probability of being of class \"1\" (real edge)\n",
    "# val_preds = edge_classifier.predict_proba(val_edge_embs)[:, 1]\n",
    "# val_roc = roc_auc_score(val_edge_labels, val_preds)\n",
    "# val_ap = average_precision_score(val_edge_labels, val_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predicted edge scores: probability of being of class \"1\" (real edge)\n",
    "test_preds_lr_s = edge_classifier_lr_stat.predict_proba(test_edge_embs_s)[:, 1]\n",
    "test_roc_lr_s = roc_auc_score(test_edge_labels, test_preds_lr_s)\n",
    "test_ap_lr_s = average_precision_score(test_edge_labels, test_preds_lr_s)\n",
    "\n",
    "\n",
    "test_preds_rf_s = edge_classifier_RF_stat.predict_proba(test_edge_embs_s)[:, 1]\n",
    "test_roc_rf_s = roc_auc_score(test_edge_labels, test_preds_rf_s)\n",
    "test_ap_rf_s = average_precision_score(test_edge_labels, test_preds_rf_s)\n",
    "\n",
    "\n",
    "test_preds_gb_s = edge_classifier_gb_stat.predict_proba(test_edge_embs_s)[:, 1]\n",
    "test_roc_gb_s = roc_auc_score(test_edge_labels, test_preds_gb_s)\n",
    "test_ap_gb_s = average_precision_score(test_edge_labels, test_preds_gb_s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node2vec Test ROC score logistic regression continous:  0.8252272727272728\n",
      "node2vec Test ROC score random forest continous:  0.8883987603305785\n",
      "node2vec Test ROC score gradient boosting continous:  0.8755785123966944\n",
      "node2vec Test AP score logistic regression continous:  0.8091970001487699\n",
      "node2vec Test AP score random forest continous:  0.9011517417368266\n",
      "node2vec Test AP score gradient boosting continous:  0.8863897280476489\n"
     ]
    }
   ],
   "source": [
    "# print 'node2vec Validation ROC score: ', str(val_roc)\n",
    "# print 'node2vec Validation AP score: ', str(val_ap)\n",
    "print 'node2vec Test ROC score logistic regression continous: ', str(test_roc_lr_s)\n",
    "print 'node2vec Test ROC score random forest continous: ', str(test_roc_rf_s)\n",
    "print 'node2vec Test ROC score gradient boosting continous: ', str(test_roc_gb_s)\n",
    "print 'node2vec Test AP score logistic regression continous: ', str(test_ap_lr_s)\n",
    "print 'node2vec Test AP score random forest continous: ', str(test_ap_rf_s)\n",
    "print 'node2vec Test AP score gradient boosting continous: ', str(test_ap_gb_s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2ad4630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## ROC curve\n",
    "fpr_lr_s, tpr_lr_s, _ = roc_curve(test_edge_labels, test_preds_lr_s)\n",
    "fpr_rf_s, tpr_rf_s, _ = roc_curve(test_edge_labels, test_preds_rf_s)\n",
    "fpr_gb_s, tpr_gb_s, _ = roc_curve(test_edge_labels, test_preds_gb_s)\n",
    "\n",
    "\n",
    "fig_roc = plt.figure()\n",
    "\n",
    "plt.plot([0,1], [0, 1], 'k--')\n",
    "plt.step(fpr_lr_s, tpr_lr_s, color = \"b\", alpha = 1, where = 'post', label = \"Logistic Regression/Static\")\n",
    "plt.step(fpr_rf_s, tpr_rf_s, color = \"salmon\", alpha = 1, where = 'post', label = \"Random Forest/Static\")\n",
    "plt.step(fpr_gb_s, tpr_gb_s, color = \"red\", alpha = 1, where = 'post', label = \"Gradient Boosting/Static\")\n",
    "\n",
    "\n",
    "\n",
    "plt.xlabel('False positive rate')\n",
    "plt.ylabel('True positive rate')\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.title('ROC curve Enron employees continous')\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "fig_roc.savefig(\"ROC_Enron_Continous.png\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}