lstm_peotry_generator.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bFWbEb6uGbN-"
      },
      "source": [
        "# Week 4: Predicting the next word\n",
        "\n",
        "Welcome to this assignment! During this week you saw how to create a model that will predict the next word in a text sequence, now you will implement such model and train it using a corpus of Shakespeare's sonnets, while also creating some helper functions to pre-process the data.\n",
        "\n",
        "\n",
        "Let's get started!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "BOwsuGQQY9OL",
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "import numpy as np \n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.utils import to_categorical \n",
        "from tensorflow.keras.preprocessing.text import Tokenizer\n",
        "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
        "from tensorflow.keras.layers import Embedding, LSTM, Dense, Bidirectional\n",
        "from tensorflow.keras.optimizers import Adam"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BTxqlHqKHzhr"
      },
      "source": [
        "For this assignment you will be using the [Shakespeare Sonnets Dataset](https://www.opensourceshakespeare.org/views/sonnets/sonnet_view.php?range=viewrange&sonnetrange1=1&sonnetrange2=154), which contains more than 2000 lines of text extracted from Shakespeare's sonnets."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "WZ4qOUzujMP6",
        "tags": [
          "graded"
        ],
        "outputId": "a50ee521-591a-4540-e15a-504f053f75e6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/gdown/cli.py:131: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n",
            "  category=FutureWarning,\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=108jAePKK4R3BVYBbYJZ32JWUwxeMg20K\n",
            "To: /content/sonnets.txt\n",
            "100% 93.6k/93.6k [00:00<00:00, 82.8MB/s]\n"
          ]
        }
      ],
      "source": [
        "# sonnets.txt\n",
        "!gdown --id 108jAePKK4R3BVYBbYJZ32JWUwxeMg20K"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "Pfd-nYKij5yY",
        "tags": [
          "graded"
        ],
        "outputId": "8e69822b-1138-4fad-d639-cc086699a2f6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 2159 lines of sonnets\n",
            "\n",
            "The first 5 lines look like this:\n",
            "\n",
            "from fairest creatures we desire increase,\n",
            "that thereby beauty's rose might never die,\n",
            "but as the riper should by time decease,\n",
            "his tender heir might bear his memory:\n",
            "but thou, contracted to thine own bright eyes,\n"
          ]
        }
      ],
      "source": [
        "# Define path for file with sonnets\n",
        "SONNETS_FILE = './sonnets.txt'\n",
        "\n",
        "# Read the data\n",
        "with open('./sonnets.txt') as f:\n",
        "    data = f.read()\n",
        "\n",
        "# Convert to lower case and save as a list\n",
        "corpus = data.lower().split(\"\\n\")\n",
        "\n",
        "print(f\"There are {len(corpus)} lines of sonnets\\n\")\n",
        "print(f\"The first 5 lines look like this:\\n\")\n",
        "for i in range(5):\n",
        "  print(corpus[i])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "imB15zrSNhA1"
      },
      "source": [
        "## Tokenizing the text\n",
        "\n",
        "Now fit the Tokenizer to the corpus and save the total number of words."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "AAhM_qAZk0o5",
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "tokenizer = Tokenizer()\n",
        "tokenizer.fit_on_texts(corpus)\n",
        "total_words = len(tokenizer.word_index) + 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "77-0sA46OETa"
      },
      "source": [
        "When converting the text into sequences you can use the `texts_to_sequences` method as you have done throughout this course.\n",
        "\n",
        "In the next graded function you will need to process this corpus one line at a time. Given this, it is important to keep in mind that the way you are feeding the data unto this method affects the result. Check the following example to make this clearer.\n",
        "\n",
        "The first example of the corpus is a string and looks like this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "tqhPxdeXlfjh",
        "tags": [
          "graded"
        ],
        "outputId": "8e5397ad-65c5-42b3-be2f-2ccfc9bf07e6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'from fairest creatures we desire increase,'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "corpus[0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XFMP4z11O3os"
      },
      "source": [
        "If you pass this text directly into the `texts_to_sequences` method you will get an unexpected result:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "EMSEhmbzNZCE",
        "tags": [
          "graded"
        ],
        "outputId": "e65b5b34-60c3-4068-972d-e83d07e991a1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[],\n",
              " [],\n",
              " [58],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [17],\n",
              " [6],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [17],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [6],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [6],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [],\n",
              " [17],\n",
              " [],\n",
              " [],\n",
              " []]"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "tokenizer.texts_to_sequences(corpus[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pPZmZtpEPEeI"
      },
      "source": [
        "This happened because `texts_to_sequences` expects a list and you are providing a string. However a string is still and `iterable` in Python so you will get the word index of every character in the string.\n",
        "\n",
        "Instead you need to place the example whithin a list before passing it to the method:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "Qmgo-vXhk4nd",
        "tags": [
          "graded"
        ],
        "outputId": "0b9e36c7-c961-472c-bd5a-490cc977a60e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[34, 417, 877, 166, 213, 517]]"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "tokenizer.texts_to_sequences([corpus[0]])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0DU7wK-eQ5dc"
      },
      "source": [
        "Notice that you received the sequence wrapped inside a list so in order to get only the desired sequence you need to explicitly get the first item in the list like this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "kpTy8WmIQ57P",
        "tags": [
          "graded"
        ],
        "outputId": "f4afcac1-3265-4527-de22-e9be881bb493",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[34, 417, 877, 166, 213, 517]"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "tokenizer.texts_to_sequences([corpus[0]])[0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-oqy9KjXRJ9A"
      },
      "source": [
        "## Generating n_grams\n",
        "\n",
        "Now complete the `n_gram_seqs` function below. This function receives the fitted tokenizer and the corpus (which is a list of strings) and should return a list containing the `n_gram` sequences for each line in the corpus:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "iy4baJMDl6kj",
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: n_gram_seqs\n",
        "def n_gram_seqs(corpus, tokenizer):\n",
        "    \"\"\"\n",
        "    Generates a list of n-gram sequences\n",
        "    \n",
        "    Args:\n",
        "        corpus (list of string): lines of texts to generate n-grams for\n",
        "        tokenizer (object): an instance of the Tokenizer class containing the word-index dictionary\n",
        "    \n",
        "    Returns:\n",
        "        input_sequences (list of int): the n-gram sequences for each line in the corpus\n",
        "    \"\"\"\n",
        "    input_sequences = []\n",
        "    \n",
        "    ### START CODE HERE\n",
        "    # Loop over every line\n",
        "    for line in corpus:\n",
        "\n",
        "      # Tokenize the current line\n",
        "      token_list = tokenizer.texts_to_sequences([line])[0]\n",
        "\n",
        "      # Loop over the line several times to generate the subphrases\n",
        "      for i in range(1, len(token_list)):\n",
        "        \n",
        "        # Generate the subphrase\n",
        "        n_gram_sequence = token_list[:i+1]\n",
        "\n",
        "        # Append the subphrase to the sequences list\n",
        "        input_sequences.append(n_gram_sequence)\n",
        "    ### END CODE HERE\n",
        "    \n",
        "    return input_sequences"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "DlKqW2pfM7G3",
        "tags": [
          "graded"
        ],
        "outputId": "3b14a808-f83b-4338-c528-0bd3257a9523",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_gram sequences for first example look like this:\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[34, 417],\n",
              " [34, 417, 877],\n",
              " [34, 417, 877, 166],\n",
              " [34, 417, 877, 166, 213],\n",
              " [34, 417, 877, 166, 213, 517]]"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "# Test your function with one example\n",
        "first_example_sequence = n_gram_seqs([corpus[0]], tokenizer)\n",
        "\n",
        "print(\"n_gram sequences for first example look like this:\\n\")\n",
        "first_example_sequence"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0HL8Ug6UU0Jt"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "n_gram sequences for first example look like this:\n",
        "\n",
        "[[34, 417],\n",
        " [34, 417, 877],\n",
        " [34, 417, 877, 166],\n",
        " [34, 417, 877, 166, 213],\n",
        " [34, 417, 877, 166, 213, 517]]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "wtPpCcBjNc4c",
        "tags": [
          "graded"
        ],
        "outputId": "9dd84f5a-845c-481d-de03-6cfd6fb68095",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_gram sequences for next 3 examples look like this:\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[8, 878],\n",
              " [8, 878, 134],\n",
              " [8, 878, 134, 351],\n",
              " [8, 878, 134, 351, 102],\n",
              " [8, 878, 134, 351, 102, 156],\n",
              " [8, 878, 134, 351, 102, 156, 199],\n",
              " [16, 22],\n",
              " [16, 22, 2],\n",
              " [16, 22, 2, 879],\n",
              " [16, 22, 2, 879, 61],\n",
              " [16, 22, 2, 879, 61, 30],\n",
              " [16, 22, 2, 879, 61, 30, 48],\n",
              " [16, 22, 2, 879, 61, 30, 48, 634],\n",
              " [25, 311],\n",
              " [25, 311, 635],\n",
              " [25, 311, 635, 102],\n",
              " [25, 311, 635, 102, 200],\n",
              " [25, 311, 635, 102, 200, 25],\n",
              " [25, 311, 635, 102, 200, 25, 278]]"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "# Test your function with a bigger corpus\n",
        "next_3_examples_sequence = n_gram_seqs(corpus[1:4], tokenizer)\n",
        "\n",
        "print(\"n_gram sequences for next 3 examples look like this:\\n\")\n",
        "next_3_examples_sequence"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EIzecMczU9UB"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "n_gram sequences for next 3 examples look like this:\n",
        "\n",
        "[[8, 878],\n",
        " [8, 878, 134],\n",
        " [8, 878, 134, 351],\n",
        " [8, 878, 134, 351, 102],\n",
        " [8, 878, 134, 351, 102, 156],\n",
        " [8, 878, 134, 351, 102, 156, 199],\n",
        " [16, 22],\n",
        " [16, 22, 2],\n",
        " [16, 22, 2, 879],\n",
        " [16, 22, 2, 879, 61],\n",
        " [16, 22, 2, 879, 61, 30],\n",
        " [16, 22, 2, 879, 61, 30, 48],\n",
        " [16, 22, 2, 879, 61, 30, 48, 634],\n",
        " [25, 311],\n",
        " [25, 311, 635],\n",
        " [25, 311, 635, 102],\n",
        " [25, 311, 635, 102, 200],\n",
        " [25, 311, 635, 102, 200, 25],\n",
        " [25, 311, 635, 102, 200, 25, 278]]\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dx3V_RjFWQSu"
      },
      "source": [
        "Apply the `n_gram_seqs` transformation to the whole corpus and save the maximum sequence length to use it later:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "laMwiRUpmuSd",
        "tags": [
          "graded"
        ],
        "outputId": "4890c9ea-ba34-4847-af30-24481101b383",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n_grams of input_sequences have length: 15462\n",
            "maximum length of sequences is: 11\n"
          ]
        }
      ],
      "source": [
        "# Apply the n_gram_seqs transformation to the whole corpus\n",
        "input_sequences = n_gram_seqs(corpus, tokenizer)\n",
        "\n",
        "# Save max length \n",
        "max_sequence_len = max([len(x) for x in input_sequences])\n",
        "\n",
        "print(f\"n_grams of input_sequences have length: {len(input_sequences)}\")\n",
        "print(f\"maximum length of sequences is: {max_sequence_len}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2OciMdmEdE9L"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "n_grams of input_sequences have length: 15462\n",
        "maximum length of sequences is: 11\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zHY7HroqWq12"
      },
      "source": [
        "## Add padding to the sequences\n",
        "\n",
        "Now code the `pad_seqs` function which will pad any given sequences to the desired maximum length. Notice that this function receives a list of sequences and should return a numpy array with the padded sequences: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "cellView": "code",
        "id": "WW1-qAZaWOhC",
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: pad_seqs\n",
        "def pad_seqs(input_sequences, maxlen):\n",
        "    \"\"\"\n",
        "    Pads tokenized sequences to the same length\n",
        "    \n",
        "    Args:\n",
        "        input_sequences (list of int): tokenized sequences to pad\n",
        "        maxlen (int): maximum length of the token sequences\n",
        "    \n",
        "    Returns:\n",
        "        padded_sequences (array of int): tokenized sequences padded to the same length\n",
        "    \"\"\"\n",
        "    ### START CODE HERE\n",
        "\n",
        "    # Pad all sequences\n",
        "    padded_sequences = np.array(pad_sequences(input_sequences, maxlen=maxlen, padding='pre'))\n",
        "\n",
        "    return padded_sequences\n",
        "    ### END CODE HERE"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "IqVQ0pb3YHLr",
        "tags": [
          "graded"
        ],
        "outputId": "9db78e10-6336-42de-b77c-aec5f5b73476",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[  0,   0,   0,  34, 417],\n",
              "       [  0,   0,  34, 417, 877],\n",
              "       [  0,  34, 417, 877, 166],\n",
              "       [ 34, 417, 877, 166, 213],\n",
              "       [417, 877, 166, 213, 517]], dtype=int32)"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ],
      "source": [
        "# Test your function with the n_grams_seq of the first example\n",
        "first_padded_seq = pad_seqs(first_example_sequence, len(first_example_sequence))\n",
        "first_padded_seq"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Re_avDznXRnU"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "array([[  0,   0,   0,  34, 417],\n",
        "       [  0,   0,  34, 417, 877],\n",
        "       [  0,  34, 417, 877, 166],\n",
        "       [ 34, 417, 877, 166, 213],\n",
        "       [417, 877, 166, 213, 517]], dtype=int32)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "j56_UCOBYzZt",
        "tags": [
          "graded"
        ],
        "outputId": "0780e046-8d08-4d70-af9c-1ffb5c766c5a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[  0,   0,   0,   0,   0,   0,   8, 878],\n",
              "       [  0,   0,   0,   0,   0,   8, 878, 134],\n",
              "       [  0,   0,   0,   0,   8, 878, 134, 351],\n",
              "       [  0,   0,   0,   8, 878, 134, 351, 102],\n",
              "       [  0,   0,   8, 878, 134, 351, 102, 156],\n",
              "       [  0,   8, 878, 134, 351, 102, 156, 199],\n",
              "       [  0,   0,   0,   0,   0,   0,  16,  22],\n",
              "       [  0,   0,   0,   0,   0,  16,  22,   2],\n",
              "       [  0,   0,   0,   0,  16,  22,   2, 879],\n",
              "       [  0,   0,   0,  16,  22,   2, 879,  61],\n",
              "       [  0,   0,  16,  22,   2, 879,  61,  30],\n",
              "       [  0,  16,  22,   2, 879,  61,  30,  48],\n",
              "       [ 16,  22,   2, 879,  61,  30,  48, 634],\n",
              "       [  0,   0,   0,   0,   0,   0,  25, 311],\n",
              "       [  0,   0,   0,   0,   0,  25, 311, 635],\n",
              "       [  0,   0,   0,   0,  25, 311, 635, 102],\n",
              "       [  0,   0,   0,  25, 311, 635, 102, 200],\n",
              "       [  0,   0,  25, 311, 635, 102, 200,  25],\n",
              "       [  0,  25, 311, 635, 102, 200,  25, 278]], dtype=int32)"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ],
      "source": [
        "# Test your function with the n_grams_seq of the next 3 examples\n",
        "next_3_padded_seq = pad_seqs(next_3_examples_sequence, max([len(s) for s in next_3_examples_sequence]))\n",
        "next_3_padded_seq"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3rmcDluOXcIU"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "array([[  0,   0,   0,   0,   0,   0,   8, 878],\n",
        "       [  0,   0,   0,   0,   0,   8, 878, 134],\n",
        "       [  0,   0,   0,   0,   8, 878, 134, 351],\n",
        "       [  0,   0,   0,   8, 878, 134, 351, 102],\n",
        "       [  0,   0,   8, 878, 134, 351, 102, 156],\n",
        "       [  0,   8, 878, 134, 351, 102, 156, 199],\n",
        "       [  0,   0,   0,   0,   0,   0,  16,  22],\n",
        "       [  0,   0,   0,   0,   0,  16,  22,   2],\n",
        "       [  0,   0,   0,   0,  16,  22,   2, 879],\n",
        "       [  0,   0,   0,  16,  22,   2, 879,  61],\n",
        "       [  0,   0,  16,  22,   2, 879,  61,  30],\n",
        "       [  0,  16,  22,   2, 879,  61,  30,  48],\n",
        "       [ 16,  22,   2, 879,  61,  30,  48, 634],\n",
        "       [  0,   0,   0,   0,   0,   0,  25, 311],\n",
        "       [  0,   0,   0,   0,   0,  25, 311, 635],\n",
        "       [  0,   0,   0,   0,  25, 311, 635, 102],\n",
        "       [  0,   0,   0,  25, 311, 635, 102, 200],\n",
        "       [  0,   0,  25, 311, 635, 102, 200,  25],\n",
        "       [  0,  25, 311, 635, 102, 200,  25, 278]], dtype=int32)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "rgK-Q_micEYA",
        "tags": [
          "graded"
        ],
        "outputId": "23b8320c-db90-4823-b4fd-741acbc27e02",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "padded corpus has shape: (15462, 11)\n"
          ]
        }
      ],
      "source": [
        "# Pad the whole corpus\n",
        "input_sequences = pad_seqs(input_sequences, max_sequence_len)\n",
        "\n",
        "print(f\"padded corpus has shape: {input_sequences.shape}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "59RD1YYNc7CW"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "padded corpus has shape: (15462, 11)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZbOidyPrXxf7"
      },
      "source": [
        "## Split the data into features and labels\n",
        "\n",
        "Before feeding the data into the neural network you should split it into features and labels. In this case the features will be the padded n_gram sequences with the last word removed from them and the labels will be the removed word.\n",
        "\n",
        "Complete the `features_and_labels` function below. This function expects the padded n_gram sequences as input and should return a tuple containing the features and the one hot encoded labels.\n",
        "\n",
        "Notice that the function also receives the total of words in the corpus, this parameter will be very important when one hot enconding the labels since every word in the corpus will be a label at least once. If you need a refresh of how the `to_categorical` function works take a look at the [docs](https://www.tensorflow.org/api_docs/python/tf/keras/utils/to_categorical)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "cellView": "code",
        "id": "9WGGbYdnZdmJ",
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: features_and_labels\n",
        "def features_and_labels(input_sequences, total_words):\n",
        "    \"\"\"\n",
        "    Generates features and labels from n-grams\n",
        "    \n",
        "    Args:\n",
        "        input_sequences (list of int): sequences to split features and labels from\n",
        "        total_words (int): vocabulary size\n",
        "    \n",
        "    Returns:\n",
        "        features, one_hot_labels (array of int, array of int): arrays of features and one-hot encoded labels\n",
        "    \"\"\"\n",
        "    ### START CODE HERE\n",
        "    features = input_sequences[:,:-1]\n",
        "    labels = input_sequences[:,-1]\n",
        "    one_hot_labels = to_categorical(labels, num_classes=total_words)\n",
        "\n",
        "    ### END CODE HERE\n",
        "\n",
        "    return features, one_hot_labels"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "23DolaBRaIAZ",
        "tags": [
          "graded"
        ],
        "outputId": "3ce058fa-429f-4e3c-df97-521c8446e2b8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "labels have shape: (5, 3211)\n",
            "\n",
            "features look like this:\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[  0,   0,   0,  34],\n",
              "       [  0,   0,  34, 417],\n",
              "       [  0,  34, 417, 877],\n",
              "       [ 34, 417, 877, 166],\n",
              "       [417, 877, 166, 213]], dtype=int32)"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ],
      "source": [
        "# Test your function with the padded n_grams_seq of the first example\n",
        "first_features, first_labels = features_and_labels(first_padded_seq, total_words)\n",
        "\n",
        "print(f\"labels have shape: {first_labels.shape}\")\n",
        "print(\"\\nfeatures look like this:\\n\")\n",
        "first_features"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7t4yAx2UaQ43"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "labels have shape: (5, 3211)\n",
        "\n",
        "features look like this:\n",
        "\n",
        "array([[  0,   0,   0,  34],\n",
        "       [  0,   0,  34, 417],\n",
        "       [  0,  34, 417, 877],\n",
        "       [ 34, 417, 877, 166],\n",
        "       [417, 877, 166, 213]], dtype=int32)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "GRTuLEt3bRKa",
        "tags": [
          "graded"
        ],
        "outputId": "cf4a1084-8d02-40b5-ad77-c8d74bf6c113",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "features have shape: (15462, 10)\n",
            "labels have shape: (15462, 3211)\n"
          ]
        }
      ],
      "source": [
        "# Split the whole corpus\n",
        "features, labels = features_and_labels(input_sequences, total_words)\n",
        "\n",
        "print(f\"features have shape: {features.shape}\")\n",
        "print(f\"labels have shape: {labels.shape}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xXSMK_HpdLns"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "features have shape: (15462, 10)\n",
        "labels have shape: (15462, 3211)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ltxaOCE_aU6J"
      },
      "source": [
        "## Create the model\n",
        "\n",
        "Now you should define a model architecture capable of achieving an accuracy of at least 80%.\n",
        "\n",
        "Some hints to help you in this task:\n",
        "\n",
        "- An appropriate `output_dim` for the first layer (Embedding) is 100, this is already provided for you.\n",
        "- A Bidirectional LSTM is helpful for this particular problem.\n",
        "- The last layer should have the same number of units as the total number of words in the corpus and a softmax activation function.\n",
        "- This problem can be solved with only two layers (excluding the Embedding) so try out small architectures first."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "cellView": "code",
        "id": "XrE6kpJFfvRY",
        "tags": [
          "graded"
        ]
      },
      "outputs": [],
      "source": [
        "# GRADED FUNCTION: create_model\n",
        "def create_model(total_words, max_sequence_len):\n",
        "    \"\"\"\n",
        "    Creates a text generator model\n",
        "    \n",
        "    Args:\n",
        "        total_words (int): size of the vocabulary for the Embedding layer input\n",
        "        max_sequence_len (int): length of the input sequences\n",
        "    \n",
        "    Returns:\n",
        "        model (tf.keras Model): the text generator model\n",
        "    \"\"\"\n",
        "    model = Sequential()\n",
        "    ### START CODE HERE\n",
        "    model = Sequential([\n",
        "              Embedding(total_words, 100, input_length=max_sequence_len-1),\n",
        "              Bidirectional(LSTM(150)),\n",
        "              Dense(total_words, activation='softmax')\n",
        "    ])\n",
        "\n",
        "    # Compile the model\n",
        "    model.compile(loss='categorical_crossentropy',\n",
        "                  optimizer='adam',\n",
        "                  metrics=['accuracy'])\n",
        "    \n",
        "    ### END CODE HERE\n",
        "\n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "0IpX_Gu_gISk",
        "tags": [],
        "outputId": "e59a7992-ed69-4f94-ed51-55bebd832784",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n",
            "484/484 [==============================] - 11s 13ms/step - loss: 6.8730 - accuracy: 0.0235\n",
            "Epoch 2/50\n",
            "484/484 [==============================] - 4s 9ms/step - loss: 6.4260 - accuracy: 0.0314\n",
            "Epoch 3/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 6.1830 - accuracy: 0.0413\n",
            "Epoch 4/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 5.9189 - accuracy: 0.0537\n",
            "Epoch 5/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 5.6098 - accuracy: 0.0652\n",
            "Epoch 6/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 5.2671 - accuracy: 0.0763\n",
            "Epoch 7/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 4.8994 - accuracy: 0.0951\n",
            "Epoch 8/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 4.5097 - accuracy: 0.1261\n",
            "Epoch 9/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 4.1098 - accuracy: 0.1693\n",
            "Epoch 10/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 3.7222 - accuracy: 0.2324\n",
            "Epoch 11/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 3.3513 - accuracy: 0.2988\n",
            "Epoch 12/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 3.0156 - accuracy: 0.3598\n",
            "Epoch 13/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 2.7174 - accuracy: 0.4224\n",
            "Epoch 14/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 2.4543 - accuracy: 0.4750\n",
            "Epoch 15/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 2.2256 - accuracy: 0.5233\n",
            "Epoch 16/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 2.0144 - accuracy: 0.5711\n",
            "Epoch 17/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 1.8307 - accuracy: 0.6149\n",
            "Epoch 18/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 1.6594 - accuracy: 0.6523\n",
            "Epoch 19/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 1.5070 - accuracy: 0.6863\n",
            "Epoch 20/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 1.3860 - accuracy: 0.7112\n",
            "Epoch 21/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 1.2656 - accuracy: 0.7379\n",
            "Epoch 22/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 1.1650 - accuracy: 0.7572\n",
            "Epoch 23/50\n",
            "484/484 [==============================] - 4s 9ms/step - loss: 1.0752 - accuracy: 0.7789\n",
            "Epoch 24/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.9986 - accuracy: 0.7943\n",
            "Epoch 25/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.9360 - accuracy: 0.8043\n",
            "Epoch 26/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.8765 - accuracy: 0.8158\n",
            "Epoch 27/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.8321 - accuracy: 0.8215\n",
            "Epoch 28/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.7894 - accuracy: 0.8288\n",
            "Epoch 29/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.7623 - accuracy: 0.8323\n",
            "Epoch 30/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.7336 - accuracy: 0.8357\n",
            "Epoch 31/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.7085 - accuracy: 0.8378\n",
            "Epoch 32/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.6850 - accuracy: 0.8411\n",
            "Epoch 33/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.6679 - accuracy: 0.8443\n",
            "Epoch 34/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.6564 - accuracy: 0.8447\n",
            "Epoch 35/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.6402 - accuracy: 0.8467\n",
            "Epoch 36/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.6319 - accuracy: 0.8464\n",
            "Epoch 37/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.6321 - accuracy: 0.8463\n",
            "Epoch 38/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.6186 - accuracy: 0.8483\n",
            "Epoch 39/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.6071 - accuracy: 0.8482\n",
            "Epoch 40/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5986 - accuracy: 0.8499\n",
            "Epoch 41/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5979 - accuracy: 0.8493\n",
            "Epoch 42/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5966 - accuracy: 0.8462\n",
            "Epoch 43/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5875 - accuracy: 0.8489\n",
            "Epoch 44/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5842 - accuracy: 0.8485\n",
            "Epoch 45/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5906 - accuracy: 0.8471\n",
            "Epoch 46/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5788 - accuracy: 0.8493\n",
            "Epoch 47/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5734 - accuracy: 0.8489\n",
            "Epoch 48/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5699 - accuracy: 0.8495\n",
            "Epoch 49/50\n",
            "484/484 [==============================] - 4s 9ms/step - loss: 0.5642 - accuracy: 0.8507\n",
            "Epoch 50/50\n",
            "484/484 [==============================] - 4s 8ms/step - loss: 0.5660 - accuracy: 0.8484\n"
          ]
        }
      ],
      "source": [
        "# Get the untrained model\n",
        "model = create_model(total_words, max_sequence_len)\n",
        "\n",
        "# Train the model\n",
        "history = model.fit(features, labels, epochs=50, verbose=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gy72RPgly55q"
      },
      "source": [
        "**To pass this assignment, your model should achieve a training accuracy of at least 80%**. If your model didn't achieve this threshold, try training again with a different model architecture, consider increasing the number of unit in your `LSTM` layer."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "1fXTEO3GJ282",
        "tags": [],
        "outputId": "382b58d7-7ecb-4d74-cf3f-4f9aaf6b2473",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Take a look at the training curves of your model\n",
        "\n",
        "acc = history.history['accuracy']\n",
        "loss = history.history['loss']\n",
        "\n",
        "epochs = range(len(acc))\n",
        "\n",
        "plt.plot(epochs, acc, 'b', label='Training accuracy')\n",
        "plt.title('Training accuracy')\n",
        "\n",
        "plt.figure()\n",
        "\n",
        "plt.plot(epochs, loss, 'b', label='Training Loss')\n",
        "plt.title('Training loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OjvED5A3qrn2"
      },
      "source": [
        "Before closing the assignment, be sure to also download the `history.pkl` file which contains the information of the training history of your model and will be used to compute your grade. You can download this file by running the cell below:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "9QRG73l6qE-c",
        "tags": [],
        "outputId": "b6c67870-b842-4c62-a6d7-bf9cfd0986ea",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_67e39883-28dc-4f56-b278-21d9407dc589\", \"history.pkl\", 944)"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "def download_history():\n",
        "  import pickle\n",
        "  from google.colab import files\n",
        "\n",
        "  with open('history.pkl', 'wb') as f:\n",
        "    pickle.dump(history.history, f)\n",
        "\n",
        "  files.download('history.pkl')\n",
        "\n",
        "download_history()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wdsMszk9zBs_"
      },
      "source": [
        "## See your model in action\n",
        "\n",
        "After all your work it is finally time to see your model generating text. \n",
        "\n",
        "Run the cell below to generate the next 100 words of a seed text.\n",
        "\n",
        "After submitting your assignment you are encouraged to try out training for different amounts of epochs and seeing how this affects the coherency of the generated text. Also try changing the seed text to see what you get!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "6Vc6PHgxa6Hm",
        "tags": [],
        "outputId": "9a14d8f8-ff18-4d4b-dda2-d888f8d6e56e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help me Obi Wan Kenobi, you're my only hope be thy worth to sing shows me for me muse thee thy slave i true say good dost one one eyes one praise seen treasure oppress'd to dote composed lie of my true true sight hate ' new old told to one so near pleasure delight new esteem'd seen treasure new ' thy far and soon to thee bright in me one much worse truth ' of my way it fire may be a tomb go bears me bow to stand add to me alone thou art bright grace that still bright more than ' painted shows it still in\n"
          ]
        }
      ],
      "source": [
        "seed_text = \"Help me Obi Wan Kenobi, you're my only hope\"\n",
        "next_words = 100\n",
        "  \n",
        "for _ in range(next_words):\n",
        "\t# Convert the text into sequences\n",
        "\ttoken_list = tokenizer.texts_to_sequences([seed_text])[0]\n",
        "\t# Pad the sequences\n",
        "\ttoken_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')\n",
        "\t# Get the probabilities of predicting a word\n",
        "\tpredicted = model.predict(token_list, verbose=0)\n",
        "\t# Choose the next word based on the maximum probability\n",
        "\tpredicted = np.argmax(predicted, axis=-1).item()\n",
        "\t# Get the actual word from the word index\n",
        "\toutput_word = tokenizer.index_word[predicted]\n",
        "\t# Append to the current text\n",
        "\tseed_text += \" \" + output_word\n",
        "\n",
        "print(seed_text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oQVDbdcYqSux"
      },
      "source": [
        "You will also need to submit this notebook for grading. To download it, click on the File tab in the upper left corner of the screen then click on Download -> Download .ipynb. You can name it anything you want as long as it is a valid .ipynb (jupyter notebook) file.\n",
        "\n",
        "**Congratulations on finishing this week's assignment!**\n",
        "\n",
        "You have successfully implemented a neural network capable of predicting the next word in a sequence of text!\n",
        "\n",
        "**We hope to see you in the next course of the specialization! Keep it up!**"
      ]
    }
  ],
  "metadata": {
    "dlai_version": "1.2.0",
    "accelerator": "GPU",
    "jupytext": {
      "main_language": "python"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "colab": {
      "name": "C3W4_Assignment.ipynb",
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}