3_mlp_intEncoding.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "AIM: To perform intent classification using MLP and integer encoding (TextVectorization Layer)."
      ],
      "metadata": {
        "id": "i2fv8bOaoXtW"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u-fY0v8Onsb9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "26b86d15-0644-41f1-a5df-9bd8b57b0ea9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Unzipping corpora/stopwords.zip.\n",
            "[nltk_data] Downloading package wordnet to /root/nltk_data...\n",
            "[nltk_data] Downloading package omw-1.4 to /root/nltk_data...\n"
          ]
        }
      ],
      "source": [
        "# import libraries\n",
        "from google.colab import drive\n",
        "import os\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import layers\n",
        "\n",
        "import string\n",
        "import re\n",
        "import nltk\n",
        "from nltk.corpus import stopwords\n",
        "nltk.download('stopwords')\n",
        "\n",
        "from sklearn import preprocessing\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# mount google drive and connect working directory\n",
        "drive.mount('/content/gdrive', force_remount = True)\n",
        "print (sorted(os.listdir('gdrive/My Drive/Colab Helper/ICData/Dataset')))\n",
        "os.chdir('gdrive/My Drive/Colab Helper/ICData/Dataset') # Connect to the directory"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uL4CPprgorGN",
        "outputId": "3aaf3341-3c4e-4ff6-f6b8-bb81d185607b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n",
            "['data_file.csv', 'glove.6B.100d.txt', 'glove.6B.50d.txt', 'model', 'test_.csv', 'train_.csv', 'valid_.csv']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# read train file and print it's shape\n",
        "traindf = pd.read_csv('train_.csv', usecols=['text','intent'])\n",
        "testdf = pd.read_csv('test_.csv', usecols=['text','intent'])\n",
        "validdf = pd.read_csv('valid_.csv', usecols=['text','intent'])\n",
        "\n",
        "print('Train Shape: ', traindf.shape)\n",
        "print('Test Shape: ', testdf.shape)\n",
        "print('Valid Shape: ', validdf.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IbRPziQBosdj",
        "outputId": "864ebb17-888d-44b1-b7aa-906d286d059e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train Shape:  (9951, 2)\n",
            "Test Shape:  (1280, 2)\n",
            "Valid Shape:  (2985, 2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Observation:\n",
        "\n",
        "1.   No NULL value present."
      ],
      "metadata": {
        "id": "M8tlwyUvowd-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# NULL value presence check\n",
        "print('NULL values: ', traindf['text'].isnull().sum())"
      ],
      "metadata": {
        "id": "2y0KcCuiovtk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b7b530ef-ccf7-46f3-e8a6-337150d1a369"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NULL values:  0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Observation:\n",
        "\n",
        "1.   Texts may not require a lot of text cleaning."
      ],
      "metadata": {
        "id": "4aNponEIo1m6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# display first 10 rows\n",
        "print('First 10 rows:\\n', traindf.head(10))"
      ],
      "metadata": {
        "id": "C49vJGUMo1OD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b695ef62-e14d-43cd-ffba-c03263d0e604"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First 10 rows:\n",
            "                                                 text              intent\n",
            "0                          find under night in-birth  SearchCreativeWork\n",
            "1         book a spot in town in the same area as me      BookRestaurant\n",
            "2                                         fimd glory  SearchCreativeWork\n",
            "3       i need a restaurant on july 18th in rose bud      BookRestaurant\n",
            "4  book a spot for 4 in oklahoma at south street ...      BookRestaurant\n",
            "5  i need to know what the weather will be like i...          GetWeather\n",
            "6  book a bistro in new zealand in 119 and a half...      BookRestaurant\n",
            "7           need a table for nine in east prairie la      BookRestaurant\n",
            "8  book a table for mindy and angelita at a resta...      BookRestaurant\n",
            "9  find me a table for two at seven somewhere in ...      BookRestaurant\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Text Processing**\n",
        "\n",
        "**Text Standardization, Tokenization, and Vectorization** (using tf.keras.layers.TextVectorization layer)\n",
        "\n",
        "1.   Convert to lowercase. ✅\n",
        "2.   Keep alphanumeric (remove punctuations if any). ✅\n",
        "3.   Remove stopwords. ✅\n",
        "4.   Perform stemming/lemmatization. ❌"
      ],
      "metadata": {
        "id": "-4a1icJAo_X0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# function to perform standardization\n",
        "@tf.keras.utils.register_keras_serializable() # if this line is not present; then the exported model will raise error while performing predictions\n",
        "def custom_standardization(input_data):\n",
        "  lowercase = tf.strings.lower(input_data)\n",
        "  remove_punctuation = tf.strings.regex_replace(lowercase, '[%s]' % re.escape(string.punctuation), '')\n",
        "  remove_stopwords = tf.strings.regex_replace(remove_punctuation, r'\\b(' + r'|'.join(stopwords.words('english')) + r')\\b\\s*', '')\n",
        "  return remove_stopwords"
      ],
      "metadata": {
        "id": "yEdjNB951Y38"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# creating TextVectorization layer\n",
        "max_features = 10000\n",
        "sequence_length = 65\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": "nI5KBixoWGbo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# calling adapt on a text-only dataset (without labels) of training data\n",
        "raw_train_ds = tf.data.Dataset.from_tensor_slices(traindf['text']).batch(64)\n",
        "vectorize_layer.adapt(raw_train_ds)"
      ],
      "metadata": {
        "id": "526Ge1M9z7L8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# get vocabulary size\n",
        "voc = vectorize_layer.get_vocabulary()\n",
        "print('Vocabulary size: {}'.format(len(voc)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rcKQ_uGeIeCF",
        "outputId": "5850896d-0a1f-4b44-d3e0-d1aadb3f5fa2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Vocabulary size: 9438\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Process Inputs**"
      ],
      "metadata": {
        "id": "SbFO_bqsdnyu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# text processing for all the x records (not on y records)\n",
        "traindf['text'] = traindf['text'].apply(lambda x: vectorize_layer(x))\n",
        "testdf['text'] = testdf['text'].apply(lambda x: vectorize_layer(x))\n",
        "validdf['text'] = validdf['text'].apply(lambda x: vectorize_layer(x))"
      ],
      "metadata": {
        "id": "j62HArIiJGx7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# label encode\n",
        "label_encoder = preprocessing.LabelEncoder()\n",
        "label_encoder.fit(traindf['intent']) # fit label encoder\n",
        "print('Label Encoder Classes: ', label_encoder.classes_)\n",
        "\n",
        "# transform labels\n",
        "traindf['intent'] = label_encoder.transform(traindf['intent'])\n",
        "testdf['intent'] = label_encoder.transform(testdf['intent'])\n",
        "validdf['intent'] = label_encoder.transform(validdf['intent'])"
      ],
      "metadata": {
        "id": "MC_W0lhd4EcK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "832f25bf-ab8a-4580-c1f4-11803506e20c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Label Encoder Classes:  ['AddToPlaylist' 'BookRestaurant' 'GetWeather' 'PlayMusic' 'RateBook'\n",
            " 'SearchCreativeWork' 'SearchScreeningEvent']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# convert model input data to arrays\n",
        "x_train = np.array([np.array(val) for val in traindf['text']])\n",
        "x_val = np.array([np.array(val) for val in validdf['text']])\n",
        "\n",
        "y_train = np.array([np.array(val) for val in traindf['intent']])\n",
        "y_val = np.array([np.array(val) for val in validdf['intent']])"
      ],
      "metadata": {
        "id": "3agWaghCEeCp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**MLP Training**\n",
        "\n",
        "Model 1"
      ],
      "metadata": {
        "id": "DjFmAMQxbJc0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# model definition\n",
        "num_tokens = len(voc) + 2\n",
        "embedding_dim = 8\n",
        "\n",
        "model1 = tf.keras.Sequential([\n",
        "  layers.Embedding(num_tokens, embedding_dim, input_length=sequence_length, name='Embedding_1'),\n",
        "  layers.Flatten(name='Flatten_1'),\n",
        "  layers.Dense(16, activation='relu', name='Dense_1'),\n",
        "  layers.Dropout(0.2, name='Dropout_1'),\n",
        "  layers.Dense(7, activation='softmax', name='Dense_2')])\n",
        "\n",
        "model1._name = 'ModelwithIntEncodingAndFlatten'\n",
        "model1.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RFiI-qTxvz0l",
        "outputId": "68016d12-8955-44f6-af6d-6314e0bbedfc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"ModelwithIntEncodingAndFlatten\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " Embedding_1 (Embedding)     (None, 65, 8)             75520     \n",
            "                                                                 \n",
            " Flatten_1 (Flatten)         (None, 520)               0         \n",
            "                                                                 \n",
            " Dense_1 (Dense)             (None, 16)                8336      \n",
            "                                                                 \n",
            " Dropout_1 (Dropout)         (None, 16)                0         \n",
            "                                                                 \n",
            " Dense_2 (Dense)             (None, 7)                 119       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 83,975\n",
            "Trainable params: 83,975\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# model compiling\n",
        "model1.compile(loss='sparse_categorical_crossentropy',\n",
        "              optimizer='adam',\n",
        "              metrics='accuracy')\n",
        "\n",
        "# model training\n",
        "epochs = 10\n",
        "%time history = model1.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=epochs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eTcA1h9GwUzr",
        "outputId": "7f2190d9-f3ec-440e-f2a7-c8f2bfef322e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "311/311 [==============================] - 2s 3ms/step - loss: 1.6254 - accuracy: 0.3559 - val_loss: 1.0744 - val_accuracy: 0.7226\n",
            "Epoch 2/10\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.7856 - accuracy: 0.7496 - val_loss: 0.3797 - val_accuracy: 0.9400\n",
            "Epoch 3/10\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.3991 - accuracy: 0.8859 - val_loss: 0.2279 - val_accuracy: 0.9561\n",
            "Epoch 4/10\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.2814 - accuracy: 0.9183 - val_loss: 0.1788 - val_accuracy: 0.9595\n",
            "Epoch 5/10\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.2307 - accuracy: 0.9275 - val_loss: 0.1568 - val_accuracy: 0.9621\n",
            "Epoch 6/10\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.1907 - accuracy: 0.9373 - val_loss: 0.1462 - val_accuracy: 0.9655\n",
            "Epoch 7/10\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.1524 - accuracy: 0.9517 - val_loss: 0.1398 - val_accuracy: 0.9678\n",
            "Epoch 8/10\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.1244 - accuracy: 0.9609 - val_loss: 0.1354 - val_accuracy: 0.9675\n",
            "Epoch 9/10\n",
            "311/311 [==============================] - 1s 2ms/step - loss: 0.1082 - accuracy: 0.9659 - val_loss: 0.1303 - val_accuracy: 0.9672\n",
            "Epoch 10/10\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.1017 - accuracy: 0.9690 - val_loss: 0.1363 - val_accuracy: 0.9675\n",
            "CPU times: user 10.2 s, sys: 969 ms, total: 11.2 s\n",
            "Wall time: 9.2 s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# plot the graphs\n",
        "history_dict = history.history # dictionary of result values\n",
        "epochs = range(1, len(history_dict['accuracy']) + 1) # number of epochs\n",
        "\n",
        "# plot for loss\n",
        "plt.plot(epochs, history_dict['loss'], 'bo', label='Training loss')\n",
        "plt.plot(epochs, history_dict['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",
        "plt.show()\n",
        "\n",
        "# plot for accuracy\n",
        "plt.plot(epochs, history_dict['accuracy'], 'bo', label='Training acc')\n",
        "plt.plot(epochs, history_dict['val_accuracy'], '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",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "VA8DK2ENzwND",
        "outputId": "fe09c79f-d0e5-4e62-c90e-2ab0526c3519"
      },
      "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"
          }
        },
        {
          "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": [
        "Model 2"
      ],
      "metadata": {
        "id": "opkuqK5UxACp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# model definition\n",
        "num_tokens = len(voc) + 2\n",
        "embedding_dim = 8\n",
        "\n",
        "model2 = tf.keras.Sequential([\n",
        "  layers.Embedding(num_tokens, embedding_dim, input_length=sequence_length, name='Embedding_1'),\n",
        "  layers.GlobalAveragePooling1D(name='GlobalAveragePool_1'),\n",
        "  layers.Dense(32, activation='relu', name='Dense_1'),\n",
        "  layers.Dropout(0.2, name='Dropout_1'),\n",
        "  layers.Dense(7, activation='softmax', name='Dense_2')])\n",
        "\n",
        "model2._name = 'ModelwithIntEncodingAndGlobalAveragePool'\n",
        "model2.summary()"
      ],
      "metadata": {
        "id": "-tiAKnUJJhlQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9fbce78c-0283-48bf-9886-0043482ddc56"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"ModelwithIntEncodingAndGlobalAveragePool\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " Embedding_1 (Embedding)     (None, 65, 8)             75520     \n",
            "                                                                 \n",
            " GlobalAveragePool_1 (Global  (None, 8)                0         \n",
            " AveragePooling1D)                                               \n",
            "                                                                 \n",
            " Dense_1 (Dense)             (None, 32)                288       \n",
            "                                                                 \n",
            " Dropout_1 (Dropout)         (None, 32)                0         \n",
            "                                                                 \n",
            " Dense_2 (Dense)             (None, 7)                 231       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 76,039\n",
            "Trainable params: 76,039\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# model compiling\n",
        "model2.compile(loss='sparse_categorical_crossentropy',\n",
        "              optimizer='adam',\n",
        "              metrics='accuracy')\n",
        "\n",
        "# model training\n",
        "epochs = 15\n",
        "%time history = model2.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=epochs)"
      ],
      "metadata": {
        "id": "VvfM-Kh6bdFx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5bfc312f-8eca-4b7c-aefc-4b0780abe9a0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 1.9317 - accuracy: 0.2320 - val_loss: 1.8858 - val_accuracy: 0.3176\n",
            "Epoch 2/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 1.6593 - accuracy: 0.4563 - val_loss: 1.3904 - val_accuracy: 0.6007\n",
            "Epoch 3/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 1.2110 - accuracy: 0.6372 - val_loss: 1.0072 - val_accuracy: 0.8375\n",
            "Epoch 4/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.8712 - accuracy: 0.7973 - val_loss: 0.6790 - val_accuracy: 0.9156\n",
            "Epoch 5/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.6066 - accuracy: 0.8629 - val_loss: 0.4791 - val_accuracy: 0.9363\n",
            "Epoch 6/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.4479 - accuracy: 0.9044 - val_loss: 0.3584 - val_accuracy: 0.9407\n",
            "Epoch 7/15\n",
            "311/311 [==============================] - 1s 2ms/step - loss: 0.3448 - accuracy: 0.9220 - val_loss: 0.2814 - val_accuracy: 0.9534\n",
            "Epoch 8/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.2691 - accuracy: 0.9415 - val_loss: 0.2320 - val_accuracy: 0.9511\n",
            "Epoch 9/15\n",
            "311/311 [==============================] - 1s 2ms/step - loss: 0.2216 - accuracy: 0.9496 - val_loss: 0.1896 - val_accuracy: 0.9642\n",
            "Epoch 10/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.1760 - accuracy: 0.9620 - val_loss: 0.1596 - val_accuracy: 0.9685\n",
            "Epoch 11/15\n",
            "311/311 [==============================] - 1s 2ms/step - loss: 0.1440 - accuracy: 0.9681 - val_loss: 0.1412 - val_accuracy: 0.9692\n",
            "Epoch 12/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.1224 - accuracy: 0.9736 - val_loss: 0.1259 - val_accuracy: 0.9715\n",
            "Epoch 13/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.1068 - accuracy: 0.9756 - val_loss: 0.1160 - val_accuracy: 0.9725\n",
            "Epoch 14/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.0931 - accuracy: 0.9785 - val_loss: 0.1094 - val_accuracy: 0.9725\n",
            "Epoch 15/15\n",
            "311/311 [==============================] - 1s 3ms/step - loss: 0.0848 - accuracy: 0.9801 - val_loss: 0.1032 - val_accuracy: 0.9722\n",
            "CPU times: user 14.3 s, sys: 1.29 s, total: 15.6 s\n",
            "Wall time: 12.9 s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# plot the graphs\n",
        "history_dict = history.history # dictionary of result values\n",
        "epochs = range(1, len(history_dict['accuracy']) + 1) # number of epochs\n",
        "\n",
        "# plot for loss\n",
        "plt.plot(epochs, history_dict['loss'], 'bo', label='Training loss')\n",
        "plt.plot(epochs, history_dict['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",
        "plt.show()\n",
        "\n",
        "# plot for accuracy\n",
        "plt.plot(epochs, history_dict['accuracy'], 'bo', label='Training acc')\n",
        "plt.plot(epochs, history_dict['val_accuracy'], '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",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "xALkGV6Pznr5",
        "outputId": "dd80df6b-f22a-4513-ea3a-bef7cd470e81"
      },
      "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"
          }
        },
        {
          "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": [
        "**Evaluate Model**"
      ],
      "metadata": {
        "id": "Lqi80zysdVyY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# evaluate model on test dataset\n",
        "x_test = np.array([np.array(val) for val in testdf['text']])\n",
        "y_test = np.array([np.array(val) for val in testdf['intent']])\n",
        "# model 1 evaluation\n",
        "print('Model 1 Evaluation on Test Set:')\n",
        "loss, accuracy = model1.evaluate(x_test, y_test)\n",
        "print(\"Loss: \", loss)\n",
        "print(\"Accuracy: \", accuracy)\n",
        "# model 2 evaluation\n",
        "print('\\nModel 2 Evaluation on Test Set:')\n",
        "loss, accuracy = model2.evaluate(x_test, y_test)\n",
        "print(\"Loss: \", loss)\n",
        "print(\"Accuracy: \", accuracy)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yyNR3LFEdZWx",
        "outputId": "e0fc151f-acb7-46ca-f145-4ba5e57a0dc6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model 1 Evaluation on Test Set:\n",
            "40/40 [==============================] - 0s 2ms/step - loss: 0.1277 - accuracy: 0.9672\n",
            "Loss:  0.12768003344535828\n",
            "Accuracy:  0.9671875238418579\n",
            "\n",
            "Model 2 Evaluation on Test Set:\n",
            "40/40 [==============================] - 0s 1ms/step - loss: 0.1056 - accuracy: 0.9711\n",
            "Loss:  0.10557307302951813\n",
            "Accuracy:  0.9710937738418579\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Export Best Model**"
      ],
      "metadata": {
        "id": "OOCtwhBJI-ri"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# save the model\n",
        "export_model = tf.keras.Sequential([\n",
        "  tf.keras.Input(shape=(1,), dtype=\"string\"),\n",
        "  vectorize_layer,\n",
        "  model2 ]) # saving model 2\n",
        "\n",
        "export_model.save('saved_model/model2_intencoding', save_format='tf')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UU3Z3GZ03Jp1",
        "outputId": "b171fdcf-7d9d-4788-e260-457834ee0fa8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Conclusion:**\n",
        "\n",
        "**Model 1:**\n",
        "\n",
        "INPUT => EMBEDDING(int encoding) => FLATTEN => FC => RELU => DO => FC => SOFTMAX\n",
        "1.   Trainable Parameters: 83,975\n",
        "1.   Epochs: 10\n",
        "2.   Loss and Accuracy:\n",
        "    *   Training Loss: 0.1017 - Training Accuracy: 0.9690\n",
        "    *   Validation Loss: 0.1363 - Validation Accuracy: 0.9675\n",
        "    *   Testing Loss: 0.1276 - Testing Accuracy: 0.9671\n",
        "3.   Wall Time: 9.2s\n",
        "**Model 2:**\n",
        "\n",
        "INPUT => EMBEDDING(int encoding) => GAP1D => FC => RELU => DO => FC => SOFTMAX\n",
        "1.   Trainable Parameters: 76,039\n",
        "1.   Epochs: 15\n",
        "2.   Loss and Accuracy:\n",
        "    *   Training Loss: 0.0437 - Training Accuracy: 0.9885\n",
        "    *   Validation Loss: 0.1214 - Validation Accuracy: 0.9712\n",
        "    *   Testing Loss: 0.1055 - Testing Accuracy: 0.9710\n",
        "3.   Wall Time: 12.9s\n",
        "\n",
        "**ANALYSIS:**\n",
        "\n",
        "1.   Model 1's flatten layer leads to more trainable parameters compared to Model 2 that uses GlobalAveragePooling1D.\n",
        "2.   Better performance is achieved by model 2."
      ],
      "metadata": {
        "id": "BMewobBSR9Kj"
      }
    }
  ]
}