Classifier_Model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Classifier_Model.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **Model Training**"
      ],
      "metadata": {
        "id": "pSyrw8yngaut"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Dataset-download\n",
        "!git clone https://github.com/ML9-FORCES/extractify-doc"
      ],
      "metadata": {
        "id": "2S7X_7nPirGL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#library - (Required in Usage & training)\n",
        "!pip install transformers\n",
        "from transformers import BertTokenizer\n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "\n",
        "#library - (Required in training only)\n",
        "!pip install scikit-plot\n",
        "import scikitplot as skplt\n",
        "import sklearn.metrics as metrics\n",
        "import pandas as pd\n",
        "import os\n",
        "import json\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#Helper-function \n",
        "\n",
        "#Dynamic Encoder & Decoder for classes\n",
        "def hot_encode(value):\n",
        "  encode={'question': 1 ,'other': 0, 'header': 0, 'answer': 2}\n",
        "  decode={1:'key',2:'value',0:'other'}\n",
        "  try:\n",
        "    return encode[value]\n",
        "  except:\n",
        "    return decode[value]\n",
        "\n",
        "#Wrappper for Post & Pre Processing over Model Usage.\n",
        "def predict(text,seq_len=50,mode=0):\n",
        "    tokens = tokenizer.encode_plus(text, max_length=seq_len,\n",
        "                                   truncation=True, padding='max_length',\n",
        "                                   add_special_tokens=True, return_token_type_ids=False,\n",
        "                                   return_tensors='tf')\n",
        "    # tokenizer returns int32 tensors, we need to return float64, so we use tf.cast\n",
        "    in_tensor = {'input_ids': tf.cast(tokens['input_ids'], tf.float64),\n",
        "            'attention_mask': tf.cast(tokens['attention_mask'], tf.float64)}\n",
        "    probs = model.predict(in_tensor)[0]\n",
        "    if mode ==1:\n",
        "      return probs\n",
        "    return np.argmax(probs)\n",
        "\n",
        "#Extracts Data From Dataset\n",
        "def extract(path):\n",
        "  arr =[]\n",
        "  for filename in os.listdir(path):\n",
        "    f = os.path.join(path, filename)\n",
        "    if os.path.isfile(f):\n",
        "      file_ = open(f)\n",
        "      data = json.load(file_)\n",
        "      file_.close()\n",
        "      for i in data['form']:\n",
        "        arr.append([i['text'],hot_encode(i['label'])])\n",
        "  df = pd.DataFrame(data = np.array(arr), columns = ['text', 'label'])\n",
        "  return df\n",
        "\n",
        "#Processing Data-Frames to TensorData with batch & Shuffle\n",
        "def tf_data(df,seq_len=246,batch_size=16,suffle=10000):\n",
        "  num_samples = len(df)\n",
        "  Xids = np.zeros((num_samples, seq_len))\n",
        "  Xmask = np.zeros((num_samples, seq_len))\n",
        "  tokenizer = BertTokenizer.from_pretrained('bert-base-cased')\n",
        "  for i, phrase in enumerate(df['text']):\n",
        "    tokens = tokenizer.encode_plus(phrase, max_length=seq_len, truncation=True,\n",
        "                                   padding='max_length', add_special_tokens=True,\n",
        "                                   return_tensors='tf')\n",
        "    Xids[i, :] = tokens['input_ids']\n",
        "    Xmask[i, :] = tokens['attention_mask']\n",
        "  df['label'] = df['label'].astype(int)\n",
        "  arr = df['label'].values\n",
        "  labels = np.zeros((num_samples, arr.max()+1))\n",
        "  labels[np.arange(num_samples), arr] = 1\n",
        "  dataset = tf.data.Dataset.from_tensor_slices((Xids, Xmask, labels))\n",
        "  def map_func(input_ids, masks, labels):\n",
        "    return {'input_ids': input_ids, 'attention_mask': masks}, labels\n",
        "  dataset = dataset.map(map_func)\n",
        "  dataset = dataset.shuffle(suffle).batch(batch_size, drop_remainder=True)\n",
        "  return dataset\n",
        "\n",
        "#For Ploting Loss & Accuracy Curves\n",
        "def plot_graphs(history, metric):\n",
        "  plt.plot(history.history[metric])\n",
        "  plt.plot(history.history['val_'+metric], '')\n",
        "  plt.xlabel(\"Epochs\")\n",
        "  plt.ylabel(metric)\n",
        "  plt.legend([metric, 'val_'+metric])"
      ],
      "metadata": {
        "id": "COj1KLeeILwQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HuBWtQV0CS6d"
      },
      "outputs": [],
      "source": [
        "#Parameters\n",
        "seq_len=50\n",
        "batch_size=16\n",
        "suffle=10000\n",
        "node=1024\n",
        "learning_rate=1e-5\n",
        "decay=1e-6\n",
        "\n",
        "#Data_Frames-Extraction\n",
        "train_data = extract('extractify-doc/dataset/training_data/annotations')\n",
        "test_data = extract('extractify-doc/dataset/testing_data/annotations')\n",
        "\n",
        "#Tensor-dataset\n",
        "train_ds = tf_data(train_data,seq_len,batch_size,suffle)\n",
        "val_ds = tf_data(test_data,seq_len,batch_size,suffle)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Building-Model\n",
        "from transformers import TFAutoModel\n",
        "bert = TFAutoModel.from_pretrained('bert-base-cased')\n",
        "input_ids = tf.keras.layers.Input(shape=(seq_len,), name='input_ids', dtype='int32')\n",
        "mask = tf.keras.layers.Input(shape=(seq_len,), name='attention_mask', dtype='int32')\n",
        "embeddings = bert.bert(input_ids, attention_mask=mask)[1]  # access pooled activations with [1]\n",
        "x = tf.keras.layers.Dense(node, activation='relu')(embeddings)\n",
        "y = tf.keras.layers.Dense(3, activation='softmax', name='outputs')(x)\n",
        "model = tf.keras.Model(inputs=[input_ids, mask], outputs=y)\n",
        "#model.layers[2].trainable = False # (optional) freeze bert layer\n",
        "optimizer = tf.keras.optimizers.Adam(lr=learning_rate, decay=decay)\n",
        "loss = tf.keras.losses.CategoricalCrossentropy()\n",
        "acc = tf.keras.metrics.CategoricalAccuracy('accuracy')\n",
        "model.compile(optimizer=optimizer, loss=loss, metrics=[acc])"
      ],
      "metadata": {
        "id": "oMHXCzU-ONrz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#model-summary\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oD_CA7zhB4e3",
        "outputId": "eed6c04d-fe04-4971-ffab-0e1aa00b5c89"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " input_ids (InputLayer)         [(None, 50)]         0           []                               \n",
            "                                                                                                  \n",
            " attention_mask (InputLayer)    [(None, 50)]         0           []                               \n",
            "                                                                                                  \n",
            " bert (TFBertMainLayer)         TFBaseModelOutputWi  108310272   ['input_ids[0][0]',              \n",
            "                                thPoolingAndCrossAt               'attention_mask[0][0]']         \n",
            "                                tentions(last_hidde                                               \n",
            "                                n_state=(None, 50,                                                \n",
            "                                768),                                                             \n",
            "                                 pooler_output=(Non                                               \n",
            "                                e, 768),                                                          \n",
            "                                 past_key_values=No                                               \n",
            "                                ne, hidden_states=N                                               \n",
            "                                one, attentions=Non                                               \n",
            "                                e, cross_attentions                                               \n",
            "                                =None)                                                            \n",
            "                                                                                                  \n",
            " dense (Dense)                  (None, 1024)         787456      ['bert[0][1]']                   \n",
            "                                                                                                  \n",
            " outputs (Dense)                (None, 3)            3075        ['dense[0][0]']                  \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 109,100,803\n",
            "Trainable params: 109,100,803\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#model-fit\n",
        "history = model.fit(\n",
        "    train_ds,\n",
        "    validation_data=val_ds,\n",
        "    epochs=3\n",
        ")"
      ],
      "metadata": {
        "id": "EsdfFZYWOeG9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "006e500b-b879-4eea-ba47-a2bd35a65ba0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/3\n",
            "463/463 [==============================] - 199s 401ms/step - loss: 0.6915 - accuracy: 0.7261 - val_loss: 0.5184 - val_accuracy: 0.8017\n",
            "Epoch 2/3\n",
            "463/463 [==============================] - 183s 394ms/step - loss: 0.5185 - accuracy: 0.8079 - val_loss: 0.5049 - val_accuracy: 0.8086\n",
            "Epoch 3/3\n",
            "463/463 [==============================] - 182s 394ms/step - loss: 0.4201 - accuracy: 0.8460 - val_loss: 0.5005 - val_accuracy: 0.8121\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#saving_model\n",
        "model.save('MODEL/classifier')\n",
        "#model.save('/content/drive/MyDrive/MODELS/classifier')"
      ],
      "metadata": {
        "id": "NBQBUL7VOtHz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Model-Metrics**"
      ],
      "metadata": {
        "id": "D2tYnRSr5diB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(16, 8))\n",
        "plt.subplot(1, 2, 1)\n",
        "plot_graphs(history, 'accuracy')\n",
        "plt.ylim(0, 1)\n",
        "plt.subplot(1, 2, 2)\n",
        "plot_graphs(history, 'loss')\n",
        "plt.ylim(0, 1)"
      ],
      "metadata": {
        "id": "6AOgT94_7E4N",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 518
        },
        "outputId": "255205af-5e4c-4b71-f9ca-c4c517238254"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.0, 1.0)"
            ]
          },
          "metadata": {},
          "execution_count": 19
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1152x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_loss, test_acc = model.evaluate(val_ds)\n",
        "print('Test Loss:', test_loss)\n",
        "print('Test Accuracy:', test_acc)"
      ],
      "metadata": {
        "id": "YsXbo-2E5cnb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e7970434-5c26-4346-901c-5d1eeddab4a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "145/145 [==============================] - 17s 114ms/step - loss: 0.5001 - accuracy: 0.8125\n",
            "Test Loss: 0.5000534057617188\n",
            "Test Accuracy: 0.8125\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_true=np.array([int(i) for i in test_data['label']])\n",
        "y_prob=np.array([predict(i,seq_len,1) for i in test_data['text']])\n",
        "y_pred=np.array([np.argmax(i) for i in y_prob])"
      ],
      "metadata": {
        "id": "k2FeSDh77slL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(metrics.classification_report(y_true,y_pred))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JlOA4sVhBRKy",
        "outputId": "ba52a796-f83e-4a38-d656-e3f4d7ebb636"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.59      0.65      0.62       434\n",
            "           1       0.87      0.87      0.87      1077\n",
            "           2       0.87      0.82      0.85       821\n",
            "\n",
            "    accuracy                           0.81      2332\n",
            "   macro avg       0.78      0.78      0.78      2332\n",
            "weighted avg       0.82      0.81      0.81      2332\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "skplt.metrics.plot_confusion_matrix(y_true, y_pred)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "DCEQjiFb664q",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "0f883f8c-0320-456a-e0bc-e97b3fa85121"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "skplt.metrics.plot_roc(y_true,y_prob)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "id": "cKMAHWHCMxMu",
        "outputId": "8d174985-2d00-4859-fdb0-43e7c3dff5b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f7f4cc01a50>"
            ]
          },
          "metadata": {},
          "execution_count": 90
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f1_score=metrics.f1_score(y_true,y_pred,average=None)\n",
        "print('F1-Score')\n",
        "print('class(0) : Other :',f1_score[0])\n",
        "print('class(1) : Key :',f1_score[1])\n",
        "print('class(2) : Value :',f1_score[2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c0RiGAXHU-M1",
        "outputId": "d2c6155e-64aa-401f-8192-fb8003618031"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "F1-Score\n",
            "class(0) : Other : 0.6197802197802198\n",
            "class(1) : Key : 0.8676265675801209\n",
            "class(2) : Value : 0.8457214241099312\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Model-Usage**"
      ],
      "metadata": {
        "id": "vmsSMVychsnq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#external requirement\n",
        "!pip install transformers\n",
        "!pip install gdown==4.1.1"
      ],
      "metadata": {
        "id": "5gVnR5Q7i8OL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eac82161-b9cf-43ad-f70e-7ebb984627bc"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting transformers\n",
            "  Downloading transformers-4.15.0-py3-none-any.whl (3.4 MB)\n",
            "\u001b[K     |████████████████████████████████| 3.4 MB 12.5 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.7/dist-packages (from transformers) (1.19.5)\n",
            "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.7/dist-packages (from transformers) (4.62.3)\n",
            "Collecting pyyaml>=5.1\n",
            "  Downloading PyYAML-6.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (596 kB)\n",
            "\u001b[K     |████████████████████████████████| 596 kB 25.1 MB/s \n",
            "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.7/dist-packages (from transformers) (3.4.0)\n",
            "Collecting huggingface-hub<1.0,>=0.1.0\n",
            "  Downloading huggingface_hub-0.2.1-py3-none-any.whl (61 kB)\n",
            "\u001b[K     |████████████████████████████████| 61 kB 497 kB/s \n",
            "\u001b[?25hRequirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from transformers) (2.23.0)\n",
            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from transformers) (4.8.2)\n",
            "Collecting sacremoses\n",
            "  Downloading sacremoses-0.0.46-py3-none-any.whl (895 kB)\n",
            "\u001b[K     |████████████████████████████████| 895 kB 50.7 MB/s \n",
            "\u001b[?25hCollecting tokenizers<0.11,>=0.10.1\n",
            "  Downloading tokenizers-0.10.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (3.3 MB)\n",
            "\u001b[K     |████████████████████████████████| 3.3 MB 41.3 MB/s \n",
            "\u001b[?25hRequirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.7/dist-packages (from transformers) (21.3)\n",
            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.7/dist-packages (from transformers) (2019.12.20)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from huggingface-hub<1.0,>=0.1.0->transformers) (3.10.0.2)\n",
            "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=20.0->transformers) (3.0.6)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->transformers) (3.6.0)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->transformers) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->transformers) (2021.10.8)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->transformers) (2.10)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->transformers) (3.0.4)\n",
            "Requirement already satisfied: click in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers) (7.1.2)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers) (1.15.0)\n",
            "Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from sacremoses->transformers) (1.1.0)\n",
            "Installing collected packages: pyyaml, tokenizers, sacremoses, huggingface-hub, transformers\n",
            "  Attempting uninstall: pyyaml\n",
            "    Found existing installation: PyYAML 3.13\n",
            "    Uninstalling PyYAML-3.13:\n",
            "      Successfully uninstalled PyYAML-3.13\n",
            "Successfully installed huggingface-hub-0.2.1 pyyaml-6.0 sacremoses-0.0.46 tokenizers-0.10.3 transformers-4.15.0\n",
            "Collecting gdown==4.1.1\n",
            "  Downloading gdown-4.1.1.tar.gz (13 kB)\n",
            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
            "    Preparing wheel metadata ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from gdown==4.1.1) (4.62.3)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.7/dist-packages (from gdown==4.1.1) (3.4.0)\n",
            "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from gdown==4.1.1) (4.6.3)\n",
            "Requirement already satisfied: requests[socks] in /usr/local/lib/python3.7/dist-packages (from gdown==4.1.1) (2.23.0)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from gdown==4.1.1) (1.15.0)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests[socks]->gdown==4.1.1) (2.10)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests[socks]->gdown==4.1.1) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests[socks]->gdown==4.1.1) (2021.10.8)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests[socks]->gdown==4.1.1) (3.0.4)\n",
            "Requirement already satisfied: PySocks!=1.5.7,>=1.5.6 in /usr/local/lib/python3.7/dist-packages (from requests[socks]->gdown==4.1.1) (1.7.1)\n",
            "Building wheels for collected packages: gdown\n",
            "  Building wheel for gdown (PEP 517) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for gdown: filename=gdown-4.1.1-py3-none-any.whl size=14211 sha256=904aeed3500d45057cfc662e5a317ebd0ec97fae410a42879a2e04f1ebd107b6\n",
            "  Stored in directory: /root/.cache/pip/wheels/0c/45/5c/0c6bf549923e217b4a0fd24a90ce36e0d183ca50b7a1a7306d\n",
            "Successfully built gdown\n",
            "Installing collected packages: gdown\n",
            "  Attempting uninstall: gdown\n",
            "    Found existing installation: gdown 3.6.4\n",
            "    Uninstalling gdown-3.6.4:\n",
            "      Successfully uninstalled gdown-3.6.4\n",
            "Successfully installed gdown-4.1.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Library\n",
        "from transformers import BertTokenizer\n",
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import gdown\n",
        "import os"
      ],
      "metadata": {
        "id": "mZb63yhOilIL"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#bert_classifier Class\n",
        "class bert_classifier:\n",
        "    def __init__(self):\n",
        "        path='./static/MODELS/bert_classifier'\n",
        "        url='https://drive.google.com/drive/folders/1u8pPnb2qPTt67Yf3v8enC2pF2HpyWaEc'\n",
        "        if not os.path.isdir(path):\n",
        "            gdown.download_folder(url,output=path, quiet=False)\n",
        "        self.tokenizer = BertTokenizer.from_pretrained('bert-base-cased')\n",
        "        self.model = tf.keras.models.load_model(path) \n",
        "\n",
        "    def preprocessing(self, input_data):\n",
        "        tokens = self.tokenizer.encode_plus(input_data, max_length=50,\n",
        "                                   truncation=True, padding='max_length',\n",
        "                                   add_special_tokens=True, return_token_type_ids=False,\n",
        "                                   return_tensors='tf')\n",
        "        # tokenizer returns int32 tensors, we need to return float64, so we use tf.cast\n",
        "        in_tensor = {'input_ids': tf.cast(tokens['input_ids'], tf.float64),\n",
        "            'attention_mask': tf.cast(tokens['attention_mask'], tf.float64)}\n",
        "        return in_tensor \n",
        "\n",
        "    def predict(self, input_data):\n",
        "        return self.model.predict(input_data)[0]\n",
        "\n",
        "    def postprocessing(self, input_data):\n",
        "        bins={1:'key',2:'value',0:'other'}\n",
        "        return bins[np.argmax(input_data)],str(np.max(input_data))\n",
        "\n",
        "    def compute_prediction(self, input_data):\n",
        "        try:\n",
        "            input_data = self.preprocessing(input_data)\n",
        "            prediction = self.predict(input_data)\n",
        "            prediction = self.postprocessing(prediction)\n",
        "        except Exception as e:\n",
        "            return {\"status\": \"Error\", \"message\": str(e)}\n",
        "        return prediction"
      ],
      "metadata": {
        "id": "Ib3uZ0U-hwO2"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Intialize Model-Object\n",
        "classifier = bert_classifier()"
      ],
      "metadata": {
        "id": "WDz9IuZ8k9Fw"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "text='DATE'\n",
        "prediction=classifier.compute_prediction(text)\n",
        "print(prediction) #(label,confidence)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AML64WCXlLGM",
        "outputId": "9ee2e85c-7b2c-440b-d8f4-d82ff9197886"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('key', '0.9858148')\n"
          ]
        }
      ]
    }
  ]
}