nlp/imbd-sentiment-classification-with-a-fully-connected-neural-network.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "IMDB Sentiment Classification with a Fully-Connected Neural Network",
      "provenance": [],
      "authorship_tag": "ABX9TyMGIiFeXtCvP3u/e79XOkpB"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aq7MqgGKBfOq"
      },
      "source": [
        "# IMDB Sentiment Classification with a Fully-Connected Neural Network\n",
        "*By Carlos Santiago Bañón*\n",
        "\n",
        "**Year:** 2020\n",
        "\n",
        "**Technologies:** Python, NumPy, Matplotlib, TensforFlow, Keras\n",
        "\n",
        "**Discipline(s):** Natural Language Processing (NLP), Deep Learning\n",
        "\n",
        "**Keywords:** `binary-classification`, `classification`, `deep-learning`, `fully-connected`, `imdb`, `imdb-movie-reviews`, `imdb-reviews`, `movie-reviews`, `natural-language-processing`, `neural-network`, `nlp`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HSmvrCh8CqZq"
      },
      "source": [
        "This notebook provides an implementation of sentiment classification using the IMDB movie reviews dataset and a fully-connected neural network built with TensorFlow and Keras."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uzlnsvf1DGpk"
      },
      "source": [
        "## 1. Import Statements\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l8DhknOWDIc4"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%tensorflow_version 2.x\n",
        "import tensorflow as tf"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yuvx7u4qDQ0p"
      },
      "source": [
        "## 2. Data Preprocessing\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qI70NJ8SN4An"
      },
      "source": [
        "The first step is to preprocess our data. Here, we load the 10,000 most-frequently occurring words in the IMDB movie review training dataset from the Keras datasets library."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IsaUq1mDDVLT"
      },
      "source": [
        "# Load the IMDB movie reviews dataset.\n",
        "imdb = tf.keras.datasets.imdb\n",
        "train_dataset, test_dataset = imdb.load_data(num_words=10000)"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nWuEpda6EBMN"
      },
      "source": [
        "# Divide the data into features and labels.\n",
        "train_data, train_labels = train_dataset\n",
        "test_data, test_labels = test_dataset"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QeI1ZJBMx_SZ"
      },
      "source": [
        "Then, we can use vectorize our data to feed it to our neural network."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xNeLo0hQyfGo"
      },
      "source": [
        "def vectorize_dataset(dataset, dimensions=10000):\n",
        "\n",
        "  results = np.zeros((len(dataset), dimensions))\n",
        "\n",
        "  # Vectorize the dataset.\n",
        "  for i, data in enumerate(dataset):\n",
        "    results[i, data] = 1.0\n",
        "\n",
        "  return results"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4pmpERdWyCtz"
      },
      "source": [
        "# Vectorize the datasets.\n",
        "X_train = vectorize_dataset(train_data)\n",
        "X_test = vectorize_dataset(test_data)\n",
        "\n",
        "# Set up the labels.\n",
        "y_train = np.asarray(train_labels).astype('float32')\n",
        "y_test = np.asarray(test_labels).astype('float32')"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P207jruNy6-f"
      },
      "source": [
        "We can then set aside some training samples to create a validation set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l9P5_QPoy-ZU"
      },
      "source": [
        "# Create a validation set.\n",
        "X_validation = X_train[:10000]\n",
        "X_train = X_train[10000:]\n",
        "y_validation = y_train[:10000]\n",
        "y_train = y_train[10000:]"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FVEOuuLPOJVH"
      },
      "source": [
        "Further, the following are the shapes of each matrix."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9PpPi0qpNI_L",
        "outputId": "5c5f7984-0cd4-4939-b460-bcb7f9eca968",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Show the shapes of the data.\n",
        "print(\"Training Data:\", X_train.shape)\n",
        "print(\"Training Labels:\", y_train.shape)\n",
        "print(\"Testing Data:\", X_test.shape)\n",
        "print(\"Testing Labels:\", y_test.shape)\n",
        "print(\"Validation Data:\", X_validation.shape)\n",
        "print(\"Validation Labels:\", y_validation.shape)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Training Data: (15000, 10000)\n",
            "Training Labels: (15000,)\n",
            "Testing Data: (25000, 10000)\n",
            "Testing Labels: (25000,)\n",
            "Validation Data: (10000, 10000)\n",
            "Validation Labels: (10000,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J5ubfhUsFLR8"
      },
      "source": [
        "## 3. Neural Network\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-gPoq2dRFtrH"
      },
      "source": [
        "### 3.1. Define the Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jU5sDVjhOVgF"
      },
      "source": [
        "We then have to define our neural network. Here, we define a sequential model with three fully-connected layers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ri1rSpp3FSDS"
      },
      "source": [
        "# Define the sequential model.\n",
        "model = tf.keras.models.Sequential()"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5CNJ9gHWFWQv"
      },
      "source": [
        "# Add three fully-connected layers to the network.\n",
        "model.add(tf.keras.layers.Dense(8, activation='relu', input_shape=(10000,)))\n",
        "model.add(tf.keras.layers.Dense(8, activation='relu'))\n",
        "model.add(tf.keras.layers.Dense(1, activation='sigmoid'))"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cdMaLgtqFeV6",
        "outputId": "910fcebf-1b35-4358-e556-3ffb97fa7cec",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Show the model.\n",
        "model.summary()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense (Dense)                (None, 8)                 80008     \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 8)                 72        \n",
            "_________________________________________________________________\n",
            "dense_2 (Dense)              (None, 1)                 9         \n",
            "=================================================================\n",
            "Total params: 80,089\n",
            "Trainable params: 80,089\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GYactRmuOhCW"
      },
      "source": [
        "Once our model is defined, we can compile it using the Adam optimizer and the binary cross-entropy loss function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "57j-R0L4Fmmf"
      },
      "source": [
        "# Compile the model.\n",
        "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hRVabAG8F3IL"
      },
      "source": [
        "### 3.2. Train the Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0IuRzsr2Osga"
      },
      "source": [
        "We then train the model on 4 epochs, using a batch size of 256."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yl1f9mvZF5Pc",
        "outputId": "c15f1bf3-7979-4c77-db92-6c55c91e199d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Define the parameters.\n",
        "num_epochs = 4\n",
        "batch_size = 256\n",
        "\n",
        "# Train the model.\n",
        "history = model.fit(X_train,\n",
        "                    y_train,\n",
        "                    epochs=num_epochs,\n",
        "                    batch_size=batch_size,\n",
        "                    validation_data=(X_validation, y_validation))"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/4\n",
            "59/59 [==============================] - 1s 21ms/step - loss: 0.6289 - accuracy: 0.6315 - val_loss: 0.5513 - val_accuracy: 0.7834\n",
            "Epoch 2/4\n",
            "59/59 [==============================] - 1s 16ms/step - loss: 0.4875 - accuracy: 0.8446 - val_loss: 0.4648 - val_accuracy: 0.8439\n",
            "Epoch 3/4\n",
            "59/59 [==============================] - 1s 16ms/step - loss: 0.3184 - accuracy: 0.9148 - val_loss: 0.2877 - val_accuracy: 0.8886\n",
            "Epoch 4/4\n",
            "59/59 [==============================] - 1s 17ms/step - loss: 0.1794 - accuracy: 0.9449 - val_loss: 0.2779 - val_accuracy: 0.8887\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WhyG0-sPHOAv"
      },
      "source": [
        "### 3.3. Display the Metrics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1TFadfX_Oyg_"
      },
      "source": [
        "Finally, we display the metrics. We begin by displaying the model's accuracy and loss based on the test set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vFoIAPdSYXqh",
        "outputId": "053dddcd-d563-44e6-816e-1c10c1183343",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "test_loss, test_accuracy = model.evaluate(X_test, y_test)\n",
        "print('Test Accuracy:', test_accuracy)\n",
        "print('Test Loss:', test_loss)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "782/782 [==============================] - 1s 2ms/step - loss: 0.2933 - accuracy: 0.8815\n",
            "Test Accuracy: 0.8814799785614014\n",
            "Test Loss: 0.29327258467674255\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k3p2c0-RO2M8"
      },
      "source": [
        "Then, we save the metric values for each epoch to plot the loss and accuracy curves for our model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8-OdhC_0KtUx"
      },
      "source": [
        "# Save the metrics.\n",
        "metrics = history.history"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZztnSHgjZPDN"
      },
      "source": [
        "Finally, once we have our metric history, we can plot the curves."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yfosMMiqHQB0"
      },
      "source": [
        "# Save the loss values.\n",
        "training_loss_list = metrics['loss']\n",
        "test_loss_list = metrics['val_loss']"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HKAZlyOmHV6f",
        "outputId": "56f36988-4793-4dc4-9971-c5cf9576216e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        }
      },
      "source": [
        "# Plot the training and test loss.\n",
        "x = np.arange(0, num_epochs, 1)\n",
        "plt.title('Training and Test Loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.plot(x, training_loss_list, label='Training Loss')\n",
        "plt.plot(x, test_loss_list, label='Test Loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RwzIUzuuI0ZP"
      },
      "source": [
        "train_accuracy_list = metrics['accuracy']\n",
        "test_accuracy_list = metrics['val_accuracy']"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kHj-j2HpI2Lb",
        "outputId": "c694a73f-58c7-4411-c480-76e0afa3cb28",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        }
      },
      "source": [
        "plt.title('Training and Test Accuracy')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.plot(x, train_accuracy_list, label='Training Accuracy')\n",
        "plt.plot(x, test_accuracy_list, label='Test Accuracy')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}