sbe_examples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import pickle\n",
    "from IMDBModel import IMDBModel\n",
    "from embedding import Embedding\n",
    "from keras.preprocessing import sequence\n",
    "import time\n",
    "from glove_utils import load_embedding\n",
    "from data_utils import IMDBDataset\n",
    "from pprint import pprint\n",
    "from explainers import SBE, LIMEExplainer\n",
    "from textblob import TextBlob\n",
    "from parsers import StanfordParser\n",
    "from utils import preprocess_text, get_tokens\n",
    "from collections import OrderedDict\n",
    "from copy import deepcopy\n",
    "import seaborn as sns\n",
    "import pandas as pd \n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load GloVe vectors used by the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading GLoVe...\n",
      "Loaded 400002 word vectors in 16.880470 seconds\n"
     ]
    }
   ],
   "source": [
    "# Load main vectors\n",
    "print('Loading GLoVe...')\n",
    "start_time = time.time()\n",
    "MODEL_EMBEDDING_FILENAME = 'data/glove.6B.100d.txt'\n",
    "m_word2index, m_index2word, m_index2embedding = load_embedding(MODEL_EMBEDDING_FILENAME)\n",
    "print('Loaded %s word vectors in %f seconds' % (len(m_word2index), time.time()-start_time))\n",
    "model_embedding = Embedding(m_word2index, m_index2word, m_index2embedding)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    }
   ],
   "source": [
    "# Load model\n",
    "imdb_model = IMDBModel('models/lstm_model.h5', model_embedding)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load IMDB data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data...\n",
      "Data loaded.\n"
     ]
    }
   ],
   "source": [
    "# Load data\n",
    "maxlen = 200\n",
    "batch_size = 32\n",
    "print('Loading data...')\n",
    "(train_text, x_train, y_train), (test_text, x_test, y_test) = IMDBDataset.load_data()\n",
    "x_train = sequence.pad_sequences(x_train, maxlen=maxlen, padding = 'pre', truncating = 'pre')\n",
    "x_test = sequence.pad_sequences(x_test, maxlen=maxlen, padding = 'pre', truncating = 'pre')\n",
    "print('Data loaded.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Explainer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sbe = SBE(imdb_model, m = 1000, SIGMA = 2/5)\n",
    "lime_explainer = LIMEExplainer(imdb_model, nsamples = 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'very well done acting and directing . this is a cross between the last don and godfather 2 . one large plus for this production is that it is claimed to be a true story of joseph bonanno . with a better music score to create mood , it could have been a rival for both godfather movies .'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "positive_text = preprocess_text(test_text[8451])\n",
    "positive_text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.87889206"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imdb_model.predict(positive_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'when i voted my 1 for this film i noticed that 75 people voted the same out of 146 total votes . that means that half the people that voted for this film feel its truly terrible . i saw this not long ago at a film festival and i was really unimpressed by its poor execution . the cinematography is unwatchable , the sound is bad , the story is cut and pasted from many other movies , and the acting is dreadful . this movie is basically a poor rip - off of three other films . no wonder this was never released in the usa .'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "negative_text =  preprocess_text(test_text[12506])\n",
    "negative_text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0016409671"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imdb_model.predict(negative_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_importance(feature_name, ranked_tokens, tokens_ranking, values, display_count):\n",
    "    data = {feature_name : ranked_tokens[:display_count], \"importance\": values[tokens_ranking][:display_count]}\n",
    "    df = pd.DataFrame(data)\n",
    "    # plot\n",
    "    sns.set_color_codes(\"deep\")\n",
    "    ax = sns.barplot(y=df.index, x =\"importance\", data=df, orient = 'h', color=\"b\", ci = None)\n",
    "    ax.set_yticklabels(df[feature_name])\n",
    "    ax.set_ylabel(feature_name)\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_sentiment(feature_name, ranked_tokens, tokens_ranking, values, display_count):\n",
    "    data = {feature_name : ranked_tokens[:display_count//2] + ranked_tokens[-display_count//2:], \n",
    "    \"sentiment\": values[tokens_ranking][:display_count//2].tolist() + values[tokens_ranking][-display_count//2:].tolist()}\n",
    "    # order from most positive to most negative for barplot\n",
    "    data[feature_name] = list(reversed(data[feature_name]))\n",
    "    data[\"sentiment\"] = list(reversed(data[\"sentiment\"]))\n",
    "    df = pd.DataFrame(data)\n",
    "    colors = ['r' if value < 0 else 'g' for value in df.sentiment]\n",
    "    # plot\n",
    "    sns.set_color_codes(\"pastel\")\n",
    "    ax = sns.barplot(y=df.index, x =\"sentiment\", data=df, orient = 'h', palette=colors, ci = None)\n",
    "    ax.set_yticklabels(df[feature_name])\n",
    "    ax.set_ylabel(feature_name)\n",
    "    return ax "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_plot(ax, fig_name, save_path = 'figures/explanations/'):\n",
    "    fig = ax.get_figure()\n",
    "    fig.savefig(save_path+fig_name, dpi = 200, bbox_inches = 'tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Word Level Explanations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Positive Sentiment Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Importance ranking\n",
    "words_ranking , ranked_words , values  = sbe.explain_text_words(positive_text, rank_by_importance = True )\n",
    "ax = plot_importance('word', ranked_words, words_ranking, values, display_count = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plot(ax,'sbewordpositiveimportance.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sentiment ranking\n",
    "words_ranking , ranked_words , values  = sbe.explain_text_words(positive_text, rank_by_importance = False)\n",
    "ax = plot_sentiment('word', ranked_words, words_ranking, values, display_count = 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plot(ax,'sbewordpositivesentiment.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_ranking, ranked_words, weights, explanation = lime_explainer.explain(positive_text, 20, return_weights= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = lime_explainer.plot_weights(weights,explanation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plot(ax, 'limewordpositive.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Negative Sentiment Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importance ranking\n",
    "words_ranking , ranked_words , values  = sbe.explain_text_words(negative_text, rank_by_importance = True )\n",
    "ax = plot_importance('word', ranked_words, words_ranking, values, display_count = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plot(ax,'sbewordnegativeimportance.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sentiment ranking\n",
    "words_ranking , ranked_words , values  = sbe.explain_text_words(negative_text, rank_by_importance = False)\n",
    "ax = plot_sentiment('word', ranked_words, words_ranking, values, display_count = 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plot(ax,'sbewordnegativesentiment.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_ranking, ranked_words, weights, explanation = lime_explainer.explain(negative_text, 20, return_weights= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = lime_explainer.plot_weights(weights,explanation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plot(ax,'limewordnegative.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sentence Level Explanations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_sentences(text):\n",
    "    sentences = list(map(str,TextBlob(text).sentences))\n",
    "    return sentences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Positive Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importance Ranking\n",
    "sentence_ranking , ranked_sentences, values = sbe.explain_tokens(get_sentences(positive_text), rank_by_importance = True)\n",
    "ax = plot_importance('sentence', ranked_sentences, sentence_ranking, values, display_count = len(sentence_ranking))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sentiment Ranking\n",
    "sentence_ranking , ranked_sentences, values = sbe.explain_tokens(get_sentences(positive_text), rank_by_importance = False)\n",
    "ax = plot_sentiment('sentence', ranked_sentences, sentence_ranking, values, display_count = len(sentence_ranking))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plot(ax, 'sbesentencepositivesentiment.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Negative Sentiment Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importance ranking\n",
    "sentence_ranking , ranked_sentences, values = sbe.explain_tokens(get_sentences(negative_text), rank_by_importance = True)\n",
    "ax = plot_importance('sentence', ranked_sentences, sentence_ranking, values, display_count = len(sentence_ranking))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sentiment Ranking\n",
    "sentence_ranking , ranked_sentences, values = sbe.explain_tokens(get_sentences(negative_text), rank_by_importance = False)\n",
    "ax = plot_sentiment('sentence', ranked_sentences, sentence_ranking, values, display_count = len(sentence_ranking))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_plot(ax, 'sbesentencenegativesentiment.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.06043263"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imdb_model.predict('that means that half the people that voted for this film feel its truly terrible .')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Phrase Level Explanations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_phrases(text):\n",
    "    parser = StanfordParser()\n",
    "    sentences = TextBlob(text).sentences\n",
    "    phrases = []\n",
    "    for sentence in sentences:\n",
    "        sentence = str(sentence)\n",
    "        phrases_in_sentence = parser.get_phrases(sentence, split_tags = ['S', 'SBAR','.'])\n",
    "        phrases.extend(phrases_in_sentence)\n",
    "    parser.close()\n",
    "    return phrases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Positive Sentiment Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse string:  (ROOT\n",
      "  (NP\n",
      "    (NP (RB very) (RB well))\n",
      "    (VP (VBN done)\n",
      "      (S\n",
      "        (VP (VBG acting)\n",
      "          (CC and)\n",
      "          (VBG directing))))\n",
      "    (. .)))\n",
      "parse string:  (ROOT\n",
      "  (S\n",
      "    (NP (DT this))\n",
      "    (VP (VBZ is)\n",
      "      (NP\n",
      "        (NP (DT a) (NN cross))\n",
      "        (PP (IN between)\n",
      "          (NP\n",
      "            (S\n",
      "              (NP (DT the) (JJ last))\n",
      "              (VP (VB don)))\n",
      "            (CC and)\n",
      "            (NP\n",
      "              (NP (NN godfather))\n",
      "              (NP (CD 2)))))))\n",
      "    (. .)))\n",
      "parse string:  (ROOT\n",
      "  (S\n",
      "    (NP\n",
      "      (NP (CD one))\n",
      "      (ADJP (JJ large)\n",
      "        (PP (CC plus)\n",
      "          (PP (IN for)\n",
      "            (NP (DT this) (NN production))))))\n",
      "    (VP (VBZ is)\n",
      "      (SBAR (IN that)\n",
      "        (S\n",
      "          (NP (PRP it))\n",
      "          (VP (VBZ is)\n",
      "            (VP (VBN claimed)\n",
      "              (S\n",
      "                (VP (TO to)\n",
      "                  (VP (VB be)\n",
      "                    (NP\n",
      "                      (NP (DT a) (JJ true) (NN story))\n",
      "                      (PP (IN of)\n",
      "                        (NP (NN joseph) (NN bonanno))))))))))))\n",
      "    (. .)))\n",
      "parse string:  (ROOT\n",
      "  (S\n",
      "    (PP (IN with)\n",
      "      (NP\n",
      "        (NP (DT a) (JJR better) (NN music) (NN score))\n",
      "        (SBAR\n",
      "          (S\n",
      "            (VP (TO to)\n",
      "              (VP (VB create)\n",
      "                (NP (NN mood))))))))\n",
      "    (, ,)\n",
      "    (NP (PRP it))\n",
      "    (VP (MD could)\n",
      "      (VP (VB have)\n",
      "        (VP (VBN been)\n",
      "          (NP\n",
      "            (NP (DT a) (NN rival))\n",
      "            (PP (IN for)\n",
      "              (NP (DT both) (NN godfather) (NNS movies)))))))\n",
      "    (. .)))\n",
      "Phrases:  ['very well done acting and directing .', 'this is a cross between ', 'the last don and godfather 2 .', 'one large plus for this production is ', 'that ', 'it is claimed ', 'to be a true story of joseph bonanno .', 'with a better music score ', 'to create mood , it could have been a rival for both godfather movies .']\n"
     ]
    }
   ],
   "source": [
    "positive_text_phrases = get_phrases(positive_text)\n",
    "print(\"Phrases: \", positive_text_phrases)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importance Ranking\n",
    "phrase_ranking , ranked_phrases, values = sbe.explain_tokens(positive_text_phrases, rank_by_importance = True)\n",
    "ax = plot_importance('phrase', ranked_phrases, phrase_ranking, values, display_count = len(phrase_ranking))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sentiment Ranking\n",
    "phrase_ranking , ranked_phrases, values = sbe.explain_tokens(positive_text_phrases, rank_by_importance = False)\n",
    "ax = plot_sentiment('phrase', ranked_phrases, phrase_ranking, values, display_count = len(phrase_ranking))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Negative Sentiment Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse string:  (ROOT\n",
      "  (S\n",
      "    (SBAR\n",
      "      (WHADVP (WRB when))\n",
      "      (S\n",
      "        (NP (FW i))\n",
      "        (VP (VBD voted)\n",
      "          (NP (PRP$ my))\n",
      "          (NP\n",
      "            (NP (CD 1))\n",
      "            (PP (IN for)\n",
      "              (NP (DT this) (NN film)))))))\n",
      "    (NP (FW i))\n",
      "    (VP (VBD noticed)\n",
      "      (SBAR (IN that)\n",
      "        (S\n",
      "          (NP (CD 75) (NNS people))\n",
      "          (VP (VBD voted)\n",
      "            (NP (DT the) (JJ same))\n",
      "            (PP (IN out))\n",
      "            (PP (IN of)\n",
      "              (NP (CD 146) (JJ total) (NNS votes)))))))\n",
      "    (. .)))\n",
      "parse string:  (ROOT\n",
      "  (S\n",
      "    (NP (DT that))\n",
      "    (VP (VBZ means)\n",
      "      (SBAR (IN that)\n",
      "        (S\n",
      "          (NP\n",
      "            (NP (PDT half) (DT the) (NNS people))\n",
      "            (SBAR\n",
      "              (WHNP (WDT that))\n",
      "              (S\n",
      "                (VP (VBD voted)\n",
      "                  (PP (IN for)\n",
      "                    (NP (DT this) (NN film)))))))\n",
      "          (VP (VB feel)\n",
      "            (S\n",
      "              (NP (PRP$ its))\n",
      "              (ADJP (RB truly) (JJ terrible)))))))\n",
      "    (. .)))\n",
      "parse string:  (ROOT\n",
      "  (S\n",
      "    (NP (LS i))\n",
      "    (VP (VBD saw)\n",
      "      (SBAR\n",
      "        (S\n",
      "          (NP (DT this))\n",
      "          (ADVP\n",
      "            (ADVP (RB not) (JJ long) (RB ago))\n",
      "            (PP (IN at)\n",
      "              (NP\n",
      "                (NP (DT a) (NN film) (NN festival))\n",
      "                (CC and)\n",
      "                (NP (FW i)))))\n",
      "          (VP (VBD was)\n",
      "            (ADJP (RB really) (JJ unimpressed))\n",
      "            (PP (IN by)\n",
      "              (NP (PRP$ its) (JJ poor) (NN execution)))))))\n",
      "    (. .)))\n",
      "parse string:  (ROOT\n",
      "  (S\n",
      "    (S\n",
      "      (NP (DT the) (NN cinematography))\n",
      "      (VP (VBZ is)\n",
      "        (ADJP (JJ unwatchable))))\n",
      "    (, ,)\n",
      "    (S\n",
      "      (NP (DT the) (NN sound))\n",
      "      (VP (VBZ is)\n",
      "        (ADJP (JJ bad))))\n",
      "    (, ,)\n",
      "    (S\n",
      "      (NP (DT the) (NN story))\n",
      "      (VP (VBZ is)\n",
      "        (VP (VBN cut)\n",
      "          (CC and)\n",
      "          (VBN pasted)\n",
      "          (PP (IN from)\n",
      "            (NP (JJ many) (JJ other) (NNS movies))))))\n",
      "    (, ,)\n",
      "    (CC and)\n",
      "    (S\n",
      "      (NP (DT the) (NN acting))\n",
      "      (VP (VBZ is)\n",
      "        (ADJP (JJ dreadful))))\n",
      "    (. .)))\n",
      "parse string:  (ROOT\n",
      "  (S\n",
      "    (NP (DT this) (NN movie))\n",
      "    (VP (VBZ is)\n",
      "      (ADVP (RB basically))\n",
      "      (NP\n",
      "        (NP (DT a) (JJ poor) (NN rip))\n",
      "        (: -)\n",
      "        (ADVP (IN off)\n",
      "          (PP (IN of)\n",
      "            (NP (CD three) (JJ other) (NNS films))))))\n",
      "    (. .)))\n",
      "parse string:  (ROOT\n",
      "  (S\n",
      "    (NP\n",
      "      (NP (DT no) (NN wonder))\n",
      "      (NP (DT this)))\n",
      "    (VP (VBD was)\n",
      "      (ADVP (RB never))\n",
      "      (VP (VBN released)\n",
      "        (PP (IN in)\n",
      "          (NP (DT the) (NN usa)))))\n",
      "    (. .)))\n",
      "Phrases:  ['when ', 'i voted my 1 for this film i noticed ', 'that ', '75 people voted the same out of 146 total votes .', 'that means ', 'that ', 'half the people ', 'that ', 'voted for this film feel ', 'its truly terrible .', 'i saw ', 'this not long ago at a film festival and i was really unimpressed by its poor execution .', 'the cinematography is unwatchable , ', 'the sound is bad , ', 'the story is cut and pasted from many other movies , and ', 'the acting is dreadful .', 'this movie is basically a poor rip - off of three other films .', 'no wonder this was never released in the usa .']\n"
     ]
    }
   ],
   "source": [
    "negative_text_phrases = get_phrases(negative_text)\n",
    "print(\"Phrases: \", negative_text_phrases)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importance Ranking\n",
    "phrase_ranking , ranked_phrases, values = sbe.explain_tokens(negative_text_phrases, rank_by_importance = True)\n",
    "ax = plot_importance('phrase', ranked_phrases, phrase_ranking, values, display_count = len(phrase_ranking))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sentiment Ranking\n",
    "phrase_ranking , ranked_phrases, values = sbe.explain_tokens(negative_text_phrases, rank_by_importance = False)\n",
    "ax = plot_sentiment('phrase', ranked_phrases, phrase_ranking, values, display_count = len(phrase_ranking))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imdb_model.predict(\"the cinematography is unwatchable.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare SBE with LIME using pseudo-adversarial example generation as proxy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predicted probabilities\n",
    "p_hat = imdb_model.model.predict(x_test, batch_size = 32).flatten()\n",
    "# predicted_ classes\n",
    "y_hat = np.where(p_hat >= 0.5, 1, 0)\n",
    "# indexes where the predictions were wrong\n",
    "wrong_indexes = np.where(y_hat != y_test)[0]\n",
    "# indexes where the prediction were correct\n",
    "correct_indexes = np.where(y_hat == y_test)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_success_rate(adv_dists):\n",
    "    adv_dists = np.array(adv_dists)\n",
    "    successful_indexes = np.where(adv_dists>0)[0]\n",
    "    success_rate = len(successful_indexes) / len(adv_dists)\n",
    "    return success_rate\n",
    "\n",
    "def get_success_rate_at_threshold(adv_dists, threshold):\n",
    "    adv_dists = np.array(adv_dists)\n",
    "    successful_indexes = np.where((adv_dists>0) & (adv_dists <= threshold))[0]\n",
    "    success_rate = len(successful_indexes) / len(adv_dists)\n",
    "    return success_rate\n",
    "\n",
    "def get_success_rates_at_thresholds(adv_dists, thresholds):\n",
    "    success_rates = dict()\n",
    "    for threshold in thresholds:\n",
    "        success_rate_at_threshold = get_success_rate_at_threshold(adv_dists,threshold)\n",
    "        success_rates[threshold] = success_rate_at_threshold\n",
    "    return success_rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_DIST = 0.3  # not more than 30% of words should be removed\n",
    "def create_adversary(model, tokens, token_ranking, y):\n",
    "    '''\n",
    "    Generate a pseudo-adversarial example by iteratively removing the word tokens\n",
    "    that contributed the most to class y. These are given by token_ranking.\n",
    "    '''\n",
    "    max_perturbation_size = int(MAX_DIST*len(tokens))\n",
    "    for i in range(max_perturbation_size):\n",
    "        kept_positions = sorted(token_ranking[i+1:])\n",
    "        adv_tokens = np.array(tokens)[kept_positions].tolist()\n",
    "        adv_text = ' '.join(adv_tokens)\n",
    "        if model.predict_class(adv_text) !=y :\n",
    "            print(\"Attack succeeded by dropping %d words\" % (i+1))\n",
    "            removed_tokens = [tokens[j]  for j in token_ranking[:i+1]]\n",
    "            return adv_text, i+1, removed_tokens\n",
    "    print(\"Attack failed\")\n",
    "    return ' '.join(tokens), 0, []\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(23)\n",
    "sample_size = 500\n",
    "sampled_indexes = np.random.choice(correct_indexes, sample_size, replace = False)\n",
    "sbe_adv_dists = []\n",
    "lime_adv_dists = []\n",
    "for (i,index) in enumerate(sampled_indexes):\n",
    "    print(\"#\",i,\" index = \", index, flush = True)\n",
    "    text = imdb_model.preprocess_text(test_text[index])\n",
    "    y = imdb_model.predict_class(text)\n",
    "    tokens = get_tokens(text)\n",
    "    print(\"Original prediction = \", imdb_model.predict(text))\n",
    "    print()\n",
    "    print(text)\n",
    "    print()\n",
    "    ########## SBE explanation\n",
    "    print(\"Getting SBE explanation...\")\n",
    "    words_ranking, ranked_words, values = sbe.explain_tokens(tokens, rank_by_importance = False)\n",
    "    if y == 1:\n",
    "        words_ranking = np.flip(words_ranking)\n",
    "        ranked_words = list(reversed(ranked_words))\n",
    "    adv_text , perturbation_size, removed_words = create_adversary(imdb_model, tokens, words_ranking, y)\n",
    "    print(\"Perturbation size = \", perturbation_size, ' out of  ', len(tokens), ' words.')\n",
    "    sbe_adv_dist = perturbation_size / len(tokens)\n",
    "    print(\"SBE adversarial distance = \", sbe_adv_dist)\n",
    "    sbe_adv_dists.append(sbe_adv_dist)\n",
    "    print(\"Removed words: \", removed_words)\n",
    "    print(\"New prediction = \", imdb_model.predict(adv_text))    \n",
    "    \n",
    "    ########### LIME explanation\n",
    "    print(\"Getting LIME explanation...\")\n",
    "    _, _ , weights, _ = lime_explainer.explain(text,len(tokens), return_weights= True)\n",
    "    # order weights from smallest to largest (most negative to most positive) instead of by absolute value\n",
    "    weights =  sorted(weights.items(),key = lambda x: x[1]) \n",
    "    words_ranking = [word for (word,weight) in weights]\n",
    "    ranked_words = [tokens[j] for j in words_ranking]\n",
    "    if y == 1:\n",
    "        words_ranking = np.flip(words_ranking)\n",
    "        ranked_words = list(reversed(ranked_words))\n",
    "    adv_text , perturbation_size, removed_words = create_adversary(imdb_model, tokens, words_ranking, y)\n",
    "    print(\"LIME Perturbation size = \", perturbation_size, ' out of  ', len(tokens), ' words.')\n",
    "    lime_adv_dist = perturbation_size / len(tokens)\n",
    "    print(\"LIME adversarial distance = \", lime_adv_dist)\n",
    "    lime_adv_dists.append(lime_adv_dist)\n",
    "    print(\"Removed words: \", removed_words)\n",
    "    print(\"New prediction = \", imdb_model.predict(adv_text))   \n",
    "    \n",
    "    \n",
    "    ### Monitor current success rates\n",
    "    if i % 20 == 0 :\n",
    "        thresholds = np.arange(0.05, MAX_DIST+0.05, 0.05)\n",
    "        current_sbe_success_rates = get_success_rates_at_thresholds(sbe_adv_dists,thresholds)\n",
    "        print(\"Current SBE success rates: \")\n",
    "        print(current_sbe_success_rates)\n",
    "        current_lime_success_rates = get_success_rates_at_thresholds(lime_adv_dists,thresholds)\n",
    "        print(\"Current LIME success rates: \")\n",
    "        print(current_lime_success_rates)\n",
    "    \n",
    "    print(80*'-')\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "experiment_handle = 'sbevslime'\n",
    "dir_name = 'results/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create directory if it does not exits\n",
    "if not os.path.exists(dir_name):\n",
    "    print(\"Created directory\")\n",
    "    os.mkdir(dir_name)\n",
    "# Pickle attack results\n",
    "f = open(dir_name + experiment_handle+'.pickle', 'wb')\n",
    "pickle.dump((sbe_adv_dists,lime_adv_dists),f)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(dir_name + experiment_handle+'.pickle', 'rb')\n",
    "(sbe_adv_dists, lime_adv_dists) = pickle.load(f)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SBE success rate: \n",
      "0.956\n",
      "LIME success rate: \n",
      "0.84\n"
     ]
    }
   ],
   "source": [
    "sbe_success_rate = get_success_rate(sbe_adv_dists)\n",
    "print(\"SBE success rate: \")\n",
    "print(sbe_success_rate)\n",
    "print(\"LIME success rate: \")\n",
    "lime_success_rate = get_success_rate(lime_adv_dists)\n",
    "print(lime_success_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0.05: 0.614, 0.1: 0.796, 0.15000000000000002: 0.864, 0.2: 0.916, 0.25: 0.938, 0.3: 0.956}\n",
      "{0.05: 0.484, 0.1: 0.642, 0.15000000000000002: 0.734, 0.2: 0.78, 0.25: 0.818, 0.3: 0.84}\n"
     ]
    }
   ],
   "source": [
    "thresholds = np.arange(0.05, MAX_DIST+0.05, 0.05)\n",
    "sbe_success_rates = get_success_rates_at_thresholds(sbe_adv_dists,thresholds)\n",
    "print(sbe_success_rates)\n",
    "lime_success_rates = get_success_rates_at_thresholds(lime_adv_dists,thresholds)\n",
    "print(lime_success_rates)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot success rates\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as mticker\n",
    "from matplotlib.ticker import PercentFormatter\n",
    "plt.xlabel('size of adversarial example')\n",
    "plt.ylabel('success rate')\n",
    "plt.ylim((0,1.1))\n",
    "plt.plot(sbe_success_rates.keys(), sbe_success_rates.values(), marker='o', label = 'SBE')\n",
    "plt.plot(lime_success_rates.keys(), lime_success_rates.values(), marker='o', label = 'LIME')\n",
    "plt.gca().yaxis.set_major_formatter(PercentFormatter(1))\n",
    "plt.gca().xaxis.set_major_formatter(PercentFormatter(1))\n",
    "plt.legend(loc='lower right')\n",
    "if not os.path.exists('figures/explanations/'):\n",
    "    os.mkdir('figures/explanations/')\n",
    "plt.savefig('figures/explanations/SBEvsLIME.png', dpi=300)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}