Evaluation_Script.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting package metadata (current_repodata.json): done\n",
      "Solving environment: done\n",
      "\n",
      "\n",
      "==> WARNING: A newer version of conda exists. <==\n",
      "  current version: 4.9.2\n",
      "  latest version: 4.11.0\n",
      "\n",
      "Please update conda by running\n",
      "\n",
      "    $ conda update -n base -c defaults conda\n",
      "\n",
      "\n",
      "\n",
      "## Package Plan ##\n",
      "\n",
      "  environment location: /home/rf27/miniconda3/envs/New_awesome_environment\n",
      "\n",
      "  added / updated specs:\n",
      "    - matplotlib\n",
      "\n",
      "\n",
      "The following packages will be downloaded:\n",
      "\n",
      "    package                    |            build\n",
      "    ---------------------------|-----------------\n",
      "    brotli-1.0.9               |       h7f98852_5          17 KB  conda-forge\n",
      "    brotli-bin-1.0.9           |       h7f98852_5          19 KB  conda-forge\n",
      "    cycler-0.11.0              |     pyhd8ed1ab_0          10 KB  conda-forge\n",
      "    kiwisolver-1.3.1           |   py39h2531618_0          80 KB\n",
      "    libbrotlicommon-1.0.9      |       h7f98852_5          65 KB  conda-forge\n",
      "    libbrotlidec-1.0.9         |       h7f98852_5          33 KB  conda-forge\n",
      "    libbrotlienc-1.0.9         |       h7f98852_5         286 KB  conda-forge\n",
      "    matplotlib-3.4.3           |   py39hf3d152e_2           7 KB  conda-forge\n",
      "    matplotlib-base-3.4.3      |   py39hbbc1b5f_0         5.6 MB\n",
      "    munkres-1.1.4              |     pyh9f0ad1d_0          12 KB  conda-forge\n",
      "    ------------------------------------------------------------\n",
      "                                           Total:         6.1 MB\n",
      "\n",
      "The following NEW packages will be INSTALLED:\n",
      "\n",
      "  brotli             conda-forge/linux-64::brotli-1.0.9-h7f98852_5\n",
      "  brotli-bin         conda-forge/linux-64::brotli-bin-1.0.9-h7f98852_5\n",
      "  cycler             conda-forge/noarch::cycler-0.11.0-pyhd8ed1ab_0\n",
      "  fonttools          pkgs/main/noarch::fonttools-4.25.0-pyhd3eb1b0_0\n",
      "  kiwisolver         pkgs/main/linux-64::kiwisolver-1.3.1-py39h2531618_0\n",
      "  libbrotlicommon    conda-forge/linux-64::libbrotlicommon-1.0.9-h7f98852_5\n",
      "  libbrotlidec       conda-forge/linux-64::libbrotlidec-1.0.9-h7f98852_5\n",
      "  libbrotlienc       conda-forge/linux-64::libbrotlienc-1.0.9-h7f98852_5\n",
      "  matplotlib         conda-forge/linux-64::matplotlib-3.4.3-py39hf3d152e_2\n",
      "  matplotlib-base    pkgs/main/linux-64::matplotlib-base-3.4.3-py39hbbc1b5f_0\n",
      "  munkres            conda-forge/noarch::munkres-1.1.4-pyh9f0ad1d_0\n",
      "\n",
      "The following packages will be UPDATED:\n",
      "\n",
      "  ca-certificates    anaconda::ca-certificates-2020.10.14-0 --> conda-forge::ca-certificates-2021.10.8-ha878542_0\n",
      "\n",
      "The following packages will be SUPERSEDED by a higher-priority channel:\n",
      "\n",
      "  certifi            pkgs/main::certifi-2021.10.8-py39h06a~ --> conda-forge::certifi-2021.10.8-py39hf3d152e_1\n",
      "\n",
      "\n",
      "\n",
      "Downloading and Extracting Packages\n",
      "matplotlib-base-3.4. | 5.6 MB    | ##################################### | 100% \n",
      "kiwisolver-1.3.1     | 80 KB     | ##################################### | 100% \n",
      "brotli-1.0.9         | 17 KB     | ##################################### | 100% \n",
      "cycler-0.11.0        | 10 KB     | ##################################### | 100% \n",
      "brotli-bin-1.0.9     | 19 KB     | ##################################### | 100% \n",
      "libbrotlienc-1.0.9   | 286 KB    | ##################################### | 100% \n",
      "munkres-1.1.4        | 12 KB     | ##################################### | 100% \n",
      "matplotlib-3.4.3     | 7 KB      | ##################################### | 100% \n",
      "libbrotlidec-1.0.9   | 33 KB     | ##################################### | 100% \n",
      "libbrotlicommon-1.0. | 65 KB     | ##################################### | 100% \n",
      "Preparing transaction: done\n",
      "Verifying transaction: done\n",
      "Executing transaction: done\n"
     ]
    }
   ],
   "source": [
    "!conda install -c conda-forge -y matplotlib "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "import torch\n",
    "\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "from torch_geometric import data as DATA\n",
    "from torch_geometric.data import Data, DataLoader\n",
    "\n",
    "from torch import optim, nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from torch_geometric.nn import GCNConv, GATConv\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device = 'cpu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_edges = pd.read_csv(\"./Test Dataset/test_edges.csv\", header=0)\n",
    "test_labels = pd.read_csv(\"./Test Dataset/test_labels.csv\", header=0)\n",
    "ground_truth = np.array(test_labels).flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "@torch.no_grad()\n",
    "def test(data):\n",
    "    model.eval()\n",
    "    z = model.encode(data.x, data.edge_index)\n",
    "    out = model.decode(z, data.edge_label_index).view(-1).sigmoid()\n",
    "    return out.cpu().sigmoid().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rf27/miniconda3/envs/New_awesome_environment/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3172: DtypeWarning: Columns (3) have mixed types.Specify dtype option on import or set low_memory=False.\n",
      "  has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n"
     ]
    }
   ],
   "source": [
    "edge_folds = pd.read_csv(\"./data_split.csv\", header=0)\n",
    "edge_folds = edge_folds[edge_folds['Label'] == 1]\n",
    "edge_folds.loc[edge_folds['Fold'] == 'Test', 'Fold'] = 5\n",
    "edge_folds.loc[edge_folds['Fold'] == '3', 'Fold'] = 3\n",
    "edge_folds.loc[edge_folds['Fold'] == '4', 'Fold'] = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MLP first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(torch.nn.Module):\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.fc1 = nn.Linear(in_channels * 2, hidden_channels)\n",
    "        self.fc2 = nn.Linear(hidden_channels, out_channels)\n",
    "        self.fc3 = nn.Linear(out_channels, 1)\n",
    "\n",
    "    def encode(self, x, edge_index):\n",
    "        return x\n",
    "\n",
    "    def decode(self, z, edge_label_index):\n",
    "        x = torch.cat((z[edge_label_index[0]], z[edge_label_index[1]]), 1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        x = x.squeeze(1)\n",
    "        return x\n",
    "\n",
    "# Text type features\n",
    "features = pd.read_csv(\"./DOC2Vec_features.csv\")\n",
    "features = features.sort_values(by=['id'])\n",
    "\n",
    "# Page type features\n",
    "page_type = pd.read_csv(\"./Training/node_classification.csv\")\n",
    "myEncoder = OneHotEncoder(sparse=False, handle_unknown='ignore')\n",
    "myEncoder.fit(page_type['page_type'].to_numpy().reshape(-1, 1))\n",
    "\n",
    "page_type = pd.concat([page_type.drop('page_type', 1),\n",
    "            pd.DataFrame(myEncoder.transform(page_type['page_type'].to_numpy().reshape(-1, 1)))], \n",
    "                         axis=1).reindex()\n",
    "\n",
    "# Node Id Embedding features\n",
    "embedding = torch.nn.Embedding(page_type.shape[0], 32)\n",
    "embedding = pd.DataFrame(np.array(embedding.weight.data))\n",
    "embedding['id'] = range(page_type.shape[0])\n",
    "\n",
    "# Finalize Feature Embedding\n",
    "features = features.merge(page_type, how='inner', on='id').merge(embedding, how='inner', on='id')\n",
    "features = features.drop(columns=['id'])\n",
    "\n",
    "features = torch.Tensor(features.to_numpy()).to(device)\n",
    "\n",
    "total_fold_predictions = {}\n",
    "total_fold_truths = {}\n",
    "for r in range(1, 6):\n",
    "    \n",
    "    edge_folds_train = edge_folds[edge_folds['Fold'] != r]\n",
    "    G = nx.from_pandas_edgelist(edge_folds_train, 'Node1', 'Node2')\n",
    "\n",
    "    edge_index = []\n",
    "    for e1, e2 in G.edges:\n",
    "        edge_index.append([e1, e2])\n",
    "    \n",
    "    edge_label_index_test = list(test_edges.to_records(index=False))\n",
    "    \n",
    "    test_graph = DATA.Data(\n",
    "        x = features.to(device),\n",
    "        edge_index = torch.LongTensor(edge_index).transpose(1, 0).to(device),\n",
    "        edge_label_index = torch.LongTensor(edge_label_index_test).transpose(1, 0).to(device),\n",
    "        edge_label = torch.LongTensor(test_labels['label'].to_numpy())\n",
    "    )\n",
    "    \n",
    "    model = Net(164, 128, 64).to(device)\n",
    "    model_path = \"./models/MLP_DOC2Vec_fold\" + str(r) + \".pt\"\n",
    "    model.load_state_dict(torch.load(model_path))\n",
    "\n",
    "    total_fold_predictions[r] = test(test_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "MLP_predictions = (total_fold_predictions[1] + \\\n",
    "                   total_fold_predictions[2] + \\\n",
    "                   total_fold_predictions[3] + \\\n",
    "                   total_fold_predictions[4] + \\\n",
    "                   total_fold_predictions[5])/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "fpr_MLP, tpr_MLP, _ = roc_curve(ground_truth, MLP_predictions)\n",
    "roc_auc_MLP = auc(fpr_MLP, tpr_MLP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GCN DOC2Vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(torch.nn.Module):\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels):\n",
    "        super().__init__()\n",
    "        self.conv1 = GCNConv(in_channels, hidden_channels)\n",
    "        self.conv2 = GCNConv(hidden_channels, hidden_channels)\n",
    "        self.conv3 = GCNConv(hidden_channels, out_channels)\n",
    "        \n",
    "        self.fc1 = nn.Linear(out_channels * 2, out_channels)\n",
    "        self.fc2 = nn.Linear(out_channels, 1)\n",
    "\n",
    "    def encode(self, x, edge_index):\n",
    "        x = self.conv1(x, edge_index).relu()\n",
    "        x = self.conv2(x, edge_index).relu()\n",
    "        return self.conv3(x, edge_index)\n",
    "\n",
    "    def decode(self, z, edge_label_index):\n",
    "        x = torch.cat((z[edge_label_index[0]], z[edge_label_index[1]]), 1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        x = x.squeeze(1)\n",
    "        return x\n",
    "\n",
    "# Text type features\n",
    "features = pd.read_csv(\"./DOC2Vec_features.csv\")\n",
    "features = features.sort_values(by=['id'])\n",
    "\n",
    "# PCA ONLY on TF_IDF\n",
    "\n",
    "# Page type features\n",
    "page_type = pd.read_csv(\"./Training/node_classification.csv\")\n",
    "myEncoder = OneHotEncoder(sparse=False, handle_unknown='ignore')\n",
    "myEncoder.fit(page_type['page_type'].to_numpy().reshape(-1, 1))\n",
    "\n",
    "page_type = pd.concat([page_type.drop('page_type', 1),\n",
    "            pd.DataFrame(myEncoder.transform(page_type['page_type'].to_numpy().reshape(-1, 1)))], \n",
    "                         axis=1).reindex()\n",
    "\n",
    "# Node Id Embedding features\n",
    "embedding = torch.nn.Embedding(page_type.shape[0], 32)\n",
    "embedding = pd.DataFrame(np.array(embedding.weight.data))\n",
    "embedding['id'] = range(page_type.shape[0])\n",
    "\n",
    "# Finalize Feature Embedding\n",
    "features = features.merge(page_type, how='inner', on='id').merge(embedding, how='inner', on='id')\n",
    "features = features.drop(columns=['id'])\n",
    "\n",
    "features = torch.Tensor(features.to_numpy()).to(device)\n",
    "\n",
    "total_fold_predictions = {}\n",
    "total_fold_truths = {}\n",
    "for r in range(1, 6):\n",
    "    \n",
    "    edge_folds_train = edge_folds[edge_folds['Fold'] != r]\n",
    "    G = nx.from_pandas_edgelist(edge_folds_train, 'Node1', 'Node2')\n",
    "\n",
    "    edge_index = []\n",
    "    for e1, e2 in G.edges:\n",
    "        edge_index.append([e1, e2])\n",
    "    \n",
    "    edge_label_index_test = list(test_edges.to_records(index=False))\n",
    "    \n",
    "    test_graph = DATA.Data(\n",
    "        x = features.to(device),\n",
    "        edge_index = torch.LongTensor(edge_index).transpose(1, 0).to(device),\n",
    "        edge_label_index = torch.LongTensor(edge_label_index_test).transpose(1, 0).to(device),\n",
    "        edge_label = torch.LongTensor(test_labels['label'].to_numpy())\n",
    "    )\n",
    "    \n",
    "    model = Net(164, 128, 64).to(device)\n",
    "    model_path = \"./models/GCN_doc2vec_fold\" + str(r) + \".pt\"\n",
    "    model.load_state_dict(torch.load(model_path))\n",
    "\n",
    "    total_fold_predictions[r] = test(test_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "GCNDOC2vec_predictions = (total_fold_predictions[1] + \\\n",
    "                           total_fold_predictions[2] + \\\n",
    "                           total_fold_predictions[3] + \\\n",
    "                           total_fold_predictions[4] + \\\n",
    "                           total_fold_predictions[5])/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "fpr_GCNDOC2Vec, tpr_GCNDOC2Vec, _ = roc_curve(ground_truth, GCNDOC2vec_predictions)\n",
    "roc_auc_GCNDOC2Vec = auc(fpr_GCNDOC2Vec, tpr_GCNDOC2Vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8533908995996494"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roc_auc_GCNDOC2Vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GCNGlove"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(torch.nn.Module):\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels):\n",
    "        super().__init__()\n",
    "        self.conv1 = GCNConv(in_channels, hidden_channels)\n",
    "        self.conv2 = GCNConv(hidden_channels, hidden_channels)\n",
    "        self.conv3 = GCNConv(hidden_channels, out_channels)\n",
    "        \n",
    "        self.fc1 = nn.Linear(out_channels * 2, out_channels)\n",
    "        self.fc2 = nn.Linear(out_channels, 1)\n",
    "\n",
    "    def encode(self, x, edge_index):\n",
    "        x = self.conv1(x, edge_index).relu()\n",
    "        x = self.conv2(x, edge_index).relu()\n",
    "        return self.conv3(x, edge_index)\n",
    "\n",
    "    def decode(self, z, edge_label_index):\n",
    "        x = torch.cat((z[edge_label_index[0]], z[edge_label_index[1]]), 1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        x = x.squeeze(1)\n",
    "        return x\n",
    "\n",
    "# Text type features\n",
    "features = pd.read_csv(\"./GLoVE_features.csv\")\n",
    "features = features.sort_values(by=['id'])\n",
    "\n",
    "# PCA ONLY on TF_IDF\n",
    "\n",
    "# Page type features\n",
    "page_type = pd.read_csv(\"./Training/node_classification.csv\")\n",
    "myEncoder = OneHotEncoder(sparse=False, handle_unknown='ignore')\n",
    "myEncoder.fit(page_type['page_type'].to_numpy().reshape(-1, 1))\n",
    "\n",
    "page_type = pd.concat([page_type.drop('page_type', 1),\n",
    "            pd.DataFrame(myEncoder.transform(page_type['page_type'].to_numpy().reshape(-1, 1)))], \n",
    "                         axis=1).reindex()\n",
    "\n",
    "# Node Id Embedding features\n",
    "embedding = torch.nn.Embedding(page_type.shape[0], 32)\n",
    "embedding = pd.DataFrame(np.array(embedding.weight.data))\n",
    "embedding['id'] = range(page_type.shape[0])\n",
    "\n",
    "# Finalize Feature Embedding\n",
    "features = features.merge(page_type, how='inner', on='id').merge(embedding, how='inner', on='id')\n",
    "features = features.drop(columns=['id'])\n",
    "\n",
    "features = torch.Tensor(features.to_numpy()).to(device)\n",
    "\n",
    "total_fold_predictions = {}\n",
    "total_fold_truths = {}\n",
    "for r in range(1, 6):\n",
    "    \n",
    "    edge_folds_train = edge_folds[edge_folds['Fold'] != r]\n",
    "    G = nx.from_pandas_edgelist(edge_folds_train, 'Node1', 'Node2')\n",
    "\n",
    "    edge_index = []\n",
    "    for e1, e2 in G.edges:\n",
    "        edge_index.append([e1, e2])\n",
    "    \n",
    "    edge_label_index_test = list(test_edges.to_records(index=False))\n",
    "    \n",
    "    test_graph = DATA.Data(\n",
    "        x = features.to(device),\n",
    "        edge_index = torch.LongTensor(edge_index).transpose(1, 0).to(device),\n",
    "        edge_label_index = torch.LongTensor(edge_label_index_test).transpose(1, 0).to(device),\n",
    "        edge_label = torch.LongTensor(test_labels['label'].to_numpy())\n",
    "    )\n",
    "    \n",
    "    model = Net(164, 128, 64).to(device)\n",
    "    model_path = \"./models/GCN_Glove_fold\" + str(r) + \".pt\"\n",
    "    model.load_state_dict(torch.load(model_path))\n",
    "\n",
    "    total_fold_predictions[r] = test(test_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "GCNGlove_predictions = (total_fold_predictions[1] + \\\n",
    "                        total_fold_predictions[2] + \\\n",
    "                        total_fold_predictions[3] + \\\n",
    "                        total_fold_predictions[4] + \\\n",
    "                        total_fold_predictions[5])/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "fpr_GCNGlove, tpr_GCNGlove, _ = roc_curve(ground_truth, GCNGlove_predictions)\n",
    "roc_auc_GCNGlove = auc(fpr_GCNGlove, tpr_GCNGlove)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8881564585409318"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roc_auc_GCNGlove"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GCN using nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(torch.nn.Module):\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels):\n",
    "        super().__init__()\n",
    "        self.conv1 = GCNConv(in_channels, hidden_channels)\n",
    "        self.conv2 = GCNConv(hidden_channels, hidden_channels)\n",
    "        self.conv3 = GCNConv(hidden_channels, out_channels)\n",
    "        \n",
    "        self.fc1 = nn.Linear(out_channels * 2, out_channels)\n",
    "        self.fc2 = nn.Linear(out_channels, 1)\n",
    "\n",
    "    def encode(self, x, edge_index):\n",
    "        x = self.conv1(x, edge_index).relu()\n",
    "        x = self.conv2(x, edge_index).relu()\n",
    "        return self.conv3(x, edge_index)\n",
    "\n",
    "    def decode(self, z, edge_label_index):\n",
    "        x = torch.cat((z[edge_label_index[0]], z[edge_label_index[1]]), 1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        x = x.squeeze(1)\n",
    "        return x\n",
    "\n",
    "# Text type features\n",
    "#features = pd.read_csv(\"./GLoVE_features.csv\")\n",
    "features = pd.DataFrame(data={'id': range(edge_folds.shape[0])})\n",
    "features = features.sort_values(by=['id'])\n",
    "\n",
    "# PCA ONLY on TF_IDF\n",
    "\n",
    "# Page type features\n",
    "page_type = pd.read_csv(\"./Training/node_classification.csv\")\n",
    "myEncoder = OneHotEncoder(sparse=False, handle_unknown='ignore')\n",
    "myEncoder.fit(page_type['page_type'].to_numpy().reshape(-1, 1))\n",
    "\n",
    "page_type = pd.concat([page_type.drop('page_type', 1),\n",
    "            pd.DataFrame(myEncoder.transform(page_type['page_type'].to_numpy().reshape(-1, 1)))], \n",
    "                         axis=1).reindex()\n",
    "\n",
    "# Node Id Embedding features\n",
    "embedding = torch.nn.Embedding(page_type.shape[0], 32)\n",
    "embedding = pd.DataFrame(np.array(embedding.weight.data))\n",
    "embedding['id'] = range(page_type.shape[0])\n",
    "\n",
    "# Finalize Feature Embedding\n",
    "features = features.merge(page_type, how='inner', on='id').merge(embedding, how='inner', on='id')\n",
    "features = features.drop(columns=['id'])\n",
    "\n",
    "features = torch.Tensor(features.to_numpy()).to(device)\n",
    "\n",
    "total_fold_predictions = {}\n",
    "total_fold_truths = {}\n",
    "for r in range(1, 6):\n",
    "    \n",
    "    edge_folds_train = edge_folds[edge_folds['Fold'] != r]\n",
    "    G = nx.from_pandas_edgelist(edge_folds_train, 'Node1', 'Node2')\n",
    "\n",
    "    edge_index = []\n",
    "    for e1, e2 in G.edges:\n",
    "        edge_index.append([e1, e2])\n",
    "    \n",
    "    edge_label_index_test = list(test_edges.to_records(index=False))\n",
    "    \n",
    "    test_graph = DATA.Data(\n",
    "        x = features.to(device),\n",
    "        edge_index = torch.LongTensor(edge_index).transpose(1, 0).to(device),\n",
    "        edge_label_index = torch.LongTensor(edge_label_index_test).transpose(1, 0).to(device),\n",
    "        edge_label = torch.LongTensor(test_labels['label'].to_numpy())\n",
    "    )\n",
    "    \n",
    "    model = Net(36, 128, 64).to(device)\n",
    "    model_path = \"./models/GCN_PageType_fold\" + str(r) + \".pt\"\n",
    "    model.load_state_dict(torch.load(model_path))\n",
    "\n",
    "    total_fold_predictions[r] = test(test_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "GCNTypes_predictions = (total_fold_predictions[1] + \\\n",
    "                        total_fold_predictions[2] + \\\n",
    "                        total_fold_predictions[3] + \\\n",
    "                        total_fold_predictions[4] + \\\n",
    "                        total_fold_predictions[5])/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "fpr_GCNTypes, tpr_GCNTypes, _ = roc_curve(ground_truth, GCNTypes_predictions)\n",
    "roc_auc_GCNTypes = auc(fpr_GCNTypes, tpr_GCNTypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8145183764366202"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roc_auc_GCNTypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot of a ROC curve for a specific class\n",
    "plt.figure(figsize=(12,8), dpi= 100)\n",
    "plt.plot(fpr_GCNDOC2Vec, tpr_GCNDOC2Vec, label='GCN-DOC2Vec curve (area = %0.2f)' % roc_auc_GCNDOC2Vec)\n",
    "plt.plot(fpr_GCNGlove, tpr_GCNGlove, label='GCN-Glove curve (area = %0.2f)' % roc_auc_GCNGlove)\n",
    "plt.plot(fpr_GCNTypes, tpr_GCNTypes, label='GCN-Only-PageType curve (area = %0.2f)' % roc_auc_GCNTypes)\n",
    "plt.plot([0, 1], [0, 1], 'k--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver operating characteristic Curve')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Last GAT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(torch.nn.Module):\n",
    "    def __init__(self, in_channels, hidden_channels, out_channels):\n",
    "        super().__init__()\n",
    "\n",
    "        self.conv1 = GATConv(in_channels, 2 * hidden_channels, heads=2, dropout=0.6)\n",
    "\n",
    "        self.conv2 = GATConv(4 * hidden_channels, hidden_channels, heads=1, concat=False,\n",
    "                             dropout=0.6)\n",
    "        \n",
    "        self.conv3 = GATConv(hidden_channels, out_channels, heads=1, concat=False,\n",
    "                             dropout=0.6)\n",
    "        \n",
    "        self.fc1 = nn.Linear(out_channels * 2, out_channels)\n",
    "        self.fc2 = nn.Linear(out_channels, 1)\n",
    "\n",
    "    def encode(self, x, edge_index):\n",
    "        x = F.elu(self.conv1(x, edge_index))\n",
    "        x = F.dropout(x, p=0.6, training=self.training)\n",
    "        x = F.elu(self.conv2(x, edge_index))\n",
    "        x = F.dropout(x, p=0.6, training=self.training)\n",
    "        x = F.elu(self.conv3(x, edge_index))\n",
    "        x = F.dropout(x, p=0.6, training=self.training)\n",
    "        return x\n",
    "    \n",
    "    def decode(self, z, edge_label_index):\n",
    "        x = torch.cat((z[edge_label_index[0]], z[edge_label_index[1]]), 1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        x = x.squeeze(1)\n",
    "        return x\n",
    "    \n",
    "# Text type features\n",
    "features = pd.read_csv(\"./GLoVE_features.csv\")\n",
    "#features = pd.DataFrame(data={'id': range(edge_folds.shape[0])})\n",
    "features = features.sort_values(by=['id'])\n",
    "\n",
    "# PCA ONLY on TF_IDF\n",
    "\n",
    "# Page type features\n",
    "page_type = pd.read_csv(\"./Training/node_classification.csv\")\n",
    "myEncoder = OneHotEncoder(sparse=False, handle_unknown='ignore')\n",
    "myEncoder.fit(page_type['page_type'].to_numpy().reshape(-1, 1))\n",
    "\n",
    "page_type = pd.concat([page_type.drop('page_type', 1),\n",
    "            pd.DataFrame(myEncoder.transform(page_type['page_type'].to_numpy().reshape(-1, 1)))], \n",
    "                         axis=1).reindex()\n",
    "\n",
    "# Node Id Embedding features\n",
    "embedding = torch.nn.Embedding(page_type.shape[0], 32)\n",
    "embedding = pd.DataFrame(np.array(embedding.weight.data))\n",
    "embedding['id'] = range(page_type.shape[0])\n",
    "\n",
    "# Finalize Feature Embedding\n",
    "features = features.merge(page_type, how='inner', on='id').merge(embedding, how='inner', on='id')\n",
    "features = features.drop(columns=['id'])\n",
    "\n",
    "features = torch.Tensor(features.to_numpy()).to(device)\n",
    "\n",
    "total_fold_predictions = {}\n",
    "total_fold_truths = {}\n",
    "for r in range(1, 6):\n",
    "    \n",
    "    edge_folds_train = edge_folds[edge_folds['Fold'] != r]\n",
    "    G = nx.from_pandas_edgelist(edge_folds_train, 'Node1', 'Node2')\n",
    "\n",
    "    edge_index = []\n",
    "    for e1, e2 in G.edges:\n",
    "        edge_index.append([e1, e2])\n",
    "    \n",
    "    edge_label_index_test = list(test_edges.to_records(index=False))\n",
    "    \n",
    "    test_graph = DATA.Data(\n",
    "        x = features.to(device),\n",
    "        edge_index = torch.LongTensor(edge_index).transpose(1, 0).to(device),\n",
    "        edge_label_index = torch.LongTensor(edge_label_index_test).transpose(1, 0).to(device),\n",
    "        edge_label = torch.LongTensor(test_labels['label'].to_numpy())\n",
    "    )\n",
    "    \n",
    "    model = Net(164, 128, 64).to(device)\n",
    "    model_path = \"./models/GAT_DOC2Vec_fold\" + str(r) + \".pt\"\n",
    "    model.load_state_dict(torch.load(model_path))\n",
    "\n",
    "    total_fold_predictions[r] = test(test_graph)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "GATDoc2Vec_predictions = (total_fold_predictions[1] + \\\n",
    "                          total_fold_predictions[2] + \\\n",
    "                          total_fold_predictions[3] + \\\n",
    "                          total_fold_predictions[4] + \\\n",
    "                          total_fold_predictions[5])/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "fpr_GAT, tpr_GAT, _ = roc_curve(ground_truth, GATDoc2Vec_predictions)\n",
    "roc_auc_GAT = auc(fpr_GAT, tpr_GAT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot of a ROC curve for a specific class\n",
    "plt.figure(figsize=(12,8), dpi= 100)\n",
    "plt.plot(fpr_MLP, tpr_MLP, label='MLP curve (area = %0.2f)' % roc_auc_MLP)\n",
    "plt.plot(fpr_GCNGlove, tpr_GCNGlove, label='GCN curve (area = %0.2f)' % roc_auc_GCNGlove)\n",
    "plt.plot(fpr_GAT, tpr_GAT, label='GAT curve (area = %0.2f)' % roc_auc_GAT)\n",
    "plt.plot([0, 1], [0, 1], 'k--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver operating characteristic Curve')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}