BA-community.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='syn2'\n",
    "args.elr = 0.003\n",
    "args.eepochs = 20\n",
    "args.coff_size = 0.05\n",
    "args.budget = -1.0\n",
    "args.coff_ent = 1.0\n",
    "args.sample_bias = 0.5\n",
    "\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",
    "    t0 = args.coff_t0\n",
    "    t1 = args.coff_te\n",
    "    epochs = args.eepochs\n",
    "    for epoch in range(epochs):\n",
    "        train_accs = []\n",
    "        loss = 0\n",
    "        pred_loss = 0\n",
    "        lap_loss = 0\n",
    "        tmp = 1.0\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",
    "\n",
    "        print('pred_loss_mean',np.mean(pred_loss.numpy()))\n",
    "\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": "stdout",
     "output_type": "stream",
     "text": [
      "extract sub graphs done\n",
      "pred_loss_mean 232.4529\n",
      "pred_loss_mean 250.8273\n",
      "pred_loss_mean 286.36267\n",
      "pred_loss_mean 331.67468\n",
      "pred_loss_mean 374.98135\n",
      "pred_loss_mean 379.18094\n",
      "pred_loss_mean 345.51715\n",
      "pred_loss_mean 301.1028\n",
      "pred_loss_mean 258.0067\n",
      "pred_loss_mean 322.62323\n",
      "pred_loss_mean 339.846\n",
      "pred_loss_mean 251.70137\n",
      "pred_loss_mean 133.5112\n",
      "pred_loss_mean 120.812675\n",
      "pred_loss_mean 149.29082\n",
      "pred_loss_mean 163.96597\n",
      "pred_loss_mean 169.4898\n",
      "pred_loss_mean 169.7347\n",
      "pred_loss_mean 163.67268\n",
      "pred_loss_mean 142.09462\n"
     ]
    }
   ],
   "source": [
    "train()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f6a30119fd0>"
      ]
     },
     "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 0.9919786096256685\n",
      "node  410 auc 0.9876941821504722\n",
      "node  415 auc 0.9883202752559798\n",
      "node  420 auc 0.9785652762396948\n",
      "node  425 auc 0.9829293219635272\n",
      "node  430 auc 0.9606771345486644\n",
      "node  435 auc 0.9610502019619156\n",
      "node  440 auc 0.9614795872042283\n",
      "node  445 auc 0.9619992984148562\n",
      "node  450 auc 0.9637875844082657\n",
      "node  455 auc 0.965424182638106\n",
      "node  460 auc 0.9640292979400514\n",
      "node  465 auc 0.9655365714477526\n",
      "node  470 auc 0.968429017409357\n",
      "node  475 auc 0.9695623130318609\n",
      "node  480 auc 0.9671428682439895\n",
      "node  485 auc 0.967665459949877\n",
      "node  490 auc 0.9684769868298401\n",
      "node  495 auc 0.9671248231676663\n",
      "node  500 auc 0.9657392250310817\n",
      "node  505 auc 0.9658961946306344\n",
      "node  510 auc 0.9659999017602772\n",
      "node  515 auc 0.9648449866296652\n",
      "node  520 auc 0.965488801881624\n",
      "node  525 auc 0.9660635766994559\n",
      "node  530 auc 0.9658874329958309\n",
      "node  535 auc 0.9659378790726282\n",
      "node  540 auc 0.9672137356903103\n",
      "node  545 auc 0.9690100546587609\n",
      "node  550 auc 0.9698543319308359\n",
      "node  555 auc 0.9700058567640181\n",
      "node  560 auc 0.9695205266465976\n",
      "node  565 auc 0.970204915797317\n",
      "node  570 auc 0.9705654434922727\n",
      "node  575 auc 0.9709766280009549\n",
      "node  580 auc 0.9719666474985624\n",
      "node  585 auc 0.9718501247377385\n",
      "node  590 auc 0.9715631578574462\n",
      "node  595 auc 0.9702120053374759\n",
      "node  600 auc 0.9673719123387263\n",
      "node  605 auc 0.9699920192341982\n",
      "node  610 auc 0.9701636212217705\n",
      "node  615 auc 0.9717464872172428\n",
      "node  620 auc 0.9714111586083339\n",
      "node  625 auc 0.9718048519781821\n",
      "node  630 auc 0.9702243549358086\n",
      "node  635 auc 0.9706754406790323\n",
      "node  640 auc 0.9707692351605505\n",
      "node  645 auc 0.9718121154579551\n",
      "node  650 auc 0.9730608773954037\n",
      "node  655 auc 0.9732315939218392\n",
      "node  660 auc 0.9735636950984603\n",
      "node  665 auc 0.973284127895728\n",
      "node  670 auc 0.9727071181331389\n",
      "node  675 auc 0.9726295267091188\n",
      "node  680 auc 0.971395851353747\n",
      "node  685 auc 0.9704976209481027\n",
      "node  690 auc 0.970795756974637\n",
      "node  695 auc 0.9709094704527026\n",
      "mean acc 0.9709094704527026\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": 10,
   "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[1],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
}