spanish_joke_classifier_tweet_only_LM_RNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the tweets for the updated vocab, test classifer on humor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/farzin/haha_2019\r\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.text import *\n",
    "from fastai.callbacks import SaveModelCallback\n",
    "import sentencepiece as spm #https://github.com/google/sentencepiece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python code Examples (testing out tokenizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading the texts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = Path('./data/rnn/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_texts_df = pd.read_csv('./data/haha_2019_train.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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>id</th>\n",
       "      <th>text</th>\n",
       "      <th>is_humor</th>\n",
       "      <th>votes_no</th>\n",
       "      <th>votes_1</th>\n",
       "      <th>votes_2</th>\n",
       "      <th>votes_3</th>\n",
       "      <th>votes_4</th>\n",
       "      <th>votes_5</th>\n",
       "      <th>funniness_average</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>705196579758583809</td>\n",
       "      <td>Niveles de retraso mental: \\r\\n\\r\\n— Bajo.\\r\\n...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>678040651817213952</td>\n",
       "      <td>—Vamos Luke desenfunda tu sable, demuestra tu ...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>546750892213829633</td>\n",
       "      <td>- ¿Te ofrezco algo?, ¿Agua, café, mi corazón, ...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>965807211292364801</td>\n",
       "      <td>No se porqué me hago la cabeza deooos</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>638403841839484928</td>\n",
       "      <td>Quisiera saber que hago durante la siesta de l...</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   id                                               text  \\\n",
       "0  705196579758583809  Niveles de retraso mental: \\r\\n\\r\\n— Bajo.\\r\\n...   \n",
       "1  678040651817213952  —Vamos Luke desenfunda tu sable, demuestra tu ...   \n",
       "2  546750892213829633  - ¿Te ofrezco algo?, ¿Agua, café, mi corazón, ...   \n",
       "3  965807211292364801              No se porqué me hago la cabeza deooos   \n",
       "4  638403841839484928  Quisiera saber que hago durante la siesta de l...   \n",
       "\n",
       "   is_humor  votes_no  votes_1  votes_2  votes_3  votes_4  votes_5  \\\n",
       "0         1         1        2        2        0        0        0   \n",
       "1         1         1        3        0        1        0        0   \n",
       "2         1         0        2        1        0        1        1   \n",
       "3         0         3        0        0        0        0        0   \n",
       "4         0         4        0        1        0        0        0   \n",
       "\n",
       "   funniness_average  \n",
       "0                1.5  \n",
       "1                1.5  \n",
       "2                2.6  \n",
       "3                NaN  \n",
       "4                NaN  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_texts_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### apply pre-rules to text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## New Line char for replacement in text\n",
    "NL = 'xxnl'\n",
    "defaults.text_spec_tok.append(NL) #add a New Line special char\n",
    "\n",
    "def sub_nl(t:str) -> str:\n",
    "    \"Replaces \\n by xxnl\"\n",
    "    return t.replace(\"\\r\\n\",\"\\n\").replace(\"\\n\",NL+\" \")\n",
    "\n",
    "# def sub_br(t:str) -> str:\n",
    "#     \"Replaces the <br /> by \\n\"\n",
    "#     re_br = re.compile(r'<\\s*br\\s*/?>', re.IGNORECASE)\n",
    "#     return re_br.sub(\"\\n\", t)\n",
    "\n",
    "def spec_add_spaces(t:str) -> str:\n",
    "    \"Add spaces between special characters\"\n",
    "    return re.sub(r'([/#?!@,])', r' \\1 ', t)\n",
    "\n",
    "def rm_useless_spaces(t:str) -> str:\n",
    "    \"Remove multiple spaces\"\n",
    "    return re.sub(' {2,}', ' ', t)\n",
    "\n",
    "def replace_rep(t:str) -> str:\n",
    "    \"Replace repetitions at the character level\"\n",
    "    def _replace_rep(m:Collection[str]) -> str:\n",
    "        c,cc = m.groups()\n",
    "        return f' {TK_REP} {len(cc)+1} {c} '\n",
    "    re_rep = re.compile(r'(\\S)(\\1{3,})')\n",
    "    return re_rep.sub(_replace_rep, t)\n",
    "    \n",
    "def replace_wrep(t:str) -> str:\n",
    "    \"Replace word repetitions\"\n",
    "    def _replace_wrep(m:Collection[str]) -> str:\n",
    "        c,cc = m.groups()\n",
    "        return f' {TK_WREP} {len(cc.split())+1} {c} '\n",
    "    re_wrep = re.compile(r'(\\b\\w+\\W+)(\\1{3,})')\n",
    "    return re_wrep.sub(_replace_wrep, t)\n",
    "\n",
    "def deal_caps(t:str) -> str:\n",
    "    \"Replace words in all caps\"\n",
    "    res = []\n",
    "    for s in re.findall(r'\\w+|\\W+', t):\n",
    "        res += ([f' {TK_UP} ',s.lower()] if (s.isupper() and (len(s)>2)) else [s.lower()])\n",
    "    return ''.join(res)\n",
    "\n",
    "def fixup(x:str) -> str:\n",
    "    \"List of replacements from html strings\"\n",
    "    re1 = re.compile(r'  +')\n",
    "    x = x.replace('#39;', \"'\").replace('amp;', '&').replace('#146;', \"'\").replace(\n",
    "        'nbsp;', ' ').replace('#36;', '$').replace('\\\\n', \"\\n\").replace('quot;', \"'\").replace(\n",
    "        '<br />', \"\\n\").replace('\\\\\"', '\"').replace('<unk>',UNK).replace(' @.@ ','.').replace(\n",
    "        ' @-@ ','-').replace('\\\\', ' \\\\ ')\n",
    "    return re1.sub(' ', html.unescape(x))\n",
    "\n",
    "default_rules = [fixup, replace_rep, replace_wrep, deal_caps, spec_add_spaces, \n",
    "                 rm_useless_spaces, sub_nl]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default Rules:\n",
      " ['fixup', 'replace_rep', 'replace_wrep', 'deal_caps', 'spec_add_spaces', 'rm_useless_spaces', 'sub_nl'] \n",
      "\n",
      "\n",
      "<function fixup at 0x7f9f7b4b42f0>\n",
      "<function replace_rep at 0x7f9f7b4b4158>\n",
      "<function replace_wrep at 0x7f9f7b4b41e0>\n",
      "<function deal_caps at 0x7f9f7b4b4268>\n",
      "<function spec_add_spaces at 0x7f9f7b4b4048>\n",
      "<function rm_useless_spaces at 0x7f9f7b4b40d0>\n",
      "<function sub_nl at 0x7f9f7b4f9d90>\n"
     ]
    }
   ],
   "source": [
    "## apply the rules\n",
    "raw_text = all_texts_df.loc[:,'text']\n",
    "\n",
    "print(\"Default Rules:\\n\",[x.__name__ for x in default_rules],\"\\n\\n\")\n",
    "\n",
    "for rule in default_rules:\n",
    "    print(rule)\n",
    "    raw_text = raw_text.apply(lambda x: rule(str(x)))\n",
    "    \n",
    "all_texts_df['new_text'] = 'xxbos ' + raw_text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    xxbos niveles de retraso mental: xxnl xxnl — b...\n",
       "1    xxbos —vamos luke desenfunda tu sable , demues...\n",
       "2    xxbos - ¿te ofrezco algo ? , ¿agua , café , mi...\n",
       "3          xxbos no se porqué me hago la cabeza deooos\n",
       "4    xxbos quisiera saber que hago durante la siest...\n",
       "Name: new_text, dtype: object"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_texts_df['new_text'].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(24000, 11)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_texts_df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clean up the imbalanced data to balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of positive samples: 9253\n",
      "Number of negative samples: 14747\n",
      "Total samples: 24000\n"
     ]
    }
   ],
   "source": [
    "print('Number of positive samples:', (all_texts_df.is_humor == 1).sum())\n",
    "print('Number of negative samples:',  (all_texts_df.is_humor == 0).sum())\n",
    "print('Total samples:', len(all_texts_df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnd_seed = 20190313\n",
    "np.random.seed(rnd_seed)\n",
    "\n",
    "idx = np.random.permutation(len(all_texts_df))\n",
    "test_cut = int(0.15 * len(idx))\n",
    "valid_cut = int(0.15 * len(idx-test_cut))\n",
    "\n",
    "df_train_all = all_texts_df.iloc[idx[:-(valid_cut+test_cut)],:]\n",
    "df_valid     = all_texts_df.iloc[idx[-(valid_cut+test_cut):-test_cut],:]\n",
    "df_test      = all_texts_df.iloc[idx[-test_cut:],:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test prevalence(n = 3600): 0.3938888888888889\n",
      "Valid prevalence(n = 3600): 0.3852777777777778\n",
      "Train all prevalence(n = 16800): 0.3838095238095238\n",
      "all samples (n = 24000)\n"
     ]
    }
   ],
   "source": [
    "print('Test prevalence(n = %d):'%len(df_test),df_test.is_humor.sum()/ len(df_test))\n",
    "print('Valid prevalence(n = %d):'%len(df_valid),df_valid.is_humor.sum()/ len(df_valid))\n",
    "print('Train all prevalence(n = %d):'%len(df_train_all), df_train_all.is_humor.sum()/ len(df_train_all))\n",
    "print('all samples (n = %d)'%len(all_texts_df))\n",
    "assert len(all_texts_df) == (len(df_test)+len(df_valid)+len(df_train_all)),'math didnt work'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((6448, 11), (10352, 11))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## oversample the less-frequent occuring cases\n",
    "# split the training data into positive and negative\n",
    "rows_pos = df_train_all.is_humor == 1\n",
    "df_train_pos = df_train_all.loc[rows_pos]\n",
    "df_train_neg = df_train_all.loc[~rows_pos]\n",
    "df_train_pos.shape,df_train_neg.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train prevalence (n = 20704): 0.5\n"
     ]
    }
   ],
   "source": [
    "df_resample_pos = df_train_pos.sample(n=len(df_train_neg),replace=True,\n",
    "                                      axis=0,random_state=rnd_seed).reset_index(drop=True)\n",
    "df_train = pd.concat([df_resample_pos,df_train_neg],axis=0) #randomized again in DataBunch?\n",
    "print('Train prevalence (n = %d):'%len(df_train), df_train.is_humor.sum()/ len(df_train))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sp tokenizer from training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_prefix = './all_tweets_es_0509'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "## itos from m.vocab file: just read directly and populate the dictionary\n",
    "itos = [] #{}\n",
    "with open(f'{model_prefix}.vocab','r') as f:\n",
    "    for line_num,line in enumerate(f):\n",
    "#         itos[line_num] = line.split(\"\\t\")[0]\n",
    "        itos.append(line.split(\"\\t\")[0])\n",
    "        \n",
    "class SPTokenizer(BaseTokenizer):\n",
    "    \"Wrapper around a SentncePiece tokenizer to make it a `BaseTokenizer`.\"\n",
    "    def __init__(self, model_prefix:str):\n",
    "        self.tok = spm.SentencePieceProcessor()\n",
    "        self.tok.load(f'{model_prefix}.model')\n",
    "\n",
    "    def tokenizer(self, t:str) -> List[str]:\n",
    "#         return self.tok.EncodeAsIds(t)  ## tokenize + numericalize. We have them broken into two parts,just return tokens\n",
    "        return self.tok.EncodeAsPieces(t)\n",
    "        \n",
    "class CustomTokenizer():\n",
    "    '''Wrapper for SentencePiece toeknizer to fit into Fast.ai V1'''\n",
    "    def __init__(self,tok_func:Callable,model_prefix:str, pre_rules:ListRules=None):\n",
    "        self.tok_func,self.model_prefix = tok_func,model_prefix\n",
    "        self.pre_rules  = ifnone(pre_rules,  defaults.text_pre_rules )\n",
    "        \n",
    "    def __repr__(self) -> str:\n",
    "        res = f'Tokenizer {self.tok_func.__name__} using `{self.model_prefix}` model with the following rules:\\n'\n",
    "        for rule in self.pre_rules: res += f' - {rule.__name__}\\n'\n",
    "        return res        \n",
    "\n",
    "    def process_text(self, t:str,tok:BaseTokenizer) -> List[str]:\n",
    "        \"Processe one text `t` with tokenizer `tok`.\"\n",
    "        for rule in self.pre_rules: t = rule(t)  \n",
    "        toks = tok.tokenizer(t)\n",
    "    \n",
    "        return toks \n",
    "    \n",
    "    def _process_all_1(self,texts:Collection[str]) -> List[List[str]]:\n",
    "        'Process a list of `texts` in one process'\n",
    "        tok = self.tok_func(self.model_prefix)\n",
    "        return [self.process_text(t,tok) for t in texts]\n",
    "                                                                     \n",
    "    def process_all(self, texts:Collection[str]) -> List[List[str]]: \n",
    "        \"Process a list of `texts`.\"                                 \n",
    "        return self._process_all_1(texts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['→', '😫', '🤨', '😲', '🏟', '📖', '🎸', '🏿', '😮', '🎬']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itos[-10:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "mycust_tok = CustomTokenizer(SPTokenizer,model_prefix,pre_rules=default_rules)\n",
    "sp_vocab = Vocab(itos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = TextClasDataBunch.from_df(PATH,df_train,df_valid,df_test,\n",
    "                               tokenizer=mycust_tok, vocab=sp_vocab,\n",
    "                               text_cols='new_text', label_cols='is_humor')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>text</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁❤ .- ~ * ( ▁? ▁el ▁di vo 00 ▁d 3 ▁tw 1 tter ▁! ▁! ▁! ▁? ▁? ▁~ k 3 ▁di 4 vl 0 zz ▁ki 3 r 3 z ▁k 3 ▁p 4 rt 3 ▁d 3 ▁no 00 ▁n 0 ▁3 nt 13 nd 3 z ▁b 3 the ▁k 0 n ▁ki 3 n ▁t 3 ▁d 3 ▁l 4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁❤ ️ -( el ▁di vo 00 ▁d 3 ▁tw 1 tter ▁! ▁! ▁? ▁i 0 ▁zo i ▁tu ▁ma 3 zt lo ▁? ▁ki 3 n ▁z up 0 ▁3 nz 3 ñ 4 l th 3 ▁? ▁d 3 ▁tu ▁k cuer p 0 ▁io o ▁k 0 noz ko ▁az t 4 ▁la ▁maz ▁in ty ma ▁p 4 r te ▁?</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁—¡ idio ta ▁! ▁ xxnl ▁—¡ h ist érica ▁! ▁ xxnl ▁— que ▁tarado . xxnl ▁— tar ada ▁tú . xxnl ▁— te ▁odio . xxnl ▁— yo ▁también . xxnl ▁— ▁¡ ▁ xxup ▁jode te ▁! ▁ xxnl ▁— no ▁me ▁hables . xxnl ▁—¡ ok ▁! ▁ xxnl ▁—¡ ok ▁! ▁ xxnl ▁— te ▁amo . xxnl ▁— yo</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁¡ ya ▁llegó ▁santa ▁! ▁ xxnl ▁ xxunk _ xxunk xxnl ▁( ・ xxunk ・ ) xxnl ▁_ | ▁ xxunk / ( ___ ▁ xxnl ▁/ ▁l ▁( __ __ / xxnl ▁ xxnl ▁ah ▁no ▁, ▁es ▁mi ▁papá ▁bien ▁pedo . xxnl ▁ xxnl ▁&lt; xxunk / xxunk - xxunk ___ xxnl ▁/ &lt; _ ▁/ ▁ xxrep ▁4 ▁_ ▁/ ”</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁¡ ya ▁llegó ▁santa ▁! ▁ xxnl ▁ xxunk _ xxunk xxnl ▁( ・ xxunk ・ ) xxnl ▁_ | ▁ xxunk / ( ___ ▁ xxnl ▁/ ▁l ▁( __ __ / xxnl ▁ xxnl ▁ah ▁no ▁, ▁es ▁mi ▁papá ▁bien ▁pedo . xxnl ▁ xxnl ▁&lt; xxunk / xxunk - xxunk ___ xxnl ▁/ &lt; _ ▁/ ▁ xxrep ▁4 ▁_ ▁/ ”</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁( ▁ xxup ▁o _ o ) ▁( xxunk _ ▁ xxunk ) ▁( ▁ xxup ▁o _ o ) ▁( xxunk _ ▁ xxunk ) ▁( ▁ xxup ▁o _ o ) ▁( xxunk _ ▁ xxunk ) ▁( ▁ xxup ▁o _ o ) ▁( xxunk _ ▁ xxunk ) ▁( xxunk _ ▁ xxunk ). ▁yo ▁con ▁el ▁móvil ▁en ▁clase .</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁— cuel ga ▁tú . xxnl ▁— no ▁, ▁cuelga ▁tú . ▁ xxnl ▁— no ▁, ▁tú . xxnl ▁— que ▁t ... xxnl ▁—¡ ▁ xxup ▁pinche ▁ xxup ▁tonta ▁me ▁ xxup ▁colgó ▁! ▁ xxnl ▁—¡ te ▁ xxup ▁escuché ▁ xxup ▁pendejo ▁! ▁ xxnl ▁— ▁ xxup ▁jajaj á ▁¡ ay ▁amor ▁! ▁es ▁broma ▁, ▁te ▁amo .</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁ xxup ▁tengo ▁un ▁ xxup ▁gran ▁ xxup ▁anuncio ▁, ▁ xxup ▁una ▁ xxup ▁noticia ▁ xxup ▁que ▁ xxup ▁cambiará ▁la ▁ xxup ▁historia ▁de ▁ xxup ▁twitter ▁, ▁ xxup ▁que ▁ xxup ▁devolver á ▁el ▁ xxup ▁sentido ▁a ▁ xxup ▁nuestra ▁ xxup ▁vida . xxnl ▁ xxnl ▁ xxup ▁pendientes ▁ xxup ▁hoy ▁en ▁la ▁ xxup ▁noche</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁— mamá ▁, ▁¿ puedo ▁salir ▁? ▁— no . ▁—¿ me ▁das ▁un ▁calce tín ▁? ▁— ok ▁, ▁toma . ▁— el ▁ xxup ▁amo ▁le ▁ha ▁ xxup ▁dado ▁a ▁ xxup ▁dob by ▁un ▁ xxup ▁calce tín ... ▁¡ ▁ xxup ▁dob by ▁es ▁ xxup ▁libre ▁! ▁# ▁ xxup ▁jajaja ▁# ▁ xxup ▁hp quo tes ▁# ▁xd</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ xxbos ▁ xxbos ▁—¿ maestro ▁entonces ▁ya ▁aprobé ▁? ▁ xxnl ▁ xxnl ▁( • ▁- ▁• ) ▁ xxnl ▁ xxunk ▁ xxunk ▁ xxunk ▁__ ( • ▁- ▁• ) ▁ xxnl ▁_ xxunk ▁_ xxunk ▁ xxunk ▁ xxunk ▁ xxnl ▁ xxnl ▁—¡ hija ▁, ▁yo ▁soy ▁el ▁conser je ▁! ▁ xxnl ▁ xxnl ▁—¡ ay ▁, ▁por ▁no ▁poner ▁atención ▁!</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.show_batch(10)  #less xxunk, but still a fair amount..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check `xxunk` fraction on humor data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((498,), (20704,))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pct_xxunk = pd.Series([sum(y==0)/len(y) for y in [x.data for x in data.train_dl.x]])\n",
    "pct_xxunk[pct_xxunk>0].shape, pct_xxunk.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.024053323029366306"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "498/20704."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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": [
    "pd.Series([sum(y==0)/len(y) for y in [x.data for x in data.train_dl.x]]).plot()\n",
    "_ = plt.title('Pct UNK in each tweet')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### build and train model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = awd_lstm_clas_config.copy()\n",
    "config['qrnn'] = False\n",
    "config['n_hid'] = 2304\n",
    "\n",
    "learn = text_classifier_learner(data, AWD_LSTM, drop_mult=0.5,pretrained=False,\n",
    "                               config=config)\n",
    "learn.load_encoder('twitter_es_enc_RNN_0510')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    }
   ],
   "source": [
    "lr_find(learn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": [
    "learn.recorder.plot(skip_end=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 03:16 <p><table style='width:375px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>accuracy</th>\n",
       "    <th>time</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>0</th>\n",
       "    <th>0.478928</th>\n",
       "    <th>0.389891</th>\n",
       "    <th>0.819722</th>\n",
       "    <th>00:18</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.551960</th>\n",
       "    <th>0.409214</th>\n",
       "    <th>0.810000</th>\n",
       "    <th>00:17</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.490082</th>\n",
       "    <th>0.374236</th>\n",
       "    <th>0.831111</th>\n",
       "    <th>00:17</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.479389</th>\n",
       "    <th>0.375077</th>\n",
       "    <th>0.822222</th>\n",
       "    <th>00:17</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>0.426523</th>\n",
       "    <th>0.379317</th>\n",
       "    <th>0.823611</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>0.457871</th>\n",
       "    <th>0.377402</th>\n",
       "    <th>0.831667</th>\n",
       "    <th>00:17</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>0.460482</th>\n",
       "    <th>0.385953</th>\n",
       "    <th>0.825833</th>\n",
       "    <th>00:17</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>0.426888</th>\n",
       "    <th>0.372635</th>\n",
       "    <th>0.837222</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>0.458544</th>\n",
       "    <th>0.377387</th>\n",
       "    <th>0.833333</th>\n",
       "    <th>00:17</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>9</th>\n",
       "    <th>0.406659</th>\n",
       "    <th>0.377650</th>\n",
       "    <th>0.837500</th>\n",
       "    <th>00:18</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with accuracy value: 0.8197222352027893.\n",
      "Better model found at epoch 2 with accuracy value: 0.8311111330986023.\n",
      "Better model found at epoch 5 with accuracy value: 0.8316666483879089.\n",
      "Better model found at epoch 7 with accuracy value: 0.8372222185134888.\n",
      "Better model found at epoch 9 with accuracy value: 0.8374999761581421.\n"
     ]
    }
   ],
   "source": [
    "learn.freeze()\n",
    "learn.fit_one_cycle(10, 1e-2, moms=(0.8,0.7), #moms=(0.65,0.35),\n",
    "                   callbacks=[SaveModelCallback(learn,every='improvement',mode='max',monitor='accuracy',name='best_acc_model')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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"
    },
    {
     "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": [
    "learn.recorder.plot_losses()\n",
    "learn.recorder.plot_metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('rnn_trained_head')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "#learn = learn.load('rnn_trained_head')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 01:58 <p><table style='width:375px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>accuracy</th>\n",
       "    <th>time</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>0</th>\n",
       "    <th>0.400586</th>\n",
       "    <th>0.375577</th>\n",
       "    <th>0.836111</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.370568</th>\n",
       "    <th>0.366349</th>\n",
       "    <th>0.840833</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.341472</th>\n",
       "    <th>0.368090</th>\n",
       "    <th>0.842222</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.321458</th>\n",
       "    <th>0.368032</th>\n",
       "    <th>0.843056</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>0.306233</th>\n",
       "    <th>0.371537</th>\n",
       "    <th>0.843611</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with accuracy value: 0.8361111283302307.\n",
      "Better model found at epoch 1 with accuracy value: 0.840833306312561.\n",
      "Better model found at epoch 2 with accuracy value: 0.8422222137451172.\n",
      "Better model found at epoch 3 with accuracy value: 0.8430555462837219.\n",
      "Better model found at epoch 4 with accuracy value: 0.8436111211776733.\n"
     ]
    }
   ],
   "source": [
    "learn.freeze_to(-2)\n",
    "learn.fit_one_cycle(5,slice(1e-3/(2.6**2),1e-3),moms=(0.7,0.4), wd=0.10,\n",
    "                   callbacks=[SaveModelCallback(learn,every='improvement',mode='max',monitor='accuracy',name='best_acc_model')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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"
    },
    {
     "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": [
    "learn.recorder.plot_losses()\n",
    "learn.recorder.plot_metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 03:13 <p><table style='width:375px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>accuracy</th>\n",
       "    <th>time</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>0</th>\n",
       "    <th>0.283750</th>\n",
       "    <th>0.377998</th>\n",
       "    <th>0.848889</th>\n",
       "    <th>00:36</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.305264</th>\n",
       "    <th>0.378522</th>\n",
       "    <th>0.851944</th>\n",
       "    <th>00:37</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.290279</th>\n",
       "    <th>0.379905</th>\n",
       "    <th>0.845556</th>\n",
       "    <th>00:33</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.273834</th>\n",
       "    <th>0.382690</th>\n",
       "    <th>0.850833</th>\n",
       "    <th>00:34</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>0.230288</th>\n",
       "    <th>0.404476</th>\n",
       "    <th>0.854167</th>\n",
       "    <th>00:35</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with accuracy value: 0.8488888740539551.\n",
      "Better model found at epoch 1 with accuracy value: 0.8519444465637207.\n",
      "Better model found at epoch 4 with accuracy value: 0.8541666865348816.\n"
     ]
    }
   ],
   "source": [
    "learn.freeze_to(-3)\n",
    "learn.fit_one_cycle(5,slice(5e-4/(2.6**3),5e-4),moms=(0.7,0.4), wd=0.10,\n",
    "                   callbacks=[SaveModelCallback(learn,every='improvement',mode='max',monitor='accuracy',name='best_acc_model')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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"
    },
    {
     "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": [
    "learn.recorder.plot_losses()\n",
    "learn.recorder.plot_metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 04:18 <p><table style='width:375px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>accuracy</th>\n",
       "    <th>time</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>0</th>\n",
       "    <th>0.253879</th>\n",
       "    <th>0.387365</th>\n",
       "    <th>0.848056</th>\n",
       "    <th>00:46</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.237303</th>\n",
       "    <th>0.384946</th>\n",
       "    <th>0.846111</th>\n",
       "    <th>00:48</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.226133</th>\n",
       "    <th>0.388606</th>\n",
       "    <th>0.855833</th>\n",
       "    <th>00:47</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.273825</th>\n",
       "    <th>0.434275</th>\n",
       "    <th>0.854722</th>\n",
       "    <th>00:49</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>0.222986</th>\n",
       "    <th>0.391095</th>\n",
       "    <th>0.849167</th>\n",
       "    <th>00:49</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with accuracy value: 0.8480555415153503.\n",
      "Better model found at epoch 2 with accuracy value: 0.8558333516120911.\n"
     ]
    }
   ],
   "source": [
    "learn.unfreeze()\n",
    "learn.fit_one_cycle(5,slice(1e-4/(2.6**4),1e-4),moms=(0.7,0.4),\n",
    "                   callbacks=[SaveModelCallback(learn,every='improvement',mode='max',monitor='accuracy',name='best_acc_model')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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"
    },
    {
     "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": [
    "learn.recorder.plot_losses()\n",
    "learn.recorder.plot_metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "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"
    },
    {
     "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": [
    "preds_t,y_t,losses_t = learn.get_preds(DatasetType.Train,with_loss=True)\n",
    "interp_t = ClassificationInterpretation(learn, preds_t, y_t, losses_t)\n",
    "interp_t.plot_confusion_matrix()\n",
    "\n",
    "preds,y,losses = learn.get_preds(with_loss=True)\n",
    "interp = ClassificationInterpretation(learn, preds, y, losses)\n",
    "interp.plot_confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<span style=\"font-family: monospace;\"><span title=\"0.165\" style=\"background-color: rgba(214, 229, 244, 0.5);\">▁</span> <span title=\"0.131\" style=\"background-color: rgba(221, 234, 246, 0.5);\">xxbos</span> <span title=\"0.259\" style=\"background-color: rgba(195, 217, 238, 0.5);\">▁es</span> <span title=\"0.301\" style=\"background-color: rgba(181, 211, 233, 0.5);\">▁increíble</span> <span title=\"0.197\" style=\"background-color: rgba(208, 225, 242, 0.5);\">▁lo</span> <span title=\"0.158\" style=\"background-color: rgba(215, 230, 244, 0.5);\">▁que</span> <span title=\"0.781\" style=\"background-color: rgba(26, 105, 174, 0.5);\">▁dura</span> <span title=\"0.233\" style=\"background-color: rgba(201, 221, 240, 0.5);\">▁la</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁batería</span> <span title=\"0.159\" style=\"background-color: rgba(215, 230, 244, 0.5);\">▁del</span> <span title=\"0.613\" style=\"background-color: rgba(69, 148, 199, 0.5);\">▁celular</span> <span title=\"0.266\" style=\"background-color: rgba(193, 217, 237, 0.5);\">▁cuando</span> <span title=\"0.493\" style=\"background-color: rgba(109, 175, 214, 0.5);\">▁nadie</span> <span title=\"0.243\" style=\"background-color: rgba(199, 219, 239, 0.5);\">▁te</span> <span title=\"0.263\" style=\"background-color: rgba(193, 217, 237, 0.5);\">▁quiere</span> <span title=\"0.183\" style=\"background-color: rgba(211, 227, 243, 0.5);\">.</span></span>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<span style=\"font-family: monospace;\"><span title=\"0.497\" style=\"background-color: rgba(107, 174, 214, 0.5);\">▁</span> <span title=\"0.441\" style=\"background-color: rgba(131, 187, 219, 0.5);\">xxbos</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁tengo</span> <span title=\"0.875\" style=\"background-color: rgba(8, 81, 156, 0.5);\">▁hambre</span> <span title=\"0.168\" style=\"background-color: rgba(213, 229, 244, 0.5);\">▁,</span> <span title=\"0.809\" style=\"background-color: rgba(20, 97, 168, 0.5);\">▁sueño</span> <span title=\"0.247\" style=\"background-color: rgba(198, 219, 239, 0.5);\">▁y</span> <span title=\"0.579\" style=\"background-color: rgba(80, 155, 203, 0.5);\">▁ganas</span> <span title=\"0.160\" style=\"background-color: rgba(215, 230, 244, 0.5);\">▁de</span> <span title=\"0.524\" style=\"background-color: rgba(98, 168, 210, 0.5);\">▁verte</span> <span title=\"0.114\" style=\"background-color: rgba(224, 236, 247, 0.5);\">.</span> <span title=\"0.185\" style=\"background-color: rgba(210, 227, 243, 0.5);\">▁no</span> <span title=\"0.277\" style=\"background-color: rgba(190, 215, 236, 0.5);\">▁en</span> <span title=\"0.308\" style=\"background-color: rgba(180, 211, 232, 0.5);\">▁ese</span> <span title=\"0.397\" style=\"background-color: rgba(149, 197, 223, 0.5);\">▁orden</span> <span title=\"0.113\" style=\"background-color: rgba(225, 236, 247, 0.5);\">▁,</span> <span title=\"0.170\" style=\"background-color: rgba(213, 229, 244, 0.5);\">▁pero</span> <span title=\"0.278\" style=\"background-color: rgba(188, 215, 235, 0.5);\">▁sí</span> <span title=\"0.304\" style=\"background-color: rgba(181, 211, 233, 0.5);\">▁todo</span> <span title=\"0.176\" style=\"background-color: rgba(212, 228, 243, 0.5);\">▁el</span> <span title=\"0.270\" style=\"background-color: rgba(191, 216, 236, 0.5);\">▁tiempo</span> <span title=\"0.108\" style=\"background-color: rgba(225, 237, 248, 0.5);\">.</span></span>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<span style=\"font-family: monospace;\"><span title=\"0.039\" style=\"background-color: rgba(239, 246, 252, 0.5);\">▁</span> <span title=\"0.047\" style=\"background-color: rgba(237, 244, 251, 0.5);\">xxbos</span> <span title=\"0.231\" style=\"background-color: rgba(201, 221, 240, 0.5);\">▁—¡</span> <span title=\"0.181\" style=\"background-color: rgba(211, 227, 243, 0.5);\">camar</span> <span title=\"0.120\" style=\"background-color: rgba(223, 235, 247, 0.5);\">ero</span> <span title=\"0.044\" style=\"background-color: rgba(238, 245, 252, 0.5);\">▁!</span> <span title=\"0.108\" style=\"background-color: rgba(225, 237, 248, 0.5);\">▁¿</span> <span title=\"0.323\" style=\"background-color: rgba(175, 209, 230, 0.5);\">tiene</span> <span title=\"0.725\" style=\"background-color: rgba(39, 119, 184, 0.5);\">▁alitas</span> <span title=\"0.059\" style=\"background-color: rgba(235, 243, 251, 0.5);\">▁?</span> <span title=\"0.107\" style=\"background-color: rgba(225, 237, 248, 0.5);\">▁—</span> <span title=\"0.233\" style=\"background-color: rgba(201, 221, 240, 0.5);\">sí</span> <span title=\"0.064\" style=\"background-color: rgba(234, 242, 250, 0.5);\">▁,</span> <span title=\"0.170\" style=\"background-color: rgba(213, 229, 244, 0.5);\">▁señor</span> <span title=\"0.266\" style=\"background-color: rgba(192, 216, 237, 0.5);\">▁—</span> <span title=\"0.756\" style=\"background-color: rgba(31, 111, 179, 0.5);\">pues</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁trá</span> <span title=\"0.444\" style=\"background-color: rgba(130, 186, 219, 0.5);\">ig</span> <span title=\"0.142\" style=\"background-color: rgba(218, 232, 245, 0.5);\">ame</span> <span title=\"0.084\" style=\"background-color: rgba(230, 240, 249, 0.5);\">▁una</span> <span title=\"0.106\" style=\"background-color: rgba(225, 237, 248, 0.5);\">▁cerveza</span> <span title=\"0.067\" style=\"background-color: rgba(233, 242, 250, 0.5);\">▁¡</span> <span title=\"0.138\" style=\"background-color: rgba(219, 233, 246, 0.5);\">pero</span> <span title=\"0.227\" style=\"background-color: rgba(202, 221, 240, 0.5);\">▁volando</span> <span title=\"0.078\" style=\"background-color: rgba(232, 241, 250, 0.5);\">▁!</span> <span title=\"0.334\" style=\"background-color: rgba(171, 207, 229, 0.5);\">▁puto</span> <span title=\"0.099\" style=\"background-color: rgba(227, 238, 248, 0.5);\">▁</span> <span title=\"0.031\" style=\"background-color: rgba(241, 247, 253, 0.5);\">xxup</span> <span title=\"0.382\" style=\"background-color: rgba(155, 200, 224, 0.5);\">▁jajajajaj</span> <span title=\"0.306\" style=\"background-color: rgba(180, 211, 232, 0.5);\">á</span> <span title=\"0.079\" style=\"background-color: rgba(231, 240, 249, 0.5);\">.</span></span>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<span style=\"font-family: monospace;\"><span title=\"0.037\" style=\"background-color: rgba(239, 246, 252, 0.5);\">▁</span> <span title=\"0.033\" style=\"background-color: rgba(240, 246, 252, 0.5);\">xxbos</span> <span title=\"0.098\" style=\"background-color: rgba(227, 238, 248, 0.5);\">▁ese</span> <span title=\"0.095\" style=\"background-color: rgba(228, 238, 248, 0.5);\">▁momento</span> <span title=\"0.111\" style=\"background-color: rgba(225, 236, 247, 0.5);\">▁cuando</span> <span title=\"0.118\" style=\"background-color: rgba(223, 235, 247, 0.5);\">▁te</span> <span title=\"0.394\" style=\"background-color: rgba(151, 198, 223, 0.5);\">▁encuentras</span> <span title=\"0.078\" style=\"background-color: rgba(231, 240, 249, 0.5);\">▁a</span> <span title=\"0.113\" style=\"background-color: rgba(224, 236, 247, 0.5);\">▁tu</span> <span title=\"0.208\" style=\"background-color: rgba(206, 224, 241, 0.5);\">▁ex</span> <span title=\"0.061\" style=\"background-color: rgba(235, 243, 251, 0.5);\">▁en</span> <span title=\"0.045\" style=\"background-color: rgba(238, 245, 252, 0.5);\">▁el</span> <span title=\"0.229\" style=\"background-color: rgba(202, 221, 240, 0.5);\">▁gym</span> <span title=\"0.049\" style=\"background-color: rgba(237, 244, 251, 0.5);\">▁y</span> <span title=\"0.090\" style=\"background-color: rgba(228, 239, 249, 0.5);\">▁te</span> <span title=\"0.286\" style=\"background-color: rgba(186, 214, 234, 0.5);\">▁preguntas</span> <span title=\"0.161\" style=\"background-color: rgba(215, 230, 244, 0.5);\">:</span> <span title=\"0.155\" style=\"background-color: rgba(216, 231, 245, 0.5);\">▁¿</span> <span title=\"0.165\" style=\"background-color: rgba(214, 229, 244, 0.5);\">por</span> <span title=\"0.115\" style=\"background-color: rgba(224, 236, 247, 0.5);\">▁qué</span> <span title=\"0.417\" style=\"background-color: rgba(141, 192, 221, 0.5);\">▁chingados</span> <span title=\"0.183\" style=\"background-color: rgba(211, 227, 243, 0.5);\">▁está</span> <span title=\"0.242\" style=\"background-color: rgba(199, 219, 239, 0.5);\">▁haciendo</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁cardio</span> <span title=\"0.085\" style=\"background-color: rgba(230, 240, 249, 0.5);\">▁si</span> <span title=\"0.054\" style=\"background-color: rgba(236, 244, 251, 0.5);\">▁no</span> <span title=\"0.121\" style=\"background-color: rgba(223, 235, 247, 0.5);\">▁tiene</span> <span title=\"0.234\" style=\"background-color: rgba(201, 221, 240, 0.5);\">▁corazón</span> <span title=\"0.154\" style=\"background-color: rgba(216, 231, 245, 0.5);\">▁?</span></span>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<span style=\"font-family: monospace;\"><span title=\"0.081\" style=\"background-color: rgba(231, 240, 249, 0.5);\">▁</span> <span title=\"0.094\" style=\"background-color: rgba(228, 238, 248, 0.5);\">xxbos</span> <span title=\"0.231\" style=\"background-color: rgba(201, 221, 240, 0.5);\">▁todos</span> <span title=\"0.238\" style=\"background-color: rgba(200, 220, 239, 0.5);\">▁son</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁ate</span> <span title=\"0.219\" style=\"background-color: rgba(203, 222, 240, 0.5);\">os</span> <span title=\"0.253\" style=\"background-color: rgba(197, 218, 238, 0.5);\">▁hasta</span> <span title=\"0.153\" style=\"background-color: rgba(216, 231, 245, 0.5);\">▁que</span> <span title=\"0.146\" style=\"background-color: rgba(218, 232, 245, 0.5);\">▁el</span> <span title=\"0.948\" style=\"background-color: rgba(8, 61, 126, 0.5);\">▁taxista</span> <span title=\"0.158\" style=\"background-color: rgba(215, 230, 244, 0.5);\">▁se</span> <span title=\"0.212\" style=\"background-color: rgba(205, 223, 241, 0.5);\">▁va</span> <span title=\"0.173\" style=\"background-color: rgba(212, 228, 243, 0.5);\">▁por</span> <span title=\"0.257\" style=\"background-color: rgba(196, 218, 238, 0.5);\">▁otra</span> <span title=\"0.407\" style=\"background-color: rgba(144, 194, 222, 0.5);\">▁calle</span> <span title=\"0.120\" style=\"background-color: rgba(223, 235, 247, 0.5);\">.</span></span>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from fastai.text.models.awd_lstm import TextClassificationInterpretation\n",
    "from matplotlib.pyplot import cm\n",
    "txt_ci = TextClassificationInterpretation.from_learner(learn)\n",
    "(_,idxs) = interp.top_losses(5)\n",
    "for idx in to_np(idxs):\n",
    "    print(\"-\"*10)\n",
    "    txt_ci.show_intrinsic_attention(df_train.iloc[idx,1],cmap=cm.Blues) #textify breaks?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save(\"haha_20190516_tweet_vocab\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### Save predictions for use in Ensemble method (not used)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "pd.DataFrame(to_np(preds)).to_csv('rnn_sent_preds.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "## fastai \"test\" has no labels.  It is a true test, not a whitholding set!!  We need a second valid set?\n",
    "## move the df_test into the \"valid\" position so we can run inference and get preds on randomized vals\n",
    "data_t = TextClasDataBunch.from_df(PATH,df_train,df_test,\n",
    "                               tokenizer=mycust_tok, vocab=sp_vocab,\n",
    "                               text_cols='new_text', label_cols='is_humor')\n",
    "learn.data = data_t\n",
    "t_preds,t_y,t_losses = learn.get_preds(with_loss=True,ds_type=DatasetType.Valid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "pd.DataFrame(to_np(t_preds)).to_csv('rnn_sent_t_preds.csv')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7 fasta.ai1 DEV",
   "language": "python",
   "name": "fastai1_dev"
  },
  "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.3"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}