FB_Models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "naWvqMEMHglO"
   },
   "source": [
    "<p style=\"font-size:32px;text-align:center\"> <b>Social network Graph Link Prediction - Facebook Challenge</b> </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9wb9N5RzHglP"
   },
   "outputs": [],
   "source": [
    "#Importing Libraries\n",
    "# please do go through this python notebook: \n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import csv\n",
    "import pandas as pd#pandas to create small dataframes \n",
    "import datetime #Convert to unix time\n",
    "import time #Convert to unix time\n",
    "# if numpy is not installed already : pip3 install numpy\n",
    "import numpy as np#Do aritmetic operations on arrays\n",
    "# matplotlib: used to plot graphs\n",
    "import matplotlib\n",
    "import matplotlib.pylab as plt\n",
    "import seaborn as sns#Plots\n",
    "from matplotlib import rcParams#Size of plots  \n",
    "from sklearn.cluster import MiniBatchKMeans, KMeans#Clustering\n",
    "import math\n",
    "import pickle\n",
    "import os\n",
    "# to install xgboost: pip3 install xgboost\n",
    "import xgboost as xgb\n",
    "\n",
    "import warnings\n",
    "import networkx as nx\n",
    "import pdb\n",
    "import pickle\n",
    "from pandas import HDFStore,DataFrame\n",
    "from pandas import read_hdf\n",
    "from scipy.sparse.linalg import svds, eigs\n",
    "import gc\n",
    "from tqdm import tqdm\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XC4OJFKkHglU"
   },
   "outputs": [],
   "source": [
    "#reading\n",
    "from pandas import read_hdf\n",
    "df_final_train = read_hdf(\"C:\\\\VipinML\\\\InputData\\\\FB\\\\fea_sample\\\\storage_sample_stage4.h5\", 'train_df',mode='r')\n",
    "df_final_test = read_hdf(\"C:\\\\VipinML\\\\InputData\\\\FB\\\\fea_sample\\\\storage_sample_stage4.h5\", 'test_df',mode='r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5Gm-BHRkHglW",
    "outputId": "d2c2294c-113e-4fdb-d3e5-dc167dcf5fbc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['source_node', 'destination_node', 'indicator_link',\n",
       "       'jaccard_followers', 'jaccard_followees', 'cosine_followers',\n",
       "       'cosine_followees', 'num_followers_s', 'num_followees_s',\n",
       "       'num_followees_d', 'inter_followers', 'inter_followees', 'adar_index',\n",
       "       'follows_back', 'same_comp', 'shortest_path', 'weight_in', 'weight_out',\n",
       "       'weight_f1', 'weight_f2', 'weight_f3', 'weight_f4', 'page_rank_s',\n",
       "       'page_rank_d', 'katz_s', 'katz_d', 'hubs_s', 'hubs_d', 'authorities_s',\n",
       "       'authorities_d', 'svd_u_s_1', 'svd_u_s_2', 'svd_u_s_3', 'svd_u_s_4',\n",
       "       'svd_u_s_5', 'svd_u_s_6', 'svd_u_d_1', 'svd_u_d_2', 'svd_u_d_3',\n",
       "       'svd_u_d_4', 'svd_u_d_5', 'svd_u_d_6', 'svd_v_s_1', 'svd_v_s_2',\n",
       "       'svd_v_s_3', 'svd_v_s_4', 'svd_v_s_5', 'svd_v_s_6', 'svd_v_d_1',\n",
       "       'svd_v_d_2', 'svd_v_d_3', 'svd_v_d_4', 'svd_v_d_5', 'svd_v_d_6'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_final_train.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XRW7VZ4AHglc"
   },
   "outputs": [],
   "source": [
    "y_train = df_final_train.indicator_link\n",
    "y_test = df_final_test.indicator_link"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4lj9M_qtHglf"
   },
   "outputs": [],
   "source": [
    "df_final_train.drop(['source_node', 'destination_node','indicator_link'],axis=1,inplace=True)\n",
    "df_final_test.drop(['source_node', 'destination_node','indicator_link'],axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lIEc91uVHgli",
    "outputId": "31f04b72-ebe5-4b13-ccca-a5ae3bc4f09c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimators =  10 Train Score 0.9063252121775113 test Score 0.8745605278006858\n",
      "Estimators =  50 Train Score 0.9205725512208812 test Score 0.9125653355634538\n",
      "Estimators =  100 Train Score 0.9238690848446947 test Score 0.9141199714153599\n",
      "Estimators =  250 Train Score 0.9239789348046863 test Score 0.9188007232664732\n",
      "Estimators =  450 Train Score 0.9237190618658074 test Score 0.9161507685828595\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Estimators vs score at depth of 5')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "estimators = [10,50,100,250,450]\n",
    "train_scores = []\n",
    "test_scores = []\n",
    "for i in estimators:\n",
    "    clf = RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
    "            max_depth=5, max_features='auto', max_leaf_nodes=None,\n",
    "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
    "            min_samples_leaf=52, min_samples_split=120,\n",
    "            min_weight_fraction_leaf=0.0, n_estimators=i, n_jobs=-1,random_state=25,verbose=0,warm_start=False)\n",
    "    clf.fit(df_final_train,y_train)\n",
    "    train_sc = f1_score(y_train,clf.predict(df_final_train))\n",
    "    test_sc = f1_score(y_test,clf.predict(df_final_test))\n",
    "    test_scores.append(test_sc)\n",
    "    train_scores.append(train_sc)\n",
    "    print('Estimators = ',i,'Train Score',train_sc,'test Score',test_sc)\n",
    "plt.plot(estimators,train_scores,label='Train Score')\n",
    "plt.plot(estimators,test_scores,label='Test Score')\n",
    "plt.xlabel('Estimators')\n",
    "plt.ylabel('Score')\n",
    "plt.title('Estimators vs score at depth of 5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nZxhrTdQHglm",
    "outputId": "53382b8e-148d-4c22-8066-d9807fb27012"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "depth =  3 Train Score 0.8916120853581238 test Score 0.8687934859875491\n",
      "depth =  9 Train Score 0.9572226298198419 test Score 0.9222953031452904\n",
      "depth =  11 Train Score 0.9623451340902863 test Score 0.9252318758281279\n",
      "depth =  15 Train Score 0.9634267621927706 test Score 0.9231288356496615\n",
      "depth =  20 Train Score 0.9631629153051491 test Score 0.9235051024711141\n",
      "depth =  35 Train Score 0.9634333127085721 test Score 0.9235601652753184\n",
      "depth =  50 Train Score 0.9634333127085721 test Score 0.9235601652753184\n",
      "depth =  70 Train Score 0.9634333127085721 test Score 0.9235601652753184\n",
      "depth =  130 Train Score 0.9634333127085721 test Score 0.9235601652753184\n"
     ]
    },
    {
     "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": [
    "depths = [3,9,11,15,20,35,50,70,130]\n",
    "train_scores = []\n",
    "test_scores = []\n",
    "for i in depths:\n",
    "    clf = RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
    "            max_depth=i, max_features='auto', max_leaf_nodes=None,\n",
    "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
    "            min_samples_leaf=52, min_samples_split=120,\n",
    "            min_weight_fraction_leaf=0.0, n_estimators=115, n_jobs=-1,random_state=25,verbose=0,warm_start=False)\n",
    "    clf.fit(df_final_train,y_train)\n",
    "    train_sc = f1_score(y_train,clf.predict(df_final_train))\n",
    "    test_sc = f1_score(y_test,clf.predict(df_final_test))\n",
    "    test_scores.append(test_sc)\n",
    "    train_scores.append(train_sc)\n",
    "    print('depth = ',i,'Train Score',train_sc,'test Score',test_sc)\n",
    "plt.plot(depths,train_scores,label='Train Score')\n",
    "plt.plot(depths,test_scores,label='Test Score')\n",
    "plt.xlabel('Depth')\n",
    "plt.ylabel('Score')\n",
    "plt.title('Depth vs score at depth of 5 at estimators = 115')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MrG1Lfl3Hglq",
    "outputId": "7b6e3c97-8d66-455d-cd79-213f824719cc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean test scores [0.96225043 0.96215493 0.96057081 0.96194015 0.96330005]\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'mean_train_score'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-0386232e104c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[0mrf_random\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdf_final_train\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my_train\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'mean test scores'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mrf_random\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'mean_test_score'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'mean train scores'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mrf_random\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'mean_train_score'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'mean_train_score'"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from scipy.stats import randint as sp_randint\n",
    "from scipy.stats import uniform\n",
    "\n",
    "param_dist = {\"n_estimators\":sp_randint(105,125),\n",
    "              \"max_depth\": sp_randint(10,15),\n",
    "              \"min_samples_split\": sp_randint(110,190),\n",
    "              \"min_samples_leaf\": sp_randint(25,65)}\n",
    "\n",
    "clf = RandomForestClassifier(random_state=25,n_jobs=-1)\n",
    "\n",
    "rf_random = RandomizedSearchCV(clf, param_distributions=param_dist,\n",
    "                                   n_iter=5,cv=10,scoring='f1',random_state=25)\n",
    "\n",
    "rf_random.fit(df_final_train,y_train)\n",
    "print('mean test scores',rf_random.cv_results_['mean_test_score'])\n",
    "print('mean train scores',rf_random.cv_results_['mean_train_score'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hme3j_diHglu",
    "outputId": "581ccc02-7770-4a94-d003-257af4e81570"
   },
   "outputs": [],
   "source": [
    "print(rf_random.best_estimator_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qu4KIEweHglx"
   },
   "outputs": [],
   "source": [
    "clf = RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
    "            max_depth=14, max_features='auto', max_leaf_nodes=None,\n",
    "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
    "            min_samples_leaf=28, min_samples_split=111,\n",
    "            min_weight_fraction_leaf=0.0, n_estimators=121, n_jobs=-1,\n",
    "            oob_score=False, random_state=25, verbose=0, warm_start=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Dax83GfLHgl1"
   },
   "outputs": [],
   "source": [
    "clf.fit(df_final_train,y_train)\n",
    "y_train_pred = clf.predict(df_final_train)\n",
    "y_test_pred = clf.predict(df_final_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PTtAp1iTHgl4",
    "outputId": "e2e3d725-3c4d-4374-d303-8f294b570977"
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "print('Train f1 score',f1_score(y_train,y_train_pred))\n",
    "print('Test f1 score',f1_score(y_test,y_test_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5XfUkZYQHgl7"
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "def plot_confusion_matrix(test_y, predict_y):\n",
    "    C = confusion_matrix(test_y, predict_y)\n",
    "    \n",
    "    A =(((C.T)/(C.sum(axis=1))).T)\n",
    "    \n",
    "    B =(C/C.sum(axis=0))\n",
    "    plt.figure(figsize=(20,4))\n",
    "    \n",
    "    labels = [0,1]\n",
    "    # representing A in heatmap format\n",
    "    cmap=sns.light_palette(\"blue\")\n",
    "    plt.subplot(1, 3, 1)\n",
    "    sns.heatmap(C, annot=True, cmap=cmap, fmt=\".3f\", xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.ylabel('Original Class')\n",
    "    plt.title(\"Confusion matrix\")\n",
    "    \n",
    "    plt.subplot(1, 3, 2)\n",
    "    sns.heatmap(B, annot=True, cmap=cmap, fmt=\".3f\", xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.ylabel('Original Class')\n",
    "    plt.title(\"Precision matrix\")\n",
    "    \n",
    "    plt.subplot(1, 3, 3)\n",
    "    # representing B in heatmap format\n",
    "    sns.heatmap(A, annot=True, cmap=cmap, fmt=\".3f\", xticklabels=labels, yticklabels=labels)\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.ylabel('Original Class')\n",
    "    plt.title(\"Recall matrix\")\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s6t11dhTHgl-",
    "outputId": "189de3be-1c99-4653-f56f-12b18b0f4db7"
   },
   "outputs": [],
   "source": [
    "print('Train confusion_matrix')\n",
    "plot_confusion_matrix(y_train,y_train_pred)\n",
    "print('Test confusion_matrix')\n",
    "plot_confusion_matrix(y_test,y_test_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "61TF-VLeHgmD",
    "outputId": "795f1b39-61c7-470f-e2d0-1fe6dc7ac5fd"
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "fpr,tpr,ths = roc_curve(y_test,y_test_pred)\n",
    "auc_sc = auc(fpr, tpr)\n",
    "plt.plot(fpr, tpr, color='navy',label='ROC curve (area = %0.2f)' % auc_sc)\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver operating characteristic with test data')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HEZ7uvN6HgmK",
    "outputId": "6f762256-54fc-4e2f-865b-22342033eb2c",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "features = df_final_train.columns\n",
    "importances = clf.feature_importances_\n",
    "indices = (np.argsort(importances))[-25:]\n",
    "plt.figure(figsize=(10,12))\n",
    "plt.title('Feature Importances')\n",
    "plt.barh(range(len(indices)), importances[indices], color='r', align='center')\n",
    "plt.yticks(range(len(indices)), [features[i] for i in indices])\n",
    "plt.xlabel('Relative Importance')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xdHW32hcHgmN"
   },
   "source": [
    "# Assignments:\n",
    "\n",
    "1. Add another feature called  Preferential Attachment  with followers and followees data of vertex. you can check about Preferential Attachment in below link\n",
    "http://be.amazd.com/link-prediction/ <br>\n",
    "2. Add  feature called svd_dot. you can calculate svd_dot as Dot product between sourse node svd and destination node svd features.  you can read about this in below pdf \n",
    "https://storage.googleapis.com/kaggle-forum-message-attachments/2594/supervised_link_prediction.pdf<br>\n",
    "3. Tune hyperparameters for XG boost with all these features and check the error metric."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "FB_Models.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}