060_understanding_recurrent_neural_networks.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.2"
    },
    "colab": {
      "name": "6_2_understanding_recurrent_neural_networks.ipynb",
      "provenance": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kOJaKlSjGf_t"
      },
      "source": [
        "# Understanding Recurrent Neural Networks\n",
        "**Author:** [FarrokhKarimi](https://github.com/farrokhkarimi)  \n",
        "**Note:** For this notebook the best runtime type is GPU"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AAROxx4A9z4L",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "e9c0d70c-3474-4405-a341-f3ba69712adb"
      },
      "source": [
        "import keras\n",
        "keras.__version__"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.8.0'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nARKqd1A9z4V"
      },
      "source": [
        "## A first recurrent layer in Keras\n",
        "\n",
        "The process we just naively implemented in Numpy corresponds to an actual Keras layer: the `SimpleRNN` layer:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C_UXm4IO9z4W"
      },
      "source": [
        "from keras.layers import SimpleRNN"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3fibgXYO9z4b"
      },
      "source": [
        "There is just one minor difference: `SimpleRNN` processes batches of sequences, like all other Keras layers, not just a single sequence like \n",
        "in our Numpy example. This means that it takes inputs of shape `(batch_size, timesteps, input_features)`, rather than `(timesteps, \n",
        "input_features)`.\n",
        "\n",
        "Like all recurrent layers in Keras, `SimpleRNN` can be run in two different modes: it can return either the full sequences of successive \n",
        "outputs for each timestep (a 3D tensor of shape `(batch_size, timesteps, output_features)`), or it can return only the last output for each \n",
        "input sequence (a 2D tensor of shape `(batch_size, output_features)`). These two modes are controlled by the `return_sequences` constructor \n",
        "argument. Let's take a look at an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cuR37Byw9z4d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fdf2cd34-60fe-4247-d445-77ebfe118afe"
      },
      "source": [
        "from keras.models import Sequential\n",
        "from keras.layers import Embedding, SimpleRNN\n",
        "\n",
        "model = Sequential()\n",
        "model.add(Embedding(10000, 32))\n",
        "model.add(SimpleRNN(32))\n",
        "model.summary()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " embedding (Embedding)       (None, None, 32)          320000    \n",
            "                                                                 \n",
            " simple_rnn (SimpleRNN)      (None, 32)                2080      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 322,080\n",
            "Trainable params: 322,080\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GLQyY6J19z4i",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81f02ac5-b1b7-487f-a634-9bc3eb2cab44"
      },
      "source": [
        "model = Sequential()\n",
        "model.add(Embedding(10000, 32))\n",
        "model.add(SimpleRNN(32, return_sequences=True))\n",
        "model.summary()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " embedding_1 (Embedding)     (None, None, 32)          320000    \n",
            "                                                                 \n",
            " simple_rnn_1 (SimpleRNN)    (None, None, 32)          2080      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 322,080\n",
            "Trainable params: 322,080\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q7zuUTsL9z4n"
      },
      "source": [
        "It is sometimes useful to stack several recurrent layers one after the other in order to increase the representational power of a network. \n",
        "In such a setup, you have to get all intermediate layers to return full sequences:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uUnqna719z4o",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "66d64dee-480b-475f-e555-29b5a33ffc28"
      },
      "source": [
        "model = Sequential()\n",
        "model.add(Embedding(10000, 32))\n",
        "model.add(SimpleRNN(32, return_sequences=True))\n",
        "model.add(SimpleRNN(32, return_sequences=True))\n",
        "model.add(SimpleRNN(32, return_sequences=True))\n",
        "model.add(SimpleRNN(32))  # This last layer only returns the last outputs.\n",
        "model.summary()"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " embedding_2 (Embedding)     (None, None, 32)          320000    \n",
            "                                                                 \n",
            " simple_rnn_2 (SimpleRNN)    (None, None, 32)          2080      \n",
            "                                                                 \n",
            " simple_rnn_3 (SimpleRNN)    (None, None, 32)          2080      \n",
            "                                                                 \n",
            " simple_rnn_4 (SimpleRNN)    (None, None, 32)          2080      \n",
            "                                                                 \n",
            " simple_rnn_5 (SimpleRNN)    (None, 32)                2080      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 328,320\n",
            "Trainable params: 328,320\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3qM_yGW39z4t"
      },
      "source": [
        "Now let's try to use such a model on the IMDB movie review classification problem. First, let's preprocess the data:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rIevMOvq9z4u",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "16f0890c-7b4f-4570-c112-0a54fcfe8834"
      },
      "source": [
        "from keras.datasets import imdb\n",
        "from keras.preprocessing import sequence\n",
        "\n",
        "max_features = 10000  # number of words to consider as features\n",
        "maxlen = 500  # cut texts after this number of words (among top max_features most common words)\n",
        "batch_size = 32\n",
        "\n",
        "print('Loading data...')\n",
        "(input_train, y_train), (input_test, y_test) = imdb.load_data(num_words=max_features)\n",
        "print(len(input_train), 'train sequences')\n",
        "print(len(input_test), 'test sequences')\n",
        "\n",
        "print('Pad sequences (samples x time)')\n",
        "input_train = sequence.pad_sequences(input_train, maxlen=maxlen)\n",
        "input_test = sequence.pad_sequences(input_test, maxlen=maxlen)\n",
        "print('input_train shape:', input_train.shape)\n",
        "print('input_test shape:', input_test.shape)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loading data...\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz\n",
            "17465344/17464789 [==============================] - 0s 0us/step\n",
            "17473536/17464789 [==============================] - 0s 0us/step\n",
            "25000 train sequences\n",
            "25000 test sequences\n",
            "Pad sequences (samples x time)\n",
            "input_train shape: (25000, 500)\n",
            "input_test shape: (25000, 500)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iVgs53Tp9z4z"
      },
      "source": [
        "Let's train a simple recurrent network using an `Embedding` layer and a `SimpleRNN` layer:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L6EU2khU9z40",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09108d99-6d13-4a2e-f6f8-c7c349561182"
      },
      "source": [
        "from keras.layers import Dense\n",
        "\n",
        "model = Sequential()\n",
        "model.add(Embedding(max_features, 32))\n",
        "model.add(SimpleRNN(32))\n",
        "model.add(Dense(1, activation='sigmoid'))\n",
        "\n",
        "model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])\n",
        "history = model.fit(input_train, y_train,\n",
        "                    epochs=10,\n",
        "                    batch_size=128,\n",
        "                    validation_split=0.2)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "157/157 [==============================] - 81s 464ms/step - loss: 0.6024 - acc: 0.6568 - val_loss: 0.4761 - val_acc: 0.7938\n",
            "Epoch 2/10\n",
            "157/157 [==============================] - 71s 455ms/step - loss: 0.3922 - acc: 0.8339 - val_loss: 0.3666 - val_acc: 0.8514\n",
            "Epoch 3/10\n",
            "157/157 [==============================] - 72s 458ms/step - loss: 0.2901 - acc: 0.8858 - val_loss: 0.4392 - val_acc: 0.7928\n",
            "Epoch 4/10\n",
            "157/157 [==============================] - 69s 442ms/step - loss: 0.2330 - acc: 0.9108 - val_loss: 0.3882 - val_acc: 0.8564\n",
            "Epoch 5/10\n",
            "157/157 [==============================] - 69s 442ms/step - loss: 0.1743 - acc: 0.9358 - val_loss: 0.3831 - val_acc: 0.8490\n",
            "Epoch 6/10\n",
            "157/157 [==============================] - 70s 446ms/step - loss: 0.1316 - acc: 0.9532 - val_loss: 0.4003 - val_acc: 0.8580\n",
            "Epoch 7/10\n",
            "157/157 [==============================] - 69s 442ms/step - loss: 0.0881 - acc: 0.9712 - val_loss: 0.4454 - val_acc: 0.8544\n",
            "Epoch 8/10\n",
            "157/157 [==============================] - 70s 444ms/step - loss: 0.0571 - acc: 0.9825 - val_loss: 0.5274 - val_acc: 0.8286\n",
            "Epoch 9/10\n",
            "157/157 [==============================] - 70s 444ms/step - loss: 0.0386 - acc: 0.9882 - val_loss: 0.6972 - val_acc: 0.7782\n",
            "Epoch 10/10\n",
            "157/157 [==============================] - 69s 441ms/step - loss: 0.0367 - acc: 0.9880 - val_loss: 0.6660 - val_acc: 0.7958\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w8J31g3W9z45"
      },
      "source": [
        "Let's display the training and validation loss and accuracy:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qLqUQS0g9z46",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        },
        "outputId": "32127890-570c-47ec-cb07-610a2deffc88"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "acc = history.history['acc']\n",
        "val_acc = history.history['val_acc']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(len(acc))\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()"
      ],
      "execution_count": 8,
      "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"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dKcb34ab9z4-"
      },
      "source": [
        "As a reminder, in section 2, our very first naive approach to this very dataset got us to 88% test accuracy. Unfortunately, our small \n",
        "recurrent network doesn't perform very well at all compared to this baseline (only up to ~84% validation accuracy). Part of the problem is \n",
        "that our inputs only consider the first **500** words rather the full sequences -- \n",
        "hence our RNN has access to less information than our earlier baseline model. The remainder of the problem is simply that **`SimpleRNN` isn't very good at processing long sequences**, like text. Other types of recurrent layers perform much better. Let's take a look at some \n",
        "more advanced layers."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VNWrqhCY9z4_"
      },
      "source": [
        "## A concrete LSTM example in Keras\n",
        "\n",
        "Now let's switch to more practical concerns: we will set up a model using a LSTM layer and train it on the IMDB data. Here's the network, \n",
        "similar to the one with `SimpleRNN` that we just presented. We only specify the output dimensionality of the LSTM layer, and leave every \n",
        "other argument (there are lots) to the Keras defaults. Keras has good defaults, and things will almost always \"just work\" without you \n",
        "having to spend time tuning parameters by hand."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WZkNlU-h9z5A",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09a8510a-dfc0-4691-c8c2-9eab73755155"
      },
      "source": [
        "from keras.layers import LSTM\n",
        "\n",
        "model = Sequential()\n",
        "model.add(Embedding(max_features, 32))\n",
        "model.add(LSTM(32))\n",
        "model.add(Dense(1, activation='sigmoid'))\n",
        "\n",
        "model.compile(optimizer='rmsprop',\n",
        "              loss='binary_crossentropy',\n",
        "              metrics=['acc'])\n",
        "history = model.fit(input_train, y_train,\n",
        "                    epochs=10,\n",
        "                    batch_size=128,\n",
        "                    validation_split=0.2)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "157/157 [==============================] - 7s 23ms/step - loss: 0.5558 - acc: 0.7319 - val_loss: 0.3807 - val_acc: 0.8396\n",
            "Epoch 2/10\n",
            "157/157 [==============================] - 3s 20ms/step - loss: 0.3281 - acc: 0.8659 - val_loss: 0.3167 - val_acc: 0.8672\n",
            "Epoch 3/10\n",
            "157/157 [==============================] - 3s 20ms/step - loss: 0.2559 - acc: 0.9011 - val_loss: 0.3515 - val_acc: 0.8454\n",
            "Epoch 4/10\n",
            "157/157 [==============================] - 3s 20ms/step - loss: 0.2106 - acc: 0.9219 - val_loss: 0.3857 - val_acc: 0.8344\n",
            "Epoch 5/10\n",
            "157/157 [==============================] - 3s 20ms/step - loss: 0.1909 - acc: 0.9330 - val_loss: 0.3046 - val_acc: 0.8858\n",
            "Epoch 6/10\n",
            "157/157 [==============================] - 3s 20ms/step - loss: 0.1662 - acc: 0.9422 - val_loss: 0.2905 - val_acc: 0.8846\n",
            "Epoch 7/10\n",
            "157/157 [==============================] - 3s 20ms/step - loss: 0.1514 - acc: 0.9460 - val_loss: 0.3501 - val_acc: 0.8804\n",
            "Epoch 8/10\n",
            "157/157 [==============================] - 3s 20ms/step - loss: 0.1366 - acc: 0.9523 - val_loss: 0.4498 - val_acc: 0.8646\n",
            "Epoch 9/10\n",
            "157/157 [==============================] - 3s 20ms/step - loss: 0.1268 - acc: 0.9552 - val_loss: 0.3886 - val_acc: 0.8798\n",
            "Epoch 10/10\n",
            "157/157 [==============================] - 3s 20ms/step - loss: 0.1186 - acc: 0.9586 - val_loss: 0.6449 - val_acc: 0.8288\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AiX7my-t9z5E",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        },
        "outputId": "a5aaec77-9af0-4965-9e98-492f44e66683"
      },
      "source": [
        "acc = history.history['acc']\n",
        "val_acc = history.history['val_acc']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(len(acc))\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()"
      ],
      "execution_count": 10,
      "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"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zg6fFgJwGLFV"
      },
      "source": [
        "**Contact** : [FarrokhKarimi](https://zil.ink/farrokhkarimi)  \n",
        "**Reference** : [tensorflow.com](https://www.tensorflow.org/)  \n",
        "Special thanks to [François Chollet](https://fchollet.com/)"
      ]
    }
  ]
}