{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important: This notebook will only work with fastai-0.7.x. Do not try to run any fastai-1.x code from this path in the repository because it will load fastai-0.7.x**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%reload_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note that this notebook is most likely going to cause a stuck process. So if you are going to run it, please make sure to restart your jupyter notebook as soon as you completed running it.\n",
    "\n",
    "The bug happens inside the `fastText` library, which we have no control over. You can check the status of this issue: [here](https://github.com/fastai/fastai/issues/754) and [here](https://github.com/facebookresearch/fastText/issues/618#issuecomment-419554225).\n",
    "\n",
    "For the future, note that there're 3 separate implementations of fasttext, perhaps one of them works:\n",
    "https://github.com/facebookresearch/fastText/tree/master/python\n",
    "https://pypi.org/project/fasttext/\n",
    "https://radimrehurek.com/gensim/models/fasttext.html#module-gensim.models.fasttext"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Translation files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.text import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "French/English parallel texts from http://www.statmt.org/wmt15/translation-task.html .  It was created by Chris Callison-Burch, who crawled millions of web pages and then used *a set of simple heuristics to transform French URLs onto English URLs (i.e. replacing \"fr\" with \"en\" and about 40 other hand-written rules), and assume that these documents are translations of each other*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = Path('data/translate')\n",
    "TMP_PATH = PATH/'tmp'\n",
    "TMP_PATH.mkdir(exist_ok=True)\n",
    "fname='giga-fren.release2.fixed'\n",
    "en_fname = PATH/f'{fname}.en'\n",
    "fr_fname = PATH/f'{fname}.fr'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re_eq = re.compile('^(Wh[^?.!]+\\?)')\n",
    "re_fq = re.compile('^([^?.!]+\\?)')\n",
    "\n",
    "lines = ((re_eq.search(eq), re_fq.search(fq)) \n",
    "         for eq, fq in zip(open(en_fname, encoding='utf-8'), open(fr_fname, encoding='utf-8')))\n",
    "\n",
    "qs = [(e.group(), f.group()) for e,f in lines if e and f]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump(qs, (PATH/'fr-en-qs.pkl').open('wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qs = pickle.load((PATH/'fr-en-qs.pkl').open('rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([('What is light ?', 'Qu’est-ce que la lumière?'),\n",
       "  ('Who are we?', 'Où sommes-nous?'),\n",
       "  ('Where did we come from?', \"D'où venons-nous?\"),\n",
       "  ('What would we do without it?', 'Que ferions-nous sans elle ?'),\n",
       "  ('What is the absolute location (latitude and longitude) of Badger, Newfoundland and Labrador?',\n",
       "   'Quelle sont les coordonnées (latitude et longitude) de Badger, à Terre-Neuve-etLabrador?')],\n",
       " 52331)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qs[:5], len(qs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_qs,fr_qs = zip(*qs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_tok = Tokenizer.proc_all_mp(partition_by_cores(en_qs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fr_tok = Tokenizer.proc_all_mp(partition_by_cores(fr_qs), 'fr')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['what', 'is', 'light', '?'],\n",
       " ['qu’', 'est', '-ce', 'que', 'la', 'lumière', '?'])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "en_tok[0], fr_tok[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(23.0, 28.0)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.percentile([len(o) for o in en_tok], 90), np.percentile([len(o) for o in fr_tok], 90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "keep = np.array([len(o)<30 for o in en_tok])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_tok = np.array(en_tok)[keep]\n",
    "fr_tok = np.array(fr_tok)[keep]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pickle.dump(en_tok, (PATH/'en_tok.pkl').open('wb'))\n",
    "pickle.dump(fr_tok, (PATH/'fr_tok.pkl').open('wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_tok = pickle.load((PATH/'en_tok.pkl').open('rb'))\n",
    "fr_tok = pickle.load((PATH/'fr_tok.pkl').open('rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def toks2ids(tok,pre):\n",
    "    freq = Counter(p for o in tok for p in o)\n",
    "    itos = [o for o,c in freq.most_common(40000)]\n",
    "    itos.insert(0, '_bos_')\n",
    "    itos.insert(1, '_pad_')\n",
    "    itos.insert(2, '_eos_')\n",
    "    itos.insert(3, '_unk')\n",
    "    stoi = collections.defaultdict(lambda: 3, {v:k for k,v in enumerate(itos)})\n",
    "    ids = np.array([([stoi[o] for o in p] + [2]) for p in tok])\n",
    "    np.save(TMP_PATH/f'{pre}_ids.npy', ids)\n",
    "    pickle.dump(itos, open(TMP_PATH/f'{pre}_itos.pkl', 'wb'))\n",
    "    return ids,itos,stoi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_ids,en_itos,en_stoi = toks2ids(en_tok,'en')\n",
    "fr_ids,fr_itos,fr_stoi = toks2ids(fr_tok,'fr')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_ids(pre):\n",
    "    ids = np.load(TMP_PATH/f'{pre}_ids.npy')\n",
    "    itos = pickle.load(open(TMP_PATH/f'{pre}_itos.pkl', 'rb'))\n",
    "    stoi = collections.defaultdict(lambda: 3, {v:k for k,v in enumerate(itos)})\n",
    "    return ids,itos,stoi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_ids,en_itos,en_stoi = load_ids('en')\n",
    "fr_ids,fr_itos,fr_stoi = load_ids('fr')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['qu’', 'est', '-ce', 'que', 'la', 'lumière', '?', '_eos_'], 17573, 24793)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[fr_itos[o] for o in fr_ids[0]], len(en_itos), len(fr_itos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Word vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "fasttext word vectors available from https://fasttext.cc/docs/en/english-vectors.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! pip install git+https://github.com/facebookresearch/fastText.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fastText as ft"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use the fastText library, you'll need to download [fasttext word vectors](https://github.com/facebookresearch/fastText/blob/master/pretrained-vectors.md) for your language (download the 'bin plus text' ones)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_vecs = ft.load_model(str((PATH/'wiki.en.bin')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fr_vecs = ft.load_model(str((PATH/'wiki.fr.bin')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_vecs(lang, ft_vecs):\n",
    "    vecd = {w:ft_vecs.get_word_vector(w) for w in ft_vecs.get_words()}\n",
    "    pickle.dump(vecd, open(PATH/f'wiki.{lang}.pkl','wb'))\n",
    "    return vecd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_vecd = get_vecs('en', en_vecs)\n",
    "fr_vecd = get_vecs('fr', fr_vecs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_vecd = pickle.load(open(PATH/'wiki.en.pkl','rb'))\n",
    "fr_vecd = pickle.load(open(PATH/'wiki.fr.pkl','rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ft_words = en_vecs.get_words(include_freq=True)\n",
    "ft_word_dict = {k:v for k,v in zip(*ft_words)}\n",
    "ft_words = sorted(ft_word_dict.keys(), key=lambda x: ft_word_dict[x])\n",
    "\n",
    "len(ft_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(300, 300)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dim_en_vec = len(en_vecd[','])\n",
    "dim_fr_vec = len(fr_vecd[','])\n",
    "dim_en_vec,dim_fr_vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0075652334, 0.29283327)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "en_vecs = np.stack(list(en_vecd.values()))\n",
    "en_vecs.mean(),en_vecs.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(29, 33)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "enlen_90 = int(np.percentile([len(o) for o in en_ids], 99))\n",
    "frlen_90 = int(np.percentile([len(o) for o in fr_ids], 97))\n",
    "enlen_90,frlen_90"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_ids_tr = np.array([o[:enlen_90] for o in en_ids])\n",
    "fr_ids_tr = np.array([o[:frlen_90] for o in fr_ids])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2SeqDataset(Dataset):\n",
    "    def __init__(self, x, y): self.x,self.y = x,y\n",
    "    def __getitem__(self, idx): return A(self.x[idx], self.y[idx])\n",
    "    def __len__(self): return len(self.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(45219, 5041)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "trn_keep = np.random.rand(len(en_ids_tr))>0.1\n",
    "en_trn,fr_trn = en_ids_tr[trn_keep],fr_ids_tr[trn_keep]\n",
    "en_val,fr_val = en_ids_tr[~trn_keep],fr_ids_tr[~trn_keep]\n",
    "len(en_trn),len(en_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trn_ds = Seq2SeqDataset(fr_trn,en_trn)\n",
    "val_ds = Seq2SeqDataset(fr_val,en_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs=125"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trn_samp = SortishSampler(en_trn, key=lambda x: len(en_trn[x]), bs=bs)\n",
    "val_samp = SortSampler(en_val, key=lambda x: len(en_val[x]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trn_dl = DataLoader(trn_ds, bs, transpose=True, transpose_y=True, num_workers=1, \n",
    "                    pad_idx=1, pre_pad=False, sampler=trn_samp)\n",
    "val_dl = DataLoader(val_ds, int(bs*1.6), transpose=True, transpose_y=True, num_workers=1, \n",
    "                    pad_idx=1, pre_pad=False, sampler=val_samp)\n",
    "md = ModelData(PATH, trn_dl, val_dl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(33, 29), (21, 7), (21, 8), (33, 13), (33, 21)]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "it = iter(trn_dl)\n",
    "its = [next(it) for i in range(5)]\n",
    "[(len(x),len(y)) for x,y in its]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_emb(vecs, itos, em_sz):\n",
    "    emb = nn.Embedding(len(itos), em_sz, padding_idx=1)\n",
    "    wgts = emb.weight.data\n",
    "    miss = []\n",
    "    for i,w in enumerate(itos):\n",
    "        try: wgts[i] = torch.from_numpy(vecs[w]*3)\n",
    "        except: miss.append(w)\n",
    "    print(len(miss),miss[5:10])\n",
    "    return emb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nh,nl = 256,2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2SeqRNN(nn.Module):\n",
    "    def __init__(self, vecs_enc, itos_enc, em_sz_enc, vecs_dec, itos_dec, em_sz_dec, nh, out_sl, nl=2):\n",
    "        super().__init__()\n",
    "        self.nl,self.nh,self.out_sl = nl,nh,out_sl\n",
    "        self.emb_enc = create_emb(vecs_enc, itos_enc, em_sz_enc)\n",
    "        self.emb_enc_drop = nn.Dropout(0.15)\n",
    "        self.gru_enc = nn.GRU(em_sz_enc, nh, num_layers=nl, dropout=0.25)\n",
    "        self.out_enc = nn.Linear(nh, em_sz_dec, bias=False)\n",
    "        \n",
    "        self.emb_dec = create_emb(vecs_dec, itos_dec, em_sz_dec)\n",
    "        self.gru_dec = nn.GRU(em_sz_dec, em_sz_dec, num_layers=nl, dropout=0.1)\n",
    "        self.out_drop = nn.Dropout(0.35)\n",
    "        self.out = nn.Linear(em_sz_dec, len(itos_dec))\n",
    "        self.out.weight.data = self.emb_dec.weight.data\n",
    "        \n",
    "    def forward(self, inp):\n",
    "        sl,bs = inp.size()\n",
    "        h = self.initHidden(bs)\n",
    "        emb = self.emb_enc_drop(self.emb_enc(inp))\n",
    "        enc_out, h = self.gru_enc(emb, h)\n",
    "        h = self.out_enc(h)\n",
    "\n",
    "        dec_inp = V(torch.zeros(bs).long())\n",
    "        res = []\n",
    "        for i in range(self.out_sl):\n",
    "            emb = self.emb_dec(dec_inp).unsqueeze(0)\n",
    "            outp, h = self.gru_dec(emb, h)\n",
    "            outp = self.out(self.out_drop(outp[0]))\n",
    "            res.append(outp)\n",
    "            dec_inp = V(outp.data.max(1)[1])\n",
    "            if (dec_inp==1).all(): break\n",
    "        return torch.stack(res)\n",
    "    \n",
    "    def initHidden(self, bs): return V(torch.zeros(self.nl, bs, self.nh))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seq2seq_loss(input, target):\n",
    "    sl,bs = target.size()\n",
    "    sl_in,bs_in,nc = input.size()\n",
    "    if sl>sl_in: input = F.pad(input, (0,0,0,0,0,sl-sl_in))\n",
    "    input = input[:sl]\n",
    "    return F.cross_entropy(input.view(-1,nc), target.view(-1))#, ignore_index=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt_fn = partial(optim.Adam, betas=(0.8, 0.99))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3097 ['l’', \"d'\", 't_up', 'd’', \"qu'\"]\n",
      "1285 [\"'s\", '’s', \"n't\", 'n’t', ':']\n"
     ]
    }
   ],
   "source": [
    "rnn = Seq2SeqRNN(fr_vecd, fr_itos, dim_fr_vec, en_vecd, en_itos, dim_en_vec, nh, enlen_90)\n",
    "learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)\n",
    "learn.crit = seq2seq_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "93120e170d0f45dbbc0e41fc792709dc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "A Jupyter Widget"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 16%|█▋        | 62/377 [00:09<00:47,  6.60it/s, loss=11.4] \n",
      " 17%|█▋        | 64/377 [00:09<00:47,  6.62it/s, loss=11.2]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-242:\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/jhoward/anaconda3/lib/python3.6/threading.py\", line 916, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"/home/jhoward/anaconda3/lib/python3.6/site-packages/tqdm/_tqdm.py\", line 144, in run\n",
      "    for instance in self.tqdm_cls._instances:\n",
      "  File \"/home/jhoward/anaconda3/lib/python3.6/_weakrefset.py\", line 60, in __iter__\n",
      "    for itemref in self.data:\n",
      "RuntimeError: Set changed size during iteration\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 70%|███████   | 265/377 [00:39<00:16,  6.64it/s, loss=30]  \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f302684c6d8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.lr_find()\n",
    "learn.sched.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr=3e-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "26801451fa214563aaef1d748a892f20",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "A Jupyter Widget"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  6%|▌         | 22/377 [00:04<01:06,  5.34it/s, loss=10.8]   \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-20:\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/jhoward/anaconda3/lib/python3.6/threading.py\", line 916, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"/home/jhoward/anaconda3/lib/python3.6/site-packages/tqdm/_tqdm.py\", line 144, in run\n",
      "    for instance in self.tqdm_cls._instances:\n",
      "  File \"/home/jhoward/anaconda3/lib/python3.6/_weakrefset.py\", line 60, in __iter__\n",
      "    for itemref in self.data:\n",
      "RuntimeError: Set changed size during iteration\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss                              \n",
      "    0      5.48978    5.462648  \n",
      "    1      4.616437   4.770539                              \n",
      "    2      4.345884   4.37726                               \n",
      "    3      3.857125   4.136014                              \n",
      "    4      3.612306   3.941867                              \n",
      "    5      3.375064   3.839872                              \n",
      "    6      3.383987   3.708972                              \n",
      "    7      3.224772   3.664173                              \n",
      "    8      3.238523   3.604765                              \n",
      "    9      2.962041   3.587814                              \n",
      "    10     2.96163    3.574888                              \n",
      "    11     2.866477   3.581224                              \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3.5812237]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.fit(lr, 1, cycle_len=12, use_clr=(20,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('initial')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load('initial')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "quels facteurs pourraient influer sur le choix de leur emplacement ? _eos_\n",
      "what factors influencetheir location ? _eos_\n",
      "what factors might might influence on the their ? ? _eos_\n",
      "\n",
      "qu’ est -ce qui ne peut pas changer ? _eos_\n",
      "what can not change ? _eos_\n",
      "what not change change ? _eos_\n",
      "\n",
      "que faites - vous ? _eos_\n",
      "what do you do ? _eos_\n",
      "what do you do ? _eos_\n",
      "\n",
      "qui réglemente les pylônes d' antennes ? _eos_\n",
      "who regulates antenna towers ? _eos_\n",
      "who regulates the doors doors ? _eos_\n",
      "\n",
      "où sont - ils situés ? _eos_\n",
      "where are they located ? _eos_\n",
      "where are the located ? _eos_\n",
      "\n",
      "quelles sont leurs compétences ? _eos_\n",
      "what are their qualifications ? _eos_\n",
      "what are their skills ? _eos_\n",
      "\n",
      "qui est victime de harcèlement sexuel ? _eos_\n",
      "who experiences sexual harassment ? _eos_\n",
      "who is victim sexual sexual ? ? _eos_\n",
      "\n",
      "quelles sont les personnes qui visitent les communautés autochtones ? _eos_\n",
      "who visits indigenous communities ? _eos_\n",
      "who are people people aboriginal aboriginal ? _eos_\n",
      "\n",
      "pourquoi ces trois points en particulier ? _eos_\n",
      "why these specific three ? _eos_\n",
      "why are these two different ? ? _eos_\n",
      "\n",
      "pourquoi ou pourquoi pas ? _eos_\n",
      "why or why not ? _eos_\n",
      "why or why not _eos_\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x,y = next(iter(val_dl))\n",
    "probs = learn.model(V(x))\n",
    "preds = to_np(probs.max(2)[1])\n",
    "\n",
    "for i in range(180,190):\n",
    "    print(' '.join([fr_itos[o] for o in x[:,i] if o != 1]))\n",
    "    print(' '.join([en_itos[o] for o in y[:,i] if o != 1]))\n",
    "    print(' '.join([en_itos[o] for o in preds[:,i] if o!=1]))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bidir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2SeqRNN_Bidir(nn.Module):\n",
    "    def __init__(self, vecs_enc, itos_enc, em_sz_enc, vecs_dec, itos_dec, em_sz_dec, nh, out_sl, nl=2):\n",
    "        super().__init__()\n",
    "        self.emb_enc = create_emb(vecs_enc, itos_enc, em_sz_enc)\n",
    "        self.nl,self.nh,self.out_sl = nl,nh,out_sl\n",
    "        self.gru_enc = nn.GRU(em_sz_enc, nh, num_layers=nl, dropout=0.25, bidirectional=True)\n",
    "        self.out_enc = nn.Linear(nh*2, em_sz_dec, bias=False)\n",
    "        self.drop_enc = nn.Dropout(0.05)\n",
    "        self.emb_dec = create_emb(vecs_dec, itos_dec, em_sz_dec)\n",
    "        self.gru_dec = nn.GRU(em_sz_dec, em_sz_dec, num_layers=nl, dropout=0.1)\n",
    "        self.emb_enc_drop = nn.Dropout(0.15)\n",
    "        self.out_drop = nn.Dropout(0.35)\n",
    "        self.out = nn.Linear(em_sz_dec, len(itos_dec))\n",
    "        self.out.weight.data = self.emb_dec.weight.data\n",
    "        \n",
    "    def forward(self, inp):\n",
    "        sl,bs = inp.size()\n",
    "        h = self.initHidden(bs)\n",
    "        emb = self.emb_enc_drop(self.emb_enc(inp))\n",
    "        enc_out, h = self.gru_enc(emb, h)\n",
    "        h = h.view(2,2,bs,-1).permute(0,2,1,3).contiguous().view(2,bs,-1)\n",
    "        h = self.out_enc(self.drop_enc(h))\n",
    "\n",
    "        dec_inp = V(torch.zeros(bs).long())\n",
    "        res = []\n",
    "        for i in range(self.out_sl):\n",
    "            emb = self.emb_dec(dec_inp).unsqueeze(0)\n",
    "            outp, h = self.gru_dec(emb, h)\n",
    "            outp = self.out(self.out_drop(outp[0]))\n",
    "            res.append(outp)\n",
    "            dec_inp = V(outp.data.max(1)[1])\n",
    "            if (dec_inp==1).all(): break\n",
    "        return torch.stack(res)\n",
    "    \n",
    "    def initHidden(self, bs): return V(torch.zeros(self.nl*2, bs, self.nh))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnn = Seq2SeqRNN_Bidir(fr_vecd, fr_itos, dim_fr_vec, en_vecd, en_itos, dim_en_vec, nh, enlen_90)\n",
    "learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)\n",
    "learn.crit = seq2seq_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "311a44c5e45644b49728f8a4105e89ed",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "A Jupyter Widget"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss                              \n",
      "    0      4.896942   4.761351  \n",
      "    1      4.323335   4.260878                              \n",
      "    2      3.962747   4.06161                               \n",
      "    3      3.596254   3.940087                              \n",
      "    4      3.432788   3.944787                              \n",
      "    5      3.310895   3.686629                              \n",
      "    6      3.454976   3.638168                              \n",
      "    7      3.093827   3.588456                              \n",
      "    8      3.257495   3.610536                              \n",
      "    9      3.033345   3.540344                              \n",
      "    10     2.967694   3.516766                              \n",
      "    11     2.718945   3.513977                              \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3.5139771]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.fit(lr, 1, cycle_len=12, use_clr=(20,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('bidir')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Teacher forcing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2SeqStepper(Stepper):\n",
    "    def step(self, xs, y, epoch):\n",
    "        self.m.pr_force = (10-epoch)*0.1 if epoch<10 else 0\n",
    "        xtra = []\n",
    "        output = self.m(*xs, y)\n",
    "        if isinstance(output,tuple): output,*xtra = output\n",
    "        self.opt.zero_grad()\n",
    "        loss = raw_loss = self.crit(output, y)\n",
    "        if self.reg_fn: loss = self.reg_fn(output, xtra, raw_loss)\n",
    "        loss.backward()\n",
    "        if self.clip:   # Gradient clipping\n",
    "            nn.utils.clip_grad_norm(trainable_params_(self.m), self.clip)\n",
    "        self.opt.step()\n",
    "        return raw_loss.data[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2SeqRNN_TeacherForcing(nn.Module):\n",
    "    def __init__(self, vecs_enc, itos_enc, em_sz_enc, vecs_dec, itos_dec, em_sz_dec, nh, out_sl, nl=2):\n",
    "        super().__init__()\n",
    "        self.emb_enc = create_emb(vecs_enc, itos_enc, em_sz_enc)\n",
    "        self.nl,self.nh,self.out_sl = nl,nh,out_sl\n",
    "        self.gru_enc = nn.GRU(em_sz_enc, nh, num_layers=nl, dropout=0.25)\n",
    "        self.out_enc = nn.Linear(nh, em_sz_dec, bias=False)\n",
    "        self.emb_dec = create_emb(vecs_dec, itos_dec, em_sz_dec)\n",
    "        self.gru_dec = nn.GRU(em_sz_dec, em_sz_dec, num_layers=nl, dropout=0.1)\n",
    "        self.emb_enc_drop = nn.Dropout(0.15)\n",
    "        self.out_drop = nn.Dropout(0.35)\n",
    "        self.out = nn.Linear(em_sz_dec, len(itos_dec))\n",
    "        self.out.weight.data = self.emb_dec.weight.data\n",
    "        self.pr_force = 1.\n",
    "        \n",
    "    def forward(self, inp, y=None):\n",
    "        sl,bs = inp.size()\n",
    "        h = self.initHidden(bs)\n",
    "        emb = self.emb_enc_drop(self.emb_enc(inp))\n",
    "        enc_out, h = self.gru_enc(emb, h)\n",
    "        h = self.out_enc(h)\n",
    "\n",
    "        dec_inp = V(torch.zeros(bs).long())\n",
    "        res = []\n",
    "        for i in range(self.out_sl):\n",
    "            emb = self.emb_dec(dec_inp).unsqueeze(0)\n",
    "            outp, h = self.gru_dec(emb, h)\n",
    "            outp = self.out(self.out_drop(outp[0]))\n",
    "            res.append(outp)\n",
    "            dec_inp = V(outp.data.max(1)[1])\n",
    "            if (dec_inp==1).all(): break\n",
    "            if (y is not None) and (random.random()<self.pr_force):\n",
    "                if i>=len(y): break\n",
    "                dec_inp = y[i]\n",
    "        return torch.stack(res)\n",
    "    \n",
    "    def initHidden(self, bs): return V(torch.zeros(self.nl, bs, self.nh))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnn = Seq2SeqRNN_TeacherForcing(fr_vecd, fr_itos, dim_fr_vec, en_vecd, en_itos, dim_en_vec, nh, enlen_90)\n",
    "learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)\n",
    "learn.crit = seq2seq_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fdd91dafb9c94ffc8eda007de8d0dabd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "A Jupyter Widget"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss                              \n",
      "    0      4.460622   12.661013 \n",
      "    1      3.468132   7.138729                              \n",
      "    2      3.235244   6.202878                              \n",
      "    3      3.101616   5.454283                              \n",
      "    4      3.135989   4.823736                              \n",
      "    5      2.980696   4.933402                              \n",
      "    6      2.91562    4.287475                              \n",
      "    7      3.032661   3.975346                              \n",
      "    8      3.103834   3.790773                              \n",
      "    9      3.121457   3.578682                              \n",
      "    10     2.917534   3.532427                              \n",
      "    11     3.326946   3.490643                              \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3.490643]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.fit(lr, 1, cycle_len=12, use_clr=(20,10), stepper=Seq2SeqStepper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('forcing')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Attentional model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rand_t(*sz): return torch.randn(sz)/math.sqrt(sz[0])\n",
    "def rand_p(*sz): return nn.Parameter(rand_t(*sz))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2SeqAttnRNN(nn.Module):\n",
    "    def __init__(self, vecs_enc, itos_enc, em_sz_enc, vecs_dec, itos_dec, em_sz_dec, nh, out_sl, nl=2):\n",
    "        super().__init__()\n",
    "        self.emb_enc = create_emb(vecs_enc, itos_enc, em_sz_enc)\n",
    "        self.nl,self.nh,self.out_sl = nl,nh,out_sl\n",
    "        self.gru_enc = nn.GRU(em_sz_enc, nh, num_layers=nl, dropout=0.25)\n",
    "        self.out_enc = nn.Linear(nh, em_sz_dec, bias=False)\n",
    "        self.emb_dec = create_emb(vecs_dec, itos_dec, em_sz_dec)\n",
    "        self.gru_dec = nn.GRU(em_sz_dec, em_sz_dec, num_layers=nl, dropout=0.1)\n",
    "        self.emb_enc_drop = nn.Dropout(0.15)\n",
    "        self.out_drop = nn.Dropout(0.35)\n",
    "        self.out = nn.Linear(em_sz_dec, len(itos_dec))\n",
    "        self.out.weight.data = self.emb_dec.weight.data\n",
    "\n",
    "        self.W1 = rand_p(nh, em_sz_dec)\n",
    "        self.l2 = nn.Linear(em_sz_dec, em_sz_dec)\n",
    "        self.l3 = nn.Linear(em_sz_dec+nh, em_sz_dec)\n",
    "        self.V = rand_p(em_sz_dec)\n",
    "\n",
    "    def forward(self, inp, y=None, ret_attn=False):\n",
    "        sl,bs = inp.size()\n",
    "        h = self.initHidden(bs)\n",
    "        emb = self.emb_enc_drop(self.emb_enc(inp))\n",
    "        enc_out, h = self.gru_enc(emb, h)\n",
    "        h = self.out_enc(h)\n",
    "\n",
    "        dec_inp = V(torch.zeros(bs).long())\n",
    "        res,attns = [],[]\n",
    "        w1e = enc_out @ self.W1\n",
    "        for i in range(self.out_sl):\n",
    "            w2h = self.l2(h[-1])\n",
    "            u = F.tanh(w1e + w2h)\n",
    "            a = F.softmax(u @ self.V, 0)\n",
    "            attns.append(a)\n",
    "            Xa = (a.unsqueeze(2) * enc_out).sum(0)\n",
    "            emb = self.emb_dec(dec_inp)\n",
    "            wgt_enc = self.l3(torch.cat([emb, Xa], 1))\n",
    "            \n",
    "            outp, h = self.gru_dec(wgt_enc.unsqueeze(0), h)\n",
    "            outp = self.out(self.out_drop(outp[0]))\n",
    "            res.append(outp)\n",
    "            dec_inp = V(outp.data.max(1)[1])\n",
    "            if (dec_inp==1).all(): break\n",
    "            if (y is not None) and (random.random()<self.pr_force):\n",
    "                if i>=len(y): break\n",
    "                dec_inp = y[i]\n",
    "\n",
    "        res = torch.stack(res)\n",
    "        if ret_attn: res = res,torch.stack(attns)\n",
    "        return res\n",
    "\n",
    "    def initHidden(self, bs): return V(torch.zeros(self.nl, bs, self.nh))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnn = Seq2SeqAttnRNN(fr_vecd, fr_itos, dim_fr_vec, en_vecd, en_itos, dim_en_vec, nh, enlen_90)\n",
    "learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)\n",
    "learn.crit = seq2seq_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr=2e-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5eeb660d3184439191ed4390415a1241",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "A Jupyter Widget"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss                              \n",
      "    0      3.882168   11.125291 \n",
      "    1      3.599992   6.667136                              \n",
      "    2      3.236066   5.552943                              \n",
      "    3      3.050283   4.919096                              \n",
      "    4      2.99024    4.500383                              \n",
      "    5      3.07999    4.000295                              \n",
      "    6      2.891087   4.024115                              \n",
      "    7      2.854725   3.673913                              \n",
      "    8      2.979285   3.590668                              \n",
      "    9      3.109851   3.459867                              \n",
      "    10     2.92878    3.517598                              \n",
      "    11     2.778292   3.390253                              \n",
      "    12     2.795427   3.388423                              \n",
      "    13     2.809757   3.353334                              \n",
      "    14     2.6723     3.368584                              \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3.3685837]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.fit(lr, 1, cycle_len=15, use_clr=(20,10), stepper=Seq2SeqStepper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('attn')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load('attn')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = next(iter(val_dl))\n",
    "probs,attns = learn.model(V(x),ret_attn=True)\n",
    "preds = to_np(probs.max(2)[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "quels facteurs pourraient influer sur le choix de leur emplacement ? _eos_\n",
      "what factors influencetheir location ? _eos_\n",
      "what factors might influence the their their their ? _eos_\n",
      "\n",
      "qu’ est -ce qui ne peut pas changer ? _eos_\n",
      "what can not change ? _eos_\n",
      "what can not change change ? _eos_\n",
      "\n",
      "que faites - vous ? _eos_\n",
      "what do you do ? _eos_\n",
      "what do you do ? _eos_\n",
      "\n",
      "qui réglemente les pylônes d' antennes ? _eos_\n",
      "who regulates antenna towers ? _eos_\n",
      "who regulates the lights ? ? _eos_\n",
      "\n",
      "où sont - ils situés ? _eos_\n",
      "where are they located ? _eos_\n",
      "where are they located ? _eos_\n",
      "\n",
      "quelles sont leurs compétences ? _eos_\n",
      "what are their qualifications ? _eos_\n",
      "what are their skills ? _eos_\n",
      "\n",
      "qui est victime de harcèlement sexuel ? _eos_\n",
      "who experiences sexual harassment ? _eos_\n",
      "who is victim sexual sexual ? _eos_\n",
      "\n",
      "quelles sont les personnes qui visitent les communautés autochtones ? _eos_\n",
      "who visits indigenous communities ? _eos_\n",
      "who is people people aboriginal people ? _eos_\n",
      "\n",
      "pourquoi ces trois points en particulier ? _eos_\n",
      "why these specific three ? _eos_\n",
      "why are these three three ? ? _eos_\n",
      "\n",
      "pourquoi ou pourquoi pas ? _eos_\n",
      "why or why not ? _eos_\n",
      "why or why not ? _eos_\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(180,190):\n",
    "    print(' '.join([fr_itos[o] for o in x[:,i] if o != 1]))\n",
    "    print(' '.join([en_itos[o] for o in y[:,i] if o != 1]))\n",
    "    print(' '.join([en_itos[o] for o in preds[:,i] if o!=1]))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "attn = to_np(attns[...,180])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f27d3ffeba8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(3, 3, figsize=(15, 10))\n",
    "for i,ax in enumerate(axes.flat):\n",
    "    ax.plot(attn[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## All"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2SeqRNN_All(nn.Module):\n",
    "    def __init__(self, vecs_enc, itos_enc, em_sz_enc, vecs_dec, itos_dec, em_sz_dec, nh, out_sl, nl=2):\n",
    "        super().__init__()\n",
    "        self.emb_enc = create_emb(vecs_enc, itos_enc, em_sz_enc)\n",
    "        self.nl,self.nh,self.out_sl = nl,nh,out_sl\n",
    "        self.gru_enc = nn.GRU(em_sz_enc, nh, num_layers=nl, dropout=0.25, bidirectional=True)\n",
    "        self.out_enc = nn.Linear(nh*2, em_sz_dec, bias=False)\n",
    "        self.drop_enc = nn.Dropout(0.25)\n",
    "        self.emb_dec = create_emb(vecs_dec, itos_dec, em_sz_dec)\n",
    "        self.gru_dec = nn.GRU(em_sz_dec, em_sz_dec, num_layers=nl, dropout=0.1)\n",
    "        self.emb_enc_drop = nn.Dropout(0.15)\n",
    "        self.out_drop = nn.Dropout(0.35)\n",
    "        self.out = nn.Linear(em_sz_dec, len(itos_dec))\n",
    "        self.out.weight.data = self.emb_dec.weight.data\n",
    "\n",
    "        self.W1 = rand_p(nh*2, em_sz_dec)\n",
    "        self.l2 = nn.Linear(em_sz_dec, em_sz_dec)\n",
    "        self.l3 = nn.Linear(em_sz_dec+nh*2, em_sz_dec)\n",
    "        self.V = rand_p(em_sz_dec)\n",
    "\n",
    "    def forward(self, inp, y=None):\n",
    "        sl,bs = inp.size()\n",
    "        h = self.initHidden(bs)\n",
    "        emb = self.emb_enc_drop(self.emb_enc(inp))\n",
    "        enc_out, h = self.gru_enc(emb, h)\n",
    "        h = h.view(2,2,bs,-1).permute(0,2,1,3).contiguous().view(2,bs,-1)\n",
    "        h = self.out_enc(self.drop_enc(h))\n",
    "\n",
    "        dec_inp = V(torch.zeros(bs).long())\n",
    "        res,attns = [],[]\n",
    "        w1e = enc_out @ self.W1\n",
    "        for i in range(self.out_sl):\n",
    "            w2h = self.l2(h[-1])\n",
    "            u = F.tanh(w1e + w2h)\n",
    "            a = F.softmax(u @ self.V, 0)\n",
    "            attns.append(a)\n",
    "            Xa = (a.unsqueeze(2) * enc_out).sum(0)\n",
    "            emb = self.emb_dec(dec_inp)\n",
    "            wgt_enc = self.l3(torch.cat([emb, Xa], 1))\n",
    "            \n",
    "            outp, h = self.gru_dec(wgt_enc.unsqueeze(0), h)\n",
    "            outp = self.out(self.out_drop(outp[0]))\n",
    "            res.append(outp)\n",
    "            dec_inp = V(outp.data.max(1)[1])\n",
    "            if (dec_inp==1).all(): break\n",
    "            if (y is not None) and (random.random()<self.pr_force):\n",
    "                if i>=len(y): break\n",
    "                dec_inp = y[i]\n",
    "        return torch.stack(res)\n",
    "\n",
    "    def initHidden(self, bs): return V(torch.zeros(self.nl*2, bs, self.nh))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnn = Seq2SeqRNN_All(fr_vecd, fr_itos, dim_fr_vec, en_vecd, en_itos, dim_en_vec, nh, enlen_90)\n",
    "learn = RNN_Learner(md, SingleModel(to_gpu(rnn)), opt_fn=opt_fn)\n",
    "learn.crit = seq2seq_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cec8c2bb6118434b8758dd816b504c49",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "A Jupyter Widget"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss                              \n",
      "    0      3.817306   7.527982  \n",
      "    1      3.239813   5.82099                               \n",
      "    2      3.06717    5.437195                              \n",
      "    3      3.077923   4.718295                              \n",
      "    4      2.952973   4.337892                              \n",
      "    5      3.018182   3.994012                              \n",
      "    6      2.761607   3.777056                              \n",
      "    7      2.913683   3.595531                              \n",
      "    8      2.91521    3.46984                               \n",
      "    9      2.921533   3.370839                              \n",
      "    10     2.913826   3.336167                              \n",
      "    11     2.746896   3.37274                               \n",
      "    12     2.695839   3.332427                              \n",
      "    13     2.531583   3.341861                              \n",
      "    14     2.524642   3.324184                              \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3.3241842]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.fit(lr, 1, cycle_len=15, use_clr=(20,10), stepper=Seq2SeqStepper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "quels facteurs pourraient influer sur le choix de leur emplacement ? _eos_\n",
      "what factors influencetheir location ? _eos_\n",
      "what factors might affect the choice of their ? ? _eos_\n",
      "\n",
      "qu’ est -ce qui ne peut pas changer ? _eos_\n",
      "what can not change ? _eos_\n",
      "what can not change change _eos_\n",
      "\n",
      "que faites - vous ? _eos_\n",
      "what do you do ? _eos_\n",
      "what do you do ? _eos_\n",
      "\n",
      "qui réglemente les pylônes d' antennes ? _eos_\n",
      "who regulates antenna towers ? _eos_\n",
      "who regulates the antenna ? ? _eos_\n",
      "\n",
      "où sont - ils situés ? _eos_\n",
      "where are they located ? _eos_\n",
      "where are they located ? _eos_\n",
      "\n",
      "quelles sont leurs compétences ? _eos_\n",
      "what are their qualifications ? _eos_\n",
      "what are their skills ? _eos_\n",
      "\n",
      "qui est victime de harcèlement sexuel ? _eos_\n",
      "who experiences sexual harassment ? _eos_\n",
      "who is victim harassment harassment ? _eos_\n",
      "\n",
      "quelles sont les personnes qui visitent les communautés autochtones ? _eos_\n",
      "who visits indigenous communities ? _eos_\n",
      "who are the people people ? ?\n",
      "\n",
      "pourquoi ces trois points en particulier ? _eos_\n",
      "why these specific three ? _eos_\n",
      "why are these three specific ? _eos_\n",
      "\n",
      "pourquoi ou pourquoi pas ? _eos_\n",
      "why or why not ? _eos_\n",
      "why or why not ? _eos_\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x,y = next(iter(val_dl))\n",
    "probs = learn.model(V(x))\n",
    "preds = to_np(probs.max(2)[1])\n",
    "\n",
    "for i in range(180,190):\n",
    "    print(' '.join([fr_itos[o] for o in x[:,i] if o != 1]))\n",
    "    print(' '.join([en_itos[o] for o in y[:,i] if o != 1]))\n",
    "    print(' '.join([en_itos[o] for o in preds[:,i] if o!=1]))\n",
    "    print()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}