TF_Sentiment_analysis_on_IMDB_dataset.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "TF_Sentiment_analysis_on_IMDB_dataset.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyM9b9iYWByQtcQQfXKjQ2SI",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/alaeddinehamroun/Natural-Language-Processing/blob/main/TF_Sentiment_analysis_on_IMDB_dataset.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This notebook trains a sentiment analysis model to classify movie reviews as positive or negative, based on the text of the review. This is an example of binary—or two-class—classification, an important and widely applicable kind of machine learning problem."
      ],
      "metadata": {
        "id": "dIuokdL8DOWY"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "QGWFwwdu_kUj"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import os\n",
        "import re\n",
        "import shutil\n",
        "import string\n",
        "import tensorflow as tf\n",
        "\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras import losses"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "url = \"https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz\"\n",
        "\n",
        "dataset = tf.keras.utils.get_file(\"aclImdb_v1\", url,\n",
        "                                    untar=True, cache_dir='.',\n",
        "                                    cache_subdir='')\n",
        "\n",
        "dataset_dir = os.path.join(os.path.dirname(dataset), 'aclImdb')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KH3Xva7KA0yy",
        "outputId": "85df6cbe-06c0-4917-a8c3-917c5bc159e5"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz\n",
            "84131840/84125825 [==============================] - 5s 0us/step\n",
            "84140032/84125825 [==============================] - 5s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "os.listdir(dataset_dir)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6PLD2ViZCSwJ",
        "outputId": "4e9c340e-0e13-451b-8db4-b032b1f19377"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['test', 'imdbEr.txt', 'train', 'imdb.vocab', 'README']"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_dir = os.path.join(dataset_dir, 'train')\n",
        "os.listdir(train_dir)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xGXyfieWD6wA",
        "outputId": "64fb164b-cc5b-411b-fee0-fb4c7f7d55ca"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['neg',\n",
              " 'urls_unsup.txt',\n",
              " 'urls_pos.txt',\n",
              " 'urls_neg.txt',\n",
              " 'unsupBow.feat',\n",
              " 'unsup',\n",
              " 'pos',\n",
              " 'labeledBow.feat']"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " sample_file = os.path.join(train_dir, 'pos/1181_9.txt')\n",
        " with open(sample_file) as f:\n",
        "   print(f.read())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B6X7gz6GEGCe",
        "outputId": "55c1b336-69e5-45e4-f7b7-e97711752ff5"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rachel Griffiths writes and directs this award winning short film. A heartwarming story about coping with grief and cherishing the memory of those we've loved and lost. Although, only 15 minutes long, Griffiths manages to capture so much emotion and truth onto film in the short space of time. Bud Tingwell gives a touching performance as Will, a widower struggling to cope with his wife's death. Will is confronted by the harsh reality of loneliness and helplessness as he proceeds to take care of Ruth's pet cow, Tulip. The film displays the grief and responsibility one feels for those they have loved and lost. Good cinematography, great direction, and superbly acted. It will bring tears to all those who have lost a loved one, and survived.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sample_file = os.path.join(train_dir, 'neg/0_3.txt')\n",
        "with open(sample_file) as f:\n",
        "  print (f.read())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8bbclGviEYLe",
        "outputId": "8e4acc86-0f15-429b-bc5e-3d0bf0119a68"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Story of a man who has unnatural feelings for a pig. Starts out with a opening scene that is a terrific example of absurd comedy. A formal orchestra audience is turned into an insane, violent mob by the crazy chantings of it's singers. Unfortunately it stays absurd the WHOLE time with no general narrative eventually making it just too off putting. Even those from the era should be turned off. The cryptic dialogue would make Shakespeare seem easy to a third grader. On a technical level it's better than you might think with some good cinematography by future great Vilmos Zsigmond. Future stars Sally Kirkland and Frederic Forrest can be seen briefly.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Load the dataset"
      ],
      "metadata": {
        "id": "vbExqsnqEuoh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "load the data off disk and prepare it into a format suitable for training. "
      ],
      "metadata": {
        "id": "ADaKxW-jE74R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "remove_dir = os.path.join(train_dir, 'unsup')\n",
        "shutil.rmtree(remove_dir)"
      ],
      "metadata": {
        "id": "-wlcylQGEtZ6"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size = 32\n",
        "seed = 42\n",
        "\n",
        "raw_train_ds = tf.keras.utils.text_dataset_from_directory(\n",
        "    'aclImdb/train', \n",
        "    batch_size=batch_size, \n",
        "    validation_split=0.2, \n",
        "    subset='training', \n",
        "    seed=seed)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F-KHHHFdFV00",
        "outputId": "4913b965-c9b7-46c0-b4de-30aee8a21b0e"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 25000 files belonging to 2 classes.\n",
            "Using 20000 files for training.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for text_batch, label_batch in raw_train_ds.take(1):\n",
        "  for i in range(3):\n",
        "    print('Review', text_batch.numpy()[i])\n",
        "    print('Label', label_batch.numpy()[i])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Av9i32evFdGG",
        "outputId": "af8ffeb0-d6f9-4adb-b65d-bb49883b53c3"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Review b'\"Pandemonium\" is a horror movie spoof that comes off more stupid than funny. Believe me when I tell you, I love comedies. Especially comedy spoofs. \"Airplane\", \"The Naked Gun\" trilogy, \"Blazing Saddles\", \"High Anxiety\", and \"Spaceballs\" are some of my favorite comedies that spoof a particular genre. \"Pandemonium\" is not up there with those films. Most of the scenes in this movie had me sitting there in stunned silence because the movie wasn\\'t all that funny. There are a few laughs in the film, but when you watch a comedy, you expect to laugh a lot more than a few times and that\\'s all this film has going for it. Geez, \"Scream\" had more laughs than this film and that was more of a horror film. How bizarre is that?<br /><br />*1/2 (out of four)'\n",
            "Label 0\n",
            "Review b\"David Mamet is a very interesting and a very un-equal director. His first movie 'House of Games' was the one I liked best, and it set a series of films with characters whose perspective of life changes as they get into complicated situations, and so does the perspective of the viewer.<br /><br />So is 'Homicide' which from the title tries to set the mind of the viewer to the usual crime drama. The principal characters are two cops, one Jewish and one Irish who deal with a racially charged area. The murder of an old Jewish shop owner who proves to be an ancient veteran of the Israeli Independence war triggers the Jewish identity in the mind and heart of the Jewish detective.<br /><br />This is were the flaws of the film are the more obvious. The process of awakening is theatrical and hard to believe, the group of Jewish militants is operatic, and the way the detective eventually walks to the final violent confrontation is pathetic. The end of the film itself is Mamet-like smart, but disappoints from a human emotional perspective.<br /><br />Joe Mantegna and William Macy give strong performances, but the flaws of the story are too evident to be easily compensated.\"\n",
            "Label 0\n",
            "Review b'Great documentary about the lives of NY firefighters during the worst terrorist attack of all time.. That reason alone is why this should be a must see collectors item.. What shocked me was not only the attacks, but the\"High Fat Diet\" and physical appearance of some of these firefighters. I think a lot of Doctors would agree with me that,in the physical shape they were in, some of these firefighters would NOT of made it to the 79th floor carrying over 60 lbs of gear. Having said that i now have a greater respect for firefighters and i realize becoming a firefighter is a life altering job. The French have a history of making great documentary\\'s and that is what this is, a Great Documentary.....'\n",
            "Label 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Label 0 corresponds to\", raw_train_ds.class_names[0])\n",
        "print(\"Label 1 corresponds to\", raw_train_ds.class_names[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_I7oej9bF8zH",
        "outputId": "61ad5b91-1497-4a3d-e487-6d14ce82fb34"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Label 0 corresponds to neg\n",
            "Label 1 corresponds to pos\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "raw_val_ds = tf.keras.utils.text_dataset_from_directory(\n",
        "    'aclImdb/train',\n",
        "    batch_size=batch_size,\n",
        "    validation_split=0.2,\n",
        "    subset='validation',\n",
        "    seed=seed\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L_sZgSz7GLnX",
        "outputId": "d20f74f9-0894-4ca4-fb2e-7c9143379f6d"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 25000 files belonging to 2 classes.\n",
            "Using 5000 files for validation.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "raw_test_ds = tf.keras.utils.text_dataset_from_directory(\n",
        "    'aclImdb/test',\n",
        "    batch_size=batch_size\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OyV45x9HGdqS",
        "outputId": "6dc4f261-98c1-441f-fdb0-742d93baba4b"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 25000 files belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Prepare the dataset for training"
      ],
      "metadata": {
        "id": "y7Yd9ocAGt9Y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Standardization refers to preprocessing the text, typically to remove punctuation or HTML elements to simplify the dataset. Tokenization refers to splitting strings into tokens (for example, splitting a sentence into individual words, by splitting on whitespace). Vectorization refers to converting tokens into numbers so they can be fed into a neural network. All of these tasks can be accomplished with the tf.keras.layers.TextVectorization layer."
      ],
      "metadata": {
        "id": "Byco3WniG6c7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note: To prevent training-testing skew (also known as training-serving skew), it is important to preprocess the data identically at train and test time. To facilitate this, the TextVectorization layer can be included directly inside your model."
      ],
      "metadata": {
        "id": "96PIiFOAHC1U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def custom_standardization(input_data):\n",
        "  lowercase = tf.strings.lower(input_data)\n",
        "  stripped_html = tf.strings.regex_replace(lowercase, '<br />', ' ')\n",
        "  return tf.strings.regex_replace(stripped_html, '[%s]' % re.escape(string.punctuation), '')"
      ],
      "metadata": {
        "id": "Q-V3ze1RGxfh"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "max_features = 10000\n",
        "sequence_length = 250\n",
        "\n",
        "vectorize_layer = layers.TextVectorization(\n",
        "    standardize=custom_standardization,\n",
        "    max_tokens=max_features,\n",
        "    output_mode='int',\n",
        "    output_sequence_length=sequence_length\n",
        ")"
      ],
      "metadata": {
        "id": "W8Itw5zjH2n1"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Make a text-only dataset (without labels), then call adapt\n",
        "train_text = raw_train_ds.map(lambda x, y: x)\n",
        "vectorize_layer.adapt(train_text)"
      ],
      "metadata": {
        "id": "30GJMyn6IP0Z"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def vectorize_text(text, label):\n",
        "  text = tf.expand_dims(text, -1)\n",
        "  return vectorize_layer(text), label"
      ],
      "metadata": {
        "id": "GIRhU9o3IdTA"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# retrieve a batch (of 32 reviews and labels) from the dataset\n",
        "text_batch, label_batch = next(iter(raw_train_ds))\n",
        "first_review, first_label = text_batch[0], label_batch[0]\n",
        "print('Review', first_review)\n",
        "print('Label', raw_train_ds.class_names[first_label])\n",
        "print('Vectorized review', vectorize_text(first_review, first_label))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "duRSvE9TIopN",
        "outputId": "e36e005f-6416-4290-e46e-7f6524e7b3d5"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Review tf.Tensor(b'Great movie - especially the music - Etta James - \"At Last\". This speaks volumes when you have finally found that special someone.', shape=(), dtype=string)\n",
            "Label neg\n",
            "Vectorized review (<tf.Tensor: shape=(1, 250), dtype=int64, numpy=\n",
            "array([[  86,   17,  260,    2,  222,    1,  571,   31,  229,   11, 2418,\n",
            "           1,   51,   22,   25,  404,  251,   12,  306,  282,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "           0,    0,    0,    0,    0,    0,    0,    0]])>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"1287 ---> \",vectorize_layer.get_vocabulary()[1287])\n",
        "print(\" 313 ---> \",vectorize_layer.get_vocabulary()[313])\n",
        "print('Vocabulary size: {}'.format(len(vectorize_layer.get_vocabulary())))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cAn7uQvOJP9X",
        "outputId": "fc5cd3f9-6bfe-4e8c-b669-7b2ad4b95529"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1287 --->  silent\n",
            " 313 --->  night\n",
            "Vocabulary size: 10000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_ds = raw_train_ds.map(vectorize_text)\n",
        "val_ds = raw_val_ds.map(vectorize_text)\n",
        "test_ds = raw_test_ds.map(vectorize_text)"
      ],
      "metadata": {
        "id": "Iolnb6wEJRbc"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Configure the dataset for performance"
      ],
      "metadata": {
        "id": "L9sQr8kVLlHp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        ".cache() keeps data in memory after it's loaded off disk. This will ensure the dataset does not become a bottleneck while training your model. If your dataset is too large to fit into memory, you can also use this method to create a performant on-disk cache, which is more efficient to read than many small files.\n",
        "\n",
        ".prefetch() overlaps data preprocessing and model execution while training."
      ],
      "metadata": {
        "id": "1-y9TMELL5_N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "AUTOTUNE = tf.data.AUTOTUNE\n",
        "\n",
        "tain_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)\n",
        "val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)\n",
        "test_ds = test_ds.cache().prefetch(buffer_size=AUTOTUNE)"
      ],
      "metadata": {
        "id": "iom1uzIvLpSd"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Create the model"
      ],
      "metadata": {
        "id": "YO1l05JYMar2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "embedding_dim = 16"
      ],
      "metadata": {
        "id": "smnE0IgrMcul"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.Sequential([\n",
        "  layers.Embedding(max_features + 1, embedding_dim),\n",
        "  layers.Dropout(0.2),\n",
        "  layers.GlobalAveragePooling1D(),\n",
        "  layers.Dropout(0.2),\n",
        "  layers.Dense(1)])\n",
        "\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w81toK0yMfcX",
        "outputId": "1d6fb46d-4a3e-49d6-ccd6-feced7666e1c"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " embedding (Embedding)       (None, None, 16)          160016    \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, None, 16)          0         \n",
            "                                                                 \n",
            " global_average_pooling1d (G  (None, 16)               0         \n",
            " lobalAveragePooling1D)                                          \n",
            "                                                                 \n",
            " dropout_1 (Dropout)         (None, 16)                0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 1)                 17        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 160,033\n",
            "Trainable params: 160,033\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loss function and optimizer"
      ],
      "metadata": {
        "id": "mSeLwQkgMrJG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(loss=losses.BinaryCrossentropy(from_logits=True),\n",
        "              optimizer='adam',\n",
        "              metrics=tf.metrics.BinaryAccuracy(threshold=0.0))"
      ],
      "metadata": {
        "id": "AYqZdoSYNBUd"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Train the model"
      ],
      "metadata": {
        "id": "Mwv4UTiSNC19"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "epochs = 10\n",
        "history = model.fit(\n",
        "    train_ds,\n",
        "    validation_data=val_ds,\n",
        "    epochs=epochs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Aq6SpPPhNEim",
        "outputId": "83fe19f4-b404-4bf9-b484-58b35ec0dc0b"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "625/625 [==============================] - 15s 22ms/step - loss: 0.6653 - binary_accuracy: 0.6906 - val_loss: 0.6163 - val_binary_accuracy: 0.7706\n",
            "Epoch 2/10\n",
            "625/625 [==============================] - 12s 19ms/step - loss: 0.5494 - binary_accuracy: 0.8006 - val_loss: 0.4986 - val_binary_accuracy: 0.8198\n",
            "Epoch 3/10\n",
            "625/625 [==============================] - 11s 18ms/step - loss: 0.4444 - binary_accuracy: 0.8462 - val_loss: 0.4204 - val_binary_accuracy: 0.8448\n",
            "Epoch 4/10\n",
            "625/625 [==============================] - 14s 23ms/step - loss: 0.3784 - binary_accuracy: 0.8662 - val_loss: 0.3737 - val_binary_accuracy: 0.8606\n",
            "Epoch 5/10\n",
            "625/625 [==============================] - 14s 22ms/step - loss: 0.3357 - binary_accuracy: 0.8776 - val_loss: 0.3451 - val_binary_accuracy: 0.8664\n",
            "Epoch 6/10\n",
            "625/625 [==============================] - 12s 19ms/step - loss: 0.3055 - binary_accuracy: 0.8864 - val_loss: 0.3260 - val_binary_accuracy: 0.8702\n",
            "Epoch 7/10\n",
            "625/625 [==============================] - 12s 19ms/step - loss: 0.2810 - binary_accuracy: 0.8967 - val_loss: 0.3130 - val_binary_accuracy: 0.8720\n",
            "Epoch 8/10\n",
            "625/625 [==============================] - 13s 20ms/step - loss: 0.2622 - binary_accuracy: 0.9052 - val_loss: 0.3036 - val_binary_accuracy: 0.8756\n",
            "Epoch 9/10\n",
            "625/625 [==============================] - 12s 19ms/step - loss: 0.2455 - binary_accuracy: 0.9097 - val_loss: 0.2965 - val_binary_accuracy: 0.8774\n",
            "Epoch 10/10\n",
            "625/625 [==============================] - 12s 19ms/step - loss: 0.2318 - binary_accuracy: 0.9159 - val_loss: 0.2915 - val_binary_accuracy: 0.8792\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Evaluate the model"
      ],
      "metadata": {
        "id": "vWxbuFm1NIUn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "loss, accuracy = model.evaluate(test_ds)\n",
        "\n",
        "print(\"Loss: \", loss)\n",
        "print(\"Accuracy: \", accuracy)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GFtQHAlNNMS_",
        "outputId": "7a969981-9de3-49c4-8102-21a95b5e9704"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "782/782 [==============================] - 13s 16ms/step - loss: 0.3101 - binary_accuracy: 0.8739\n",
            "Loss:  0.31013578176498413\n",
            "Accuracy:  0.8738800287246704\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history_dict = history.history\n",
        "history_dict.keys()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zXV6FGHwNStA",
        "outputId": "0b59de3e-b7e9-462e-a072-749b7ff3a00c"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['loss', 'binary_accuracy', 'val_loss', 'val_binary_accuracy'])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "acc = history_dict['binary_accuracy']\n",
        "val_acc = history_dict['val_binary_accuracy']\n",
        "loss = history_dict['loss']\n",
        "val_loss = history_dict['val_loss']\n",
        "\n",
        "epochs = range(1, len(acc) + 1)\n",
        "\n",
        "# \"bo\" is for \"blue dot\"\n",
        "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
        "# b is for \"solid blue line\"\n",
        "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "J8nRsWciNVyg",
        "outputId": "0637231c-dbfe-40e3-f3ce-975dd6c8771e"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZgU1b3/8feXnYEBZRERhEEvIrJvoqIIqIlGA+5KuCg/oixxC8YF5arESOJV4kOIK2rUJGPQa5SL1wWjiOAaQIkKYkQdBEVFlB1kwO/vj1PDLMwK3V0905/X88zTXdXV1d/ugf5MnVN1jrk7IiKSuWrFXYCIiMRLQSAikuEUBCIiGU5BICKS4RQEIiIZTkEgIpLhFASSUGb2nJldmOht42RmeWZ2YhL262b2H9H9e83shspsuxevM8LMXtjbOsvZ7yAzW53o/Urq1Ym7AImfmW0uspgFfA/sipbHuntuZffl7qckY9uazt3HJWI/ZpYDfArUdfed0b5zgUr/DiXzKAgEd29ccN/M8oCL3P3FktuZWZ2CLxcRqTnUNCRlKjj0N7NrzexL4CEz29/M/s/M1prZd9H9tkWeM8/MLorujzKzV81sarTtp2Z2yl5u28HM5pvZJjN70czuMrO/llF3ZWr8jZm9Fu3vBTNrUeTxkWa20szWmdmkcj6f/mb2pZnVLrLuDDN7N7p/pJm9YWbrzWyNmd1pZvXK2NfDZnZLkeWro+d8YWajS2x7qpm9Y2YbzWyVmU0u8vD86Ha9mW02s6MLPtsizz/GzBaa2Ybo9pjKfjblMbPO0fPXm9lSMxta5LGfmNmyaJ+fm9lV0foW0e9nvZl9a2YLzEzfSymmD1wqciDQDGgPjCH8m3koWm4HbAPuLOf5/YEPgRbAbcCDZmZ7se2jwD+B5sBkYGQ5r1mZGn8G/D/gAKAeUPDFdARwT7T/g6LXa0sp3P0tYAswpMR+H43u7wImRO/naOAE4Bfl1E1Uw8lRPScBHYGS/RNbgAuA/YBTgfFmdnr02MDodj93b+zub5TYdzPgGWB69N7uAJ4xs+Yl3sMen00FNdcFngZeiJ53GZBrZp2iTR4kNDNmA12BudH6XwGrgZZAK+B6QOPepJiCQCryA3CTu3/v7tvcfZ27/93dt7r7JmAKcHw5z1/p7ve7+y7gEaA14T98pbc1s3ZAP+BGd9/h7q8Cs8t6wUrW+JC7/9vdtwGPAz2j9WcD/+fu8939e+CG6DMoy9+A4QBmlg38JFqHuy929zfdfae75wH3lVJHac6N6nvf3bcQgq/o+5vn7u+5+w/u/m70epXZL4Tg+Mjd/xLV9TdgOfDTItuU9dmU5yigMXBr9DuaC/wf0WcD5ANHmFkTd//O3d8usr410N7d8919gWsAtJRTEEhF1rr79oIFM8sys/uippONhKaI/Yo2j5TwZcEdd98a3W1cxW0PAr4tsg5gVVkFV7LGL4vc31qkpoOK7jv6Il5X1msR/vo/08zqA2cCb7v7yqiOw6Jmjy+jOn5LODqoSLEagJUl3l9/M3s5avraAIyr5H4L9r2yxLqVQJsiy2V9NhXW7O5FQ7Pofs8ihORKM3vFzI6O1t8OrABeMLNPzGxi5d6GJJKCQCpS8q+zXwGdgP7u3oTCpoiymnsSYQ3QzMyyiqw7uJzt96XGNUX3Hb1m87I2dvdlhC+8UyjeLAShiWk50DGq4/q9qYHQvFXUo4QjooPdvSlwb5H9VvTX9BeEJrOi2gGfV6KuivZ7cIn2/d37dfeF7j6M0Gw0i3CkgbtvcvdfufshwFDgSjM7YR9rkSpSEEhVZRPa3NdH7c03JfsFo7+wFwGTzaxe9NfkT8t5yr7U+ARwmpkdG3Xs3kzF/08eBa4gBM7/lKhjI7DZzA4HxleyhseBUWZ2RBREJevPJhwhbTezIwkBVGAtoSnrkDL2/SxwmJn9zMzqmNl5wBGEZpx98Rbh6OEaM6trZoMIv6OZ0e9shJk1dfd8wmfyA4CZnWZm/xH1BW0g9KuU1xQnSaAgkKqaBjQEvgHeBJ5P0euOIHS4rgNuAR4jXO9Qmr2u0d2XApcQvtzXAN8ROjPLU9BGP9fdvymy/irCl/Qm4P6o5srU8Fz0HuYSmk3mltjkF8DNZrYJuJHor+vouVsJfSKvRWfiHFVi3+uA0whHTeuAa4DTStRdZe6+g/DFfwrhc78buMDdl0ebjATyoiaycYTfJ4TO8BeBzcAbwN3u/vK+1CJVZ+qXkerIzB4Dlrt70o9IRGo6HRFItWBm/czsUDOrFZ1eOYzQ1iwi+0hXFkt1cSDwJKHjdjUw3t3fibckkZpBTUMiIhlOTUMiIhmu2jUNtWjRwnNycuIuQ0SkWlm8ePE37t6ytMeqXRDk5OSwaNGiuMsQEalWzKzkFeW7qWlIRCTDKQhERDKcgkBEJMNVuz4CEUm9/Px8Vq9ezfbt2yveWGLVoEED2rZtS926dSv9HAWBiFRo9erVZGdnk5OTQ9nzCknc3J1169axevVqOnToUOnnZUTTUG4u5ORArVrhNlfTeItUyfbt22nevLlCIM2ZGc2bN6/ykVuNPyLIzYUxY2BrNKXJypVhGWDEiLKfJyLFKQSqh735PdX4I4JJkwpDoMDWrWG9iIhkQBB89lnV1otI+lm3bh09e/akZ8+eHHjggbRp02b38o4dO8p97qJFi7j88ssrfI1jjjkmIbXOmzeP0047LSH7SpUaHwTtSk7yV8F6Edl3ie6Xa968OUuWLGHJkiWMGzeOCRMm7F6uV68eO3fuLPO5ffv2Zfr06RW+xuuvv75vRVZjNT4IpkyBrKzi67KywnoRSbyCfrmVK8G9sF8u0SdpjBo1inHjxtG/f3+uueYa/vnPf3L00UfTq1cvjjnmGD788EOg+F/okydPZvTo0QwaNIhDDjmkWEA0btx49/aDBg3i7LPP5vDDD2fEiBEUjNL87LPPcvjhh9OnTx8uv/zyCv/y//bbbzn99NPp3r07Rx11FO+++y4Ar7zyyu4jml69erFp0ybWrFnDwIED6dmzJ127dmXBggWJ/cDKUeM7iws6hCdNCs1B7dqFEFBHsUhylNcvl+j/d6tXr+b111+ndu3abNy4kQULFlCnTh1efPFFrr/+ev7+97/v8Zzly5fz8ssvs2nTJjp16sT48eP3OOf+nXfeYenSpRx00EEMGDCA1157jb59+zJ27Fjmz59Phw4dGD58eIX13XTTTfTq1YtZs2Yxd+5cLrjgApYsWcLUqVO56667GDBgAJs3b6ZBgwbMmDGDH//4x0yaNIldu3axteSHmEQ1Pggg/OPTF79IaqSyX+6cc86hdu3aAGzYsIELL7yQjz76CDMjPz+/1Oeceuqp1K9fn/r163PAAQfw1Vdf0bZt22LbHHnkkbvX9ezZk7y8PBo3bswhhxyy+/z84cOHM2PGjHLre/XVV3eH0ZAhQ1i3bh0bN25kwIABXHnllYwYMYIzzzyTtm3b0q9fP0aPHk1+fj6nn346PXv23KfPpipqfNOQiKRWKvvlGjVqtPv+DTfcwODBg3n//fd5+umnyzyXvn79+rvv165du9T+hcpssy8mTpzIAw88wLZt2xgwYADLly9n4MCBzJ8/nzZt2jBq1Cj+/Oc/J/Q1y6MgEJGEiqtfbsOGDbRp0waAhx9+OOH779SpE5988gl5eXkAPPbYYxU+57jjjiM36hyZN28eLVq0oEmTJnz88cd069aNa6+9ln79+rF8+XJWrlxJq1atuPjii7nooot4++23E/4eyqIgEJGEGjECZsyA9u3BLNzOmJH85tlrrrmG6667jl69eiX8L3iAhg0bcvfdd3PyySfTp08fsrOzadq0abnPmTx5MosXL6Z79+5MnDiRRx55BIBp06bRtWtXunfvTt26dTnllFOYN28ePXr0oFevXjz22GNcccUVCX8PZal2cxb37dvXNTGNSGp98MEHdO7cOe4yYrd582YaN26Mu3PJJZfQsWNHJkyYEHdZeyjt92Vmi929b2nb64hARKSS7r//fnr27EmXLl3YsGEDY8eOjbukhMiIs4ZERBJhwoQJaXkEsK90RCAikuEUBCIiGU5BICKS4RQEIiIZTkEgImlv8ODBzJkzp9i6adOmMX78+DKfM2jQIApONf/JT37C+vXr99hm8uTJTJ06tdzXnjVrFsuWLdu9fOONN/Liiy9WpfxSpdNw1QoCEUl7w4cPZ+bMmcXWzZw5s1IDv0EYNXS//fbbq9cuGQQ333wzJ5544l7tK10pCEQk7Z199tk888wzuyehycvL44svvuC4445j/Pjx9O3bly5dunDTTTeV+vycnBy++eYbAKZMmcJhhx3Gscceu3uoagjXCPTr148ePXpw1llnsXXrVl5//XVmz57N1VdfTc+ePfn4448ZNWoUTzzxBAAvvfQSvXr1olu3bowePZrvv/9+9+vddNNN9O7dm27durF8+fJy31/cw1XrOgIRqZJf/hKWLEnsPnv2hGnTyn68WbNmHHnkkTz33HMMGzaMmTNncu6552JmTJkyhWbNmrFr1y5OOOEE3n33Xbp3717qfhYvXszMmTNZsmQJO3fupHfv3vTp0weAM888k4svvhiA//qv/+LBBx/ksssuY+jQoZx22mmcffbZxfa1fft2Ro0axUsvvcRhhx3GBRdcwD333MMvf/lLAFq0aMHbb7/N3XffzdSpU3nggQfKfH9xD1etIwIRqRaKNg8VbRZ6/PHH6d27N7169WLp0qXFmnFKWrBgAWeccQZZWVk0adKEoUOH7n7s/fff57jjjqNbt27k5uaydOnScuv58MMP6dChA4cddhgAF154IfPnz9/9+JlnnglAnz59dg9UV5ZXX32VkSNHAqUPVz19+nTWr19PnTp16NevHw899BCTJ0/mvffeIzs7u9x9V4aOCESkSsr7yz2Zhg0bxoQJE3j77bfZunUrffr04dNPP2Xq1KksXLiQ/fffn1GjRpU5/HRFRo0axaxZs+jRowcPP/ww8+bN26d6C4ay3pdhrCdOnMipp57Ks88+y4ABA5gzZ87u4aqfeeYZRo0axZVXXskFF1ywT7VmzBHBrl3wz3/GXYWI7K3GjRszePBgRo8evftoYOPGjTRq1IimTZvy1Vdf8dxzz5W7j4EDBzJr1iy2bdvGpk2bePrpp3c/tmnTJlq3bk1+fv7uoaMBsrOz2bRp0x776tSpE3l5eaxYsQKAv/zlLxx//PF79d7iHq46Y44IJk+G226Dd9+FTp3irkZE9sbw4cM544wzdjcRFQzbfPjhh3PwwQczYMCAcp/fu3dvzjvvPHr06MEBBxxAv379dj/2m9/8hv79+9OyZUv69++/+8v//PPP5+KLL2b69Om7O4kBGjRowEMPPcQ555zDzp076devH+PGjdur91Uwl3L37t3JysoqNlz1yy+/TK1atejSpQunnHIKM2fO5Pbbb6du3bo0btw4IRPYZMww1F9+CZ07Q48e8PLLYZx0EakcDUNdvWgY6jIceGA4InjlFXjoobirERFJHxkTBAA//zkceyxcdRV8/XXc1YiIpIeMCoJatcKUeZs3w5VXxl2NSPVS3ZqRM9Xe/J6SGgRmdrKZfWhmK8xsYhnbnGtmy8xsqZk9msx6IPQTXHcd5OZCiaFLRKQMDRo0YN26dQqDNOfurFu3jgYNGlTpeUnrLDaz2sC/gZOA1cBCYLi7LyuyTUfgcWCIu39nZge4e7mNNomYs3j79tBpnJ8P778PWVn7tDuRGi8/P5/Vq1fv9Tn6kjoNGjSgbdu21K1bt9j68jqLk3n66JHACnf/JCpiJjAMKHrZ38XAXe7+HUBFIZAoDRqEJqJBg+DXv4b//u9UvKpI9VW3bl06dOgQdxmSJMlsGmoDrCqyvDpaV9RhwGFm9pqZvWlmJ5e2IzMbY2aLzGzR2rVrE1Lc8cfD6NHw+9/Dv/6VkF2KiFRLcXcW1wE6AoOA4cD9ZrbHWLHuPsPd+7p735YtWybsxW+/HZo1g4svDlcei4hkomQGwefAwUWW20briloNzHb3fHf/lNCn0DGJNRXTrFkYN2XhQrj77lS9qohIeklmECwEOppZBzOrB5wPzC6xzSzC0QBm1oLQVPRJEmvaw/Dh8KMfwfXXw6pVFW8vIlLTJC0I3H0ncCkwB/gAeNzdl5rZzWZWMPbrHGCdmS0DXgaudvd1yaqpNGZwzz2haeiyy1L5yiIi6SFjxhqqyG23wbXXwpNPwhlnJHz3IiKx0lhDlTBhQri24NJLYcOGuKsREUkdBUGkbt1wbcGaNTBpUtzViIikjoKgiCOPDP0Ed98Nb74ZdzUiIqmhICjhllugTZtwbUF+ftzViIgkn4KghOxsuPPOMAbR738fdzUiIsmnICjFsGFw5plhHKKPP467GhGR5FIQlGH69NCBPG4cVLMzbEVEqkRBUIY2beDWW+HFF+Gvf427GhGR5FEQlGPcODjqqDCb2TffxF2NiEhyKAjKUTC15fr1cPXVcVcjIpIcCoIKdOsWQuDhh2Hu3LirERFJPAVBJdxwAxx6KIwdC9u2xV2NiEhiKQgqoWFDuPdeWLECpkyJuxoRkcRSEFTSiSfCyJFhfuOlS+OuRkQkcRQEVfD730PTpjBmDPzwQ9Wfn5sLOTmhEzonJyyLiMRNQVAFLVuGMHj99XA2UVXk5oYAWbkyXKC2cmVYVhiISNw0MU0VuYdmokWL4IMP4KCDKve8nJzw5V9S+/aQl5fICkVE9qSJaRLILHQcf/89XHFF5Z/32WdVWy8ikioKgr3QsWM4pfSJJ+Dppyv3nHbtqrZeRCRVFAR76eqroUsXuOQS2Ly54u2nTIGsrOLrsrJ0OqqIxE9BsJfq1QsdxqtWhaODiowYEbZv3z40L7VvH5ZHjEh+rSIi5VFn8T4aPz58ob/1FvQttRtGRCR+6ixOot/9Dlq1ClNb7twZdzUiIlWnINhH++0XJrFZsgT+8Ie4qxERqToFQQKcdRb89Kdw4426JkBEqh8FQQKYhQnvzeAXv9DUliJSvSgIEqRdu3Aq6HPPweOPx12NiEjlKQgS6NJLw5lDl18O330XdzUiIpWjIEig2rXDqaTr1sG118ZdjYhI5SgIEqxXL5gwAe6/HxYsiLsaEZGKKQiSYPLkcOXwmDFhcDoRkXSmIEiCRo3gnntg+XK49da4qxERKZ+CIElOOQXOPx9++9sQCCIi6UpBkETTpoURRseO3bupLUVEUkFBkEStWsHtt8P8+fDQQ3FXIyJSOgVBko0eDccdF+Yv+OqruKsREdlTUoPAzE42sw/NbIWZTSzl8VFmttbMlkQ/FyWznjjUqgX33QdbtoTTSkVE0k3SgsDMagN3AacARwDDzeyIUjZ9zN17Rj8PJKueOHXuDNddB3/7Gzz/fNzViIgUl8wjgiOBFe7+ibvvAGYCw5L4emntuuugU6cwkc2WLXFXIyJSKJlB0AZYVWR5dbSupLPM7F0ze8LMDk5iPbGqXz8MP5GXF4arFhFJF3F3Fj8N5Lh7d+AfwCOlbWRmY8xskZktWrt2bUoLTKSBA2HcOLjjDrj33rirEREJkhkEnwNF/8JvG63bzd3XuXvBIAwPAH1K25G7z3D3vu7et2XLlkkpNlWmT4fTTgvzFvz1r3FXIyKS3CBYCHQ0sw5mVg84H5hddAMza11kcSjwQRLrSQt168L//A8MHgyjRsFTT8VdkYhkuqQFgbvvBC4F5hC+4B9396VmdrOZDY02u9zMlprZv4DLgVHJqiedNGgA//u/0K9fGIbihRfirkhEMpl5NZtXsW/fvr5o0aK4y0iI774LRwb//ncIg2OPjbsiEampzGyxu/ct7bG4O4sz2v77hwBo1w5OPRUWL467IhHJRAqCmB1wALz4IjRrBj/+MSxdGndFIpJpFARpoG3bEAb16sFJJ8HHH8ddkYhkEgVBmjj00BAGO3bACSfAqlUVP0dEJBEUBGnkiCNgzpzQiXziifD113FXJCKZQEGQZvr0gWeeCUcEP/pRCAURkWRSEKShY48N1xl88EGY8nLTprgrEpGaTEGQpk46CR57DBYtgmHDYNu2uCsSkZpKQZDGTj8dHnkE5s2Dc84JHckiIommIEhzI0bAPfeEfoORI2HXrrgrEpGapk5lNjKzRsA2d//BzA4DDgeec/f8pFYnAIwdG/oJrr4aGjeG++8PU2CKiCRCpYIAmA8cZ2b7Ay8QRhY9DxiRrMKkuKuuCmFw880hDKZNA7O4qxKRmqCyQWDuvtXMfg7c7e63mdmSZBYme5o8GTZuDCHQpAn85jdxVyQiNUGlg8DMjiYcAfw8Wlc7OSVJWczC7GabN8Mtt0B2NlxzTdxViUh1V9kg+CVwHfBUNKfAIcDLyStLymIWprncvBmuvTY0E/3iF3FXJSLVWaWCwN1fAV4BMLNawDfufnkyC5Oy1a4Nf/4zbNkCl1wSjgxGjoy7KhGprip17omZPWpmTaKzh94HlpnZ1cktTcpTty48/jgMGRKmvHzyybgrEpHqqrInIR7h7huB04HngA6A/gaNWcGUl/37hykv58yp3PNycyEnJ5yCmpMTlkUkc1U2COqaWV1CEMyOrh+oXnNc1lCNG8Ozz0KXLnDGGbBgQfnb5+bCmDGwciW4h9sxYxQGIpmsskFwH5AHNALmm1l7YGOyipKq2W+/cDTQvn2Y8rK8KZ0nTYKtW4uv27o1rBeRzLTXk9ebWR1335ngeipUkyavT7TVq+G448K1Bq+8Al277rlNrVrhSKAkM/jhh+TXKCLx2OfJ682sqZndYWaLop/fE44OJI20bQsvvQT164fRS1es2HObdu1Kf25Z60Wk5qts09CfgE3AudHPRuChZBUle++QQ8KUlzt3lj7l5ZQpkJVVfF1WVlgvIpmpskFwqLvf5O6fRD+/Bg5JZmGy9wqmvFy/Pkx5+dVXhY+NGAEzZoT+BLNwO2NGWC8imamyQbDNzI4tWDCzAYCmSkljvXuHs4lWrw5TXn77beFjI0ZAXl7oE8jLUwiIZLrKBsE44C4zyzOzPOBOYGzSqpKEGDAAZs2C5cs15aWIlK1SQeDu/3L3HkB3oLu79wKGJLUySYiTTgpXIC9eDEOHaspLEdlTlaY3cfeN0RXGAFcmoR5JgmHDwthEr7wCZ5+tKS9FpLh9medK06JUIz/7WRi19Nln4T//U1Neikihyg5DXRoNMVHNjBkT+gmuuioMTfHAA5ryUkQqCAIz20TpX/gGNExKRZJUv/pVCINf/xq+/x7++Edo1izuqkQkTuX+Peju2e7epJSfbHffl6MJidFNN4UgeOwxOPzwMODcXo40IiI1gBoGMpAZ3HhjOJOoQ4fQZ3DyyfDxx3FXJiJxUBBksB494PXXQ/PQG2+EQepuvRXy8+OuTERSSUGQ4WrXhksvhWXLwkVn110HffrAm2/GXZmIpIqCQIAwcumTT4Yrkb/9Fo45JsyHvGFD3JWJSLIpCKSYYcPggw/gssvgnnvCAHZ//7s6k0VqsqQGgZmdbGYfmtkKM5tYznZnmZmbWamTJkhqZWfDH/4Ab70FLVuGq5GHDdtzSGsRqRmSFgRmVhu4CzgFOAIYbmZHlLJdNnAF8FayapG9069fmPby9tvDhDedO8O0aboqWaSmSeYRwZHAimj+gh3ATGBYKdv9BvhvYHsSa5G9VKdOuBJ56VIYOBAmTID+/eGdd+KuTEQSJZlB0AYo2piwOlq3m5n1Bg5292fK25GZjSmYJnPt2rWJr1QqlJMDzzwDM2eGOQ769g1XKW/eHHdlIrKvYussNrNawB3Aryra1t1nuHtfd+/bsmXL5BcnpTKD884LnckXXQR33AFduoSAEJHqK5lB8DlwcJHlttG6AtlAV2BeNNnNUcBsdRinv/33h/vugwULoFEjOO00OPdcWLMm7spEZG8kMwgWAh3NrIOZ1QPOB2YXPOjuG9y9hbvnuHsO8CYw1N0XJbEmSaBjjw19BTffDLNnh87ke+8NU2CKSPWRtCBw953ApcAc4APgcXdfamY3m9nQZL2upFb9+nDDDfDuu2Ge5PHj4bjjQueyiFQP5tXsSqG+ffv6okU6aEhH7vDII4VDXV9zDUyaBA01YLlI7MxssbuX2vSuK4slYcxg1ChYvhzOPx+mTIHu3cM1CCKSvhQEknAtW4Y5kv/xj3CUcOKJcOGF8M03xbfLzQ2npdaqFW5zc+OoVkQUBJI0J54I770H118Pjz4aJsF55JEQDrm5YerMlSvD8sqVYVlhIJJ66iOQlHj/fRg7Nsx/MGRIaD764os9t2vfHvLyUl6eSI2nPgKJXdeu4bqDe+4JM6OVFgIAn32W2rpEREEgKVSrFowbF65MzsoqfZt27VJbk4goCCQGrVvDjBnhGoSi6tQJQSEiqaUgkFiMGAEPPlh4BJCVFTqNr7sujG46YwZs3BhvjSKZQkEgsRkxovCsoS1bwlhFd9wR7o8dCwceGE47nT9fM6SJJJOCQNJGy5ZhvoP33oM334SRI+Gpp+D44+Gww+B3vyu7k1lE9p6CQNKOWWgeuu++cJTw8MNw0EHheoR27eCnP4VZsyA/P+5KRWoGBYGktUaNQvPQK6/Av/8NV18dTj894wxo2zYsL18ed5Ui1ZuCQKqNjh1D89Bnn8HTT8Mxx4Q5lDt3hgEDQufzpk1xVylS/SgIpNqpUydMhvPUU2HazNtvh2+/DbOmtW4NP/85vPaaOphFKktBINVaq1Zw1VWwbFn48j//fHjssTBpzhFHhJD48su4qxRJbwoCqRHMQlPRAw+EL/4HH4TmzcOcCG3bwumnh+aknTvjrlQk/SgIpMZp3BhGj4ZXXw3DWVx5JbzxBgwdCgcfDBMnho5nEQkUBFKjHX443HZb6EuYNQv69YOpU6FTJxg4MAyLvWVL3FWKxEtBIBmhbl0YNgxmz4ZVq+DWW0MT0qhRoYP54ovDY+vXx12pSOppPgLJWO6h+ehPf4LHH4etW8MIqX36hDkThgwJp6U2ahR3pSL7rrz5CBQEIsD334dhLebOhZdfDvfz88ORxFFHweDBIRiOOmrPUVNFqgNNTCNSjsawM+sAAAsrSURBVNzc0GcweHDoMxg7Fr77DubMCR3N27fDLbfAoEGw//5w0knhwra33tJZSFIz1Im7AJE4FcydvHVrWC6YOxnC6Kg/+lG4v359GAV17tzwc/31YX12dhgUr6ApqVu30LwkUp2oaUgyWk5O+PIvqaK5k7/+GubNKwyGjz4K65s3L2xGGjIkjJpqloTCRapIfQQiZahVq/ShKMzghx8qv59Vq0LfQkEwrFoV1h90UPFgyMlJSNkiVaYgECnD3h4RlMcdPv64sON57txwBAHQoUNhKAweHE5dFUkFBYFIGUr2EUCYNnPGjNBHkAjuYSykgqOFefMKr1fo3LkwGI4/PjQtiSSDgkCkHLm5MGlSGN66XTuYMiVxIVCaXbtgyZLCYFiwIFzdbBY6m3v2DLcFP61bq59B9p2CQCSN7dgBCxeGUHj11TBV55o1hY83awZduxYPh65doUmT+GqW6qe8INDpoyIxq1cvXME8YEDhunXrQiAU/Lz/Pvz5z8Un3mnfvjAUCgKiU6ewP5GqUBCIpKHmzcMFbIMGFa5zDx3bRQPivffg+ecLL2yrWzeEQcmjh/bt1bwkZVPTkEg1t2MHfPjhngHx2WeF22Rn79m81K1baHaSzKA+ApEMtGEDLF26Z0B8913hNq1b7xkOnTtDw4bx1S3JoT4CkQzUtGmYte2YYwrXucMXXxT2OxSEw513hoH3IFxkd8gh4ZqHDh3CtRZFbw84QM1MNY2CQCQNpOoUVjNo0yb8nHxy4fqdO2HFisKAWL4cPv0UnnwSvvmm+D4aNtwzHIre339/BUV1o6YhkZil4qK2fbF5c7jKOi8vhMOnnxbez8vbczKfJk3KD4rs7BS/AQHURyCS1pIxzEUqrV+/ZzgUBMannxYPOAgd1GU1O+XkqH8iWWILAjM7GfgDUBt4wN1vLfH4OOASYBewGRjj7svK26eCQGqaRA18l47cQ9NSWUGxcmVh30SBVq0KQ6FdOzjwwNCp3bp14f3sbDU/VVUsQWBmtYF/AycBq4GFwPCiX/Rm1sTdN0b3hwK/cPeTS9tfAQWB1DTV/YhgX/zwQ5g7uqyg+PzzcHpsSQ0bFg+Gsm5btoQ66gkF4jtr6Ehghbt/EhUxExgG7A6CghCINAKqVzuVSAJMmVJ6H8GUKfHVlCq1aoWhug86qPiV1QXcw+mua9aEwCjtdtkyeOmlPfsqCvbfsmXpRxUlbzN5bupkBkEbYFWR5dVA/5IbmdklwJVAPWBIaTsyszHAGIB27dolvFCROBV0CKdy4Lvqwiz0KTRrBl26lL/t9u0hHAoCorTQeO89+Oqr0qcYbdy47KBo2TKcDVX0pybNXZ3MpqGzgZPd/aJoeSTQ390vLWP7nwE/dvcLy9uvmoZEZF/88EMYy6m8o4yC26JjO5WUlVUYCs2aFQ+JkstF1+23XxgKJNXiahr6HDi4yHLbaF1ZZgL3JLEeEZHdzUUtW0L37uVvu2VLCIV16+Dbb0MzVcFPyeVPPim8v2VL+ftt3Lji8ChtuWlTqF07cZ9FgWQGwUKgo5l1IATA+cDPim5gZh3dPZrtlVOBjxARSRONGsGhh4afqtixo/zQKLn84YeF60ueRVXUH/8Il5baprJvkhYE7r7TzC4F5hBOH/2Tuy81s5uBRe4+G7jUzE4E8oHvgHKbhUREqoN69cJpsK1aVf2527aVHRoDBya+VtAFZSJSRKpna5PU0aBzIlKhkkNdrFwZlkFhUNPVirsAEUkPkybtORzE1q1hvdRsCgIRAYpPZFOZ9VJzKAhEBAh9AlVZLzWHgkBEgNAxnJVVfF2mDHWR6RQEIgKEDuEZMwonum/fPn3mRJDk0llDIrLbiBH64s9EOiIQEclwCgIRSTu5uWGehlq1wm1ubtwV1WxqGhKRtKIL21JPRwQiklZ0YVvqKQhEJK3owrbUUxCISFrRhW2ppyAQkbSiC9tST0EgImlFF7alns4aEpG0owvbUktHBCIiZciU6xl0RCAiUopMup5BRwQiIqXIpOsZFAQiIqXIpOsZFAQiIqXIpOsZFAQiIqXIpOsZFAQiIqVIp+sZkn32ks4aEhEpQzpcz5CKs5d0RCAiksZScfaSgkBEJI2l4uwlBYGISBpLxdlLCgIRkTSWirOXFAQiImksFWcv6awhEZE0l+yzl3REICKS4RQEIiIZTkEgIpLhFAQiIhlOQSAikuHM3eOuoUrMbC2wMu469lEL4Ju4i0gj+jwK6bMoTp9HcfvyebR395alPVDtgqAmMLNF7t437jrShT6PQvositPnUVyyPg81DYmIZDgFgYhIhlMQxGNG3AWkGX0ehfRZFKfPo7ikfB7qIxARyXA6IhARyXAKAhGRDKcgSCEzO9jMXjazZWa21MyuiLumuJlZbTN7x8z+L+5a4mZm+5nZE2a23Mw+MLOj464pTmY2Ifp/8r6Z/c3MGsRdU6qY2Z/M7Gsze7/IumZm9g8z+yi63T9Rr6cgSK2dwK/c/QjgKOASMzsi5pridgXwQdxFpIk/AM+7++FADzL4czGzNsDlQF937wrUBs6Pt6qUehg4ucS6icBL7t4ReClaTggFQQq5+xp3fzu6v4nwH71NvFXFx8zaAqcCD8RdS9zMrCkwEHgQwN13uPv6eKuKXR2goZnVAbKAL2KuJ2XcfT7wbYnVw4BHovuPAKcn6vUUBDExsxygF/BWvJXEahpwDfBD3IWkgQ7AWuChqKnsATNrFHdRcXH3z4GpwGfAGmCDu78Qb1Wxa+Xua6L7XwKtErVjBUEMzKwx8Hfgl+6+Me564mBmpwFfu/viuGtJE3WA3sA97t4L2EICD/2rm6j9exghIA8CGpnZf8ZbVfrwcN5/ws79VxCkmJnVJYRArrs/GXc9MRoADDWzPGAmMMTM/hpvSbFaDax294IjxCcIwZCpTgQ+dfe17p4PPAkcE3NNcfvKzFoDRLdfJ2rHCoIUMjMjtAF/4O53xF1PnNz9Ondv6+45hE7Aue6esX/xufuXwCoz6xStOgFYFmNJcfsMOMrMsqL/NyeQwZ3nkdnAhdH9C4H/TdSOFQSpNQAYSfjrd0n085O4i5K0cRmQa2bvAj2B38ZcT2yiI6MngLeB9wjfVRkz3ISZ/Q14A+hkZqvN7OfArcBJZvYR4Yjp1oS9noaYEBHJbDoiEBHJcAoCEZEMpyAQEclwCgIRkQynIBARyXAKApGIme0qclrvEjNL2JW9ZpZTdCRJkXRSJ+4CRNLINnfvGXcRIqmmIwKRCphZnpndZmbvmdk/zew/ovU5ZjbXzN41s5fMrF20vpWZPWVm/4p+CoZGqG1m90dj7L9gZg2j7S+P5qh418xmxvQ2JYMpCEQKNSzRNHRekcc2uHs34E7CqKkAfwQecffuQC4wPVo/HXjF3XsQxgtaGq3vCNzl7l2A9cBZ0fqJQK9oP+OS9eZEyqIri0UiZrbZ3RuXsj4PGOLun0SDBn7p7s3N7BugtbvnR+vXuHsLM1sLtHX374vsIwf4RzSpCGZ2LVDX3W8xs+eBzcAsYJa7b07yWxUpRkcEIpXjZdyviu+L3N9FYR/dqcBdhKOHhdFELCIpoyAQqZzzity+Ed1/ncLpE0cAC6L7LwHjYfeczE3L2qmZ1QIOdveXgWuBpsAeRyUiyaS/PEQKNTSzJUWWn3f3glNI949GBf0eGB6tu4wwo9jVhNnF/l+0/gpgRjRi5C5CKKyhdLWBv0ZhYcB0TVEpqaY+ApEKRH0Efd39m7hrEUkGNQ2JiGQ4HRGIiGQ4HRGIiGQ4BYGISIZTEIiIZDgFgYhIhlMQiIhkuP8PqGKPo3jAlc8AAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "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.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend(loc='lower right')\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "WDzpdRShNXdk",
        "outputId": "d8def16e-4c68-4635-b7a1-818ad6fb548d"
      },
      "execution_count": 37,
      "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"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Export the model"
      ],
      "metadata": {
        "id": "JAE99375NdLl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "export_model = tf.keras.Sequential([\n",
        "  vectorize_layer,\n",
        "  model,\n",
        "  layers.Activation('sigmoid')\n",
        "])\n",
        "\n",
        "export_model.compile(\n",
        "    loss=losses.BinaryCrossentropy(from_logits=False), optimizer=\"adam\", metrics=['accuracy']\n",
        ")\n",
        "\n",
        "# Test it with `raw_test_ds`, which yields raw strings\n",
        "loss, accuracy = export_model.evaluate(raw_test_ds)\n",
        "print(accuracy)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nB2Rl3edNgFY",
        "outputId": "18e0e9a7-712b-43c5-e2f5-7c107592011b"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "782/782 [==============================] - 11s 14ms/step - loss: 0.3101 - accuracy: 0.8739\n",
            "0.8738800287246704\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Inference on new data"
      ],
      "metadata": {
        "id": "bS30nHR8NjZo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "examples = [\n",
        "  \"The movie was great!\",\n",
        "  \"The movie was okay.\",\n",
        "  \"The movie was terrible...\"\n",
        "]\n",
        "\n",
        "export_model.predict(examples)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0ROBHLReNoQL",
        "outputId": "6907fe6b-c3a1-42f0-b541-2d85e8916b3b"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.6448705 ],\n",
              "       [0.47012255],\n",
              "       [0.38437638]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    }
  ]
}