att-mt.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import unicode_literals, print_function, division\n",
    "from io import open\n",
    "import unicodedata\n",
    "import string\n",
    "import re\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch import optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "SOS_token = 0\n",
    "EOS_token = 1\n",
    "\n",
    "\n",
    "class Lang:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.word2index = {}\n",
    "        self.word2count = {}\n",
    "        self.index2word = {0: \"SOS\", 1: \"EOS\"}\n",
    "        self.n_words = 2  # Count SOS and EOS\n",
    "\n",
    "    def addSentence(self, sentence):\n",
    "        for word in sentence.split(' '):\n",
    "            self.addWord(word)\n",
    "\n",
    "    def addWord(self, word):\n",
    "        if word not in self.word2index:\n",
    "            self.word2index[word] = self.n_words\n",
    "            self.word2count[word] = 1\n",
    "            self.index2word[self.n_words] = word\n",
    "            self.n_words += 1\n",
    "        else:\n",
    "            self.word2count[word] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unicodeToAscii(s):\n",
    "    return ''.join(\n",
    "        c for c in unicodedata.normalize('NFD', s)\n",
    "        if unicodedata.category(c) != 'Mn'\n",
    "    )\n",
    "\n",
    "# Lowercase, trim, and remove special characters\n",
    "def normalizeString(s):\n",
    "    s = unicodeToAscii(s.lower().strip())\n",
    "    s = re.sub(r\"([.!?])\", r\" \\1\", s)\n",
    "    s = re.sub(r\"[^a-zA-Z.!?]+\", r\" \", s)\n",
    "    s = re.findall(r'\\w+', s)\n",
    "    return \" \".join(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readLangs(lang1, lang2, reverse=False):\n",
    "\n",
    "    path = \"C:/Users/siddp/OneDrive/Desktop/project/encoder-decoder-models\"\n",
    "    lines = open(path + '/data/%s-%s.txt' % (lang1, lang2), encoding='utf-8').read().strip().split('\\n')\n",
    "    # lang1 is english and lang2 is french\n",
    "\n",
    "    # Split every line into pairs and normalize\n",
    "    pairs = [[normalizeString(s) for s in l.split('\\t')] for l in lines]\n",
    "\n",
    "    # Reverse pairs, make Lang instances\n",
    "    if reverse:\n",
    "        pairs = [list(reversed(p)) for p in pairs]\n",
    "        input_lang = Lang(lang2)\n",
    "        output_lang = Lang(lang1)\n",
    "    else:\n",
    "        input_lang = Lang(lang1)\n",
    "        output_lang = Lang(lang2)\n",
    "\n",
    "    return input_lang, output_lang, pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_LENGTH = 15\n",
    "\n",
    "\n",
    "def filterPair(p):\n",
    "    return len(p[0].split(' ')) < MAX_LENGTH and len(p[1].split(' ')) < MAX_LENGTH\n",
    "\n",
    "\n",
    "def filterPairs(pairs):\n",
    "    return [pair for pair in pairs if filterPair(pair)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read 135842 sentence pairs\n",
      "Trimmed to 132157 sentence pairs\n",
      "Counted words:\n",
      "fra 20650\n",
      "eng 12543\n",
      "['il y a quelque chose qui cloche', 'that doesn t seem right']\n"
     ]
    }
   ],
   "source": [
    "def prepareData(lang1, lang2, reverse=False):\n",
    "    input_lang, output_lang, pairs = readLangs(lang1, lang2, reverse)\n",
    "    print(\"Read %s sentence pairs\" % len(pairs))\n",
    "    pairs = filterPairs(pairs)\n",
    "    print(\"Trimmed to %s sentence pairs\" % len(pairs))\n",
    "    for pair in pairs:\n",
    "        input_lang.addSentence(pair[0])\n",
    "        output_lang.addSentence(pair[1])\n",
    "    print(\"Counted words:\")\n",
    "    print(input_lang.name, input_lang.n_words)\n",
    "    print(output_lang.name, output_lang.n_words)\n",
    "    return input_lang, output_lang, pairs\n",
    "\n",
    "\n",
    "input_lang, output_lang, pairs = prepareData('eng', 'fra', True)\n",
    "print(random.choice(pairs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n",
      "2341\n",
      "15\n",
      "5441\n"
     ]
    }
   ],
   "source": [
    "print(input_lang.word2count['respecte'])\n",
    "print(input_lang.word2index['respecte'])\n",
    "print(output_lang.word2count['respected'])\n",
    "print(output_lang.word2index['respected'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def indexesFromSentence(lang, sentence):\n",
    "    return [lang.word2index[word] for word in sentence.split(' ')]\n",
    "\n",
    "\n",
    "def tensorFromSentence(lang, sentence):\n",
    "    indexes = indexesFromSentence(lang, sentence)\n",
    "    indexes.append(EOS_token)\n",
    "    return torch.tensor(indexes, dtype=torch.long, device=device).view(-1, 1)\n",
    "\n",
    "\n",
    "def tensorsFromPair(pair):\n",
    "    input_tensor = tensorFromSentence(input_lang, pair[0])\n",
    "    target_tensor = tensorFromSentence(output_lang, pair[1])\n",
    "    return (input_tensor, target_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Encoder-Decoder Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EncoderRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super(EncoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.embedding = nn.Embedding(input_size, hidden_size)\n",
    "        self.gru = nn.GRU(hidden_size, hidden_size)\n",
    "\n",
    "    def forward(self, input, hidden):\n",
    "        # unsqueeze can be used\n",
    "        embedded = self.embedding(input).view(1, 1, -1)\n",
    "        output, hidden = self.gru(embedded, hidden)\n",
    "        return output, hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 1, 128])\n"
     ]
    }
   ],
   "source": [
    "# Testing encoder model\n",
    "testing_model = EncoderRNN(input_size=input_lang.n_words, hidden_size=128).to(device)\n",
    "input = tensorFromSentence(input_lang, random.choice(pairs)[0])\n",
    "hidden_size = 128\n",
    "hidden = torch.zeros(1, 1, hidden_size, device=device)\n",
    "# print(input.get_device())\n",
    "output, hidden = testing_model(input[0], hidden)\n",
    "print(output.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 128])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output[0].size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecoderRNN(nn.Module):\n",
    "    def __init__(self, hidden_size, output_size):\n",
    "        super(DecoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.embedding = nn.Embedding(output_size, hidden_size)\n",
    "        self.gru = nn.GRU(hidden_size, hidden_size)\n",
    "        self.out = nn.Linear(hidden_size, output_size)\n",
    "        self.softmax = nn.LogSoftmax(dim=1)\n",
    "\n",
    "    def forward(self, input, hidden):\n",
    "        # hidden = torch.zeros(1, 1, self.hidden_size, device=device)\n",
    "        output = self.embedding(input).view(1, 1, -1)\n",
    "        output = F.relu(output)\n",
    "        output, hidden = self.gru(output, hidden)\n",
    "        output = self.softmax(self.out(output[0]))\n",
    "        return output, hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 12543])\n"
     ]
    }
   ],
   "source": [
    "# Testing decoder model\n",
    "testing_model = DecoderRNN(hidden_size=128, output_size=output_lang.n_words).to(device)\n",
    "input = tensorFromSentence(output_lang, random.choice(pairs)[1])\n",
    "# print(input.get_device())\n",
    "hidden_size=128\n",
    "hidden = torch.zeros(1, 1, hidden_size, device=device)\n",
    "output, hidden = testing_model(input[0], hidden)\n",
    "print(output.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([7064], device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "print(output.argmax(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_forcing_ratio = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In the simplest seq2seq decoder we use only last output of the encoder. This last output is sometimes called the context vector as it encodes context \n",
    "# from the entire sequence. This context vector is used as the initial hidden state of the decoder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length=MAX_LENGTH):\n",
    "\n",
    "    encoder_optimizer.zero_grad()\n",
    "    decoder_optimizer.zero_grad()\n",
    "\n",
    "    input_length = input_tensor.size(0)\n",
    "    # length of input sentence\n",
    "    target_length = target_tensor.size(0)\n",
    "    # length of target sentence for training\n",
    "\n",
    "    loss = 0\n",
    "    hidden_size = 128\n",
    "    encoder_hidden = torch.zeros(1, 1, hidden_size, device=device)\n",
    "\n",
    "    for ei in range(input_length):\n",
    "        # word by word training in GRU\n",
    "        encoder_output, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)\n",
    "\n",
    "    decoder_input = torch.tensor([[SOS_token]], device=device)\n",
    "\n",
    "    # Initialized by encoder hidden state, not random initialization.\n",
    "    decoder_hidden = encoder_hidden\n",
    "\n",
    "    use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False\n",
    "\n",
    "    if use_teacher_forcing:\n",
    "        # Teacher forcing: Feed the target as the next input\n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden)\n",
    "            loss += criterion(decoder_output, target_tensor[di])\n",
    "            # loss += criterion(decoder_output.argmax(1), target_tensor[di])\n",
    "            decoder_input = target_tensor[di]  # Teacher forcing\n",
    "\n",
    "    else:\n",
    "        # Without teacher forcing: use its own predictions as the next input\n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden)\n",
    "            # topv, topi = decoder_output.topk(1)\n",
    "            best_guess = decoder_output.argmax(1)\n",
    "            # decoder_input = topi.squeeze().detach()  # detach from history as input\n",
    "            decoder_input = best_guess\n",
    "\n",
    "            loss += criterion(decoder_output, target_tensor[di])\n",
    "            # loss += criterion(best_guess, target_tensor[di])\n",
    "            if decoder_input.item() == EOS_token:\n",
    "                break\n",
    "\n",
    "    loss.backward()\n",
    "\n",
    "    encoder_optimizer.step()\n",
    "    decoder_optimizer.step()\n",
    "\n",
    "    return loss.item() / target_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.01):\n",
    "    plot_losses = []\n",
    "    print_loss_total = 0  # Reset every print_every\n",
    "    plot_loss_total = 0  # Reset every plot_every\n",
    "\n",
    "    encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)\n",
    "    decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)\n",
    "    training_pairs = [tensorsFromPair(random.choice(pairs))\n",
    "                      for i in range(n_iters)]\n",
    "    criterion = nn.NLLLoss()\n",
    "\n",
    "    for iter in range(1, n_iters + 1):\n",
    "        training_pair = training_pairs[iter - 1]\n",
    "        input_tensor = training_pair[0]\n",
    "        target_tensor = training_pair[1]\n",
    "\n",
    "        loss = train(input_tensor, target_tensor, encoder,\n",
    "                     decoder, encoder_optimizer, decoder_optimizer, criterion)\n",
    "        print_loss_total += loss\n",
    "        plot_loss_total += loss\n",
    "\n",
    "        if iter % print_every == 0:\n",
    "            print_loss_avg = print_loss_total / print_every\n",
    "            print_loss_total = 0\n",
    "            print(f\"iteration: {iter} and loss: {print_loss_avg}\")                             \n",
    "\n",
    "        if iter % plot_every == 0:\n",
    "            plot_loss_avg = plot_loss_total / plot_every\n",
    "            plot_losses.append(plot_loss_avg)\n",
    "            plot_loss_total = 0\n",
    "\n",
    "    plt.figure()\n",
    "    fig, ax = plt.subplots()\n",
    "    plt.plot(plot_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden_size = 128\n",
    "encoder1 = EncoderRNN(input_lang.n_words, hidden_size).to(device)\n",
    "decoder1 = DecoderRNN(hidden_size, output_lang.n_words).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 1000 and loss: 4.122932302121956\n",
      "iteration: 2000 and loss: 4.100129234905553\n",
      "iteration: 3000 and loss: 4.071954886472316\n",
      "iteration: 4000 and loss: 4.023332756273478\n",
      "iteration: 5000 and loss: 3.996266427733541\n",
      "iteration: 6000 and loss: 3.9900842699854167\n",
      "iteration: 7000 and loss: 3.9633900327632046\n",
      "iteration: 8000 and loss: 3.884419621428431\n",
      "iteration: 9000 and loss: 3.9185299326804706\n",
      "iteration: 10000 and loss: 3.8689347274697194\n",
      "iteration: 11000 and loss: 3.815499222018292\n",
      "iteration: 12000 and loss: 3.8902748845860367\n",
      "iteration: 13000 and loss: 3.7833620184671704\n",
      "iteration: 14000 and loss: 3.777705871080399\n",
      "iteration: 15000 and loss: 3.84167296803537\n",
      "iteration: 16000 and loss: 3.7141548505745727\n",
      "iteration: 17000 and loss: 3.719420674402239\n",
      "iteration: 18000 and loss: 3.6921194569437565\n",
      "iteration: 19000 and loss: 3.6384075082132155\n",
      "iteration: 20000 and loss: 3.718917219188978\n",
      "iteration: 21000 and loss: 3.633888830948248\n",
      "iteration: 22000 and loss: 3.6718180764640787\n",
      "iteration: 23000 and loss: 3.5939471732757733\n",
      "iteration: 24000 and loss: 3.602141714038377\n",
      "iteration: 25000 and loss: 3.564462716948161\n",
      "iteration: 26000 and loss: 3.6103444303762595\n",
      "iteration: 27000 and loss: 3.5306938826659806\n",
      "iteration: 28000 and loss: 3.530765404334791\n",
      "iteration: 29000 and loss: 3.5032275888121145\n",
      "iteration: 30000 and loss: 3.563994551410558\n",
      "iteration: 31000 and loss: 3.531402263226329\n",
      "iteration: 32000 and loss: 3.46370732195804\n",
      "iteration: 33000 and loss: 3.465911668572213\n",
      "iteration: 34000 and loss: 3.485313242327211\n",
      "iteration: 35000 and loss: 3.438883482463329\n",
      "iteration: 36000 and loss: 3.4330284593034173\n",
      "iteration: 37000 and loss: 3.4240685506696757\n",
      "iteration: 38000 and loss: 3.418446457275576\n",
      "iteration: 39000 and loss: 3.3717744154064357\n",
      "iteration: 40000 and loss: 3.4412957891908813\n",
      "iteration: 41000 and loss: 3.4149615402864484\n",
      "iteration: 42000 and loss: 3.373020967826984\n",
      "iteration: 43000 and loss: 3.430313272736955\n",
      "iteration: 44000 and loss: 3.291899923064757\n",
      "iteration: 45000 and loss: 3.3001840368213524\n",
      "iteration: 46000 and loss: 3.3443872747828878\n",
      "iteration: 47000 and loss: 3.4210700831469048\n",
      "iteration: 48000 and loss: 3.2931752126050435\n",
      "iteration: 49000 and loss: 3.278134594492532\n",
      "iteration: 50000 and loss: 3.381954734555971\n",
      "iteration: 51000 and loss: 3.2991682787003214\n",
      "iteration: 52000 and loss: 3.3638357417187867\n",
      "iteration: 53000 and loss: 3.2537073411529227\n",
      "iteration: 54000 and loss: 3.284572528436487\n",
      "iteration: 55000 and loss: 3.327923326999285\n",
      "iteration: 56000 and loss: 3.294328676324127\n",
      "iteration: 57000 and loss: 3.2040824824919394\n",
      "iteration: 58000 and loss: 3.2388801927239355\n",
      "iteration: 59000 and loss: 3.1867778139474767\n",
      "iteration: 60000 and loss: 3.2558461981307816\n",
      "iteration: 61000 and loss: 3.1998689139421175\n",
      "iteration: 62000 and loss: 3.2714458483297406\n",
      "iteration: 63000 and loss: 3.234266638899076\n",
      "iteration: 64000 and loss: 3.1912909062094887\n",
      "iteration: 65000 and loss: 3.260898019356406\n",
      "iteration: 66000 and loss: 3.2019961576438107\n",
      "iteration: 67000 and loss: 3.183628093688359\n",
      "iteration: 68000 and loss: 3.20158216354308\n",
      "iteration: 69000 and loss: 3.0784549357094644\n",
      "iteration: 70000 and loss: 3.227466003742521\n",
      "iteration: 71000 and loss: 3.1746421505507447\n",
      "iteration: 72000 and loss: 3.154877459673683\n",
      "iteration: 73000 and loss: 3.11865379870655\n",
      "iteration: 74000 and loss: 3.220830984633683\n",
      "iteration: 75000 and loss: 3.1601864168155216\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_every=1000\n",
    "plot_every=100\n",
    "learning_rate=0.01\n",
    "n_iters=75000\n",
    "\n",
    "trainIters(encoder1, decoder1, n_iters=n_iters, plot_every=plot_every, print_every=print_every)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_translation(encoder, decoder, sentence, max_length=MAX_LENGTH):\n",
    "    print(f\"Input sentence is: {sentence}\")\n",
    "    with torch.no_grad():\n",
    "        input_tensor = tensorFromSentence(input_lang, sentence)\n",
    "        input_length = input_tensor.size()[0]\n",
    "\n",
    "        hidden_size = 128\n",
    "        encoder_hidden = torch.zeros(1, 1, hidden_size, device=device)\n",
    "\n",
    "        for ei in range(input_length):\n",
    "            encoder_output, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)\n",
    "\n",
    "        decoder_input = torch.tensor([[SOS_token]], device=device)  # SOS\n",
    "        decoder_hidden = encoder_hidden\n",
    "        decoded_words = []\n",
    "\n",
    "        for di in range(max_length):\n",
    "            decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden)\n",
    "            best_guess = decoder_output.argmax(1)\n",
    "            if best_guess.item() == 1:# EOS_token\n",
    "                decoded_words.append('<EOS>')\n",
    "                break\n",
    "            else:\n",
    "                decoded_words.append(output_lang.index2word[best_guess.item()])\n",
    "\n",
    "            decoder_input = best_guess\n",
    "\n",
    "        return decoded_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input sentence is: il faut que tu reviennes\n",
      "['you', 'need', 'to', 'do', '<EOS>']\n"
     ]
    }
   ],
   "source": [
    "sen = \"Il faut que tu reviennes\"\n",
    "# We need you back.\tIl faut que tu reviennes\n",
    "print(get_translation(encoder1, decoder1, sen.lower()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Saving the models\n",
    "# https://stackoverflow.com/questions/42703500/how-do-i-save-a-trained-model-in-pytorch\n",
    "\n",
    "path = \"C:/Users/siddp/OneDrive/Desktop/project/encoder-decoder-models/model\"\n",
    "torch.save(encoder1.state_dict(), path + \"/encoder_simple.pth\")\n",
    "torch.save(decoder1.state_dict(), path + \"/decoder_simple.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # hidden_size = 128\n",
    "# # encoder1 = EncoderRNN(input_lang.n_words, hidden_size).to(device)\n",
    "# # decoder1 = DecoderRNN(hidden_size, output_lang.n_words).to(device)\n",
    "\n",
    "# model_encoder = EncoderRNN(input_lang.n_words, hidden_size)\n",
    "# model_encoder.load_state_dict(torch.load(path + \"/encoder_simple.pth\"))\n",
    "# model_encoder.eval()\n",
    "\n",
    "# model_decoder = DecoderRNN(hidden_size, output_lang.n_words)\n",
    "# model_decoder.load_state_dict(torch.load(path + \"/decoder_simple.pth\"))\n",
    "# model_decoder.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoder-Decoder Model with Attention Weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class AttnDecoderRNN(nn.Module):\n",
    "#     def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):\n",
    "#         super(AttnDecoderRNN, self).__init__()\n",
    "#         self.hidden_size = hidden_size\n",
    "#         self.output_size = output_size\n",
    "#         self.dropout_p = dropout_p\n",
    "#         self.max_length = max_length\n",
    "\n",
    "#         self.embedding = nn.Embedding(self.output_size, self.hidden_size)\n",
    "#         self.attn = nn.Linear(self.hidden_size * 2, self.max_length)\n",
    "#         self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)\n",
    "#         self.dropout = nn.Dropout(self.dropout_p)\n",
    "#         self.gru = nn.GRU(self.hidden_size, self.hidden_size)\n",
    "#         self.out = nn.Linear(self.hidden_size, self.output_size)\n",
    "\n",
    "#     def forward(self, input, hidden, encoder_outputs):\n",
    "#         # print(input.size())\n",
    "#         embedded = self.embedding(input).view(1, 1, -1)\n",
    "#         embedded = self.dropout(embedded)\n",
    "#         # print(embedded.size())\n",
    "\n",
    "#         attn_weights = F.softmax(self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)\n",
    "#         # print(attn_weights.size())\n",
    "#         # print(encoder_outputs.size())\n",
    "#         attn_applied = torch.bmm(attn_weights.unsqueeze(0), encoder_outputs.unsqueeze(0))\n",
    "\n",
    "#         output = torch.cat((embedded[0], attn_applied[0]), 1)\n",
    "#         # print(output.size())\n",
    "#         output = self.attn_combine(output).unsqueeze(0)\n",
    "\n",
    "#         output = F.relu(output)\n",
    "#         output, hidden = self.gru(output, hidden)\n",
    "\n",
    "#         output = F.log_softmax(self.out(output[0]), dim=1)\n",
    "#         return output, hidden, attn_weights\n",
    "\n",
    "#     def initHidden(self):\n",
    "#         return torch.zeros(1, 1, self.hidden_size, device=device)\n",
    "\n",
    "class AttnDecoderRNN(nn.Module):\n",
    "    def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):\n",
    "        super(AttnDecoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.output_size = output_size\n",
    "        self.dropout_p = dropout_p\n",
    "        self.max_length = max_length\n",
    "\n",
    "        self.embedding = nn.Embedding(self.output_size, self.hidden_size)\n",
    "        self.attn = nn.Linear(self.hidden_size * 2, self.max_length)\n",
    "        self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)\n",
    "        self.dropout = nn.Dropout(self.dropout_p)\n",
    "        self.gru = nn.GRU(self.hidden_size, self.hidden_size)\n",
    "        self.out = nn.Linear(self.hidden_size, self.output_size)\n",
    "\n",
    "    def forward(self, input, hidden, encoder_outputs):\n",
    "        embedded = self.embedding(input).view(1, 1, -1)\n",
    "        embedded = self.dropout(embedded)\n",
    "\n",
    "        attn_weights = F.softmax(self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)\n",
    "        # https://pytorch.org/docs/stable/generated/torch.bmm.html\n",
    "        attn_applied = torch.bmm(attn_weights.unsqueeze(0), encoder_outputs.unsqueeze(0))\n",
    "\n",
    "        output = torch.cat((embedded[0], attn_applied[0]), 1)\n",
    "        output = self.attn_combine(output).unsqueeze(0)\n",
    "\n",
    "        output = F.relu(output)\n",
    "        output, hidden = self.gru(output, hidden)\n",
    "\n",
    "        output = F.log_softmax(self.out(output[0]), dim=1)\n",
    "        return output, hidden, attn_weights\n",
    "\n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 12543])\n"
     ]
    }
   ],
   "source": [
    "hidden_size = 128\n",
    "model_test = AttnDecoderRNN(hidden_size, output_size=output_lang.n_words).to(device)\n",
    "input = tensorFromSentence(output_lang, random.choice(pairs)[1])\n",
    "# print(input.get_device())\n",
    "encoder_outputs = torch.zeros(MAX_LENGTH, hidden_size, device=device)\n",
    "encoder_output = output.squeeze(dim=0) # from encoder testing model\n",
    "encoder_outputs[0] = encoder_output\n",
    "hidden = torch.zeros(1, 1, hidden_size, device=device)\n",
    "# Testing for the first word in the sentence\n",
    "output, hidden, attn_weights = model_test(input[0], hidden, encoder_outputs)\n",
    "print(output.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_forcing_ratio = 0.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length=MAX_LENGTH):\n",
    "    encoder_hidden = torch.zeros(1, 1, 128, device=device)\n",
    "\n",
    "    encoder_optimizer.zero_grad()\n",
    "    decoder_optimizer.zero_grad()\n",
    "\n",
    "    input_length = input_tensor.size(0)\n",
    "    target_length = target_tensor.size(0)\n",
    "\n",
    "    encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)\n",
    "\n",
    "    loss = 0\n",
    "\n",
    "    for ei in range(input_length):\n",
    "        encoder_output, encoder_hidden = encoder(\n",
    "            input_tensor[ei], encoder_hidden)\n",
    "        encoder_outputs[ei] = encoder_output[0, 0]\n",
    "\n",
    "    decoder_input = torch.tensor([[SOS_token]], device=device)\n",
    "\n",
    "    decoder_hidden = encoder_hidden\n",
    "\n",
    "    use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False\n",
    "\n",
    "    if use_teacher_forcing:\n",
    "        # Teacher forcing: Feed the target as the next input\n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden, decoder_attention = decoder(\n",
    "                decoder_input, decoder_hidden, encoder_outputs)\n",
    "            loss += criterion(decoder_output, target_tensor[di])\n",
    "            decoder_input = target_tensor[di]  # Teacher forcing\n",
    "\n",
    "    else:\n",
    "        # Without teacher forcing: use its own predictions as the next input\n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden, decoder_attention = decoder(\n",
    "                decoder_input, decoder_hidden, encoder_outputs)\n",
    "            topv, topi = decoder_output.topk(1)\n",
    "            decoder_input = topi.squeeze().detach()  # detach from history as input\n",
    "\n",
    "            loss += criterion(decoder_output, target_tensor[di])\n",
    "            if decoder_input.item() == EOS_token:\n",
    "                break\n",
    "\n",
    "    loss.backward()\n",
    "\n",
    "    encoder_optimizer.step()\n",
    "    decoder_optimizer.step()\n",
    "\n",
    "    return loss.item() / target_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.01):\n",
    "    plot_losses = []\n",
    "    print_loss_total = 0  # Reset every print_every\n",
    "    plot_loss_total = 0  # Reset every plot_every\n",
    "\n",
    "    encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)\n",
    "    decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)\n",
    "    training_pairs = [tensorsFromPair(random.choice(pairs))\n",
    "                      for i in range(n_iters)]\n",
    "    criterion = nn.NLLLoss()\n",
    "\n",
    "    for iter in range(1, n_iters + 1):\n",
    "        training_pair = training_pairs[iter - 1]\n",
    "        input_tensor = training_pair[0]\n",
    "        target_tensor = training_pair[1]\n",
    "\n",
    "        loss = train(input_tensor, target_tensor, encoder,\n",
    "                     decoder, encoder_optimizer, decoder_optimizer, criterion)\n",
    "        print_loss_total += loss\n",
    "        plot_loss_total += loss\n",
    "\n",
    "        if iter % print_every == 0:\n",
    "            print_loss_avg = print_loss_total / print_every\n",
    "            print_loss_total = 0\n",
    "            print(f\"iteration: {iter} and loss: {print_loss_avg}\")                             \n",
    "\n",
    "        if iter % plot_every == 0:\n",
    "            plot_loss_avg = plot_loss_total / plot_every\n",
    "            plot_losses.append(plot_loss_avg)\n",
    "            plot_loss_total = 0\n",
    "\n",
    "    plt.figure()\n",
    "    fig, ax = plt.subplots()\n",
    "    plt.plot(plot_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden_size = 128\n",
    "# If running the whole script, change the encoder variable.\n",
    "encoder1 = EncoderRNN(input_lang.n_words, hidden_size).to(device)\n",
    "attn_decoder1 = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 1000 and loss: 4.868433686065531\n",
      "iteration: 2000 and loss: 4.588422094839882\n",
      "iteration: 3000 and loss: 4.5146644456231595\n",
      "iteration: 4000 and loss: 4.320980576365867\n",
      "iteration: 5000 and loss: 4.370992446527776\n",
      "iteration: 6000 and loss: 4.228047223667724\n",
      "iteration: 7000 and loss: 4.197827134912458\n",
      "iteration: 8000 and loss: 4.141726487613366\n",
      "iteration: 9000 and loss: 4.113820819723415\n",
      "iteration: 10000 and loss: 3.971491836017184\n",
      "iteration: 11000 and loss: 4.052714520255264\n",
      "iteration: 12000 and loss: 3.958799485383357\n",
      "iteration: 13000 and loss: 4.0509332698812575\n",
      "iteration: 14000 and loss: 3.968657473004684\n",
      "iteration: 15000 and loss: 3.9020923092831543\n",
      "iteration: 16000 and loss: 3.903898262960236\n",
      "iteration: 17000 and loss: 3.8424423746451692\n",
      "iteration: 18000 and loss: 3.860324892400757\n",
      "iteration: 19000 and loss: 3.848842014261484\n",
      "iteration: 20000 and loss: 3.769152237114264\n",
      "iteration: 21000 and loss: 3.7250022338693225\n",
      "iteration: 22000 and loss: 3.7094934152421426\n",
      "iteration: 23000 and loss: 3.7297249880403234\n",
      "iteration: 24000 and loss: 3.740718313529364\n",
      "iteration: 25000 and loss: 3.726640249642317\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print_every=1000\n",
    "plot_every=500\n",
    "learning_rate=0.01\n",
    "n_iters=25000\n",
    "\n",
    "trainIters(encoder1, attn_decoder1, n_iters=n_iters, plot_every=plot_every, print_every=print_every)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(encoder, decoder, sentence, max_length=MAX_LENGTH):\n",
    "    with torch.no_grad():\n",
    "        input_tensor = tensorFromSentence(input_lang, sentence)\n",
    "        input_length = input_tensor.size()[0]\n",
    "        encoder_hidden = torch.zeros(1, 1, 128, device=device)\n",
    "\n",
    "        encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)\n",
    "\n",
    "        for ei in range(input_length):\n",
    "            encoder_output, encoder_hidden = encoder(input_tensor[ei],\n",
    "                                                     encoder_hidden)\n",
    "            encoder_outputs[ei] += encoder_output[0, 0]\n",
    "\n",
    "        decoder_input = torch.tensor([[SOS_token]], device=device)  # SOS\n",
    "\n",
    "        decoder_hidden = encoder_hidden\n",
    "\n",
    "        decoded_words = []\n",
    "        decoder_attentions = torch.zeros(max_length, max_length)\n",
    "\n",
    "        for di in range(max_length):\n",
    "            decoder_output, decoder_hidden, decoder_attention = decoder(\n",
    "                decoder_input, decoder_hidden, encoder_outputs)\n",
    "            decoder_attentions[di] = decoder_attention.data\n",
    "            topv, topi = decoder_output.data.topk(1)\n",
    "            if topi.item() == EOS_token:\n",
    "                decoded_words.append('<EOS>')\n",
    "                break\n",
    "            else:\n",
    "                decoded_words.append(output_lang.index2word[topi.item()])\n",
    "\n",
    "            decoder_input = topi.squeeze().detach()\n",
    "\n",
    "        return decoded_words, decoder_attentions[:di + 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it s you want to\n"
     ]
    }
   ],
   "source": [
    "sen = \"Il faut que tu reviennes\"\n",
    "# We need you back.\tIl faut que tu reviennes\n",
    "de, de_att = evaluate(encoder1, attn_decoder1, sen.lower())\n",
    "print(\" \".join(de[:-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Still bad bro :/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = \"C:/Users/siddp/OneDrive/Desktop/project/encoder-decoder-models/model\"\n",
    "# torch.save(encoder1.state_dict(), path + \"/encoder_simple.pth\")\n",
    "torch.save(attn_decoder1.state_dict(), path + \"/decoder_attention.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "b2ec3647308baa210fcf1b48a8ee3939f0fefc43cc1ff01e9e2580cf8866ec76"
  },
  "kernelspec": {
   "display_name": "Python 3.9.12 ('att_venv')",
   "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.9.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}