IMDB Data Example SpaCy and SentencePiece

IMDB_data tokenize LM build SpaCy (default).ipynb

IMDB_data tokenize LM build.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": [
    "from fastai import *\n",
    "from fastai.text import *\n",
    "import re\n",
    "import sentencepiece as spm #https://github.com/google/sentencepiece\n",
    "\n",
    "np.random.seed(20180311)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sentencepiece tokenizer & LM Build"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data processing to DataBunch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get IMDB Data and build DF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PosixPath('/home/farzin/.fastai/data/imdb')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IMDB_PATH = untar_data(URLs.IMDB)\n",
    "IMDB_PATH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(75000, 25000)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## raw data does not have the unsup in the train directory.  Just move it there\n",
    "#  ~/.fastai/data/imdb$ mv unsup/ ./train/\n",
    "CLASSES = ['neg', 'pos', 'unsup']\n",
    "\n",
    "def get_texts(path):\n",
    "    texts,labels = [],[]\n",
    "    for idx,label in enumerate(CLASSES):\n",
    "        for fname in (path/label).glob('*.*'):\n",
    "            texts.append(fname.open('r', encoding='utf8').read())\n",
    "            labels.append([0]) ## all unsupervised case\n",
    "\n",
    "    return np.array(texts),np.array(labels)\n",
    "\n",
    "train_texts,train_labels = get_texts(IMDB_PATH/'train')\n",
    "valid_texts,valid_labels = get_texts(IMDB_PATH/'test')\n",
    "\n",
    "len(train_texts),len(valid_texts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## we can combine the \"train\" and \"valid\" for the LM step\n",
    "all_texts = np.concatenate([train_texts,valid_texts])\n",
    "all_texts_df = pd.DataFrame({'text':all_texts, 'labels':[0]*len(all_texts)}, columns=['labels','text'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default Rules:\n",
      " ['fix_html', 'replace_rep', 'replace_wrep', 'spec_add_spaces', 'rm_useless_spaces'] \n",
      "\n",
      "\n",
      "<function fix_html at 0x7f1058e22ea0>\n",
      "<function replace_rep at 0x7f1058e22d90>\n",
      "<function replace_wrep at 0x7f1058e22e18>\n",
      "<function spec_add_spaces at 0x7f105dbc2730>\n",
      "<function rm_useless_spaces at 0x7f1058e22d08>\n"
     ]
    }
   ],
   "source": [
    "raw_text = all_texts_df.loc[:,'text']\n",
    "\n",
    "print(\"Default Rules:\\n\",[x.__name__ for x in defaults.text_pre_rules],\"\\n\\n\")\n",
    "\n",
    "for rule in defaults.text_pre_rules:\n",
    "    print(rule)\n",
    "    raw_text = raw_text.apply(lambda x: rule(str(x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    <s>\"Fred Claus\" somehow avoids becoming this y...\n",
       "1    <s>Firstly I would like to point out that I on...\n",
       "2    <s>I finally got to have a look at this experi...\n",
       "3    <s>After having red the overwhelming reviews t...\n",
       "4    <s>About three minutes into this thing I start...\n",
       "Name: new_text, dtype: object"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## SentencePiece expects <s> ... </s> so we add that here:\n",
    "all_texts_df['new_text'] = '<s>' + raw_text + '</s>'\n",
    "all_texts_df['new_text'].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## save as a file for SP\n",
    "formatted_text_file = 'tmp_IMDB_SP_example'\n",
    "all_texts_df['new_text'].to_frame().to_csv(formatted_text_file, header=False,index=False,quotechar=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SP Tokenizer SWIG wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# m.model and m.vocab created in the pwd\n",
    "vocab_size = 500\n",
    "model_prefix = 'wk103m_example'\n",
    "\n",
    "spm.SentencePieceTrainer.Train(f'--input={formatted_text_file}'\\\n",
    "                               f' --model_prefix={model_prefix}'\\\n",
    "                               f' --vocab_size={vocab_size}')\n",
    "#                               f'--unk_piece={UNK} --bos_piece={BOS} --eos_id=-1 --pad_piece={PAD}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\t<unk>\t0\r\n",
      "     2\t<s>\t0\r\n",
      "     3\t</s>\t0\r\n",
      "     4\t▁\t-2.84395\r\n",
      "     5\ts\t-2.97\r\n",
      "     6\tt\t-3.53742\r\n",
      "     7\t▁the\t-3.7748\r\n",
      "     8\t.\t-3.86454\r\n",
      "     9\t,\t-3.91818\r\n",
      "    10\t▁a\t-4.07048\r\n",
      "    11\tn\t-4.18876\r\n",
      "    12\ta\t-4.24687\r\n",
      "    13\te\t-4.25059\r\n",
      "    14\to\t-4.27973\r\n",
      "    15\ty\t-4.44583\r\n",
      "    16\t▁to\t-4.48563\r\n",
      "    17\ting\t-4.50046\r\n",
      "    18\t▁and\t-4.50961\r\n",
      "    19\t▁of\t-4.5516\r\n",
      "    20\t'\t-4.64682\r\n",
      "    21\td\t-4.69638\r\n",
      "    22\t▁in\t-4.76258\r\n",
      "    23\ti\t-4.77796\r\n",
      "    24\ted\t-4.78844\r\n",
      "    25\tc\t-4.81265\r\n",
      "    26\tr\t-4.84313\r\n",
      "    27\t▁is\t-4.84642\r\n",
      "    28\tre\t-4.896\r\n",
      "    29\tp\t-4.94282\r\n",
      "    30\t▁I\t-4.97998\r\n",
      "    31\ter\t-4.9895\r\n",
      "    32\tu\t-4.99602\r\n",
      "    33\t▁it\t-5.11542\r\n",
      "    34\tor\t-5.14418\r\n",
      "    35\tb\t-5.17535\r\n",
      "    36\tar\t-5.22629\r\n",
      "    37\tm\t-5.2283\r\n",
      "    38\tle\t-5.23756\r\n",
      "    39\t▁f\t-5.23919\r\n",
      "    40\tw\t-5.28417\r\n",
      "    41\tf\t-5.28488\r\n",
      "    42\tly\t-5.29174\r\n",
      "    43\t▁that\t-5.29407\r\n",
      "    44\tal\t-5.30172\r\n",
      "    45\tg\t-5.30389\r\n",
      "    46\tl\t-5.37982\r\n",
      "    47\tin\t-5.40889\r\n",
      "    48\t▁this\t-5.4378\r\n",
      "    49\t-\t-5.48409\r\n",
      "    50\tk\t-5.5797\r\n"
     ]
    }
   ],
   "source": [
    "## Vocab in order of frequency\n",
    "!head -n50 {model_prefix}.vocab | nl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "## load up the Processor\n",
    "sp = spm.SentencePieceProcessor()\n",
    "sp.load(f'{model_prefix}.model')\n",
    "\n",
    "## itos from m.vocab file: just read directly and populate the dictionary\n",
    "itos = {}\n",
    "with open(f'{model_prefix}.vocab','r') as f:\n",
    "    for line_num,line in enumerate(f):\n",
    "        itos[line_num] = line.split(\"\\t\")[0]\n",
    "        \n",
    "stoi = {v:k for k,v in itos.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Based on Tokenizer() class: https://github.com/fastai/fastai/blob/master/fastai/text/transform.py#L87\n",
    "class CustomTokenizer():\n",
    "    '''Wrapper for SentencePiece toeknizer to fit into Fast.ai V1'''\n",
    "    def __init__(self,sp_processor,pre_rules:ListRules=None,post_rules:ListRules=None):\n",
    "        self.sp = sp_processor\n",
    "        self.pre_rules  = ifnone(pre_rules,  defaults.text_pre_rules )\n",
    "        \n",
    "    def __repr__(self) -> str:\n",
    "        return \"Custom Tokenizer\"\n",
    "\n",
    "    def process_text(self, t:str) -> List[str]:\n",
    "        \"Processe one text `t` with tokenizer `tok`.\"\n",
    "        for rule in self.pre_rules: t = rule(t)                                                                                 \n",
    "        toks = sp.EncodeAsIds(t)\n",
    "        \n",
    "        return toks \n",
    "    \n",
    "    def _process_all_1(self,texts:Collection[str]) -> List[List[str]]:\n",
    "        'Process a list of `texts` in one process'\n",
    "        return [self.process_text(t) 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)\n",
    "    \n",
    "mycust_tok = CustomTokenizer(sp)\n",
    "#setup Vocab object for use in LM  \n",
    "# Vocab source: https://github.com/fastai/fastai/blob/master/fastai/text/transform.py#L122\n",
    "sp_vocab = Vocab(itos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>labels</th>\n",
       "      <th>text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>Detective Frank Keller(Al Pacino, in a perfect...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>This is a VERY good movie. I give it a 10.&lt;br ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>I can't say I enjoyed this as much as \"The Big...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>I sat last night to see this film being played...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>First of all, I agree that the plot left somet...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   labels                                               text\n",
       "0       0  Detective Frank Keller(Al Pacino, in a perfect...\n",
       "1       0  This is a VERY good movie. I give it a 10.<br ...\n",
       "2       0  I can't say I enjoyed this as much as \"The Big...\n",
       "3       0  I sat last night to see this film being played...\n",
       "4       0  First of all, I agree that the plot left somet..."
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx = np.random.permutation(len(all_texts))\n",
    "cut = int(0.1 * len(idx))\n",
    "LM_train_df = pd.DataFrame({'text':all_texts[idx[cut:]], 'labels':[0] * (len(all_texts)-cut)}, columns=['labels','text'])\n",
    "LM_valid_df = pd.DataFrame({'text':all_texts[idx[:cut]], 'labels':[0] * cut}, columns=['labels','text'])\n",
    "LM_train_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = Path(\"./tmp_IMDB_example\")\n",
    "\n",
    "data = TextLMDataBunch.from_df(PATH, LM_train_df, LM_valid_df, \n",
    "                               tokenizer=mycust_tok, vocab=sp_vocab, \n",
    "                               text_cols='text', label_cols='labels')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  LM Learner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = language_model_learner(data, AWD_LSTM, drop_mult=0.5)\n",
    "learn.freeze()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  LM Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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"
     ]
    },
    {
     "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": [
    "lr_find(learn)\n",
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 14:24 <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.747901</th>\n",
       "    <th>3.465941</th>\n",
       "    <th>0.260205</th>\n",
       "    <th>14:24</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(1,1e-2)"
   ]
  },
  {
   "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_losses()"
   ]
  }
 ],
 "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.1"
  },
  "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
}