spanish_joke_classifier_tweet_only_LM_QRNN-LabelSmoothing[LM and Clas]-Copy1.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\"]=\"1\""
   ]
  },
  {
   "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 0x7f14e58d3400>\n",
      "<function replace_rep at 0x7f14e58d3268>\n",
      "<function replace_wrep at 0x7f14e58d32f0>\n",
      "<function deal_caps at 0x7f14e58d3378>\n",
      "<function spec_add_spaces at 0x7f14e58d3158>\n",
      "<function rm_useless_spaces at 0x7f14e58d31e0>\n",
      "<function sub_nl at 0x7f14e58fcea0>\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'] =  raw_text #tokenizer adds xxbos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    niveles de retraso mental: xxnl xxnl — bajo.xx...\n",
       "1    —vamos luke desenfunda tu sable , demuestra tu...\n",
       "2    - ¿te ofrezco algo ? , ¿agua , café , mi coraz...\n",
       "3                no se porqué me hago la cabeza deooos\n",
       "4    quisiera saber que hago durante la siesta de l...\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 ▁❤ .- ~ * ( ▁? ▁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 ▁g 4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ 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 ▁—¡ 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 ▁más .</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁ 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 ▁¡ 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 ▁( ▁ 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 ▁— 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 ▁ 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 ▁— 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 ▁—¿ 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": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = awd_lstm_clas_config.copy()\n",
    "config['qrnn'] = True\n",
    "config['n_hid'] = 2304\n",
    "\n",
    "learn = text_classifier_learner(data, AWD_LSTM, drop_mult=0.7,pretrained=False,\n",
    "                               config=config)\n",
    "learn.load_encoder('twitter_es_enc_QRNN_0517_labelsmooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FlattenedLoss of CrossEntropyLoss()"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.loss_func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.layers import LabelSmoothingCrossEntropy\n",
    "learn.loss_func = FlattenedLoss(LabelSmoothingCrossEntropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "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": 130,
   "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=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "## transform that will drop (replace?) low prob words in each input batch.  \n",
    "# 1) run words through LM, find prob of next word for each word\n",
    "# 2) use prob to adjust/drop each word in the batch\n",
    "# 3) Use a transform/augmentation for each prediction.\n",
    "\n",
    "### Transform that will change/replace the entire sentence.  En-Fr -> Fr-En to get the same semantics, but new set of words.\n",
    "## can we do with many words?  Can we couple with single-word drop/replace?\n",
    "## multiplies the amount of transforms?  Applied after word-level transform?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 07:02 <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.549287</th>\n",
       "    <th>0.459978</th>\n",
       "    <th>0.827222</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.539480</th>\n",
       "    <th>0.474697</th>\n",
       "    <th>0.816667</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.525697</th>\n",
       "    <th>0.446888</th>\n",
       "    <th>0.834722</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.529438</th>\n",
       "    <th>0.469992</th>\n",
       "    <th>0.809722</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>0.516729</th>\n",
       "    <th>0.464084</th>\n",
       "    <th>0.816111</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>0.515130</th>\n",
       "    <th>0.431999</th>\n",
       "    <th>0.843333</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>0.506556</th>\n",
       "    <th>0.439585</th>\n",
       "    <th>0.846111</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>0.516932</th>\n",
       "    <th>0.429214</th>\n",
       "    <th>0.848333</th>\n",
       "    <th>00:18</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>0.498624</th>\n",
       "    <th>0.460026</th>\n",
       "    <th>0.818889</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>9</th>\n",
       "    <th>0.507117</th>\n",
       "    <th>0.445614</th>\n",
       "    <th>0.835556</th>\n",
       "    <th>00:18</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>10</th>\n",
       "    <th>0.479977</th>\n",
       "    <th>0.445280</th>\n",
       "    <th>0.848889</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>11</th>\n",
       "    <th>0.473188</th>\n",
       "    <th>0.443706</th>\n",
       "    <th>0.845278</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>12</th>\n",
       "    <th>0.456050</th>\n",
       "    <th>0.440569</th>\n",
       "    <th>0.850278</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>13</th>\n",
       "    <th>0.448775</th>\n",
       "    <th>0.428801</th>\n",
       "    <th>0.863056</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>14</th>\n",
       "    <th>0.424545</th>\n",
       "    <th>0.460754</th>\n",
       "    <th>0.821667</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>15</th>\n",
       "    <th>0.405055</th>\n",
       "    <th>0.459605</th>\n",
       "    <th>0.858611</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>16</th>\n",
       "    <th>0.412201</th>\n",
       "    <th>0.452259</th>\n",
       "    <th>0.856389</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>17</th>\n",
       "    <th>0.392126</th>\n",
       "    <th>0.451724</th>\n",
       "    <th>0.848889</th>\n",
       "    <th>00:21</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>18</th>\n",
       "    <th>0.387675</th>\n",
       "    <th>0.449242</th>\n",
       "    <th>0.850278</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>19</th>\n",
       "    <th>0.394624</th>\n",
       "    <th>0.454812</th>\n",
       "    <th>0.851389</th>\n",
       "    <th>00:19</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.8272222280502319.\n",
      "Better model found at epoch 2 with accuracy value: 0.8347222208976746.\n",
      "Better model found at epoch 5 with accuracy value: 0.8433333039283752.\n",
      "Better model found at epoch 6 with accuracy value: 0.8461111187934875.\n",
      "Better model found at epoch 7 with accuracy value: 0.8483333587646484.\n",
      "Better model found at epoch 10 with accuracy value: 0.8488888740539551.\n",
      "Better model found at epoch 12 with accuracy value: 0.8502777814865112.\n",
      "Better model found at epoch 13 with accuracy value: 0.8630555272102356.\n"
     ]
    }
   ],
   "source": [
    "learn.unfreeze()\n",
    "## 0.7 drop\n",
    "learn.fit_one_cycle(20, slice(1e-3/(2.6**4),1e-2), moms=(0.7,0.4), wd=0.25, pct_start=0.4, div_factor=10.,\n",
    "             callbacks=[SaveModelCallback(learn,every='improvement',mode='max',monitor='accuracy',name='best_acc_model_Q')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.recorder.plot_losses()\n",
    "learn.recorder.plot_metrics()\n",
    "learn.recorder.plot_lr(show_moms=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='10' class='' max='20', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      50.00% [10/20 03:37<03:37]\n",
       "    </div>\n",
       "    \n",
       "<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.431046</th>\n",
       "    <th>0.442774</th>\n",
       "    <th>0.849444</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.417311</th>\n",
       "    <th>0.441951</th>\n",
       "    <th>0.852222</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.413646</th>\n",
       "    <th>0.445484</th>\n",
       "    <th>0.850833</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.402241</th>\n",
       "    <th>0.449529</th>\n",
       "    <th>0.852500</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>0.403372</th>\n",
       "    <th>0.453549</th>\n",
       "    <th>0.853611</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>0.396146</th>\n",
       "    <th>0.452103</th>\n",
       "    <th>0.862500</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>0.386636</th>\n",
       "    <th>0.473986</th>\n",
       "    <th>0.855000</th>\n",
       "    <th>00:19</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>0.383117</th>\n",
       "    <th>0.444590</th>\n",
       "    <th>0.851389</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>0.383484</th>\n",
       "    <th>0.467547</th>\n",
       "    <th>0.848889</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>9</th>\n",
       "    <th>0.382047</th>\n",
       "    <th>0.458127</th>\n",
       "    <th>0.850278</th>\n",
       "    <th>00:20</th>\n",
       "  </tr>\n",
       "</table>\n",
       "\n",
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='0' class='progress-bar-interrupted' max='323', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      Interrupted\n",
       "    </div>\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.8494444489479065.\n",
      "Better model found at epoch 1 with accuracy value: 0.852222204208374.\n",
      "Better model found at epoch 3 with accuracy value: 0.8525000214576721.\n",
      "Better model found at epoch 4 with accuracy value: 0.8536111116409302.\n",
      "Better model found at epoch 5 with accuracy value: 0.862500011920929.\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-134-e42263dd6cd9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m learn.fit(20, slice(1e-3/(2.6**4)/25.,3e-2/10.), wd=0.125,\n\u001b[0;32m----> 2\u001b[0;31m              callbacks=[SaveModelCallback(learn,every='improvement',mode='max',monitor='accuracy',name='best_acc_model_Q')])\n\u001b[0m",
      "\u001b[0;32m~/fast_ai/fastai-fork/fastai/basic_train.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, epochs, lr, wd, callbacks)\u001b[0m\n\u001b[1;32m    198\u001b[0m         \u001b[0mcallbacks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mcb\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcb\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcallback_fns\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdefaults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextra_callback_fns\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mlistify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcallbacks\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    199\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mdefaults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextra_callbacks\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcallbacks\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mdefaults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextra_callbacks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 200\u001b[0;31m         \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mepochs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetrics\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcallbacks\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mcallbacks\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    201\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    202\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcreate_opt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mFloats\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwd\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mFloats\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m->\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/fast_ai/fastai-fork/fastai/basic_train.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(epochs, learn, callbacks, metrics)\u001b[0m\n\u001b[1;32m     99\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mxb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0myb\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mprogress_bar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_dl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparent\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpbar\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    100\u001b[0m                 \u001b[0mxb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 101\u001b[0;31m                 \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloss_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss_func\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    102\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_batch_end\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/fast_ai/fastai-fork/fastai/basic_train.py\u001b[0m in \u001b[0;36mloss_batch\u001b[0;34m(model, xb, yb, loss_func, opt, cb_handler)\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     32\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mopt\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 33\u001b[0;31m         \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mskip_bwd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_backward_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     34\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mskip_bwd\u001b[0m\u001b[0;34m:\u001b[0m                     \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     35\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mcb_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_backward_end\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mopt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/fast_ai/fastai-fork/fastai/callback.py\u001b[0m in \u001b[0;36mon_backward_begin\u001b[0;34m(self, loss)\u001b[0m\n\u001b[1;32m    288\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mon_backward_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m->\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    289\u001b[0m         \u001b[0;34m\"Handle gradient calculation on `loss`.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 290\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msmoothener\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    291\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'last_loss'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'smooth_loss'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msmoothener\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msmooth\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    292\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'backward_begin'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcall_mets\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "learn.fit(20, slice(1e-3/(2.6**4)/25.,3e-2/10.), wd=0.125,\n",
    "             callbacks=[SaveModelCallback(learn,every='improvement',mode='max',monitor='accuracy',name='best_acc_model_Q')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.recorder.plot_losses()\n",
    "learn.recorder.plot_metrics()\n",
    "learn.recorder.plot_lr(show_moms=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('rnn_trained_unfreezeAll_labelsmoothing_lmAndclas')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "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": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<span style=\"font-family: monospace;\"><span title=\"0.065\" style=\"background-color: rgba(234, 242, 250, 0.5);\">▁</span> <span title=\"0.141\" style=\"background-color: rgba(218, 232, 245, 0.5);\">xxbos</span> <span title=\"0.224\" style=\"background-color: rgba(203, 222, 240, 0.5);\">▁es</span> <span title=\"0.271\" style=\"background-color: rgba(191, 216, 236, 0.5);\">▁increíble</span> <span title=\"0.170\" style=\"background-color: rgba(213, 229, 244, 0.5);\">▁lo</span> <span title=\"0.224\" style=\"background-color: rgba(203, 222, 240, 0.5);\">▁que</span> <span title=\"0.431\" style=\"background-color: rgba(135, 189, 220, 0.5);\">▁dura</span> <span title=\"0.281\" style=\"background-color: rgba(187, 214, 235, 0.5);\">▁la</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁batería</span> <span title=\"0.311\" style=\"background-color: rgba(178, 210, 232, 0.5);\">▁del</span> <span title=\"0.710\" style=\"background-color: rgba(43, 123, 186, 0.5);\">▁celular</span> <span title=\"0.372\" style=\"background-color: rgba(158, 202, 225, 0.5);\">▁cuando</span> <span title=\"0.573\" style=\"background-color: rgba(83, 157, 204, 0.5);\">▁nadie</span> <span title=\"0.712\" style=\"background-color: rgba(42, 122, 185, 0.5);\">▁te</span> <span title=\"0.708\" style=\"background-color: rgba(43, 123, 186, 0.5);\">▁quiere</span> <span title=\"0.137\" style=\"background-color: rgba(219, 233, 246, 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.064\" style=\"background-color: rgba(234, 242, 250, 0.5);\">▁</span> <span title=\"0.142\" style=\"background-color: rgba(218, 232, 245, 0.5);\">xxbos</span> <span title=\"0.148\" style=\"background-color: rgba(218, 232, 245, 0.5);\">▁&quot;</span> <span title=\"0.148\" style=\"background-color: rgba(218, 232, 245, 0.5);\">la</span> <span title=\"0.214\" style=\"background-color: rgba(205, 223, 241, 0.5);\">▁vida</span> <span title=\"0.154\" style=\"background-color: rgba(216, 231, 245, 0.5);\">▁es</span> <span title=\"0.309\" style=\"background-color: rgba(178, 210, 232, 0.5);\">▁corta</span> <span title=\"0.164\" style=\"background-color: rgba(214, 229, 244, 0.5);\">▁para</span> <span title=\"0.397\" style=\"background-color: rgba(149, 197, 223, 0.5);\">...&quot;</span> <span title=\"0.709\" style=\"background-color: rgba(43, 123, 186, 0.5);\">▁bitch</span> <span title=\"0.128\" style=\"background-color: rgba(221, 234, 246, 0.5);\">▁,</span> <span title=\"0.219\" style=\"background-color: rgba(204, 223, 241, 0.5);\">▁la</span> <span title=\"0.268\" style=\"background-color: rgba(192, 216, 237, 0.5);\">▁vida</span> <span title=\"0.302\" style=\"background-color: rgba(181, 211, 233, 0.5);\">▁es</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁corta</span> <span title=\"0.360\" style=\"background-color: rgba(162, 203, 226, 0.5);\">▁para</span> <span title=\"0.268\" style=\"background-color: rgba(192, 216, 237, 0.5);\">▁todo</span> <span title=\"0.055\" style=\"background-color: rgba(236, 243, 251, 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.061\" style=\"background-color: rgba(235, 243, 251, 0.5);\">▁</span> <span title=\"0.207\" style=\"background-color: rgba(206, 224, 241, 0.5);\">xxbos</span> <span title=\"0.564\" style=\"background-color: rgba(85, 159, 205, 0.5);\">▁hombres</span> <span title=\"0.210\" style=\"background-color: rgba(206, 224, 241, 0.5);\">:</span> <span title=\"0.231\" style=\"background-color: rgba(201, 221, 240, 0.5);\">▁ustedes</span> <span title=\"0.201\" style=\"background-color: rgba(207, 225, 242, 0.5);\">▁qué</span> <span title=\"0.297\" style=\"background-color: rgba(183, 212, 234, 0.5);\">▁saben</span> <span title=\"0.316\" style=\"background-color: rgba(177, 210, 231, 0.5);\">▁de</span> <span title=\"0.664\" style=\"background-color: rgba(55, 135, 192, 0.5);\">▁deportes</span> <span title=\"0.730\" style=\"background-color: rgba(37, 117, 183, 0.5);\">▁extremos</span> <span title=\"0.202\" style=\"background-color: rgba(207, 225, 242, 0.5);\">▁,</span> <span title=\"0.244\" style=\"background-color: rgba(199, 219, 239, 0.5);\">▁si</span> <span title=\"0.317\" style=\"background-color: rgba(176, 209, 231, 0.5);\">▁nunca</span> <span title=\"0.448\" style=\"background-color: rgba(128, 185, 218, 0.5);\">▁han</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁corrido</span> <span title=\"0.419\" style=\"background-color: rgba(139, 192, 221, 0.5);\">▁en</span> <span title=\"0.962\" style=\"background-color: rgba(8, 57, 120, 0.5);\">▁tacones</span> <span title=\"0.075\" style=\"background-color: rgba(232, 241, 250, 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.089\" style=\"background-color: rgba(229, 239, 249, 0.5);\">▁</span> <span title=\"0.185\" style=\"background-color: rgba(210, 227, 243, 0.5);\">xxbos</span> <span title=\"0.318\" style=\"background-color: rgba(176, 209, 231, 0.5);\">▁ayer</span> <span title=\"0.565\" style=\"background-color: rgba(85, 159, 205, 0.5);\">▁comí</span> <span title=\"0.174\" style=\"background-color: rgba(212, 228, 243, 0.5);\">▁con</span> <span title=\"0.271\" style=\"background-color: rgba(191, 216, 236, 0.5);\">▁un</span> <span title=\"0.834\" style=\"background-color: rgba(15, 91, 163, 0.5);\">▁adicto</span> <span title=\"0.295\" style=\"background-color: rgba(183, 212, 234, 0.5);\">▁al</span> <span title=\"0.671\" style=\"background-color: rgba(53, 133, 191, 0.5);\">▁ajedrez</span> <span title=\"0.270\" style=\"background-color: rgba(192, 216, 237, 0.5);\">▁,</span> <span title=\"0.683\" style=\"background-color: rgba(50, 130, 190, 0.5);\">▁teníamos</span> <span title=\"0.327\" style=\"background-color: rgba(173, 208, 230, 0.5);\">▁un</span> <span title=\"0.523\" style=\"background-color: rgba(99, 169, 211, 0.5);\">▁cubre</span> <span title=\"0.247\" style=\"background-color: rgba(198, 219, 239, 0.5);\">mesa</span> <span title=\"0.176\" style=\"background-color: rgba(212, 228, 243, 0.5);\">▁a</span> <span title=\"0.327\" style=\"background-color: rgba(173, 208, 230, 0.5);\">▁cuadros</span> <span title=\"0.153\" style=\"background-color: rgba(216, 231, 245, 0.5);\">▁y</span> <span title=\"0.221\" style=\"background-color: rgba(203, 222, 240, 0.5);\">▁le</span> <span title=\"0.371\" style=\"background-color: rgba(160, 202, 225, 0.5);\">▁tomó</span> <span title=\"0.215\" style=\"background-color: rgba(205, 223, 241, 0.5);\">▁2</span> <span title=\"0.269\" style=\"background-color: rgba(192, 216, 237, 0.5);\">▁horas</span> <span title=\"0.646\" style=\"background-color: rgba(60, 140, 195, 0.5);\">▁pasarme</span> <span title=\"0.445\" style=\"background-color: rgba(128, 185, 218, 0.5);\">▁la</span> <span title=\"0.881\" style=\"background-color: rgba(8, 79, 153, 0.5);\">▁maldita</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁sal</span> <span title=\"0.136\" style=\"background-color: rgba(220, 233, 246, 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.038\" style=\"background-color: rgba(239, 246, 252, 0.5);\">▁</span> <span title=\"0.142\" style=\"background-color: rgba(218, 232, 245, 0.5);\">xxbos</span> <span title=\"0.253\" style=\"background-color: rgba(197, 218, 238, 0.5);\">▁tipos</span> <span title=\"0.087\" style=\"background-color: rgba(229, 239, 249, 0.5);\">▁de</span> <span title=\"0.117\" style=\"background-color: rgba(224, 236, 247, 0.5);\">▁te</span> <span title=\"0.099\" style=\"background-color: rgba(227, 238, 248, 0.5);\">:</span> <span title=\"0.237\" style=\"background-color: rgba(200, 220, 239, 0.5);\">▁extraño</span> <span title=\"0.060\" style=\"background-color: rgba(235, 243, 251, 0.5);\">▁</span> <span title=\"0.064\" style=\"background-color: rgba(234, 242, 250, 0.5);\">xxnl</span> <span title=\"0.191\" style=\"background-color: rgba(209, 226, 242, 0.5);\">▁te</span> <span title=\"0.206\" style=\"background-color: rgba(206, 224, 241, 0.5);\">:</span> <span title=\"0.320\" style=\"background-color: rgba(176, 209, 231, 0.5);\">▁la</span> <span title=\"1.000\" style=\"background-color: rgba(8, 48, 107, 0.5);\">▁cre</span> <span title=\"0.401\" style=\"background-color: rgba(147, 196, 222, 0.5);\">iste</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": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save(\"haha_20190516_tweet_vocab_labelsmoothing_lmAndclas\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate test file for submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tweet1</td>\n",
       "      <td>Historia #36.\\n*Entra corriendo y gritando al ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>tweet2</td>\n",
       "      <td>estoy tomando helado en el centro y pedi tiram...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>tweet3</td>\n",
       "      <td>— ¿De 15 o 20 centímetros?\\n\\n— Ven y averígua...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>tweet4</td>\n",
       "      <td>Que fea soy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>tweet5</td>\n",
       "      <td>#OMG, VAMOS EN RETROCESO RESULTE CON 40 SEGUID...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       id                                               text\n",
       "0  tweet1  Historia #36.\\n*Entra corriendo y gritando al ...\n",
       "1  tweet2  estoy tomando helado en el centro y pedi tiram...\n",
       "2  tweet3  — ¿De 15 o 20 centímetros?\\n\\n— Ven y averígua...\n",
       "3  tweet4                                        Que fea soy\n",
       "4  tweet5  #OMG, VAMOS EN RETROCESO RESULTE CON 40 SEGUID..."
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df = pd.read_csv('./data/haha_2019_test.csv')\n",
    "test_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6000, 2)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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"
     ]
    }
   ],
   "source": [
    "## apply the rules\n",
    "raw_text = test_df.loc[:,'text']\n",
    "\n",
    "print(\"Default Rules:\\n\",[x.__name__ for x in default_rules],\"\\n\\n\")\n",
    "for rule in default_rules:\n",
    "    raw_text = raw_text.apply(lambda x: rule(str(x)))    \n",
    "test_df['new_text'] =  raw_text #tokenizer adds xxbos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_tst = TextClasDataBunch.from_df(PATH, df_train, df_valid, test_df,\n",
    "                               tokenizer=mycust_tok, vocab=sp_vocab,\n",
    "                               text_cols='new_text', label_cols='is_humor')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.data = data_tst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "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": [
    "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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAARoAAAEmCAYAAAC9C19sAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAFBtJREFUeJzt3XucXWV97/HPbzKZ3APBBAiBXEggMaGnKBEptMrFw0VA8ELlUiqKYotaI9qClh4iXrgo56ilVUTkIBwuVY+VmxK1KIIgCUExhHCRECHBEBISIExuk1//2GvSSZqZTJJ5Zk8mn/frtV/stdaznvVb7NlfnvWsNUNkJpJUUkO9C5DU+xk0koozaCQVZ9BIKs6gkVScQSOpOINmJxURAyLitohYERHf3Y5+zoiIGV1ZW71ExF9ExOP1rqM3Cp+j6dki4nTgPGAS8ArwG+ALmXnvdvZ7JvAx4NDMXLfdhfZwEZHAfpn5VL1r2Rk5ounBIuI84CvAF4E9gNHAvwIndUH3Y4AndoaQ6YyIaKx3Db1aZvrqgS9gF+BV4JQO2vSjFkSLqtdXgH7VtsOB54BPAi8AzwPvr7Z9FlgDrK2OcTYwHbihTd9jgQQaq+WzgKepjarmA2e0WX9vm/0OBWYCK6p/Htpm28+BzwH3Vf3MAIa3c26t9f9Dm/pPBt4OPAEsAz7Tpv3BwP3A8qrtlUBTte2e6lxWVuf73jb9nw/8Ebi+dV21z/jqGG+slvcClgCH1/tnY0d81b0AX+18MHAssK71i95Om4uBB4DdgRHAr4DPVdsOr/a/GOhbfUFfA4ZV2zcNlnaDBhgEvAxMrLaNBKZU7zcEDbAb8BJwZrXfadXy66rtPwd+D+wPDKiWL23n3Frr/19V/R+qvug3AkOAKUAzMK5qfxBwSHXcscBjwLQ2/SUwYTP9X0YtsAe0DZqqzYeAucBA4C7gy/X+udhRX1469VyvA17Mji9tzgAuzswXMnMJtZHKmW22r622r83MO6n913ziNtazHjggIgZk5vOZ+ehm2hwPPJmZ12fmusy8CZgHnNimzbWZ+URmNgP/BhzYwTHXUpuPWgvcDAwHvpqZr1THnwv8KUBmPpSZD1THfQa4CnhrJ87posxcXdWzkcy8GngK+DW1cP3HLfSndhg0PddSYPgW5g72Aha0WV5QrdvQxyZB9RoweGsLycyV1C43/gZ4PiLuiIhJnaintaZRbZb/uBX1LM3Mlup9axAsbrO9uXX/iNg/Im6PiD9GxMvU5rWGd9A3wJLMXLWFNlcDBwD/nJmrt9BW7TBoeq77gdXU5iXas4japG6r0dW6bbGS2iVCqz3bbszMuzLzf1L7L/s8al/ALdXTWtPCbaxpa3ydWl37ZeZQ4DNAbGGfDm+5RsRgavNe1wDTI2K3rih0Z2TQ9FCZuYLa/MS/RMTJETEwIvpGxHERcXnV7CbgwogYERHDq/Y3bOMhfwO8JSJGR8QuwKdbN0TEHhFxUkQMohZ+r1K77NjUncD+EXF6RDRGxHuBycDt21jT1hhCbR7p1Wq09bebbF8M7LuVfX4VmJWZHwTuAL6x3VXupAyaHiwzr6D2DM2F1CZCnwU+Cvx71eTzwCzgEeB3wOxq3bYc6yfALVVfD7FxODRUdSyidifmrfz3LzKZuRQ4gdqdrqXU7hidkJkvbktNW+lTwOnU7mZdTe1c2poOXBcRyyPiL7fUWUScRG1CvvU8zwPeGBFndFnFOxEf2JNUnCMaScUZNJKKM2gkFWfQSCquR/0iWTQOyGgaUu8yVMCue2zp2TntiFa+uIjVryzf0vNKPSxomobQb+IW7zxqB3T0tLPrXYIKmDG9c3f7vXSSVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFNda7gN6iX1MjP71mGk1NjTT26cMPfvown//GnRx+8P58cdo7aWgIVr62mg9ddD1PP/vihv1OPupAbvryBznsjMuZPfcPTJ0yhiv/6TQAIuAL37iTW+9+pF6ntdN73cC+nPvnY9hlQCMJ/McTS/nRY0t485hdec+BezJql/5ceMfjPL20GYARg5q44uTXs+jlVQA8ueQ1rnngWfo3NjD9uP029LvbwCbufXoZ35m5sB6n1e2KBk1EHAt8FegDfCszLy15vHpavWYdx57zNVY2r6GxsYH/+PZ5zLhvLl/7zKmc8omreHz+Ys455S+44IPHcs5FNwAweGA/PnL64Tz4yPwN/Tz6+0UcdsbltLSsZ8/hQ/n1LZ/mjnvm0NKyvl6ntlNryeT6WQt5Zlkz/RsbuOSEiTyy6BWeXd7M/757Ph/6s33+2z6LX1nNBbc9vtG6VevWb7TuiydM5ME/LC9ef09R7NIpIvoA/wIcB0wGTouIyaWO1xOsbF4DQN/GPjQ29iEzyUyGDuoPwNAhA3h+yYoN7S869wSuuPYnrFqzbsO65lVrN4RKv6a+ZGY3noE2tbx5Hc8sq41WVq1bz8IVq9htYF8WrVjN8y+v3qY+Rw7txy79G5m3eGVXltqjlRzRHAw8lZlPA0TEzcBJwNyCx6yrhobgVzeez/h9RnDVLfcwc84Czr34Rn7wz+eyavUaXl65irf+9RUAHDhpb/becxg/vvdRPvG+t23Uz5sOGMM3pv8Vo0fuxtkXXudopocYMaiJsbsN5KkXOw6IEYObuOSEiTSvbeHfHn6eeS9s3P7Pxg7j/mdeKllqj1NyMngU8Gyb5eeqdb3W+vXJIadeyoRjLmTqAWOYPH4kHzvjCN75sX9lwrH/xPU/fIDLPvkuIoLLPvluzr/i/2+2n5lzFnDQe77An//V5fz9B46mX5NTafXWr7GBTxwxjutmPkfz2vaD/6XmtXz0+4/y6dsf5/qZC/nYW8YyoO/GX7NDx+3KfU8bNN0qIs6JiFkRMSvXNde7nC6x4tVmfjHrCY45bDJ/sv8oZs5ZAMD3ZszmkD8dx5BB/Zg8fiQzvvVx5t3xWQ7+k7F87ysf5o2TR2/Uz+PzF/Pqa6uZMmGvepyGKn0Czjt8HPc+vYyZf1jRYdt165NXV7cAMH9ZM4tfWc3Iof02bB89bAB9Ipi/rHf8rHdWyaBZCLSdKdu7WreRzPxmZk7NzKnROKBgOWUNHzaYXQbX6u/fry9HvXkS8+YvZujgAUwYvTsARx4yicfnL+blV1exz5EXMOn4i5h0/EU8+LtneM+0q5g99w+M2et19OlT+1hGjxzGxHF7smDR0rqdl+DDh41h4YpV3Dl3yRbbDunXSETt/e6Dm9hzaD8Wv7Jmw/bDxg3jvvk712gGys7RzAT2i4hx1ALmVOD0gserqz2HD+Xqi8+kT0MDDQ3B938ymx/9cg4f+dyN3PTlD7I+17P85WY+PP2GDvs59A378qn3H83adS2sX598/Iu3sHT5zjNp2NNM3H0Qbxm/GwuWNXPpiRMBuHn28/TtE5x18N4M7d/IPxw1ngXLmrnkp7/n9XsM4pQ3jKRlfZIJ37r/WVauadnQ3yFjd+Wyn/6+XqdTN1HyrkZEvB34CrXb29/OzC901L5h4O7Zb+JfFqtH9XPStLPrXYIKmDH9DJbNnxtbald0ljEz7wTuLHkMST1f3SeDJfV+Bo2k4gwaScUZNJKKM2gkFWfQSCrOoJFUnEEjqTiDRlJxBo2k4gwaScUZNJKKM2gkFWfQSCrOoJFUnEEjqTiDRlJxBo2k4gwaScUZNJKKM2gkFWfQSCrOoJFUnEEjqTiDRlJxBo2k4gwaScUZNJKKM2gkFWfQSCrOoJFUnEEjqTiDRlJxBo2k4gwaScUZNJKKM2gkFWfQSCrOoJFUnEEjqTiDRlJxBo2k4hrb2xARtwHZ3vbMfEeRiiT1Ou0GDfDlbqtCUq/WbtBk5i+6sxBJvVdHIxoAImI/4BJgMtC/dX1m7luwLkm9SGcmg68Fvg6sA44AvgPcULIoSb1LZ4JmQGb+DIjMXJCZ04Hjy5YlqTfZ4qUTsDoiGoAnI+KjwEJgcNmyJPUmnRnRfBwYCPwdcBBwJvC+kkVJ6l22OKLJzJnV21eB95ctR1Jv1Jm7TnezmQf3MvPIIhVJ6nU6M0fzqTbv+wPvpnYHSpI6pTOXTg9tsuq+iHiwRDFveP1o7vv1lSW6llTAYV8b2Kl2nbl02q3NYgO1CeFdtq0sSTujzlw6PURtjiaoXTLNB84uWZSk3qUzQfP6zFzVdkVE9CtUj6ReqDPP0fxqM+vu7+pCJPVeHf09mj2BUcCAiHgDtUsngKHUHuCTpE7p6NLpGOAsYG/gCv4raF4GPlO2LEm9SUd/j+Y64LqIeHdmfr8ba5LUy3RmjuagiNi1dSEihkXE5wvWJKmX6UzQHJeZy1sXMvMl4O3lSpLU23QmaPq0vZ0dEQMAb29L6rTOPEfz/4CfRcS11CaEzwKuK1mUpN6lM7/rdFlE/BZ4G7UnhO8CxpQuTFLv0dn/gdxiaiFzCnAk8FixiiT1Oh09sLc/cFr1ehG4hdrfDT6im2qT1Et0dOk0D/glcEJmPgUQEZ/olqok9SodXTq9C3geuDsiro6Io/ivp4MlqdPaDZrM/PfMPBWYBNwNTAN2j4ivR8TR3VWgpB3fFieDM3NlZt6YmSdS+72nh4Hzi1cmqdfo7F0noPZUcGZ+MzOPKlWQpN5nq4JGkraFQSOpOINGUnEGjaTiDBpJxRk0koozaCQVZ9BIKs6gkVScQSOpOINGUnEGjaTiDBpJxRk0koozaCQVZ9BIKs6gkVScQSOpOINGUnEGjaTiDBpJxRk0koozaCQVZ9BIKs6gkVScQSOpOINGUnEGjaTiDBpJxRk0koozaCQVZ9BIKs6gkVScQSOpOINGUnEGjaTiDJpuNuOuH/M/pkxkyqQJfOnyS+tdjrqQn237igVNRHw7Il6IiDmljrGjaWlpYdrffYQf3vYjHn5kLt+9+SYemzu33mWpC/jZdqzkiOb/AscW7H+HM/PBBxk/fgLj9t2XpqYmTnnvqdx+2w/rXZa6gJ9tx4oFTWbeAywr1f+OaNGihey99z4blkeN2puFCxfWsSJ1FT/bjtV9jiYizomIWRExa8mLS+pdjqQC6h40mfnNzJyamVNHDB9R73KK2muvUTz33LMblhcufI5Ro0bVsSJ1FT/bjtU9aHYmU9/0Jp566kmemT+fNWvW8N1bbub4E95R77LUBfxsO9ZY7wJ2Jo2Njfyfr17JiccfQ0tLC+876wNMnjKl3mWpC/jZdiwys0zHETcBhwPDgcXARZl5TUf7HHTQ1Lzv17OK1COp6x325qk89NCs2FK7YiOazDytVN+SdizO0UgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIMGknFGTSSijNoJBVn0EgqzqCRVJxBI6k4g0ZScQaNpOIiM+tdwwYRsQRYUO86uslw4MV6F6Eut7N9rmMyc8SWGvWooNmZRMSszJxa7zrUtfxcN89LJ0nFGTSSijNo6ueb9S5ARfi5boZzNJKKc0QjqTiDRlJxBo2k4hrrXcDOICImAScBo6pVC4FbM/Ox+lUldR9HNIVFxPnAzUAAD1avAG6KiAvqWZvUXbzrVFhEPAFMycy1m6xvAh7NzP3qU5lKioj3Z+a19a6jp3BEU956YK/NrB9ZbVPv9Nl6F9CTOEdT3jTgZxHxJPBstW40MAH4aN2q0naLiEfa2wTs0Z219HReOnWDiGgADmbjyeCZmdlSv6q0vSJiMXAM8NKmm4BfZebmRrI7JUc03SAz1wMP1LsOdbnbgcGZ+ZtNN0TEz7u/nJ7LEY2k4pwMllScQSOpOINGAERES0T8JiLmRMR3I2LgdvR1eETcXr1/R0cPJkbErhFx7jYcY3pEfGpba1T3MmjUqjkzD8zMA4A1wN+03Rg1W/3zkpm3ZualHTTZFdjqoNGOxaDR5vwSmBARYyPi8Yj4DjAH2Ccijo6I+yNidjXyGQwQEcdGxLyImA28q7WjiDgrIq6s3u8RET+IiN9Wr0OBS4Hx1WjqS1W7v4+ImRHxSER8tk1f/xgRT0TEvcDEbvu3oe3m7W1tJCIageOAH1er9gPel5kPRMRw4ELgbZm5svo9rvMi4nLgauBI4Cnglna6/xrwi8x8Z0T0AQYDFwAHZOaB1fGPro55MLXnUW6NiLcAK4FTgQOp/dzOBh7q2rNXKQaNWg2IiNbnQX4JXEPtVycWZGbrM0CHAJOB+yICoAm4H5gEzM/MJwEi4gbgnM0c40jgrwGqhxVXRMSwTdocXb0erpYHUwueIcAPMvO16hi3btfZqlsZNGrV3DqqaFWFycq2q4CfZOZpm7TbaL/tFMAlmXnVJseY1oXHUDdzjkZb4wHgsIiYABARgyJif2AeMDYixlftTmtn/58Bf1vt2ycidgFeoTZaaXUX8IE2cz+jImJ34B7g5IgYEBFDgBO7+NxUkEGjTsvMJcBZ1P6WziNUl02ZuYrapdId1WTwC+108XHgiIj4HbX5lcmZuZTapdiciPhSZs4AbgTur9p9DxiSmbOpzf38FvgRMLPYiarL+SsIkopzRCOpOINGUnEGjaTiDBpJxRk0koozaCQVZ9BIKu4/Af1rF4a4RRXmAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "preds_tst,y_tst,losses_tst = learn.get_preds(DatasetType.Test,with_loss=True, ordered=True)\n",
    "interp_t = ClassificationInterpretation(learn, preds_tst, y_tst, losses_tst)\n",
    "interp_t.plot_confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text ▁ xxbos ▁¿ le ▁pusiste ▁a ▁tu ▁hijo ▁bec kh am ▁hace ▁16 ▁años ▁y ▁ahora ▁odia ▁el ▁fútbol ▁, ▁a ▁la ▁humanidad ▁y ▁a ▁ti ... ▁? ▁. ¡ normal ▁, ▁ya ▁hay ▁que ▁ser ▁gilipollas ▁! ▁."
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_tst.test_ds.get(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "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>new_text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tweet1</td>\n",
       "      <td>Historia #36.\\n*Entra corriendo y gritando al ...</td>\n",
       "      <td>historia # 36.xxnl *entra corriendo y gritando...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>tweet2</td>\n",
       "      <td>estoy tomando helado en el centro y pedi tiram...</td>\n",
       "      <td>estoy tomando helado en el centro y pedi tiram...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>tweet3</td>\n",
       "      <td>— ¿De 15 o 20 centímetros?\\n\\n— Ven y averígua...</td>\n",
       "      <td>— ¿de 15 o 20 centímetros ? xxnl xxnl — ven y ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>tweet4</td>\n",
       "      <td>Que fea soy</td>\n",
       "      <td>que fea soy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>tweet5</td>\n",
       "      <td>#OMG, VAMOS EN RETROCESO RESULTE CON 40 SEGUID...</td>\n",
       "      <td># xxup omg , xxup vamos en xxup retroceso xxu...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       id                                               text  \\\n",
       "0  tweet1  Historia #36.\\n*Entra corriendo y gritando al ...   \n",
       "1  tweet2  estoy tomando helado en el centro y pedi tiram...   \n",
       "2  tweet3  — ¿De 15 o 20 centímetros?\\n\\n— Ven y averígua...   \n",
       "3  tweet4                                        Que fea soy   \n",
       "4  tweet5  #OMG, VAMOS EN RETROCESO RESULTE CON 40 SEGUID...   \n",
       "\n",
       "                                            new_text  \n",
       "0  historia # 36.xxnl *entra corriendo y gritando...  \n",
       "1  estoy tomando helado en el centro y pedi tiram...  \n",
       "2  — ¿de 15 o 20 centímetros ? xxnl xxnl — ven y ...  \n",
       "3                                        que fea soy  \n",
       "4   # xxup omg , xxup vamos en xxup retroceso xxu...  "
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_cols = ['id','is_humor','funniness_average'] #need value in last col.  Try 3?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_df = test_df['id'].to_frame().copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_df['is_humor'] = to_np(preds_tst.argmax(dim=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_df['funniness_average'] = 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "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>is_humor</th>\n",
       "      <th>funniness_average</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>tweet1</td>\n",
       "      <td>1</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>tweet2</td>\n",
       "      <td>0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>tweet3</td>\n",
       "      <td>1</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>tweet4</td>\n",
       "      <td>0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>tweet5</td>\n",
       "      <td>0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       id  is_humor  funniness_average\n",
       "0  tweet1         1                3.0\n",
       "1  tweet2         0                3.0\n",
       "2  tweet3         1                3.0\n",
       "3  tweet4         0                3.0\n",
       "4  tweet5         0                3.0"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_df.to_csv('sub0520_1.csv',header=True,index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id,is_humor,funniness_average\r\n",
      "tweet1,1,3.0\r\n",
      "tweet2,0,3.0\r\n",
      "tweet3,1,3.0\r\n",
      "tweet4,0,3.0\r\n",
      "tweet5,0,3.0\r\n",
      "tweet6,0,3.0\r\n",
      "tweet7,0,3.0\r\n",
      "tweet8,0,3.0\r\n",
      "tweet9,0,3.0\r\n"
     ]
    }
   ],
   "source": [
    "!head sub0520_1.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  adding: sub0520_1.csv (deflated 84%)\r\n"
     ]
    }
   ],
   "source": [
    "!zip  sub0520_1.zip sub0520_1.csv "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cp sub0520_1.zip /mnt/awcnas4_AWX/tmp/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.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
}