bert_CoLA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "bert_CoLA.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F23dOdmW3Pwn",
        "outputId": "03ee8785-1698-4d1b-ccc6-38d3749919da"
      },
      "source": [
        "# verify GPU availability\n",
        "import tensorflow as tf\n",
        "\n",
        "device_name = tf.test.gpu_device_name()\n",
        "if device_name != '/device:GPU:0':\n",
        "  raise SystemError('GPU device not found')\n",
        "print('Found GPU at: {}'.format(device_name))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found GPU at: /device:GPU:0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 341
        },
        "id": "xgqQLFWC3cam",
        "outputId": "15dfed32-ebd2-4899-c073-f46a5f0ef4a5"
      },
      "source": [
        "\n",
        "# install\n",
        "!pip install pytorch-pretrained-bert pytorch-nlp\n",
        "\n",
        "# BERT imports\n",
        "import torch\n",
        "import os\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 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",
        "# specify GPU device\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "n_gpu = torch.cuda.device_count()\n",
        "torch.cuda.get_device_name(0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: pytorch-pretrained-bert in /usr/local/lib/python3.7/dist-packages (0.6.2)\n",
            "Requirement already satisfied: pytorch-nlp in /usr/local/lib/python3.7/dist-packages (0.5.0)\n",
            "Requirement already satisfied: torch>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from pytorch-pretrained-bert) (1.9.0+cu102)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from pytorch-pretrained-bert) (1.19.5)\n",
            "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from pytorch-pretrained-bert) (2019.12.20)\n",
            "Requirement already satisfied: boto3 in /usr/local/lib/python3.7/dist-packages (from pytorch-pretrained-bert) (1.18.30)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from pytorch-pretrained-bert) (4.62.0)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from pytorch-pretrained-bert) (2.23.0)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (3.7.4.3)\n",
            "Requirement already satisfied: botocore<1.22.0,>=1.21.30 in /usr/local/lib/python3.7/dist-packages (from boto3->pytorch-pretrained-bert) (1.21.30)\n",
            "Requirement already satisfied: jmespath<1.0.0,>=0.7.1 in /usr/local/lib/python3.7/dist-packages (from boto3->pytorch-pretrained-bert) (0.10.0)\n",
            "Requirement already satisfied: s3transfer<0.6.0,>=0.5.0 in /usr/local/lib/python3.7/dist-packages (from boto3->pytorch-pretrained-bert) (0.5.0)\n",
            "Requirement already satisfied: python-dateutil<3.0.0,>=2.1 in /usr/local/lib/python3.7/dist-packages (from botocore<1.22.0,>=1.21.30->boto3->pytorch-pretrained-bert) (2.8.2)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.25.4 in /usr/local/lib/python3.7/dist-packages (from botocore<1.22.0,>=1.21.30->boto3->pytorch-pretrained-bert) (1.25.11)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil<3.0.0,>=2.1->botocore<1.22.0,>=1.21.30->boto3->pytorch-pretrained-bert) (1.15.0)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->pytorch-pretrained-bert) (2.10)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->pytorch-pretrained-bert) (3.0.4)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->pytorch-pretrained-bert) (2021.5.30)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Tesla K80'"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 140
        },
        "id": "MNM7RhA_4EvA",
        "outputId": "5f586be0-7d7f-425f-b0d4-c715aee21fbd"
      },
      "source": [
        "# Using CoLA dataset: https://nyu-mll.github.io/CoLA/\n",
        "\n",
        "# add special tokens for BERT to work properly\n",
        "df = pd.read_csv(\"in_domain_train.tsv\", delimiter='\\t', header=None, names=['sentence_source', 'label', 'label_notes', 'sentence'])\n",
        "sentences = df.sentence.values\n",
        "print(sentences[0])\n",
        "labels = df.label.values\n",
        "\n",
        "# Tokenize with BERT tokenizer\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])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-8731ea1c-16e4-40b6-aa0b-fba9f969bcb2\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-8731ea1c-16e4-40b6-aa0b-fba9f969bcb2\">\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": {}
        },
        {
          "output_type": "stream",
          "text": [
            "Saving in_domain_train.tsv to in_domain_train (2).tsv\n",
            "Drive already mounted at /drive; to attempt to forcibly remount, call drive.mount(\"/drive\", force_remount=True).\n",
            "Our friends won't buy this analysis, let alone the next one we propose.\n",
            "Tokenize the first sentence:\n",
            "['our', 'friends', 'won', \"'\", 't', 'buy', 'this', 'analysis', ',', 'let', 'alone', 'the', 'next', 'one', 'we', 'propose', '.']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M6Y_29855BsN"
      },
      "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\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FksyO6Pj6Glq"
      },
      "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)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x_Ddr4olMi_M"
      },
      "source": [
        "Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wst32mzC51in"
      },
      "source": [
        "\n",
        "# Use train_test_split to split our data into train and validation sets for training\n",
        "train_inputs, validation_inputs, train_labels, validation_labels = train_test_split(input_ids, labels, \n",
        "                                                            random_state=2018, test_size=0.1)\n",
        "train_masks, validation_masks, _, _ = train_test_split(attention_masks, input_ids,\n",
        "                                             random_state=2018, test_size=0.1)\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)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KpmOarpzI0mV",
        "outputId": "1c977486-1e46-4a10-82be-22c38ecbcc82"
      },
      "source": [
        "# Load BertForSequenceClassification, the pretrained BERT model with a single linear classification layer on top. \n",
        "\n",
        "model = BertForSequenceClassification.from_pretrained(\"bert-base-uncased\", num_labels=2)\n",
        "model.cuda()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "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=2, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P4OPVW1EJC9P"
      },
      "source": [
        "\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",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Pb4OpXcJExj",
        "outputId": "ee11839d-d4ba-4265-e4c0-12bba0d929be"
      },
      "source": [
        "# This variable contains all of the hyperparemeter information our training loop needs\n",
        "optimizer = BertAdam(optimizer_grouped_parameters,\n",
        "                     lr=2e-5,\n",
        "                     warmup=.1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "t_total value of -1 results in schedule not being applied\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9P8WKfHZJORf",
        "outputId": "f472d2d4-4b0d-43ae-9254-33566d4f884c"
      },
      "source": [
        "# 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",
        "\n",
        "t = [] \n",
        "\n",
        "# Store our loss and accuracy for plotting\n",
        "train_loss_set = []\n",
        "\n",
        "# Number of training epochs (authors recommend between 2 and 4)\n",
        "epochs = 1\n",
        "\n",
        "# trange is a tqdm wrapper around the normal python range\n",
        "for _ in trange(epochs, desc=\"Epoch\"):\n",
        "  \n",
        "  \n",
        "  # Training\n",
        "  \n",
        "  # Set our model to training mode (as opposed to evaluation mode)\n",
        "  model.train()\n",
        "  \n",
        "  # Tracking variables\n",
        "  tr_loss = 0\n",
        "  nb_tr_examples, nb_tr_steps = 0, 0\n",
        "  \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",
        "    \n",
        "    \n",
        "    # Update tracking variables\n",
        "    tr_loss += loss.item()\n",
        "    nb_tr_examples += b_input_ids.size(0)\n",
        "    nb_tr_steps += 1\n",
        "\n",
        "  print(\"Train loss: {}\".format(tr_loss/nb_tr_steps))\n",
        "    \n",
        "    \n",
        "  # Validation\n",
        "\n",
        "  # Put model in evaluation mode to evaluate loss on the validation set\n",
        "  model.eval()\n",
        "\n",
        "  # Tracking variables \n",
        "  eval_loss, eval_accuracy = 0, 0\n",
        "  nb_eval_steps, nb_eval_examples = 0, 0\n",
        "\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",
        "    \n",
        "    # Move logits and labels to CPU\n",
        "    logits = logits.detach().cpu().numpy()\n",
        "    label_ids = b_labels.to('cpu').numpy()\n",
        "\n",
        "    tmp_eval_accuracy = flat_accuracy(logits, label_ids)\n",
        "    \n",
        "    eval_accuracy += tmp_eval_accuracy\n",
        "    nb_eval_steps += 1\n",
        "\n",
        "  print(\"Validation Accuracy: {}\".format(eval_accuracy/nb_eval_steps))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\rEpoch:   0%|          | 0/1 [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:1025.)\n",
            "  next_m.mul_(beta1).add_(1 - beta1, grad)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Train loss: 0.6180545573907275\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch: 100%|██████████| 1/1 [06:14<00:00, 374.17s/it]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Validation Accuracy: 0.6925154320987654\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 513
        },
        "id": "FLpIN_eALqDo",
        "outputId": "4073e994-b8aa-41d5-abc0-aad2ff84adf4"
      },
      "source": [
        "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()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "21Bu98O1MdR3"
      },
      "source": [
        "Testing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lftTMwkvLyU4"
      },
      "source": [
        "df = pd.read_csv(\"out_of_domain_dev.tsv\", delimiter='\\t', header=None, names=['sentence_source', 'label', 'label_notes', 'sentence'])\n",
        "\n",
        "# Create sentence and label lists\n",
        "sentences = df.sentence.values\n",
        "\n",
        "# We need to add special tokens at the beginning and end of each sentence for BERT to work properly\n",
        "sentences = [\"[CLS] \" + sentence + \" [SEP]\" for sentence in sentences]\n",
        "labels = df.label.values\n",
        "\n",
        "tokenized_texts = [tokenizer.tokenize(sent) for sent in sentences]\n",
        "\n",
        "\n",
        "MAX_LEN = 128\n",
        "\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",
        "# Pad our input tokens\n",
        "input_ids = pad_sequences(input_ids, maxlen=MAX_LEN, dtype=\"long\", truncating=\"post\", padding=\"post\")\n",
        "# Create attention masks\n",
        "attention_masks = []\n",
        "\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",
        "\n",
        "prediction_inputs = torch.tensor(input_ids)\n",
        "prediction_masks = torch.tensor(attention_masks)\n",
        "prediction_labels = torch.tensor(labels)\n",
        "  \n",
        "batch_size = 32  \n",
        "\n",
        "\n",
        "prediction_data = TensorDataset(prediction_inputs, prediction_masks, prediction_labels)\n",
        "prediction_sampler = SequentialSampler(prediction_data)\n",
        "prediction_dataloader = DataLoader(prediction_data, sampler=prediction_sampler, batch_size=batch_size)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TvCJwx5GMCqH"
      },
      "source": [
        "# Prediction on test set\n",
        "\n",
        "# Put model in evaluation mode\n",
        "model.eval()\n",
        "\n",
        "# Tracking variables \n",
        "predictions , true_labels = [], []\n",
        "\n",
        "# Predict \n",
        "for batch in prediction_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 prediction\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",
        "\n",
        "  # Move logits and labels to CPU\n",
        "  logits = logits.detach().cpu().numpy()\n",
        "  label_ids = b_labels.to('cpu').numpy()\n",
        "  \n",
        "  # Store predictions and true labels\n",
        "  predictions.append(logits)\n",
        "  true_labels.append(label_ids)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OHx1aR5WMGOQ",
        "outputId": "336bb1ef-9241-434b-fd7e-addafcd06175"
      },
      "source": [
        "# Import and evaluate each test batch using Matthew's correlation coefficient\n",
        "from sklearn.metrics import matthews_corrcoef\n",
        "matthews_set = []\n",
        "\n",
        "for i in range(len(true_labels)):\n",
        "  matthews = matthews_corrcoef(true_labels[i],\n",
        "                 np.argmax(predictions[i], axis=1).flatten())\n",
        "  matthews_set.append(matthews)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:900: RuntimeWarning: invalid value encountered in double_scalars\n",
            "  mcc = cov_ytyp / np.sqrt(cov_ytyt * cov_ypyp)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lTAiIbv4MREt"
      },
      "source": [
        "# Flatten the predictions and true values for aggregate Matthew's evaluation on the whole dataset\n",
        "flat_predictions = [item for sublist in predictions for item in sublist]\n",
        "flat_predictions = np.argmax(flat_predictions, axis=1).flatten()\n",
        "flat_true_labels = [item for sublist in true_labels for item in sublist]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HfwkSfEpMRqM",
        "outputId": "33edb40f-3323-4214-d1c7-e6c0c0cb6e1d"
      },
      "source": [
        "matthews_corrcoef(flat_true_labels, flat_predictions)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:900: RuntimeWarning: invalid value encountered in double_scalars\n",
            "  mcc = cov_ytyp / np.sqrt(cov_ytyt * cov_ypyp)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.0"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    }
  ]
}