fwaf_classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "fwaf_classification.ipynb",
      "provenance": [],
      "machine_shape": "hm",
      "authorship_tag": "ABX9TyOVqHohuxZe6EYH0R/4ZA6H",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dcpatton/cybersecurity_data_science/blob/main/fwaf_classification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Objective\n",
        "\n",
        "Using data from https://github.com/faizann24/Fwaf-Machine-Learning-driven-Web-Application-Firewall , which is composed of bad URL queries and good URL queries, we will make a binary classification prediction of them."
      ],
      "metadata": {
        "id": "BaGpdyd3CWEg"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "m-XUmllpKwQt",
        "outputId": "563f2527-9bd6-4882-ca46-21c78544e0ab"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.8.2'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "import tensorflow as tf\n",
        "import random\n",
        "\n",
        "seed = 53\n",
        "random.seed(seed)\n",
        "tf.random.set_seed(seed)\n",
        "tf.__version__"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# retrieve the data\n",
        "!curl 'https://raw.githubusercontent.com/faizann24/Fwaf-Machine-Learning-driven-Web-Application-Firewall/master/badqueries.txt' -o bad_queries.txt\n",
        "!curl 'https://raw.githubusercontent.com/faizann24/Fwaf-Machine-Learning-driven-Web-Application-Firewall/master/goodqueries.txt' -o good_queries.txt"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6VhYbLcQLGjL",
        "outputId": "e09467a1-cea0-453a-abaf-9c1f3f5d8a4c"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
            "                                 Dload  Upload   Total   Spent    Left  Speed\n",
            "100 3295k  100 3295k    0     0  2513k      0  0:00:01  0:00:01 --:--:-- 2512k\n",
            "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
            "                                 Dload  Upload   Total   Spent    Left  Speed\n",
            "100 22.9M  100 22.9M    0     0  10.8M      0  0:00:02  0:00:02 --:--:-- 10.8M\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "bad_queries = []\n",
        "lines = []\n",
        "with open('bad_queries.txt') as f:\n",
        "    bad_queries = f.readlines()\n",
        "\n",
        "good_queries = []\n",
        "lines = []\n",
        "with open('good_queries.txt') as f:\n",
        "    good_queries = f.readlines()"
      ],
      "metadata": {
        "id": "SYUQ1vpmLGlw"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "len(bad_queries), len(good_queries)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UZGQ8rctLGnv",
        "outputId": "d6790603-72c5-40b8-b4a4-3ee6af294c88"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(48126, 1294531)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib.parse\n",
        "def remove_quotes(l1):\n",
        "  result = []\n",
        "  for s in l1:\n",
        "    result.append(urllib.parse.unquote_plus(s))\n",
        "  return result\n",
        "bad_queries = remove_quotes(bad_queries)\n",
        "good_queries = remove_quotes(good_queries)"
      ],
      "metadata": {
        "id": "8113Img2NNQq"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "text = bad_queries + good_queries\n",
        "y_bad = [1 for i in range(0, len(bad_queries))]\n",
        "y_good = [0 for i in range(0, len(good_queries))]\n",
        "y = y_bad + y_good\n",
        "data = pd.DataFrame(text, columns=['url'])\n",
        "data['target'] = y\n",
        "data.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VnRhohYTNNTf",
        "outputId": "b2ceb5d8-075e-4499-9b2a-2f1737982316"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 1342657 entries, 0 to 1342656\n",
            "Data columns (total 2 columns):\n",
            " #   Column  Non-Null Count    Dtype \n",
            "---  ------  --------------    ----- \n",
            " 0   url     1342657 non-null  object\n",
            " 1   target  1342657 non-null  int64 \n",
            "dtypes: int64(1), object(1)\n",
            "memory usage: 20.5+ MB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Note the unbalanced distribution\n",
        "data.target.value_counts()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p3j1YjUXP7BH",
        "outputId": "6fe2966e-cbcc-484d-f923-4e857bcb2e76"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    1294531\n",
              "1      48126\n",
              "Name: target, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "total = 1342657 \n",
        "neg = 1294531\n",
        "pos = 48126\n",
        "weight_for_0 = (1 / neg) * (total / 2.0)\n",
        "weight_for_1 = (1 / pos) * (total / 2.0)\n",
        "\n",
        "class_weight = {0: weight_for_0, 1: weight_for_1}\n",
        "\n",
        "print('Weight for class 0: {:.2f}'.format(weight_for_0))\n",
        "print('Weight for class 1: {:.2f}'.format(weight_for_1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rLg60XuBGOlL",
        "outputId": "b8d8d35d-a2f6-41ad-cc38-492efd56ea17"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Weight for class 0: 0.52\n",
            "Weight for class 1: 13.95\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# shuffle the data\n",
        "data = data.sample(frac=1).reset_index(drop=True)"
      ],
      "metadata": {
        "id": "qnBUVgojVwrk"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "raw_ds = tf.data.Dataset.from_tensor_slices((data.url.values, data.target.values))"
      ],
      "metadata": {
        "id": "PqMguEFNP7Dx"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for url, target in raw_ds.take(1):\n",
        "  print(url)\n",
        "  print(target)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dsQvptqMNNWY",
        "outputId": "6ec63d00-58f9-4a0e-850d-42868dcd1521"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(b'/049831/\\n', shape=(), dtype=string)\n",
            "tf.Tensor(0, shape=(), dtype=int64)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "size = raw_ds.cardinality().numpy()\n",
        "train_size = int(0.8 * size)\n",
        "val_size = int(0.1 * size)\n",
        "test_size = int(0.1 * size)\n",
        "\n",
        "train_ds = raw_ds.take(train_size)\n",
        "test_ds = raw_ds.skip(train_size)\n",
        "val_ds = test_ds.take(val_size)\n",
        "test_ds = test_ds.skip(val_size)\n",
        "\n",
        "train_size, val_size, test_size"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m7OWTtrYNNY-",
        "outputId": "3b46aecd-5529-4363-8a02-ebebd820c5ac"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1074125, 134265, 134265)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size = 2048\n",
        "train_ds = train_ds.batch(batch_size)\n",
        "val_ds = val_ds.batch(batch_size)\n",
        "test_ds = test_ds.batch(batch_size)"
      ],
      "metadata": {
        "id": "GxPhJaNeW2O_"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "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",
        "  #                                 '')\n",
        "  return lowercase"
      ],
      "metadata": {
        "id": "1UpMJcWejpO3"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "max_length = data.url.str.len().max()\n",
        "max_length"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0MCP9MqxUOJf",
        "outputId": "9467f3f1-1ca3-44bd-bd3c-e9ff1d66577f"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3063"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "max_features = 10000\n",
        "sequence_length = 500\n",
        "type(sequence_length)\n",
        "vectorize_layer = tf.keras.layers.TextVectorization(standardize=custom_standardization,\n",
        "                                                    max_tokens=max_features, \n",
        "                                                    output_sequence_length=sequence_length)"
      ],
      "metadata": {
        "id": "jcMlSBSaWEBL"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_text = train_ds.map(lambda x, y: x)\n",
        "vectorize_layer.adapt(train_text)"
      ],
      "metadata": {
        "id": "MTfhvChVWEEV"
      },
      "execution_count": 17,
      "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": "ncviy-S9WEHD"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_ds = train_ds.map(vectorize_text)\n",
        "val_ds = val_ds.map(vectorize_text)\n",
        "test_ds = test_ds.map(vectorize_text)"
      ],
      "metadata": {
        "id": "zVsL9vJGWjOV"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_ds = train_ds.shuffle(1024).prefetch(tf.data.AUTOTUNE)\n",
        "val_ds = val_ds.cache().prefetch(tf.data.AUTOTUNE)\n",
        "test_ds = test_ds.cache().prefetch(tf.data.AUTOTUNE)"
      ],
      "metadata": {
        "id": "9SUOXCH3Y_ii"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Logistic Regression"
      ],
      "metadata": {
        "id": "zK0UMQpU_uyA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# tf.keras.backend.clear_session()\n",
        "\n",
        "# inp = tf.keras.Input(shape=(sequence_length, ))\n",
        "# out = tf.keras.layers.Dense(1, activation='sigmoid')(inp)\n",
        "\n",
        "# model = tf.keras.Model(inp, out)\n",
        "# model.summary()"
      ],
      "metadata": {
        "id": "zBod9mJn_1Lw"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),\n",
        "#               loss='bce', metrics=[tf.keras.metrics.AUC(curve='PR'), tf.keras.metrics.AUC(name='auroc')])\n",
        "# es = tf.keras.callbacks.EarlyStopping(patience=9, verbose=1, restore_best_weights=True)\n",
        "# history = model.fit(train_ds, epochs=500, validation_data=val_ds, verbose=2,\n",
        "#                     class_weight=class_weight, callbacks=[es])"
      ],
      "metadata": {
        "id": "DKm9eJrY_0_G"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# model.evaluate(test_ds)"
      ],
      "metadata": {
        "id": "bMs0Ls7sACug"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## LSTM"
      ],
      "metadata": {
        "id": "sV99u_88yevy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.keras.backend.clear_session()\n",
        "\n",
        "inp = tf.keras.Input(shape=(None,))\n",
        "x = tf.keras.layers.Embedding(max_features+1, 64)(inp)\n",
        "x = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64))(x)\n",
        "out = tf.keras.layers.Dense(1, activation='sigmoid')(x)\n",
        "\n",
        "model = tf.keras.Model(inp, out)\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GMAOsUB4WjRP",
        "outputId": "33d14255-b626-4448-dffd-03274fad19ad"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, None)]            0         \n",
            "                                                                 \n",
            " embedding (Embedding)       (None, None, 64)          640064    \n",
            "                                                                 \n",
            " bidirectional (Bidirectiona  (None, 128)              66048     \n",
            " l)                                                              \n",
            "                                                                 \n",
            " dense (Dense)               (None, 1)                 129       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 706,241\n",
            "Trainable params: 706,241\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),\n",
        "              loss=tf.keras.losses.BinaryFocalCrossentropy(),\n",
        "              metrics=[tf.keras.metrics.AUC(curve='PR')])\n",
        "es = tf.keras.callbacks.EarlyStopping(patience=19, verbose=1, restore_best_weights=True)\n",
        "history = model.fit(train_ds, epochs=500, validation_data=val_ds, verbose=2,\n",
        "                    class_weight=class_weight, callbacks=[es])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jZe3Hr7Ca1mq",
        "outputId": "19d3f175-cc62-4d78-e4ca-dd2849b7d628"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/500\n",
            "525/525 - 152s - loss: 0.1575 - auc: 0.2459 - val_loss: 0.1328 - val_auc: 0.3354 - 152s/epoch - 290ms/step\n",
            "Epoch 2/500\n",
            "525/525 - 142s - loss: 0.1398 - auc: 0.4074 - val_loss: 0.1428 - val_auc: 0.4286 - 142s/epoch - 270ms/step\n",
            "Epoch 3/500\n",
            "525/525 - 141s - loss: 0.1344 - auc: 0.4512 - val_loss: 0.1260 - val_auc: 0.4475 - 141s/epoch - 269ms/step\n",
            "Epoch 4/500\n",
            "525/525 - 141s - loss: 0.1323 - auc: 0.4639 - val_loss: 0.1220 - val_auc: 0.4537 - 141s/epoch - 269ms/step\n",
            "Epoch 5/500\n",
            "525/525 - 141s - loss: 0.1312 - auc: 0.4691 - val_loss: 0.1333 - val_auc: 0.4568 - 141s/epoch - 269ms/step\n",
            "Epoch 6/500\n",
            "525/525 - 141s - loss: 0.1304 - auc: 0.4725 - val_loss: 0.1327 - val_auc: 0.4584 - 141s/epoch - 269ms/step\n",
            "Epoch 7/500\n",
            "525/525 - 141s - loss: 0.1300 - auc: 0.4735 - val_loss: 0.1106 - val_auc: 0.4596 - 141s/epoch - 269ms/step\n",
            "Epoch 8/500\n",
            "525/525 - 141s - loss: 0.1296 - auc: 0.4744 - val_loss: 0.1232 - val_auc: 0.4600 - 141s/epoch - 269ms/step\n",
            "Epoch 9/500\n",
            "525/525 - 141s - loss: 0.1293 - auc: 0.4754 - val_loss: 0.1200 - val_auc: 0.4604 - 141s/epoch - 269ms/step\n",
            "Epoch 10/500\n",
            "525/525 - 141s - loss: 0.1292 - auc: 0.4759 - val_loss: 0.1231 - val_auc: 0.4608 - 141s/epoch - 269ms/step\n",
            "Epoch 11/500\n",
            "525/525 - 141s - loss: 0.1290 - auc: 0.4760 - val_loss: 0.1243 - val_auc: 0.4611 - 141s/epoch - 269ms/step\n",
            "Epoch 12/500\n",
            "525/525 - 141s - loss: 0.1289 - auc: 0.4772 - val_loss: 0.1371 - val_auc: 0.4614 - 141s/epoch - 269ms/step\n",
            "Epoch 13/500\n",
            "525/525 - 141s - loss: 0.1288 - auc: 0.4767 - val_loss: 0.1287 - val_auc: 0.4616 - 141s/epoch - 269ms/step\n",
            "Epoch 14/500\n",
            "525/525 - 141s - loss: 0.1287 - auc: 0.4770 - val_loss: 0.1421 - val_auc: 0.4614 - 141s/epoch - 269ms/step\n",
            "Epoch 15/500\n",
            "525/525 - 141s - loss: 0.1289 - auc: 0.4766 - val_loss: 0.1244 - val_auc: 0.4616 - 141s/epoch - 269ms/step\n",
            "Epoch 16/500\n",
            "525/525 - 141s - loss: 0.1286 - auc: 0.4774 - val_loss: 0.1129 - val_auc: 0.4617 - 141s/epoch - 269ms/step\n",
            "Epoch 17/500\n",
            "525/525 - 141s - loss: 0.1286 - auc: 0.4769 - val_loss: 0.1169 - val_auc: 0.4618 - 141s/epoch - 269ms/step\n",
            "Epoch 18/500\n",
            "525/525 - 141s - loss: 0.1285 - auc: 0.4774 - val_loss: 0.1333 - val_auc: 0.4618 - 141s/epoch - 269ms/step\n",
            "Epoch 19/500\n",
            "525/525 - 141s - loss: 0.1285 - auc: 0.4773 - val_loss: 0.1222 - val_auc: 0.4619 - 141s/epoch - 269ms/step\n",
            "Epoch 20/500\n",
            "525/525 - 141s - loss: 0.1284 - auc: 0.4776 - val_loss: 0.1197 - val_auc: 0.4619 - 141s/epoch - 269ms/step\n",
            "Epoch 21/500\n",
            "525/525 - 141s - loss: 0.1285 - auc: 0.4774 - val_loss: 0.1159 - val_auc: 0.4619 - 141s/epoch - 269ms/step\n",
            "Epoch 22/500\n",
            "525/525 - 141s - loss: 0.1284 - auc: 0.4774 - val_loss: 0.1205 - val_auc: 0.4617 - 141s/epoch - 269ms/step\n",
            "Epoch 23/500\n",
            "525/525 - 141s - loss: 0.1284 - auc: 0.4776 - val_loss: 0.1300 - val_auc: 0.4617 - 141s/epoch - 269ms/step\n",
            "Epoch 24/500\n",
            "525/525 - 141s - loss: 0.1284 - auc: 0.4774 - val_loss: 0.1222 - val_auc: 0.4619 - 141s/epoch - 269ms/step\n",
            "Epoch 25/500\n",
            "525/525 - 141s - loss: 0.1283 - auc: 0.4777 - val_loss: 0.1220 - val_auc: 0.4620 - 141s/epoch - 269ms/step\n",
            "Epoch 26/500\n",
            "Restoring model weights from the end of the best epoch: 7.\n",
            "525/525 - 141s - loss: 0.1283 - auc: 0.4776 - val_loss: 0.1213 - val_auc: 0.4618 - 141s/epoch - 269ms/step\n",
            "Epoch 26: early stopping\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "history = history.history\n",
        "\n",
        "fig, (ax1, ax2) = plt.subplots(2, 1, sharex='col', figsize=(20, 14))\n",
        "\n",
        "ax1.plot(history['loss'], label='Train loss')\n",
        "ax1.plot(history['val_loss'], label='Validation loss')\n",
        "ax1.legend(loc='best')\n",
        "ax1.set_title('Loss')\n",
        "\n",
        "ax2.plot(history['auc'], label='Training')\n",
        "ax2.plot(history['val_auc'], label='Validation')\n",
        "ax2.legend(loc='best')\n",
        "ax2.set_title('AUC')\n",
        "\n",
        "plt.xlabel('Epochs')\n",
        "sns.despine()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 839
        },
        "id": "iPIFAgv4kOBE",
        "outputId": "a3ddfd32-d524-4f86-f0fa-234a4025213d"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x1008 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.evaluate(test_ds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OB7azZNZa2Du",
        "outputId": "c9615327-647f-4ad6-f190-544ad14c277d"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "66/66 [==============================] - 6s 74ms/step - loss: 0.1104 - auc: 0.4769\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.11043694615364075, 0.4769119918346405]"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Results\n",
        "The final model gives the best result. Hyperparameter tuning could probably help as well as increasing the sequence_length in the TextVectorization.\n",
        "\n",
        "* baseline logistic regression      : loss: 0.1552 - auc: 0.1489\n",
        "* LR with class_weight              : loss: 0.6415 - auc: 0.1535\n",
        "* baseline LSTM                     : loss: 0.1547 - auc: 0.0359\n",
        "* custom standardization            : loss: 0.1552 - auc: 0.0361\n",
        "* bidirectional                     : loss: 0.1035 - auc: 0.4643\n",
        "* lstm units=128                    : loss: 0.1036 - auc: 0.4725\n",
        "* class_weight                      : loss: 0.4158 - auc: 0.4793\n",
        "* another lstm layer units=64       : loss: 0.4222 - auc: 0.4588\n",
        "* sequence length = 500             : loss: 0.4237 - auc: 0.4660\n",
        "* BinaryFocalCrossentropy           : **loss: 0.1083 - auc: 0.4796**\n",
        "* lr=1e-4                           : loss: 0.1104 - auc: 0.4769"
      ],
      "metadata": {
        "id": "jT4qqYvkkiej"
      }
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "V0U0AKZ_bdQY"
      },
      "execution_count": 27,
      "outputs": []
    }
  ]
}