Text_Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Text_Classification.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPpwlOM8VYJa7QabNcasu0S",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/DhilipSanjay/Detection-of-Sensitive-Data-Exposure-in-Images/blob/main/Text_Classification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sM59X-o79RgC"
      },
      "source": [
        "# Text Classification to detect sensitive data exposure\n",
        "\n",
        "## Importing libraries and downloading the dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "leaIgZqWI9HX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "70d435a6-1a95-4735-bd60-858f2a1199ed"
      },
      "source": [
        "# Importing the necessary libraries\n",
        "import tensorflow as tf\n",
        "import json\n",
        "import os\n",
        "import random\n",
        "\n",
        "from tensorflow.keras.preprocessing.text import Tokenizer\n",
        "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
        "\n",
        "# Downloading the dataset\n",
        "git_folder = \"/content/Detection-of-Sensitive-Data-Exposure-in-Images\"\n",
        "if os.path.exists(git_folder) == False:\n",
        "  !git clone https://github.com/DhilipSanjay/Detection-of-Sensitive-Data-Exposure-in-Images.git\n",
        "\n",
        "dataset_folder = git_folder + \"/text_dataset/\"\n",
        "sensitive_datafile = \"SensitiveDataset.json\"\n",
        "nonsensitive_datafile = \"NonSensitiveDataset.json\""
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'Detection-of-Sensitive-Data-Exposure-in-Images'...\n",
            "remote: Enumerating objects: 305, done.\u001b[K\n",
            "remote: Counting objects: 100% (305/305), done.\u001b[K\n",
            "remote: Compressing objects: 100% (205/205), done.\u001b[K\n",
            "remote: Total 1031 (delta 103), reused 298 (delta 96), pack-reused 726\u001b[K\n",
            "Receiving objects: 100% (1031/1031), 235.51 MiB | 34.48 MiB/s, done.\n",
            "Resolving deltas: 100% (114/114), done.\n",
            "Checking out files: 100% (736/736), done.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h_o7FrN_Jgr1"
      },
      "source": [
        "# Necessary Variables\n",
        "vocab_size = 3000\n",
        "embedding_dim = 32\n",
        "max_length = 60\n",
        "truncation_type='post'\n",
        "padding_type='post'\n",
        "oov_tok = \"<OOV>\"\n",
        "training_size = 20000"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7i3YvPoe9ZaT"
      },
      "source": [
        "## Preprocessing the dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vIUEAZOfJyy-",
        "outputId": "91c05886-e361-4a64-8bee-03a34dd84b43"
      },
      "source": [
        "dataList = []\n",
        "sentences = []\n",
        "labels = []\n",
        "# Stopwords should be removed or excluded from the given text so that more \n",
        "# focus can be given to those words which define the meaning of the text.\n",
        "stopwords = [ \"a\", \"about\", \"above\", \"after\", \"again\", \"against\", \"all\", \"am\", \"an\", \"and\", \"any\", \"are\", \"as\", \"at\", \"be\", \"because\", \"been\", \"before\", \"being\", \"below\", \"between\", \"both\", \"but\", \"by\", \"could\", \"did\", \"do\", \"does\", \"doing\", \"down\", \"during\", \"each\", \"few\", \"for\", \"from\", \"further\", \"had\", \"has\", \"have\", \"having\", \"he\", \"he'd\", \"he'll\", \"he's\", \"her\", \"here\", \"here's\", \"hers\", \"herself\", \"him\", \"himself\", \"his\", \"how\", \"how's\", \"i\", \"i'd\", \"i'll\", \"i'm\", \"i've\", \"if\", \"in\", \"into\", \"is\", \"it\", \"it's\", \"its\", \"itself\", \"let's\", \"me\", \"more\", \"most\", \"my\", \"myself\", \"nor\", \"of\", \"on\", \"once\", \"only\", \"or\", \"other\", \"ought\", \"our\", \"ours\", \"ourselves\", \"out\", \"over\", \"own\", \"same\", \"she\", \"she'd\", \"she'll\", \"she's\", \"should\", \"so\", \"some\", \"such\", \"than\", \"that\", \"that's\", \"the\", \"their\", \"theirs\", \"them\", \"themselves\", \"then\", \"there\", \"there's\", \"these\", \"they\", \"they'd\", \"they'll\", \"they're\", \"they've\", \"this\", \"those\", \"through\", \"to\", \"too\", \"under\", \"until\", \"up\", \"very\", \"was\", \"we\", \"we'd\", \"we'll\", \"we're\", \"we've\", \"were\", \"what\", \"what's\", \"when\", \"when's\", \"where\", \"where's\", \"which\", \"while\", \"who\", \"who's\", \"whom\", \"why\", \"why's\", \"with\", \"would\", \"you\", \"you'd\", \"you'll\", \"you're\", \"you've\", \"your\", \"yours\", \"yourself\", \"yourselves\" ]\n",
        "\n",
        "def loadDataset(filename):\n",
        "  with open(dataset_folder + filename, 'r') as f:\n",
        "      datastore = json.load(f)\n",
        "  for item in datastore:\n",
        "    sentence = item['data']\n",
        "    label = item['is_sensitive']\n",
        "    for word in stopwords: #Remove stop words in sentence\n",
        "      token = \" \" + word + \" \"\n",
        "      sentence = sentence.replace(token, \" \")\n",
        "    dataList.append([sentence, label])\n",
        "\n",
        "# Loading both sensitive and non-sensitive dataset\n",
        "loadDataset(sensitive_datafile)\n",
        "loadDataset(nonsensitive_datafile)\n",
        "\n",
        "# Shuffling the dataset randomly\n",
        "random.shuffle(dataList)\n",
        "\n",
        "# Dataset size: 31500 (approx)\n",
        "print(\"Dataset Size: \", len(dataList))\n",
        "\n",
        "# Dataset has both sentences and labels\n",
        "for item in dataList:\n",
        "  sentences.append(item[0])\n",
        "  labels.append(item[1])\n",
        "\n",
        "# Splitting up the total dataset\n",
        "# Training size = 20000\n",
        "# Validation size = 11500 (approx)\n",
        "training_sentences = sentences[0:training_size]\n",
        "validation_sentences = sentences[training_size:]\n",
        "training_labels = labels[0:training_size]\n",
        "validation_labels = labels[training_size:]\n",
        "\n",
        "print(\"Training Dataset Size: \", len(training_sentences))\n",
        "print(\"Sample Training Data:\", training_sentences[0])\n",
        "print(\"Validation Dataset Size: \", len(validation_sentences))\n",
        "print(\"Sample Validation Data:\", validation_sentences[0])"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dataset Size:  31576\n",
            "Training Dataset Size:  20000\n",
            "Sample Training Data: Chuck, formerly successful stockbroker, found refuge ulcer-inducing Wall Street rat race job attendant New York City morgue. His displeasure \"promoted\" Night Shift Supervisor make room boss's nephew exacerbated irrational exuberance Bill \"Blaze\" Blazejowski, new co-worker. They inspired plight Chuck's prostitute neighbor, Belinda, apply Chuck's financial acumen Bill's entrepreneurial spirit open prostitution service headquartered morgue.\n",
            "Chuck falls love Belinda, relationship becomes complicated Belinda refuses quit prostitution. Chuck's passiveness keeps telling Belinda loves her. Meanwhile, Chuck Bill's foray prostitution business draws ire dangerous pimps come morgue threaten kill Chuck. Bill inadvertently leads undercover cops morgue Chuck assaulted pimps. A shootout ensues. Chuck Bill rescued, arrested promoting prostitution. Because arrest political embarrassment, guys offered old jobs back dismissal charges. Chuck accepts this, Bill sees opportunity bargain mayor's office. Chuck Bill fight part ways. Chuck's fiancée breaks him.\n",
            "Chuck sees Belinda hall apartment complex, fails express true feelings her. Belinda leaves, Chuck becomes angry afraid. With renewed determination, Chuck finds Belinda working adult club professes love her. He also finds Bill employed there. The three leave club together go town.\n",
            "Validation Dataset Size:  11576\n",
            "Sample Validation Data: After frustrating day hunting Canada left group combat veterans empty-handed, hunting party comes river. Another band hunters appears side, stares down.\n",
            "Suddenly gun goes off, Zeke retaliates shooting killing one men riverbank. After exchange gunfire, Major Rex friends win skirmish, driving group off.\n",
            "Deciding keep incident secret police, round posse friends pursue hunters woods bloody mini-war Lou questions.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kt01OaiEMbQ9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c03c713c-6a9b-4b35-ea31-f65d345bba61"
      },
      "source": [
        "# Tokenizer takes the num_words (here vocab_size = 3000) maximum occuring unique words from the dataset.\n",
        "# Anything out of these words will be treated as Out of Vocabulary(<oov>)\n",
        "# It strips the punctutations and removes upper-case letters.\n",
        "tokenizer = Tokenizer(num_words=vocab_size, oov_token=oov_tok)\n",
        "\n",
        "# Apply the tokenizer on training sentences and generate the word index\n",
        "# Eg: word_index[\"the\"] = 1; word_index[\"cat\"] = 2; etc.\n",
        "tokenizer.fit_on_texts(training_sentences)\n",
        "\n",
        "# Save the word index (Used for deploying in web application)\n",
        "word_index = tokenizer.word_index\n",
        "print(\"Size of word index:\", len(word_index))\n",
        "\n",
        "with open(\"word_index.json\", \"w\") as outfile:  \n",
        "    json.dump(word_index, outfile)\n",
        "    print(\"Saving the word index as JSON\")\n",
        "\n",
        "# Transforms each word in sentences to a sequence of integers based on the word_index\n",
        "training_sequences = tokenizer.texts_to_sequences(training_sentences)\n",
        "# To feed the text into neural network - sentences must be of the same length. Hence we'll be using padding.\n",
        "# If the sentences are smaller than the maxlen, then we'll pad (Here, we are using post padding)\n",
        "# If the sentences are larger than the maxlen, then we'll truncate (Here, we are using post truncation)\n",
        "training_padded = pad_sequences(training_sequences, maxlen=max_length, padding=padding_type, truncating=truncation_type)\n",
        "\n",
        "# Apply the same for validation data\n",
        "validation_sequences = tokenizer.texts_to_sequences(validation_sentences)\n",
        "validation_padded = pad_sequences(validation_sequences, maxlen=max_length, padding=padding_type, truncating=truncation_type)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Size of word index: 102652\n",
            "Saving the word index as JSON\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SSHwIoCLPKPq"
      },
      "source": [
        "# Convert to Numpy arrays, so as to get it to work with TensorFlow 2.x\n",
        "import numpy as np\n",
        "training_padded = np.array(training_padded)\n",
        "training_labels = np.array(training_labels)\n",
        "validation_padded = np.array(validation_padded)\n",
        "validation_labels = np.array(validation_labels)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9OLtjmJw9ehH"
      },
      "source": [
        "## Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p5ADD9CuNFWB",
        "outputId": "7cf5a76d-b9fc-4268-b85c-588ba8ba18ea"
      },
      "source": [
        "# Callbacks to cancel training after reaching a desired accuracy\n",
        "# This is done to avoid overfitting\n",
        "DESIRED_ACCURACY = 0.999\n",
        "class myCallback(tf.keras.callbacks.Callback):\n",
        "  def on_epoch_end(self, epoch, logs={}):\n",
        "    if logs.get('accuracy') > DESIRED_ACCURACY:\n",
        "      print(\"Reached 99.9% accuracy so cancelling training!\")\n",
        "      self.model.stop_training = True\n",
        "\n",
        "callbacks = myCallback()\n",
        "\n",
        "# Sequential - defines a SEQUENCE of layers in the neural network.\n",
        "model = tf.keras.Sequential([\n",
        "    # Embedding - Turns positive integers (indexes) into dense vectors of fixed size (here embedding_dim = 32).\n",
        "    tf.keras.layers.Embedding(vocab_size, embedding_dim, input_length=max_length),\n",
        "    # 1D convolution layer - filter size = 128, convolution window = 5, activation fn = ReLU\n",
        "    tf.keras.layers.Conv1D(64, 5, activation='relu'),\n",
        "    # Global average pooling operation (Flattening)\n",
        "    tf.keras.layers.GlobalAveragePooling1D(),\n",
        "    # Regular densely-connected Neural Network layer with ReLU activation function.\n",
        "    tf.keras.layers.Dense(24, activation='relu'),\n",
        "    # Regular densely-connected Neural Network layer with sigmoid activation function.\n",
        "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "# model.compile - Configures the model for training.\n",
        "model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])\n",
        "# Adam -  optimization algorithm used instead of the classical stochastic gradient descent procedure to update network weights.\n",
        "\n",
        "# Display the summary of the model\n",
        "model.summary()"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "embedding (Embedding)        (None, 60, 32)            96000     \n",
            "_________________________________________________________________\n",
            "conv1d (Conv1D)              (None, 56, 64)            10304     \n",
            "_________________________________________________________________\n",
            "global_average_pooling1d (Gl (None, 64)                0         \n",
            "_________________________________________________________________\n",
            "dense (Dense)                (None, 24)                1560      \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 1)                 25        \n",
            "=================================================================\n",
            "Total params: 107,889\n",
            "Trainable params: 107,889\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mb2NlD159g8k"
      },
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7TP5ThxvNPK8",
        "outputId": "1db2817f-845e-4340-f404-df4edfd414ae"
      },
      "source": [
        "num_epochs = 6\n",
        "\n",
        "# model.fit - Train the model for a fixed number of epochs\n",
        "history = model.fit(training_padded, \n",
        "                    training_labels, \n",
        "                    epochs=num_epochs, \n",
        "                    validation_data=(\n",
        "                        validation_padded, \n",
        "                        validation_labels), \n",
        "                    verbose=1)\n",
        "                    #callbacks=[callbacks])"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/6\n",
            "625/625 [==============================] - 6s 9ms/step - loss: 0.1748 - accuracy: 0.9814 - val_loss: 0.0037 - val_accuracy: 0.9989\n",
            "Epoch 2/6\n",
            "625/625 [==============================] - 5s 8ms/step - loss: 0.0025 - accuracy: 0.9992 - val_loss: 0.0017 - val_accuracy: 0.9994\n",
            "Epoch 3/6\n",
            "625/625 [==============================] - 5s 8ms/step - loss: 8.0982e-04 - accuracy: 0.9998 - val_loss: 0.0012 - val_accuracy: 0.9998\n",
            "Epoch 4/6\n",
            "625/625 [==============================] - 5s 8ms/step - loss: 4.3107e-04 - accuracy: 0.9999 - val_loss: 0.0017 - val_accuracy: 0.9994\n",
            "Epoch 5/6\n",
            "625/625 [==============================] - 5s 8ms/step - loss: 3.6006e-04 - accuracy: 1.0000 - val_loss: 0.0013 - val_accuracy: 0.9996\n",
            "Epoch 6/6\n",
            "625/625 [==============================] - 5s 8ms/step - loss: 8.9253e-04 - accuracy: 0.9999 - val_loss: 0.0014 - val_accuracy: 0.9995\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "poN5h1SD9tiE"
      },
      "source": [
        "## Plotting Accuracy and Loss Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "id": "WCDbITWsNWlI",
        "outputId": "b96fcbf4-f236-4f22-a4c4-84e157cca63c"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Plot the accuracy and loss functions\n",
        "def plot_graphs(history, string):\n",
        "  plt.plot(history.history[string])\n",
        "  plt.plot(history.history['val_'+string])\n",
        "  plt.xlabel(\"Epochs\")\n",
        "  plt.ylabel(string)\n",
        "  plt.legend([string, 'val_'+string])\n",
        "  plt.show()\n",
        "  \n",
        "plot_graphs(history, \"accuracy\")\n",
        "plot_graphs(history, \"loss\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEHCAYAAAC0pdErAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZhcdZ3v8fe3lu5OZ2lIp9NFFkgggZBKRLCDy8gmkoqOGjcMuCGXGa4L6gxeRnTUi1zncZnnkTtz5VG5ooOKQgZ0nswF6SBEgREhnZgQOgEMMUCHLJ2FbJ3eqr73jzodKkV10p306do+r+epp0796ndOfSsN9alzfqfOz9wdERGRfJFiFyAiIqVJASEiIgUpIEREpCAFhIiIFKSAEBGRghQQIiJSUCzMjZvZIuBfgCjwI3f/Vt7ztcBPgTcAu4Al7r45eO51wA+BCUAGWODu3YO91qRJk3zGjBkhvAsRkcq1atWqne7eVOi50ALCzKLArcBlQAew0syWufv6nG7XAHvcfZaZXQF8G1hiZjHg58DH3H2tmTUCfUd7vRkzZtDW1hbKexERqVRm9sJgz4V5iOl8YKO7b3L3XuAuYHFen8XAHcHyPcClZmbAQuApd18L4O673D0dYq0iIpInzICYCryU87gjaCvYx937gb1AI3Am4GbWamarzewfQqxTREQKCHUM4gTEgLcCC4Au4CEzW+XuD+V2MrNrgWsBTj311FEvUkSkkoUZEFuA6TmPpwVthfp0BOMODWQHqzuAR9x9J4CZ3Q+cBxwREO5+G3AbQEtLiy4qJVKF+vr66OjooLt70HNYBKirq2PatGnE4/EhrxNmQKwEZpvZTLJBcAXw4bw+y4CrgMeBDwIPu7ubWSvwD2ZWD/QCFwG3hFiriJSpjo4Oxo8fz4wZM8gOYUo+d2fXrl10dHQwc+bMIa8X2hhEMKZwHdAKbACWunu7md1sZu8Jut0ONJrZRuB64MZg3T3Ad8mGzBpgtbvfF1atIlK+uru7aWxsVDgchZnR2Ng47L2sUMcg3P1+4P68tq/lLHcDlw+y7s/JnuoqInJUCodjO55/o6r/JfWWVw7xzd9sYPs+Hb8UEclV9QHR1dPPD3+/ieXrtxe7FBEpU+PGjSt2CaGo+oCYNXkcp08ay/L2bcUuRUSkpFR9QJgZC5MJHn9+F3u7jno1DxGRo3J3brjhBubNm8f8+fO5++67Adi6dSsXXnghr3/965k3bx6PPvoo6XSaT3ziE4f73nJL6Z2oWao/lBtVqWQzP/j98zz0zHbef960YpcjIsfp6//ZzvqX943oNudOmcD/fHdySH1/9atfsWbNGtauXcvOnTtZsGABF154Ib/4xS9IpVL84z/+I+l0mq6uLtasWcOWLVt4+umnAXjllVdGtO6RUPV7EADnTDuJ5gm1tOowk4icgMcee4wrr7ySaDRKc3MzF110EStXrmTBggX85Cc/4aabbmLdunWMHz+e008/nU2bNvHZz36WBx54gAkTJhS7/NfQHgQQiRgL5yb491Uvcag3zZiaaLFLEpHjMNRv+qPtwgsv5JFHHuG+++7jE5/4BNdffz0f//jHWbt2La2trfzgBz9g6dKl/PjHPy52qUfQHkQglUzQ3ZfhkT93FrsUESlTF1xwAXfffTfpdJrOzk4eeeQRzj//fF544QWam5v527/9W/7mb/6G1atXs3PnTjKZDB/4wAf4xje+werVq4td/mtoDyLwxtMn0jAmTmv7NlLJRLHLEZEy9L73vY/HH3+cc845BzPjO9/5DolEgjvuuIN//ud/Jh6PM27cOH7605+yZcsWrr76ajKZDADf/OY3i1z9a5l7ZVzjrqWlxU90wqDr717DQ8/soO0rbyce1c6VSDnYsGEDZ599drHLKAuF/q2CK2W3FOqvT8EcqXkJ9h7q48m/7C52KSIiRaeAyHHh7Cbq4hGdzSQiggLiCGNqolx0ZhPL27eTyVTGoTcRkeOlgMiTSibYtq+btR2l96MVEZHRpIDIc+mcZmIRo7VdF+8TkeqmgMjTUB/nTac3srx9G5VyhpeIyPFQQBSQSjazaedBNu44UOxSRESKRgFRwGVzsz+U09lMIjLSjjZ3xObNm5k3b94oVnN0CogCEg11vH76SRqHEJGqpkttDGLRvATf+s0zbHnlEFNPGlPsckRkKH5zI2xbN7LbTMyHd3xr0KdvvPFGpk+fzmc+8xkAbrrpJmKxGCtWrGDPnj309fXxjW98g8WLFw/rZbu7u/nUpz5FW1sbsViM7373u1xyySW0t7dz9dVX09vbSyaT4d5772XKlCl86EMfoqOjg3Q6zVe/+lWWLFlyQm8btAcxqIHrMWmmORE5miVLlrB06dLDj5cuXcpVV13Fr3/9a1avXs2KFSv4whe+MOyTXm699VbMjHXr1vHLX/6Sq666iu7ubn7wgx/w+c9/njVr1tDW1sa0adN44IEHmDJlCmvXruXpp59m0aJFI/LetAcxiJmTxnJm8zha27dx9V/NLHY5IjIUR/mmH5Zzzz2XHTt28PLLL9PZ2cnJJ59MIpHg7//+73nkkUeIRCJs2bKF7du3k0gM/UKgjz32GJ/97GcBmDNnDqeddhrPPfccb37zm/mnf/onOjo6eP/738/s2bOZP38+X/jCF/jiF7/Iu971Li644IIReW/agziKVDLBk3/Zza4DPcUuRURK2OWXX84999zD3XffzZIlS7jzzjvp7Oxk1apVrFmzhubmZrq7u0fktT784Q+zbNkyxowZwzvf+U4efvhhzjzzTFavXs38+fP5yle+ws033zwir6WAOIpUMkHG4aENO4pdioiUsCVLlnDXXXdxzz33cPnll7N3714mT55MPB5nxYoVvPDCC8Pe5gUXXMCdd94JwHPPPceLL77IWWedxaZNmzj99NP53Oc+x+LFi3nqqad4+eWXqa+v56Mf/Sg33HDDiM0toUNMR5GcMoGpJ42htX0bH1owvdjliEiJSiaT7N+/n6lTp3LKKafwkY98hHe/+93Mnz+flpYW5syZM+xtfvrTn+ZTn/oU8+fPJxaL8W//9m/U1taydOlSfvaznxGPx0kkEnz5y19m5cqV3HDDDUQiEeLxON///vdH5H2FOh+EmS0C/gWIAj9y92/lPV8L/BR4A7ALWOLum81sBrABeDbo+kd3/+TRXmsk5oMo5Ov/2c6dT7zI6q9exrha5alIqdF8EENXMvNBmFkUuBV4BzAXuNLM5uZ1uwbY4+6zgFuAb+c897y7vz64HTUcwpRKJujtz/D7ZzUVqYhUlzC/Ep8PbHT3TQBmdhewGFif02cxcFOwfA/wPTOzEGsatgUzJjJxbA2t7dv469edUuxyRKQCrFu3jo997GNHtNXW1vLEE08UqaLCwgyIqcBLOY87gDcO1sfd+81sL9AYPDfTzP4E7AO+4u6PhljroKIR47Kzm7l/3VZ6+zPUxDSuL1Jq3J0S+255VPPnz2fNmjWj+prHM5xQqp92W4FT3f1c4HrgF2Y2Ib+TmV1rZm1m1tbZGd4hoNS8Zvb39POH53eG9hoicnzq6urYtWuXrr58FO7Orl27qKurG9Z6Ye5BbAFyT/2ZFrQV6tNhZjGgAdjl2b90D4C7rzKz54EzgSNGod39NuA2yA5Sh/EmAN5yxiTG1kRpbd/GxWdNDutlROQ4TJs2jY6ODsL8klgJ6urqmDZt2rDWCTMgVgKzzWwm2SC4AvhwXp9lwFXA48AHgYfd3c2sCdjt7mkzOx2YDWwKsdajqotHuXjOZB5cv51vvNeJRspnV1ak0sXjcWbO1NUOwhDaISZ37weuA1rJnrK61N3bzexmM3tP0O12oNHMNpI9lHRj0H4h8JSZrSE7eP1Jd98dVq1DkUom2Hmgl9Uv7ilmGSIioybUE/vd/X7g/ry2r+UsdwOXF1jvXuDeMGsbrkvOaqImGqH16W0smDGx2OWIiISuVAepS874ujhvmdVI63pNRSoi1UEBMQypZIKXdh9iw9b9xS5FRCR0CohhePvZzZhpKlIRqQ4KiGFoGl/LgtMmKiBEpCooIIZpYbKZZ7bt54VdB4tdiohIqBQQwzQwFan2IkSk0ikghmn6xHrmnjKB1vbtxS5FRCRUCojjkEomWP3iHnbsH5kpBEVESpEC4jik5jXjDg+u116EiFQuBcRxOKt5PKc11uswk4hUNAXEcTAzUskEjz+/k33dfcUuR0QkFAqI45RKNtOXdlY8s6PYpYiIhEIBcZzOnX4yTeNrdbqriFQsBcRxikSMhXOb+d2znXT3pYtdjojIiFNAnIBUMkFXb5pH/6ypSEWk8iggTsCbTm9kfF1Mh5lEpCIpIE5ATSzCpXMm89CG7fSnM8UuR0RkRCkgTlAqmWBPVx9Pbi7qjKgiIiNOAXGCLjqridpYhOX60ZyIVBgFxAmqr4lxwewmlrdrKlIRqSwKiBGQSjbz8t5u1m3ZW+xSRERGjAJiBLz97GaiEdPZTCJSURQQI+DksTW8ceZEXbxPRCqKAmKEpJIJNu44wMYdB4pdiojIiFBAjJCFyWZAU5GKSOVQQIyQUxrGcM60BpYrIESkQoQaEGa2yMyeNbONZnZjgedrzezu4PknzGxG3vOnmtkBM/sfYdY5UhYmE6zt2MvWvYeKXYqIyAkLLSDMLArcCrwDmAtcaWZz87pdA+xx91nALcC3857/LvCbsGocaalkAkA/mhORihDmHsT5wEZ33+TuvcBdwOK8PouBO4Lle4BLzcwAzOy9wF+A9hBrHFGzJo/jjKaxGocQkYoQZkBMBV7KedwRtBXs4+79wF6g0czGAV8Evn60FzCza82szczaOjs7R6zwE5FKJnjiL7vZc7C32KWIiJyQUh2kvgm4xd2Pes6ou9/m7i3u3tLU1DQ6lR3DonkJ0hnnIU1FKiJlLsyA2AJMz3k8LWgr2MfMYkADsAt4I/AdM9sM/B3wZTO7LsRaR8z8qQ1MaajTYSYRKXuxELe9EphtZjPJBsEVwIfz+iwDrgIeBz4IPOzZK95dMNDBzG4CDrj790KsdcSYGQuTCX755It09fZTXxPmP7GISHhC24MIxhSuA1qBDcBSd283s5vN7D1Bt9vJjjlsBK4HXnMqbDlamGympz/D758tjXEREZHjEerXW3e/H7g/r+1rOcvdwOXH2MZNoRQXovNnTOTk+jit7dt4x/xTil2OiMhxKdVB6rIWi0a49OxmHnpmB739mopURMqTAiIkqWSC/d39/HHTrmKXIiJyXBQQIblg9iTqa6I6m0lEypYCIiR18SgXndnEg+u3k8loKlIRKT8KiBAtmpdgx/4e/vTSK8UuRURk2BQQIbpkzmTiUU1FKiLlSQERogl1cd58xiRa27eR/f2fiEj5UECELJVs5oVdXTy7fX+xSxERGRYFRMgum9uMGbQ+rTkiRKS8KCBCNnl8HeederLGIUSk7CggRkEq2cz6rft4aXdXsUsRERkyBcQoGJiKVHsRIlJOFBCj4LTGscxJjNdc1SJSVhQQoySVTLDyhd107u8pdikiIkOigBglqWQCd/jtBu1FiEh5UECMkrNPGc/0iWM0DiEiZUMBMUrMjNTcBH/YuIv93X3FLkdE5JgUEKMoNS9BbzrDCk1FKiJlQAExis479WQmjavRYSYRKQsKiFEUjRiXzW3md8/soLsvXexyRESOSgExyhYmExzsTfOH53cWuxQRkaNSQIyyt5zRyLjamC7eJyIlTwExympjUd42ZzIPbthOWlORikgJU0AUQSqZYPfBXlZu3l3sUkREBjWkgDCzz5vZBMu63cxWm9nCsIurVBef1URNLKKzmUSkpA11D+K/ufs+YCFwMvAx4FvHWsnMFpnZs2a20cxuLPB8rZndHTz/hJnNCNrPN7M1wW2tmb1vyO+oDIytjXHBrEksb9+uqUhFpGQNNSAsuH8n8DN3b89pK7yCWRS4FXgHMBe40szm5nW7Btjj7rOAW4BvB+1PAy3u/npgEfBDM4sNsdaykEom2PLKIdpf3lfsUkREChpqQKwys+VkA6LVzMYDmWOscz6w0d03uXsvcBewOK/PYuCOYPke4FIzM3fvcvf+oL0OqLiv2ZeePZmIaY4IESldQw2Ia4AbgQXu3gXEgauPsc5U4KWcxx1BW8E+QSDsBRoBzOyNZtYOrAM+mRMYFaFxXC0LZkxUQIhIyRpqQLwZeNbdXzGzjwJfIfthHhp3f8Ldk8AC4EtmVpffx8yuNbM2M2vr7Cy/6xulkgme236Av+w8WOxSREReY6gB8X2gy8zOAb4APA/89BjrbAGm5zyeFrQV7BOMMTQAu3I7uPsG4AAwL/8F3P02d29x95ampqYhvpXSsTDZDOgwk4iUpqEGRL9nT7dZDHzP3W8Fxh9jnZXAbDObaWY1wBXAsrw+y4CrguUPAg+7uwfrxADM7DRgDrB5iLWWjWkn1zN/aoMCQkRK0lADYr+ZfYns6a33mVmE7DjEoIIxg+uAVmADsNTd283sZjN7T9DtdqDRzDYC15Md5wB4K7DWzNYAvwY+7e4VefGiVLKZP734Ctv2dhe7FBGRI9hQzsM3swTwYWCluz9qZqcCF7v7sQ4zjZqWlhZva2srdhnD9uft+7nslkf4X4uTfOzNM4pdjohUGTNb5e4thZ4b0h6Eu28D7gQazOxdQHcphUM5mzV5HKdPGktruy7eJyKlZaiX2vgQ8CRwOfAh4Akz+2CYhVULM2NhMsEfN+1ib5emIhWR0jHUMYh/JPsbiKvc/eNkfwT31fDKqi6pZDP9GeehZ7QXISKlY6gBEXH3HTmPdw1jXTmGc6adRPOEWp3NJCIlZajXN3rAzFqBXwaPlwD3h1NS9YlEjIVzE/z7qpc41JtmTE202CWJiAx5kPoG4DbgdcHtNnf/YpiFVZtUMkF3X4ZH/lx+vwgXkco05Cukuvu9wL0h1lLV3nj6RBrGxGlt30YqmSh2OSIiRw8IM9tP4SupGuDuPiGUqqpQPBrh0rMn89v12+lLZ4hHNcQjIsV11E8hdx/v7hMK3MYrHEZeKplgX3c/T2zSVKQiUnz6mlpCLpzdRF1cU5GKSGlQQJSQMTVRLjqzieXrt5HJVNwcSSJSZhQQJSaVTLB9Xw9rO14pdikiUuUUECXm0jnNxCKmazOJSNEpIEpMQ32cN53eyPL2bQzlSrsiImFRQJSgVLKZTTsPsnHHgWKXIiJVTAFRgi6bm/2h3ANP62wmESkeBUQJSjTUce6pJ9G6XgEhIsWjgChRqWSCp7fso2NPV7FLEZEqpYAoUQPXY1qus5lEpEgUECVq5qSxnNk8Tr+qFpGiUUCUsFQywcrNu9l1oKfYpYhIFVJAlLBUMkHG4aENO47dWURkhCkgSlhyygSmnjRGh5lEpCgUECXMzFiYbObRjTs50NNf7HJEpMooIEpcKpmgtz/D757VYSYRGV2hBoSZLTKzZ81so5ndWOD5WjO7O3j+CTObEbRfZmarzGxdcP+2MOssZQtmTKRxbI0u3icioy60gDCzKHAr8A5gLnClmc3N63YNsMfdZwG3AN8O2ncC73b3+cBVwM/CqrPURSPG289uZsUzO+jpTxe7HBGpImHuQZwPbHT3Te7eC9wFLM7rsxi4I1i+B7jUzMzd/+TuLwft7cAYM6sNsdaSlprXzIGefv7w/K5ilyIiVSTMgJgKvJTzuCNoK9jH3fuBvUBjXp8PAKvdvWp/DPCWMyYxtibKcp3NJCKjqKQHqc0sSfaw038f5PlrzazNzNo6OztHt7hRVBePcvGcyTy4fjtpTUUqIqMkzIDYAkzPeTwtaCvYx8xiQAOwK3g8Dfg18HF3f77QC7j7be7e4u4tTU1NI1x+aUklE+w80MvqF/cUuxQRqRJhBsRKYLaZzTSzGuAKYFlen2VkB6EBPgg87O5uZicB9wE3uvt/hVhj2bjkrCZqohFaNUeEiIyS0AIiGFO4DmgFNgBL3b3dzG42s/cE3W4HGs1sI3A9MHAq7HXALOBrZrYmuE0Oq9ZyML4uzltmNdK6XlORisjosEr5sGlpafG2trZilxGqXz75Il/61Tru+9xbSU5pKHY5IlIBzGyVu7cUeq6kB6nlSJfNbcYM/WhOREaFAqKMTBpXy4LTJup0VxEZFQqIMrMw2cwz2/bzwq6DxS5FRCqcAqLMDExFqkuAi0jYFBBlZvrEeuaeMkHjECISOgVEGUolE6x+cQ879ncXuxQRqWAKiDKUmteMOzy4XnsRIhIeBUQZOqt5PKc11uswk4iESgFRhsyMVDLBHzbuZO+hvmKXIyIVSgFRplLJBP0ZZ8UzmopURMKhgChT504/icnja3W6q4iERgFRpiIR47K5zfzu2U66+zQVqYiMPAVEGUslExzqS/Pon3cWuxQRqUAKiDL2ptMbGV8X02EmEQmFAqKM1cQiXDpnMg9t2E5/OlPsckSkwiggylwqmWBPVx9Pbt5d7FJEpMIoIMrcRWc1URuLsFw/mhOREaaAKHP1NTEumN1Ea7umIhWRkaWAqACL5iXYurebpzr2FrsUEakgCogK8PazJxONmM5mEpERpYCoACfV1/DGmRMVECIyohQQFSKVTPB850E27jhQ7FJEpEIoICrEwmQzoKlIRWTkKCAqxCkNYzhnWgPLFRAiMkIUEBVkYTLB2o69bN17qNiliEgFUEBUkFQyAaAfzYnIiAg1IMxskZk9a2YbzezGAs/XmtndwfNPmNmMoL3RzFaY2QEz+16YNVaSWZPHcUbTWB54WoeZROTEhRYQZhYFbgXeAcwFrjSzuXndrgH2uPss4Bbg20F7N/BV4H+EVV+lWjQvwZObd7PnYG+xSxGRMhfmHsT5wEZ33+TuvcBdwOK8PouBO4Lle4BLzczc/aC7P0Y2KGQYUskE6Yzz2w06zCQiJybMgJgKvJTzuCNoK9jH3fuBvUDjUF/AzK41szYza+vs7DzBcivD/KkNTGmoo1XjECJygsp6kNrdb3P3FndvaWpqKnY5JcHMWJhM8OifO+nq7S92OSJSxsIMiC3A9JzH04K2gn3MLAY0ALtCrKkqLEw209Of4ffPaq9KRI5fmAGxEphtZjPNrAa4AliW12cZcFWw/EHgYdc1q0/Y+TMmcnJ9XL+qFpETEgtrw+7eb2bXAa1AFPixu7eb2c1Am7svA24HfmZmG4HdZEMEADPbDEwAaszsvcBCd18fVr2VJBaNcOnZzbS2b6O3P0NNrKyPJIpIkYQWEADufj9wf17b13KWu4HLB1l3Rpi1VbpUMsE9qzp4fNMuLjpT4zMiMnz6almhLpg9ifqaqA4zichxU0BUqLp4lIvPauLB9dvJZDSsIyLDp4CoYKlkgs79PfzppT3FLkVEypACooJdMmcy8ajpR3MiclwUEBVsQl2cN58xidb2bejsYREZLgVEhUslm3lhVxfPbt9f7FJEpMwoICrcZXObMYPWp3WYSUSGRwFR4SaPr+O8U0/W6a4iMmwKiCqQSjazfus+XtrdVexSRKSMKCCqwMBUpNqLEJHhUEBUgdMaxzInMV4BISLDooCoEqlkgrYX9tC5v6fYpYhImVBAVIlUMoE7mopURIZMAVElzj5lPNMnjtFhJhEZMgVElTAzUnMT/GHjLvZ39xW7HBEpA6HOB1EWdjwDP/8ANEyFCVOz9w3TX12eMA3GTgKzYld6wlLzEvzosb+w4tlO3nPOlGKXIyIlTgERjcOMt8K+LfDyn+CZ+yCdN5AbrYUJU6BhWvaWGx4DwVLXUPIhct6pJzNpXA2t7dsUECJyTAqIxjPg/T989bE7HNwJ+zpgbwfs3RIsb8mGyF8ehf1bwdNHbqdmXBAc014bHgOhUlM/uu8tTzRiXDa3mWVrXqa7L01dPFrUekSktCkg8pnBuKbsbcq5hfuk++HAtteGx96O7P22dXBwx2vXG3NyEBYFwqNhKoyfArGaUN/ewmSCXz75Ev+1cSeXnt0c6muJSHlTQByPaOzVw028sXCf/p4gNPLCY+8WeOVFePEP0L03byWDcc2Fw2NC8HrjJkPk+L/5v+WMRsbXxmht36aAEJGjUkCEJVYLE0/P3gbTc+C14bG3I7tXsmMDbPwt9OVdPykSy+5p5A6qD+yRDOyd1E8cdDykNhblkjmT+e2GHTzw9FYmjInTkHMbVxvDSnwsRURGh1XKRDItLS3e1tZW7DJGljsc2pOzJ5I7LjIQJi9DJu+01diYYFA9fyxkOjRM5XfbavjEL54p+JLRiDGhLnY4MAYC5KT6I4Mk9zmFS4lwh0w/9Hdn92D7uyGThmhN9hYL7iNxiOgMd8kys1Xu3lLoOe1BlDKz7N5A/URIzC/cJ5OBg52DhMcW2PS77HiJZw6vcjGwaXw9megY0pE4/VZDv9XQazF6PU43cbozMboPRunaF+dgJsrB/ggH0jG6PcYO4rzkcXqJ0UucHuL0epz+SJxIvI54TR01tWOoqRtDbd0Y6urqGVNfT/2YesaNrWfs2HGMG1vPhLFjaaivqaxwyWSyZ8HlfkgP3Pd1F24/vHyowHPHWjd3G91H/J2PKhIPgiOe3dsdWI7WBvc1QXv81YDJD5pB2we2M9j2c9sHtp/3uidwGLXqDHzJD+H/HwVEuYtEYHxz9jb1DYX7pPtg/7acQ1kdRA5sJ9LfTay/h9r+nuBDLbile4MPnINHtHvOsjHInqcDPcFt37HL7/E4PcTYTZxei5O2GtKR7M0HPixitURidUTitURr6ojF64jX1lFTV58Noto6LFb36gdRrC74sKo9cjkSy76fvqN8EJ/oB3X+KdLDZtma43VB7bWvva9rKNx+xHpBm0Wyf/90X7a2dC/092bvj7j1vfq3P9y3L/tvdeiVoK331fYjthPC9b0sUiA4ao7SlnOLRLNB6Znsh6dnAM9r8wJtuf1y7l/TdgL98CPXKVjbMPsBJN8Pl/9kxP8MCohqEI3DSdOztxNw+PvJEYcyenO+MffmBU1OuPT30NPdxaHuQ/R0H6Knu4u+nm76eg7R39tNuq+bTF8P3teNBx9Ukb4erLuLaOYVauijhj6i1k+UXuL0E6ePWhv5X4V7JI5Ha/G8D/dTH/UAAAhLSURBVF8LPnytbsKrgXT4fswQPrRrj/zwjtW99nE0XvK/p3mNgf8eBsJmyAGU3z7Uvnlh1XvwyNfMpINDaJYNGhu4z2+zAm25j/PWzW8r1A+O0i+/DivQdox+BV/TYPLZofxpQw0IM1sE/AsQBX7k7t/Ke74W+CnwBmAXsMTdNwfPfQm4BkgDn3P31jBrlWEwC77BxaF2iKsAdcFtuNydg71p9h7qY29XX/b+UG/wuJf9XYc42NXFoa4uug510d19iN5DXfT0HKK35xBx76WGfqKk6SFOj8fppoYeag4/7hk4VEacNMc+vBGNGLGBWzRCPGpB26vL8WiEWDTblu2XbYtGMsQiPcSjvUQj+7P9gudjkYF1gu1GjGjQlt1udvuF+736mgPL0YhhZC+1EjEw7HD+RMwOf/ZEbKBftm+hdXKfO7xu8MfNrh/DLE4kOhaLWtD+2nXIW//w65RbMFaB0ALCzKLArcBlQAew0syWufv6nG7XAHvcfZaZXQF8G1hiZnOBK4AkMAX4rZmd6Z7/6zSpBmbGuNoY42pjTD1pzLDWzQ2XA9399KUzpDNOfyZDX9pJZ5y+dIb+tNMftB9eTmfoC+6z/bLLg/VLp52+oP3wdjOv9ulPOwf7++kPtpUO+vblbSu3lr50ZZxEMhz5oUIQJLmhckR7TggOhFzO/u4RO2S5EZSfRzakdQYPsSPWOWL9wts92rZtsE6DrHPxmU185V1zB63teIW5B3E+sNHdNwGY2V3AYiA3IBYDNwXL9wDfs+w7Xgzc5e49wF/MbGOwvcdDrFcqUG64lCN3J+McDpv0EYGSc5/xbNjkhlnQjoPj2SNBnt2mM3Ao/tXlzOHlbN/C6ww8F/QPlgnqHOg3sExev4FlgEwmpw6y63N4/SPXYWA5c2S9uf9GA/XmRuqRJ2n6IO1HPvZB+g2+3SPXGWSR/DNGB9veUNfJfXDKML84DVWY/9dMBV7KedzBa39VdriPu/eb2V6gMWj/Y966U8MrVaQ0mRlRg6jO6pEiKOuToc3sWjNrM7O2zs7OYpcjIlJRwgyILUDuaTPTgraCfcwsBjSQHaweyrq4+23u3uLuLU1NTSNYuoiIhBkQK4HZZjbTzGrIDjovy+uzDLgqWP4g8LBnD7otA64ws1ozmwnMBp4MsVYREckT2hhEMKZwHdBK9jTXH7t7u5ndDLS5+zLgduBnwSD0brIhQtBvKdkB7X7gMzqDSURkdOlaTCIiVexo12Iq60FqEREJjwJCREQKUkCIiEhBFTMGYWadwAsnsIlJwM4RKqccVNv7Bb3naqH3PDynuXvB3wlUTECcKDNrG2ygphJV2/sFvedqofc8cnSISUREClJAiIhIQQqIV91W7AJGWbW9X9B7rhZ6zyNEYxAiIlKQ9iBERKSgqg8IM1tkZs+a2UYzu7HY9YTNzH5sZjvM7Oli1zJazGy6ma0ws/Vm1m5mny92TWEzszoze9LM1gbv+evFrmk0mFnUzP5kZv+v2LWMFjPbbGbrzGyNmY3o9Yaq+hBTMC3qc+RMiwpcmTctakUxswuBA8BP3X1esesZDWZ2CnCKu682s/HAKuC9Ff53NmCsux8wszjwGPB5d//jMVYta2Z2PdACTHD3dxW7ntFgZpuBFncf8d9+VPsexOFpUd29FxiYFrViufsjZK+cWzXcfau7rw6W9wMbqPAZCj3rQPAwHtwq+tugmU0D/hr4UbFrqRTVHhCFpkWt6A+OamdmM4BzgSeKW0n4gsMta4AdwIPuXunv+X8D/wBkil3IKHNguZmtMrNrR3LD1R4QUkXMbBxwL/B37r6v2PWEzd3T7v56sjMynm9mFXtI0czeBexw91XFrqUI3uru5wHvAD4THEYeEdUeEEOa2lTKX3Ac/l7gTnf/VbHrGU3u/gqwAlhU7FpC9FfAe4Lj8XcBbzOznxe3pNHh7luC+x3Ar8keOh8R1R4QQ5kWVcpcMGB7O7DB3b9b7HpGg5k1mdlJwfIYsidiPFPcqsLj7l9y92nuPoPs/8cPu/tHi1xW6MxsbHDiBWY2FlgIjNgZilUdEO7eDwxMi7oBWOru7cWtKlxm9kvgceAsM+sws2uKXdMo+CvgY2S/Va4Jbu8sdlEhOwVYYWZPkf0i9KC7V82pn1WkGXjMzNYCTwL3ufsDI7Xxqj7NVUREBlfVexAiIjI4BYSIiBSkgBARkYIUECIiUpACQkREClJAiByDmaVzTo9dM5JX/TWzGdV0ZV0pL7FiFyBSBg4Fl6wQqSragxA5TsF1+L8TXIv/STObFbTPMLOHzewpM3vIzE4N2pvN7NfBHA1rzewtwaaiZvZ/g3kblge/fMbMPhfMYfGUmd1VpLcpVUwBIXJsY/IOMS3JeW6vu88Hvkf2aqIA/we4w91fB9wJ/GvQ/q/A7939HOA8YOBX+7OBW909CbwCfCBovxE4N9jOJ8N6cyKD0S+pRY7BzA64+7gC7ZuBt7n7puBigNvcvdHMdpKdoKgvaN/q7pPMrBOY5u49OduYQfYyGLODx18E4u7+DTN7gOzkTv8B/EfO/A4io0J7ECInxgdZHo6enOU0r44N/jVwK9m9jZVmpjFDGVUKCJETsyTn/vFg+Q9krygK8BHg0WD5IeBTcHgyn4bBNmpmEWC6u68Avgg0AK/ZixEJk76RiBzbmGBmtgEPuPvAqa4nB1dM7QGuDNo+C/zEzG4AOoGrg/bPA7cFV9BNkw2LrYO8ZhT4eRAiBvxrMK+DyKjRGITIcQpzsniRUqBDTCIiUpD2IEREpCDtQYiISEEKCBERKUgBISIiBSkgRESkIAWEiIgUpIAQEZGC/j/fNk+RXtIJhwAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z9ymTQswYUQz"
      },
      "source": [
        "## Confusion Matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "tVdCGN-tYXqX",
        "outputId": "609a920b-9292-4bab-c967-e9f5dfa83c34"
      },
      "source": [
        "import seaborn\n",
        "print('Confusion Matrix')\n",
        "y_predicted = model.predict(validation_padded)\n",
        "y_predicted_labels = y_predicted > 0.5\n",
        "\n",
        "size = np.size(y_predicted_labels)\n",
        "y_predicted_labels = y_predicted_labels.reshape(size, )\n",
        "\n",
        "for i in range (1, 5):\n",
        "  total = i * size // 4\n",
        "  cm = tf.math.confusion_matrix(labels=validation_labels[0:total],predictions=y_predicted_labels[0:total])\n",
        "\n",
        "  # Calculate accuracy\n",
        "  cm_np = cm.numpy()\n",
        "  conf_acc = (cm_np[0, 0] + cm_np[1, 1])/ np.sum(cm_np) * 100\n",
        "  print(\"Accuracy for\", str(total), \"Test Data = \", conf_acc)\n",
        "\n",
        "  # Plot the confusion matrix\n",
        "  plt.figure(figsize = (10,7))\n",
        "  seaborn.heatmap(cm, annot=True, fmt='d')\n",
        "  plt.title(\"Confusion Matrix for \" + str(total) + \" Test Data\")\n",
        "  plt.xlabel('Predicted')\n",
        "  plt.ylabel('Expected')"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Confusion Matrix\n",
            "Accuracy for 2894 Test Data =  99.93089149965446\n",
            "Accuracy for 5788 Test Data =  99.94816862474084\n",
            "Accuracy for 8682 Test Data =  99.9539276664363\n",
            "Accuracy for 11576 Test Data =  99.94816862474084\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f94fRNNo-386"
      },
      "source": [
        "## Saving the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F_rBTIVTQHow",
        "outputId": "0f7565ac-7726-4213-df4b-13251ef118a3"
      },
      "source": [
        "# Save and convert the model (Used for deploying in web application)\n",
        "model.save('model/text_model.h5')\n",
        "print(\"Saved the model successfully\")\n",
        "\n",
        "!apt-get -qq install virtualenv\n",
        "!virtualenv -p python3 venv\n",
        "!source venv/bin/activate\n",
        "!pip install -q tensorflowjs\n",
        "!tensorflowjs_converter --input_format=keras /content/model/text_model.h5 /content/text_model\n",
        "print(\"Model converted to JSON successfully\")"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saved the model successfully\n",
            "Selecting previously unselected package python-pip-whl.\n",
            "(Reading database ... 160983 files and directories currently installed.)\n",
            "Preparing to unpack .../python-pip-whl_9.0.1-2.3~ubuntu1.18.04.4_all.deb ...\n",
            "Unpacking python-pip-whl (9.0.1-2.3~ubuntu1.18.04.4) ...\n",
            "Selecting previously unselected package python3-pkg-resources.\n",
            "Preparing to unpack .../python3-pkg-resources_39.0.1-2_all.deb ...\n",
            "Unpacking python3-pkg-resources (39.0.1-2) ...\n",
            "Selecting previously unselected package python3-virtualenv.\n",
            "Preparing to unpack .../python3-virtualenv_15.1.0+ds-1.1_all.deb ...\n",
            "Unpacking python3-virtualenv (15.1.0+ds-1.1) ...\n",
            "Selecting previously unselected package virtualenv.\n",
            "Preparing to unpack .../virtualenv_15.1.0+ds-1.1_all.deb ...\n",
            "Unpacking virtualenv (15.1.0+ds-1.1) ...\n",
            "Setting up python-pip-whl (9.0.1-2.3~ubuntu1.18.04.4) ...\n",
            "Setting up python3-pkg-resources (39.0.1-2) ...\n",
            "Setting up python3-virtualenv (15.1.0+ds-1.1) ...\n",
            "Setting up virtualenv (15.1.0+ds-1.1) ...\n",
            "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n",
            "Already using interpreter /usr/bin/python3\n",
            "Using base prefix '/usr'\n",
            "New python executable in /content/venv/bin/python3\n",
            "Also creating executable in /content/venv/bin/python\n",
            "Installing setuptools, pkg_resources, pip, wheel...done.\n",
            "\u001b[K     |████████████████████████████████| 71kB 6.4MB/s \n",
            "\u001b[K     |████████████████████████████████| 112kB 34.1MB/s \n",
            "\u001b[?25h2021-04-12 14:15:11.168849: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0\n",
            "Model converted to JSON successfully\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "plgECuQc9wdt"
      },
      "source": [
        "## Sample Example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kyfb-NtpNV7h",
        "outputId": "05c0b5d9-457a-48eb-d1d9-414adf34007c"
      },
      "source": [
        "# Sample examples\n",
        "sentence = [\"My credit card no is 124345346\", \"game of thrones season finale showing this sunday night\"]\n",
        "sequences = tokenizer.texts_to_sequences(sentence)\n",
        "padded = pad_sequences(sequences, maxlen=max_length, padding=padding_type, truncating=truncation_type)\n",
        "predictions = model.predict(padded)\n",
        "for i in range(len(predictions)):\n",
        "  print(predictions[i][0])\n",
        "  if predictions[i][0]>0.5:\n",
        "    print(\"Sensitive - \"+ sentence[i])\n",
        "  else:\n",
        "    print(\"Non-Sensitive - \" + sentence[i] )"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.9997549\n",
            "Sensitive - My credit card no is 124345346\n",
            "0.24462655\n",
            "Non-Sensitive - game of thrones season finale showing this sunday night\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}