pairwise_node_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import numpy as np\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "from codes.dataset import *\n",
    "from codes.model import *\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading graph dataset: PROTEINS_full\n",
      "Graph Nums 1113\n",
      "Loaded 739 graphs having node sizes in permissible limits\n"
     ]
    }
   ],
   "source": [
    "data_list = load_protein_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "train_data, test_data = train_test_split(data_list, test_size = 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node: max: 620, min: 20, mean: 52.84979702300406\n",
      "Edge: max: 2098, min: 46, mean: 197.32070365358592\n"
     ]
    }
   ],
   "source": [
    "device = 'cpu'\n",
    "\n",
    "nodes = [data.num_nodes for data in data_list]\n",
    "edges = [data.num_edges for data in data_list]\n",
    "print('Node: max: {}, min: {}, mean: {}'.format(max(nodes), min(nodes), sum(nodes)/len(nodes)))\n",
    "print('Edge: max: {}, min: {}, mean: {}'.format(max(edges), min(edges), sum(edges)/len(edges)))\n",
    "\n",
    "\n",
    "# model\n",
    "num_features = data_list[0].x.shape[1]\n",
    "\n",
    "input_dim = num_features\n",
    "\n",
    "OUTPUT_DIM = 256\n",
    "FEATURE_DIM = 256\n",
    "HIDDEN_DIM = 256\n",
    "EPOCHS = 20\n",
    "LEARNING_RATE = 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = PairwiseModel(input_dim=input_dim, feature_dim=FEATURE_DIM, hidden_dim=HIDDEN_DIM, model_type=\"GraphSAGE\",\n",
    "                      aggregator = \"max\", output_dim=OUTPUT_DIM)\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20, Iteration 12/591, Loss 0.71, Accuracy 0.5664\r"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/krishanu/anaconda3/envs/gnn/lib/python3.7/site-packages/torch/nn/functional.py:1351: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
      "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/20, Train Loss 0.698, Test Loss 0.697, Train Accuracy 0.545, Test Accuracy 0.556\n",
      "Epoch 4/20, Train Loss 0.695, Test Loss 0.692, Train Accuracy 0.539, Test Accuracy 0.551\n",
      "Epoch 6/20, Train Loss 0.693, Test Loss 0.687, Train Accuracy 0.533, Test Accuracy 0.534\n",
      "Epoch 8/20, Train Loss 0.693, Test Loss 0.687, Train Accuracy 0.533, Test Accuracy 0.531\n",
      "Epoch 10/20, Train Loss 0.694, Test Loss 0.688, Train Accuracy 0.536, Test Accuracy 0.529\n",
      "Epoch 12/20, Train Loss 0.692, Test Loss 0.687, Train Accuracy 0.529, Test Accuracy 0.528\n",
      "Epoch 14/20, Train Loss 0.692, Test Loss 0.687, Train Accuracy 0.527, Test Accuracy 0.528\n",
      "Epoch 16/20, Train Loss 0.692, Test Loss 0.686, Train Accuracy 0.531, Test Accuracy 0.526\n",
      "Epoch 18/20, Train Loss 0.692, Test Loss 0.687, Train Accuracy 0.529, Test Accuracy 0.524\n",
      "Epoch 20/20, Train Loss 0.692, Test Loss 0.687, Train Accuracy 0.526, Test Accuracy 0.524\n"
     ]
    }
   ],
   "source": [
    "loss_func = nn.BCEWithLogitsLoss()\n",
    "\n",
    "train_loss = []\n",
    "test_loss = []\n",
    "\n",
    "train_acc = []\n",
    "test_acc = []\n",
    "\n",
    "for epoch in range(EPOCHS):\n",
    "    train_loss_temp = []\n",
    "    test_loss_temp = []\n",
    "\n",
    "    train_acc_temp = []\n",
    "    test_acc_temp = []\n",
    "    \n",
    "    model.train()\n",
    "    shuffle(train_data)\n",
    "\n",
    "    for i, data in enumerate(train_data):\n",
    "        \n",
    "        pred = model(data)\n",
    "        label = torch.from_numpy(data.pair_nodes_class).float()\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        loss = loss_func(pred, label)\n",
    "\n",
    "        # update\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        accuracy = np.mean(label.numpy() == (pred.detach().numpy() > 0.5))\n",
    "        \n",
    "        print(\"Epoch {}/{}, Iteration {}/{}, Loss {}, Accuracy {}\".format(epoch + 1, EPOCHS, i + 1, len(train_data),\n",
    "                                                                         round(loss.item(), 3), round(accuracy, 3)),\n",
    "             end = \"\\r\", flush = True)\n",
    "        train_loss_temp.append(loss.item())\n",
    "        train_acc_temp.append(accuracy)\n",
    "    model.eval()\n",
    "    for i, data in enumerate(test_data):\n",
    "        \n",
    "        pred = model(data)\n",
    "        label = torch.from_numpy(data.pair_nodes_class).float()\n",
    "        \n",
    "        loss = loss_func(pred, label)\n",
    "        \n",
    "        accuracy = np.mean(label.numpy() == (pred.detach().numpy() > 0.5))\n",
    "        \n",
    "        test_loss_temp.append(loss.item())\n",
    "        test_acc_temp.append(accuracy)\n",
    "        \n",
    "    \n",
    "    train_loss.append(np.mean(train_loss_temp))\n",
    "    test_loss.append(np.mean(test_loss_temp))\n",
    "\n",
    "    train_acc.append(np.mean(train_acc_temp))\n",
    "    test_acc.append(np.mean(test_acc_temp))\n",
    "    \n",
    "    if ((epoch + 1) % (EPOCHS // 10) == 0):\n",
    "        print(\"Epoch {}/{}, Train Loss {}, Test Loss {}, Train Accuracy {}, Test Accuracy {}\".format(epoch + 1, EPOCHS, round(np.mean(train_loss_temp), 3), round(np.mean(test_loss_temp), 3), \n",
    "                                                                                                     round(np.mean(train_acc_temp), 3), round(np.mean(test_acc_temp), 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_auc_score as roc_auc\n",
    "\n",
    "def calculate_roc(model, data):\n",
    "    preds = None\n",
    "    labels = None\n",
    "    \n",
    "    for d in data:\n",
    "        pred = model(d).detach().numpy().flatten()\n",
    "        label = torch.from_numpy(d.pair_nodes_class).numpy().flatten()\n",
    "\n",
    "        if preds is None:\n",
    "            preds = pred\n",
    "            labels = label\n",
    "        else:\n",
    "            preds = np.concatenate([preds, pred], axis = None)\n",
    "            labels = np.concatenate([labels, label], axis= None)\n",
    "\n",
    "    return roc_auc(label, pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/krishanu/anaconda3/envs/gnn/lib/python3.7/site-packages/torch/nn/functional.py:1351: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
      "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.517320222007722"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculate_roc(model, test_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}