To_Perform_Text_Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **To Perform Text classification in NLP**\n"
      ],
      "metadata": {
        "id": "oohGu3R1CJLN"
      }
    },
    {
      "cell_type": "code",
      "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\n"
      ],
      "metadata": {
        "id": "cGlyQyHe_WX4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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": "Uub_TbZdAPwb",
        "outputId": "d7bb39f3-9948-48d2-b612-0924cb4376c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz\n",
            "84125825/84125825 [==============================] - 4s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "os.listdir(dataset_dir)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tSilljUVASdI",
        "outputId": "7c1e51dc-da45-4815-fe36-3d4f21af5a54"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['train', 'imdb.vocab', 'README', 'test', 'imdbEr.txt']"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "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": "GBTKJmV4AVD4",
        "outputId": "df4445bb-8fa3-43c1-a830-1a3d74d4e5e2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['neg',\n",
              " 'unsup',\n",
              " 'labeledBow.feat',\n",
              " 'urls_neg.txt',\n",
              " 'unsupBow.feat',\n",
              " 'urls_unsup.txt',\n",
              " 'urls_pos.txt',\n",
              " 'pos']"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "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": "qYUV-kFSAXrj",
        "outputId": "634de7f0-5ee5-47bc-dec8-77886ff93004"
      },
      "execution_count": null,
      "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": [
        "remove_dir = os.path.join(train_dir, 'unsup')\n",
        "shutil.rmtree(remove_dir)"
      ],
      "metadata": {
        "id": "rjjwWrEaAaqq"
      },
      "execution_count": null,
      "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": "Df_2v0Z1Ac4H",
        "outputId": "14f9e914-dd35-49cf-f8f4-945be3910963"
      },
      "execution_count": null,
      "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": "HPCNzv1tAjbE",
        "outputId": "e450a83f-9af0-41de-b338-d96bfa7fde85"
      },
      "execution_count": null,
      "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": "S4AWejHWAmp5",
        "outputId": "5492bcaf-23b1-4f4e-f1de-e825b6657244"
      },
      "execution_count": null,
      "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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uHhuWAwBAp5z",
        "outputId": "e9aa2d5c-f470-48c6-a5f8-f8a63aca36b1"
      },
      "execution_count": null,
      "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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZJi26PzBAtML",
        "outputId": "fe8c3dcb-d223-4ca4-85b6-37a0d0aad9fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 25000 files belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "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,\n",
        "                                  '[%s]' % re.escape(string.punctuation),\n",
        "                                  '')"
      ],
      "metadata": {
        "id": "eH911FD8Awhl"
      },
      "execution_count": null,
      "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)"
      ],
      "metadata": {
        "id": "KlMHjyObAz7_"
      },
      "execution_count": null,
      "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": "afa3VDLcA4eP"
      },
      "execution_count": null,
      "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": "FTz1XliYA71C"
      },
      "execution_count": null,
      "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": "3b_3g-36A-_H",
        "outputId": "0df93b7f-f123-45db-f486-e9a16f40a46e"
      },
      "execution_count": null,
      "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": "4kxF3LG4BEaS",
        "outputId": "5b2dd9e9-1369-4606-d8f6-a39a11d471ef"
      },
      "execution_count": null,
      "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": "xSZ95lJcBH0v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "AUTOTUNE = tf.data.AUTOTUNE\n",
        "\n",
        "train_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": "-tQQlx45BK2c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "embedding_dim = 16"
      ],
      "metadata": {
        "id": "wkeFAPbjBN2Y"
      },
      "execution_count": null,
      "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": "O4vcZwN8BRpk",
        "outputId": "c143b8b8-f61c-4237-a3cf-05824b3fb2e6"
      },
      "execution_count": null,
      "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": "code",
      "source": [
        "model.compile(loss=losses.BinaryCrossentropy(from_logits=True),\n",
        "              optimizer='adam',\n",
        "              metrics=tf.metrics.BinaryAccuracy(threshold=0.0))"
      ],
      "metadata": {
        "id": "XvGCFcwoBVPP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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": "lLN1TGofBYQ_",
        "outputId": "bb155fb5-0e34-4909-86d2-cabd9505b61e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "625/625 [==============================] - 13s 20ms/step - loss: 0.6665 - binary_accuracy: 0.6895 - val_loss: 0.6193 - val_binary_accuracy: 0.7692\n",
            "Epoch 2/10\n",
            "625/625 [==============================] - 5s 9ms/step - loss: 0.5532 - binary_accuracy: 0.7982 - val_loss: 0.5016 - val_binary_accuracy: 0.8214\n",
            "Epoch 3/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.4466 - binary_accuracy: 0.8442 - val_loss: 0.4219 - val_binary_accuracy: 0.8466\n",
            "Epoch 4/10\n",
            "625/625 [==============================] - 7s 11ms/step - loss: 0.3795 - binary_accuracy: 0.8658 - val_loss: 0.3749 - val_binary_accuracy: 0.8598\n",
            "Epoch 5/10\n",
            "625/625 [==============================] - 6s 10ms/step - loss: 0.3364 - binary_accuracy: 0.8783 - val_loss: 0.3458 - val_binary_accuracy: 0.8672\n",
            "Epoch 6/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.3064 - binary_accuracy: 0.8876 - val_loss: 0.3268 - val_binary_accuracy: 0.8698\n",
            "Epoch 7/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.2827 - binary_accuracy: 0.8965 - val_loss: 0.3133 - val_binary_accuracy: 0.8728\n",
            "Epoch 8/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.2635 - binary_accuracy: 0.9036 - val_loss: 0.3038 - val_binary_accuracy: 0.8742\n",
            "Epoch 9/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.2460 - binary_accuracy: 0.9097 - val_loss: 0.2968 - val_binary_accuracy: 0.8770\n",
            "Epoch 10/10\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.2321 - binary_accuracy: 0.9167 - val_loss: 0.2924 - val_binary_accuracy: 0.8792\n"
          ]
        }
      ]
    },
    {
      "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": "_7yxE9GIBbf8",
        "outputId": "f4963a52-a4fb-4e3b-e8e6-a3b7b5124a2c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "782/782 [==============================] - 9s 12ms/step - loss: 0.3105 - binary_accuracy: 0.8737\n",
            "Loss:  0.31054311990737915\n",
            "Accuracy:  0.8736799955368042\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history_dict = history.history\n",
        "history_dict.keys()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OBr4gw5WBe4K",
        "outputId": "9705f2f0-f77a-4dd8-df7c-369351eecff1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['loss', 'binary_accuracy', 'val_loss', 'val_binary_accuracy'])"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "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": "vrJ4Q2RZBh1d",
        "outputId": "9f0a8e7b-0411-48e6-913b-46663e415b17"
      },
      "execution_count": null,
      "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": "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": "Kr3qrxPsBi59",
        "outputId": "638e86f5-7a0c-473d-870e-8668d3afc302"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU1f3/8deHgEAAWcWFLViRxSpbxIqtS9WKdaH6xQqiBbVFcKv+aq1WWxGl1WqrtVor1gWRFlBbxBZXXKtWCaugoGhBg6jIvq+f3x/nhkzCJJlAJneSeT8fj3nMvecu85kbuJ8559x7rrk7IiIipdWJOwAREclMShAiIpKUEoSIiCSlBCEiIkkpQYiISFJKECIikpQShKTMzJ41syFVvW6czGyxmZ2Uhv26mR0STf/FzH6Vyrp78DmDzeyFPY1TpDym+yBqNzNbnzCbC2wBdkTzl7j7+OqPKnOY2WLgx+7+UhXv14FO7r6oqtY1szzgf0A9d99eFXGKlKdu3AFIerl746Lp8k6GZlZXJx3JFPr3mBnUxJSlzOx4Mys0s1+Y2RfAI2bW3Mz+ZWbLzWxVNN02YZtXzezH0fRQM/uPmd0Zrfs/Mzt1D9ftaGavm9k6M3vJzO4zs8fLiDuVGG8xszej/b1gZq0Sll9gZkvMbIWZ3VDO8TnKzL4ws5yEsrPMbG403cfM3jaz1Wa2zMzuNbN9ytjXo2Z2a8L8z6NtPjezi0qte5qZzTKztWb2mZmNTFj8evS+2szWm9nRRcc2Yfu+ZjbdzNZE731TPTaVPM4tzOyR6DusMrPJCcv6m9ns6Dt8bGb9ovISzXlmNrLo72xmeVFT28Vm9inwclT+RPR3WBP9GzksYfuGZvb76O+5Jvo31tDM/m1mV5T6PnPN7Kxk31XKpgSR3Q4AWgAdgGGEfw+PRPPtgU3AveVsfxSwEGgF/A54yMxsD9b9G/Au0BIYCVxQzmemEuN5wIVAa2Af4BoAM+sG3B/t/6Do89qShLu/A2wAvltqv3+LpncAV0ff52jgRODScuImiqFfFM/JQCegdP/HBuBHQDPgNGCEmf0gWnZs9N7M3Ru7+9ul9t0C+DdwT/Td/gD828xalvoOux2bJCo6zuMITZaHRfu6K4qhD/AY8PPoOxwLLC7reCRxHNAVOCWaf5ZwnFoDM4HEJtE7gd5AX8K/42uBncBY4PyilcysO9CGcGykMtxdryx5Ef6jnhRNHw9sBRqUs34PYFXC/KuEJiqAocCihGW5gAMHVGZdwslnO5CbsPxx4PEUv1OyGG9MmL8UeC6a/jUwIWFZo+gYnFTGvm8FHo6mmxBO3h3KWPcq4J8J8w4cEk0/CtwaTT8M3Jaw3qGJ6ybZ793AXdF0XrRu3YTlQ4H/RNMXAO+W2v5tYGhFx6Yyxxk4kHAibp5kvQeK4i3v3180P7Lo75zw3Q4uJ4Zm0TpNCQlsE9A9yXoNgFWEfh0IieTP1f3/rTa8VIPIbsvdfXPRjJnlmtkDUZV9LaFJo1liM0spXxRNuPvGaLJxJdc9CFiZUAbwWVkBpxjjFwnTGxNiOihx3+6+AVhR1mcRagtnm1l94GxgprsvieI4NGp2+SKK4zeE2kRFSsQALCn1/Y4ys1eipp01wPAU91u07yWlypYQfj0XKevYlFDBcW5H+JutSrJpO+DjFONNZtexMbMcM7staqZaS3FNpFX0apDss6J/0xOB882sDjCIUOORSlKCyG6lL2H7GdAZOMrd96W4SaOsZqOqsAxoYWa5CWXtyll/b2Jclrjv6DNblrWyu79POMGeSsnmJQhNVQsIv1L3BX65JzEQalCJ/gZMAdq5e1PgLwn7reiSw88JTUKJ2gNLU4irtPKO82eEv1mzJNt9BnyjjH1uINQeixyQZJ3E73ge0J/QDNeUUMsoiuFrYHM5nzUWGExo+tvopZrjJDVKEJKoCaHavjpqz74p3R8Y/SIvAEaa2T5mdjRwRppifBI43cy+HXUoj6Li/wN/A35KOEE+USqOtcB6M+sCjEgxhknAUDPrFiWo0vE3Ifw63xy155+XsGw5oWnn4DL2PRU41MzOM7O6ZnYu0A34V4qxlY4j6XF292WEvoE/R53Z9cysKIE8BFxoZieaWR0zaxMdH4DZwMBo/XxgQAoxbCHU8nIJtbSiGHYSmuv+YGYHRbWNo6PaHlFC2An8HtUe9pgShCS6G2hI+HX2X+C5avrcwYSO3hWEdv+JhBNDMnsco7vPBy4jnPSXEdqpCyvY7O+EjtOX3f3rhPJrCCfvdcCDUcypxPBs9B1eBhZF74kuBUaZ2TpCn8mkhG03AqOBNy1cPfWtUvteAZxO+PW/gtBpe3qpuFNV0XG+ANhGqEV9ReiDwd3fJXSC3wWsAV6juFbzK8Iv/lXAzZSskSXzGKEGtxR4P4oj0TXAe8B0YCVwOyXPaY8BhxP6tGQP6EY5yThmNhFY4O5pr8FI7WVmPwKGufu3446lplINQmJnZkea2TeiJol+hHbnyRVtJ1KWqPnuUmBM3LHUZEoQkgkOIFyCuZ5wDf8Id58Va0RSY5nZKYT+mi+puBlLyqEmJhERSUo1CBERSarWDNbXqlUrz8vLizsMEZEaZcaMGV+7+37JltWaBJGXl0dBQUHcYYiI1ChmVvru+13UxCQiIkkpQYiISFJKECIikpQShIiIJKUEISIiSSlBiIjUUOPHQ14e1KkT3sePr2iLyqk1l7mKiGST8eNh2DDYGD1qa8mSMA8weHDVfIZqECIiNdANNxQnhyIbN4byqqIEISJSA336aeXK94QShIhIDdS+9MNqKyjfE0oQIiI10OjRkJtbsiw3N5RXFSUIEZFKSvfVQ6kYPBjGjIEOHcAsvI8ZU3Ud1KCrmEREKqU6rh5K1eDB6f1M1SBERCqhOq4eyhRKECIilVAdVw9lCiUIEZFKqI6rhzKFEoSISCVUx9VDmUIJQkRqjGy5eihT6ComEakRsunqoUyhGoSI1AjZdPVQpkhrgjCzfma20MwWmdl1SZZ3MLNpZjbXzF41s7YJy4aY2UfRa0g64xSRzJdNVw9lirQlCDPLAe4DTgW6AYPMrFup1e4EHnP3I4BRwG+jbVsANwFHAX2Am8ysebpiFZHMl01XD2WKdNYg+gCL3P0Td98KTAD6l1qnG/ByNP1KwvJTgBfdfaW7rwJeBPqlMVYRyXDZdPVQpkhngmgDfJYwXxiVJZoDnB1NnwU0MbOWKW6LmQ0zswIzK1i+fHmVBS4iu4v7CqJsunooU8TdSX0NcJyZzQKOA5YCO1Ld2N3HuHu+u+fvt99+6YpRJOsVXUG0ZAm4F19BFEeSWLwYdu4M70oO6ZXOBLEUaJcw3zYq28XdP3f3s929J3BDVLY6lW1FpProCqLslM4EMR3oZGYdzWwfYCAwJXEFM2tlZkUxXA88HE0/D3zPzJpHndPfi8pEJAa6gig7pS1BuPt24HLCif0DYJK7zzezUWZ2ZrTa8cBCM/sQ2B8YHW27EriFkGSmA6OiMhGJga4gyk7m7nHHUCXy8/O9oKAg7jBEaqXSdzFDuIJIncQ1n5nNcPf8ZMvi7qQWkRpAVxBlJ43FJCIpyZbxh6SYahAiGS7u+w8ke6kGIZLBMmkEU8k+qkGIZDDdfyBxUoIQyWC6/0DipAQhksF0/4HESQlCJINpBFOJkxKESAbT/QcSJ13FJJLhdP+BxEU1CJEy6P4DyXaqQYgkofsPpDrt2AHr1sHatbBmTeXfu3WDp5+u+riUIESSKO/+AyUIKeIe/l3syUl97dri6fXrK/6sOnVg333Dq2nT8L7//tCpExx2WHq+nxKESBK6/yC7uIdf8CtXwooVqb2vXAmrVoVf/xVp1Kj4pF703q5dyfnS76XLGjUKFypUJyUIkSTatw/NSsnKJXO5w4YNu5/IUznZb99e9n6bNIEWLaBly/DeoUN4b948nLzLO8nvuy/k5FTfMahKShAiSYwenfz5B7r/oOq4w+bNsGnT7q+NG8svK0oCyU72W7eW/ZmNGpU80R9+eHhPLCv93qIF1KtXfcclkyhBiCRR1M9www2hWal9+5Acsq3/YceO4pPv11+H9w0bKncyL6ts8+aQJPZEw4YlT+ydOyc/sSeWNW8ODRpU7fGp7ZQgRMpQ2+4/2LEjtJkXneyLXqXnE8tWrUrtJF6vXqhhNWxY/Cqab9oUDjigZFnpdcorKz3foEHosJX0U4IQqYF27oTVq8s+sSebX7my7JN9/frQqlXxq127kvMtWxa/N2q0+4m7praxS/mUIERitG1b+JW+alXxVTFlvUqf7HfuTL7PffYpeXLv3r34BF/6hF/0ys2t/itkJPMpQYjspW3bwq/5ik7wyZZv2FD+vos6VZs3Dyf1ww/f/eRe+oQfx+WQUjspQUjGGT8+/s7hbdvg/fdh9mwoLCz/F35FNzk1ahRO8EWvgw8uni46+Sd7NWsWagMicVGCkIwSxxAX69fDnDkwa1ZICLNmwbx5JS+XzM0tefLu2BF69Sr75F508tdJXmoy8z29zizD5Ofne0FBQdxhyF7Ky0t+g1qHDrB48d7v/8svi5NAUUL46KPizttWraBnz/Dq0SO8d+wYOnFFaiMzm+Hu+cmWqQYhGaWqhrhwh08+KVkrmDULli0rXicvLySA888vTght2qj9XqSIEoRklD0Z4qKovyCxVjB7dhgIDcIlmN26wUknlawdNGuWnu8gUlsoQUhGqWiIi3XrYO7c4mQwaxbMn1/cX5CbGy7rPP/84iaib35Td9CK7An1QUjGKbqKackSaN0ajj8+lM+aBYsWJe8vKKoVdOqkm7ZEKkN9EFJjLFgQkkCjRmH+q69g0qTQUdyjB1xwQXFCOOgg9ReIpJMShMTu449h4sTwmjs3nPSPPRbuvBN691Z/gUhclCAkFkuWhJrBxIkwY0Yo69sX/vhHGDAg1A5EJF5KEFJtCgvhiSdCUnjnnVB25JGhpnDOOXoYj0imUYKQtPriC3jyyZAU/vOfUNajB/z2t/DDH4ZhJ0QkMylBSJX7+mt46qmQFF57LYw6ethhMGoUnHsuHHpo3BGKSCrSmiDMrB/wRyAH+Ku731ZqeXtgLNAsWuc6d59qZnnAB8DCaNX/uvvwdMYqe2fVKvjnP0NSmDYtPJzm0EPD5arnnhsShIjULGlLEGaWA9wHnAwUAtPNbIq7v5+w2o3AJHe/38y6AVOBvGjZx+7eI13xyd5buxaefjokhRdeCHc0H3wwXHttSApHHKHLUEVqsnTWIPoAi9z9EwAzmwD0BxIThAP7RtNNgc/TGI9UgfXr4ZlnwhVIzz4LW7aEzuWf/jQkhd69lRREaot0Jog2wGcJ84XAUaXWGQm8YGZXAI2AkxKWdTSzWcBa4EZ3f6P0B5jZMGAYQHtdApM2GzfC1KmhpvDvf4cHzh90EAwfHpLCUUfpGcEitVHcndSDgEfd/fdmdjQwzsy+CSwD2rv7CjPrDUw2s8PcfW3ixu4+BhgDYaiN6g6+NtuyBZ57LiSFKVPCk89at4YLLwxJ4dvfVlIQqe3SmSCWAu0S5ttGZYkuBvoBuPvbZtYAaOXuXwFbovIZZvYxcCigwZbSaPx4+PnPw5DYZmHMoxYt4LzzQlI47jioG/dPChGpNun87z4d6GRmHQmJYSBwXql1PgVOBB41s65AA2C5me0HrHT3HWZ2MNAJ+CSNsWa9sWPhJz8JHc0QkkP9+vCHP8CQIfHGJiLxSFsjgbtvBy4HnidcsjrJ3eeb2SgzOzNa7WfAT8xsDvB3YKiH4WWPBeaa2WzgSWC4u69MV6zZbvr0ksmhyJYtcNNN8cQkIvHTcN9ZbONG+PWv4a67ws1syZiVvUxEar7yhvtWN2OWeuUVOPxw+P3vwwN62rVLvp4uDhPJXkoQWWb16pAQvvvdcBXSq6/C/feHsZFyc0uum/gkNxHJPkoQWWTKlDDkxUMPhbud584NVyYBDB4MY8ZAhw6hWalDhzA/eHC8MYtIfHTRYhb46iu48spwT8MRR4ThMfKTtDgOHqyEICLFVIOoxdxh3Djo2jUMpHfrrVBQkDw5iIiUphpELfXpp3DJJeFu6KOPDs1KXbvGHZWI1CSqQdQyO3fCffeFvoY33oB77gnvSg4iUlmqQdQiCxfCj38cntz2ve/BAw9AXl7cUYlITaUaRC2wbVu4TLV7d5g/Hx59NDQtKTmIyN5QDaKGmzkTLr4YZs+GAQPgT3+CAw6IOyoRqQ1Ug6ihNm2C66+HPn3giy/CM6CfeELJQUSqjmoQNdAbb4S+hg8/hIsugjvvhObN445KRGob1SBqkLVr4bLL4NhjYetWePHFcPmqkoOIpIMSRA0xdSp885th3KSrroJ58+CkkyreTkRkT6mJKcN9/TVcfTU8/jh06wZvvQXf+lbcUYlINqiwBmFmZ5iZahrVzD2MndStG0yYEJ7bMHOmkoOIVJ9UTvznAh+Z2e/MrEu6AxJYuhR+8AMYODDcyzBzJtx8c3gEqIhIdakwQbj7+UBP4GPCs6PfNrNhZtYk7dFlmZ07wxDb3bqFDug774S33w4P9hERqW4pNR25+1rCs6EnAAcCZwEzzeyKNMaWVVasCJ3Ol1wCvXqFZzX87GeQkxN3ZCKSrVLpgzjTzP4JvArUA/q4+6lAd+Bn6Q0vO7jDkCHw5pth/KSXX4ZDDok7KhHJdqlcxfR/wF3u/npiobtvNLOL0xNWdvnDH+Df/w7DZAwbFnc0IiJBKgliJLCsaMbMGgL7u/tid5+WrsCyxX//C9ddB2efHW6CExHJFKn0QTwB7EyY3xGVyV5atSpcqdS2bbgj2izuiEREiqVSg6jr7luLZtx9q5ntk8aYsoJ7GEdp6dLQ99CsWdwRiYiUlEoNYrmZnVk0Y2b9ga/TF1J2+NOfYPJkuP32MCKriEimSaUGMRwYb2b3AgZ8BvworVHVcgUFcM01cMYZYRgNEZFMVGGCcPePgW+ZWeNofn3ao6rF1qyBc88Nz2149FH1O4hI5kppsD4zOw04DGhg0RnN3UelMa5ayT1cxrpkCbz+OrRoEXdEIiJlqzBBmNlfgFzgBOCvwADg3TTHVSs98ABMmgS33QZ9+8YdjYhI+VLppO7r7j8CVrn7zcDRwKHpDav2mT07PMehXz/4+c/jjkZEpGKpJIjN0ftGMzsI2EYYj0lStG5d6Hdo2RIeewzqaPB0EakBUumDeMbMmgF3ADMBBx5Ma1S1iDuMGAGLFoUxlvbbL+6IRERSU26CiB4UNM3dVwNPmdm/gAbuvqZaoqsFHn4Yxo+HUaPguOPijkZEJHXlNna4+07gvoT5LUoOqZs3D664Ak48EX75y7ijERGpnFRaw6eZ2f+Z6Yr9ytiwAX74Q9h33/A8aT3XQURqmlQSxCWEwfm2mNlaM1tnZmtT2bmZ9TOzhWa2yMyuS7K8vZm9YmazzGyumX0/Ydn10XYLzeyUlL9Rhrj8cliwIDQvHXBA3NGIiFReKo8cbeLuddx9H3ffN5rft6LtzCyH0Dx1KtANGGRm3UqtdiMwyd17AgOBP0fbdovmDwP6AX+O9lcjPPZYuEv6xhtD81JFxo8Pz56uUye8jx+f5gBFRFKQyo1yxyYrL/0AoST6AIvc/ZNoPxOA/sD7ibsBipJNU+DzaLo/MMHdtwD/M7NF0f7erijeuC1YAJdeGjqkb7qp4vXHjw93V2/cGOaXLCl+aNDgwemLU0SkIqlc5pp4W1cDwol6BvDdCrZrQxjYr0ghcFSpdUYCL0TPtm4EnJSw7X9Lbdum9AeY2TBgGED79u0rCCf9Nm0K/Q4NG4YTfyr9DjfcUJwcimzcGMqVIEQkTqk0MZ2R8DoZ+Cawqoo+fxDwqLu3Bb4PjIsurU2Ju49x93x3z98vA24wuOoqeO89GDcO2uyWzpL79NPKlYuIVJc9uae3EOiawnpLgXYJ822jskQXA5MA3P1tQg2lVYrbZpQJE2DMmPD40H79Ut+urIpPBlSIRCTLVZggzOxPZnZP9LoXeINwR3VFpgOdzKxj9AS6gcCUUut8CpwYfU5XQoJYHq030Mzqm1lHoBMZPEDgRx/BT34SBuAbVckxbkePhtzckmW5uaFcRCROqfRBFCRMbwf+7u5vVrSRu283s8uB54Ec4GF3n29mo4ACd58C/Ax40MyuJnRYD3V3B+ab2SRCh/Z24DJ331Gpb1ZNNm8O/Q777BNqEfXqVW77on6GG24IzUrt24fkoP4HEYmbhfNxOSuYNQI2F52go8tN67v7xnI3rGb5+fleUFBQ8YpV7PLL4b77YMqU8IQ4EZGaxMxmuHt+smUp3UkNNEyYbwi8VBWB1XRPPhmSw//7f0oOIlL7pJIgGiQ+ZjSazi1n/azwySdw8cXQpw/89rdxRyMiUvVSSRAbzKxX0YyZ9QY2pS+kzLd1KwwcGJ4nPWFC6H8QEaltUumkvgp4wsw+Bww4ADg3rVFluF/8AqZPh3/8Azp2jDsaEZH0qDBBuPt0M+sCdI6KFrr7tvSGlbmmTIG77w7DeJ91VtzRiIikTyr3QVwGNHL3ee4+D2hsZpemP7TMs2QJDB0KvXrBHXfEHY2ISHql0gfxk+iJcgC4+yrgJ+kLKTNt2waDBsH27TBxItSvH3dEIiLplUofRI6ZWXQDW9F9EFnXLXvjjfD226FT+pBD4o5GRCT9UkkQzwETzeyBaP4S4Nn0hZR5pk6F3/0OLrkEzs3q7nkRySapJIhfEIbUHh7NzyVcyZQVCgvhRz+CI46Au+6KOxoRkeqTynDfO4F3gMWEZ0F8F/ggvWFlhu3b4bzzwnhLkyaF5zyIiGSLMmsQZnYo4XkNg4CvgYkA7n5C9YQWv5Ej4Y03wvMdOneucHURkVqlvCamBYShvU9390UA0airWeHFF+E3v4GLLoLzz487GhGR6ldeE9PZwDLgFTN70MxOJNxJXestWxaSQteucM89cUcjIhKPMhOEu09294FAF+AVwpAbrc3sfjP7XnUFWN127AjPYli3LvQ7NGoUd0QiIvFIpZN6g7v/zd3PIDz6cxbhyqZaafRoeOWVMIz3YYfFHY2ISHwq9Uxqd1/l7mPc/cR0BRSnV1+Fm28OzUtDh8YdjYhIvCqVIGqzr74Kl7Qecgjcf38YyltEJJulcqNcrbdzJ1xwAaxcCc8+C40bxx2RiEj8lCCA22+HF16Av/wFunePOxoRkcyQ9U1MCxbAr34VxlgaNizuaEREMkfW1yA6d4axY+GMM9TvICKSKOsThFm470FERErK+iYmERFJTglCRESSUoIQEZGklCBERCQpJQgREUlKCUJERJJSghARkaSUIEREJCklCBERSUoJQkREklKCEBGRpNKaIMysn5ktNLNFZnZdkuV3mdns6PWhma1OWLYjYdmUdMYpIiK7S9tgfWaWA9wHnAwUAtPNbIq7v1+0jrtfnbD+FUDPhF1scvce6YpPRETKl84aRB9gkbt/4u5bgQlA/3LWHwT8PY3xiIhIJaQzQbQBPkuYL4zKdmNmHYCOwMsJxQ3MrMDM/mtmPyhju2HROgXLly+vqrhFRITM6aQeCDzp7jsSyjq4ez5wHnC3mX2j9EbuPsbd8909f7/99quuWEVEskI6E8RSoF3CfNuoLJmBlGpecvel0fsnwKuU7J8QEZE0S2eCmA50MrOOZrYPIQnsdjWSmXUBmgNvJ5Q1N7P60XQr4Bjg/dLbiohI+qTtKiZ3325mlwPPAznAw+4+38xGAQXuXpQsBgIT3N0TNu8KPGBmOwlJ7LbEq59ERCT9rOR5uebKz8/3goKCuMMQEalRzGxG1N+7m0zppBYRkQyjBCEiIkkpQYiISFJKECIikpQShIiIJKUEISIiSSlBiIhIUkoQIiKSlBKEiIgkpQQhIiJJKUGIiEhSShAiIpKUEoSIiCSlBCEiIkkpQYiISFJKECIikpQShIiIJKUEISIiSSlBiIhIUnXjDkBEar5t27ZRWFjI5s2b4w5FytCgQQPatm1LvXr1Ut5GCUJE9lphYSFNmjQhLy8PM4s7HCnF3VmxYgWFhYV07Ngx5e3UxCQie23z5s20bNlSySFDmRktW7asdA1PCUJEqoSSQ2bbk7+PEoSIiCSlBCEi1W78eMjLgzp1wvv48Xu3vxUrVtCjRw969OjBAQccQJs2bXbNb926tdxtCwoKuPLKKyv8jL59++5dkDWQOqlFpFqNHw/DhsHGjWF+yZIwDzB48J7ts2XLlsyePRuAkSNH0rhxY6655ppdy7dv307duslPd/n5+eTn51f4GW+99daeBVeDqQYhItXqhhuKk0ORjRtDeVUaOnQow4cP56ijjuLaa6/l3Xff5eijj6Znz5707duXhQsXAvDqq69y+umnAyG5XHTRRRx//PEcfPDB3HPPPbv217hx413rH3/88QwYMIAuXbowePBg3B2AqVOn0qVLF3r37s2VV165a7+JFi9ezHe+8x169epFr169SiSe22+/ncMPP5zu3btz3XXXAbBo0SJOOukkunfvTq9evfj444+r9kCVQzUIEalWn35aufK9UVhYyFtvvUVOTg5r167ljTfeoG7durz00kv88pe/5KmnntptmwULFvDKK6+wbt06OnfuzIgRI3a7d2DWrFnMnz+fgw46iGOOOYY333yT/Px8LrnkEl5//XU6duzIoEGDksbUunVrXnzxRRo0aMBHH33EoEGDKCgo4Nlnn+Xpp5/mnXfeITc3l5UrVwIwePBgrrvuOs466yw2b97Mzp07q/5AlUEJQkSqVfv2oVkpWXlVO+ecc8jJyQFgzZo1DBkyhI8++ggzY9u2bUm3Oe2006hfvz7169endevWfPnll7Rt27bEOn369NlV1qNHDxYvXkzjxo05+OCDd91nMGjQIMaMGbPb/rdt28bll1/O7NmzycnJ4cMPPwTgpZde4sILLyQ3NxeAFi1asG7dOpYuXcpZZ50FhJvdqpOamESkWo0eDdE5cJfc3FBe1Ro1arRr+le/+hUnnHAC8+bN45lnninznoD69evvms7JyWH79u17tE5Z7rrrLvbff3/mzJlDQUFBhZ3ocVKCEJFqNXgwjAsR8cIAAAvVSURBVBkDHTqAWXgfM2bPO6hTtWbNGtq0aQPAo48+WuX779y5M5988gmLFy8GYOLEiWXGceCBB1KnTh3GjRvHjh07ADj55JN55JFH2Bh10KxcuZImTZrQtm1bJk+eDMCWLVt2La8OShAiUu0GD4bFi2HnzvCe7uQAcO2113L99dfTs2fPSv3iT1XDhg3585//TL9+/ejduzdNmjShadOmu6136aWXMnbsWLp3786CBQt21XL69evHmWeeSX5+Pj169ODOO+8EYNy4cdxzzz0cccQR9O3bly+++KLKYy+LFfW+13T5+fleUFAQdxgiWemDDz6ga9eucYcRu/Xr19O4cWPcncsuu4xOnTpx9dVXxx3WLsn+TmY2w92TXuerGoSISBV58MEH6dGjB4cddhhr1qzhkksuiTukvaKrmEREqsjVV1+dUTWGvZXWGoSZ9TOzhWa2yMyuS7L8LjObHb0+NLPVCcuGmNlH0WtIOuMUEZHdpa0GYWY5wH3AyUAhMN3Mprj7+0XruPvVCetfAfSMplsANwH5gAMzom1XpSteEREpKZ01iD7AInf/xN23AhOA/uWsPwj4ezR9CvCiu6+MksKLQL80xioiIqWkM0G0AT5LmC+MynZjZh2AjsDLldnWzIaZWYGZFSxfvrxKghYRkSBTrmIaCDzp7jsqs5G7j3H3fHfP32+//dIUmohkuhNOOIHnn3++RNndd9/NiBEjytzm+OOPp+jS+O9///usXr16t3VGjhy5636EskyePJn339/Vcs6vf/1rXnrppcqEn7HSmSCWAu0S5ttGZckMpLh5qbLbikiWGzRoEBMmTChRNmHChDIHzCtt6tSpNGvWbI8+u3SCGDVqFCeddNIe7SvTpPMy1+lAJzPrSDi5DwTOK72SmXUBmgNvJxQ/D/zGzJpH898Drk9jrCJSRa66CqJHM1SZHj3g7rvLXj5gwABuvPFGtm7dyj777MPixYv5/PPP+c53vsOIESOYPn06mzZtYsCAAdx88827bZ+Xl0dBQQGtWrVi9OjRjB07ltatW9OuXTt69+4NhHscxowZw9atWznkkEMYN24cs2fPZsqUKbz22mvceuutPPXUU9xyyy2cfvrpDBgwgGnTpnHNNdewfft2jjzySO6//37q169PXl4eQ4YM4ZlnnmHbtm088cQTdOnSpURMixcv5oILLmDDhg0A3HvvvbseWnT77bfz+OOPU6dOHU499VRuu+02Fi1axPDhw1m+fDk5OTk88cQTfOMb39ir4562GoS7bwcuJ5zsPwAmuft8MxtlZmcmrDoQmOAJt3S7+0rgFkKSmQ6MispERHbTokUL+vTpw7PPPguE2sMPf/hDzIzRo0dTUFDA3Llzee2115g7d26Z+5kxYwYTJkxg9uzZTJ06lenTp+9advbZZzN9+nTmzJlD165deeihh+jbty9nnnkmd9xxB7Nnzy5xQt68eTNDhw5l4sSJvPfee2zfvp37779/1/JWrVoxc+ZMRowYkbQZq2hY8JkzZzJx4sRdT71LHBZ8zpw5XHvttUAYFvyyyy5jzpw5vPXWWxx44IF7d1BJ841y7j4VmFqq7Nel5keWse3DwMNpC05E0qK8X/rpVNTM1L9/fyZMmMBDDz0EwKRJkxgzZgzbt29n2bJlvP/++xxxxBFJ9/HGG29w1lln7Rpy+8wzi3/Lzps3jxtvvJHVq1ezfv16TjnllHLjWbhwIR07duTQQw8FYMiQIdx3331cddVVQEg4AL179+Yf//jHbttnwrDgmdJJHZuqfjauiMSjf//+TJs2jZkzZ7Jx40Z69+7N//73P+68806mTZvG3LlzOe2008oc5rsiQ4cO5d577+W9997jpptu2uP9FCkaMrys4cIzYVjwrE4QRc/GXbIE3IufjaskIVLzNG7cmBNOOIGLLrpoV+f02rVradSoEU2bNuXLL7/c1QRVlmOPPZbJkyezadMm1q1bxzPPPLNr2bp16zjwwAPZtm0b4xNOEk2aNGHdunW77atz584sXryYRYsWAWFU1uOOOy7l75MJw4JndYKormfjikj1GDRoEHPmzNmVILp3707Pnj3p0qUL5513Hsccc0y52/fq1Ytzzz2X7t27c+qpp3LkkUfuWnbLLbdw1FFHccwxx5ToUB44cCB33HEHPXv2LPG86AYNGvDII49wzjnncPjhh1OnTh2GDx+e8nfJhGHBs3q47zp1Qs2hNLMwTr2IpEbDfdcMGu67Esp6Bm46no0rIlLTZHWCqM5n44qI1DRZnSDiejauSG1UW5qra6s9+ftk/QODBg9WQhDZWw0aNGDFihW0bNkSM4s7HCnF3VmxYkWl74/I+gQhInuvbdu2FBYWolGVM1eDBg1o27ZtpbZRghCRvVavXj06duwYdxhSxbK6D0JERMqmBCEiIkkpQYiISFK15k5qM1sOLIk7jr3UCvg67iAyiI5HSToexXQsStqb49HB3ZM+krPWJIjawMwKyrrlPRvpeJSk41FMx6KkdB0PNTGJiEhSShAiIpKUEkRmGRN3ABlGx6MkHY9iOhYlpeV4qA9CRESSUg1CRESSUoIQEZGklCAygJm1M7NXzOx9M5tvZj+NO6a4mVmOmc0ys3/FHUvczKyZmT1pZgvM7AMzOzrumOJkZldH/0/mmdnfzaxyQ5TWcGb2sJl9ZWbzEspamNmLZvZR9N68Kj5LCSIzbAd+5u7dgG8Bl5lZt5hjittPgQ/iDiJD/BF4zt27AN3J4uNiZm2AK4F8d/8mkAMMjDeqavco0K9U2XXANHfvBEyL5veaEkQGcPdl7j4zml5HOAG0iTeq+JhZW+A04K9xxxI3M2sKHAs8BODuW919dbxRxa4u0NDM6gK5wOcxx1Ot3P11YGWp4v7A2Gh6LPCDqvgsJYgMY2Z5QE/gnXgjidXdwLXAzrgDyQAdgeXAI1GT21/NrFHcQcXF3ZcCdwKfAsuANe7+QrxRZYT93X1ZNP0FsH9V7FQJIoOYWWPgKeAqd18bdzxxMLPTga/cfUbcsWSIukAv4H537wlsoIqaD2qiqG29PyFxHgQ0MrPz440qs3i4d6FK7l9QgsgQZlaPkBzGu/s/4o4nRscAZ5rZYmAC8F0zezzekGJVCBS6e1GN8klCwshWJwH/c/fl7r4N+AfQN+aYMsGXZnYgQPT+VVXsVAkiA1h4iO9DwAfu/oe444mTu1/v7m3dPY/Q+fiyu2ftL0R3/wL4zMw6R0UnAu/HGFLcPgW+ZWa50f+bE8niTvsEU4Ah0fQQ4Omq2KkSRGY4BriA8Gt5dvT6ftxBSca4AhhvZnOBHsBvYo4nNlFN6klgJvAe4RyWVcNumNnfgbeBzmZWaGYXA7cBJ5vZR4Ra1m1V8lkaakNERJJRDUJERJJSghARkaSUIEREJCklCBERSUoJQkREklKCEKmAme1IuPx4tplV2Z3MZpaXOCqnSCapG3cAIjXAJnfvEXcQItVNNQiRPWRmi83sd2b2npm9a2aHROV5Zvaymc01s2lm1j4q39/M/mlmc6JX0RAROWb2YPSMgxfMrGG0/pXRM0LmmtmEmL6mZDElCJGKNSzVxHRuwrI17n44cC9hFFqAPwFj3f0IYDxwT1R+D/Cau3cnjKc0PyrvBNzn7ocBq4H/i8qvA3pG+xmeri8nUhbdSS1SATNb7+6Nk5QvBr7r7p9Egy1+4e4tzexr4EB33xaVL3P3Vma2HGjr7lsS9pEHvBg96AUz+wVQz91vNbPngPXAZGCyu69P81cVKUE1CJG942VMV8aWhOkdFPcNngbcR6htTI8ekCNSbZQgRPbOuQnvb0fTb1H8GMzBwBvR9DRgBOx65nbTsnZqZnWAdu7+CvALoCmwWy1GJJ30i0SkYg3NbHbC/HPuXnSpa/NolNUtwKCo7ArCE+B+Tnga3IVR+U+BMdHomzsIyWIZyeUAj0dJxIB79KhRqW7qgxDZQ1EfRL67fx13LCLpoCYmERFJSjUIERFJSjUIERFJSglCRESSUoIQEZGklCBERCQpJQgREUnq/wNJpqyK1hpbLQAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "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": "CmDK5uVpBnb6",
        "outputId": "073ad91f-5f9e-4f75-87df-743564c388a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "782/782 [==============================] - 10s 12ms/step - loss: 0.3105 - accuracy: 0.8737\n",
            "0.8736799955368042\n"
          ]
        }
      ]
    },
    {
      "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": "N3hyQLtlBqTe",
        "outputId": "6fd1a5ed-0fe1-44fe-b24f-594a8f97d97a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 382ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.60274893],\n",
              "       [0.42418835],\n",
              "       [0.34401143]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    }
  ]
}