ai-translation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Seq2Seq ML model for German to English translation\n",
    "\n",
    "Data: https://www.manythings.org/anki/ \n",
    "\n",
    "Simplified from PyTorch tutorial here: https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "from io import open\n",
    "import unicodedata\n",
    "import string\n",
    "import re\n",
    "import random\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch import optim\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common sequence-to-sequence (seq2seq) models are encoder-decoder models, which (commonly) use a recurrent neural network (RNN) to encode the source (input) sentence into a single vector."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### we will be representing each word in a language as a one-hot vector.We’ll need a unique index per word to use as the inputs and targets of the networks later.\n",
    "\n",
    "we will use a helper class called Lang which has word → index (word2index) and index → word (index2word) dictionaries, as well as a count of each word word2count to use to later replace rare words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "SOS_token = 0\n",
    "EOS_token = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "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  \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": "markdown",
   "metadata": {},
   "source": [
    "#### The files are all in Unicode, to simplify we will turn Unicode characters to ASCII, make everything lowercase, and trim most punctuation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalizeString(s):\n",
    "    \n",
    "    s = s.lower().strip()\n",
    "    \n",
    "    s = ''.join(\n",
    "        char for char in unicodedata.normalize('NFD', s)\n",
    "        if unicodedata.category(char) != 'Mn')\n",
    "    \n",
    "    s = re.sub(r\"([.!?])\", r\" \\1\", s)\n",
    "    s = re.sub(r\"[^a-zA-Z.!?]+\", r\" \", s)\n",
    "    \n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### - To read the data file we will split the file into lines\n",
    "#### - then split lines into pairs and normalize\n",
    "#### - The files are all English → German, to translate German → English add reverse flag to reverse the pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readLangs(lang1, lang2, reverse=False):\n",
    "    \n",
    "    print(\"Reading lines...\")\n",
    "\n",
    "    lines = open('datasets/%s-%s.txt' % (lang1, lang2), encoding='utf-8'). \\\n",
    "                  read().strip().split('\\n')\n",
    "\n",
    "    pairs = [[normalizeString(s) for s in l.split('\\t')] for l in lines]\n",
    "\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": "markdown",
   "metadata": {},
   "source": [
    "#### Since there are a lot of example sentences and we want to train something quickly, we’ll trim the data set to only relatively short and simple sentences. Here the maximum length is 10 words (that includes ending punctuation) and we’re filtering to sentences that translate to the form “I am” or “He is” etc. (accounting for apostrophes replaced earlier)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_LENGTH = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng_prefixes = (\"i am \", \"i m \",\n",
    "                \"he is\", \"he s \",\n",
    "                \"she is\", \"she s \",\n",
    "                \"you are\", \"you re \",\n",
    "                \"we are\", \"we re \",\n",
    "                \"they are\", \"they re \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filterPairs(pairs):\n",
    "    return [p for p in pairs \n",
    "            if \n",
    "            len(p[0].split(' ')) < MAX_LENGTH and \n",
    "            len(p[1].split(' ')) < MAX_LENGTH and \n",
    "            p[1].startswith(eng_prefixes)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Read text file and split into lines, split lines into pairs\n",
    "- Normalize text, filter by length and content\n",
    "- Make word lists from sentences in pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepareData(lang1, lang2, reverse=False):\n",
    "    \n",
    "    input_lang, output_lang, pairs = readLangs(lang1, lang2, reverse)\n",
    "    print(\"Read %s sentence pairs\" % len(pairs))\n",
    "    \n",
    "    pairs = filterPairs(pairs)\n",
    "    print(\"Trimmed to %s sentence pairs\" % len(pairs))\n",
    "    \n",
    "    for pair in pairs:\n",
    "        input_lang.addSentence(pair[0])\n",
    "        output_lang.addSentence(pair[1])\n",
    "        \n",
    "    print(\"Counted words:\")\n",
    "    print(input_lang.name, input_lang.n_words)\n",
    "    print(output_lang.name, output_lang.n_words)\n",
    "    \n",
    "    return input_lang, output_lang, pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading lines...\n",
      "Read 176692 sentence pairs\n",
      "Trimmed to 9678 sentence pairs\n",
      "Counted words:\n",
      "deu 4494\n",
      "eng 2913\n",
      "['er ist anfang zwanzig .', 'he is in his early twenties .']\n"
     ]
    }
   ],
   "source": [
    "input_lang, output_lang, pairs = prepareData('eng', 'deu', reverse=True)\n",
    "\n",
    "print(random.choice(pairs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Encoder-Decoder\n",
    "A Sequence to Sequence network, or seq2seq network, or Encoder Decoder network, is a model consisting of two RNNs called the encoder and decoder. The encoder reads an input sequence and outputs a single vector, and the decoder reads that vector to produce an output sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EncoderRNN(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super(EncoderRNN, self).__init__()\n",
    "        \n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.embedding = nn.Embedding(input_size, hidden_size)\n",
    "        \n",
    "        self.gru = nn.GRU(hidden_size, hidden_size)\n",
    "\n",
    "    def forward(self, input, hidden):\n",
    "        \n",
    "        # [1, hidden_size] -> [1, 1, hidden_size]\n",
    "        embedded = self.embedding(input).view(1, 1, -1)\n",
    "        output = embedded\n",
    "        \n",
    "        output, hidden = self.gru(output, hidden)\n",
    "        \n",
    "        return output, hidden\n",
    "\n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Basic Decoder\n",
    "\n",
    "At every step of decoding, the decoder is given an input token and hidden state. The initial input token is the start-of-string SOS token, and the first hidden state is the context vector (the encoder’s last hidden state)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecoderRNN(nn.Module):\n",
    "    \n",
    "    def __init__(self, hidden_size, output_size):\n",
    "        super(DecoderRNN, self).__init__()\n",
    "        \n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.embedding = nn.Embedding(output_size, hidden_size)\n",
    "        \n",
    "        self.gru = nn.GRU(hidden_size, hidden_size)\n",
    "        \n",
    "        self.out = nn.Linear(hidden_size, output_size)\n",
    "        \n",
    "        self.softmax = nn.LogSoftmax(dim=1)\n",
    "\n",
    "    def forward(self, input, hidden):\n",
    "        output = self.embedding(input).view(1, 1, -1)\n",
    "        output = F.relu(output)\n",
    "        \n",
    "        output, hidden = self.gru(output, hidden)\n",
    "        \n",
    "        # [1, 1, hidden_size] -> [1, hidden_size]\n",
    "        output = self.softmax(self.out(output[0]))\n",
    "        \n",
    "        return output, hidden\n",
    "\n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Preparing Training Data\n",
    "\n",
    "To train, for each pair we will need an input tensor (indexes of the words in the input sentence) and target tensor (indexes of the words in the target sentence). While creating these vectors we will append the EOS token to both sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tensorFromSentence(lang, sentence):\n",
    "    indexes = [lang.word2index[word] for word in sentence.split(' ')]\n",
    "\n",
    "    indexes.append(EOS_token)\n",
    "    \n",
    "    return torch.tensor(indexes, dtype=torch.long).view(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tensorsFromPair(pair):\n",
    "    input_tensor = tensorFromSentence(input_lang, pair[0])\n",
    "    target_tensor = tensorFromSentence(output_lang, pair[1])\n",
    "    \n",
    "    return (input_tensor, target_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To train we run the input sentence through the encoder, and keep track of every output and the latest hidden state. Then the decoder is given the SOS token as its first input, and the last hidden state of the encoder as its first hidden state.\n",
    "\n",
    "<b>“Teacher forcing” </b> is the concept of using the real target outputs as each next input, instead of using the decoder’s guess as the next input.\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_forcing_ratio = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(input_tensor, target_tensor, \n",
    "          encoder, decoder,\n",
    "          encoder_optimizer, decoder_optimizer, \n",
    "          criterion):\n",
    "    \n",
    "    encoder_hidden = encoder.initHidden()\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",
    "    loss = 0\n",
    "\n",
    "    for ei in range(input_length):\n",
    "        encoder_output, encoder_hidden = encoder(\n",
    "            input_tensor[ei], encoder_hidden)\n",
    "\n",
    "    decoder_input = torch.tensor([[SOS_token]])\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",
    "       \n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden = decoder(\n",
    "                decoder_input, decoder_hidden)\n",
    "            \n",
    "            loss += criterion(decoder_output, target_tensor[di])\n",
    "            decoder_input = target_tensor[di]  \n",
    "\n",
    "    else:\n",
    "        \n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden = decoder(\n",
    "                decoder_input, decoder_hidden)\n",
    "            \n",
    "            topv, topi = decoder_output.topk(1)\n",
    "            decoder_input = topi.squeeze().detach()  \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": "markdown",
   "metadata": {},
   "source": [
    "- Initialize optimizers and criterion\n",
    "- Create set of training pairs\n",
    "- Start empty losses array for plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_losses = []\n",
    "print_loss_total = 0  \n",
    "plot_loss_total = 0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "hidden_size = 256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder1 = EncoderRNN(input_lang.n_words, hidden_size)\n",
    "decoder1 = DecoderRNN(hidden_size, output_lang.n_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder_optimizer = optim.SGD(encoder1.parameters(), lr=0.01)\n",
    "decoder_optimizer = optim.SGD(decoder1.parameters(), lr=0.01)\n",
    "\n",
    "training_pairs = [tensorsFromPair(random.choice(pairs))\n",
    "                  for i in range(30000)]\n",
    "criterion = nn.NLLLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration - 1000 loss - 38.2183\n",
      "iteration - 2000 loss - 32.5884\n",
      "iteration - 3000 loss - 30.2088\n",
      "iteration - 4000 loss - 29.0034\n",
      "iteration - 5000 loss - 28.2344\n",
      "iteration - 6000 loss - 27.5534\n",
      "iteration - 7000 loss - 26.6797\n",
      "iteration - 8000 loss - 25.8495\n",
      "iteration - 9000 loss - 25.0718\n",
      "iteration - 10000 loss - 24.7925\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x117bf61d0>]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for iter in range(1, 30001):\n",
    "    \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, \n",
    "                 encoder1, decoder1, \n",
    "                 encoder_optimizer, decoder_optimizer, \n",
    "                 criterion)\n",
    "    \n",
    "    print_loss_total += loss\n",
    "    plot_loss_total += loss\n",
    "\n",
    "    if iter % 1000 == 0:\n",
    "        print_loss_avg = print_loss_total / 100\n",
    "        print_loss_total = 0\n",
    "        print('iteration - %d loss - %.4f' % (iter, print_loss_avg))\n",
    "\n",
    "    if iter % 100 == 0:\n",
    "        plot_loss_avg = plot_loss_total / 100\n",
    "        plot_losses.append(plot_loss_avg)\n",
    "        plot_loss_total = 0\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(15, 8))\n",
    "loc = ticker.MultipleLocator(base=0.2)\n",
    "ax.yaxis.set_major_locator(loc)\n",
    "plt.plot(plot_losses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### KEY: > input = target < output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluation\n",
    "there are no targets so we simply feed the decoder’s predictions back to itself for each step. Every time it predicts a word we add it to the output string, and if it predicts the EOS token we stop there. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(encoder, decoder, sentence):\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        input_tensor = tensorFromSentence(input_lang, sentence)\n",
    "        input_length = input_tensor.size(0)\n",
    "        \n",
    "        encoder_hidden = encoder.initHidden()\n",
    "\n",
    "        for ei in range(input_length):\n",
    "            encoder_output, encoder_hidden = encoder(input_tensor[ei],\n",
    "                                                     encoder_hidden)\n",
    "\n",
    "        decoder_input = torch.tensor([[SOS_token]])  \n",
    "        decoder_hidden = encoder_hidden\n",
    "\n",
    "        decoded_words = []\n",
    "\n",
    "        for di in range(MAX_LENGTH):\n",
    "            decoder_output, decoder_hidden = decoder(decoder_input, \n",
    "                                                     decoder_hidden)\n",
    "\n",
    "            topv, topi = decoder_output.data.topk(1)\n",
    "            \n",
    "            if topi.item() == EOS_token:\n",
    "                decoded_words.append('<EOS>')\n",
    "                break\n",
    "                \n",
    "            else:\n",
    "                decoded_words.append(output_lang.index2word[topi.item()])\n",
    "\n",
    "            decoder_input = topi.squeeze().detach()\n",
    "\n",
    "        return decoded_words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can evaluate random sentences from the training set and print out the input, target, and output to make some subjective quality judgements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> so blod bin ich nicht .\n",
      "= i m not that stupid .\n",
      "< i m not . . . <EOS>\n",
      "\n",
      "> ich bin hier weil ich ihre hilfe brauche .\n",
      "= i m here because i need your help .\n",
      "< i m sorry i can i can t help .\n",
      "\n",
      "> ich bin kein bisschen mude .\n",
      "= i m not at all tired .\n",
      "< i m not a at all . <EOS>\n",
      "\n",
      "> er will hoch hinaus .\n",
      "= he is driven .\n",
      "< he s a little . . <EOS>\n",
      "\n",
      "> er lugt .\n",
      "= he is lying .\n",
      "< he s a little . <EOS>\n",
      "\n",
      "> ich spure eine gro e feindseligkeit .\n",
      "= i m sensing a lot of hostility .\n",
      "< i m a little . . <EOS>\n",
      "\n",
      "> das beantwortet meine frage nicht .\n",
      "= you re not answering my question .\n",
      "< you re not my . . <EOS>\n",
      "\n",
      "> die sind alle alter als sie .\n",
      "= they re all older than you .\n",
      "< they are as than you . <EOS>\n",
      "\n",
      "> ich sorge mich um euch alle .\n",
      "= i m worried about all of you .\n",
      "< i m going to you you . <EOS>\n",
      "\n",
      "> du hast den bezug zur realitat verloren .\n",
      "= you re out of touch with reality .\n",
      "< you re the only of <EOS>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "        \n",
    "        pair = random.choice(pairs)\n",
    "        \n",
    "        print('>', pair[0])\n",
    "        print('=', pair[1])\n",
    "        \n",
    "        output_words = evaluate(encoder1, decoder1, pair[0])\n",
    "        output_sentence = ' '.join(output_words)\n",
    "        \n",
    "        print('<', output_sentence)\n",
    "        print('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_sentence = 'es tut mir sehr leid' #Re-run for 'es geht mir gut'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_words = evaluate(encoder1, \n",
    "                        decoder1, \n",
    "                        input_sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = es tut mir sehr leid\n",
      "output = i m sorry about that . <EOS>\n"
     ]
    }
   ],
   "source": [
    "print('input =', input_sentence)\n",
    "print('output =', ' '.join(output_words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}