ChG_Miner_GraphSAGE.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "Bad key \"text.kerning_factor\" on line 4 in\n",
      "/home/apurv/anaconda3/envs/tf/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test_patch.mplstyle.\n",
      "You probably need to get an updated matplotlibrc file from\n",
      "https://github.com/matplotlib/matplotlib/blob/v3.1.3/matplotlibrc.template\n",
      "or from the matplotlib source distribution\n"
     ]
    }
   ],
   "source": [
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import netwulf as nw\n",
    "from netwulf import visualize\n",
    "import pandas as pd\n",
    "from statistics import mean\n",
    "import stellargraph as sg\n",
    "from stellargraph.data import EdgeSplitter\n",
    "from sklearn.model_selection import train_test_split\n",
    "from stellargraph.mapper import GraphSAGELinkGenerator\n",
    "from stellargraph.layer import GraphSAGE, link_classification\n",
    "from tensorflow import keras\n",
    "from sklearn import preprocessing, feature_extraction, model_selection\n",
    "from math import log\n",
    "import os\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         drug  gene\n",
      "DB05127     1     0\n",
      "P49190      0     1\n",
      "DB04716     1     0\n",
      "Average Degree : 4.123382813563938\n",
      "StellarGraph: Undirected multigraph\n",
      " Nodes: 7343, Edges: 15139\n",
      "\n",
      " Node types:\n",
      "  default: [7343]\n",
      "    Features: float32 vector, length 2\n",
      "    Edge types: default-default->default\n",
      "\n",
      " Edge types:\n",
      "    default-default->default: [15139]\n",
      "        Weights: all 1 (default)\n"
     ]
    }
   ],
   "source": [
    "# GraphSAGE and GAT Preprocessing \n",
    "# Step 1 Loading Graph Data (Making it Homogenous)\n",
    "# Treating drug and gene name as an feature dimensions and creating 2-D one-hot vector \n",
    "\n",
    "edges = pd.read_csv('ChG-Miner_miner-chem-gene.tsv', sep = '\\t')\n",
    "drugs = pd.DataFrame(index=pd.unique(edges[\"#Drug\"])).assign(drug=1, gene=0)\n",
    "genes = pd.DataFrame(index=pd.unique(edges[\"Gene\"])).assign(drug=0, gene=1)\n",
    "\n",
    "nodes = pd.concat([drugs, genes])\n",
    "Minergraphv = sg.StellarGraph(\n",
    "    nodes, \n",
    "    edges,\n",
    "    source_column=\"#Drug\", \n",
    "    target_column=\"Gene\",\n",
    ")\n",
    "# Need to write Steller Graph constructor to create a graph with one node type\n",
    "print(nodes.sample(3))\n",
    "G=Minergraphv.node_degrees()\n",
    "#print('Average Degree : ' + str(mean(G[k] for k in G)))\n",
    "#print(Minergraphv.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removed 1000 edges\n",
      "Sampled 1000 negative examples\n",
      "** Sampled 1513 positive and 1513 negative edges. **\n"
     ]
    }
   ],
   "source": [
    "# Define an edge splitter on the original graph G:\n",
    "edge_splitter_test = EdgeSplitter(Minergraphv)\n",
    "\n",
    "# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G, and obtain the\n",
    "# reduced graph G_test with the sampled links removed:\n",
    "G_test, edge_ids_test, edge_labels_test = edge_splitter_test.train_test_split(\n",
    "    p=0.1, method=\"global\", keep_connected=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removed 1000 edges\n",
      "Sampled 1000 negative examples\n",
      "** Sampled 1362 positive and 1362 negative edges. **\n"
     ]
    }
   ],
   "source": [
    "# Define an edge splitter on the reduced graph G_test:\n",
    "edge_splitter_train = EdgeSplitter(G_test)\n",
    "\n",
    "# Randomly sample a fraction p=0.1 of all positive links, and same number of negative links, from G_test, and obtain the\n",
    "# reduced graph G_train with the sampled links removed:\n",
    "G_train, edge_ids_train, edge_labels_train = edge_splitter_train.train_test_split(\n",
    "    p=0.1, method=\"global\", keep_connected=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "StellarGraph: Undirected multigraph\n",
      " Nodes: 7343, Edges: 12264\n",
      "\n",
      " Node types:\n",
      "  default: [7343]\n",
      "    Features: float32 vector, length 2\n",
      "    Edge types: default-default->default\n",
      "\n",
      " Edge types:\n",
      "    default-default->default: [12264]\n",
      "        Weights: all 1 (default)\n"
     ]
    }
   ],
   "source": [
    "print(G_train.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "StellarGraph: Undirected multigraph\n",
      " Nodes: 7343, Edges: 13626\n",
      "\n",
      " Node types:\n",
      "  default: [7343]\n",
      "    Features: float32 vector, length 2\n",
      "    Edge types: default-default->default\n",
      "\n",
      " Edge types:\n",
      "    default-default->default: [13626]\n",
      "        Weights: all 1 (default)\n"
     ]
    }
   ],
   "source": [
    "print(G_test.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 20\n",
    "epochs = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_samples = [20, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Training with Shuffle 2 layers\n",
    "train_gen = GraphSAGELinkGenerator(G_train, batch_size, num_samples)\n",
    "train_flow = train_gen.flow(edge_ids_train, edge_labels_train, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test without shuffle\n",
    "test_gen = GraphSAGELinkGenerator(G_test, batch_size, num_samples)\n",
    "test_flow = test_gen.flow(edge_ids_test, edge_labels_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_sizes = [20, 20]\n",
    "graphsage = GraphSAGE(\n",
    "    layer_sizes=layer_sizes, generator=train_gen, bias=True, dropout=0.3\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the model and expose input and output sockets of graphsage model\n",
    "# for link prediction\n",
    "x_inp, x_out = graphsage.in_out_tensors()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "link_classification: using 'ip' method to combine node embeddings into edge embeddings\n"
     ]
    }
   ],
   "source": [
    "prediction = link_classification(\n",
    "    output_dim=1, output_act=\"relu\", edge_embedding_method=\"ip\"\n",
    ")(x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = keras.Model(inputs=x_inp, outputs=prediction)\n",
    "\n",
    "model.compile(\n",
    "    optimizer=keras.optimizers.Adam(lr=1e-3),\n",
    "    loss=keras.losses.binary_crossentropy,\n",
    "    metrics=[\"acc\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:sample_weight modes were coerced from\n",
      "  ...\n",
      "    to  \n",
      "  ['...']\n",
      "137/137 [==============================] - 9s 63ms/step - loss: 4.6993 - acc: 0.2232\n",
      "WARNING:tensorflow:sample_weight modes were coerced from\n",
      "  ...\n",
      "    to  \n",
      "  ['...']\n",
      "152/152 [==============================] - 9s 60ms/step - loss: 4.9185 - acc: 0.2115\n",
      "\n",
      "Train Set Metrics of the initial (untrained) model:\n",
      "\tloss: 4.6993\n",
      "\tacc: 0.2232\n",
      "\n",
      "Test Set Metrics of the initial (untrained) model:\n",
      "\tloss: 4.9185\n",
      "\tacc: 0.2115\n"
     ]
    }
   ],
   "source": [
    "#Evaluate the initial (untrained) model on the train and test set\n",
    "\n",
    "init_train_metrics = model.evaluate(train_flow)\n",
    "init_test_metrics = model.evaluate(test_flow)\n",
    "\n",
    "print(\"\\nTrain Set Metrics of the initial (untrained) model:\")\n",
    "for name, val in zip(model.metrics_names, init_train_metrics):\n",
    "    print(\"\\t{}: {:0.4f}\".format(name, val))\n",
    "\n",
    "print(\"\\nTest Set Metrics of the initial (untrained) model:\")\n",
    "for name, val in zip(model.metrics_names, init_test_metrics):\n",
    "    print(\"\\t{}: {:0.4f}\".format(name, val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:sample_weight modes were coerced from\n",
      "  ...\n",
      "    to  \n",
      "  ['...']\n",
      "WARNING:tensorflow:sample_weight modes were coerced from\n",
      "  ...\n",
      "    to  \n",
      "  ['...']\n",
      "Train for 137 steps, validate for 152 steps\n",
      "Epoch 1/20\n",
      "137/137 - 18s - loss: 0.8870 - acc: 0.4662 - val_loss: 4.9296 - val_acc: 0.5000\n",
      "Epoch 2/20\n",
      "137/137 - 17s - loss: 0.7881 - acc: 0.5426 - val_loss: 5.1018 - val_acc: 0.5000\n",
      "Epoch 3/20\n",
      "137/137 - 16s - loss: 0.7667 - acc: 0.5587 - val_loss: 5.2838 - val_acc: 0.5000\n",
      "Epoch 4/20\n",
      "137/137 - 16s - loss: 0.7560 - acc: 0.5683 - val_loss: 5.2294 - val_acc: 0.5000\n",
      "Epoch 5/20\n",
      "137/137 - 16s - loss: 0.7379 - acc: 0.5639 - val_loss: 5.3598 - val_acc: 0.5000\n",
      "Epoch 6/20\n",
      "137/137 - 17s - loss: 0.7449 - acc: 0.5595 - val_loss: 5.5336 - val_acc: 0.5000\n",
      "Epoch 7/20\n",
      "137/137 - 16s - loss: 0.7335 - acc: 0.5742 - val_loss: 5.3881 - val_acc: 0.5000\n",
      "Epoch 8/20\n",
      "137/137 - 15s - loss: 0.7284 - acc: 0.5661 - val_loss: 5.3773 - val_acc: 0.5000\n",
      "Epoch 9/20\n",
      "137/137 - 19s - loss: 0.7430 - acc: 0.5518 - val_loss: 5.5021 - val_acc: 0.5000\n",
      "Epoch 10/20\n",
      "137/137 - 20s - loss: 0.7214 - acc: 0.5679 - val_loss: 5.3575 - val_acc: 0.5000\n",
      "Epoch 11/20\n",
      "137/137 - 19s - loss: 0.7314 - acc: 0.5709 - val_loss: 5.2661 - val_acc: 0.5000\n",
      "Epoch 12/20\n",
      "137/137 - 17s - loss: 0.7350 - acc: 0.5540 - val_loss: 5.4018 - val_acc: 0.5000\n",
      "Epoch 13/20\n",
      "137/137 - 18s - loss: 0.7361 - acc: 0.5521 - val_loss: 5.2952 - val_acc: 0.5000\n",
      "Epoch 14/20\n",
      "137/137 - 17s - loss: 0.7160 - acc: 0.5668 - val_loss: 5.3052 - val_acc: 0.5000\n",
      "Epoch 15/20\n",
      "137/137 - 18s - loss: 0.7257 - acc: 0.5558 - val_loss: 5.4079 - val_acc: 0.5000\n",
      "Epoch 16/20\n",
      "137/137 - 15s - loss: 0.7160 - acc: 0.5668 - val_loss: 5.3571 - val_acc: 0.5000\n",
      "Epoch 17/20\n",
      "137/137 - 16s - loss: 0.7164 - acc: 0.5503 - val_loss: 5.4662 - val_acc: 0.5000\n",
      "Epoch 18/20\n",
      "137/137 - 16s - loss: 0.7198 - acc: 0.5529 - val_loss: 5.3121 - val_acc: 0.5000\n",
      "Epoch 19/20\n",
      "137/137 - 16s - loss: 0.7244 - acc: 0.5591 - val_loss: 5.2045 - val_acc: 0.5000\n",
      "Epoch 20/20\n",
      "137/137 - 16s - loss: 0.7171 - acc: 0.5529 - val_loss: 5.4391 - val_acc: 0.5000\n"
     ]
    }
   ],
   "source": [
    "#Training the model\n",
    "history = model.fit(train_flow, epochs=epochs, validation_data=test_flow, verbose=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sg.utils.plot_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:sample_weight modes were coerced from\n",
      "  ...\n",
      "    to  \n",
      "  ['...']\n",
      "137/137 [==============================] - 6s 46ms/step - loss: 5.2632 - acc: 0.5000\n",
      "WARNING:tensorflow:sample_weight modes were coerced from\n",
      "  ...\n",
      "    to  \n",
      "  ['...']\n",
      "152/152 [==============================] - 8s 50ms/step - loss: 5.4391 - acc: 0.5000\n",
      "\n",
      "Train Set Metrics of the trained model:\n",
      "\tloss: 5.2632\n",
      "\tacc: 0.5000\n",
      "\n",
      "Test Set Metrics of the trained model:\n",
      "\tloss: 5.4391\n",
      "\tacc: 0.5000\n"
     ]
    }
   ],
   "source": [
    "#Evaluate the trained model on test citation links:\n",
    "train_metrics = model.evaluate(train_flow)\n",
    "test_metrics = model.evaluate(test_flow)\n",
    "\n",
    "print(\"\\nTrain Set Metrics of the trained model:\")\n",
    "for name, val in zip(model.metrics_names, train_metrics):\n",
    "    print(\"\\t{}: {:0.4f}\".format(name, val))\n",
    "\n",
    "print(\"\\nTest Set Metrics of the trained model:\")\n",
    "for name, val in zip(model.metrics_names, test_metrics):\n",
    "    print(\"\\t{}: {:0.4f}\".format(name, val))"
   ]
  },
  {
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}