Tweets_Spanish_SP_LM_more_rules_RNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.text import *\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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = Path('./data/rnn/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def myreadlines(f, newline:str='\\n', rsz:int=4096):                                                                                                \n",
    "    \"read with custom newline\"                                                                                                                     \n",
    "    buf = ''                                                                                                                                       \n",
    "    while True:                                                                                                                                    \n",
    "        while newline in buf:                                                                                                                      \n",
    "            pos = buf.index(newline)                                                                                                               \n",
    "            yield buf[:pos]                                                                                                                        \n",
    "            buf = buf[pos + len(newline):]                                                                                                         \n",
    "        chunk = f.read(rsz)                                                                                                                        \n",
    "        if not chunk: break                                                                                                                        \n",
    "        buf += chunk\n",
    "        \n",
    "corpus_fname = './data/all_file.txt'\n",
    "corpus_txt = []\n",
    "with open(corpus_fname,'r') as f:\n",
    "    next(f)\n",
    "    for kk,line in enumerate(myreadlines(f,'\"\\n')): \n",
    "        corpus_txt.append(line.lstrip('\"'))\n",
    "        \n",
    "all_texts_df = pd.DataFrame(corpus_txt,columns=[\"tweet_text\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(475145, 1)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_texts_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Saber, entender y estar convencides que la frase #LaESILaDefendemosEntreTodes es nuestra linea es nuestro eje.\\n#AlertaESI!!!!\\nVamos por mas!!! e invitamos a todas aquellas personas que quieran se parte.'],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_texts_df.iloc[2,:].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentence Piece Tokenizer"
   ]
  },
  {
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sub_nl(t:str) -> str:\n",
    "    \"Replaces \\n by xxnl\"\n",
    "    return t.replace(\"\\r\\n\",\"\\n\").replace(\"\\n\",NL+\" \")\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": 10,
   "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 0x7fc795a54158>\n",
      "<function replace_rep at 0x7fc795c03d90>\n",
      "<function replace_wrep at 0x7fc795a54048>\n",
      "<function deal_caps at 0x7fc795a540d0>\n",
      "<function spec_add_spaces at 0x7fc795c038c8>\n",
      "<function rm_useless_spaces at 0x7fc795c03f28>\n",
      "<function sub_nl at 0x7fc795c03e18>\n"
     ]
    }
   ],
   "source": [
    "raw_text = all_texts_df.loc[:,'tweet_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": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "@RaulB2005 raúl te quiero muchísimo y aunque no te haya visto en la puta vida eres una de las personas más importantes que he conocido, muchas gracias por todo uwu\n",
      "xxbos  @ raulb2005 raúl te quiero muchísimo y aunque no te haya visto en la puta vida eres una de las personas más importantes que he conocido , muchas gracias por todo uwu\n",
      "---------------\n",
      "@piopiotwit @CristoReySpain @veronicafumanal @vox_es @monasterioR No opinó ,que si no sube el pan y como lo vea pedro Sánchez es capaz de hacerlo y ahora que ha bajado que no me culpen\n",
      "xxbos  @ piopiotwit @ cristoreyspain @ veronicafumanal @ vox_es @ monasterior no opinó , que si no sube el pan y como lo vea pedro sánchez es capaz de hacerlo y ahora que ha bajado que no me culpen\n",
      "---------------\n",
      "Saber, entender y estar convencides que la frase #LaESILaDefendemosEntreTodes es nuestra linea es nuestro eje.\n",
      "#AlertaESI!!!!\n",
      "Vamos por mas!!! e invitamos a todas aquellas personas que quieran se parte.\n",
      "xxbos saber , entender y estar convencides que la frase # laesiladefendemosentretodes es nuestra linea es nuestro eje.xxnl  # alertaesi xxrep 4 ! xxnl vamos por mas ! ! ! e invitamos a todas aquellas personas que quieran se parte.\n",
      "---------------\n"
     ]
    }
   ],
   "source": [
    "for kk in range(3):\n",
    "    print(all_texts_df['tweet_text'].iloc[kk])\n",
    "    print(all_texts_df['new_text'].iloc[kk])\n",
    "    print('-'*15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "formatted_text_file = './data/twitter_es_0516'\n",
    "all_texts_df['new_text'].to_frame().to_csv(\n",
    "    formatted_text_file, header=False,index=False,quotechar=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_size = 60000 # can't be bigger than total possible size?\n",
    "model_prefix = 'all_tweets_es_0509'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['xxpad', 'xxbos', 'xxeos', 'xxfld', 'xxmaj', 'xxup', 'xxrep', 'xxwrep', 'xxnl']\n"
     ]
    }
   ],
   "source": [
    "uds = [x for x in defaults.text_spec_tok if x != UNK]\n",
    "print(uds)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "spm.SentencePieceTrainer.Train(f'--input={formatted_text_file}'\\\n",
    "                               f' --model_prefix={model_prefix}'\\\n",
    "                               f' --vocab_size={vocab_size}'\\\n",
    "                               f' --model_type=bpe'\\\n",
    "                               f\" --user_defined_symbols={','.join(uds)}\"\n",
    "                               f' --unk_piece={UNK} --bos_id=-1 --eos_id=-1 --pad_id=-1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\txxunk\t0\r\n",
      "     2\txxpad\t0\r\n",
      "     3\txxbos\t0\r\n",
      "     4\txxeos\t0\r\n",
      "     5\txxfld\t0\r\n",
      "     6\txxmaj\t0\r\n",
      "     7\txxup\t0\r\n",
      "     8\txxrep\t0\r\n",
      "     9\txxwrep\t0\r\n",
      "    10\txxnl\t0\r\n",
      "    11\t▁e\t-0\r\n",
      "    12\t▁d\t-1\r\n",
      "    13\t▁p\t-2\r\n",
      "    14\t▁l\t-3\r\n",
      "    15\t▁a\t-4\r\n",
      "    16\t▁c\t-5\r\n",
      "    17\ter\t-6\r\n",
      "    18\tos\t-7\r\n",
      "    19\ten\t-8\r\n",
      "    20\t▁s\t-9\r\n",
      "    21\t▁de\t-10\r\n",
      "    22\tar\t-11\r\n",
      "    23\t▁m\t-12\r\n",
      "    24\tue\t-13\r\n",
      "    25\t▁t\t-14\r\n"
     ]
    }
   ],
   "source": [
    "## Vocab in order of frequency\n",
    "!head -n25 {model_prefix}.vocab | nl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\t→\t-59980\r\n",
      "     2\t😫\t-59981\r\n",
      "     3\t🤨\t-59982\r\n",
      "     4\t😲\t-59983\r\n",
      "     5\t🏟\t-59984\r\n",
      "     6\t📖\t-59985\r\n",
      "     7\t🎸\t-59986\r\n",
      "     8\t🏿\t-59987\r\n",
      "     9\t😮\t-59988\r\n",
      "    10\t🎬\t-59989\r\n"
     ]
    }
   ],
   "source": [
    "!tail -10 {model_prefix}.vocab | nl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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.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.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",
    "        #post rules?\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": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60000"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(itos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "mycust_tok = CustomTokenizer(SPTokenizer,model_prefix,pre_rules=default_rules)\n",
    "sp_vocab = Vocab(itos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_texts = all_texts_df['new_text'].values.squeeze()\n",
    "idx = np.random.permutation(len(all_texts))\n",
    "cut = int(0.1 * len(idx))\n",
    "train_df = pd.DataFrame({'text':all_texts[idx[cut:]], 'labels':[0] * (len(all_texts)-cut)}, columns=['labels','text'])\n",
    "valid_df = pd.DataFrame({'text':all_texts[idx[:cut]], 'labels':[0] * cut}, columns=['labels','text'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((427631, 2), (47514, 2))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.shape, valid_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "keyword_args = {'bs':batch_size}\n",
    "data = TextLMDataBunch.from_df(PATH, train_df, valid_df, \n",
    "                               tokenizer=mycust_tok, vocab=sp_vocab,\n",
    "                               text_cols='text', label_cols='labels',**keyword_args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.save('tweet_es_lm_data_SP_more_rules.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = load_data(PATH,'tweet_es_lm_data_SP_more_rules.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'emb_sz': 400, 'n_hid': 2304, 'n_layers': 3, 'pad_token': 1, 'qrnn': False, 'bidir': False, 'output_p': 0.1, 'hidden_p': 0.15, 'input_p': 0.25, 'embed_p': 0.02, 'weight_p': 0.2, 'tie_weights': True, 'out_bias': True}\n"
     ]
    }
   ],
   "source": [
    "config = awd_lstm_lm_config.copy()\n",
    "config['qrnn'] = False\n",
    "config['n_hid'] = 2304\n",
    "print(config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SequentialRNN(\n",
       "  (0): AWD_LSTM(\n",
       "    (encoder): Embedding(60000, 400, padding_idx=1)\n",
       "    (encoder_dp): EmbeddingDropout(\n",
       "      (emb): Embedding(60000, 400, padding_idx=1)\n",
       "    )\n",
       "    (rnns): ModuleList(\n",
       "      (0): WeightDropout(\n",
       "        (module): LSTM(400, 2304, batch_first=True)\n",
       "      )\n",
       "      (1): WeightDropout(\n",
       "        (module): LSTM(2304, 2304, batch_first=True)\n",
       "      )\n",
       "      (2): WeightDropout(\n",
       "        (module): LSTM(2304, 400, batch_first=True)\n",
       "      )\n",
       "    )\n",
       "    (input_dp): RNNDropout()\n",
       "    (hidden_dps): ModuleList(\n",
       "      (0): RNNDropout()\n",
       "      (1): RNNDropout()\n",
       "      (2): RNNDropout()\n",
       "    )\n",
       "  )\n",
       "  (1): LinearDecoder(\n",
       "    (decoder): Linear(in_features=400, out_features=60000, bias=True)\n",
       "    (output_dp): RNNDropout()\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn = language_model_learner(data, AWD_LSTM,drop_mult=0.5,pretrained=False,config=config)\n",
    "learn.unfreeze()\n",
    "learn.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "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": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 6:04: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>4.810897</th>\n",
       "    <th>4.744090</th>\n",
       "    <th>0.294905</th>\n",
       "    <th>35:13</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>4.492759</th>\n",
       "    <th>4.415994</th>\n",
       "    <th>0.317618</th>\n",
       "    <th>36:16</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>4.351180</th>\n",
       "    <th>4.277734</th>\n",
       "    <th>0.329252</th>\n",
       "    <th>36:34</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>4.254134</th>\n",
       "    <th>4.183558</th>\n",
       "    <th>0.338147</th>\n",
       "    <th>35:15</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>4.136836</th>\n",
       "    <th>4.105386</th>\n",
       "    <th>0.346386</th>\n",
       "    <th>36:45</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>4.027468</th>\n",
       "    <th>4.040223</th>\n",
       "    <th>0.353615</th>\n",
       "    <th>37:00</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>3.922316</th>\n",
       "    <th>3.984550</th>\n",
       "    <th>0.360608</th>\n",
       "    <th>36:59</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>3.791417</th>\n",
       "    <th>3.948491</th>\n",
       "    <th>0.365619</th>\n",
       "    <th>36:57</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>3.717671</th>\n",
       "    <th>3.934413</th>\n",
       "    <th>0.367894</th>\n",
       "    <th>36:57</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>9</th>\n",
       "    <th>3.625161</th>\n",
       "    <th>3.936184</th>\n",
       "    <th>0.368044</th>\n",
       "    <th>36:57</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(10, 3e-3, moms=(0.6,0.4), wd=0.02, pct_start=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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_losses()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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_metrics() ## prob can do better with more training!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8XGW5wPHfk8m+t9m7pku6b6Gl0JZCKVAKsiogmwoooFy5Cl5U9F4RvN6rclUUcAFURHZRsCKllFJKF7rSNF1p0zVpszXN2jTrPPePmbRpmj2zNs/385lPZ855zznvmU7mmXcXVcUYY4zpTIi/M2CMMSbwWbAwxhjTJQsWxhhjumTBwhhjTJcsWBhjjOmSBQtjjDFdsmBhjDGmSxYsjDHGdMmChTHGmC6F+jsDnpKcnKyZmZn+zoYxxgSVTZs2HVXVlK7SnTXBIjMzk40bN/o7G8YYE1RE5GB30lk1lDHGmC55LViISKSIrBeRLSKyXUQe7SDdTSKyw53m5Vbbf+betlNEfi0i4q28GmOM6Zw3q6HqgfmqWiMiYcAqEVmsqmtbEohIFvAwMEdVy0Uk1b19NjAHmOJOugq4CPjQi/k1xhjTAa8FC3XNfV7jfhnmfrSdD/1u4GlVLXcfU9JyOBAJhAPiPrbYW3k1xhjTOa+2WYiIQ0RygBJgqaqua5NkDDBGRFaLyFoRWQigqh8Dy4FC92OJqu70Zl6NMcZ0zKvBQlWbVXUaMASYKSKT2iQJBbKAecAtwLMikigio4Hx7uMGA/NFZG7b84vIPSKyUUQ2lpaWevNWjDGmX/NJbyhVrcBVUljYZlcBsEhVG1V1P7AbV/C4HlirqjWqWgMsBma1c95nVHWGqs5ISemym7Axxphe8mZvqBQRSXQ/jwIuA3a1SfYWrlIFIpKMq1pqH3AIuEhEQt2N4xcBVg1ljDFtvLGpgFfWH/L6dbxZssgAlotILrABV5vF2yLymIhc406zBCgTkR24Sh4PqWoZ8AawF9gKbAG2qOo/vZhXY4wJSq9vzOfNTw57/Tre7A2VC2S3s/0HrZ4r8KD70TpNM3Cvt/JmjDFni+KqOqYMSfT6dWwEtzHGBClVpbiqjrS4CK9fy4KFMcYEqaoTTdQ1OklPiPT6tSxYGGNMkCqqqgMgLd6ChTHGmA60BAsrWRhjjOlQcUuwsJKFMcaYjhRXuoJFijVwG2OM6UhRVR0DosOIDHN4/VoWLIwxJkgVV9X5pHEbLFgYY0zQKqqq80njNliwMMaYoFVcVe+Txm2wYGGMMUGpsdnJ0Zp6Ui1YGGOM6UhpdT2qvuk2CxYsjDEmKJ0akOf9brNgwcIYY4JSiQ+n+gALFsYYE5SKKn03ehssWBhjTFAqqqonzCEMiA73yfUsWBhjTBAqrqojNS6SkBDxyfUsWBhjTBAqqvTdgDywYGGMMUGpuLrOZ+0VYMHCGGOCUnGl7+aFAgsWxhgTdKrrGjne0ExavG/GWIAFC2OMCTrFPlwhr4UFC2OMCTLFVfWA7wbkgReDhYhEish6EdkiIttF5NEO0t0kIjvcaV52b7tYRHJaPepE5Dpv5dUYY4KJrwfkAYR68dz1wHxVrRGRMGCViCxW1bUtCUQkC3gYmKOq5SKSCqCqy4Fp7jQDgTzgPS/m1RhjgkaRj6f6AC8GC1VVoMb9Msz90DbJ7gaeVtVy9zEl7ZzqBmCxqtZ6K6/GGBNMiqvqiI8MJSrc+8uptvBqm4WIOEQkBygBlqrqujZJxgBjRGS1iKwVkYXtnOZm4BVv5tMYY4JJsQ9XyGvh1WChqs2qOg0YAswUkUltkoQCWcA84BbgWRFJbNkpIhnAZGBJe+cXkXtEZKOIbCwtLfXGLRhjTMApqqr3aRUU+Kg3lKpWAMuBtiWHAmCRqjaq6n5gN67g0eIm4E1VbezgvM+o6gxVnZGSkuKNrBtjTMAprvTt6G3wbm+olJZSgohEAZcBu9okewtXqQIRScZVLbWv1f5bsCooY4w5qdmplNb4vmThzd5QGcCfRcSBKyi9rqpvi8hjwEZVXYSremmBiOwAmoGHVLUMQEQygaHACi/m0RhjgsrRmnqanUqaj9ssvNkbKhfIbmf7D1o9V+BB96NtugPAYG/lzxhjgtHJ0dtnSzWUMcYYz/PHgDywYGGMMUGlpWSRluC7SQTBgoUxxgSVoqo6HCFCUowFC2OMMR0orqonNS4Ch4+WU21hwcIYY4JIcZVvFz1qYcHCGGOCSJEfBuSBBQtjjAkqRX6YFwosWBhjTNCobWiiuq6JVB8up9rCgoUxxgSJlhXyrBrKGGNMh/w1IA8sWBhjTNA4NSDPgoUxxpgO+GM51RYWLIwxJkgUV9URGxFKbIQ3JwxvnwULY4wJEq4Beb7vCQUWLIwxJmgUVfpnjAVYsDDGmKBR7Ie1t1tYsDDGmCDQ7FSKqurIsJKFMcaYjpRWu5ZTzUiI8sv1LVgYY0wQOFJ5AoBBiVayMMYY04HCCtcYCytZGGOM6VBhS8nCgoUxxpiOHKmoIzrcQXyU7wfkgQULY4wJCoWVJ8hIiETEt8uptvBasBCRSBFZLyJbRGS7iDzaQbqbRGSHO83LrbYPE5H3RGSne3+mt/JqjDGB7khlHYMS/VMFBeDN8kw9MF9Va0QkDFglIotVdW1LAhHJAh4G5qhquYiktjr+BeDHqrpURGIBpxfzaowxAa2w4gRjx6b47fpeCxaqqkCN+2WY+6Ftkt0NPK2q5e5jSgBEZAIQqqpL3dtrMMaYfqqhyUlpTb3fekKBl9ssRMQhIjlACbBUVde1STIGGCMiq0VkrYgsbLW9QkT+LiKbReRxEXF4M6/GGBOoiqvqUPXfGAvwcrBQ1WZVnQYMAWaKyKQ2SUKBLGAecAvwrIgkurfPBf4DOBcYCdzR9vwico+IbBSRjaWlpV67D2OM8afCSv+OsQAf9YZS1QpgObCwza4CYJGqNqrqfmA3ruBRAOSo6j5VbQLeAs5p57zPqOoMVZ2RkuK/ujxjjPGmQj+P3gbv9oZKcZcSEJEo4DJgV5tkb+EqVSAiybiqn/YBG4BEEWmJAPOBHd7KqzHGBLIjfh69Dd7tDZUB/Nnd1hACvK6qb4vIY8BGVV0ELAEWiMgOoBl4SFXLAETkP4Bl4upUvAl41ot5NcaYgFVYeYL4yFBi/LBCXgtv9obKBbLb2f6DVs8VeND9aJtuKTDFW/kzxphgcaTCv2MswEZwG2NMwGsZve1PFiyMMSbAFVbWkWElC2OMMR2pa2zm2PEGBlnJwhhjTEcCYYwFWLAwxpiAVljhGmOR4ccxFmDBwhhjAtoRd8nCX4setbBgYYwxAaylZJFubRb+VVHbwA8XbWf9/mP+zooxxpzhSGUdSTHhRIb5dy7Vfh8sHCHC82sOsPlQub+zYowxZyisPOH39gqwYEFcZBixEaEnexwYY0wgKayo83tPKLBgAbjqAossWBhjAtCRyhN+H2MBFiwAyEiIpLDKgoUxJrDU1DdRXdfk99HbYMECgPT4SIrc88UbY0ygODnGwkoWgSEjIZLS6nqamp3+zooxxpx0coyFlSwCQ3pCFE6F0pp6f2fFGGNOspJFgGn5jwjkHlFvbT7M8k9L/HLt36/Yy7KdxX65tjH92ZGKE4hAWrz/g4X/ll0KIC0jIwO5R9RP391FQlQYF49N9el11+w9yv8u3sW0oYlcMj7Np9c2pr87UllHalwEYQ7//673fw4CQKCXLKrrGimsrGNXUTVlPqwqa2p28ugi19LnuQUVVJ5o9Nm1jTEtix75v70CLFgAkBAVRmRYSMD2iMorqTn5fO0+301L8uLag3xaXM2XLxiBU+HjvWU+u7YxxjUgb1AAjN4GCxYAiAgZCVEBW7JoCRYhAqv3HvXJNctq6vnF0t3MzUrmOwvHER3uYHWeb65tjAFV5UgAlSyszcLNNdYicINFeGgIs0Ym+ezX/eNLPqW2oZlHrp5IeGgI540YaMHCGB+qqG2krtEZED2hwEoWJ2UkRAZ0yWJkcgxzs5LZf/Q4Ryq8W12WW1DBaxvzuXNOJqNTYwG4ICuFfUePc9jL1zbGuBxxV4sHwhgLsGBxUlpCJMVVdTid6u+snGFPSQ2jU2OZPSoZ8G7bgdOp/OAf20mKieDfL8k6uf2C0a5rW+nCGN8orGhZTvUsL1mISKSIrBeRLSKyXUQe7SDdTSKyw53m5Vbbm0Ukx/1Y5K18tshIiKTJqRw9HlgD8+oam8kvr2V0aizj0uMYGBPu1XaLv28+TE5+Bd+9YhxxkWEnt49JiyU5NoJVeyxYGOMLhQFWsuhWm4WIjAIKVLVeROYBU4AXVLWik8PqgfmqWiMiYcAqEVmsqmtbnTcLeBiYo6rlItJ6EMEJVZ3W0xvqrfT4U2MtUuMCI5ID7C2tQRWyUuMICZGT7Raqioh49FoNTU5++u4usocl8tnswaftExEuGJ3Eyj1HcTqVkBDPXtsYc7ojlXWEhgjJsRH+zgrQ/ZLF34BmERkNPAMMBV7u7AB1aenzGeZ+tK3juRt4WlXL3cf4Z4gynOxxEGjtFi09oVraDmaNSqKwso4DZbUev9bqvKOUVtdz//zR7QaDOaOTKTvewKfF1R6/tjHmdIUVJ0iLj8QRID/MuhssnKraBFwPPKmqDwEZXR0kIg4RyQFKgKWquq5NkjHAGBFZLSJrRWRhq32RIrLRvf26buaz1wJ1FHdeSQ2OECEzORqA2aOSAO+0HbyztZC4yFDmuNsn2ppj7RbG+MyRysAZYwHdDxaNInIL8CXgbfe2sE7SA6Cqze6qpCHATBGZ1CZJKJAFzANuAZ4VkUT3vuGqOgO4FXjCXRV2GhG5xx1QNpaWlnbzVtqXFBNOmEMCrmSxp7iG4UnRRIS61t8dkRxDRkKkxxu5G5udvLejmMvGp528VluDEqMYmRLDKgsWxnhdII3ehu4HizuBWcCPVXW/iIwA/tLdi7jbNpYDC9vsKgAWqWqjqu4HduMKHqjqYfe/+4APgex2zvuMqs5Q1RkpKSndzU67QkKEtABc12JPSTWjU2JPvhYRZo1K4uN9ZR7tufXx3jIqTzRyxeTOC4xzRyezbt8xGppsOndjvMXpVIor6wNi7e0W3QoWqrpDVf9dVV8RkQFAnKr+tLNjRCSlpZQgIlHAZcCuNsnewlWqQESScVVL7RORASIS0Wr7HGBH92+rdwJtrEVDk5ODZbVkpcWetn32qGSOebjtYPG2QmLCHczNar8KqsWc0cmcaGzmk0PlHru2MeZ0O4uqaGh2kpUa5++snNStYCEiH4pIvIgMBD7BVV30iy4OywCWi0gusAFXm8XbIvKYiFzjTrMEKBORHbhKHg+pahkwHtgoIlvc23+iql4PFukJURQF0PKqB8uO0+TUk43bLTzdbtHU7GTJ9mIuGZ9GZFj7VVAtzh+V5Jp2pJ1rV9Y2sq+0pp2jjDE9sdLdRb2rH2++1N1qqARVrQI+i6vL7HnApZ0doKq5qpqtqlNUdZKqPube/gNVXeR+rqr6oKpOUNXJqvqqe/sa9+up7n//0Ptb7L6MBNeUH6qBMTCvpSdU218XgxKjGJEc47F2i/X7j3HseANXTk7vMm18ZBhThyae0W7xyaFyLn/iI656chXH65s8ki9j+quVe0oZlx4XEOtYtOhusAgVkQzgJk41cJ910uMjqW9yUlEbGFNx73EHi5EpMWfsmzUqiXX7j3lkKdh3thUSFebgojHdWyvjgtHJbMmvoKquEVXlz2sO8Pnff0x9UzO1Dc2s2N23zgbG9Ge1DU1s2F8eUKUK6H6weAxXldFeVd0gIiOBPd7Lln8E2roWeSU1DBkQRXT4mWMnZ49Koqa+idzDlX26RrNTeXdbMfPHpRIV3nkVVIs5o5NxKizfVcI3X8vhkUXbuTArhWXfmsfAmHCWbC/qU56M6c/W7T9GQ7OTC8f0rdOOp3VrBLeq/hX4a6vX+4DPeStT/nJyrEXVCSYMivdzbk7NCdWeWSNd7RYf7y3jnGEDen2NDQeOcbSmniu76AXVWvawRKLCHDz4+hZUlYcuH8vXLhpFSIhw6fhUFm8roqHJSXioTT1mTE99tLuUiNAQzs0c6O+snKa7030MAZ7E1SsJYCXwDVUt8FbG/CGQRnE3O5W9pTVcMDqp3f1JsRGMS4/jLx8fZE9xNXGRYcRFhhIfFca49DjmdXP51cVbC4kMC2He2O7/iokIdXDxuBTW7jvGr2/O5oJWxeUFE9J5fWMBa/eVBdwvI2OCwco9RzlvZFKXnU18rbvrWfwJ1/QeN7pf3+7edpk3MuUvKXEROEIkIEZxF5TX0tDk7LBkAfCVuSP50+r9fHLI1X5QXddEs3vsxS9umspnzxnS6TWcTmXxtiLmjUklJqJnS5v8/EbXtF1tq64uyEomOtzBku1FFiyM6aEjFSfIK6nh5nOH+jsrZ+juN0SKqv6p1evnReSb3siQPzlChNS4iIAoWewpbpkTquN+1jdMH8IN008FBFWlpr6Ju1/YyHf/vpURyTFkd1JF9cmhckqq67miG72g2uqofSMyzMG8sSks3VHMj66dZBMOGtMDK/e4OocE4g+t7lYql4nI7e65nhwicjtwVi7InJ7guxXzVJUNB45R39R8xr680tMnEOwOESEuMozf3DadtPgI7v3Lpk7v5Z2tRYSHhjB/XPeqrLprwYR0SqrrySnobFJiY0xbH+0+Snp8JFk9+Lv3le4Gi7twdZstAgqBG4A7vJQnv0qPjzw5j7y3LdlezI2/+5j/fnvnGfv2FNeQGhdBQlSXU3CdYWBMOM998VyO1zdxz182Utd4ZjByOpV3txVyYVbKaetWeMLF41IJDRHrFWVMDzQ7lVV5R5mblezx5Qc8obvTfRxU1WtUNUVVU1X1Os7C3lDgKlkU+mBgXmOzk5+9uwsReHHdQbYWnN4FNq+k+oxpPnpibHocT9yczdbDlXz7jdyT91NWU8/vVuxl3v99yJHKOq6e2v1eUN2VEBXGrFFJvLe9OGAGOBoT6HILKqg80cjcAKyCgr6tlPegx3IRQDISIqltaKbay6OQX92Qz76jx/nFTVNJiongP/+x7eTEgKpKXknNaRMI9sZlE9L4jwVjWbTlCI/+cwffeHUzs/73A36yeBfpCZH8+pZsrpk6yBO3c4YFE9PZf/T4yVHoxpjOrdxzFJFTSxgHmp51gTld4JWTPCDd3X22qLKOeA9Xz7SoqW/iV+/vZuaIgVw3zbUi3QOvbeHVDfncet4wCivrON7QzOi0vk8idt+8UXxaVM3zaw4QFxnKrecN47bzhpHlgXN3ZsGENP7rrW0s2V7k8WsVu+fvCqSpEIzpq492lzJ5cAIDY8L9nZV29aVkcVbWL3hiFHdRZR2/W7G33bYCgGdW7OVoTQPfu3I8IsJ10wZz3oiB/GzJLo4dbzi1Ol4fSxbgavR+/MYp/OnOc1n3vUv44TUTvR4owPVFnj0skSXbiz163mancsuza/nqi5s8el5j/KmqrpHN+RVcmBWYVVDQRbAQkWoRqWrnUQ14p/7Cz06txd37Ru4X1x7kJ4t38YU/rKOyzTxTxVV1PLtyP5+ZksG0oa51nkSEH103iZq6Jn66eNfJOaH60mbRWkSog4vHprY7bYg3LZiQztbDlRyp8FyHgfe2F7Gv9Dg5+RWUH2/w2HmN8ac1eWU0OzXg5oNqrdNgoapxqhrfziNOVX37zeMjLVUbfSlZ7CmpJi4ylC35ldz4+zWnfVn+culumpxOvn352NOOGZMWx10XjOC1jfm8tfkwidFhJAVocbS7Lp+YBri+4D1BVfndir3EhDtQhdV7bcU+c3ZYuaeUmHAH5wzv/dQ93maT97QRHhpCcmxEn8Za5JXUMHtUEs/feS5HKur43G/XsLu4mt3F1by+MZ/bzx/O8KQzZ5L9xiVZpMdHsvVwJVmpsQHZfa4nRqbEkpUa67GqqI/3lrGloJLvXjGOuMhQVu62YGGCn6ry0Z5SZo1KJswRuF/JgZszP+rLinkNTU4OlNUyOjWW2aOTee3e82lyKjf8dg0P/XULMeGh3D8/q91jYyJC+a+rJgA9G4wXyBZMTGP9gWOUeGBRqd+u2EtybAQ3zhjK7FFJrMo7al1zTdA7UFZL/rETXDQmcKugwIJFu/oyivtg2XGanXpywaKJgxL4+9dmkxwXwZaCSu67eHSnvR2unJzO964cx+3nD+/V9QPNTTNcc9w8vTyvT+fZdriSlXuOctcFmUSGObggK4XDFSfYd/S4J7JpjN+0VNN2d/JPf7Fg0Y6MhMheL6/a0jjdumQwdGA0b3x1Nj++fhJ3XZDZ6fEiwj0XjmLioIReXT/QDE+K4aYZQ3h5/SEKymt7fZ7frdhLbEQot53nCqIXuhsCV+2xqigT3JZsL2LS4HiGDoz2d1Y6ZcGiHekJkVSeaKS2oecD8/I6WN1uYEw4t503nIjQwJp22Bfun5+FIPx6We/WyzpYdpx3thZy2/nDTk5/MjwphqEDo05OvGZMMCququOTQxVcPqHnk3n6mgWLdrSMtehNVdSeTla3668GJUZx+/nDeWNTAXtL2x/R7XQqr6w/xCeHys/Y98xH+wgNCeHLc0actn1uVgof7y2j0QNLyxrjD+/tcHX+WDjJgkVQSo8/NYq7p/I6Wd2uP7vv4lFEhjn45dLdZ+xTVf7rH9t4+O9b+exv1nDd06v5R85hGpudlFbX89dNBXxu+mBS24zYnjs6meMNzWw+ZLPbmuC0ZFsRI5NjguI7w4JFO3o7irvZqewrrQnI6YX9LTk2gjvnZPJ2biE7jlSd3K6q/OTdXby07hB3zx3BY9dOpPJEI994NYe5P13O/a98QmOzk7vnjjzjnLNHJRMisMqqokwQqqhtYO2+MhZMTA+KbvIWLNpxai3ungWLgvJa6rtY3a4/u2fuKOIjQ/n5e5+e3PabD/fy+xX7uP38YXzvyvF8cVYmyx68iD/eMYOstFjW7jvGlZMzGNnO1CcJ0WFMGZLIR9bIbYLQsp0lNDk1KKqgoG8TCZ61IsMcJMeG93jG1JNzOnWyul1/lhAdxr0XjeLxJZ/yyaFycvMreHzJp1yfPZjHrpl08tdVSIgwf1wa88elkX+sttOuxhdmJfPU8jwqaxtJiPbOxI/GeMOS7UWkx0cyZXBw9Hz0WslCRCJFZL2IbBGR7SLyaAfpbhKRHe40L7fZFy8iBSLylLfy2ZELRifz4aclJ9e07o72us2a090xO5Pk2HDuf3kzP/znDhZMSOPxG6Z0uPzq0IHRna4PfkFWCk6FNTb1hwkitQ1NrNhdyuUT04Jm6WFvVkPVA/NVdSowDVgoIue3TiAiWcDDwBxVnQi0Xdf7R8BHXsxjhy6dkEZ5bWO7vXM6kldSQ0ovV7frL2IiQrlv3mgOV5xgblYyT96aTWgfpjjIHpZITLiDlXkWLEzw+Gh3KfVNTi6fGBxVUODFaih1zcPQUo8T5n60/Zl+N/C0qpa7jylp2SEi04E04F1ghrfy2ZELx6QQ5hDe31HMuZkDu3XMnhJr3O6OL8waTmp8BPPHpfZ53EmYI4RZo5JsvIUJKu9uKyIxOoyZI7r33RIIvNrALSIOEckBSoClqrquTZIxwBgRWS0ia0Vkofu4EODnwH90cf57RGSjiGwsLfXsl0V8ZBjnj0xi6c7uTYKnquy1brPdEuYI4aopgzw2FmVuVgr5x05wsMym/jCBr6HJybJdJVw6Pq1PpWpf82pOVbVZVacBQ4CZIjKpTZJQIAuYB9wCPCsiicB9wDuqWtDF+Z9R1RmqOiMlxfOLhlw6Po19pcc7HEjWWnFVPTX1TVay8IML3FN/rLReUSYIfLyvjOq6pqCqggIfdZ1V1QpgObCwza4CYJGqNqrqfmA3ruAxC/i6iBwA/g/4ooj8xBd5be2S8a6JvZZ1o3Sxp6QagFEWLHxuZHIMgxNt6g8THJZsLyI63BHQCx21x5u9oVLcpQREJAq4DNjVJtlbuEoViEgyrmqpfap6m6oOU9VMXFVRL6jqd72V144MGRDN+Ix43t9R0mXalm6zWdZt1udEhLlZyazOK+twKVtjAkGzU3lvezHzxqYQGRZc88R5s2SRASwXkVxgA642i7dF5DERucadZglQJiI7cJU8HlLVMi/mqccuG5/KxoPHONbFEp57SmpIiAojOTa4V7cLVgsnpVNT7+qOaEyg2nSwnKM19UFXBQVeDBaqmquq2ao6RVUnqepj7u0/UNVF7ueqqg+q6gRVnayqr7ZznudV9eveymdXLp2QhlNh+a7OSxd57p5QwTBs/2w0Z3QyA6LDeDu3sNN0VXWN/Py9T9l2uNJHOTOBZs3eoyx84iN2FlZ1ndjDnl25j/jIUC4Zn+bza/dV8DTF+8mkQQmkxUfwfhftFjaBoH+FOUJYOCmDZTuLOdHQcVXUn1cf4MkP8rjqyVXc9fwGNvdgHI0JfuXHG3jgtRx2FVVz/yube7UMQW9tO1zJ0h3FfGXuSGI7GWgaqCxYdCEkRLhkfBordpd2WB9eVlPPseMNFiz87OopGdQ2NPNBB6XApmYnL68/xHkjBvKty8bwyaFyrv/NGm5/bh3r9gVU7afxAlXle29u5djxBr5/5Xj2ltbwo7d3+Oz6T7y/h/jIUO6Yk+mza3qSBYtuuGx8GrUNzazt4Aslz6b5CAjnjUwiOTaCt3OPtLt/2a4SCivruOuCEdx/SRarvjOfh68Yx66iKj7/zFruf2UzlbWNPs618ZW/bipg8bYivrVgLHdfOJKvXjSKV9bn868uqi49YdvhSt7f6SpVxEcG5wwPFiy6YdaoJKLCHCzb2f4v1rxSCxaBwBEifGZyOh/sKqGm/szqhRfXHmRQQiSXjHN1iY6NCOXei0ax8tvzeeDSMSzeWsjlT3xkXXDPQgfLjvPoou2cN2LgyenuH7xsDNOGJvLdv+eSf6z3S/52xxPv7yYhKixoSxVgwaJbIsMcXDgmmfd3FuOaxeR0eSU1RIc7GJQQ5YfcmdaumjqI+iYn7+84vY1pX2kNK/cc5dbzhp0xajYq3ME3Ls3izfvmEBPh4At/WM8PF23vtO3DBI+RK0rAAAAbMUlEQVSmZifffC2HkBDhF5+fhsM9cV+YI4Qnb8kGhW+8upkmL624uLWgkvd3lvCVC0YEbakCLFh026Xj0yisrGP7kTN7UOSV1DAqJTZoZo88m00fNoD0+MgzqqJeWneIMIdw07lDOzx28pAE/vXvc7ljdibPrznAVU+uJM892NIEryc/yGPzoQp+fP1kBiee/oNu6MBo/vv6SXxyqIJf9XKN+K78apmrVPGlIC5VgAWLbps/LhWRU2vmtpZnEwgGjJAQ4aopGazYXUrlCVf7w4mGZv66MZ+FkzJIjYvs9PjIMAc/vGYiL375PI4db+CRRdt9kW3jJTn5FTy1PI/rswdzzdRB7aa5dtpgbpw+hKeW57HxwDGPXv9sKVWABYtuS4qNYPaoJH77YR6/W7H35DoX1XWNFFbW2TQfAeSqqYNobFbe214EwKIth6mqa+IL5w/v9jkuyErm7gtHsjqv7LRlYE1weeqDPBKjwnj02omdpnv02olkxEfy6D934OzBGjZdORvaKlpYsOiBp245h0vHp/GTxbu47bm1HK44wd5S10yn1rgdOKYOSWDowCj+mVuIqvLCxwcZmxbHuZkDenSe22YOJzrcwXOr9nkpp8abCspr+WBXMTfPHNrlr/ro8FC+vXAcWw9X8lbOYY9cP7eggmW7Srh77gjigrxUARYsemRATDi/ue0cHr9hClsLKln4xEc8t9L1RWLVUIFDRPjM5EGszjvK8k9L2H6kittnDe/x6PqE6DBumjGUf245QnEP12M3/vfSukMA3Hpe90qU10wdxNQhCfzs3U890rnh18v2uNoqZmf2+VyBwIJFD4kIN84YyjvfmEtWaixv5xYS7ghh2MBof2fNtHL11Ayancq3Xt9CbEQo12cP7tV57pozgman8vyaA57NoOmT77+5lf/uZEBdXWMzr64/xKXj085o1O5ISIjwn1dNoKiqjmdX9q006RpX4WqrOBtKFWDBoteGJ8Xw+r2z+PbCsXxt3qigWsSkP5iQEc/I5BjKaxv57DmDez29wrCkaC6fmM5Law9yvJ2xG8b3th2u5KV1h3hu1f4O117/V24h5bWNfHFWZo/OfW7mQK6cnM5vP9zbp9Lkr5a5RmsHew+o1uwbrg9CHSHcN280D1w2xt9ZMW2ICFe7e7/c3oOG7fZ8Ze5Iquqa+OvGfE9kzfTRb1fsJTYilCEDonjkH9tpbGd8xAtrDzIyJYY5o5N6fP7vLBxHs1P5+Xuf9ip/24+45oC66yzoAdWaBQtz1vravFG89W9zGJPWtzVGpg8fwDnDEvnj6gMne8EZ/9h/9DiLtxZy+/nDeeTqiewpqeHPbaoIcwsq2JJfwRfO73k7FbhqDe6Yk8lfNxWw/UjPZyd+clkecRGh3DlnRI+PDWQWLMxZKzLMwbShiR45191zR3LoWC1LdxR55Hymd36/Yi+hjhDuuiCTS8encvHYFJ54fw8lraqMXvj4INHhDj43fUivr/NvF48mMSqMH/9rZ7uzNnRkV1EV724v4s45mSREnT2lCrBgYUy3LJiYzrCB0Ty7cr+/s3JWWL6rhHv/spH9R493+5iiyjr+9kkBN80YQmpcJCLCI1dPpKHJyf+8sxNwTUH+zy1HuC57cJ+qgBKiwnjgsjGs2VvGku1dL6vc4sllecRGhHLXBWdXqQIsWBjTLY4Q4a45mWw6WM4ntgZGrxVX1XHfS5u48/kNLNlezF3Pb6CitvNVKFs8t3IfToV7Lxx1cltmcgz3XjSSt3KOsG5fGa9vzKe+yckXZ/WtnQrglpnDGJcex8N/z+VIxYku0+8uruadbYXcMTuTxOizb8VMCxbGdNONM4YSHxnKC9aNtseancrzq/dzyc9XsGxnCQ9dPpaX7z6Pw+UnuPcvm2ho6nwSv4raBl5ef4irp2QwtE039fvmjWZwYhSPLNrOi+sOMjNzIOPS4/uc5zBHCE/fdg4NTU7uf2Vzuw3prT35QR7RYQ6+fBaWKsCChTHdFhMRyryxqazb79n5g852B44e5/rfrOaH/9xB9rBE3nvgQv7t4tHMHpXMz26Ywrr9x/j+m1s7bRv485qD1DY089V5o87YFxXu4L+umsCuomryj53gCx4oVbQYlRLLTz43hU0Hy3l8Sce9o/JKang79whfnJ3JgJizr1QBEHxr+xnjR9nDElm05QiFlSfIsCnpu5R/rJZbnl1LXWMzv74lm6unZJzWQ+m67MHsK63h1x/kMTIllq+1EwxqG5p4fs1+LhmX2mGJ4fKJaVw8NoVPi6q5fGK6R+/h6qmDWL//GM98tI9zMwdy2YTT18/edriS7/wtl8hQB185S0sVYMHCmB7JHuaaXyrnUAUZky1YdOZIxQlueXYttQ3NvHL3+UwY1P4X/QOXjWHf0eP89N1djEiOZuGkjNP2v7I+n/LaRu67+MxA0kJE+O3t0znR0Ex4qOcrTP7zqvHk5Ffwrddz+Ne/z2XowGiq6hr5xXu7eeHjAwyMCeeJm6eRFBvh8WsHCgsWxvTAhIx4wkND2JxfwRWTM7o+oJ8qqarjtufWUVnbyEt3n9dhoADXF/3/3TiVwxUn+OZrOUxbc4Dquiaq6hqpOuH6d+aIgUwfPrDTa0aGOYgMc3j6VgCICHXw9K3n8JknV/L1lz/hjjmZ/M87uzhaU88Xzh/OtxaMPeu6yrZlwcKYHggPDWHSoHg2W4+oDpXV1HPbc+sorqrjL1+eyZQhXY91iQxz8MwXZvCdv+VSU9dERkIkY9LiiI8MJSEqjJtnDvNBzjs3LCmax2+Yyldf3MQDr21hypAE/vClGd26v7OB14KFiEQCHwER7uu8oaqPtJPuJuCHgAJbVPVWERkOvImrAT4MeFJVf+etvBrTE9nDBvDi2oM0NjsJsznBTlNZ28gX/rCeQ8dqef7OmV2WBlpLiYvgj3ec68Xc9d3CSen872cnI7h6xzn60eqY3ixZ1APzVbVGRMKAVSKyWFXXtiQQkSzgYWCOqpaLSKp7VyEwS1XrRSQW2CYii1T1yBlXMcbHsocl8odV+9lVWM3kIQn+zk7AUFUeeD2HvJIanv3SDGaN6vm8TMHglgAo5fiD134WqUuN+2WY+9G2b9zdwNOqWu4+psT9b4Oq1rvTRHgzn8b0VEsj9+Z8/1dFHa9vYk9xNceON3h0hbfeeGNTAR/sKuHhK8dx0ZgUv+bFeJ5X2yxExAFsAkbjCgrr2iQZ4063GnAAP1TVd93bhgL/ch/7UHulChG5B7gHYNiw/hntje8NSogkNS6CzYcq+OIs/+blqy9uYuUe1zTdjhBhYEw4ybERZA9L5NFrJvqsmqyoso7H3t7BzMyBfKmH04Kb4ODVYKGqzcA0EUkE3hSRSaq6rc31s4B5wBDgIxGZrKoVqpoPTBGRQcBbIvKGqha3Of8zwDMAM2bMsOlAjU+ICNnDEv3eyL3jSBUr9xzl5nOHMjY9jrKaBo7W1FNYWcfL6w6RGBXGtxeO83o+VJWH/55LY7OTn90whZB+VI/fn/ikN5SqVojIcmAh0DpYFADrVLUR2C8iu3EFjw2tjj0iItuAucAbvsivMV3JHjaAJduLOXa8gYF+GrH7h1X7iQ538PAV40mIPr3b5nf/lstvPtzLeSOTvF4l9MamApZ/WsojV08gMznGq9cy/uO1MqqIpLhLFIhIFHAZsKtNsrdwlSoQkWRc1VL7RGSI+xhEZABwAdC7lUiM8YJs99TnOX5qtyipqmPRlsPcNGPoGYEC4JGrJzI2LY4HX8s5bfpuT7Pqp/7DmxWaGcByEcnFVVJYqqpvi8hjInKNO80SoExEdgDLcbVNlAHjgXUisgVYAfyfqm71Yl6N6ZHJQxJwhAibD1X45fovfHyQJqdyZwfLdkaFO3jq1mxqG5r5xqs5Xlm0yaqf+hevVUOpai6Q3c72H7R6rsCD7kfrNEuBKd7KmzF9FR0eyrj0OL8EixMNzby47iCXjU9jeFLH1T5ZaXE8du1EHnojlyc/2MM3L/Xs8r9/++SwVT/1I9Yl1Zheyh6WSE5+hc+XWv375gIqahv5ytyRXaa9YfoQPps9mF8t28OavUc9mo8/rd7PpMHxVv3UT1iwMKaXsocOoKa+ib2lNV0n9hCnU/nDqv1MGZLAuZkDukwvIvzoukmMSI7hm6/mUFPf5JF8nGhoZldRNReNSbHqp37C5oYyppeyh7kauTcfKmdMWtxp+w6V1fLKhkOcaGimvslJQ5OThmYn0WEOvrVgDKnxkb265oe7S9hXepxf3TzttKm+OxMTEcqPr5vMLc+uZdnOYq6dNrhX125t25FKmp3KtKFdByxzdrBgYUwvjUiOISEqjM2HKvj8uacGhR6tqefW59ZSWFlHTLiD8FAHEaEhhIeGUFh5gtV7j/LCXTMZmRLb4bnLjzcQFX7mLKrPrdxPRkIkV/ZwxtvzRgwkNS6CxVuLPBIsctxtNdOG9o9J9IwFC2N67dTgvFON3HWNzdz7l00crannzftmnzEjaW5BBXf+aQM3/O5j/njHuWd82R6vb+KJ93fzx9UHiAgN4cKsFC6bkMb8cakcqTzBmr1lfPeKcT0emR0SIiyclM7rG/OpbWgiOrxvf/o5+RUMTowiJe7sXb/BnM7aLIzpg+yhA9hdUk11XSOqynf+lsumg+X84qZp7U5dPWVIIm98bTYxEQ5ufXYtK3aXAq5uqO9uK+LSX6zg2ZX7+dw5g/nsOYNdC+78dQvT/3spX/rjBqLDHdxybu+mtrliUgZ1jU4+/LS0T/cMrmAxbZiVKvoTK1kY0wfZwxJRhdyCSjYeKOcfOUd46PKxnVYTjUiO4W9fm82X/riBLz+/ge9dOZ5VeUf5YFcJ49LjeOrWc5g+3NUW8KNrla2HK1m6o5jln5ZwxaTMdgfhdcfMEQNJignnna2FPa7Gaq2kuo7DFSc6HONhzk4WLIzpg6nuaqRfLt3NxoPlfO6cIdzXzjrSbaXGRfLavedzzwsbeeztHcSEO/jPz4znjtmZhLaqYhIRpgxJZMqQRL61YGyf8uoIERZMTGdRzmHqGpt7varclvxKwNor+hsLFsb0QUJUGKNTY9l4sJyZmQP5n89O6nYvpfjIMP5810ze2FTA/HGpZCR4f03vKyen88r6Q3y0u5QFE9N7dY6c/HJCQ4RJg20tj/7E2iyM6aN5Y1IYmRLD774wnYjQnv1ajwh1cNt5w30SKADOH5lEQlQYi7cV9focOfkVjMuI89p61yYwWbAwpo++/5nxLH3gIr/NPtsTYY4QFkxI4/2dxdQ3Nff4eKdTyc2vZGo/WXfanGLBwpg+EpGgWov5isnpVNc1sSavrMfH7i2tobq+ydor+iELFsb0M3NGJxMXEco7Wwt7fOzmfNeYkmzrNtvvWLAwpp+JCHVw6YQ0lu4sprHZ2aNjc/IriIsMZWRyx6PPzdnJgoUx/dDCSelU1Daydl/PqqK25FcwdUiiTR7YD1mwMKYfumhMCtHhjh71imqZadbaK/onCxbG9EORYQ4uHpfKkm1F3V6P49RMsxYs+iMLFsb0U1dOyqDseAPr9x/rVvqTM81a43a/ZMHCmH5q3tgUwh0hLNtZ3K30OfkVDBkQRXKszTTbH1mwMKafiokI5fxRSSzbVdKt9Dn5FVYF1Y9ZsDCmH7tkXCr7jx7vcmnYlplmLVj0XxYsjOnHLhmfCtBlVZStjGcsWBjTjw0ZEM249DiW7ey8Kionv8Jmmu3nvBYsRCRSRNaLyBYR2S4ij3aQ7iYR2eFO87J72zQR+di9LVdEPu+tfBrT310yPpWNB8uprG3sMM2WAptptr/zZsmiHpivqlOBacBCETm/dQIRyQIeBuao6kTgm+5dtcAX3dsWAk+IiJV/jfGCS8an0exUPtzdfumipKqODQfKmZmZ5OOcmUDitWChLi2tZmHuR9vRP3cDT6tqufuYEve/u1V1j/v5EaAESPFWXo3pz6YNSSQ5Npz3O6iK+v1H+2h2KnfMzvRtxkxA8WqbhYg4RCQH15f9UlVd1ybJGGCMiKwWkbUisrCdc8wEwoG93syrMf1VSIhw8dhUPvy05IyJBctq6nlp3UGunTaIYUnRfsqhCQReDRaq2qyq04AhwEwRmdQmSSiQBcwDbgGebV3dJCIZwF+AO1X1jOkxReQeEdkoIhtLS0u9dRvGnPUuGZ9GdV0TGw6cPpr7uVX7qW9yct+80X7KmQkUPukNpaoVwHJc7Q+tFQCLVLVRVfcDu3EFD0QkHvgX8H1VXdvBeZ9R1RmqOiMlxWqpjOmtuVnJ7tHcp6qiKmobeGHNAT4zOYPRqTYleX/nzd5QKS2lBBGJAi4DdrVJ9hauUgUikoyrWmqfiIQDbwIvqOob3sqjMcYlJiKUWaOS+KDVaO4/rT7A8YZmvj7fShXGuyWLDGC5iOQCG3C1WbwtIo+JyDXuNEuAMhHZgavk8ZCqlgE3ARcCd4hIjvsxzYt5Nabfu3T8qdHc1XWN/Gn1fhZMSGNcery/s2YCQKi3TqyquUB2O9t/0Oq5Ag+6H63TvAi86K28GWPONH98Gv/1j+0s21lMY7NSVdfE/fOz/J0tEyC8FiyMMcFlcGIU4zPi+VduIYeO1TJvbAqTh9iIbeNi030YY066ZFwqWwoqKa9ttFKFOY0FC2PMSS0TC84elcT04QP8nBsTSKwayhhz0tQhidw3bxTXZQ/2d1ZMgLFgYYw5KSRE+PbCcf7OhglAVg1ljDGmSxYsjDHGdMmChTHGmC5ZsDDGGNMlCxbGGGO6ZMHCGGNMlyxYGGOM6ZIFC2OMMV0S18SvwU9ESoGD7pcJQGU7ydrb3tW2tvtbv04GjvYyy93JW2/Tdra/O+9BZ68D4f67k94+A/YZsM9A9z4Dw1W169XjVPWsewDPdHd7V9va7m+zb6O389ybtJ3t78570MU9+/3++/Ie2GfAPgP2Gej5e62qZ2011D97sL2rbW33d3TuvurJebtK29n+7rwHnb0OhPvvTnr7DPRsn30GOt/WHz4DnTprqqH8QUQ2quoMf+fDX/r7/YO9B/39/qH/vAdna8nCV57xdwb8rL/fP9h70N/vH/rJe2AlC2OMMV2ykoUxxpguWbAAROSPIlIiItt6cex0EdkqInki8msRkVb77heRXSKyXUR+5tlce5Y33gMR+aGIHBaRHPfjSs/n3DO89Rlw7/+WiKiIJHsux57npc/Aj0Qk1/3//56IDPJ8zj3DS/f/uPs7IFdE3hSRRM/n3DcsWLg8Dyzs5bG/Be4GstyPhQAicjFwLTBVVScC/9f3bHrV83j4PXD7papOcz/e6VsWvep5vHD/IjIUWAAc6mP+fOF5PP8ePK6qU1R1GvA28IO+ZtKLnsfz978UmKSqU4DdwMN9zKPfWLAAVPUj4FjrbSIySkTeFZFNIrJSRM5YPkxEMoB4VV2rrsafF4Dr3Lu/BvxEVevd1yjx7l30jZfeg6Dhxfv/JfBtIOAbB73xHqhqVaukMQTw++Cl+39PVZvcSdcCQ7x7F95jwaJjzwD3q+p04D+A37STZjBQ0Op1gXsbwBhgroisE5EVInKuV3PrHX19DwC+7i6C/1FEBngvq17Rp/sXkWuBw6q6xdsZ9aI+fwZE5Mcikg/cRmCXLNrjib+BFncBiz2eQx+xNbjbISKxwGzgr62qnyN6eJpQYCBwPnAu8LqIjNQg6X7moffgt8CPcP2a/BHwc1x/MAGvr/cvItHA93BVQQUlD30GUNXvA98XkYeBrwOPeCyTXuSp+3ef6/tAE/CSZ3LnexYs2hcCVLjrWU8SEQewyf1yEa4vw9bFyiHAYffzAuDv7uCwXkScuOaQKfVmxj2oz++Bqha3Ou5ZXHXWwaKv9z8KGAFscX/RDAE+EZGZqlrk5bx7iif+Dlp7CXiHIAkWeOj+ReQO4CrgkmD5sdguT81pEuwPIBPY1ur1GuBG93PB1VDd3nHrcZUeBFcR80r39q8Cj7mfjwHycY9rCdSHF96DjFZpHgBe9fc9+vL+26Q5ACT7+x798BnIapXmfuANf9+jj+9/IbADSPH3vfX5vfF3BgLhAbwCFAKNuEoEX8b1q/BdYIv7P/sHHRw7A9gG7AWeagkIQDjwonvfJ8B8f9+nH96DvwBbgVxcv8AyfHU/gXD/bdIEfLDw0mfgb+7tubjmIxrs7/v08f3n4fqhmON+/M7f99nbh43gNsYY0yXrDWWMMaZLFiyMMcZ0yYKFMcaYLlmwMMYY0yULFsYYY7pkwcKc1USkxsfXe05EJnjoXM3u2Vq3icg/u5qxVEQSReQ+T1zbmLas66w5q4lIjarGevB8oXpqYjivap13EfkzsFtVf9xJ+kzgbVWd5Iv8mf7FSham3xGRFBH5m4hscD/muLfPFJGPRWSziKwRkbHu7XeIyCIR+QBYJiLzRORDEXnDvVbBS63WL/hQRGa4n9e4J9HbIiJrRSTNvX2U+/VWEfnvbpZ+PubUBIWxIrJMRD5xn+Nad5qfAKPcpZHH3Wkfct9jrog86sG30fQzFixMf/QrXOtsnAt8DnjOvX0XMFdVs3HNjvo/rY45B7hBVS9yv84GvglMAEYCc9q5TgywVlWnAh/hWu+g5fq/UtXJnD5babvccxFdgmsUPEAdcL2qngNcDPzcHay+C+xV19ohD4nIAlxrK8wEpgHTReTCrq5nTHtsIkHTH10KTGg1k2i8e4bRBODPIpKFa6bcsFbHLFXV1msdrFfVAgARycE1p9CqNtdp4NTkiZuAy9zPZ3FqzYuX6XhhrCj3uQcDO3EtpAOu+Yf+x/3F73TvT2vn+AXux2b361hcweOjDq5nTIcsWJj+KAQ4X1XrWm8UkaeA5ap6vbv+/8NWu4+3OUd9q+fNtP+31KinGgU7StOZE6o6zT3d+RLg34Bf41oXIgWYrqqNInIAiGzneAH+V1V/38PrGnMGq4Yy/dF7uGZABUBEWqagTuDU1NJ3ePH6a3FVfwHc3FViVa0F/h34loiE4spniTtQXAwMdyetBuJaHboEuMtdakJEBotIqofuwfQzFizM2S5aRApaPR7E9cU7w93ouwPXdPIAPwP+V0Q2491S9zeBB0UkFxgNVHZ1gKpuxjVz6y241oWYISJbgS/iamtBVcuA1e6uto+r6nu4qrk+dqd9g9ODiTHdZl1njfExd7XSCVVVEbkZuEVVr+3qOGP8ydosjPG96cBT7h5MFQTJUrOmf7OShTHGmC5Zm4UxxpguWbAwxhjTJQsWxhhjumTBwhhjTJcsWBhjjOmSBQtjjDFd+n8d5juUozVJqAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.recorder.plot(skip_end=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 8:59:31 <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>3.657215</th>\n",
       "    <th>3.936536</th>\n",
       "    <th>0.368102</th>\n",
       "    <th>35:08</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>3.642413</th>\n",
       "    <th>3.935692</th>\n",
       "    <th>0.368301</th>\n",
       "    <th>35:16</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>3.643426</th>\n",
       "    <th>3.934475</th>\n",
       "    <th>0.368607</th>\n",
       "    <th>35:12</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>3.647562</th>\n",
       "    <th>3.933661</th>\n",
       "    <th>0.368984</th>\n",
       "    <th>36:05</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>3.599793</th>\n",
       "    <th>3.932830</th>\n",
       "    <th>0.369230</th>\n",
       "    <th>36:22</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>3.600282</th>\n",
       "    <th>3.932656</th>\n",
       "    <th>0.369566</th>\n",
       "    <th>36:07</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>3.610645</th>\n",
       "    <th>3.932462</th>\n",
       "    <th>0.369760</th>\n",
       "    <th>36:22</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>3.594446</th>\n",
       "    <th>3.931697</th>\n",
       "    <th>0.369881</th>\n",
       "    <th>36:22</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>3.592897</th>\n",
       "    <th>3.931861</th>\n",
       "    <th>0.370063</th>\n",
       "    <th>36:22</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>9</th>\n",
       "    <th>3.579580</th>\n",
       "    <th>3.931844</th>\n",
       "    <th>0.370068</th>\n",
       "    <th>36:22</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>10</th>\n",
       "    <th>3.576053</th>\n",
       "    <th>3.932137</th>\n",
       "    <th>0.370153</th>\n",
       "    <th>36:22</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>11</th>\n",
       "    <th>3.548421</th>\n",
       "    <th>3.932229</th>\n",
       "    <th>0.370216</th>\n",
       "    <th>35:12</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>12</th>\n",
       "    <th>3.560789</th>\n",
       "    <th>3.932641</th>\n",
       "    <th>0.370218</th>\n",
       "    <th>35:27</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>13</th>\n",
       "    <th>3.574803</th>\n",
       "    <th>3.932706</th>\n",
       "    <th>0.370233</th>\n",
       "    <th>36:22</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>14</th>\n",
       "    <th>3.547282</th>\n",
       "    <th>3.932850</th>\n",
       "    <th>0.370205</th>\n",
       "    <th>36:22</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(15, 1e-4, moms=(0.6,0.4), wd=0.01, pct_start=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save_encoder('twitter_es_enc_RNN_0510')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save(\"twitter_raw_es_more_rules_RNN_20190509\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Percentage of `xxunk` in each tweet.  Is it high?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((22405,), (427631,))"
      ]
     },
     "execution_count": 34,
     "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": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.05239330170170076"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "22405/427631."
   ]
  },
  {
   "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"
    }
   ],
   "source": [
    "pct_xxunk.hist()\n",
    "_ = plt.title('Pct UNK in each tweet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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": [
    "pct_xxunk.plot()\n",
    "_ = plt.title('Pct UNK in each tweet')"
   ]
  }
 ],
 "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
}