machine_translation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Artificial Intelligence Nanodegree\n",
    "## Machine Translation Project\n",
    "In this notebook, sections that end with **'(IMPLEMENTATION)'** in the header indicate that the following blocks of code will require additional functionality which you must provide. Please be sure to read the instructions carefully!\n",
    "\n",
    "## Introduction\n",
    "In this notebook, you will build a deep neural network that functions as part of an end-to-end machine translation pipeline. Your completed pipeline will accept English text as input and return the French translation.\n",
    "\n",
    "- **Preprocess** - You'll convert text to sequence of integers.\n",
    "- **Models** Create models which accepts a sequence of integers as input and returns a probability distribution over possible translations. After learning about the basic types of neural networks that are often used for machine translation, you will engage in your own investigations, to design your own model!\n",
    "- **Prediction** Run the model on English text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%aimport helper\n",
    "%autoreload 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections\n",
    "\n",
    "import helper\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.utils import pad_sequences\n",
    "from keras.models import Model\n",
    "from keras.layers import GRU, Input, Dense, TimeDistributed, Activation, RepeatVector, Bidirectional\n",
    "from keras.layers import Embedding\n",
    "from keras.optimizers import Adam\n",
    "from keras.losses import sparse_categorical_crossentropy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Verify access to the GPU\n",
    "The following test applies only if you expect to be using a GPU, e.g., while running in a Udacity Workspace or using an AWS instance with GPU support. Run the next cell, and verify that the device_type is \"GPU\".\n",
    "- If the device is not GPU & you are running from a Udacity Workspace, then save your workspace with the icon at the top, then click \"enable\" at the bottom of the workspace.\n",
    "- If the device is not GPU & you are running from an AWS instance, then refer to the cloud computing instructions in the classroom to verify your setup steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[name: \"/device:CPU:0\"\n",
      "device_type: \"CPU\"\n",
      "memory_limit: 268435456\n",
      "locality {\n",
      "}\n",
      "incarnation: 4003941463999558694\n",
      "xla_global_id: -1\n",
      ", name: \"/device:GPU:0\"\n",
      "device_type: \"GPU\"\n",
      "memory_limit: 5750390784\n",
      "locality {\n",
      "  bus_id: 1\n",
      "  links {\n",
      "  }\n",
      "}\n",
      "incarnation: 13345214294460300557\n",
      "physical_device_desc: \"device: 0, name: NVIDIA GeForce RTX 3070 Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.6\"\n",
      "xla_global_id: 416903419\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.python.client import device_lib\n",
    "print(device_lib.list_local_devices())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset\n",
    "We begin by investigating the dataset that will be used to train and evaluate your pipeline.  The most common datasets used for machine translation are from [WMT](http://www.statmt.org/).  However, that will take a long time to train a neural network on.  We'll be using a dataset we created for this project that contains a small vocabulary.  You'll be able to train your model in a reasonable time with this dataset.\n",
    "### Load Data\n",
    "The data is located in `data/small_vocab_en` and `data/small_vocab_fr`. The `small_vocab_en` file contains English sentences with their French translations in the `small_vocab_fr` file. Load the English and French data from these files from running the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Loaded\n"
     ]
    }
   ],
   "source": [
    "# Load English data\n",
    "english_sentences = helper.load_data('data/small_vocab_en')\n",
    "# Load French data\n",
    "french_sentences = helper.load_data('data/small_vocab_fr')\n",
    "\n",
    "print('Dataset Loaded')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Files\n",
    "Each line in `small_vocab_en` contains an English sentence with the respective translation in each line of `small_vocab_fr`.  View the first two lines from each file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "small_vocab_en Line 1:  new jersey is sometimes quiet during autumn , and it is snowy in april .\n",
      "small_vocab_fr Line 1:  new jersey est parfois calme pendant l' automne , et il est neigeux en avril .\n",
      "small_vocab_en Line 2:  the united states is usually chilly during july , and it is usually freezing in november .\n",
      "small_vocab_fr Line 2:  les Ã©tats-unis est gÃ©nÃ©ralement froid en juillet , et il gÃ¨le habituellement en novembre .\n"
     ]
    }
   ],
   "source": [
    "for sample_i in range(2):\n",
    "    print('small_vocab_en Line {}:  {}'.format(sample_i + 1, english_sentences[sample_i]))\n",
    "    print('small_vocab_fr Line {}:  {}'.format(sample_i + 1, french_sentences[sample_i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From looking at the sentences, you can see they have been preprocessed already.  The puncuations have been delimited using spaces. All the text have been converted to lowercase.  This should save you some time, but the text requires more preprocessing.\n",
    "### Vocabulary\n",
    "The complexity of the problem is determined by the complexity of the vocabulary.  A more complex vocabulary is a more complex problem.  Let's look at the complexity of the dataset we'll be working with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1823250 English words.\n",
      "227 unique English words.\n",
      "10 Most common words in the English dataset:\n",
      "\"is\" \",\" \".\" \"in\" \"it\" \"during\" \"the\" \"but\" \"and\" \"sometimes\"\n",
      "\n",
      "1961295 French words.\n",
      "355 unique French words.\n",
      "10 Most common words in the French dataset:\n",
      "\"est\" \".\" \",\" \"en\" \"il\" \"les\" \"mais\" \"et\" \"la\" \"parfois\"\n"
     ]
    }
   ],
   "source": [
    "english_words_counter = collections.Counter([word for sentence in english_sentences for word in sentence.split()])\n",
    "french_words_counter = collections.Counter([word for sentence in french_sentences for word in sentence.split()])\n",
    "\n",
    "print('{} English words.'.format(len([word for sentence in english_sentences for word in sentence.split()])))\n",
    "print('{} unique English words.'.format(len(english_words_counter)))\n",
    "print('10 Most common words in the English dataset:')\n",
    "print('\"' + '\" \"'.join(list(zip(*english_words_counter.most_common(10)))[0]) + '\"')\n",
    "print()\n",
    "print('{} French words.'.format(len([word for sentence in french_sentences for word in sentence.split()])))\n",
    "print('{} unique French words.'.format(len(french_words_counter)))\n",
    "print('10 Most common words in the French dataset:')\n",
    "print('\"' + '\" \"'.join(list(zip(*french_words_counter.most_common(10)))[0]) + '\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For comparison, _Alice's Adventures in Wonderland_ contains 2,766 unique words of a total of 15,500 words.\n",
    "## Preprocess\n",
    "For this project, you won't use text data as input to your model. Instead, you'll convert the text into sequences of integers using the following preprocess methods:\n",
    "1. Tokenize the words into ids\n",
    "2. Add padding to make all the sequences the same length.\n",
    "\n",
    "Time to start preprocessing the data...\n",
    "### Tokenize (IMPLEMENTATION)\n",
    "For a neural network to predict on text data, it first has to be turned into data it can understand. Text data like \"dog\" is a sequence of ASCII character encodings.  Since a neural network is a series of multiplication and addition operations, the input data needs to be number(s).\n",
    "\n",
    "We can turn each character into a number or each word into a number.  These are called character and word ids, respectively.  Character ids are used for character level models that generate text predictions for each character.  A word level model uses word ids that generate text predictions for each word.  Word level models tend to learn better, since they are lower in complexity, so we'll use those.\n",
    "\n",
    "Turn each sentence into a sequence of words ids using Keras's [`Tokenizer`](https://keras.io/preprocessing/text/#tokenizer) function. Use this function to tokenize `english_sentences` and `french_sentences` in the cell below.\n",
    "\n",
    "Running the cell will run `tokenize` on sample data and show output for debugging."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'the': 1, 'quick': 2, 'a': 3, 'brown': 4, 'fox': 5, 'jumps': 6, 'over': 7, 'lazy': 8, 'dog': 9, 'by': 10, 'jove': 11, 'my': 12, 'study': 13, 'of': 14, 'lexicography': 15, 'won': 16, 'prize': 17, 'this': 18, 'is': 19, 'short': 20, 'sentence': 21}\n",
      "\n",
      "Sequence 1 in x\n",
      "  Input:  The quick brown fox jumps over the lazy dog .\n",
      "  Output: [1, 2, 4, 5, 6, 7, 1, 8, 9]\n",
      "Sequence 2 in x\n",
      "  Input:  By Jove , my quick study of lexicography won a prize .\n",
      "  Output: [10, 11, 12, 2, 13, 14, 15, 16, 3, 17]\n",
      "Sequence 3 in x\n",
      "  Input:  This is a short sentence .\n",
      "  Output: [18, 19, 3, 20, 21]\n"
     ]
    }
   ],
   "source": [
    "def tokenize(x):\n",
    "    \"\"\"\n",
    "    Tokenize x\n",
    "    :param x: List of sentences/strings to be tokenized\n",
    "    :return: Tuple of (tokenized x data, tokenizer used to tokenize x)\n",
    "    \"\"\"\n",
    "    # TODO: Implement\n",
    "    x_tk = Tokenizer()\n",
    "    x_tk.fit_on_texts(x)\n",
    "\n",
    "    return x_tk.texts_to_sequences(x), x_tk\n",
    "\n",
    "# Tokenize Example output\n",
    "text_sentences = [\n",
    "    'The quick brown fox jumps over the lazy dog .',\n",
    "    'By Jove , my quick study of lexicography won a prize .',\n",
    "    'This is a short sentence .']\n",
    "text_tokenized, text_tokenizer = tokenize(text_sentences)\n",
    "print(text_tokenizer.word_index)\n",
    "print()\n",
    "for sample_i, (sent, token_sent) in enumerate(zip(text_sentences, text_tokenized)):\n",
    "    print('Sequence {} in x'.format(sample_i + 1))\n",
    "    print('  Input:  {}'.format(sent))\n",
    "    print('  Output: {}'.format(token_sent))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Padding (IMPLEMENTATION)\n",
    "When batching the sequence of word ids together, each sequence needs to be the same length.  Since sentences are dynamic in length, we can add padding to the end of the sequences to make them the same length.\n",
    "\n",
    "Make sure all the English sequences have the same length and all the French sequences have the same length by adding padding to the **end** of each sequence using Keras's [`pad_sequences`](https://keras.io/preprocessing/sequence/#pad_sequences) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequence 1 in x\n",
      "  Input:  [1 2 4 5 6 7 1 8 9]\n",
      "  Output: [1 2 4 5 6 7 1 8 9 0]\n",
      "Sequence 2 in x\n",
      "  Input:  [10 11 12  2 13 14 15 16  3 17]\n",
      "  Output: [10 11 12  2 13 14 15 16  3 17]\n",
      "Sequence 3 in x\n",
      "  Input:  [18 19  3 20 21]\n",
      "  Output: [18 19  3 20 21  0  0  0  0  0]\n"
     ]
    }
   ],
   "source": [
    "def pad(x, length=None):\n",
    "    \"\"\"\n",
    "    Pad x\n",
    "    :param x: List of sequences.\n",
    "    :param length: Length to pad the sequence to.  If None, use length of longest sequence in x.\n",
    "    :return: Padded numpy array of sequences\n",
    "    \"\"\"\n",
    "    # TODO: Implement\n",
    "    length = max(map(len,x)) if length is None else length\n",
    "\n",
    "    return pad_sequences(x, maxlen=length, padding='post')\n",
    "\n",
    "# Pad Tokenized output\n",
    "test_pad = pad(text_tokenized)\n",
    "for sample_i, (token_sent, pad_sent) in enumerate(zip(text_tokenized, test_pad)):\n",
    "    print('Sequence {} in x'.format(sample_i + 1))\n",
    "    print('  Input:  {}'.format(np.array(token_sent)))\n",
    "    print('  Output: {}'.format(pad_sent))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preprocess Pipeline\n",
    "Your focus for this project is to build neural network architecture, so we won't ask you to create a preprocess pipeline.  Instead, we've provided you with the implementation of the `preprocess` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data Preprocessed\n",
      "Max English sentence length: 15\n",
      "Max French sentence length: 21\n",
      "English vocabulary size: 199\n",
      "French vocabulary size: 345\n"
     ]
    }
   ],
   "source": [
    "def preprocess(x, y):\n",
    "    \"\"\"\n",
    "    Preprocess x and y\n",
    "    :param x: Feature List of sentences\n",
    "    :param y: Label List of sentences\n",
    "    :return: Tuple of (Preprocessed x, Preprocessed y, x tokenizer, y tokenizer)\n",
    "    \"\"\"\n",
    "    preprocess_x, x_tk = tokenize(x)\n",
    "    preprocess_y, y_tk = tokenize(y)\n",
    "\n",
    "    preprocess_x = pad(preprocess_x)\n",
    "    preprocess_y = pad(preprocess_y)\n",
    "\n",
    "    # Keras's sparse_categorical_crossentropy function requires the labels to be in 3 dimensions\n",
    "    preprocess_y = preprocess_y.reshape(*preprocess_y.shape, 1)\n",
    "\n",
    "    return preprocess_x, preprocess_y, x_tk, y_tk\n",
    "\n",
    "preproc_english_sentences, preproc_french_sentences, english_tokenizer, french_tokenizer =\\\n",
    "    preprocess(english_sentences, french_sentences)\n",
    "    \n",
    "max_english_sequence_length = preproc_english_sentences.shape[1]\n",
    "max_french_sequence_length = preproc_french_sentences.shape[1]\n",
    "english_vocab_size = len(english_tokenizer.word_index)\n",
    "french_vocab_size = len(french_tokenizer.word_index)\n",
    "\n",
    "print('Data Preprocessed')\n",
    "print(\"Max English sentence length:\", max_english_sequence_length)\n",
    "print(\"Max French sentence length:\", max_french_sequence_length)\n",
    "print(\"English vocabulary size:\", english_vocab_size)\n",
    "print(\"French vocabulary size:\", french_vocab_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Models\n",
    "In this section, you will experiment with various neural network architectures.\n",
    "You will begin by training four relatively simple architectures.\n",
    "- Model 1 is a simple RNN\n",
    "- Model 2 is a RNN with Embedding\n",
    "- Model 3 is a Bidirectional RNN\n",
    "- Model 4 is an Encoder-Decoder RNN\n",
    "\n",
    "After experimenting with the four simple architectures, you will construct a deeper architecture that is designed to outperform all four models.\n",
    "### Ids Back to Text\n",
    "The neural network will be translating the input to words ids, which isn't the final form we want.  We want the French translation.  The function `logits_to_text` will bridge the gab between the logits from the neural network to the French translation.  You'll be using this function to better understand the output of the neural network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`logits_to_text` function loaded.\n"
     ]
    }
   ],
   "source": [
    "def logits_to_text(logits, tokenizer):\n",
    "    \"\"\"\n",
    "    Turn logits from a neural network into text using the tokenizer\n",
    "    :param logits: Logits from a neural network\n",
    "    :param tokenizer: Keras Tokenizer fit on the labels\n",
    "    :return: String that represents the text of the logits\n",
    "    \"\"\"\n",
    "    index_to_words = {id: word for word, id in tokenizer.word_index.items()}\n",
    "    index_to_words[0] = '<PAD>'\n",
    "\n",
    "    return ' '.join([index_to_words[prediction] for prediction in np.argmax(logits, 1)])\n",
    "\n",
    "print('`logits_to_text` function loaded.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotting_results(history):\n",
    "    \"\"\"\n",
    "    Plot results of a model trainig\n",
    "    \"\"\"\n",
    "    acc = history.history['accuracy']\n",
    "    val_acc = history.history['val_accuracy']\n",
    "    loss = history.history['loss']\n",
    "    val_loss = history.history['val_loss']\n",
    "\n",
    "    epochs = range(1, len(acc) + 1)\n",
    "\n",
    "    plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "    plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "    plt.title('Training and validation accuracy')\n",
    "    plt.legend()\n",
    "\n",
    "    plt.figure()\n",
    "\n",
    "    plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "    plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "    plt.title('Training and validation loss')\n",
    "    plt.legend()\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 1: RNN (IMPLEMENTATION)\n",
    "![RNN](images/rnn.png)\n",
    "A basic RNN model is a good baseline for sequence data.  In this model, you'll build a RNN that translates English to French."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "1724/1724 [==============================] - 9s 4ms/step - loss: 1.2259 - accuracy: 0.6430 - val_loss: 0.9707 - val_accuracy: 0.6759\n",
      "Epoch 2/10\n",
      "1724/1724 [==============================] - 7s 4ms/step - loss: 0.9013 - accuracy: 0.6941 - val_loss: 0.8198 - val_accuracy: 0.7209\n",
      "Epoch 3/10\n",
      "1724/1724 [==============================] - 7s 4ms/step - loss: 0.7713 - accuracy: 0.7388 - val_loss: 0.7369 - val_accuracy: 0.7496\n",
      "Epoch 4/10\n",
      "1724/1724 [==============================] - 7s 4ms/step - loss: 0.6968 - accuracy: 0.7654 - val_loss: 0.6947 - val_accuracy: 0.7599\n",
      "Epoch 5/10\n",
      "1724/1724 [==============================] - 7s 4ms/step - loss: 0.6400 - accuracy: 0.7838 - val_loss: 0.5922 - val_accuracy: 0.8003\n",
      "Epoch 6/10\n",
      "1724/1724 [==============================] - 7s 4ms/step - loss: 0.6087 - accuracy: 0.7936 - val_loss: 0.6358 - val_accuracy: 0.7828\n",
      "Epoch 7/10\n",
      "1724/1724 [==============================] - 7s 4ms/step - loss: 0.5914 - accuracy: 0.7987 - val_loss: 0.7126 - val_accuracy: 0.7674\n",
      "Epoch 8/10\n",
      "1724/1724 [==============================] - 7s 4ms/step - loss: 0.5738 - accuracy: 0.8043 - val_loss: 0.5847 - val_accuracy: 0.7980\n",
      "Epoch 9/10\n",
      "1724/1724 [==============================] - 7s 4ms/step - loss: 0.5576 - accuracy: 0.8085 - val_loss: 0.5726 - val_accuracy: 0.8027\n",
      "Epoch 10/10\n",
      "1724/1724 [==============================] - 7s 4ms/step - loss: 0.5370 - accuracy: 0.8159 - val_loss: 0.4948 - val_accuracy: 0.8323\n",
      "1/1 [==============================] - 0s 220ms/step\n",
      "new jersey est parfois calme en l' automne et il est neigeux en avril <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD>\n"
     ]
    }
   ],
   "source": [
    "def simple_model(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):\n",
    "    \"\"\"\n",
    "    Build and train a basic RNN on x and y\n",
    "    :param input_shape: Tuple of input shape\n",
    "    :param output_sequence_length: Length of output sequence\n",
    "    :param english_vocab_size: Number of unique English words in the dataset\n",
    "    :param french_vocab_size: Number of unique French words in the dataset\n",
    "    :return: Keras model built, but not trained\n",
    "    \"\"\"\n",
    "    # TODO: Build the layers\n",
    "    gru_size=512\n",
    "    learning_rate = 1e-3\n",
    "\n",
    "    input_seq = Input(input_shape[1:])\n",
    "    \n",
    "    rnn = GRU(gru_size, return_sequences=True)(input_seq)\n",
    "    \n",
    "    logits = TimeDistributed(Dense(french_vocab_size))(rnn)\n",
    "\n",
    "    model = Model(input_seq, Activation('softmax')(logits))\n",
    "    \n",
    "    model.compile(loss=sparse_categorical_crossentropy,\n",
    "                  optimizer=Adam(learning_rate),\n",
    "                  metrics=['accuracy'])\n",
    "    \n",
    "    return model\n",
    "\n",
    "# Reshaping the input to work with a basic RNN\n",
    "tmp_x = pad(preproc_english_sentences, max_french_sequence_length)\n",
    "tmp_x = tmp_x.reshape((-1, preproc_french_sentences.shape[-2], 1))\n",
    "\n",
    "# Train the neural network\n",
    "simple_rnn_model = simple_model(\n",
    "    tmp_x.shape,\n",
    "    max_french_sequence_length,\n",
    "    english_vocab_size+1,\n",
    "    french_vocab_size+1)\n",
    "\n",
    "simple_rnn_history =simple_rnn_model.fit(tmp_x, preproc_french_sentences, batch_size=64, epochs=10, validation_split=0.2)\n",
    "\n",
    "# Print prediction(s)\n",
    "print(logits_to_text(simple_rnn_model.predict(tmp_x[:1])[0], french_tokenizer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotting_results(simple_rnn_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 2: Embedding (IMPLEMENTATION)\n",
    "![RNN](images/embedding.png)\n",
    "You've turned the words into ids, but there's a better representation of a word.  This is called word embeddings.  An embedding is a vector representation of the word that is close to similar words in n-dimensional space, where the n represents the size of the embedding vectors.\n",
    "\n",
    "In this model, you'll create a RNN model using embedding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "1724/1724 [==============================] - 10s 5ms/step - loss: 0.9780 - accuracy: 0.7633 - val_loss: 0.3790 - val_accuracy: 0.8809\n",
      "Epoch 2/10\n",
      "1724/1724 [==============================] - 8s 5ms/step - loss: 0.3135 - accuracy: 0.8982 - val_loss: 0.2628 - val_accuracy: 0.9133\n",
      "Epoch 3/10\n",
      "1724/1724 [==============================] - 8s 5ms/step - loss: 0.2442 - accuracy: 0.9174 - val_loss: 0.2291 - val_accuracy: 0.9213\n",
      "Epoch 4/10\n",
      "1724/1724 [==============================] - 8s 5ms/step - loss: 0.2158 - accuracy: 0.9253 - val_loss: 0.2148 - val_accuracy: 0.9270\n",
      "Epoch 5/10\n",
      "1724/1724 [==============================] - 8s 5ms/step - loss: 0.2000 - accuracy: 0.9298 - val_loss: 0.2058 - val_accuracy: 0.9289\n",
      "Epoch 6/10\n",
      "1724/1724 [==============================] - 9s 5ms/step - loss: 0.1892 - accuracy: 0.9328 - val_loss: 0.1966 - val_accuracy: 0.9314\n",
      "Epoch 7/10\n",
      "1724/1724 [==============================] - 9s 5ms/step - loss: 0.1823 - accuracy: 0.9349 - val_loss: 0.1908 - val_accuracy: 0.9329\n",
      "Epoch 8/10\n",
      "1724/1724 [==============================] - 8s 5ms/step - loss: 0.1776 - accuracy: 0.9360 - val_loss: 0.1886 - val_accuracy: 0.9338\n",
      "Epoch 9/10\n",
      "1724/1724 [==============================] - 8s 5ms/step - loss: 0.1734 - accuracy: 0.9370 - val_loss: 0.1864 - val_accuracy: 0.9352\n",
      "Epoch 10/10\n",
      "1724/1724 [==============================] - 8s 5ms/step - loss: 0.1714 - accuracy: 0.9377 - val_loss: 0.1836 - val_accuracy: 0.9354\n",
      "Model Prediction:\n",
      "1/1 [==============================] - 0s 195ms/step\n",
      "new jersey est parfois calme en l' automne et il est neigeux en avril <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD>\n",
      "French Translation (Ground Truth):\n",
      "[\"new jersey est parfois calme pendant l' automne , et il est neigeux en avril .\"]\n",
      "English Text:\n",
      "['new jersey is sometimes quiet during autumn , and it is snowy in april .']\n"
     ]
    }
   ],
   "source": [
    "def embed_model(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):\n",
    "    \"\"\"\n",
    "    Build and train a RNN model using word embedding on x and y\n",
    "    :param input_shape: Tuple of input shape\n",
    "    :param output_sequence_length: Length of output sequence\n",
    "    :param english_vocab_size: Number of unique English words in the dataset\n",
    "    :param french_vocab_size: Number of unique French words in the dataset\n",
    "    :return: Keras model built, but not trained\n",
    "    \"\"\"\n",
    "    # TODO: Implement\n",
    "    gru_size=256\n",
    "    embedding_dim = 64\n",
    "    learning_rate = 1e-3\n",
    "\n",
    "    input_seq = Input(input_shape[1:])\n",
    "    \n",
    "    embedding = Embedding(english_vocab_size, embedding_dim)(input_seq)\n",
    "    \n",
    "    rnn = GRU(gru_size, return_sequences=True)(embedding)\n",
    "    \n",
    "    logits = TimeDistributed(Dense(french_vocab_size))(rnn)\n",
    "\n",
    "    model = Model(input_seq, Activation('softmax')(logits))\n",
    "    \n",
    "    model.compile(loss=sparse_categorical_crossentropy,\n",
    "                  optimizer=Adam(learning_rate),\n",
    "                  metrics=['accuracy'])\n",
    "    \n",
    "    return model\n",
    "\n",
    "# TODO: Reshape the input\n",
    "tmp_x = pad(preproc_english_sentences, max_french_sequence_length)\n",
    "tmp_x = tmp_x.reshape((-1, preproc_french_sentences.shape[-2]))\n",
    "\n",
    "# TODO: Train the neural network\n",
    "embed_rnn_model = embed_model(\n",
    "    tmp_x.shape,\n",
    "    max_french_sequence_length,\n",
    "    english_vocab_size+1,\n",
    "    french_vocab_size+1)\n",
    "\n",
    "embed_rnn_history=embed_rnn_model.fit(tmp_x, preproc_french_sentences, batch_size=64, epochs=10, validation_split=0.2)\n",
    "\n",
    "\n",
    "# TODO: Print prediction(s)\n",
    "print('Model Prediction:')\n",
    "print(logits_to_text(embed_rnn_model.predict(tmp_x[:1])[0], french_tokenizer))\n",
    "\n",
    "print('French Translation (Ground Truth):')\n",
    "print(french_sentences[:1])\n",
    "\n",
    "print('English Text:')\n",
    "print(english_sentences[:1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotting_results(embed_rnn_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 3: Bidirectional RNNs (IMPLEMENTATION)\n",
    "![RNN](images/bidirectional.png)\n",
    "One restriction of a RNN is that it can't see the future input, only the past.  This is where bidirectional recurrent neural networks come in.  They are able to see the future data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "1724/1724 [==============================] - 14s 7ms/step - loss: 1.0997 - accuracy: 0.6705 - val_loss: 0.8924 - val_accuracy: 0.7006\n",
      "Epoch 2/10\n",
      "1724/1724 [==============================] - 12s 7ms/step - loss: 0.8106 - accuracy: 0.7199 - val_loss: 0.7521 - val_accuracy: 0.7356\n",
      "Epoch 3/10\n",
      "1724/1724 [==============================] - 12s 7ms/step - loss: 0.6923 - accuracy: 0.7593 - val_loss: 0.6803 - val_accuracy: 0.7621\n",
      "Epoch 4/10\n",
      "1724/1724 [==============================] - 12s 7ms/step - loss: 0.6227 - accuracy: 0.7813 - val_loss: 0.5603 - val_accuracy: 0.8083\n",
      "Epoch 5/10\n",
      "1724/1724 [==============================] - 12s 7ms/step - loss: 0.5579 - accuracy: 0.8046 - val_loss: 0.5560 - val_accuracy: 0.8107\n",
      "Epoch 6/10\n",
      "1724/1724 [==============================] - 12s 7ms/step - loss: 0.5375 - accuracy: 0.8121 - val_loss: 0.5256 - val_accuracy: 0.8164\n",
      "Epoch 7/10\n",
      "1724/1724 [==============================] - 12s 7ms/step - loss: 0.4965 - accuracy: 0.8258 - val_loss: 0.5220 - val_accuracy: 0.8193\n",
      "Epoch 8/10\n",
      "1724/1724 [==============================] - 12s 7ms/step - loss: 0.4687 - accuracy: 0.8356 - val_loss: 0.4453 - val_accuracy: 0.8460\n",
      "Epoch 9/10\n",
      "1724/1724 [==============================] - 12s 7ms/step - loss: 0.4501 - accuracy: 0.8420 - val_loss: 0.4694 - val_accuracy: 0.8387\n",
      "Epoch 10/10\n",
      "1724/1724 [==============================] - 12s 7ms/step - loss: 0.4267 - accuracy: 0.8503 - val_loss: 0.4250 - val_accuracy: 0.8519\n",
      "Model Prediction:\n",
      "1/1 [==============================] - 0s 394ms/step\n",
      "new jersey est relaxant calme en mois automne et il est neigeux est avril <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD>\n",
      "French Translation (Ground Truth):\n",
      "[\"new jersey est parfois calme pendant l' automne , et il est neigeux en avril .\"]\n",
      "English Text:\n",
      "['new jersey is sometimes quiet during autumn , and it is snowy in april .']\n"
     ]
    }
   ],
   "source": [
    "def bd_model(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):\n",
    "    \"\"\"\n",
    "    Build and train a bidirectional RNN model on x and y\n",
    "    :param input_shape: Tuple of input shape\n",
    "    :param output_sequence_length: Length of output sequence\n",
    "    :param english_vocab_size: Number of unique English words in the dataset\n",
    "    :param french_vocab_size: Number of unique French words in the dataset\n",
    "    :return: Keras model built, but not trained\n",
    "    \"\"\"\n",
    "    # TODO: Implement\n",
    "    learning_rate = 1e-3\n",
    "    gru_size=512\n",
    "\n",
    "    input_seq = Input(input_shape[1:])\n",
    "    \n",
    "    bd = Bidirectional(GRU(gru_size, return_sequences=True))(input_seq)\n",
    "    \n",
    "    logits = TimeDistributed(Dense(french_vocab_size))(bd)\n",
    "\n",
    "    model = Model(input_seq, Activation('softmax')(logits))\n",
    "    \n",
    "    model.compile(loss=sparse_categorical_crossentropy,\n",
    "                  optimizer=Adam(learning_rate),\n",
    "                  metrics=['accuracy'])\n",
    "    \n",
    "    return model\n",
    "\n",
    "# TODO: Train and Print prediction(s)\n",
    "\n",
    "tmp_x = pad(preproc_english_sentences, max_french_sequence_length)\n",
    "tmp_x = tmp_x.reshape((-1, preproc_french_sentences.shape[-2], 1))\n",
    "\n",
    "bd_rnn_model = bd_model(\n",
    "    tmp_x.shape,\n",
    "    max_french_sequence_length,\n",
    "    english_vocab_size+1,\n",
    "    french_vocab_size+1)\n",
    "\n",
    "bd_rnn_history=bd_rnn_model.fit(tmp_x, preproc_french_sentences, batch_size=64, epochs=10, validation_split=0.2)\n",
    "\n",
    "print('Model Prediction:')\n",
    "print(logits_to_text(bd_rnn_model.predict(tmp_x[:1])[0], french_tokenizer))\n",
    "\n",
    "print('French Translation (Ground Truth):')\n",
    "print(french_sentences[:1])\n",
    "\n",
    "print('English Text:')\n",
    "print(english_sentences[:1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotting_results(bd_rnn_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 4: Encoder-Decoder (IMPLEMENTATION)\n",
    "Time to look at encoder-decoder models.  This model is made up of an encoder and decoder. The encoder creates a matrix representation of the sentence.  The decoder takes this matrix as input and predicts the translation as output.\n",
    "\n",
    "Create an encoder-decoder model in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "1724/1724 [==============================] - 15s 8ms/step - loss: 1.4762 - accuracy: 0.6040 - val_loss: 1.1435 - val_accuracy: 0.6581\n",
      "Epoch 2/10\n",
      "1724/1724 [==============================] - 13s 8ms/step - loss: 1.0592 - accuracy: 0.6714 - val_loss: 1.0159 - val_accuracy: 0.6712\n",
      "Epoch 3/10\n",
      "1724/1724 [==============================] - 13s 8ms/step - loss: 0.8533 - accuracy: 0.7191 - val_loss: 0.7462 - val_accuracy: 0.7491\n",
      "Epoch 4/10\n",
      "1724/1724 [==============================] - 15s 9ms/step - loss: 0.6923 - accuracy: 0.7583 - val_loss: 0.6356 - val_accuracy: 0.7723\n",
      "Epoch 5/10\n",
      "1724/1724 [==============================] - 16s 9ms/step - loss: 0.6121 - accuracy: 0.7801 - val_loss: 0.5641 - val_accuracy: 0.7974\n",
      "Epoch 6/10\n",
      "1724/1724 [==============================] - 15s 9ms/step - loss: 0.5583 - accuracy: 0.7980 - val_loss: 0.5239 - val_accuracy: 0.8081\n",
      "Epoch 7/10\n",
      "1724/1724 [==============================] - 15s 9ms/step - loss: 0.5137 - accuracy: 0.8123 - val_loss: 0.4442 - val_accuracy: 0.8360\n",
      "Epoch 8/10\n",
      "1724/1724 [==============================] - 15s 9ms/step - loss: 0.4699 - accuracy: 0.8265 - val_loss: 0.4513 - val_accuracy: 0.8340\n",
      "Epoch 9/10\n",
      "1724/1724 [==============================] - 15s 9ms/step - loss: 0.4588 - accuracy: 0.8303 - val_loss: 0.4067 - val_accuracy: 0.8571\n",
      "Epoch 10/10\n",
      "1724/1724 [==============================] - 16s 9ms/step - loss: 0.4465 - accuracy: 0.8364 - val_loss: 0.4162 - val_accuracy: 0.8476\n",
      "Model Prediction:\n",
      "1/1 [==============================] - 0s 352ms/step\n",
      "new jersey est parfois calme au cours de et automne et en avril avril <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD>\n",
      "French Translation (Ground Truth):\n",
      "[\"new jersey est parfois calme pendant l' automne , et il est neigeux en avril .\"]\n",
      "English Text:\n",
      "['new jersey is sometimes quiet during autumn , and it is snowy in april .']\n"
     ]
    }
   ],
   "source": [
    "def encdec_model(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):\n",
    "    \"\"\"\n",
    "    Build and train an encoder-decoder model on x and y\n",
    "    :param input_shape: Tuple of input shape\n",
    "    :param output_sequence_length: Length of output sequence\n",
    "    :param english_vocab_size: Number of unique English words in the dataset\n",
    "    :param french_vocab_size: Number of unique French words in the dataset\n",
    "    :return: Keras model built, but not trained\n",
    "    \"\"\"\n",
    "    # TODO: Implement\n",
    "    learning_rate = 1e-3\n",
    "    gru_size=512\n",
    "    rp=21\n",
    "    \n",
    "    input_seq = Input(input_shape[1:])\n",
    "    \n",
    "    rnn = GRU(gru_size)(input_seq)\n",
    "    \n",
    "    rpvect = RepeatVector(rp)(rnn)\n",
    "    \n",
    "    decoder = GRU(gru_size, return_sequences=True)(rpvect)\n",
    "    \n",
    "    logits = TimeDistributed(Dense(french_vocab_size, activation='softmax'))(decoder)\n",
    "    \n",
    "    model = Model(inputs = input_seq, outputs = logits)\n",
    "    \n",
    "    model.compile(loss=sparse_categorical_crossentropy,\n",
    "                  optimizer=Adam(learning_rate),\n",
    "                  metrics=['accuracy'])\n",
    "    \n",
    "    return model\n",
    "\n",
    "# TODO: Train and Print prediction(s)\n",
    "tmp_x = pad(preproc_english_sentences, max_french_sequence_length)\n",
    "tmp_x = tmp_x.reshape((-1, preproc_french_sentences.shape[-2], 1))\n",
    "\n",
    "encdec_rnn_model = encdec_model(\n",
    "    tmp_x.shape,\n",
    "    max_french_sequence_length,\n",
    "    english_vocab_size+1,\n",
    "    french_vocab_size+1)\n",
    "\n",
    "encdec_rnn_history=encdec_rnn_model.fit(tmp_x, preproc_french_sentences, batch_size=64, epochs=10, validation_split=0.2)\n",
    "\n",
    "print('Model Prediction:')\n",
    "print(logits_to_text(encdec_rnn_model.predict(tmp_x[:1])[0], french_tokenizer))\n",
    "\n",
    "print('French Translation (Ground Truth):')\n",
    "print(french_sentences[:1])\n",
    "\n",
    "print('English Text:')\n",
    "print(english_sentences[:1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotting_results(encdec_rnn_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 5: Custom (IMPLEMENTATION)\n",
    "Use everything you learned from the previous models to create a model that incorporates embedding and a bidirectional rnn into one model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Model Loaded\n",
      "Epoch 1/10\n",
      "1724/1724 [==============================] - 50s 26ms/step - loss: 0.8831 - accuracy: 0.7618 - val_loss: 0.3328 - val_accuracy: 0.8977\n",
      "Epoch 2/10\n",
      "1724/1724 [==============================] - 44s 26ms/step - loss: 0.2146 - accuracy: 0.9333 - val_loss: 0.1547 - val_accuracy: 0.9516\n",
      "Epoch 3/10\n",
      "1724/1724 [==============================] - 44s 26ms/step - loss: 0.1354 - accuracy: 0.9578 - val_loss: 0.1203 - val_accuracy: 0.9637\n",
      "Epoch 4/10\n",
      "1724/1724 [==============================] - 44s 26ms/step - loss: 0.1068 - accuracy: 0.9669 - val_loss: 0.1074 - val_accuracy: 0.9675\n",
      "Epoch 5/10\n",
      "1724/1724 [==============================] - 44s 26ms/step - loss: 0.0907 - accuracy: 0.9723 - val_loss: 0.1026 - val_accuracy: 0.9698\n",
      "Epoch 6/10\n",
      "1724/1724 [==============================] - 45s 26ms/step - loss: 0.0780 - accuracy: 0.9761 - val_loss: 0.0935 - val_accuracy: 0.9721\n",
      "Epoch 7/10\n",
      "1724/1724 [==============================] - 45s 26ms/step - loss: 0.0731 - accuracy: 0.9778 - val_loss: 0.0873 - val_accuracy: 0.9750\n",
      "Epoch 8/10\n",
      "1724/1724 [==============================] - 45s 26ms/step - loss: 0.0726 - accuracy: 0.9781 - val_loss: 0.0975 - val_accuracy: 0.9720\n",
      "Epoch 9/10\n",
      "1724/1724 [==============================] - 44s 25ms/step - loss: 0.0646 - accuracy: 0.9804 - val_loss: 0.0889 - val_accuracy: 0.9745\n",
      "Epoch 10/10\n",
      "1724/1724 [==============================] - 44s 25ms/step - loss: 0.0570 - accuracy: 0.9827 - val_loss: 0.0811 - val_accuracy: 0.9780\n",
      "Model Prediction:\n",
      "WARNING:tensorflow:5 out of the last 5 calls to <function Model.make_predict_function.<locals>.predict_function at 0x000001EE145B3550> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 1s 1s/step\n",
      "new jersey est parfois calme pendant l' automne et il est neigeux en avril <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD>\n",
      "French Translation (Ground Truth):\n",
      "[\"new jersey est parfois calme pendant l' automne , et il est neigeux en avril .\"]\n",
      "English Text:\n",
      "['new jersey is sometimes quiet during autumn , and it is snowy in april .']\n"
     ]
    }
   ],
   "source": [
    "def model_final(input_shape, output_sequence_length, english_vocab_size, french_vocab_size):\n",
    "    \"\"\"\n",
    "    Build and train a model that incorporates embedding, encoder-decoder, and bidirectional RNN on x and y\n",
    "    :param input_shape: Tuple of input shape\n",
    "    :param output_sequence_length: Length of output sequence\n",
    "    :param english_vocab_size: Number of unique English words in the dataset\n",
    "    :param french_vocab_size: Number of unique French words in the dataset\n",
    "    :return: Keras model built, but not trained\n",
    "    \"\"\"\n",
    "    # TODO: Implement\n",
    "    learning_rate = 1e-3\n",
    "    embedding_dim = 64\n",
    "    gru_size=512\n",
    "    rp=21\n",
    "    \n",
    "    input_seq = Input(shape=(input_shape[1:]))\n",
    "    \n",
    "    embedding = Embedding(english_vocab_size, embedding_dim)(input_seq)\n",
    "    \n",
    "    rnn1 = Bidirectional(GRU(gru_size, return_sequences=True))(embedding)\n",
    "    \n",
    "    rnn2 = Bidirectional(GRU(gru_size))(rnn1)\n",
    "    \n",
    "    rpvect = RepeatVector(rp)(rnn2)\n",
    "\n",
    "    decoder = Bidirectional(GRU(gru_size, return_sequences=True))(rpvect)\n",
    "    \n",
    "    logits = TimeDistributed(Dense(french_vocab_size, activation='softmax'))(decoder)\n",
    "    \n",
    "    model = Model(inputs = input_seq, outputs = logits)\n",
    "    \n",
    "    model.compile(loss=sparse_categorical_crossentropy,\n",
    "                  optimizer=Adam(learning_rate),\n",
    "                  metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "\n",
    "print('Final Model Loaded')\n",
    "# TODO: Train the final model\n",
    "tmp_x = pad(preproc_english_sentences, max_french_sequence_length)\n",
    "tmp_x = tmp_x.reshape((-1, preproc_french_sentences.shape[-2]))\n",
    "\n",
    "final_rnn_model = model_final(\n",
    "    tmp_x.shape,\n",
    "    max_french_sequence_length,\n",
    "    english_vocab_size+1,\n",
    "    french_vocab_size+1)\n",
    "\n",
    "final_rnn_history=final_rnn_model.fit(tmp_x, preproc_french_sentences, batch_size=64, epochs=10, validation_split=0.2)\n",
    "\n",
    "\n",
    "print('Model Prediction:')\n",
    "print(logits_to_text(final_rnn_model.predict(tmp_x[:1])[0], french_tokenizer))\n",
    "\n",
    "print('French Translation (Ground Truth):')\n",
    "print(french_sentences[:1])\n",
    "\n",
    "print('English Text:')\n",
    "print(english_sentences[:1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotting_results(final_rnn_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction (IMPLEMENTATION)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "1724/1724 [==============================] - 44s 23ms/step - loss: 0.8677 - accuracy: 0.7672 - val_loss: 0.2703 - val_accuracy: 0.9161\n",
      "Epoch 2/10\n",
      "1724/1724 [==============================] - 39s 23ms/step - loss: 0.1950 - accuracy: 0.9397 - val_loss: 0.1619 - val_accuracy: 0.9497\n",
      "Epoch 3/10\n",
      "1724/1724 [==============================] - 39s 23ms/step - loss: 0.1280 - accuracy: 0.9602 - val_loss: 0.1129 - val_accuracy: 0.9653\n",
      "Epoch 4/10\n",
      "1724/1724 [==============================] - 40s 23ms/step - loss: 0.1008 - accuracy: 0.9688 - val_loss: 0.1017 - val_accuracy: 0.9695\n",
      "Epoch 5/10\n",
      "1724/1724 [==============================] - 40s 23ms/step - loss: 0.0887 - accuracy: 0.9728 - val_loss: 0.0954 - val_accuracy: 0.9716\n",
      "Epoch 6/10\n",
      "1724/1724 [==============================] - 39s 23ms/step - loss: 0.0775 - accuracy: 0.9761 - val_loss: 0.1044 - val_accuracy: 0.9693\n",
      "Epoch 7/10\n",
      "1724/1724 [==============================] - 39s 23ms/step - loss: 0.0708 - accuracy: 0.9783 - val_loss: 0.0807 - val_accuracy: 0.9768\n",
      "Epoch 8/10\n",
      "1724/1724 [==============================] - 39s 23ms/step - loss: 0.0699 - accuracy: 0.9787 - val_loss: 0.1010 - val_accuracy: 0.9723\n",
      "Epoch 9/10\n",
      "1724/1724 [==============================] - 40s 23ms/step - loss: 0.0598 - accuracy: 0.9818 - val_loss: 0.1002 - val_accuracy: 0.9727\n",
      "Epoch 10/10\n",
      "1724/1724 [==============================] - 40s 23ms/step - loss: 0.0576 - accuracy: 0.9825 - val_loss: 0.0949 - val_accuracy: 0.9737\n",
      "WARNING:tensorflow:6 out of the last 6 calls to <function Model.make_predict_function.<locals>.predict_function at 0x000001F0508FE040> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 1s 1s/step\n",
      "Sample 1:\n",
      "il a vu un vieux camion jaune <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD>\n",
      "Il a vu un vieux camion jaune\n",
      "Sample 2:\n",
      "new jersey est parfois calme pendant l' automne et est est en en <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD>\n",
      "new jersey est parfois calme pendant l' automne et il est neigeux en avril <PAD> <PAD> <PAD> <PAD> <PAD> <PAD> <PAD>\n"
     ]
    }
   ],
   "source": [
    "def final_predictions(x, y, x_tk, y_tk):\n",
    "    \"\"\"\n",
    "    Gets predictions using the final model\n",
    "    :param x: Preprocessed English data\n",
    "    :param y: Preprocessed French data\n",
    "    :param x_tk: English tokenizer\n",
    "    :param y_tk: French tokenizer\n",
    "    \"\"\"\n",
    "    # TODO: Train neural network using model_final\n",
    "\n",
    "    model = model_final(\n",
    "        x.shape,\n",
    "        y.shape[1],\n",
    "        len(x_tk.word_index)+1,\n",
    "        len(y_tk.word_index)+1)\n",
    "    \n",
    "\n",
    "    model.fit(x, y, batch_size=64, epochs=10, validation_split=0.2)\n",
    "    \n",
    "    ## DON'T EDIT ANYTHING BELOW THIS LINE\n",
    "    y_id_to_word = {value: key for key, value in y_tk.word_index.items()}\n",
    "    y_id_to_word[0] = '<PAD>'\n",
    "\n",
    "    sentence = 'he saw a old yellow truck'\n",
    "    sentence = [x_tk.word_index[word] for word in sentence.split()]\n",
    "    sentence = pad_sequences([sentence], maxlen=x.shape[-1], padding='post')\n",
    "    sentences = np.array([sentence[0], x[0]])\n",
    "    predictions = model.predict(sentences, len(sentences))\n",
    "\n",
    "    print('Sample 1:')\n",
    "    print(' '.join([y_id_to_word[np.argmax(x)] for x in predictions[0]]))\n",
    "    print('Il a vu un vieux camion jaune')\n",
    "    print('Sample 2:')\n",
    "    print(' '.join([y_id_to_word[np.argmax(x)] for x in predictions[1]]))\n",
    "    print(' '.join([y_id_to_word[np.max(x)] for x in y[0]]))\n",
    "\n",
    "\n",
    "final_predictions(preproc_english_sentences, preproc_french_sentences, english_tokenizer, french_tokenizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optional Enhancements\n",
    "\n",
    "This project focuses on learning various network architectures for machine translation, but we don't evaluate the models according to best practices by splitting the data into separate test & training sets -- so the model accuracy is overstated. Use the [`sklearn.model_selection.train_test_split()`](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) function to create separate training & test datasets, then retrain each of the models using only the training set and evaluate the prediction accuracy using the hold out test set. Does the \"best\" model change?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}