BA-shapes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('./codes/')\n",
    "from config import args\n",
    "\n",
    "args.dataset='syn1'\n",
    "args.elr = 0.003\n",
    "args.eepochs = 10\n",
    "args.coff_size = 0.05\n",
    "args.budget = -1\n",
    "args.coff_ent = 1.0\n",
    "\n",
    "from tqdm import tqdm\n",
    "import tensorflow as tf\n",
    "from utils import *\n",
    "from models import GCN\n",
    "from metrics import *\n",
    "import numpy as np\n",
    "from Extractor import Extractor\n",
    "from Explainer import Explainer\n",
    "from scipy.sparse import coo_matrix,csr_matrix\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_auc_score\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "explainer\n"
     ]
    }
   ],
   "source": [
    "with open('./dataset/' + args.dataset + '.pkl', 'rb') as fin:\n",
    "    adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask, edge_label_matrix  = pkl.load(fin)\n",
    "\n",
    "adj = csr_matrix(adj)\n",
    "support = preprocess_adj(adj)\n",
    "\n",
    "features_tensor = tf.convert_to_tensor(features,dtype=tf.float32)\n",
    "support_tensor = tf.SparseTensor(*support)\n",
    "support_tensor = tf.cast(support_tensor,tf.float32)\n",
    "\n",
    "model = GCN(input_dim=features.shape[1], output_dim=y_train.shape[1])\n",
    "model.load_weights(args.save_path+ args.dataset)\n",
    "\n",
    "explainer = Explainer(model=model)\n",
    "embeds = model.embedding((features_tensor,support_tensor)).numpy()\n",
    "\n",
    "all_label = np.logical_or(y_train,np.logical_or(y_val,y_test))\n",
    "single_label = np.argmax(all_label,axis=-1)\n",
    "hops = len(args.hiddens.split('-'))\n",
    "extractor = Extractor(adj,features,edge_label_matrix,embeds,all_label,hops)\n",
    "if args.setting==1:\n",
    "    if args.dataset=='syn3':\n",
    "        allnodes = [i for i in range(511,871,6)]\n",
    "    elif args.dataset=='syn4':\n",
    "        allnodes = [i for i in range(511,800,1)]\n",
    "    else:\n",
    "        allnodes = [i for i in range(400,700,5)] # setting from their original paper\n",
    "elif args.setting==2:\n",
    "    allnodes = [i for i in range(single_label.shape[0]) if single_label[i] ==1]\n",
    "elif args.setting==3:\n",
    "    if args.dataset == 'syn2':\n",
    "        allnodes = [i for i in range(single_label.shape[0]) if single_label[i] != 0 and single_label[i] != 4]\n",
    "    else:\n",
    "        allnodes = [i for i in range(single_label.shape[0]) if single_label[i] != 0]\n",
    "\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=args.elr)\n",
    "clip_value_min = -2.0\n",
    "clip_value_max = 2.0\n",
    "\n",
    "sub_support_tensors = []\n",
    "sub_label_tensors = []\n",
    "sub_features = []\n",
    "sub_embeds = []\n",
    "sub_adjs = []\n",
    "sub_edge_labels = []\n",
    "sub_labels = []\n",
    "remap = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "for node in allnodes:\n",
    "    sub_adj,sub_feature, sub_embed, sub_label,sub_edge_label_matrix = extractor.subgraph(node)\n",
    "    remap[node]=len(sub_adjs)\n",
    "    sub_support = preprocess_adj(sub_adj)\n",
    "    sub_support_tensor = tf.cast(tf.SparseTensor(*sub_support),tf.float32)\n",
    "    sub_label_tensor = tf.convert_to_tensor(sub_label,dtype=tf.float32)\n",
    "\n",
    "    sub_adjs.append(sub_adj)\n",
    "    sub_features.append(tf.cast(sub_feature,tf.float32))\n",
    "    sub_embeds.append(sub_embed)\n",
    "    sub_labels.append(sub_label)\n",
    "    sub_edge_labels.append(sub_edge_label_matrix)\n",
    "    sub_label_tensors.append(sub_label_tensor)\n",
    "    sub_support_tensors.append(sub_support_tensor)\n",
    "best_auc = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def plot(node,label):\n",
    "    after_adj_dense = explainer.masked_adj.numpy()\n",
    "    after_adj = coo_matrix(after_adj_dense)\n",
    "\n",
    "    rcd = np.concatenate([np.expand_dims(after_adj.row,-1),np.expand_dims(after_adj.col,-1),np.expand_dims(after_adj.data,-1)],-1)\n",
    "    pos_edges = []\n",
    "    filter_edges = []\n",
    "    edge_weights = after_adj.data\n",
    "    sorted_edge_weights = np.sort(edge_weights)\n",
    "    thres_index = max(int(edge_weights.shape[0]-12),0)\n",
    "    thres = sorted_edge_weights[thres_index]\n",
    "    filter_thres_index = min(thres_index,max(int(edge_weights.shape[0]-edge_weights.shape[0]/2),edge_weights.shape[0]-100))\n",
    "    # filter_thres_index = min(thres_index,max(int(edge_weights.shape[0]-edge_weights.shape[0]/4),edge_weights.shape[0]-100))\n",
    "    filter_thres = sorted_edge_weights[filter_thres_index]\n",
    "    filter_nodes =set()\n",
    "\n",
    "    # print(sorted_edge_weights)\n",
    "#     print('thres',thres)\n",
    "    for r,c,d in rcd:\n",
    "        r = int(r)\n",
    "        c = int(c)\n",
    "        if d>=thres:\n",
    "            pos_edges.append((r,c))\n",
    "        if d>filter_thres:\n",
    "            filter_edges.append((r,c))\n",
    "            filter_nodes.add(r)\n",
    "            filter_nodes.add(c)\n",
    "\n",
    "    num_nodes = sub_adj.shape[0]\n",
    "    G = nx.Graph()\n",
    "    G.add_nodes_from(range(num_nodes))\n",
    "    G.add_edges_from(filter_edges)\n",
    "\n",
    "    for cc in nx.connected_components(G):\n",
    "        if 0 in cc:\n",
    "            G = G.subgraph(cc).copy()\n",
    "            break\n",
    "\n",
    "    pos_edges = [(u, v) for (u, v) in pos_edges if u in G.nodes() and v in G.nodes()]\n",
    "    pos = nx.kamada_kawai_layout(G)\n",
    "\n",
    "    colors = ['orange', 'red', 'green', 'blue', 'maroon', 'brown', 'darkslategray', 'paleturquoise', 'darksalmon',\n",
    "              'slategray', 'mediumseagreen', 'mediumblue', 'orchid', ]\n",
    "    if args.dataset=='syn3':\n",
    "        colors = ['orange', 'blue']\n",
    "\n",
    "\n",
    "    if args.dataset=='syn4':\n",
    "        colors = ['orange', 'black','black','black','blue']\n",
    "\n",
    "\n",
    "    # nodes\n",
    "    labels = label#.numpy()\n",
    "    max_label = np.max(labels)+1\n",
    "#     print(max_label)\n",
    "\n",
    "    nmb_nodes = after_adj_dense.shape[0]\n",
    "    label2nodes= []\n",
    "    for i in range(max_label):\n",
    "    \tlabel2nodes.append([])\n",
    "    for i in range(nmb_nodes):\n",
    "    \tlabel2nodes[labels[i]].append(i)\n",
    "\n",
    "    for i in range(max_label):\n",
    "        node_filter = []\n",
    "        for j in range(len(label2nodes[i])):\n",
    "            if label2nodes[i][j] in G.nodes():\n",
    "                node_filter.append(label2nodes[i][j])\n",
    "        nx.draw_networkx_nodes(G, pos,\n",
    "                               nodelist=node_filter,\n",
    "                               node_color=colors[i % len(colors)],\n",
    "                               node_size=500)\n",
    "\n",
    "    nx.draw_networkx_nodes(G, pos,\n",
    "                           nodelist=[0],\n",
    "                           node_color=colors[labels[0]],\n",
    "                           node_size=1000)\n",
    "\n",
    "    nx.draw_networkx_edges(G, pos, width=7, alpha=0.5, edge_color='grey')\n",
    "\n",
    "    nx.draw_networkx_edges(G, pos,\n",
    "                           edgelist=pos_edges,\n",
    "                           width=7, alpha=0.5)\n",
    "\n",
    "\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "#     plt.savefig('./vis/'+args.dataset+'/P'+str(node)+'.png')\n",
    "    plt.clf()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train():\n",
    "    print('extract sub graphs done')\n",
    "    epochs = args.eepochs\n",
    "    for epoch in tqdm(range(epochs)):\n",
    "        train_accs = []\n",
    "        loss = 0\n",
    "        pred_loss = 0\n",
    "        lap_loss = 0\n",
    "        tmp = float(1.0*np.power(0.05,epoch/epochs))\n",
    "        with tf.GradientTape() as tape:\n",
    "            for i in range(len(allnodes)):\n",
    "                output = model.call((sub_features[i],sub_support_tensors[i]),training=False)\n",
    "                train_acc = accuracy(output, sub_label_tensors[i])\n",
    "                train_accs.append(float(train_acc))\n",
    "                pred_label = tf.argmax(output, 1)\n",
    "\n",
    "                x = sub_features[i]\n",
    "                adj = sub_adjs[i]\n",
    "                nodeid = 0\n",
    "                embed = sub_embeds[i]\n",
    "                pred = explainer((x,adj,nodeid,embed,tmp),training=True)\n",
    "                l,pl,ll = explainer.loss(pred, pred_label, sub_label_tensor, 0)\n",
    "                loss += l\n",
    "                pred_loss += pl\n",
    "                lap_loss += ll\n",
    "            train_variables = []\n",
    "            for para in explainer.trainable_variables:\n",
    "                if para.name.startswith('explainer'):\n",
    "                    train_variables.append(para)\n",
    "        grads = tape.gradient(loss, train_variables)\n",
    "        cliped_grads = [tf.clip_by_value(t, clip_value_min, clip_value_max) for t in grads]\n",
    "        optimizer.apply_gradients(zip(cliped_grads, train_variables))\n",
    "        explainer.save_weights(args.save_path + 'expaliner_'+args.dataset)\n",
    "\n",
    "\n",
    "reals = []\n",
    "preds = []\n",
    "def acc(sub_adj,sub_edge_label):\n",
    "    real = []\n",
    "    pred = []\n",
    "    sub_edge_label = sub_edge_label.todense()\n",
    "    mask = explainer.masked_adj.numpy()\n",
    "    for r,c in list(zip(sub_adj.row,sub_adj.col)):\n",
    "        d = sub_edge_label[r,c] + sub_edge_label[c,r]\n",
    "        if d==0:\n",
    "            real.append(0)\n",
    "        else:\n",
    "            real.append(1)\n",
    "        pred.append(mask[r][c]+mask[c][r])\n",
    "    reals.extend(real)\n",
    "    preds.extend(pred)\n",
    "\n",
    "    if len(np.unique(real))==1 or len(np.unique(pred))==1:\n",
    "        return -1\n",
    "    return roc_auc_score(real,pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def explain_test(node,needplot=True):\n",
    "    newid = remap[node]\n",
    "    sub_adj, sub_feature, sub_embed, sub_label, sub_edge_label =  sub_adjs[newid],sub_features[newid],sub_embeds[newid],sub_labels[newid],sub_edge_labels[newid]\n",
    "\n",
    "    nodeid = 0\n",
    "    explainer((sub_feature,sub_adj,nodeid,sub_embed,1.0),training=False)\n",
    "    label = np.argmax(sub_label,-1)\n",
    "    if needplot:\n",
    "        plot(node,label)\n",
    "    acc(sub_adj,sub_edge_label)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|          | 0/10 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extract sub graphs done\n",
      "WARNING:tensorflow:Layer explainer is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
      "\n",
      "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
      "\n",
      "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [00:12<00:00,  1.26s/it]\n"
     ]
    }
   ],
   "source": [
    "train()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7fcf7c3da780>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "explainer.load_weights(args.save_path + 'expaliner_'+args.dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node  400 auc 1.0\n",
      "node  405 auc 1.0\n",
      "node  410 auc 1.0\n",
      "node  415 auc 1.0\n",
      "node  420 auc 1.0\n",
      "node  425 auc 1.0\n",
      "node  430 auc 0.9998598780378443\n",
      "node  435 auc 0.9998754758601059\n",
      "node  440 auc 0.9998928077455049\n",
      "node  445 auc 0.9999016886421467\n",
      "node  450 auc 0.999906548665414\n",
      "node  455 auc 0.9998415874603969\n",
      "node  460 auc 0.999849133354939\n",
      "node  465 auc 0.9998539909149903\n",
      "node  470 auc 0.9998600162086496\n",
      "node  475 auc 0.9998039597598949\n",
      "node  480 auc 0.9998171623598245\n",
      "node  485 auc 0.9998252795773542\n",
      "node  490 auc 0.9997808457470806\n",
      "node  495 auc 0.9997864489837862\n",
      "node  500 auc 0.999742476505515\n",
      "node  505 auc 0.9996990374525251\n",
      "node  510 auc 0.9996655472616831\n",
      "node  515 auc 0.9996827175946722\n",
      "node  520 auc 0.9996992650601318\n",
      "node  525 auc 0.9997075379952156\n",
      "node  530 auc 0.9996822268970965\n",
      "node  535 auc 0.9996932610457452\n",
      "node  540 auc 0.9997042905325908\n",
      "node  545 auc 0.9997118138407003\n",
      "node  550 auc 0.9997204226301561\n",
      "node  555 auc 0.9997271731473224\n",
      "node  560 auc 0.9996955652490004\n",
      "node  565 auc 0.9997034939382016\n",
      "node  570 auc 0.9997093546123874\n",
      "node  575 auc 0.9997129192677047\n",
      "node  580 auc 0.9996859493078312\n",
      "node  585 auc 0.9996899309003641\n",
      "node  590 auc 0.9996989272340906\n",
      "node  595 auc 0.9997064046139644\n",
      "node  600 auc 0.9997146440622822\n",
      "node  605 auc 0.9997196496923091\n",
      "node  610 auc 0.9997259361969455\n",
      "node  615 auc 0.9997306177671474\n",
      "node  620 auc 0.999735296189939\n",
      "node  625 auc 0.9997100012337172\n",
      "node  630 auc 0.9996842967198339\n",
      "node  635 auc 0.9996919771768104\n",
      "node  640 auc 0.9997009268620611\n",
      "node  645 auc 0.9997128952962243\n",
      "node  650 auc 0.9997151332979706\n",
      "node  655 auc 0.999718758259031\n",
      "node  660 auc 0.999724301622422\n",
      "node  665 auc 0.9997034793026115\n",
      "node  670 auc 0.9997064836583687\n",
      "node  675 auc 0.9997125682043715\n",
      "node  680 auc 0.9997159197854204\n",
      "node  685 auc 0.9997202702276865\n",
      "node  690 auc 0.9997242790291511\n",
      "node  695 auc 0.9997280786367185\n",
      "mean acc 0.9997280786367185\n"
     ]
    }
   ],
   "source": [
    "\n",
    "reals= []\n",
    "preds = []\n",
    "for node in allnodes:\n",
    "    explain_test(node,needplot=False)\n",
    "    auc = roc_auc_score(reals, preds)\n",
    "    print('node ',node, 'auc',auc)\n",
    "\n",
    "print('mean acc',auc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "explain_test(allnodes[40],needplot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf2",
   "language": "python",
   "name": "tf2"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}