Final Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Only use competicion data for both fine-tuning and final classification"
   ]
  },
  {
   "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)"
   ]
  },
  {
   "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": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH=Path('./data/election_tweets')\n",
    "\n",
    "WIKILM_PATH=Path('./language_model_wiki/LM')\n",
    "\n",
    "TWEETSLM_PATH=Path('./LM_tweets')\n",
    "\n",
    "CLAS_PATH=Path('./tweets_class')\n",
    "\n",
    "PRE_FINETUNE_PATH=Path('./LM_fine_tune')\n",
    "\n",
    "BOS = 'xbos'  # beginning-of-sentence tag\n",
    "FLD = 'xfld'  # data field tag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Prepare Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(DATA_PATH/'corpus_completo_5_temas_08-sep-2016-codificacion_5_temas.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3116, 5)\n",
      "['Num' 'Id Tweet' 'Fecha Publicacion' 'Texto' 'Tema_05']\n",
      "False\n",
      "False\n",
      "2     1102\n",
      "1      738\n",
      "9      718\n",
      "11     359\n",
      "10     199\n",
      "Name: Tema_05, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df.shape)\n",
    "print(df.columns.values)\n",
    "print(df['Texto'].isnull().any())\n",
    "print(df['Tema_05'].isnull().any())\n",
    "print(df['Tema_05'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2    1102\n",
      "1     738\n",
      "3     718\n",
      "5     359\n",
      "4     199\n",
      "Name: Tema_05, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# encode lables\n",
    "df['Tema_05'] = df['Tema_05'].replace([1, 2, 9, 10, 11], [1, 2, 3, 4, 5])\n",
    "print(df['Tema_05'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "tweets = df['Texto'].values\n",
    "labels = df['Tema_05'].values\n",
    "LABELS = set(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hidden": true
   },
   "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": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "tweets = preprocess_tweets(tweets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "col_names = ['label', 'tweet']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train shapes: (2242,) (2242,)\n",
      "valid shapes: (250,) (250,)\n",
      "test shapes: (624,) (624,)\n"
     ]
    }
   ],
   "source": [
    "tweets_train, tweets_test, labels_train, labels_test = train_test_split(\n",
    "                                                    tweets, labels,\n",
    "                                                    stratify=labels, \n",
    "                                                    test_size=0.20)\n",
    "\n",
    "tweets_train, tweets_valid, labels_train, labels_valid = train_test_split(\n",
    "                                                    tweets_train, labels_train,\n",
    "                                                    stratify=labels_train, \n",
    "                                                    test_size=0.10)\n",
    "\n",
    "print('train shapes:', tweets_train.shape, labels_train.shape)\n",
    "print('valid shapes:', tweets_valid.shape, labels_valid.shape)\n",
    "print('test shapes:', tweets_test.shape, labels_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_trn = pd.DataFrame({'tweet':tweets_train, 'label':labels_train}, columns=col_names)\n",
    "df_val = pd.DataFrame({'tweet':tweets_valid, 'label':labels_valid}, columns=col_names)\n",
    "df_tst = pd.DataFrame({'tweet':tweets_test, 'label':labels_test}, columns=col_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2    794\n",
      "1    531\n",
      "3    516\n",
      "5    258\n",
      "4    143\n",
      "Name: label, dtype: int64\n",
      "2    88\n",
      "1    59\n",
      "3    58\n",
      "5    29\n",
      "4    16\n",
      "Name: label, dtype: int64\n",
      "2    220\n",
      "1    148\n",
      "3    144\n",
      "5     72\n",
      "4     40\n",
      "Name: label, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df_trn['label'].value_counts())\n",
    "print(df_val['label'].value_counts())\n",
    "print(df_tst['label'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5    794\n",
      "3    794\n",
      "1    794\n",
      "4    794\n",
      "2    794\n",
      "Name: label, dtype: int64\n",
      "2    88\n",
      "1    59\n",
      "3    58\n",
      "5    29\n",
      "4    16\n",
      "Name: label, dtype: int64\n",
      "2    220\n",
      "1    148\n",
      "3    144\n",
      "5     72\n",
      "4     40\n",
      "Name: label, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "def balance_df(df):\n",
    "    lst = [df]\n",
    "    max_size = df['label'].value_counts().max()\n",
    "    for class_index, group in df.groupby('label'):\n",
    "        lst.append(group.sample(max_size-len(group), replace=True))\n",
    "    df = pd.concat(lst)\n",
    "    return df\n",
    "\n",
    "df_trn = balance_df(df_trn)\n",
    "\n",
    "print(df_trn['label'].value_counts())\n",
    "print(df_val['label'].value_counts())\n",
    "print(df_tst['label'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_trn.to_csv(CLAS_PATH/'train.csv', header=False, index=False)\n",
    "df_val.to_csv(CLAS_PATH/'validation.csv', header=False, index=False)\n",
    "df_tst.to_csv(CLAS_PATH/'test.csv', header=False, index=False)\n",
    "\n",
    "(CLAS_PATH/'classes.txt').open('w').writelines(f'{o}\\n' for o in LABELS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Create dataframes for Language Model fine-tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "tweets_lm = np.concatenate([tweets_train, tweets_valid, tweets_test])\n",
    "labels_lm = np.concatenate([labels_train, labels_valid, labels_test])\n",
    "\n",
    "tweets_train_lm, tweets_valid_lm, labels_train_lm, labels_valid_lm = train_test_split(\n",
    "                                                    tweets_lm, labels_lm,\n",
    "                                                    stratify=labels_lm, \n",
    "                                                    test_size=0.10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_trn = pd.DataFrame({'tweet':tweets_train_lm, 'label':[0]*len(tweets_train_lm)}, columns=col_names)\n",
    "df_val = pd.DataFrame({'tweet':tweets_valid_lm, 'label':[0]*len(tweets_valid_lm)}, columns=col_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_trn.to_csv(TWEETSLM_PATH/'train.csv', header=False, index=False)\n",
    "df_val.to_csv(TWEETSLM_PATH/'validation.csv', header=False, index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2804, 2), (312, 2))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_trn.shape, df_val.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Tokenize and Standarize General Tokens\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "chunksize=24000\n",
    "\n",
    "re1 = re.compile(r'  +')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "hidden": true
   },
   "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": 21,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_trn = pd.read_csv(TWEETSLM_PATH/'train.csv', header=None, chunksize=chunksize)\n",
    "df_val = pd.read_csv(TWEETSLM_PATH/'validation.csv', header=None, chunksize=chunksize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hidden": true
   },
   "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": 23,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2804, 2804, 312, 312)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(tok_trn),len(trn_labels), len(tok_val), len(val_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['\\n', 'xbos', '@ahorapodemos', '@ierrejon', 'totalmente', 'de', 'acuerdo', ',', 'pero', 'son', 'grandes', 'manippuladores.expertos', 'en', 'guerra', 'sucia', 'y', 'con', 'grandes', 'medios.adelante', '.'], ['\\n', 'xbos', 'rt', '@eldiarioes', ':', 'rivera', ':', '\"', 'me', 'río', 'un', 'rato', 'cuando', 'me', 'dicen', 'que', 'somos', 'el', 'partido', 'del', 'ibex', '\"', 'hyp_link', 'hyp_link']]\n"
     ]
    }
   ],
   "source": [
    "print(tok_trn[:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(TWEETSLM_PATH/'tmp').mkdir(exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "np.save(TWEETSLM_PATH/'tmp'/'tok_trn.npy', tok_trn)\n",
    "np.save(TWEETSLM_PATH/'tmp'/'tok_val.npy', tok_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "tok_trn = np.load(TWEETSLM_PATH/'tmp'/'tok_trn.npy')\n",
    "tok_val = np.load(TWEETSLM_PATH/'tmp'/'tok_val.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('\\n', 2804),\n",
       " ('xbos', 2804),\n",
       " (':', 2725),\n",
       " ('t_up', 2261),\n",
       " ('hyp_link', 2056),\n",
       " ('de', 2055),\n",
       " ('#', 2009),\n",
       " ('hash_tag', 1987),\n",
       " ('rt', 1959),\n",
       " ('el', 1603),\n",
       " ('que', 1359),\n",
       " ('.', 1319),\n",
       " ('la', 1285),\n",
       " ('a', 1272),\n",
       " (',', 1259),\n",
       " ('y', 1094),\n",
       " ('en', 1093),\n",
       " ('\"', 994),\n",
       " ('no', 707),\n",
       " ('los', 571)]"
      ]
     },
     "execution_count": 28,
     "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": 77,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "max_vocab = 60000\n",
    "min_freq = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3569"
      ]
     },
     "execution_count": 78,
     "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": 79,
   "metadata": {
    "hidden": true
   },
   "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": 80,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "np.save(TWEETSLM_PATH/'tmp'/'trn_ids.npy', trn_lm)\n",
    "np.save(TWEETSLM_PATH/'tmp'/'val_ids.npy', val_lm)\n",
    "pickle.dump(itos, open(TWEETSLM_PATH/'tmp'/'itos.pkl', 'wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Load Encoder Weights for Language Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "BACKBONE_MODEL = PRE_FINETUNE_PATH/'models/lm1_wgts.h5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "wgts = torch.load(BACKBONE_MODEL, map_location=lambda storage, loc: storage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "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": 5,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "enc_wgts = to_np(wgts['0.encoder.weight'])\n",
    "row_m = enc_wgts.mean(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "itos2 = pickle.load((PRE_FINETUNE_PATH/'tmp'/'itos.pkl').open('rb'))\n",
    "stoi2 = collections.defaultdict(lambda:-1, {v:k for k,v in enumerate(itos2)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "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": 7,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "em_sz,nh,nl = 400,1150,3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "trn_lm = np.load(TWEETSLM_PATH/'tmp'/'trn_ids.npy')\n",
    "val_lm = np.load(TWEETSLM_PATH/'tmp'/'val_ids.npy')\n",
    "itos = pickle.load(open(TWEETSLM_PATH/'tmp'/'itos.pkl', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3569, 2804)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vs=len(itos)\n",
    "vs,len(trn_lm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reuse 3356 word embeddings from fine-tuning\n",
      "213 where not in vocab from fine-tuning\n"
     ]
    }
   ],
   "source": [
    "new_w = np.zeros((vs, em_sz), dtype=np.float32)\n",
    "n_replaced_vocab = 0\n",
    "\n",
    "for i,w in enumerate(itos):\n",
    "    r = stoi2[w]\n",
    "    if r>=0 :\n",
    "        new_w[i] = enc_wgts[r]\n",
    "        n_replaced_vocab +=1\n",
    "    else:\n",
    "        new_w[i] = row_m\n",
    "\n",
    "print(f'Reuse {n_replaced_vocab} word embeddings from fine-tuning')\n",
    "print(f'{vs-n_replaced_vocab} where not in vocab from fine-tuning')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "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": 11,
   "metadata": {
    "hidden": true
   },
   "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": {
    "heading_collapsed": true
   },
   "source": [
    "## Language Model Finetuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "wd=1e-7\n",
    "bptt=70\n",
    "bs=32\n",
    "em_sz,nh,nl = 400,1150,3\n",
    "opt_fn = partial(optim.SGD, momentum=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "trn_lm = np.load(TWEETSLM_PATH/'tmp'/'trn_ids.npy')\n",
    "val_lm = np.load(TWEETSLM_PATH/'tmp'/'val_ids.npy')\n",
    "trn_lm = np.concatenate(trn_lm)\n",
    "val_lm = np.concatenate(val_lm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "itos = pickle.load(open(TWEETSLM_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(TWEETSLM_PATH, 1, vs, trn_dl, val_dl, bs=bs, bptt=bptt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#drops = np.array([0.25, 0.1, 0.2, 0.02, 0.15])*0.7\n",
    "drops = np.array([0.25, 0.1, 0.2, 0.02, 0.15])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hidden": true
   },
   "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": 17,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "learn.model.load_state_dict(wgts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5311ac3c0a0c4617a3ae6567faf128c3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=10, style=ProgressStyle(description_width='initia…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                          \r"
     ]
    }
   ],
   "source": [
    "learn.lr_find2(start_lr=1e-1,end_lr=3e-1, num_it=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hidden": true
   },
   "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": 20,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "lr= 12e-2\n",
    "lrs = lr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "learn.clip=0.12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5f678275a7394476b7613ae797a7f58e",
       "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      3.512094   3.143803   0.361683  \n",
      "    1      3.463854   3.109608   0.370076                 \n",
      "    2      3.424736   3.081873   0.37387                  \n",
      "    3      3.394829   3.04915    0.380063                 \n",
      "    4      3.374648   3.046742   0.381777                 \n",
      "    5      3.356267   3.033215   0.387061                 \n",
      "    6      3.346115   3.029274   0.388473                 \n",
      "    7      3.346055   3.03861    0.384868                 \n",
      "    8      3.341172   3.017115   0.390713                 \n",
      "    9      3.335366   3.032818   0.385621                 \n",
      "    10     3.335254   3.020991   0.389409                 \n",
      "    11     3.323995   3.013379   0.389844                 \n",
      "    12     3.315387   3.015023   0.390625                 \n",
      "    13     3.304528   3.00829    0.390722                 \n",
      "    14     3.297402   3.004618   0.39092                  \n",
      "    15     3.289839   2.999266   0.395143                 \n",
      "    16     3.278691   3.016183   0.390739                 \n",
      "    17     3.273526   2.997917   0.395143                 \n",
      "    18     3.271013   3.000481   0.393347                 \n",
      "    19     3.26961    2.98832    0.398525                 \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[array([2.98832]), 0.3985252778851584]"
      ]
     },
     "execution_count": 22,
     "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": 23,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "learn.load('lm1_wgts')\n",
    "learn.save_encoder('lm1_enc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Classifier tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "chunksize=24000\n",
    "\n",
    "re1 = re.compile(r'  +')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_trn = pd.read_csv(CLAS_PATH/'train.csv', header=None, chunksize=chunksize)\n",
    "df_val = pd.read_csv(CLAS_PATH/'validation.csv', header=None, chunksize=chunksize)\n",
    "df_tst = pd.read_csv(CLAS_PATH/'test.csv', header=None, chunksize=chunksize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "tok_trn, trn_labels = get_all(df_trn, 1)\n",
    "tok_val, val_labels = get_all(df_val, 1)\n",
    "tok_tst, tst_labels = get_all(df_tst, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(CLAS_PATH/'tmp').mkdir(exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "np.save(CLAS_PATH/'tmp'/'tok_trn.npy', tok_trn)\n",
    "np.save(CLAS_PATH/'tmp'/'tok_val.npy', tok_val)\n",
    "np.save(CLAS_PATH/'tmp'/'tok_tst.npy', tok_tst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "np.save(CLAS_PATH/'tmp'/'trn_labels.npy', trn_labels)\n",
    "np.save(CLAS_PATH/'tmp'/'val_labels.npy', val_labels)\n",
    "np.save(CLAS_PATH/'tmp'/'tst_labels.npy', tst_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "tok_trn = np.load(CLAS_PATH/'tmp'/'tok_trn.npy')\n",
    "tok_val = np.load(CLAS_PATH/'tmp'/'tok_val.npy')\n",
    "tok_tst = np.load(CLAS_PATH/'tmp'/'tok_tst.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3569"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itos = pickle.load((TWEETSLM_PATH/'tmp'/'itos.pkl').open('rb'))\n",
    "stoi = collections.defaultdict(lambda:0, {v:k for k,v in enumerate(itos)})\n",
    "len(itos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "trn_clas = np.array([[stoi[o] for o in p] for p in tok_trn])\n",
    "val_clas = np.array([[stoi[o] for o in p] for p in tok_val])\n",
    "tst_clas = np.array([[stoi[o] for o in p] for p in tok_tst])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "np.save(CLAS_PATH/'tmp'/'trn_ids.npy', trn_clas)\n",
    "np.save(CLAS_PATH/'tmp'/'val_ids.npy', val_clas)\n",
    "np.save(CLAS_PATH/'tmp'/'tst_ids.npy', tst_clas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "trn_clas = np.load(CLAS_PATH/'tmp'/'trn_ids.npy')\n",
    "val_clas = np.load(CLAS_PATH/'tmp'/'val_ids.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "trn_labels = np.squeeze(np.load(CLAS_PATH/'tmp'/'trn_labels.npy'))\n",
    "val_labels = np.squeeze(np.load(CLAS_PATH/'tmp'/'val_labels.npy'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bptt,em_sz,nh,nl = 70,400,1150,3\n",
    "vs = len(itos)\n",
    "opt_fn = partial(optim.Adam, betas=(0.8, 0.99))\n",
    "bs = 96"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "min_lbl = trn_labels.min()\n",
    "trn_labels -= min_lbl\n",
    "val_labels -= min_lbl\n",
    "c=int(trn_labels.max())+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "In the classifier, unlike LM, we need to read a tweet at a time. We do not deal with equal bptt size batches, so we have to pad the sequences to the same length in each batch. To create batches of similar sized movie tweets, we use a sortish sampler method invented by [@Smerity](https://twitter.com/Smerity) and [@jekbradbury](https://twitter.com/jekbradbury)\n",
    "\n",
    "The sortishSampler cuts down the overall number of padding tokens the classifier ends up seeing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "trn_ds = TextDataset(trn_clas, trn_labels)\n",
    "val_ds = TextDataset(val_clas, val_labels)\n",
    "trn_samp = SortishSampler(trn_clas, key=lambda x: len(trn_clas[x]), bs=bs//2)\n",
    "val_samp = SortSampler(val_clas, key=lambda x: len(val_clas[x]))\n",
    "trn_dl = DataLoader(trn_ds, bs//2, transpose=True, num_workers=1, pad_idx=1, sampler=trn_samp)\n",
    "val_dl = DataLoader(val_ds, bs, transpose=True, num_workers=1, pad_idx=1, sampler=val_samp)\n",
    "md = ModelData(TWEETSLM_PATH, trn_dl, val_dl, test_dl=val_dl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#dps = np.array([0.4,0.5,0.05,0.3,0.4])*0.8\n",
    "dps = np.array([0.4,0.5,0.05,0.3,0.4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "m = get_rnn_classifer(bptt, 20*70, c, vs, emb_sz=em_sz, n_hid=nh, n_layers=nl, pad_token=1,\n",
    "          layers=[em_sz*3, 50, c], drops=[dps[4], 0.1],\n",
    "          dropouti=dps[0], wdrop=dps[1], dropoute=dps[2], dropouth=dps[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "opt_fn = partial(optim.Adam, betas=(0.7, 0.99))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "learn = RNN_Learner(md, TextModel(to_gpu(m)), opt_fn=opt_fn)\n",
    "learn.reg_fn = partial(seq2seq_reg, alpha=2, beta=1)\n",
    "learn.clip=.12\n",
    "learn.metrics = [accuracy]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "#wd = 1e-7\n",
    "learn.load_encoder('lm1_enc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "learn.freeze_to(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "92d19de5ef36472ab045827dd26af09b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=4, style=ProgressStyle(description_width='initial…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                          \r"
     ]
    },
    {
     "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.lr_find2(start_lr=1e-4,end_lr=2e-3, num_it=300)\n",
    "learn.sched.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "lr= 6e-4\n",
    "lrm = 2.6\n",
    "lrs = np.array([lr/(lrm**4), lr/(lrm**3), lr/(lrm**2), lr/lrm, lr])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8b1c9d9f8e51461cb6c3172f28ad2846",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=4, style=ProgressStyle(description_width='initial…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss   accuracy                 \n",
      "    0      1.488677   1.34094    0.502495  \n",
      "    1      1.387118   1.234598   0.546618                 \n",
      "    2      1.312703   1.137717   0.620914                 \n",
      "    3      1.265535   1.107144   0.612576                 \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[array([1.10714]), 0.6125756885324206]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.fit(lrs, 4, wds=wd, cycle_len=1, use_clr_beta=(32,10,0.8,0.7), best_save_name='clas2_0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "learn.load('clas2_0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "learn.freeze_to(-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c6925877c87b4f67b740da98ac57a096",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=8, style=ProgressStyle(description_width='initial…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss   accuracy                 \n",
      "    0      1.235413   1.101505   0.602274  \n",
      "    1      1.226216   1.101165   0.595277                 \n",
      "    2      1.202811   1.05636    0.628502                 \n",
      "    3      1.143528   1.049464   0.627495                 \n",
      "    4      1.180812   1.026346   0.613807                 \n",
      "    5      1.158619   1.029651   0.631889                 \n",
      "    6      1.124048   1.033859   0.568824                 \n",
      "    7      1.123336   1.021324   0.575373                 \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[array([1.02132]), 0.5753733026129859]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.fit(lrs, 8, wds=wd, cycle_len=1, use_clr_beta=(32,10,0.8,0.7),  best_save_name='clas2_1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "learn.load('clas2_1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "learn.unfreeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f74149fc9d654a39814c7b2e0684a405",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=10, style=ProgressStyle(description_width='initia…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss   accuracy                 \n",
      "    0      1.129126   0.999955   0.603981  \n",
      "    1      1.064518   0.935651   0.637655                 \n",
      "    2      0.966681   0.882731   0.652126                  \n",
      "    3      0.86542    0.883413   0.643306                  \n",
      "    4      0.80838    0.872838   0.671804                  \n",
      "    5      0.797952   0.841629   0.656327                  \n",
      "    6      0.729612   0.824696   0.662318                  \n",
      "    7      0.663911   0.836466   0.679841                  \n",
      "    8      0.612505   0.820628   0.685274                  \n",
      "    9      0.57248    0.805872   0.700527                  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[array([0.80587]), 0.7005272507667542]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.fit(lr, 2, cycle_len=5, use_clr_beta=(32,10,0.8,0.7), best_save_name='final')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "hidden": true
   },
   "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.load('final')\n",
    "learn.sched.plot_loss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1(macro) =  0.7308588062526968\n",
      "Accuracy  =  0.75\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bs = 256\n",
    "bptt,em_sz,nh,nl = 70,400,1150,3\n",
    "\n",
    "tst_sent = np.load(CLAS_PATH/'tmp/tst_ids.npy')\n",
    "tst_lbls = np.load(CLAS_PATH/'tmp/tst_labels.npy').flatten()\n",
    "tst_lbls -= tst_lbls.min()\n",
    "c=int(tst_lbls.max())+1\n",
    "tst_ds = TextDataset(tst_sent, tst_lbls)\n",
    "tst_samp = SortSampler(tst_sent, key=lambda x: len(tst_sent[x]))\n",
    "tst_lbls_sampled = tst_lbls[list(tst_samp)]\n",
    "tst_dl = DataLoader(tst_ds, bs, transpose=True, num_workers=1, pad_idx=1, sampler=tst_samp)\n",
    "md = ModelData(TWEETSLM_PATH, None, tst_dl)\n",
    "itos = pickle.load(open(TWEETSLM_PATH/'tmp/itos.pkl', 'rb'))\n",
    "vs = len(itos)\n",
    "    \n",
    "m = get_rnn_classifer(bptt, 20*70, c, vs, emb_sz=em_sz, n_hid=nh, n_layers=nl, pad_token=1,\n",
    "                layers=[em_sz*3, 50, c], drops=[0., 0.])\n",
    "\n",
    "learn = RNN_Learner(md, TextModel(to_gpu(m)))\n",
    "learn.load_encoder('lm1_enc')\n",
    "learn.load('final')\n",
    "predictions = np.argmax(learn.predict(), axis=1)\n",
    "\n",
    "f1 = f1_score(tst_lbls_sampled, predictions, average='macro')\n",
    "print('F1(macro) = ', f1)\n",
    "\n",
    "acc = (tst_lbls_sampled == predictions).mean()\n",
    "print('Accuracy  = ', acc)\n",
    "\n",
    "\n",
    "cnf_matrix = confusion_matrix(tst_lbls_sampled, predictions)\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=['PI', 'PoI', 'CI', 'PeI', 'O'], title='confusion matrix')\n",
    "plt.show()"
   ]
  },
  {
   "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
}