ExplainabilityUseCase.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0c740326-9e22-477e-89bd-474e1a897ee1",
   "metadata": {},
   "source": [
    "**------------------------------------------------------------------------------------------------------------------------------------------------------**\n",
    "\n",
    "**Input: Prediction(s) obtained from a trained GNN - GraphSAGE, GCN and GAT**\n",
    "\n",
    "**This notebook returns a dictionary containing the most important nodes and edges that were most influential for the prediction(s) using Integrated Gradients and Saliency Maps**\n",
    "\n",
    "**------------------------------------------------------------------------------------------------------------------------------------------------------**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faf38c8a-21a7-477f-a35a-faa325584e0c",
   "metadata": {},
   "source": [
    "# Librairies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e1800886-4197-4cc7-b1cf-ce08f928c94e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import operator\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import json\n",
    "\n",
    "import os\n",
    "import re\n",
    "import random\n",
    "import itertools\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import Linear\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import dgl\n",
    "import dgl.nn as dglnn\n",
    "import dgl.function as fn\n",
    "from dgl import AddReverse\n",
    "from dgl.data.utils import save_graphs\n",
    "\n",
    "from captum.attr import Saliency, IntegratedGradients\n",
    "from torch_geometric.explain import characterization_score\n",
    "\n",
    "from functools import partial\n",
    "\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\")\n",
    "\n",
    "from src.utils import *\n",
    "from src.gnn import *\n",
    "from src.explain import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "59cd9b43-0585-41cc-9abd-83144a62b5f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# etype we want to predict\n",
    "etype = ('Compound', 'DRUGBANK::treats::Compound:Disease', 'Disease')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "813271d5-84e9-4a3d-9581-ace56c539bcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "keys = ['Gene', 'Compound', 'Disease', 'Biological Process', 'Molecular Function', 'Pathway']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4f5d051-9e5b-4082-a69d-6d7cb36a37d4",
   "metadata": {},
   "source": [
    "# 1) Get Subgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5c0bd01-1042-477d-95c2-048e34b7d2a4",
   "metadata": {},
   "source": [
    "**Get DRKG**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d5e50bcf-07d9-472b-a738-a16844f3f16f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('Input/DRKG/drkg.tsv', sep='\\t', header=None)\n",
    "df = df.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa6700d9-962f-4ae2-88d4-bbc651e866b4",
   "metadata": {},
   "source": [
    "**Define subgraph for Alzheimer, we drop all the 'compound treats disease (not Alzheimer)' edges**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bd8b582b-a823-47ed-aa81-5a8d5f34c101",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = df[(df[1] == 'DRUGBANK::treats::Compound:Disease') & (df[2] != 'Disease::MESH:D000544')].index\n",
    "df = df.drop(labels=labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f28aa7d5-b35a-4b88-95d3-e828bc060595",
   "metadata": {},
   "source": [
    "**Create HeteroGraph**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "144b7dd4-381a-4e4a-be77-474c28aaf978",
   "metadata": {},
   "outputs": [],
   "source": [
    "node_dict = get_node_dict(df)\n",
    "node_dict = {k:v for k,v in node_dict.items() if k in keys}\n",
    "edge_dict = get_edge_dict(df, node_dict)\n",
    "g = dgl.heterograph(edge_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a7ccc107-5cc7-49ef-b841-7d2dfcce7060",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('Output/Explainability/Alzheimer/node_mapping.json', 'w') as file:\n",
    "    json.dump(node_dict, file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "976cde0c-c3c9-413c-8a3e-eb806575f157",
   "metadata": {},
   "source": [
    "**Add reverse edges**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d495e570-43de-4275-b33c-540b9ef1fa5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = AddReverse()\n",
    "g = transform(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0daa9a64-9c92-469d-aa9b-d4f9b803ff7e",
   "metadata": {},
   "source": [
    "**Add node features**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "72d3d564-3344-4527-9a3e-3388560247da",
   "metadata": {},
   "outputs": [],
   "source": [
    "g, node_features = add_node_features(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44cd0142-3054-4b6d-a837-f406124ba389",
   "metadata": {},
   "source": [
    "**Construct negative graph**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "42407713-e850-4311-803e-51a45d720c92",
   "metadata": {},
   "outputs": [],
   "source": [
    "g_neg = construct_negative_graph(g, etype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbbc9c41-8edc-4611-afa3-29a8e6798d77",
   "metadata": {},
   "source": [
    "**Save subgraph**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "42b734bd-56fa-4d7f-814c-d50fdd5deab8",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_graphs('Output/Explainability/Alzheimer/AlzheimerGraph', g_list=[g, g_neg])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d704488-de43-4db0-bf5c-dddafc608ead",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 2) Get Explainability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9e7a9426-c8e2-484e-bdb5-780daca55455",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sal: 0\n",
      "sal: 1\n",
      "sal: 2\n",
      "sal: 3\n",
      "sal: 4\n",
      "sal: 5\n",
      "sal: 6\n",
      "sal: 7\n"
     ]
    }
   ],
   "source": [
    "get_imp_node_dicts(g, etype, 'sal', keys, 500)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ade6cecb-6966-4e54-aaff-332b9bfcb3af",
   "metadata": {},
   "source": [
    "# 3) Assess Explainability"
   ]
  },
  {
   "cell_type": "raw",
   "id": "bea8732a-fbb7-4831-a531-5c89ed4ed334",
   "metadata": {},
   "source": [
    "y, y_explain, y_complement = get_all_predictions(g, etype, 'sal', keys)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "daf187ef-9af8-4381-bbb4-28f8003759db",
   "metadata": {},
   "source": [
    "def normalize(vector):\n",
    "    normalized_vector = []\n",
    "    for x in vector:\n",
    "        normalized_vector.append((x - min(vector)) / (max(vector) - min(vector)))\n",
    "    return normalized_vector"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f5890788-d2a7-437a-89a4-03b9d52c9dbf",
   "metadata": {},
   "source": [
    "y = normalize(y)\n",
    "y_explain = normalize(y_explain)\n",
    "y_complement = normalize(y_complement)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2ef537e9-cfe9-4b32-8963-7dc79d3a16c0",
   "metadata": {},
   "source": [
    "y = [1 if x >= 0.5 else 0 for x in y]\n",
    "y_explain = [1 if x >= 0.5 else 0 for x in y_explain]\n",
    "y_complement = [1 if x >= 0.5 else 0 for x in y_complement]"
   ]
  },
  {
   "cell_type": "raw",
   "id": "28d4e7d8-9fc3-4763-babc-3de54f6a05ee",
   "metadata": {},
   "source": [
    "def get_fidelity_count(y, y_complement, y_explain):    \n",
    "    count = 0\n",
    "    count_minus = 0\n",
    "    count_plus = 0\n",
    "\n",
    "    for i in range(len(y)):\n",
    "        if y[i] == 1:\n",
    "            count += 1 \n",
    "            if y[i] == y_complement[i]:\n",
    "                count_plus += 1\n",
    "            elif y[i] == y_explain[i]:\n",
    "                count_minus += 1\n",
    "    return count, count_minus, count_plus"
   ]
  },
  {
   "cell_type": "raw",
   "id": "36dbb868-2494-41a2-ba62-ae3d22b4fce5",
   "metadata": {},
   "source": [
    "count, count_minus, count_plus = get_fidelity_count(y, y_complement, y_explain)\n",
    "\n",
    "pos_fidelity = 1. - (count_plus/count)\n",
    "print(f'Fidelity+: {pos_fidelity:.4f}')\n",
    "neg_fidelity = 1. - (count_minus/count)\n",
    "print(f'Fidelity-: {neg_fidelity:.4f}')\n",
    "charac = characterization_score(pos_fidelity, neg_fidelity)\n",
    "print(f'Characerization score: {charac:.4f}')"
   ]
  }
 ],
 "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.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}