Ch6/02_BERT_ATIS.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-m92wDoNlzcg"
      },
      "source": [
        "## Intent Classification for the ATIS Dataset using BERT.\n",
        "In this notebook we build a classifier for the ATIS Dataset using [BERT](https://arxiv.org/abs/1810.04805), a pre-Trained NLP model open soucred by google in late 2018 that can be used for [Transfer Learning](https://towardsdatascience.com/transfer-learning-in-nlp-fecc59f546e4) on text data. More Details on our approach can be found at this [Article](https://towardsdatascience.com/bert-for-dummies-step-by-step-tutorial-fb90890ffe03).The dataset is in the repo.<br>\n",
        "This notebook requires a GPU to get setup. We suggest you to run this on your local machine only if you have a GPU setup or else you can use google colab."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EVr-bWUpVUBC"
      },
      "source": [
        "### Importing\n",
        "Making the necessary imports and installing the required libraries.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3XHt3WCThUS-",
        "outputId": "9f7fa726-ecd6-432f-d4be-7f5cae8cd0d6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting pytorch-pretrained-bert\n",
            "  Downloading pytorch_pretrained_bert-0.6.2-py3-none-any.whl (123 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m123.8/123.8 kB\u001b[0m \u001b[31m3.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting pytorch-nlp\n",
            "  Downloading pytorch_nlp-0.5.0-py3-none-any.whl (90 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m90.1/90.1 kB\u001b[0m \u001b[31m11.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: torch>=0.4.1 in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (2.0.1+cu118)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (1.23.5)\n",
            "Collecting boto3 (from pytorch-pretrained-bert)\n",
            "  Downloading boto3-1.28.37-py3-none-any.whl (135 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m135.8/135.8 kB\u001b[0m \u001b[31m14.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (2.31.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (4.66.1)\n",
            "Requirement already satisfied: regex in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (2023.6.3)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (3.12.2)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (4.7.1)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (3.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (3.1.2)\n",
            "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (2.0.0)\n",
            "Requirement already satisfied: cmake in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=0.4.1->pytorch-pretrained-bert) (3.27.2)\n",
            "Requirement already satisfied: lit in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=0.4.1->pytorch-pretrained-bert) (16.0.6)\n",
            "Collecting botocore<1.32.0,>=1.31.37 (from boto3->pytorch-pretrained-bert)\n",
            "  Downloading botocore-1.31.37-py3-none-any.whl (11.1 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m11.1/11.1 MB\u001b[0m \u001b[31m84.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting jmespath<2.0.0,>=0.7.1 (from boto3->pytorch-pretrained-bert)\n",
            "  Downloading jmespath-1.0.1-py3-none-any.whl (20 kB)\n",
            "Collecting s3transfer<0.7.0,>=0.6.0 (from boto3->pytorch-pretrained-bert)\n",
            "  Downloading s3transfer-0.6.2-py3-none-any.whl (79 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.8/79.8 kB\u001b[0m \u001b[31m9.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->pytorch-pretrained-bert) (3.2.0)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->pytorch-pretrained-bert) (3.4)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->pytorch-pretrained-bert) (2.0.4)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->pytorch-pretrained-bert) (2023.7.22)\n",
            "Requirement already satisfied: python-dateutil<3.0.0,>=2.1 in /usr/local/lib/python3.10/dist-packages (from botocore<1.32.0,>=1.31.37->boto3->pytorch-pretrained-bert) (2.8.2)\n",
            "Collecting urllib3<3,>=1.21.1 (from requests->pytorch-pretrained-bert)\n",
            "  Downloading urllib3-1.26.16-py2.py3-none-any.whl (143 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m143.1/143.1 kB\u001b[0m \u001b[31m16.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=0.4.1->pytorch-pretrained-bert) (2.1.3)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=0.4.1->pytorch-pretrained-bert) (1.3.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil<3.0.0,>=2.1->botocore<1.32.0,>=1.31.37->boto3->pytorch-pretrained-bert) (1.16.0)\n",
            "Installing collected packages: urllib3, pytorch-nlp, jmespath, botocore, s3transfer, boto3, pytorch-pretrained-bert\n",
            "  Attempting uninstall: urllib3\n",
            "    Found existing installation: urllib3 2.0.4\n",
            "    Uninstalling urllib3-2.0.4:\n",
            "      Successfully uninstalled urllib3-2.0.4\n",
            "Successfully installed boto3-1.28.37 botocore-1.31.37 jmespath-1.0.1 pytorch-nlp-0.5.0 pytorch-pretrained-bert-0.6.2 s3transfer-0.6.2 urllib3-1.26.16\n",
            "Collecting seqeval\n",
            "  Downloading seqeval-1.2.2.tar.gz (43 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.6/43.6 kB\u001b[0m \u001b[31m890.2 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: numpy>=1.14.0 in /usr/local/lib/python3.10/dist-packages (from seqeval) (1.23.5)\n",
            "Requirement already satisfied: scikit-learn>=0.21.3 in /usr/local/lib/python3.10/dist-packages (from seqeval) (1.2.2)\n",
            "Requirement already satisfied: scipy>=1.3.2 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=0.21.3->seqeval) (1.10.1)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=0.21.3->seqeval) (1.3.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=0.21.3->seqeval) (3.2.0)\n",
            "Building wheels for collected packages: seqeval\n",
            "  Building wheel for seqeval (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for seqeval: filename=seqeval-1.2.2-py3-none-any.whl size=16162 sha256=f26cd857e38a28ffdd8d304ae95c5ec3445dc7cbb66632598d291bdf735ae0ab\n",
            "  Stored in directory: /root/.cache/pip/wheels/1a/67/4a/ad4082dd7dfc30f2abfe4d80a2ed5926a506eb8a972b4767fa\n",
            "Successfully built seqeval\n",
            "Installing collected packages: seqeval\n",
            "Successfully installed seqeval-1.2.2\n"
          ]
        }
      ],
      "source": [
        "# install\n",
        "!pip install pytorch-pretrained-bert pytorch-nlp\n",
        "!pip install seqeval"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "d-mlOxsO-cgl"
      },
      "outputs": [],
      "source": [
        "#importing a few necessary packages and setting the DATA directory\n",
        "DATA_DIR=\".\"\n",
        "import os\n",
        "import numpy as np\n",
        "import pickle\n",
        "import tensorflow as tf\n",
        "\n",
        "\n",
        "# BERT imports\n",
        "import torch\n",
        "from torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler\n",
        "from keras.utils import pad_sequences\n",
        "from sklearn.model_selection import train_test_split\n",
        "from torch.optim import Adam\n",
        "from pytorch_pretrained_bert import BertTokenizer, BertConfig\n",
        "from pytorch_pretrained_bert import BertAdam, BertForSequenceClassification\n",
        "from tqdm import tqdm, trange\n",
        "import pandas as pd\n",
        "import io\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "#importing packages to calculate the f1_score of our model\n",
        "from seqeval.metrics import f1_score\n",
        "\n",
        "# specify GPU device\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "if torch.cuda.is_available():\n",
        "    n_gpu = torch.cuda.device_count()\n",
        "    torch.cuda.get_device_name(0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M1D9QaVXVejl"
      },
      "source": [
        "### Dataset\n",
        "Upload the dataset into colab"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 109
        },
        "id": "LPzhwGqK-kXc",
        "outputId": "e69caad5-c5ab-498b-f9e8-33b41823da72"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-65992b64-50b1-4c1c-86af-0bf2b5783fef\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-65992b64-50b1-4c1c-86af-0bf2b5783fef\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving atis.test.w-intent.iob to atis.test.w-intent.iob\n",
            "Saving atis.train.w-intent.iob to atis.train.w-intent.iob\n"
          ]
        }
      ],
      "source": [
        "#importing the dataset\n",
        "#upload the \"atis.test.w-intent.iob\" and atis.train.w-intent.iob\" present in data2 folder\n",
        "try:\n",
        "    from google.colab import files\n",
        "    uploaded = files.upload()\n",
        "except ModuleNotFoundError:\n",
        "    print('Not using colab')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6OQLsmbqVqfN"
      },
      "source": [
        "### Preprocessing\n",
        "We need to read data from the .iob files. Hence we need a few preprocessing helper functions. The below functions can be found in the utils.py file."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "Dg16o9IO_BDd"
      },
      "outputs": [],
      "source": [
        "#preprocessing functions\n",
        "def get_data(filename):\n",
        "    df = pd.read_csv(filename,delim_whitespace=True,names=['word','label'])\n",
        "    beg_indices = list(df[df['word'] == 'BOS'].index)+[df.shape[0]]\n",
        "    sents,labels,intents = [],[],[]\n",
        "    for i in range(len(beg_indices[:-1])):\n",
        "        sents.append(df[beg_indices[i]+1:beg_indices[i+1]-1]['word'].values)\n",
        "        labels.append(df[beg_indices[i]+1:beg_indices[i+1]-1]['label'].values)\n",
        "        intents.append(df.loc[beg_indices[i+1]-1]['label'])\n",
        "    return np.array(sents),np.array(labels),np.array(intents)\n",
        "\n",
        "def get_data2(filename):\n",
        "    with open(filename) as f:\n",
        "        contents = f.read()\n",
        "    sents,labels,intents = [],[],[]\n",
        "    for line in contents.strip().split('\\n'):\n",
        "        words,labs = [i.split(' ') for i in line.split('\\t')]\n",
        "        sents.append(words[1:-1])\n",
        "        labels.append(labs[1:-1])\n",
        "        intents.append(labs[-1])\n",
        "    return np.array(sents),np.array(labels),np.array(intents)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m-ND3usZV8UO"
      },
      "source": [
        "Reading the training data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xc4ULfDU_T16",
        "outputId": "beb120a3-489f-4c04-96cd-cc61608bb99b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loading the training Data\n",
            "Number of training sentences : 4952\n",
            "Number of unique intents : 17\n",
            "('i want to fly from boston at 838 am and arrive in denver at 1110 in the morning', 'atis_flight')\n",
            "('what flights are available from pittsburgh to baltimore on thursday morning', 'atis_flight')\n",
            "('what is the arrival time in san francisco for the 755 am flight leaving washington', 'atis_flight_time')\n",
            "('cheapest airfare from tacoma to orlando', 'atis_airfare')\n",
            "('round trip fares from pittsburgh to philadelphia under 1000 dollars', 'atis_airfare')\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-4-fe13b9f6a376>:21: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "  return np.array(sents),np.array(labels),np.array(intents)\n"
          ]
        }
      ],
      "source": [
        "print(\"Loading the training Data\")\n",
        "\n",
        "try:\n",
        "    from google.colab import files\n",
        "    sents,labels,intents = get_data2('atis.train.w-intent.iob')\n",
        "except ModuleNotFoundError:\n",
        "    sents,labels,intents = get_data2('Data/data2/atis.train.w-intent.iob')\n",
        "\n",
        "train_sentences = [\" \".join(i) for i in sents]\n",
        "\n",
        "train_texts = train_sentences\n",
        "train_labels= intents.tolist()\n",
        "\n",
        "vals = []\n",
        "\n",
        "for i in range(len(train_labels)):\n",
        "    if \"#\" in train_labels[i]:\n",
        "        vals.append(i)\n",
        "\n",
        "for i in vals[::-1]:\n",
        "    train_labels.pop(i)\n",
        "    train_texts.pop(i)\n",
        "\n",
        "print (\"Number of training sentences :\",len(train_texts))\n",
        "print (\"Number of unique intents :\",len(set(train_labels)))\n",
        "\n",
        "for i in zip(train_texts[:5], train_labels[:5]):\n",
        "    print(i)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GsJTkImyV_r8"
      },
      "source": [
        "Reading the Test data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tWJ8th5TBsrW",
        "outputId": "2555e42c-cb0a-423c-e081-85f8e90afb2a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "atis_day_name\n",
            "atis_day_name\n",
            "Number of testing sentences : 876\n",
            "Number of unique intents : 15\n",
            "('i would like to find a flight from charlotte to las vegas that makes a stop in st. louis', 'atis_flight')\n",
            "('on april first i need a ticket from tacoma to san jose departing before 7 am', 'atis_airfare')\n",
            "('on april first i need a flight going from phoenix to san diego', 'atis_flight')\n",
            "('i would like a flight traveling one way from phoenix to san diego on april first', 'atis_flight')\n",
            "('i would like a flight from orlando to salt lake city for april first on delta airlines', 'atis_flight')\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-4-fe13b9f6a376>:10: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "  return np.array(sents),np.array(labels),np.array(intents)\n"
          ]
        }
      ],
      "source": [
        "try:\n",
        "    from google.colab import files\n",
        "    sents,labels,intents = get_data('atis.test.w-intent.iob')\n",
        "except ModuleNotFoundError:\n",
        "    sents,labels,intents = get_data('Data/data2/atis.test.w-intent.iob')\n",
        "\n",
        "\n",
        "test_sentences = [\" \".join(i) for i in sents]\n",
        "\n",
        "test_texts = test_sentences\n",
        "test_labels = intents.tolist()\n",
        "\n",
        "new_labels = set(test_labels) - set(train_labels)\n",
        "\n",
        "vals = []\n",
        "\n",
        "for i in range(len(test_labels)):\n",
        "    if \"#\" in test_labels[i]:\n",
        "        vals.append(i)\n",
        "    elif test_labels[i] in new_labels:\n",
        "        print(test_labels[i])\n",
        "        vals.append(i)\n",
        "\n",
        "for i in vals[::-1]:\n",
        "    test_labels.pop(i)\n",
        "    test_texts.pop(i)\n",
        "\n",
        "print (\"Number of testing sentences :\",len(test_texts))\n",
        "print (\"Number of unique intents :\",len(set(test_labels)))\n",
        "\n",
        "for i in zip(test_texts[:5], test_labels[:5]):\n",
        "    print(i)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tymf0cdgWCy5"
      },
      "source": [
        "As this is a demonstration we will we using only using the training data. We will split it to get a test and train data.<br>\n",
        "Converting the data into a pandas dataframe."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jpbJHj6GXM3o",
        "outputId": "d4f933cb-79b8-4102-dc68-e1102ccd2348"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Length of training labels: 4952\n",
            "Length of training texts: 4952\n"
          ]
        }
      ],
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "\n",
        "df = pd.DataFrame(data =zip(train_labels,train_texts),columns=['Labels',\"Text\"])\n",
        "\n",
        "lb_make = LabelEncoder()\n",
        "df[\"Labels\"] = lb_make.fit_transform(df[\"Labels\"])\n",
        "\n",
        "train_texts = list(df['Text'])\n",
        "train_labels = list(df['Labels'])\n",
        "print(\"Length of training labels:\",len(train_labels))\n",
        "print(\"Length of training texts:\",len(train_texts))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WrmcXpsyWqeW"
      },
      "source": [
        "BERT expects data to be in a specific format, i.e, [CLS] token1,token2,....[SEP]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wKZgpzwLB5jD",
        "outputId": "6262ffa6-015d-416f-a9d3-ac029320d3df"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[CLS] i want to fly from boston at 838 am and arrive in denver at 1110 in the morning [SEP]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 231508/231508 [00:00<00:00, 2645190.19B/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tokenize the first sentence:\n",
            "['[CLS]', 'i', 'want', 'to', 'fly', 'from', 'boston', 'at', '83', '##8', 'am', 'and', 'arrive', 'in', 'denver', 'at', '111', '##0', 'in', 'the', 'morning', '[SEP]']\n"
          ]
        }
      ],
      "source": [
        "query_data_train = list(train_texts)\n",
        "sentences = [\"[CLS] \" + query + \" [SEP]\" for query in query_data_train]\n",
        "print(sentences[0])\n",
        "\n",
        "# Tokenize with BERT tokenizer\n",
        "\n",
        "#BERT only takes a token size of 512.\n",
        "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)\n",
        "tokenized_texts = [tokenizer.tokenize(sent) for sent in sentences]\n",
        "print (\"Tokenize the first sentence:\")\n",
        "print (tokenized_texts[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "qSl4Bw-9Shgn"
      },
      "outputs": [],
      "source": [
        "# Set the maximum sequence length.\n",
        "MAX_LEN = 128\n",
        "# Pad our input tokens\n",
        "input_ids = pad_sequences([tokenizer.convert_tokens_to_ids(txt) for txt in tokenized_texts],\n",
        "                          maxlen=MAX_LEN, dtype=\"long\", truncating=\"post\", padding=\"post\")\n",
        "# Use the BERT tokenizer to convert the tokens to their index numbers in the BERT vocabulary\n",
        "input_ids = [tokenizer.convert_tokens_to_ids(x) for x in tokenized_texts]\n",
        "input_ids = pad_sequences(input_ids, maxlen=MAX_LEN, dtype=\"long\", truncating=\"post\", padding=\"post\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FqkxN3IjaG7p"
      },
      "source": [
        "Creating the BERT attention masks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "XnbD4jorSqXs"
      },
      "outputs": [],
      "source": [
        "# Create attention masks\n",
        "attention_masks = []\n",
        "# Create a mask of 1s for each token followed by 0s for padding\n",
        "for seq in input_ids:\n",
        "    seq_mask = [float(i>0) for i in seq]\n",
        "    attention_masks.append(seq_mask)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "46r7l4GZgFTE"
      },
      "outputs": [],
      "source": [
        "intent_data_label_train = train_labels#renaming"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUv9j3v1aKYg"
      },
      "source": [
        "### Splitting the training data into train and test sets."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "LFsyID-US8s8"
      },
      "outputs": [],
      "source": [
        "# Use train_test_split to split our data into train and validation sets for training\n",
        "\n",
        "\n",
        "train_inputs, validation_inputs, train_labels, validation_labels = train_test_split(input_ids,\n",
        "                                                                                    intent_data_label_train,\n",
        "                                                                                    random_state=2020,\n",
        "                                                                                    test_size=0.1)\n",
        "train_masks, validation_masks, _, _ = train_test_split(attention_masks,\n",
        "                                                       input_ids,\n",
        "                                                       random_state=2020,\n",
        "                                                       test_size=0.1)\n",
        "\n",
        "\n",
        "# Convert all of our data into torch tensors, the required datatype for our model\n",
        "train_inputs = torch.tensor(train_inputs)\n",
        "validation_inputs = torch.tensor(validation_inputs)\n",
        "train_labels = torch.tensor(train_labels)\n",
        "validation_labels = torch.tensor(validation_labels)\n",
        "train_masks = torch.tensor(train_masks)\n",
        "validation_masks = torch.tensor(validation_masks)\n",
        "\n",
        "# Select a batch size for training.\n",
        "batch_size = 32\n",
        "\n",
        "# Create an iterator of our data with torch DataLoader\n",
        "train_data = TensorDataset(train_inputs, train_masks, train_labels)\n",
        "train_sampler = RandomSampler(train_data)\n",
        "train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=batch_size)\n",
        "validation_data = TensorDataset(validation_inputs, validation_masks, validation_labels)\n",
        "validation_sampler = SequentialSampler(validation_data)\n",
        "validation_dataloader = DataLoader(validation_data, sampler=validation_sampler, batch_size=batch_size)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nEHUwpWSTGy0",
        "outputId": "6468b67a-bb7a-4e10-8c89-b20bf0672d1b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 407873900/407873900 [00:09<00:00, 43125581.25B/s]\n"
          ]
        }
      ],
      "source": [
        "model = BertForSequenceClassification.from_pretrained(\"bert-base-uncased\", num_labels=17)\n",
        "if torch.cuda.is_available():\n",
        "    model.cuda()\n",
        "else:\n",
        "    model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CgcfFlczaW_V"
      },
      "source": [
        "### Fine-Tuning BERT"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 866
        },
        "id": "MZFkgV9ybATM",
        "outputId": "fdfb475d-4bf6-444f-86c8-7486b3f1c3fa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:pytorch_pretrained_bert.optimization:t_total value of -1 results in schedule not being applied\n",
            "Epoch:   0%|          | 0/4 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/pytorch_pretrained_bert/optimization.py:275: UserWarning: This overload of add_ is deprecated:\n",
            "\tadd_(Number alpha, Tensor other)\n",
            "Consider using one of the following signatures instead:\n",
            "\tadd_(Tensor other, *, Number alpha) (Triggered internally at ../torch/csrc/utils/python_arg_parser.cpp:1485.)\n",
            "  next_m.mul_(beta1).add_(1 - beta1, grad)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train loss: 0.4845616072815444\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\rEpoch:  25%|██▌       | 1/4 [01:51<05:34, 111.52s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Accuracy: 0.96875\n",
            "Train loss: 0.1131925695974912\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\rEpoch:  50%|█████     | 2/4 [03:42<03:42, 111.47s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Accuracy: 0.982421875\n",
            "Train loss: 0.06519937950984708\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\rEpoch:  75%|███████▌  | 3/4 [05:35<01:52, 112.07s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Accuracy: 0.986328125\n",
            "Train loss: 0.030708313204481134\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Epoch: 100%|██████████| 4/4 [07:29<00:00, 112.29s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Accuracy: 0.9921875\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# BERT fine-tuning parameters\n",
        "FULL_FINETUNING = True\n",
        "if FULL_FINETUNING:\n",
        "    param_optimizer = list(model.named_parameters())\n",
        "    no_decay = ['bias', 'gamma', 'beta']\n",
        "    optimizer_grouped_parameters = [\n",
        "      {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],\n",
        "      'weight_decay_rate': 0.01},\n",
        "      {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)],\n",
        "      'weight_decay_rate': 0.0}\n",
        "  ]\n",
        "else:\n",
        "    param_optimizer = list(model.classifier.named_parameters())\n",
        "    optimizer_grouped_parameters = [{\"params\": [p for n, p in param_optimizer]}]\n",
        "\n",
        "optimizer = BertAdam(optimizer_grouped_parameters, lr=3e-5)\n",
        "\n",
        "\n",
        "# Function to calculate the accuracy of our predictions vs labels\n",
        "def flat_accuracy(preds, labels):\n",
        "    pred_flat = np.argmax(preds, axis=1).flatten()\n",
        "    labels_flat = labels.flatten()\n",
        "    return np.sum(pred_flat == labels_flat) / len(labels_flat)\n",
        "\n",
        "# Store our loss and accuracy for plotting\n",
        "train_loss_set = []\n",
        "# Number of training epochs\n",
        "epochs = 4\n",
        "\n",
        "# BERT training loop\n",
        "for _ in trange(epochs, desc=\"Epoch\"):\n",
        "\n",
        "  ###### TRAINING ######\n",
        "\n",
        "    # Set our model to training mode\n",
        "    model.train()\n",
        "    # Tracking variables\n",
        "    tr_loss = 0\n",
        "    nb_tr_examples, nb_tr_steps = 0, 0\n",
        "    # Train the data for one epoch\n",
        "    for step, batch in enumerate(train_dataloader):\n",
        "        # Add batch to GPU\n",
        "        batch = tuple(t.to(device) for t in batch)\n",
        "        # Unpack the inputs from our dataloader\n",
        "        b_input_ids, b_input_mask, b_labels = batch\n",
        "        # Clear out the gradients (by default they accumulate)\n",
        "        optimizer.zero_grad()\n",
        "        # Forward pass\n",
        "        loss = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask, labels=b_labels)\n",
        "        train_loss_set.append(loss.item())\n",
        "        # Backward pass\n",
        "        loss.backward()\n",
        "        # Update parameters and take a step using the computed gradient\n",
        "        optimizer.step()\n",
        "        # Update tracking variables\n",
        "        tr_loss += loss.item()\n",
        "        nb_tr_examples += b_input_ids.size(0)\n",
        "        nb_tr_steps += 1\n",
        "    print(\"Train loss: {}\".format(tr_loss/nb_tr_steps))\n",
        "\n",
        "  ###### VALIDATION ######\n",
        "\n",
        "  # Put model in evaluation mode\n",
        "    model.eval()\n",
        "    # Tracking variables\n",
        "    eval_loss, eval_accuracy = 0, 0\n",
        "    nb_eval_steps, nb_eval_examples = 0, 0\n",
        "    # Evaluate data for one epoch\n",
        "    for batch in validation_dataloader:\n",
        "        # Add batch to GPU\n",
        "        batch = tuple(t.to(device) for t in batch)\n",
        "        # Unpack the inputs from our dataloader\n",
        "        b_input_ids, b_input_mask, b_labels = batch\n",
        "        # Telling the model not to compute or store gradients, saving memory and speeding up validation\n",
        "        with torch.no_grad():\n",
        "          # Forward pass, calculate logit predictions\n",
        "            logits = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask)\n",
        "        # Move logits and labels to CPU\n",
        "        logits = logits.detach().cpu().numpy()\n",
        "        label_ids = b_labels.to('cpu').numpy()\n",
        "        tmp_eval_accuracy = flat_accuracy(logits, label_ids)\n",
        "        eval_accuracy += tmp_eval_accuracy\n",
        "        nb_eval_steps += 1\n",
        "    print(\"Validation Accuracy: {}\".format(eval_accuracy/nb_eval_steps))\n",
        "\n",
        "# plot training performance\n",
        "plt.figure(figsize=(15,8))\n",
        "plt.title(\"Training loss\")\n",
        "plt.xlabel(\"Batch\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.plot(train_loss_set)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "HFBoMelbXxP5"
      },
      "execution_count": 14,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}