01_train_LM_en.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nbdev.showdoc import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default_exp core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from fastai2.text.all import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data is seperated into two folders, `train` and `valid`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0m\u001b[01;34mtrain\u001b[0m/  \u001b[01;34mvalid\u001b[0m/\r\n"
     ]
    }
   ],
   "source": [
    "ls data/en-100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The issue is that all of the data, in each folder, lives in just a single file. We want to run the tokenization in parallel and as such it would be best to split the files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def split_file_into_chunks(path, num_chunks=24):\n",
    "    txt = Path(path).read().split('\\n')\n",
    "    chunk_len = len(txt) // num_chunks\n",
    "    \n",
    "    for i in range(num_chunks):\n",
    "        with open(Path(path).parent / f'{i}.txt', \"w\") as text_file:\n",
    "            text_file.write('\\n'.join(txt[i*chunk_len:(i+1)*chunk_len]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split_file_into_chunks('data/en-100/train/en.wiki.train.tokens')\n",
    "# split_file_into_chunks('data/en-100/valid/en.wiki.valid.tokens')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !rm data/en-100/train/*.txt\n",
    "# !rm data/en-100/valid/*.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.txt   13.txt  17.txt  20.txt  2.txt  6.txt  en.wiki.train.tokens\r\n",
      "10.txt  14.txt  18.txt  21.txt  3.txt  7.txt\r\n",
      "11.txt  15.txt  19.txt  22.txt  4.txt  8.txt\r\n",
      "12.txt  16.txt  1.txt   23.txt  5.txt  9.txt\r\n"
     ]
    }
   ],
   "source": [
    "ls data/en-100/train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To tokenize the text, we can use the very handy `tokenize_folder` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tokenize_folder('data/en-100/', folders=['train', 'valid'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tokenized text now lives in a new folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "counter.pkl  \u001b[0m\u001b[01;34mmodels\u001b[0m/  \u001b[01;34mtrain\u001b[0m/  \u001b[01;34mvalid\u001b[0m/\r\n"
     ]
    }
   ],
   "source": [
    "ls data/en-100_tok/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To have control over the vocabulary our LM will use, we can use `make_vocab` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab = make_vocab(pd.read_pickle('data/en-100_tok/counter.pkl'), max_vocab=4000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'data/en-100_tok/'\n",
    "mult = 4\n",
    "bs = 80\n",
    "seq_len = 70\n",
    "\n",
    "lm = DataBlock(blocks=(TextBlock(vocab=vocab, is_lm=True),),\n",
    "                get_x=read_tokenized_file,\n",
    "                get_items=partial(get_text_files, folders=['train', 'valid']),\n",
    "                splitter=FuncSplitter(lambda itm: itm.parent.name == 'valid'))\n",
    "\n",
    "dbunch_lm = lm.databunch(path, path=path, bs=bs, seq_len=seq_len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we go for a vocab of 4k, how many unknowns will we get?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.mean((torch.cat([tup[0] for tup in dbunch_lm.valid_ds]) == 0).float())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is stunning, the fact that just 4k tokens cover so much vocabulary! Since the initial intent is exploratory, a 4k vocab will be a great starting point. This should allow us to experiment with all of the architectures we have in our arsenal without worrying too much about memory footprint.\n",
    "\n",
    "Let's start with training a basic architecture with a permutation matrix between the embeddings and the model. This setup will allow us to experiment whether the model will be able to learn the mapping of words to embeddings should we wipe it out. Also, what happens if we replace the English embeddings with embeddings from a different language? Is there enough structure in the embedding space for the LM to be able to map foreign language embeddings to their English counterparts?\n",
    "\n",
    "We replace the encoder with our `PermuteEmgedding` layer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PermuteEmbedding(nn.Module):\n",
    "    def __init__(self, num_embeddings, embedding_dim, padding_idx):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.num_embeddings = num_embeddings\n",
    "        self.embedding_dim = embedding_dim\n",
    "        self.padding_idx = padding_idx\n",
    "        \n",
    "        # to conform to nn.Embedding api\n",
    "        self.max_norm=None\n",
    "        self.norm_type=2.0\n",
    "        self.scale_grad_by_freq=False\n",
    "        self.sparse = False\n",
    "\n",
    "        self.weight = nn.Parameter( torch.Tensor(num_embeddings, embedding_dim) )\n",
    "        self.p = nn.Parameter( torch.eye(self.num_embeddings) )\n",
    "        self.p.requires_grad = False\n",
    "        \n",
    "        self.reset_parameters()\n",
    "        \n",
    "    def forward(self, words):\n",
    "        return F.embedding(words, self.p @ self.weight)\n",
    "    \n",
    "    def reset_parameters(self): pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time to modify the `AWD_LSTM` architecture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class pAWD_LSTM(AWD_LSTM):\n",
    "    def __init__(self, vocab_sz, emb_sz, n_hid, n_layers, pad_token=1, hidden_p=0.2, input_p=0.6, embed_p=0.1,\n",
    "                 weight_p=0.5, bidir=False, packed=False):\n",
    "        store_attr(self, 'emb_sz,n_hid,n_layers,pad_token,packed')\n",
    "        self.bs = 1\n",
    "        self.n_dir = 2 if bidir else 1\n",
    "#         self.encoder = nn.Embedding(vocab_sz, emb_sz, padding_idx=pad_token)\n",
    "        self.encoder = PermuteEmbedding(vocab_sz, emb_sz, padding_idx=pad_token)\n",
    "    \n",
    "#         self.encoder_dp = EmbeddingDropout(self.encoder, embed_p)\n",
    "        self.encoder_dp = self.encoder # chosing to initally train without embedding dropout\n",
    "        self.rnns = nn.ModuleList([self._one_rnn(emb_sz if l == 0 else n_hid, (n_hid if l != n_layers - 1 else emb_sz)//self.n_dir,\n",
    "                                                 bidir, weight_p, l) for l in range(n_layers)])\n",
    "        self.encoder.weight.data.uniform_(-self.initrange, self.initrange)\n",
    "        self.input_dp = RNNDropout(input_p)\n",
    "        self.hidden_dps = nn.ModuleList([RNNDropout(hidden_p) for l in range(n_layers)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding our architecture to `_model_meta` so that we can nicely interface with the `fastai v2` machinery."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "import fastai2\n",
    "fastai2.text.models.core._model_meta[pAWD_LSTM] = fastai2.text.models.core._model_meta[AWD_LSTM]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "\n",
    "# TODO: add gradient clipping of 0.12 at some point\n",
    "\n",
    "def opt(params, lr):\n",
    "    return Adam(params, lr, mom=0.8, sqr_mom=0.99)\n",
    "\n",
    "drops = np.array([0.25, 0.1, 0.2, 0.02, 0.15])\n",
    "\n",
    "config = dict(\n",
    "    emb_sz=100,\n",
    "    n_hid=1150,\n",
    "    n_layers=3,\n",
    "    input_p=drops[0],\n",
    "    hidden_p=drops[1],\n",
    "    weight_p=drops[2],\n",
    "    embed_p=drops[3])\n",
    "\n",
    "awd_lstm_lm_config.update(config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = language_model_learner(\n",
    "    dbunch_lm,\n",
    "    pAWD_LSTM,\n",
    "    opt_func=opt,\n",
    "    pretrained=False,\n",
    "    config=awd_lstm_lm_config,\n",
    "    drop_mult=0.1,\n",
    "    metrics=[accuracy]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\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",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>2.904468</td>\n",
       "      <td>2.818111</td>\n",
       "      <td>0.426659</td>\n",
       "      <td>46:37</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(1, 5e-3,  moms=(0.8, 0.7, 0.8), wd=1e-7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# learn.save('pLSTM_en')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<fastai2.text.learner.LMLearner at 0x7f04353aebd0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.load('pLSTM_en')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\"The man who tried to hit the Le Recording Company in Mount Stephen 's army near\""
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.predict('The man', n_words=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have a trained LM, let's wipe the mapping from words to embeddings and see if we can recover it.\n",
    "\n",
    "We will freeze the model and only train the part mapping from word idx to embedding (or, in other words, performing a linear combination of embeddings and ideally assigning the largest weight to the correct embedding for a given word idx)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "import warnings\n",
    "\n",
    "@patch_to(LMLearner)\n",
    "def optimize_permutation(self):\n",
    "    with warnings.catch_warnings():\n",
    "        warnings.simplefilter(\"ignore\")\n",
    "        self.freeze_to(4)\n",
    "    self.model[0].encoder.p.requires_grad = True\n",
    "    \n",
    "@patch_to(LMLearner)\n",
    "def optimize_model(self):\n",
    "    self.unfreeze()\n",
    "    self.model[0].encoder.p.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.optimize_permutation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.model[0].encoder.p.requires_grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.model[0].encoder.weight.requires_grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def aza_loss(learn, input=None, target=None, scaling_factor=5/2000, debug=False):\n",
    "    p = learn.model[0].encoder.p\n",
    "    sums_to_one = (1-p.abs().sum(dim=0)).abs().sum() + (1-p.abs().sum(dim=1)).abs().sum()\n",
    "    the_model = CrossEntropyLossFlat()(input, target)\n",
    "    if debug: return sums_to_one, the_model\n",
    "    else:     return scaling_factor * sums_to_one + (1 - scaling_factor) * the_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[1., 0., 0.,  ..., 0., 0., 0.],\n",
       "        [0., 1., 0.,  ..., 0., 0., 0.],\n",
       "        [0., 0., 1.,  ..., 0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0.,  ..., 1., 0., 0.],\n",
       "        [0., 0., 0.,  ..., 0., 1., 0.],\n",
       "        [0., 0., 0.,  ..., 0., 0., 1.]], device='cuda:0', requires_grad=True)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.model[0].encoder.p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "preds, targs = learn.get_preds()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(2.8107, device='cuda:0', grad_fn=<AddBackward0>)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aza_loss(learn, preds, targs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[ 0.0051,  0.0193, -0.0052,  ..., -0.0437, -0.0082, -0.0039],\n",
       "        [-0.0143,  0.0311,  0.0125,  ...,  0.0009, -0.0131, -0.0531],\n",
       "        [ 0.0110, -0.0108,  0.0508,  ..., -0.0026,  0.0138, -0.0033],\n",
       "        ...,\n",
       "        [-0.0406,  0.0192,  0.0293,  ..., -0.0078, -0.0231, -0.0044],\n",
       "        [-0.0192, -0.0023, -0.0092,  ..., -0.0520, -0.0204,  0.0116],\n",
       "        [ 0.0316, -0.0025,  0.0039,  ..., -0.0014, -0.0006,  0.0467]],\n",
       "       device='cuda:0', requires_grad=True)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nn.init.kaiming_normal_(learn.model[0].encoder.p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "preds, targs = learn.get_preds()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(564637.8750, device='cuda:0', grad_fn=<AddBackward0>), tensor(6.2451))"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aza_loss(learn, preds, targs, debug=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.loss_func = lambda preds, targs: aza_loss(learn, preds, targs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\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",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>3.020772</td>\n",
       "      <td>2.977226</td>\n",
       "      <td>0.403813</td>\n",
       "      <td>40:20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(1, 1e-3,  moms=(0.8, 0.7, 0.8), wd=1e-7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# learn.save('pLSTM_en_permute_embeddings')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<fastai2.text.learner.LMLearner at 0x7fc7eadbd4d0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.load('pLSTM_en_permute_embeddings')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch_to(LMLearner)\n",
    "def hitInTopN(self, n=1, how_many=None):\n",
    "    data = self.model[0].encoder.p.data.argsort(descending=True)[10:10+how_many, :n]\n",
    "    hits = torch.any(data == torch.arange(10, how_many+10).reshape(-1,1).cuda(), -1)\n",
    "    return hits.float().mean().item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9899999499320984, 1.0)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.hitInTopN(1, 100), learn.hitInTopN(5, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "acc1 = [(x, learn.hitInTopN(1, x)) for x in range(50,1500,200)]\n",
    "acc2 = [(x, learn.hitInTopN(2, x)) for x in range(50,1500,200)]\n",
    "acc3 = [(x, learn.hitInTopN(3, x)) for x in range(50,1500,200)]\n",
    "acc5 = [(x, learn.hitInTopN(5, x)) for x in range(50,1500,200)]\n",
    "acc10 = [(x, learn.hitInTopN(10, x)) for x in range(50,1500,200)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fc7eaa834d0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,10))\n",
    "plt.plot(*zip(*acc1))\n",
    "plt.plot(*zip(*acc2))\n",
    "plt.plot(*zip(*acc3))\n",
    "plt.plot(*zip(*acc5))\n",
    "plt.plot(*zip(*acc10))\n",
    "plt.legend([f'acc @ {x}' for x in [1,2,3,5,10]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch_to(LMLearner)\n",
    "def print_synonyms(self, start_idx, n):\n",
    "    data = self.model[0].encoder.p.data.argsort(descending=True)[:, :5]\n",
    "    print('actual word\\t\\tpredictions\\n')\n",
    "    for i in range(start_idx, start_idx+n):\n",
    "        print(f'{self.dbunch.vocab[i]}\\t\\t{[self.dbunch.vocab[idx] for idx in data[i]]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "actual word\t\tpredictions\n",
      "\n",
      "two\t\t['two', 'three', 'four', 'few', 'five']\n",
      "or\t\t['or', 'nor', '&', 'and', '/']\n",
      "have\t\t['have', 've', 'has', 'shall', 'will']\n",
      "who\t\t['who', 'whom', 'whose', 'he', 'you']\n",
      "new\t\t['new', 'great', 'greater', 'larger', 'los']\n",
      "been\t\t['been', 'become', 'remained', 'being', 'come']\n",
      "has\t\t['has', 've', 'have', 'will', 'shall']\n",
      "@,@\t\t['@,@', '×', '<', 'xxrep', 'per']\n",
      "she\t\t['she', 'madonna', 'actress', 'neither', 'none']\n",
      "when\t\t['when', 'shortly', 'here', 'meanwhile', 'although']\n",
      "time\t\t['time', 'moment', 'way', 'times', 'reason']\n",
      "during\t\t['during', 'throughout', 'shortly', 'within', 'after']\n",
      "other\t\t['other', 'different', 'others', 'older', 'smaller']\n",
      "would\t\t['would', 'might', 'could', 'should', \"'ll\"]\n",
      "into\t\t['into', 'onto', 'across', 'toward', 'towards']\n",
      "all\t\t['all', 'every', 'any', 'both', 'those']\n",
      "i\t\t['i', 'we', 'doesn', '[', '<']\n",
      "more\t\t['more', 'less', 'relatively', 'very', 'much']\n",
      "0\t\t['0', '600', '500', '700', '400']\n",
      "while\t\t['while', 'whilst', 'whereas', 'although', 'shortly']\n"
     ]
    }
   ],
   "source": [
    "learn.print_synonyms(60, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_data.ipynb.\n",
      "Converted 01_train_LM_en.ipynb.\n",
      "Converted 02_train_LM_es.ipynb.\n",
      "Converted 03_translate_en_to_es.ipynb.\n",
      "Converted 04_LM_with_normalized_embeddings.ipynb.\n",
      "Converted 04a_LM_with_normalized_embeddings_mixer_softmax.ipynb.\n",
      "Converted 05_aligning_the_embeddings_using_vecmap.ipynb.\n",
      "Converted 99_index.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from nbdev.export import notebook2script\n",
    "notebook2script()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}