GNNExplainer.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "GNNExplainer.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyP8AsYHpQ8hd7lcKpu8mhzG",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/paulamartingonzalez/GNN-expl/blob/main/GNNExplainer.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IaXBWY4oD327",
        "outputId": "cb0e05b8-2abe-46a3-8a6b-6634ff166a55"
      },
      "source": [
        "!pip install dgl "
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: dgl in /usr/local/lib/python3.7/dist-packages (0.6.1)\n",
            "Requirement already satisfied: numpy>=1.14.0 in /usr/local/lib/python3.7/dist-packages (from dgl) (1.21.5)\n",
            "Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.7/dist-packages (from dgl) (2.23.0)\n",
            "Requirement already satisfied: networkx>=2.1 in /usr/local/lib/python3.7/dist-packages (from dgl) (2.6.3)\n",
            "Requirement already satisfied: scipy>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from dgl) (1.4.1)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19.0->dgl) (2.10)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19.0->dgl) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19.0->dgl) (2021.10.8)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19.0->dgl) (3.0.4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8aC2wp6rD5KO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "976f1ed7-a3e2-4e56-861b-0c147e706129"
      },
      "source": [
        "import dgl\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from dgl.dataloading import GraphDataLoader\n",
        "from torch.utils.data.sampler import SubsetRandomSampler\n",
        "from dgl.nn import GraphConv,EdgeWeightNorm\n",
        "from random import randint\n",
        "from torch.utils.data import DataLoader\n",
        "from scipy.sparse import coo_matrix\n",
        "from scipy import sparse\n",
        "from functools import partial\n",
        "import pandas as pd\n",
        "import networkx as nx"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Using backend: pytorch\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_4a8YYa7MDNU"
      },
      "source": [
        "# Create random graphs for graph classification"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mwly_px1D6jo",
        "outputId": "e2122bca-20ef-4f51-fd46-7bb8b66a75ae"
      },
      "source": [
        "gs=[]\n",
        "node_number = 20\n",
        "initial_nodes = 2\n",
        "node_feats=4\n",
        "\n",
        "\n",
        "for i in range(25):\n",
        "    G = nx.barabasi_albert_graph(node_number, initial_nodes)\n",
        "    A = nx.adjacency_matrix(G)\n",
        "    g = dgl.DGLGraph(A)\n",
        "    g.ndata['h_n'] = torch.randn(g.num_nodes(), node_feats)\n",
        "    label = randint(0, 1)\n",
        "    gs.append((g,label))"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/dgl/base.py:45: DGLWarning: Recommend creating graphs by `dgl.graph(data)` instead of `dgl.DGLGraph(data)`.\n",
            "  return warnings.warn(message, category=category, stacklevel=1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nWsQaDvpMGkh"
      },
      "source": [
        "# Define model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IzX1NRjJGhpW"
      },
      "source": [
        "class GCN(nn.Module):\n",
        "    def __init__(self, in_feats, h_feats, num_classes):\n",
        "        super(GCN, self).__init__()\n",
        "        self.conv1 = GraphConv(in_feats, h_feats)\n",
        "        self.conv2 = GraphConv(h_feats, num_classes)\n",
        "        self.w = EdgeWeightNorm()\n",
        "        self.out_act = nn.Sigmoid()\n",
        "\n",
        "    def forward(self, g, in_feat):\n",
        "        h = self.conv1(g, in_feat)\n",
        "        h = F.relu(h)\n",
        "        h = self.conv2(g, h)\n",
        "        g.ndata['h'] = h\n",
        "        return self.out_act(dgl.mean_nodes(g, 'h'))"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Osh0y_9jMKFL"
      },
      "source": [
        "# Dataloader"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CWDdNWfdHxp_"
      },
      "source": [
        "def collate(samples):\n",
        "    # The input `samples` is a list of pairs\n",
        "    #  (graph, label).\n",
        "    graphs, labels = map(list, zip(*samples))\n",
        "    batched_graph = dgl.batch(graphs)\n",
        "    return batched_graph, torch.tensor(labels)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BzfKlhQdH-63"
      },
      "source": [
        "train_dataloader = DataLoader(gs, batch_size=int(10), shuffle=True,\n",
        "                            collate_fn=collate)"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ISr7o9jTMMYV"
      },
      "source": [
        "# Train"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dzFsDYmkHuIa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa9915c6-3e3c-406c-de5e-bc6067999806"
      },
      "source": [
        "# Create the model with given dimensions\n",
        "model = GCN(4, 16, 1)\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
        "loss_func = nn.BCELoss()\n",
        "\n",
        "for epoch in range(20):\n",
        "    for batched_graph, labels in train_dataloader:\n",
        "        #edge_weight = (torch.randn(batched_graph.num_edges()) ** 2).requires_grad_() \n",
        "        #edge_weight = torch.tensor(batched_graph.adj(scipy_fmt='coo').todense())\n",
        "        pred = model(batched_graph, batched_graph.ndata['h_n'].float())\n",
        "        loss = loss_func(pred.round(), labels.unsqueeze(1).float())\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/autocast_mode.py:141: UserWarning: User provided device_type of 'cuda', but CUDA is not available. Disabling\n",
            "  warnings.warn('User provided device_type of \\'cuda\\', but CUDA is not available. Disabling')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "01MM27PjMWFf"
      },
      "source": [
        "# Get node importances"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4S9uX24FOYfV"
      },
      "source": [
        "Select one graph:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LuCDHa-eNVlH"
      },
      "source": [
        "graphs = dgl.unbatch(batched_graph)\n",
        "G = graphs[2]\n",
        "edge_weight = (torch.randn(G.num_edges()) ** 2).requires_grad_() "
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 318
        },
        "id": "-mn439jONgT5",
        "outputId": "cf10ca2e-512f-47d5-aa73-6a0aab7a9993"
      },
      "source": [
        "nx_G = G.to_networkx().to_undirected()\n",
        "# Kamada-Kawaii layout usually looks pretty for arbitrary graphs\n",
        "pos = nx.kamada_kawai_layout(nx_G)\n",
        "nx.draw(nx_G, pos, with_labels=True, node_color=[[.7, .7, .7]])"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "GNN explainer implementation taken from [https://github.com/ShaharGottlieb/GNNExplainer_DGL](https://github.com/ShaharGottlieb/GNNExplainer_DGL)"
      ],
      "metadata": {
        "id": "BhXW2Pn8_xh7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from math import sqrt\n",
        "from tqdm import tqdm\n",
        "import copy\n",
        "import numpy as np\n",
        "import dgl\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import networkx as nx\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.patches as mpatches\n",
        "\n",
        "\n",
        "class ExplainerTags:\n",
        "    ORIGINAL_ID = '_explainer_original_id'\n",
        "    EDGE_MASK = '_explainer_edge_mast'\n",
        "    NODE_FEATURES = 'explainer_feature'\n",
        "\n",
        "\n",
        "# UDF for message passing. this will execute after all the previous messages, and mask the final massage.\n",
        "def mask_message(edges):\n",
        "    edata = edges.data['m']\n",
        "    emask = edges.data[ExplainerTags.EDGE_MASK].sigmoid().view(-1, 1)\n",
        "    masked_message = (edata.view(edata.shape[0], -1) * emask).view(edata.shape)\n",
        "    return {'m': masked_message}\n",
        "\n",
        "\n",
        "# workaround to hijack the \"update_all\" function of DGL\n",
        "class ExplainGraph(dgl.DGLGraph):\n",
        "    def update_all(self, message_func, reduce_func, apply_node_func=None, etype=None):\n",
        "        super().apply_edges(message_func)\n",
        "        super().update_all(mask_message, reduce_func, apply_node_func, etype)\n",
        "\n",
        "\n",
        "class GNNExplainer:\n",
        "    \"\"\"\n",
        "        TODO - add info\n",
        "    \"\"\"\n",
        "    # hyper parameters, taken from the original paper\n",
        "    params = {\n",
        "        'edge_size': 0.005,\n",
        "        'feat_size': 0.5,\n",
        "        'edge_ent': 1.0,\n",
        "        'feat_ent': 0.1,\n",
        "        'eps': 1e-15\n",
        "    }\n",
        "\n",
        "    def __init__(self, graph: dgl.DGLGraph, model: nn.Module, num_hops: int,\n",
        "                 epochs: int = 100, lr: float = 0.01,\n",
        "                 mask_threshold: float = 0.5, edge_size: float = 0.005, feat_size: float = 0.1):\n",
        "        \"\"\"\n",
        "        :param graph: dgl base graph\n",
        "        :param model: model to explain\n",
        "        :param num_hops: number of message passing layers in model\n",
        "        :param epochs: number of epochs to optimize explainer\n",
        "        :param lr: learning rate\n",
        "        :param mask_threshold: threshold for hard-mask at return\n",
        "        \"\"\"\n",
        "        self.g: dgl.DGLGraph = graph\n",
        "        self.model = model\n",
        "        self.epochs = epochs\n",
        "        self.lr = lr\n",
        "        self.threshold = mask_threshold\n",
        "        self.num_hops = num_hops\n",
        "        self.feature_mask = None\n",
        "        self.params['edge_size'] = edge_size\n",
        "        self.params['feat_size'] = feat_size\n",
        "        self.nfeat = ExplainerTags.NODE_FEATURES\n",
        "        for module in self.model.modules():\n",
        "            if hasattr(module, '_allow_zero_in_degree'):\n",
        "                module._allow_zero_in_degree = True\n",
        "\n",
        "    def __set_masks__(self, g: dgl.DGLGraph):\n",
        "        \"\"\" set masks for edges and features \"\"\"\n",
        "        num_feat = g.ndata[self.nfeat].shape[1:]\n",
        "        self.feature_mask = nn.Parameter(torch.randn(num_feat) * 0.1)\n",
        "\n",
        "        std = nn.init.calculate_gain('relu') * sqrt(2.0 / (2 * g.num_nodes()))\n",
        "        g.edata[ExplainerTags.EDGE_MASK] = nn.Parameter(torch.randn(g.num_edges()) * std)\n",
        "\n",
        "    @staticmethod\n",
        "    def __apply_feature_mask__(feat, mask):\n",
        "        mask_sig = mask.view(1, -1).sigmoid()\n",
        "        return feat * mask_sig\n",
        "\n",
        "    def __loss__(self, g, node_idx, log_logits, pred_label):\n",
        "        # prediction loss\n",
        "        if node_idx is None:  # graph classification\n",
        "            loss = -log_logits.view(-1)[pred_label]\n",
        "        else:\n",
        "            loss = -log_logits[node_idx, pred_label[node_idx]]\n",
        "\n",
        "        # edge loss\n",
        "        me = g.edata[ExplainerTags.EDGE_MASK].sigmoid()\n",
        "        loss = loss + torch.sum(me) * self.params['edge_size']  # edge regularization - subgraph size\n",
        "        entropy = -me * torch.log(me + self.params['eps']) - (1 - me) * torch.log(1 - me + self.params['eps'])\n",
        "        loss = loss + self.params['edge_ent'] * entropy.mean()  # edge los: entropy + regularization\n",
        "\n",
        "        # node features loss\n",
        "        mn = self.feature_mask.sigmoid()\n",
        "        loss = loss + torch.mean(mn) * self.params['feat_size']  # node feature regularization\n",
        "        entropy = -mn * torch.log(mn + self.params['eps']) - (1 - mn) * torch.log(1 - mn + self.params['eps'])\n",
        "        loss = loss + self.params['feat_ent'] * entropy.mean()  # node feature los: entropy + regularization\n",
        "        # print(log_logits, loss)\n",
        "        return loss\n",
        "\n",
        "    def _predict(self, graph, model, node_id, feat_mask=None):\n",
        "        model.eval()\n",
        "        feat = graph.ndata[self.nfeat]\n",
        "        if feat_mask is not None:\n",
        "            feat = feat * feat_mask\n",
        "        with torch.no_grad():\n",
        "            log_logits = model(graph, feat)\n",
        "            pred_label = log_logits.argmax(dim=-1)\n",
        "\n",
        "        if node_id is None:   # graph classification\n",
        "            return log_logits, pred_label\n",
        "        else:    # node classification\n",
        "            return log_logits[node_id], pred_label[node_id]\n",
        "\n",
        "    def _create_subgraph(self, node_idx):\n",
        "        \"\"\" get all nodes that contribute to the computation of node's embedding \"\"\"\n",
        "        if node_idx is None:  # graph classification\n",
        "            sub_g = copy.deepcopy(self.g)\n",
        "            sub_g.ndata[ExplainerTags.ORIGINAL_ID] = torch.range(0, self.g.num_nodes() - 1, dtype=torch.int)\n",
        "        else:\n",
        "            nodes = torch.tensor([node_idx])\n",
        "            eid_list = []\n",
        "            for _ in range(self.num_hops):\n",
        "                predecessors, _, eid = self.g.in_edges(nodes, form='all')\n",
        "                eid_list.extend(eid)\n",
        "                predecessors = torch.flatten(predecessors).unique()\n",
        "                nodes = torch.cat([nodes, predecessors])\n",
        "                nodes = torch.unique(nodes)\n",
        "            eid_list = list(np.unique(np.array([eid_list])))\n",
        "            sub_g = dgl.edge_subgraph(self.g, eid_list)  # TODO - handle heterogeneous graphs\n",
        "            sub_g.ndata[ExplainerTags.ORIGINAL_ID] = sub_g.ndata[dgl.NID]\n",
        "        return sub_g\n",
        "\n",
        "    def explain_node(self, node_idx):\n",
        "        \"\"\" main function - calculate explanation \"\"\"\n",
        "        # get prediction label\n",
        "        self.model.eval()\n",
        "        feat = self.g.ndata[self.nfeat]\n",
        "        device = feat.device\n",
        "        with torch.no_grad():\n",
        "            log_logits = self.model(self.g, feat)\n",
        "            pred_label = log_logits.argmax(dim=-1)\n",
        "\n",
        "        # create initial subgraph (all nodes and edges that contribute to the explanation)\n",
        "        subgraph = self._create_subgraph(node_idx)\n",
        "        if node_idx is None:  # graph classification\n",
        "            new_node_id = None\n",
        "            pred_label = pred_label\n",
        "        else:  # node classification\n",
        "            new_node_id = np.where(subgraph.ndata[ExplainerTags.ORIGINAL_ID] == node_idx)[0][0]\n",
        "            pred_label = pred_label[subgraph.ndata[ExplainerTags.ORIGINAL_ID]]\n",
        "\n",
        "        # \"trick\" the graph so we can hijack its calls\n",
        "        original_graph_class = subgraph.__class__\n",
        "        subgraph.__class__ = ExplainGraph  # super hacky, but i find it elegant in it's own way.\n",
        "\n",
        "        # set feature and edge masks\n",
        "        self.__set_masks__(subgraph)\n",
        "        feat = subgraph.ndata[self.nfeat]\n",
        "        # move to device\n",
        "        self.feature_mask.to(device)\n",
        "        subgraph.to(device)\n",
        "\n",
        "        # start optimizing\n",
        "        optimizer = torch.optim.Adam([self.feature_mask, subgraph.edata[ExplainerTags.EDGE_MASK]], lr=self.lr)\n",
        "\n",
        "        pbar = tqdm(total=self.epochs)\n",
        "        pbar.set_description('Explaining node {}'.format(node_idx))\n",
        "        # training loop\n",
        "        for epoch in range(1, self.epochs + 1):\n",
        "            h = self.__apply_feature_mask__(feat, self.feature_mask)  # soft mask features\n",
        "            log_logits = self.model(subgraph, h)         # get prediction (will mask edges inside dgl.graph.update_all)\n",
        "            loss = self.__loss__(subgraph, new_node_id, log_logits, pred_label)\n",
        "            optimizer.zero_grad()\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "            # print(loss.detach())\n",
        "            pbar.update(1)\n",
        "        pbar.close()\n",
        "        subgraph.__class__ = original_graph_class\n",
        "\n",
        "        # get hard node feature mask and edge mask\n",
        "        node_feat_mask = self.feature_mask.detach().sigmoid() > self.threshold\n",
        "        edge_mask = subgraph.edata[ExplainerTags.EDGE_MASK].detach().sigmoid()\n",
        "        subgraph.remove_edges(np.where(edge_mask < self.threshold)[0])\n",
        "\n",
        "        # remove isolated nodes from subgraph\n",
        "        isolated_nodes = np.where((subgraph.in_degrees() == 0) & (subgraph.out_degrees() == 0))[0]\n",
        "        if node_idx is not None:  # node classification\n",
        "            # don't delete our node in any case..\n",
        "            isolated_nodes = isolated_nodes[isolated_nodes != new_node_id]\n",
        "        if sum(isolated_nodes) != subgraph.number_of_nodes():\n",
        "            subgraph.remove_nodes(isolated_nodes)\n",
        "        return subgraph, node_feat_mask\n",
        "\n",
        "    def test_explanation(self, node_id, subgraph, feat_mask):\n",
        "        \"\"\" print explanation results- reduced size, and accuracy\n",
        "        :param node_id: original node id which we explained\n",
        "        :param subgraph: result from GNNExplainer.explain_node\n",
        "        :param feat_mask: result from GNNExplainer.explain_node\n",
        "        \"\"\"\n",
        "        # get node prediction for original task\n",
        "        log_logit_original, label_original = self._predict(self.g, self.model, node_id)\n",
        "        # mapping to new subgraph node id\n",
        "        if node_id is None:  # graph classification\n",
        "            new_node_id = None\n",
        "        else:   # node classification\n",
        "            new_node_id = np.where(subgraph.ndata[ExplainerTags.ORIGINAL_ID] == node_id)[0][0]\n",
        "        # current prediction results\n",
        "        log_logit, label = self._predict(subgraph, self.model, new_node_id, feat_mask)\n",
        "        # create subgraph needed for computation, for size reference\n",
        "        origin_sub_g = self._create_subgraph(node_id)\n",
        "        # print results\n",
        "        print(\"subgraph size before masking (V,E)=({}, {})\".format(origin_sub_g.num_nodes(), origin_sub_g.num_edges()))\n",
        "        print(\"subgraph size after masking  (V,E)=({}, {})\".format(subgraph.num_nodes(), subgraph.num_edges()))\n",
        "        print(\"num features before masking: {}\".format(torch.numel(feat_mask)))\n",
        "        print(\"num features after masking: {}\".format(feat_mask.sum()))\n",
        "        print(\"log_logits before masking: {}\".format(log_logit_original))\n",
        "        print(\"log_logits after masking: {}\".format(log_logit))\n",
        "        print(\"label before masking: {}\".format(label_original))\n",
        "        print(\"label after masking: {}\".format(label))\n",
        "\n",
        "    def _visualize(self, subgraph, nlabel_mapping=None, title=\"\"):\n",
        "        num_classes = int(torch.max(self.g.ndata['label']).item()) + 1\n",
        "        nx_g = dgl.to_networkx(subgraph, node_attrs=['label', ExplainerTags.ORIGINAL_ID])\n",
        "        mapping = {i: nx_g.nodes[i][ExplainerTags.ORIGINAL_ID].item() for i in nx_g.nodes.keys()}\n",
        "        node_labels = [nx_g.nodes[i]['label'].item() for i in nx_g.nodes.keys()]\n",
        "\n",
        "        cmap = plt.get_cmap('cool', num_classes)\n",
        "        cmap.set_under('gray')\n",
        "\n",
        "        node_kwargs = {'node_size': 400, 'cmap': cmap, 'node_color': node_labels, 'vmin': 0, 'vmax': num_classes-1}\n",
        "        label_kwargs = {'labels': mapping, 'font_size': 10}\n",
        "\n",
        "        pos = nx.spring_layout(nx_g)\n",
        "        ax = plt.gca()\n",
        "        for source, target, data in nx_g.edges(data=True):\n",
        "            ax.annotate(\n",
        "                '', xy=pos[target], xycoords='data', xytext=pos[source],\n",
        "                textcoords='data', arrowprops=dict(\n",
        "                    arrowstyle=\"->\",\n",
        "                    alpha=1.0,  # max(data['att'], 0.1), # TODO - change for transparent visualization mode\n",
        "                    shrinkA=sqrt(node_kwargs['node_size']) / 2.0,\n",
        "                    shrinkB=sqrt(node_kwargs['node_size']) / 2.0,\n",
        "                    connectionstyle=\"arc3,rad=0.1\",\n",
        "                ))\n",
        "        nx.draw_networkx_labels(nx_g, pos, **label_kwargs)\n",
        "        nx.draw_networkx_nodes(nx_g, pos, **node_kwargs)\n",
        "        if nlabel_mapping is None:\n",
        "            nlabel_mapping = {i: i for i in range(num_classes)}\n",
        "        patch_list = [mpatches.Patch(color=cmap(i), label=nlabel_mapping[i]) for i in range(num_classes)]\n",
        "        ax.legend(handles=patch_list, title=\"Label\", loc=1)\n",
        "        if title is not None:\n",
        "            plt.title(title)\n",
        "        plt.show()\n",
        "\n",
        "    def visualize(self, subgraph, node_id, nlabel_mapping=None, title=\"\"):\n",
        "        \"\"\"\n",
        "        visualize explanation\n",
        "        :param subgraph: result from GNNExplainer.explain_node\n",
        "        :param node_id: node id used to explain\n",
        "        :param nlabel_mapping: mapping between node label to text, to be printed in legend\n",
        "        :param title: optional title for graph\n",
        "        \"\"\"\n",
        "        self._visualize(self._create_subgraph(node_id), nlabel_mapping, title)\n",
        "        self._visualize(subgraph, nlabel_mapping, title)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "JM4ch9FI_c16"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lrDUKGzHOaUS"
      },
      "source": [
        "Try with our random graphs"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.eval()\n",
        "num_hops = 2\n",
        "graph_label = 178\n",
        "g = G\n",
        "g.ndata[ExplainerTags.NODE_FEATURES] = g.ndata['h_n'].float().to(torch.device(\"cpu\"))\n",
        "explainer = GNNExplainer(g, model, num_hops, epochs=100, edge_size=0.05, feat_size=0)\n",
        "subgraph, feat_mask = explainer.explain_node(None)\n",
        "explainer.test_explanation(None, subgraph, feat_mask)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SmUXZIcx_8K1",
        "outputId": "a63999fc-3e9c-4903-da75-248d215496a9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:124: UserWarning: torch.range is deprecated and will be removed in a future release because its behavior is inconsistent with Python's range builtin. Instead, use torch.arange, which produces values in [start, end).\n",
            "Explaining node None:   0%|          | 0/100 [00:00<?, ?it/s]/usr/local/lib/python3.7/dist-packages/torch/autocast_mode.py:141: UserWarning: User provided device_type of 'cuda', but CUDA is not available. Disabling\n",
            "  warnings.warn('User provided device_type of \\'cuda\\', but CUDA is not available. Disabling')\n",
            "Explaining node None: 100%|██████████| 100/100 [00:00<00:00, 168.25it/s]"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "label_mapping = {0: 'C', 1: 'N', 2: 'O', 3: 'F', 4: 'I', 5: 'Cl', 6: 'Br'}\n",
        "explainer.visualize(subgraph, None, label_mapping, \"Mutagenic label {}\".format(dataset.labels[graph_label]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 158
        },
        "id": "sUQ4yCfHAQ2f",
        "outputId": "afa7fd3d-f57f-4701-e30b-0becdf037109"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-3-b10445e536e2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexplainer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'explainer' is not defined"
          ]
        }
      ]
    }
  ]
}