Step3_Robust_classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Robust classification\n",
    "- classification performance with different training data\n",
    "> original <br>\n",
    "> original + ctf_by_human <br>\n",
    "> original + ctf_by_auto_generated <br>\n",
    "- classification performance with different number of causal words being substitued <br>\n",
    "> Performance of only substitute causal words <br>\n",
    "> Performance of substituting all top terms <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import io, time\n",
    "from itertools import combinations, cycle, product\n",
    "from IPython.display import display\n",
    "\n",
    "import nltk\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle, random, re\n",
    "from collections import Counter\n",
    "from PyDictionary import PyDictionary\n",
    "dictionary=PyDictionary()\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "pd.set_option('max_colwidth', -1) # change None to -1\n",
    "\n",
    "import sklearn\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import KFold, cross_val_score, train_test_split\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "random.seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Generate_counterfactual import run_counterfactual\n",
    "from Classification import get_top_terms\n",
    "data_path = 'my_data_path'   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Counterfactual:\n",
    "    def __init__(self, df_train, df_test, moniker):\n",
    "        display(df_train.head(1))\n",
    "        self.moniker = moniker\n",
    "        self.train = df_train\n",
    "        self.test = df_test\n",
    "        \n",
    "def load_data(moniker):\n",
    "    if(moniker == 'kindle'):\n",
    "        ds = pickle.load(open(data_path+\"kindle_ct/ds_kindle.pkl\", \"rb\"))\n",
    "    elif(moniker == 'imdb'):\n",
    "        ds = pickle.load(open(data_path+\"imdb_ct/ds_imdb.pkl\", \"rb\"))\n",
    "    elif(moniker == 'imdb_sents'):\n",
    "        ds = pickle.load(open(data_path+\"imdb_ct/split_sents/ds_imdb.pkl\", \"rb\"))\n",
    "    \n",
    "    return ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def organize_data(ds, limit=''):\n",
    "    \"\"\"\n",
    "    Organize data for easy use in the evaluation\n",
    "    'original','original+ctf_by_predicted_causal','original+ctf_by_annotated_causal','original+ctf_by_all_causal','original+ctf_by_human'\n",
    "    \n",
    "    \"\"\"\n",
    "    train_data = {}\n",
    "    if(limit == 'ct'): # only those have counterfactuals as original data\n",
    "        ds.train['len_ct_text_causal'] = ds.train['ct_text_causal'].apply(lambda x: len(x.strip()))\n",
    "        df_select = ds.train[ds.train['len_ct_text_causal'] > 0]\n",
    "        train_data['original'] = {'text':df_select.text.values, 'label':df_select.label.values}\n",
    "    else:\n",
    "        train_data['original'] = {'text':ds.train.text.values, 'label':ds.train.label.values}\n",
    "    \n",
    "    if(ds.moniker == 'imdb'):\n",
    "        train_data['ctf_by_human'] = {'text':ds.train.ct_text_amt.values, 'label':ds.train.ct_label.values}\n",
    "        train_data['original+ctf_by_human'] = {'text':list(train_data['original']['text'])+list(ds.train.ct_text_amt.values), \n",
    "                                          'label':list(train_data['original']['label'])+list(ds.train.ct_label.values)}\n",
    "    \n",
    "    elif(ds.moniker == 'imdb_sents'):\n",
    "        train_data['ctf_by_human'] = {'text':ds.train_ct.text.values, 'label':ds.train_ct.label.values}\n",
    "        train_data['original+ctf_by_human'] = {'text':list(train_data['original']['text'])+list(ds.train_ct.text.values), \n",
    "                                          'label':list(train_data['original']['label'])+list(ds.train_ct.label.values)}\n",
    "        \n",
    "    for flag, col in zip(['predicted_causal','annotated_causal','all_causal'],['identified_causal','causal','all_causal']):\n",
    "        ds.train['len_ct_text_'+col] = ds.train['ct_text_'+col].apply(lambda x: len(x.strip()))\n",
    "        df_train_ct_text_flag = ds.train[ds.train['len_ct_text_'+col] > 0]\n",
    "        train_data['ctf_'+flag] = {'text':df_train_ct_text_flag['ct_text_'+col].values, 'label':df_train_ct_text_flag.ct_label.values}\n",
    "        train_data['original+ctf_by_'+flag] = {'text':list(train_data['original']['text'])+list(df_train_ct_text_flag['ct_text_'+col].values), \n",
    "                                          'label':list(train_data['original']['label'])+list(df_train_ct_text_flag.ct_label.values)}\n",
    "\n",
    "    \n",
    "    test_data = {}\n",
    "    ds.test['len_ct_text_causal'] = ds.test['ct_text_causal'].apply(lambda x: len(x.strip()))\n",
    "    df_test_ct_text_causal = ds.test[ds.test.len_ct_text_causal > 0]\n",
    "    \n",
    "    test_data['Original'] = {'text': ds.test.text.values, 'label': ds.test.label.values}\n",
    "    test_data['ct_causal'] = {'text': df_test_ct_text_causal.ct_text_causal.values, 'label': df_test_ct_text_causal.ct_label.values}\n",
    "    \n",
    "    \n",
    "    if(ds.moniker == 'imdb_sents'):\n",
    "        test_data['Counterfactual'] = {'text': ds.test_ct.text.values, 'label': ds.test_ct.label.values}\n",
    "    else:\n",
    "        test_data['Counterfactual'] = {'text': ds.test.ct_text_amt.values, 'label': ds.test.ct_label.values}\n",
    "        \n",
    "    if(ds.moniker == 'kindle'):\n",
    "        test_data['original_selected'] = {'text': ds.select_test.text.values, 'label': ds.select_test.label.values}\n",
    "        test_data['ct_amt_selected'] = {'text': ds.select_test.ct_text_amt.values, 'label': ds.select_test.ct_label.values}\n",
    "    \n",
    "    return train_data, test_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Classification performance with different training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_classifier(train_text, train_label, test_text, test_label, report=True, train='comb'):\n",
    "    \"\"\"\n",
    "    Given training data and test data\n",
    "    \"\"\"\n",
    "    if(len(train_text) == 0 or len(test_text) == 0): # not generating any counterfactual examples\n",
    "        return 0.0\n",
    "    \n",
    "    vec = CountVectorizer(min_df=5, binary=True, max_df=.8)\n",
    "    if(train == 'comb'):\n",
    "        X = vec.fit_transform(list(train_text) + list(test_text))\n",
    "        X_train = vec.transform(train_text)\n",
    "        X_test = vec.transform(test_text)\n",
    "    elif(train == 'train'):\n",
    "        X_train = vec.fit_transform(list(train_text))\n",
    "        X_test = vec.transform(test_text)\n",
    "    \n",
    "    clf = LogisticRegression(class_weight='auto', solver='lbfgs', max_iter=1000)\n",
    "    clf.fit(X_train, train_label)\n",
    "    \n",
    "    \n",
    "    if(report):\n",
    "        print(classification_report(test_label, clf.predict(X_test)))\n",
    "        return clf, vec\n",
    "    else:\n",
    "        result = classification_report(test_label, clf.predict(X_test), output_dict=True)\n",
    "        return float('%.3f' % result['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classification_performance(train_data, test_data):\n",
    "    \"\"\"\n",
    "    train: original, ct_auto, original+ct_auto\n",
    "    test: original, ct_auto, ct_amt\n",
    "    ct_text_auto: if no causal words or no antonym substitutions, then not use it;\n",
    "    Not every text could generate a counterfactual text;\n",
    "    \"\"\"\n",
    "    \n",
    "    df_result = pd.DataFrame({'Sample_size':[0]*5,\n",
    "                              'Original':[0]*5,\n",
    "                              'Counterfactual':[0]*5})\n",
    "    \n",
    "    df_result.rename(index={i: f for i, f in enumerate(['original','original+ctf_by_predicted_causal','original+ctf_by_annotated_causal','original+ctf_by_all_causal','original+ctf_by_human'])}, inplace=True)\n",
    "\n",
    "        \n",
    "    for train_flag, test_flag in product(['original','original+ctf_by_predicted_causal','original+ctf_by_annotated_causal','original+ctf_by_all_causal','original+ctf_by_human'],['Original','Counterfactual']):\n",
    "        try:\n",
    "            df_result.loc[train_flag,'Sample_size'] = len(train_data[train_flag]['label'])\n",
    "            df_result.loc[train_flag,test_flag] = fit_classifier(train_data[train_flag]['text'], \n",
    "                                                                 train_data[train_flag]['label'],\n",
    "                                                                 test_data[test_flag]['text'], \n",
    "                                                                 test_data[test_flag]['label'], report=False)\n",
    "        except: # no human annotated counterfactual training data for kindle  \n",
    "            df_result.loc[train_flag,'Sample_size'] = np.NaN\n",
    "            df_result.loc[train_flag,test_flag] = np.NaN\n",
    "    \n",
    "    return df_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Robust classification for IMDB-L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Sample_size</th>\n",
       "      <th>Original</th>\n",
       "      <th>Counterfactual</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>original</th>\n",
       "      <td>1707</td>\n",
       "      <td>0.816</td>\n",
       "      <td>0.615</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_predicted_causal</th>\n",
       "      <td>2991</td>\n",
       "      <td>0.742</td>\n",
       "      <td>0.744</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_annotated_causal</th>\n",
       "      <td>3325</td>\n",
       "      <td>0.760</td>\n",
       "      <td>0.818</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_all_causal</th>\n",
       "      <td>3401</td>\n",
       "      <td>0.773</td>\n",
       "      <td>0.857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_human</th>\n",
       "      <td>3414</td>\n",
       "      <td>0.818</td>\n",
       "      <td>0.869</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  Sample_size  Original  Counterfactual\n",
       "original                          1707         0.816     0.615         \n",
       "original+ctf_by_predicted_causal  2991         0.742     0.744         \n",
       "original+ctf_by_annotated_causal  3325         0.760     0.818         \n",
       "original+ctf_by_all_causal        3401         0.773     0.857         \n",
       "original+ctf_by_human             3414         0.818     0.869         "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds = load_data('imdb')\n",
    "train_data, test_data = organize_data(ds,limit='')\n",
    "df_result = classification_performance(train_data, test_data)\n",
    "df_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Robust classification for IMDB-S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Sample_size</th>\n",
       "      <th>Original</th>\n",
       "      <th>Counterfactual</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>original</th>\n",
       "      <td>8173</td>\n",
       "      <td>0.711</td>\n",
       "      <td>0.605</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_predicted_causal</th>\n",
       "      <td>10744</td>\n",
       "      <td>0.685</td>\n",
       "      <td>0.660</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_annotated_causal</th>\n",
       "      <td>11828</td>\n",
       "      <td>0.679</td>\n",
       "      <td>0.696</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_all_causal</th>\n",
       "      <td>16202</td>\n",
       "      <td>0.685</td>\n",
       "      <td>0.726</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_human</th>\n",
       "      <td>16679</td>\n",
       "      <td>0.705</td>\n",
       "      <td>0.762</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  Sample_size  Original  Counterfactual\n",
       "original                          8173         0.711     0.605         \n",
       "original+ctf_by_predicted_causal  10744        0.685     0.660         \n",
       "original+ctf_by_annotated_causal  11828        0.679     0.696         \n",
       "original+ctf_by_all_causal        16202        0.685     0.726         \n",
       "original+ctf_by_human             16679        0.705     0.762         "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds = load_data('imdb_sents')\n",
    "train_data, test_data = organize_data(ds,limit='')\n",
    "df_result = classification_performance(train_data, test_data)\n",
    "df_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Robust classification for Kindle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Sample_size</th>\n",
       "      <th>Original</th>\n",
       "      <th>Counterfactual</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>original</th>\n",
       "      <td>10000.0</td>\n",
       "      <td>0.888</td>\n",
       "      <td>0.514</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_predicted_causal</th>\n",
       "      <td>15725.0</td>\n",
       "      <td>0.866</td>\n",
       "      <td>0.624</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_annotated_causal</th>\n",
       "      <td>15695.0</td>\n",
       "      <td>0.882</td>\n",
       "      <td>0.662</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_all_causal</th>\n",
       "      <td>19954.0</td>\n",
       "      <td>0.752</td>\n",
       "      <td>0.720</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>original+ctf_by_human</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  Sample_size  Original  Counterfactual\n",
       "original                          10000.0      0.888     0.514         \n",
       "original+ctf_by_predicted_causal  15725.0      0.866     0.624         \n",
       "original+ctf_by_annotated_causal  15695.0      0.882     0.662         \n",
       "original+ctf_by_all_causal        19954.0      0.752     0.720         \n",
       "original+ctf_by_human            NaN          NaN       NaN            "
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds = load_data('kindle')\n",
    "train_data, test_data = organize_data(ds,limit='')\n",
    "df_result = classification_performance(train_data, test_data)\n",
    "df_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Performance change with different number of causal word substitutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {},
   "outputs": [],
   "source": [
    "def substitute_causal_terms(data_path,ds,train_data,test_data,moniker,df_causal_terms,flag):\n",
    "    \"\"\"\n",
    "    n_causal: number of causal words being substituted\n",
    "    How does the performance change with different number of causal word being substituted?\n",
    "    \"\"\"\n",
    "    \n",
    "    # re-generate counterfactuals for p% causal terms from topn causal\n",
    "    run_counterfactual(data_path,ds,df_causal_terms,moniker,flag,show_data=False)\n",
    "    train_data, test_data = organize_data(ds)\n",
    "    \n",
    "    df_result = classification_performance(train_data, test_data)\n",
    "    \n",
    "    # count the number of augmented counterfactual training samples\n",
    "    ds.train['len_ct_text_'+flag] = ds.train['ct_text_'+flag].apply(lambda x: len(x.strip()))\n",
    "    n_train = ds.train[ds.train['len_ct_text_'+flag] > 0].shape[0]\n",
    "    \n",
    "    ds.test['len_ct_text_'+flag] = ds.test['ct_text_'+flag].apply(lambda x: len(x.strip()))\n",
    "    n_test = ds.test[ds.test['len_ct_text_'+flag] > 0].shape[0]\n",
    "    \n",
    "    substitute_result = {}\n",
    "    for f in ['original','ct_causal','ctf']:\n",
    "        substitute_result[f] = df_result.loc['original+ct_'+flag,f]\n",
    "    \n",
    "    return n_train, n_test, substitute_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "metadata": {},
   "outputs": [],
   "source": [
    "def performance_of_causal_substitution(data_path,ds,train_data,test_data):\n",
    "    \"\"\"\n",
    "    Performance change with different number of causal substitutions\n",
    "    # sort terms in abs(coef) descending order\n",
    "    \"\"\"\n",
    "    causal_substitution = []\n",
    "\n",
    "    # range for all causal terms\n",
    "    ds.all_causal_terms['coef_abs'] = ds.all_causal_terms['coef'].apply(lambda x: abs(x))\n",
    "    ds.all_causal_terms = ds.all_causal_terms.sort_values(by=['coef_abs'],ascending=False)\n",
    "    \n",
    "    for n in list(np.arange(0, ds.all_causal_terms.shape[0], 10))+[ds.all_causal_terms.shape[0]]:\n",
    "        if( n% 50 == 0):\n",
    "            print(n)\n",
    "        df_causal_terms = ds.all_causal_terms.head(n)\n",
    "        flag = 'all_causal'\n",
    "        \n",
    "        \n",
    "        # run to get result\n",
    "        n_train, n_test, substitute_result = substitute_causal_terms(data_path,ds,train_data,test_data,ds.moniker,\n",
    "                                                                     df_causal_terms,flag)\n",
    "        \n",
    "        causal_substitution.append({'substitute_causal_wds': n,\n",
    "                                    'flag':flag,\n",
    "                                    'n_train_ctf':n_train,\n",
    "                                    'n_test_ctf':n_test,\n",
    "                                    'original':substitute_result['original'],\n",
    "                                    'Counterfactual':substitute_result['ctf']})\n",
    "\n",
    "    return pd.DataFrame(causal_substitution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_result(causal_substitution_result, moniker):\n",
    "    \n",
    "    x_values = causal_substitution_result.substitute_causal_wds.values[:-2]\n",
    "    ticks = plt.xticks(ticks=range(len(x_values)), labels=x_values)\n",
    "    plt.title('Performance change with counterfactually augmented data \\n from different number of causal word substitutions (%s)' % moniker)\n",
    "    plt.xlabel('Causal word substitutions')\n",
    "    plt.ylabel('Test set accuracy')\n",
    "\n",
    "    plt.plot(range(len(x_values)), causal_substitution_result.ct_amt.values[:-2], 'o-', label='ct_amt')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_sentence_bywd(ds, wd, limit='no_causal'):\n",
    "    \"\"\"\n",
    "    Select sentences contain a word\n",
    "    \"\"\"\n",
    "    wd_docs = []\n",
    "    for ri, row in ds.train.iterrows():\n",
    "        if(wd in row['causal_wds']):\n",
    "            if(limit == 'no_causal'):\n",
    "                flag = 0\n",
    "                for s_wd in row['causal_wds']:\n",
    "                    if(s_wd in ds.top_terms[ds.top_terms.causal == 1].term.values):\n",
    "                        flag = 1\n",
    "                        \n",
    "                if(flag == 0):\n",
    "                    wd_docs.append(ri)\n",
    "            else:\n",
    "                wd_docs.append(ri)\n",
    "                \n",
    "    df_wd = ds.train.loc[wd_docs]\n",
    "    \n",
    "    return df_wd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Kindle "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "50\n",
      "100\n",
      "150\n",
      "200\n",
      "250\n",
      "21.048294870058694\n"
     ]
    }
   ],
   "source": [
    "ds = load_data(moniker='kindle')\n",
    "train_data, test_data = organize_data(ds,limit='')\n",
    "start = time.time()\n",
    "causal_substitution_result_kindle = performance_of_causal_substitution(data_path,ds,train_data,test_data)\n",
    "end = time.time()\n",
    "print((end-start)/60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- IMDB-L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "50\n",
      "100\n",
      "150\n",
      "200\n",
      "250\n",
      "23.847073352336885\n"
     ]
    }
   ],
   "source": [
    "ds = load_data(moniker='imdb')\n",
    "train_data, test_data = organize_data(ds,limit='')\n",
    "start = time.time()\n",
    "causal_substitution_result_imdb = performance_of_causal_substitution(data_path,ds,train_data,test_data)\n",
    "end = time.time()\n",
    "print((end-start)/60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- IMDB-S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 449,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "50\n",
      "100\n",
      "150\n",
      "200\n",
      "250\n",
      "21.45292599995931\n"
     ]
    }
   ],
   "source": [
    "ds = load_data(moniker='imdb_sents')\n",
    "train_data, test_data = organize_data(ds,limit='')\n",
    "start = time.time()\n",
    "causal_substitution_result_imdb_sents = performance_of_causal_substitution(data_path,ds,train_data,test_data)\n",
    "end = time.time()\n",
    "print((end-start)/60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 513,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(11,6))\n",
    "for causal_substitution_result, moniker,m in zip([causal_substitution_result_imdb, causal_substitution_result_imdb_sents, causal_substitution_result_kindle],['IMDb_L','IMDB_S','Kindle'],['o','*','d']):\n",
    "    x_values = causal_substitution_result.substitute_causal_wds.values\n",
    "    plt.plot(x_values, causal_substitution_result.ct_amt.values, label=moniker, markersize=12, marker=m)\n",
    "    \n",
    "plt.tick_params(axis='x', labelsize=20)\n",
    "plt.tick_params(axis='y', labelsize=20)\n",
    "    \n",
    "plt.xlabel('Number of causal words to substitute', fontsize=20)\n",
    "plt.ylabel('Accuracy for \\nCounterfactual test data', fontsize=20)\n",
    "plt.legend(loc='lower right', fontsize=18)\n",
    "# fig.savefig('./Fig/classifier_causalFromVocab.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>substitute_causal_wds</th>\n",
       "      <th>flag</th>\n",
       "      <th>n_train_ct</th>\n",
       "      <th>n_test_ct</th>\n",
       "      <th>original</th>\n",
       "      <th>ct_causal</th>\n",
       "      <th>ct_amt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>all_causal</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.816</td>\n",
       "      <td>0.301</td>\n",
       "      <td>0.615</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>all_causal</td>\n",
       "      <td>898</td>\n",
       "      <td>260</td>\n",
       "      <td>0.748</td>\n",
       "      <td>0.521</td>\n",
       "      <td>0.727</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>20</td>\n",
       "      <td>all_causal</td>\n",
       "      <td>1085</td>\n",
       "      <td>297</td>\n",
       "      <td>0.764</td>\n",
       "      <td>0.554</td>\n",
       "      <td>0.746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>30</td>\n",
       "      <td>all_causal</td>\n",
       "      <td>1264</td>\n",
       "      <td>343</td>\n",
       "      <td>0.750</td>\n",
       "      <td>0.622</td>\n",
       "      <td>0.773</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>40</td>\n",
       "      <td>all_causal</td>\n",
       "      <td>1454</td>\n",
       "      <td>405</td>\n",
       "      <td>0.750</td>\n",
       "      <td>0.666</td>\n",
       "      <td>0.799</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   substitute_causal_wds        flag  n_train_ct  n_test_ct  original  \\\n",
       "0  0                      all_causal  0           0          0.816      \n",
       "1  10                     all_causal  898         260        0.748      \n",
       "2  20                     all_causal  1085        297        0.764      \n",
       "3  30                     all_causal  1264        343        0.750      \n",
       "4  40                     all_causal  1454        405        0.750      \n",
       "\n",
       "   ct_causal  ct_amt  \n",
       "0  0.301      0.615   \n",
       "1  0.521      0.727   \n",
       "2  0.554      0.746   \n",
       "3  0.622      0.773   \n",
       "4  0.666      0.799   "
      ]
     },
     "execution_count": 461,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "causal_substitution_result_imdb.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>term</th>\n",
       "      <th>coef</th>\n",
       "      <th>causal</th>\n",
       "      <th>antonyms</th>\n",
       "      <th>n_antonyms</th>\n",
       "      <th>antonym_source</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>83</th>\n",
       "      <td>adorable</td>\n",
       "      <td>1.187</td>\n",
       "      <td>1</td>\n",
       "      <td>{'ugly': -0.681}</td>\n",
       "      <td>1</td>\n",
       "      <td>antonym</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>142</th>\n",
       "      <td>amazing</td>\n",
       "      <td>1.124</td>\n",
       "      <td>1</td>\n",
       "      <td>{'unimpressive': -0.462, 'ugly': -0.681, 'ineffective': -1.062}</td>\n",
       "      <td>3</td>\n",
       "      <td>synonym_antonym</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>174</th>\n",
       "      <td>annoying</td>\n",
       "      <td>-1.043</td>\n",
       "      <td>1</td>\n",
       "      <td>{'good': 1.191}</td>\n",
       "      <td>1</td>\n",
       "      <td>synonym_antonym</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>204</th>\n",
       "      <td>appropriate</td>\n",
       "      <td>1.496</td>\n",
       "      <td>1</td>\n",
       "      <td>{'inappropriate': -0.311}</td>\n",
       "      <td>1</td>\n",
       "      <td>antonym</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>269</th>\n",
       "      <td>awesome</td>\n",
       "      <td>1.321</td>\n",
       "      <td>1</td>\n",
       "      <td>{'unimpressive': -0.462}</td>\n",
       "      <td>1</td>\n",
       "      <td>antonym</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3464</th>\n",
       "      <td>wasted</td>\n",
       "      <td>-1.371</td>\n",
       "      <td>1</td>\n",
       "      <td>{'found': 0.198}</td>\n",
       "      <td>1</td>\n",
       "      <td>antonym</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3465</th>\n",
       "      <td>wasting</td>\n",
       "      <td>-1.040</td>\n",
       "      <td>1</td>\n",
       "      <td>{'good': 1.191, 'strength': 0.357}</td>\n",
       "      <td>2</td>\n",
       "      <td>synonym_antonym</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3552</th>\n",
       "      <td>wonderful</td>\n",
       "      <td>2.007</td>\n",
       "      <td>1</td>\n",
       "      <td>{'unimpressive': -0.462, 'inferior': -0.644}</td>\n",
       "      <td>2</td>\n",
       "      <td>antonym</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3568</th>\n",
       "      <td>worse</td>\n",
       "      <td>-1.839</td>\n",
       "      <td>1</td>\n",
       "      <td>{'better': 0.257, 'best': 1.267}</td>\n",
       "      <td>2</td>\n",
       "      <td>antonym</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3569</th>\n",
       "      <td>worst</td>\n",
       "      <td>-2.205</td>\n",
       "      <td>1</td>\n",
       "      <td>{'good': 1.191, 'superior': 0.431, 'best': 1.267}</td>\n",
       "      <td>3</td>\n",
       "      <td>antonym</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>75 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             term   coef  causal  \\\n",
       "83    adorable     1.187  1        \n",
       "142   amazing      1.124  1        \n",
       "174   annoying    -1.043  1        \n",
       "204   appropriate  1.496  1        \n",
       "269   awesome      1.321  1        \n",
       "...       ...        ... ..        \n",
       "3464  wasted      -1.371  1        \n",
       "3465  wasting     -1.040  1        \n",
       "3552  wonderful    2.007  1        \n",
       "3568  worse       -1.839  1        \n",
       "3569  worst       -2.205  1        \n",
       "\n",
       "                                                             antonyms  \\\n",
       "83    {'ugly': -0.681}                                                  \n",
       "142   {'unimpressive': -0.462, 'ugly': -0.681, 'ineffective': -1.062}   \n",
       "174   {'good': 1.191}                                                   \n",
       "204   {'inappropriate': -0.311}                                         \n",
       "269   {'unimpressive': -0.462}                                          \n",
       "...                        ...                                          \n",
       "3464  {'found': 0.198}                                                  \n",
       "3465  {'good': 1.191, 'strength': 0.357}                                \n",
       "3552  {'unimpressive': -0.462, 'inferior': -0.644}                      \n",
       "3568  {'better': 0.257, 'best': 1.267}                                  \n",
       "3569  {'good': 1.191, 'superior': 0.431, 'best': 1.267}                 \n",
       "\n",
       "      n_antonyms   antonym_source  \n",
       "83    1           antonym          \n",
       "142   3           synonym_antonym  \n",
       "174   1           synonym_antonym  \n",
       "204   1           antonym          \n",
       "269   1           antonym          \n",
       "...  ..               ...          \n",
       "3464  1           antonym          \n",
       "3465  2           synonym_antonym  \n",
       "3552  2           antonym          \n",
       "3568  2           antonym          \n",
       "3569  3           antonym          \n",
       "\n",
       "[75 rows x 6 columns]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds.top_terms[ds.top_terms.causal == 1]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python tf_bert",
   "language": "python",
   "name": "tf_bert"
  },
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}