Fine-tune 0.0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data used for fine-tuning and final classification :\n",
    "\n",
    "* corpus completo 5 temas - 08-sep-2016 - codificacion 5 temas.csv (competition)\n",
    "* textos_de_los_tweets_en_campaña_2016.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "\n",
    "import sys\n",
    "from fastai.text import *\n",
    "import html\n",
    "import json\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from google_drive_downloader import GoogleDriveDownloader as gdd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import f1_score, confusion_matrix\n",
    "\n",
    "np.random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH=Path('./data')\n",
    "\n",
    "WIKILM_PATH=Path('./language_model_wiki/LM')\n",
    "\n",
    "FINE_TUNE_PATH=Path('./LM_fine_tune')\n",
    "\n",
    "BOS = 'xbos'  # beginning-of-sentence tag\n",
    "FLD = 'xfld'  # data field tag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/andreas/anaconda3/envs/fastai_v07/lib/python3.6/site-packages/ipykernel_launcher.py:7: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support regex separators (separators > 1 char and different from '\\s+' are interpreted as regex); you can avoid this warning by specifying engine='python'.\n",
      "  import sys\n"
     ]
    }
   ],
   "source": [
    "df_1 = pd.read_csv(\n",
    "    DATA_PATH/'election_tweets/corpus_completo_5_temas_08-sep-2016-codificacion_5_temas.csv')\n",
    "\n",
    "df_2 = pd.read_csv(\n",
    "    DATA_PATH/'tweets_2015_y_2016/textos_de_los_tweets_en_campaña_2016.csv',\n",
    "                sep='delimiter', \n",
    "                header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "tweets_1 = df_1['Texto'].values\n",
    "tweets_2 = df_2[0].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "tweets = np.concatenate([tweets_1, tweets_1, tweets_2])\n",
    "del df_1, df_2, tweets_1, tweets_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3226119,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tweets.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flattern(A):\n",
    "    'Source: https://stackoverflow.com/a/17867797/7273299'\n",
    "    \n",
    "    'Flattens a list of lists and strings into a list.'\n",
    "    rt = []\n",
    "    for i in A:\n",
    "        if isinstance(i,list): rt.extend(flattern(i))\n",
    "        else: rt.append(i)\n",
    "    return rt\n",
    "\n",
    "def isInt(v):\n",
    "    'Source: https://stackoverflow.com/a/9859202/7273299'\n",
    "    \n",
    "    'Checks if a string is a number.'\n",
    "    try:     i = int(v)\n",
    "    except:  return False\n",
    "    return True\n",
    "\n",
    "def char_count(word, chars, lbound=2):\n",
    "    char_count = [word.count(char) for char in chars]\n",
    "    return all(i >= lbound for i in char_count)\n",
    "\n",
    "def replace_lol(repl_str, texts):\n",
    "    for string, chars in repl_str:\n",
    "        texts = [[[string, i] if char_count(i, set(chars), 2) else i for i in text.split()] for text in texts]\n",
    "        texts = np.array([flattern(text) for text in texts])\n",
    "        texts = np.array([' '.join(text) for text in texts])\n",
    "    return texts\n",
    "\n",
    "def preprocess_tweets(tweets):\n",
    "    \"\"\"\n",
    "    twitter specific text processing and shuffle\n",
    "    \"\"\"\n",
    "    # Placeholders for hyperlinks and user references\n",
    "    tweets = [['hyp_link' if i.startswith('http') \n",
    "               #else 'user_ref' if i.startswith('@') \n",
    "               else i for i in tweet.split()] for tweet in tweets]\n",
    "    tweets = np.array([' '.join(i) for i in tweets])\n",
    "\n",
    "    # Prefix for Hashtags\n",
    "    tweets = [[['hash_tag', i] if i.startswith('#') else i for i in tweet.split()] for tweet in tweets]\n",
    "    tweets = np.array([flattern(tweet) for tweet in tweets])\n",
    "    tweets = np.array([' '.join(i) for i in tweets])\n",
    "\n",
    "    # Prefix for integers\n",
    "    tweets = [[['int_string', i] if isInt(i) else i for i in tweet.split()] for tweet in tweets]\n",
    "    tweets = np.array([flattern(tweet) for tweet in tweets])\n",
    "    tweets = np.array([' '.join(i) for i in tweets])\n",
    "\n",
    "    # Prefix for slang\n",
    "    tweets = [[['que', 'slang_string'] if i=='q' else ['por', 'slang_string'] if i=='x' else ['de', 'slang_string'] if i=='d' else ['Que', 'slang_string'] if i=='Q' else ['Por', 'slang_string'] if i=='X' else ['De', 'slang_string'] if i=='D' else i for i in tweet.split()] for tweet in tweets]\n",
    "    tweets = np.array([flattern(tweet) for tweet in tweets])\n",
    "    tweets = np.array([' '.join(i) for i in tweets])\n",
    "\n",
    "    # Lol type characters\n",
    "    repl_str = [('risa_ja','ja'), ('risa_ji','ji'), ('risa_je','je'), ('risa_jo','jo'), ('risa_ju', 'ju')]\n",
    "\n",
    "    # Adding prefix to lol type characters\n",
    "    tweets = replace_lol(repl_str, tweets)\n",
    "\n",
    "   \n",
    "    \n",
    "    return tweets\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "tweets = preprocess_tweets(tweets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_limit = int(len(tweets)*0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "col_names = ['label', 'tweet']\n",
    "df_trn = pd.DataFrame({'tweet':tweets[:train_limit], 'label':[0]*len(tweets[:train_limit])},\n",
    "                      columns=col_names)\n",
    "\n",
    "df_val = pd.DataFrame({'tweet':tweets[train_limit:], 'label':[0]*len(tweets[train_limit:])},\n",
    "                      columns=col_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_trn.to_csv(FINE_TUNE_PATH/'train.csv', header=False, index=False)\n",
    "df_val.to_csv(FINE_TUNE_PATH/'validation.csv', header=False, index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenize and Standarize General Tokens\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "chunksize=24000\n",
    "\n",
    "re1 = re.compile(r'  +')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fixup(x):\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>','u_n').replace(' @.@ ','.').replace(\n",
    "        ' @-@ ','-').replace('\\\\', ' \\\\ ')\n",
    "    return re1.sub(' ', html.unescape(x))\n",
    "\n",
    "def get_texts(df, n_lbls=1):\n",
    "    labels = df.iloc[:,range(n_lbls)].values.astype(np.int64)\n",
    "    texts = f'\\n{BOS} ' + df[n_lbls].astype(str)\n",
    "    for i in range(n_lbls+1, len(df.columns)): texts += f' {FLD} {i-n_lbls} ' + df[i].astype(str)\n",
    "    texts = texts.apply(fixup).values.astype(str)\n",
    "\n",
    "    tok = Tokenizer(lang='es').proc_all_mp(partition_by_cores(texts), lang='es')\n",
    "    return tok, list(labels)\n",
    "\n",
    "def get_all(df, n_lbls):\n",
    "    tok, labels = [], []\n",
    "#     print(df)\n",
    "    for i, r in enumerate(df):\n",
    "        tok_, labels_ = get_texts(r, n_lbls)\n",
    "        tok += tok_;\n",
    "        labels += labels_\n",
    "    return tok, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_trn = pd.read_csv(FINE_TUNE_PATH/'train.csv', header=None, chunksize=chunksize)\n",
    "df_val = pd.read_csv(FINE_TUNE_PATH/'validation.csv', header=None, chunksize=chunksize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tok_trn, trn_labels = get_all(df_trn, 1)\n",
    "tok_val, val_labels = get_all(df_val, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2903507, 2903507, 322612, 322612)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(tok_trn),len(trn_labels), len(tok_val), len(val_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['\\n', 'xbos', 'rt', '@elespanolcom', ':', 'por', 'qué', 'ciudadanos', '(', 'aún', ')', 'no', 'supera', 'al', 't_up', 'psoe', 'en', 'los', 'sondeos', '.', 'con', 'gráficos', 'de', '@kikollan', '.', 'hyp_link', 'hyp_link'], ['\\n', 'xbos', 'rt', '@subversivos', '_', ':', 'mismo', 'programa', 'que', 'el', 'pp', ',', 'mismas', 'maneras', '.', '¿', 'dudas', 'ya', 'que', 'c', \"'s\", 'es', 'pp', 'con', 'careta', 'de', 'podemos', '?', 'hyp_link', 'hyp_link']]\n"
     ]
    }
   ],
   "source": [
    "print(tok_trn[:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "(FINE_TUNE_PATH/'tmp').mkdir(exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(FINE_TUNE_PATH/'tmp'/'tok_trn.npy', tok_trn)\n",
    "np.save(FINE_TUNE_PATH/'tmp'/'tok_val.npy', tok_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('\\n', 2903669),\n",
       " ('xbos', 2903507),\n",
       " ('t_up', 1828153),\n",
       " ('hyp_link', 1613978),\n",
       " ('de', 1445932),\n",
       " ('#', 1435955),\n",
       " ('hash_tag', 1401996),\n",
       " (',', 1210426),\n",
       " ('el', 1121413),\n",
       " ('que', 1085253),\n",
       " ('.', 1081281),\n",
       " ('a', 994657),\n",
       " ('pp', 885402),\n",
       " ('la', 877053),\n",
       " ('y', 755785),\n",
       " ('en', 653518),\n",
       " ('no', 584926),\n",
       " (':', 528221),\n",
       " ('\"', 506311),\n",
       " ('psoe', 446134)]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freq = Counter(p for o in tok_trn for p in o)\n",
    "freq.most_common(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_vocab = 60000\n",
    "min_freq = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60002"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itos = [o for o,c in freq.most_common(max_vocab) if c>min_freq]\n",
    "itos.insert(0, '_pad_')\n",
    "itos.insert(0, '_unk_')\n",
    "\n",
    "stoi = collections.defaultdict(lambda:0, {v:k for k,v in enumerate(itos)})\n",
    "len(itos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "trn_lm = np.array([[stoi[o] for o in p] for p in tok_trn])\n",
    "val_lm = np.array([[stoi[o] for o in p] for p in tok_val])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(FINE_TUNE_PATH/'tmp'/'trn_ids.npy', trn_lm)\n",
    "np.save(FINE_TUNE_PATH/'tmp'/'val_ids.npy', val_lm)\n",
    "pickle.dump(itos, open(FINE_TUNE_PATH/'tmp'/'itos.pkl', 'wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Encoder Weights for Language Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "BACKBONE_MODEL = WIKILM_PATH/'models/lm1_weights.h5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "wgts = torch.load(BACKBONE_MODEL, map_location=lambda storage, loc: storage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We calculate the mean of the layer0 encoder weights. This can be used to assign weights to unknown tokens when we transfer to target IMDB LM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "enc_wgts = to_np(wgts['0.encoder.weight'])\n",
    "row_m = enc_wgts.mean(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "itos2 = pickle.load((WIKILM_PATH/'tmp'/'itos.pkl').open('rb'))\n",
    "stoi2 = collections.defaultdict(lambda:-1, {v:k for k,v in enumerate(itos2)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we try to transfer the knowledge from wikitext to the IMDB LM, we match up the vocab words and their indexes. We use the defaultdict container once again, to assign mean weights to unknown IMDB tokens that do not exist in wikitext103."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "em_sz,nh,nl = 400,1150,3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "trn_lm = np.load(FINE_TUNE_PATH/'tmp'/'trn_ids.npy')\n",
    "val_lm = np.load(FINE_TUNE_PATH/'tmp'/'val_ids.npy')\n",
    "itos = pickle.load(open(FINE_TUNE_PATH/'tmp'/'itos.pkl', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60002, 2903507)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vs=len(itos)\n",
    "vs,len(trn_lm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_w = np.zeros((vs, em_sz), dtype=np.float32)\n",
    "for i,w in enumerate(itos):\n",
    "    r = stoi2[w]\n",
    "    new_w[i] = enc_wgts[r] if r>=0 else row_m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"We now overwrite the weights into the wgts odict. The decoder module, which we will explore in detail is also loaded with the same weights due to an idea called weight tying.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "wgts['0.encoder.weight'] = T(new_w)\n",
    "wgts['0.encoder_with_dropout.embed.weight'] = T(np.copy(new_w))\n",
    "wgts['1.decoder.weight'] = T(np.copy(new_w))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Language Model Finetuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "wd=1e-7\n",
    "bptt=70\n",
    "bs=64\n",
    "em_sz,nh,nl = 400,1150,3\n",
    "opt_fn = partial(optim.SGD, momentum=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "trn_lm = np.load(FINE_TUNE_PATH/'tmp'/'trn_ids.npy')\n",
    "val_lm = np.load(FINE_TUNE_PATH/'tmp'/'val_ids.npy')\n",
    "trn_lm = np.concatenate(trn_lm)\n",
    "val_lm = np.concatenate(val_lm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "itos = pickle.load(open(FINE_TUNE_PATH/'tmp'/'itos.pkl', 'rb'))\n",
    "vs = len(itos)\n",
    "\n",
    "trn_dl = LanguageModelLoader(trn_lm, bs, bptt)\n",
    "val_dl = LanguageModelLoader(val_lm, bs, bptt)\n",
    "md = LanguageModelData(FINE_TUNE_PATH, 1, vs, trn_dl, val_dl, bs=bs, bptt=bptt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "drops = np.array([0.25, 0.1, 0.2, 0.02, 0.15])*0.7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = md.get_model(opt_fn, em_sz, nh, nl, \n",
    "    dropouti=drops[0], dropout=drops[1], wdrop=drops[2], dropoute=drops[3], dropouth=drops[4])\n",
    "\n",
    "learn.metrics = [accuracy]\n",
    "learn.unfreeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.model.load_state_dict(wgts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load('lm1_wgts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "384fd76e48b04423b251ec718c29151e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=1, style=ProgressStyle(description_width='initial…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  2%|▏         | 300/13544 [01:16<55:57,  3.94it/s, loss=4.25]  "
     ]
    }
   ],
   "source": [
    "learn.lr_find2(start_lr=1e-1,end_lr=3e-1, num_it=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x864 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.sched.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr= 12e-2\n",
    "lrs = lr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.clip=0.12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8d2c62b63cf64be0b507e2fbfb7273b5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=20, style=ProgressStyle(description_width='initia…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss   accuracy                       \n",
      "    0      4.146484   4.076003   0.325902  \n",
      "    1      4.085562   4.045473   0.328404                       \n",
      "    2      4.045637   4.01578    0.330973                       \n",
      "    3      4.011313   3.989434   0.332991                       \n",
      "    4      3.96399    3.96926    0.334729                       \n",
      "    5      3.932326   3.953837   0.335982                       \n",
      "    6      3.91684    3.944764   0.336711                       \n",
      "    7      3.920672   3.94038    0.337094                       \n",
      "    8      3.909998   3.938073   0.337202                       \n",
      "    9      3.905821   3.937117   0.337492                       \n",
      "    10     3.891802   3.929351   0.337794                       \n",
      "    11     3.8689     3.917538   0.338524                       \n",
      "    12     3.832885   3.903798   0.339469                       \n",
      "    13     3.787091   3.891234   0.340544                       \n",
      "    14     3.772499   3.879684   0.341366                       \n",
      "    15     3.76934    3.871775   0.341932                       \n",
      "    16     3.791588   3.865283   0.342515                       \n",
      "    17     3.750893   3.862608   0.342781                       \n",
      "    18     3.754826   3.861336   0.342907                       \n",
      "    19     3.754324   3.861096   0.342964                       \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[array([3.8611]), 0.3429635709264911]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.fit(lr, 2, cycle_len=10, use_clr_beta=(10,33,0.95,0.85), best_save_name='lm1_wgts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load('lm1_wgts')\n",
    "learn.save_encoder('lm1_enc')"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}