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": "48f904e0-f918-43fe-9491-0f63c38636ef"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[31mERROR: Invalid requirement: 'pytorch-pretrained-bert=0.4.0'\n",
      "Hint: = is not a valid operator. Did you mean == ?\u001b[0m\n",
      "Requirement already satisfied: seqeval==0.0.12 in /usr/local/lib/python3.7/dist-packages (0.0.12)\n",
      "Requirement already satisfied: numpy>=1.14.0 in /usr/local/lib/python3.7/dist-packages (from seqeval==0.0.12) (1.19.5)\n",
      "Requirement already satisfied: Keras>=2.2.4 in /usr/local/lib/python3.7/dist-packages (from seqeval==0.0.12) (2.4.3)\n",
      "Requirement already satisfied: scipy>=0.14 in /usr/local/lib/python3.7/dist-packages (from Keras>=2.2.4->seqeval==0.0.12) (1.4.1)\n",
      "Requirement already satisfied: h5py in /usr/local/lib/python3.7/dist-packages (from Keras>=2.2.4->seqeval==0.0.12) (3.1.0)\n",
      "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from Keras>=2.2.4->seqeval==0.0.12) (3.13)\n",
      "Requirement already satisfied: cached-property; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from h5py->Keras>=2.2.4->seqeval==0.0.12) (1.5.2)\n"
     ]
    }
   ],
   "source": [
    "# install\n",
    "!pip install pytorch-pretrained-bert=0.4.0 pytorch-nlp\n",
    "!pip install seqeval==0.0.12"
   ]
  },
  {
   "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.preprocessing.sequence 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": 106,
     "resources": {
      "http://localhost:8080/nbextensions/google.colab/files.js": {
       "data": "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",
       "headers": [
        [
         "content-type",
         "application/javascript"
        ]
       ],
       "ok": true,
       "status": 200,
       "status_text": ""
      }
     }
    },
    "id": "LPzhwGqK-kXc",
    "outputId": "3eb1aef8-f48b-49d8-d1ce-9684d2769847"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "     <input type=\"file\" id=\"files-61fa5ab3-679e-4be4-b2c2-d4c67b2d5fb6\" name=\"files[]\" multiple disabled\n",
       "        style=\"border:none\" />\n",
       "     <output id=\"result-61fa5ab3-679e-4be4-b2c2-d4c67b2d5fb6\">\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 src=\"/nbextensions/google.colab/files.js\"></script> "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "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": "ca9aaea6-7e74-49be-8cfd-5cae86d08480"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py: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"
     ]
    }
   ],
   "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": "3f20c996-214c-41ea-98d5-9d8edfca3969"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py: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",
      "  # Remove the CWD from sys.path while we load stuff.\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": "9fd10b0e-92c2-4606-cb56-6c6c431af512"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": "7eb9a8ad-2237-4335-ea3c-ca184acd5c6e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[CLS] i want to fly from boston at 838 am and arrive in denver at 1110 in the morning [SEP]\n",
      "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": "898bc23f-eb37-4c03-a95b-e15a64046b3b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BertForSequenceClassification(\n",
       "  (bert): BertModel(\n",
       "    (embeddings): BertEmbeddings(\n",
       "      (word_embeddings): Embedding(30522, 768, padding_idx=0)\n",
       "      (position_embeddings): Embedding(512, 768)\n",
       "      (token_type_embeddings): Embedding(2, 768)\n",
       "      (LayerNorm): BertLayerNorm()\n",
       "      (dropout): Dropout(p=0.1, inplace=False)\n",
       "    )\n",
       "    (encoder): BertEncoder(\n",
       "      (layer): ModuleList(\n",
       "        (0): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (1): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (2): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (3): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (4): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (5): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (6): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (7): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (8): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (9): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (10): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "        (11): BertLayer(\n",
       "          (attention): BertAttention(\n",
       "            (self): BertSelfAttention(\n",
       "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "            (output): BertSelfOutput(\n",
       "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "              (LayerNorm): BertLayerNorm()\n",
       "              (dropout): Dropout(p=0.1, inplace=False)\n",
       "            )\n",
       "          )\n",
       "          (intermediate): BertIntermediate(\n",
       "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          )\n",
       "          (output): BertOutput(\n",
       "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
       "            (LayerNorm): BertLayerNorm()\n",
       "            (dropout): Dropout(p=0.1, inplace=False)\n",
       "          )\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (pooler): BertPooler(\n",
       "      (dense): Linear(in_features=768, out_features=768, bias=True)\n",
       "      (activation): Tanh()\n",
       "    )\n",
       "  )\n",
       "  (dropout): Dropout(p=0.1, inplace=False)\n",
       "  (classifier): Linear(in_features=768, out_features=17, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 13,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "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": 788
    },
    "id": "MZFkgV9ybATM",
    "outputId": "897ea6d8-afdf-47dd-db6d-b72313c9c878"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "t_total value of -1 results in schedule not being applied\n",
      "Epoch:   0%|          | 0/4 [00:00<?, ?it/s]/usr/local/lib/python3.7/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  /pytorch/torch/csrc/utils/python_arg_parser.cpp:1005.)\n",
      "  next_m.mul_(beta1).add_(1 - beta1, grad)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 1.0584670407431467\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "Epoch:  25%|&#9608;&#9608;&#9612;       | 1/4 [01:55<05:47, 115.89s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Accuracy: 0.8359375\n",
      "Train loss: 0.560495495476893\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "Epoch:  50%|&#9608;&#9608;&#9608;&#9608;&#9608;     | 2/4 [03:57<03:55, 117.69s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Accuracy: 0.873046875\n",
      "Train loss: 0.3820755224941032\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "Epoch:  75%|&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9612;  | 3/4 [06:01<01:59, 119.59s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Accuracy: 0.943359375\n",
      "Train loss: 0.24857785073774202\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 100%|&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;| 4/4 [08:06<00:00, 121.70s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Accuracy: 0.962890625\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "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()"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "02_BERT_ATIS.ipynb",
   "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": 1
}