diff --git a/examples/mpnn_pom_explainability.ipynb b/examples/mpnn_pom_explainability.ipynb
new file mode 100644
index 0000000..484db35
--- /dev/null
+++ b/examples/mpnn_pom_explainability.ipynb
@@ -0,0 +1,1002 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Example script for training MPNN-POM model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import deepchem as dc\n",
+    "from openpom.feat.graph_featurizer import GraphFeaturizer, GraphConvConstants\n",
+    "from openpom.utils.data_utils import get_class_imbalance_ratio\n",
+    "from openpom.models.mpnn_pom import MPNNPOMModel\n",
+    "from datetime import datetime\n",
+    "\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "No of tasks:  138\n"
+     ]
+    }
+   ],
+   "source": [
+    "TASKS = [\n",
+    "'alcoholic', 'aldehydic', 'alliaceous', 'almond', 'amber', 'animal',\n",
+    "'anisic', 'apple', 'apricot', 'aromatic', 'balsamic', 'banana', 'beefy',\n",
+    "'bergamot', 'berry', 'bitter', 'black currant', 'brandy', 'burnt',\n",
+    "'buttery', 'cabbage', 'camphoreous', 'caramellic', 'cedar', 'celery',\n",
+    "'chamomile', 'cheesy', 'cherry', 'chocolate', 'cinnamon', 'citrus', 'clean',\n",
+    "'clove', 'cocoa', 'coconut', 'coffee', 'cognac', 'cooked', 'cooling',\n",
+    "'cortex', 'coumarinic', 'creamy', 'cucumber', 'dairy', 'dry', 'earthy',\n",
+    "'ethereal', 'fatty', 'fermented', 'fishy', 'floral', 'fresh', 'fruit skin',\n",
+    "'fruity', 'garlic', 'gassy', 'geranium', 'grape', 'grapefruit', 'grassy',\n",
+    "'green', 'hawthorn', 'hay', 'hazelnut', 'herbal', 'honey', 'hyacinth',\n",
+    "'jasmin', 'juicy', 'ketonic', 'lactonic', 'lavender', 'leafy', 'leathery',\n",
+    "'lemon', 'lily', 'malty', 'meaty', 'medicinal', 'melon', 'metallic',\n",
+    "'milky', 'mint', 'muguet', 'mushroom', 'musk', 'musty', 'natural', 'nutty',\n",
+    "'odorless', 'oily', 'onion', 'orange', 'orangeflower', 'orris', 'ozone',\n",
+    "'peach', 'pear', 'phenolic', 'pine', 'pineapple', 'plum', 'popcorn',\n",
+    "'potato', 'powdery', 'pungent', 'radish', 'raspberry', 'ripe', 'roasted',\n",
+    "'rose', 'rummy', 'sandalwood', 'savory', 'sharp', 'smoky', 'soapy',\n",
+    "'solvent', 'sour', 'spicy', 'strawberry', 'sulfurous', 'sweaty', 'sweet',\n",
+    "'tea', 'terpenic', 'tobacco', 'tomato', 'tropical', 'vanilla', 'vegetable',\n",
+    "'vetiver', 'violet', 'warm', 'waxy', 'weedy', 'winey', 'woody'\n",
+    "]\n",
+    "print(\"No of tasks: \", len(TASKS))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--2024-07-03 12:42:44--  https://raw.githubusercontent.com/ARY2260/openpom/main/openpom/data/curated_datasets/curated_GS_LF_merged_4983.csv\n",
+      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.111.133, 185.199.108.133, ...\n",
+      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.\n",
+      "HTTP request sent, awaiting response... 200 OK\n",
+      "Length: 1647971 (1.6M) [text/plain]\n",
+      "Saving to: ‘curated_GS_LF_merged_4983.csv.4’\n",
+      "\n",
+      "curated_GS_LF_merge 100%[===================>]   1.57M  --.-KB/s    in 0.05s   \n",
+      "\n",
+      "2024-07-03 12:42:44 (28.8 MB/s) - ‘curated_GS_LF_merged_4983.csv.4’ saved [1647971/1647971]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# download curated dataset\n",
+    "!wget https://raw.githubusercontent.com/ARY2260/openpom/main/openpom/data/curated_datasets/curated_GS_LF_merged_4983.csv\n",
+    "\n",
+    "# The curated dataset can also found at `openpom/data/curated_datasets/curated_GS_LF_merged_4983.csv` in the repo.\n",
+    "\n",
+    "input_file = 'curated_GS_LF_merged_4983.csv' # or new downloaded file path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get dataset\n",
+    "\n",
+    "featurizer = GraphFeaturizer()\n",
+    "smiles_field = 'nonStereoSMILES'\n",
+    "loader = dc.data.CSVLoader(tasks=TASKS,\n",
+    "                   feature_field=smiles_field,\n",
+    "                   featurizer=featurizer)\n",
+    "dataset = loader.create_dataset(inputs=[input_file])\n",
+    "n_tasks = len(dataset.tasks)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4983"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# get train valid test splits\n",
+    "\n",
+    "randomstratifiedsplitter = dc.splits.RandomStratifiedSplitter()\n",
+    "train_dataset, test_dataset, valid_dataset = randomstratifiedsplitter.train_valid_test_split(dataset, frac_train = 0.8, frac_valid = 0.1, frac_test = 0.1, seed = 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train_dataset:  3999\n",
+      "valid_dataset:  498\n",
+      "test_dataset:  486\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"train_dataset: \", len(train_dataset))\n",
+    "print(\"valid_dataset: \", len(valid_dataset))\n",
+    "print(\"test_dataset: \", len(test_dataset))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_ratios = get_class_imbalance_ratio(train_dataset)\n",
+    "assert len(train_ratios) == n_tasks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "learning_rate = dc.models.optimizers.ExponentialDecay(initial_rate=0.001, decay_rate=0.5, decay_steps=32*15, staircase=True)\n",
+    "#learning_rate = 0.001"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# initialize model\n",
+    "\n",
+    "model = MPNNPOMModel(n_tasks = n_tasks,\n",
+    "                            batch_size=128,\n",
+    "                            learning_rate=learning_rate,\n",
+    "                            class_imbalance_ratio = train_ratios,\n",
+    "                            loss_aggr_type = 'sum',\n",
+    "                            node_out_feats = 100,\n",
+    "                            edge_hidden_feats = 75,\n",
+    "                            edge_out_feats = 100,\n",
+    "                            num_step_message_passing = 5,\n",
+    "                            mpnn_residual = True,\n",
+    "                            message_aggregator_type = 'sum',\n",
+    "                            mode = 'classification',\n",
+    "                            number_atom_features = GraphConvConstants.ATOM_FDIM,\n",
+    "                            number_bond_features = GraphConvConstants.BOND_FDIM,\n",
+    "                            n_classes = 1,\n",
+    "                            readout_type = 'set2set',\n",
+    "                            num_step_set2set = 3,\n",
+    "                            num_layer_set2set = 2,\n",
+    "                            ffn_hidden_list= [392, 392],\n",
+    "                            ffn_embeddings = 256,\n",
+    "                            ffn_activation = 'relu',\n",
+    "                            ffn_dropout_p = 0.12,\n",
+    "                            ffn_dropout_at_input_no_act = False,\n",
+    "                            weight_decay = 1e-5,\n",
+    "                            self_loop = False,\n",
+    "                            optimizer_name = 'adam',\n",
+    "                            log_frequency = 32,\n",
+    "                            model_dir = './examples/experiments',\n",
+    "                            device_name='cuda')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<bound method MPNNPOM.forward of MPNNPOM(\n",
+       "  (mpnn): CustomMPNNGNN(\n",
+       "    (project_node_feats): Sequential(\n",
+       "      (0): Linear(in_features=134, out_features=100, bias=True)\n",
+       "      (1): ReLU()\n",
+       "    )\n",
+       "    (gnn_layer): NNConv(\n",
+       "      (edge_func): Sequential(\n",
+       "        (0): Linear(in_features=6, out_features=75, bias=True)\n",
+       "        (1): ReLU()\n",
+       "        (2): Linear(in_features=75, out_features=10000, bias=True)\n",
+       "      )\n",
+       "      (res_fc): Identity()\n",
+       "    )\n",
+       "    (gru): GRU(100, 100)\n",
+       "  )\n",
+       "  (project_edge_feats): Sequential(\n",
+       "    (0): Linear(in_features=6, out_features=100, bias=True)\n",
+       "    (1): ReLU()\n",
+       "  )\n",
+       "  (readout_set2set): Set2Set(\n",
+       "    n_iters=3\n",
+       "    (lstm): LSTM(400, 200, num_layers=2)\n",
+       "  )\n",
+       "  (ffn): CustomPositionwiseFeedForward(\n",
+       "    (activation): ReLU()\n",
+       "    (linears): ModuleList(\n",
+       "      (0): Linear(in_features=400, out_features=392, bias=True)\n",
+       "      (1): Linear(in_features=392, out_features=392, bias=True)\n",
+       "      (2): Linear(in_features=392, out_features=256, bias=True)\n",
+       "      (3): Linear(in_features=256, out_features=138, bias=True)\n",
+       "    )\n",
+       "    (dropout_p): ModuleList(\n",
+       "      (0-3): 4 x Dropout(p=0.12, inplace=False)\n",
+       "    )\n",
+       "    (batchnorms): ModuleList(\n",
+       "      (0-1): 2 x BatchNorm1d(392, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "    )\n",
+       "  )\n",
+       ")>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.model.forward"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nb_epoch = 100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "metric = dc.metrics.Metric(dc.metrics.roc_auc_score)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Comment line if you intend to train your model\n",
+    "\n",
+    "model.restore()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loss_e = model.evaluate(valid_dataset, [metric])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'roc_auc_score': 0.8761967159725471}"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "loss_e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "losses = []\n",
+    "train_scores_list = []\n",
+    "valid_scores_list = []\n",
+    "\n",
+    "start_time = datetime.now()\n",
+    "for epoch in range(1, nb_epoch+1):\n",
+    "        loss = model.fit(\n",
+    "              train_dataset,\n",
+    "              nb_epoch=1,\n",
+    "              max_checkpoints_to_keep=1,\n",
+    "              deterministic=False,\n",
+    "              restore=epoch>1)\n",
+    "        train_scores = model.evaluate(train_dataset, [metric])['roc_auc_score']\n",
+    "        valid_scores = model.evaluate(valid_dataset, [metric])['roc_auc_score']\n",
+    "        print(f\"epoch {epoch}/{nb_epoch} ; loss = {loss}; train_scores = {train_scores}; valid_scores = {valid_scores}\")\n",
+    "\n",
+    "        # Append the metrics to the lists\n",
+    "        losses.append(loss)\n",
+    "        train_scores_list.append(train_scores)\n",
+    "        valid_scores_list.append(valid_scores)\n",
+    "\n",
+    "model.save_checkpoint()\n",
+    "end_time = datetime.now()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "# Plot the metrics\n",
+    "epochs = range(1, nb_epoch + 1)\n",
+    "\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "\n",
+    "# Plot loss\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.plot(epochs, losses, label='Loss')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Loss')\n",
+    "plt.title('Loss over Epochs')\n",
+    "plt.legend()\n",
+    "\n",
+    "# Plot training and validation scores on the same plot\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.plot(epochs, train_scores_list, label='Training Score')\n",
+    "plt.plot(epochs, valid_scores_list, label='Validation Score')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Score')\n",
+    "plt.title('Training and Validation Scores over Epochs')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_scores = model.evaluate(test_dataset, [metric])['roc_auc_score']\n",
+    "print(\"time_taken: \", str(end_time-start_time))\n",
+    "print(\"test_score: \", test_scores)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from rdkit import Chem\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<rdkit.Chem.rdchem.Mol at 0x7ff13979b660>"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Test_SMILES = 'C=CCSCC=C'\n",
+    "\n",
+    "mol = Chem.MolFromSmiles(Test_SMILES)\n",
+    "y = Chem.MolToSmiles(mol)\n",
+    "mol"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set the figure size - handy for larger output\n",
+    "plt.rcParams[\"figure.figsize\"] = [10, 6]\n",
+    "\n",
+    "# Set up with a higher resolution screen (useful on Mac)\n",
+    "%config InlineBackend.figure_format = 'retina'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='odors'>"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 580,
+       "width": 826
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "featurizer = GraphFeaturizer()\n",
+    "featurized_data = featurizer.featurize(Test_SMILES)\n",
+    "\n",
+    "# Get predictions from trained model\n",
+    "prediction = model.predict(dc.data.NumpyDataset(featurized_data))\n",
+    "\n",
+    "# Visualize the top 10 predictions\n",
+    "prediction_df = pd.DataFrame({'odors': TASKS, 'prediction': prediction.squeeze()}).sort_values(by='prediction', ascending=False)\n",
+    "prediction_df[:20].plot.bar(x='odors', y='prediction')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "threshold = 0.5\n",
+    "inputs_labels = [(prediction > threshold).astype(int)[0]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inputs = [[featurized_data[0]]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inputs_weights = np.array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
+    "        1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
+    "        1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
+    "        1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
+    "        1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
+    "        1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
+    "        1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
+    "        1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
+    "        1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\" \n",
+    "Considering that the input of the model is a SMILES string, \n",
+    "it is converted to DGLGraph using GraphFeaturizer() and _prepare_batch()\n",
+    "\"\"\"\n",
+    "\n",
+    "g, labels, weights = model._prepare_batch((inputs, inputs_labels, inputs_weights))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Graph(num_nodes=7, num_edges=12,\n",
+       "      ndata_schemes={'x': Scheme(shape=(134,), dtype=torch.float32)}\n",
+       "      edata_schemes={'edge_attr': Scheme(shape=(6,), dtype=torch.float32)})"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "g"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Target in Integrated Gradients Method:\n",
+    "\n",
+    "When dealing with a non-scalar output, such as in classification models or multi-target regression scenarios, the gradients are computed for a specific element of the output. For classification models, this typically means calculating the gradient with respect to the output associated with the true class or the class predicted by the model, which is referred to as the target."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Index of the highest value: 121\n",
+      "Label: sulfurous\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# Find the index of the highest value\n",
+    "highest_index = np.argmax(prediction)\n",
+    "\n",
+    "\"\"\"\n",
+    "The integrated gradients method typically requires specifying a target class for which the gradients are computed. \n",
+    "In this context, the target class is chosen as the odor label with the highest predicted probability or odor label of interest. \n",
+    "This approach helps to focus the explanation on the most relevant prediction made by the model.\n",
+    "\"\"\"\n",
+    "\n",
+    "target = int(highest_index)\n",
+    "\n",
+    "print(\"Index of the highest value:\", highest_index)\n",
+    "print(\"Label:\", TASKS[highest_index])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from functools import partial\n",
+    "from captum.attr import IntegratedGradients\n",
+    "from torch_geometric.utils import from_dgl, to_dgl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = from_dgl(g)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.backends.cudnn.enabled=False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Edge explainability\n",
+    "\n",
+    "def model_edge_forward(edge_mask, g):\n",
+    "    data = from_dgl(g)\n",
+    "    data.edge_attr = edge_mask\n",
+    "    new_g = to_dgl(data)\n",
+    "    out = model.model(new_g)\n",
+    "    return out[0]\n",
+    "\n",
+    "\n",
+    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
+    "\n",
+    "edge_mask = data.edge_attr.requires_grad_(True).to(device)\n",
+    "\n",
+    "ig = IntegratedGradients(partial(model_edge_forward, g=g))\n",
+    "\n",
+    "ig_attr_edge = ig.attribute(edge_mask, target=target,\n",
+    "                            internal_batch_size=g.num_edges(), n_steps=3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Node explainability\n",
+    "\n",
+    "def model_node_forward(node_mask,g):\n",
+    "    data = from_dgl(g)\n",
+    "    data.x = node_mask\n",
+    "    new_g = to_dgl(data)\n",
+    "    out = model.model(new_g)\n",
+    "    return out[0]\n",
+    "\n",
+    "node_mask = data.x.requires_grad_(True).to(device)\n",
+    "\n",
+    "ig = IntegratedGradients(partial(model_node_forward, g=g))\n",
+    "\n",
+    "ig_attr_node = ig.attribute(node_mask, target=target,\n",
+    "                            internal_batch_size=g.num_nodes())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Output: \n",
+    "\n",
+    "The Integrated Gradients class attribute method returns input attributions with the same size and dimensionality as the inputs (nodes and edges). \n",
+    "\n",
+    "The attributions were aggregated  and rescaled to give a sing;e relative attribution value representing the importance of the graph nodes and edges."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Node Attributions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([0.0610, 0.1336, 0.1336, 0.0610, 0.3265, 1.0000, 0.3265],\n",
+       "       device='cuda:0', dtype=torch.float64, grad_fn=<DivBackward0>)"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ig_attr_node = ig_attr_node.abs().sum(dim=1)\n",
+    "\n",
+    "# Rescaling\n",
+    "\n",
+    "ig_attr_node /= ig_attr_node.max()\n",
+    "\n",
+    "ig_attr_node"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0.06097530428735916,\n",
+       " 0.13355852927670603,\n",
+       " 0.13355852809286423,\n",
+       " 0.06097530705061317,\n",
+       " 0.3264978440581468,\n",
+       " 1.0,\n",
+       " 0.326497846712926]"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "node_list = ig_attr_node.tolist()\n",
+    "node_list"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Edge Attribution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([0.4791, 0.6062, 1.0000, 1.0000, 0.6062, 0.4791], device='cuda:0',\n",
+       "       dtype=torch.float64, grad_fn=<DivBackward0>)"
+      ]
+     },
+     "execution_count": 61,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sum_tensor = ig_attr_edge.abs().sum(dim=1)\n",
+    "\n",
+    "# Reshape the tensor into pairs; each pair representing a single bond (directed)\n",
+    "ig_attr_edge = sum_tensor.view(-1, 2)\n",
+    "\n",
+    "# Sum the elements in each pair to get the value of a single bond\n",
+    "ig_attr_edge = torch.sum(ig_attr_edge, dim=1)\n",
+    "\n",
+    "# Rescaling\n",
+    "ig_attr_edge /= ig_attr_edge.max()\n",
+    "\n",
+    "ig_attr_edge"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0.47910542787668575,\n",
+       " 0.6062098564115913,\n",
+       " 0.9999999790755246,\n",
+       " 1.0,\n",
+       " 0.6062096890157891,\n",
+       " 0.4791054209018606]"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "edge_list = ig_attr_edge.tolist()\n",
+    "edge_list"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "RDKIT Playground"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from __future__ import print_function\n",
+    "from rdkit.Chem.Draw import rdMolDraw2D\n",
+    "import io\n",
+    "from PIL import Image\n",
+    "from collections import defaultdict\n",
+    "from rdkit.Chem import rdmolfiles\n",
+    "from rdkit.Chem import rdmolops\n",
+    "from collections import defaultdict\n",
+    "from rdkit.Chem.Draw import rdMolDraw2D"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# To ensure the same order of the nodes and atoms is retained with RDkit and IG\n",
+    "\n",
+    "order = rdmolfiles.CanonicalRankAtoms(mol)\n",
+    "mol = rdmolops.RenumberAtoms(mol, order)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "colors = [(1.0, 0.1, 0.0), (0.3, 1.0, 0.0)]\n",
+    "\n",
+    "athighlights = defaultdict(list)\n",
+    "arads = {}\n",
+    "\n",
+    "bndhighlights = defaultdict(list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=700x400>"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Node Attribution Visualization\n",
+    "\n",
+    "for i, a in enumerate(mol.GetAtoms()):\n",
+    "    aid = a.GetIdx()   \n",
+    "    if node_list[i] == 0:\n",
+    "        continue\n",
+    "    else:\n",
+    "        # Node attribution is visualized by the transparency. Proportional to the values in the node_list\n",
+    "        trans_atom = node_list[i]\n",
+    "        athighlights[aid].append((colors[1][0], colors[1][1], colors[1][2], trans_atom))\n",
+    "\n",
+    "bndhighlights = defaultdict(list)\n",
+    "\n",
+    "\n",
+    "d2d = rdMolDraw2D.MolDraw2DCairo(700,400)\n",
+    "d2d.DrawMoleculeWithHighlights(mol,\"\",dict(athighlights),dict(bndhighlights),arads,{})\n",
+    "d2d.FinishDrawing()\n",
+    "bio = io.BytesIO(d2d.GetDrawingText())\n",
+    "Image.open(bio)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=700x400>"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Edge Attribution Visualization\n",
+    "\n",
+    "athighlights = defaultdict(list)\n",
+    "\n",
+    "for i, a in enumerate(mol.GetBonds()):\n",
+    "    aid1 = a.GetBeginAtomIdx()\n",
+    "    aid2 = a.GetEndAtomIdx()\n",
+    "\n",
+    "    bid = mol.GetBondBetweenAtoms(aid1,aid2).GetIdx()\n",
+    "    # Edges attribution is visualized by the transparency. Proportional to the values in the edge_list\n",
+    "    trans_bnd = edge_list[i]\n",
+    "    bndhighlights[bid].append((colors[0][0], colors[0][1], colors[0][2], trans_bnd))\n",
+    "\n",
+    "\n",
+    "d2d = rdMolDraw2D.MolDraw2DCairo(700,400)\n",
+    "d2d.DrawMoleculeWithHighlights(mol,\"\",dict(athighlights),dict(bndhighlights),arads,{})\n",
+    "d2d.FinishDrawing()\n",
+    "bio = io.BytesIO(d2d.GetDrawingText())\n",
+    "Image.open(bio)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "odor_pom",
+   "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.19"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}