code/clickbait_classification_headline_thresholding_pr_curve.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e3d1e416",
   "metadata": {},
   "source": [
    "#### Clickbait Detection on Headline's text using Deberta and Electra pre-trained Models and their Tokenizers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "991c9e20",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import f1_score, balanced_accuracy_score, mean_squared_error, confusion_matrix, recall_score, precision_score, accuracy_score, log_loss\n",
    "from transformers import AutoTokenizer, AutoModel, AutoModelForSequenceClassification, AutoConfig,Trainer, TrainingArguments, BertweetTokenizer, BertConfig\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torch\n",
    "\n",
    "# import nltk\n",
    "# nltk.download('punkt')\n",
    "# from nltk.tokenize import sent_tokenize\n",
    "# from nltk.corpus import stopwords\n",
    "# import re\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "import json\n",
    "import os\n",
    "import re\n",
    "import gc\n",
    "\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9c62dc83",
   "metadata": {},
   "outputs": [],
   "source": [
    "path = './Webis17HeadlineClsData/'  # Webis17HeadlineClsData or Webis17HeadlineArticleClsData\n",
    "root = \"./\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2e66f3c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_csv(path+'train.csv')\n",
    "df_validation = pd.read_csv(path+'validation.csv')\n",
    "df_test = pd.read_csv(path+'test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "abd7717a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>postText</th>\n",
       "      <th>truthClass</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>UK’s response to modern slavery leaving victim...</td>\n",
       "      <td>no-clickbait</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>this is good</td>\n",
       "      <td>clickbait</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>The \"forgotten\" Trump roast: Relive his brutal...</td>\n",
       "      <td>no-clickbait</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Meet the happiest #dog in the world!</td>\n",
       "      <td>clickbait</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Tokyo's subway is shut down amid fears over an...</td>\n",
       "      <td>no-clickbait</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                            postText    truthClass\n",
       "0  UK’s response to modern slavery leaving victim...  no-clickbait\n",
       "1                                       this is good     clickbait\n",
       "2  The \"forgotten\" Trump roast: Relive his brutal...  no-clickbait\n",
       "3               Meet the happiest #dog in the world!     clickbait\n",
       "4  Tokyo's subway is shut down amid fears over an...  no-clickbait"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cb618e71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(19538, 2459, 18979)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df_train), len(df_validation), len(df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "08f2a251",
   "metadata": {},
   "outputs": [],
   "source": [
    "# doing the following data processing resulted into poor model performance \n",
    "\n",
    "# nltk.download('stopwords')\n",
    "\n",
    "# stop_words = set(stopwords.words('english'))\n",
    "# #https://catriscode.com/2021/05/01/tweets-cleaning-with-python/\n",
    "# def clean_data(tweet):\n",
    "#     if type(tweet) == np.float:\n",
    "#         return \"\"\n",
    "#     temp = tweet.lower()\n",
    "#     temp = re.sub(\"'\", \"\", temp) # to avoid removing contractions in english\n",
    "#     temp = re.sub(\"@[A-Za-z0-9_]+\",\"\", temp)\n",
    "#     temp = re.sub(\"#[A-Za-z0-9_]+\",\"\", temp)\n",
    "#     temp = re.sub(r'http\\S+', '', temp)\n",
    "#     temp = re.sub('[()!?]', ' ', temp)\n",
    "#     temp = re.sub('\\[.*?\\]',' ', temp)\n",
    "#     temp = re.sub(\"[^a-z0-9]\",\" \", temp)\n",
    "#     temp = temp.split()\n",
    "#     temp = [w for w in temp if not w in stop_words]\n",
    "#     temp = \" \".join(word for word in temp)\n",
    "#     return temp\n",
    "\n",
    "# #https://stackoverflow.com/questions/33404752/removing-emojis-from-a-string-in-python\n",
    "# def deEmojify(text):\n",
    "# #     print(text)\n",
    "#     regrex_pattern = re.compile(pattern = \"[\"\n",
    "#         u\"\\U0001F600-\\U0001F64F\"  # emoticons\n",
    "#         u\"\\U0001F300-\\U0001F5FF\"  # symbols & pictographs\n",
    "#         u\"\\U0001F680-\\U0001F6FF\"  # transport & map symbols\n",
    "#         u\"\\U0001F1E0-\\U0001F1FF\"  # flags (iOS)\n",
    "#                            \"]+\", flags = re.UNICODE)\n",
    "#     return regrex_pattern.sub(r'',text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "35312e2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_train['postText'] = df_train['postText'].astype(str)\n",
    "# df_validation['postText'] = df_validation['postText'].astype(str)\n",
    "# df_test['postText'] = df_test['postText'].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "69ba2ffd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_train['postText'] = df_train['postText'].apply(deEmojify)\n",
    "# df_train['postText'] = df_train['postText'].apply(clean_data)\n",
    "\n",
    "# df_validation['postText'] = df_validation['postText'].apply(deEmojify)\n",
    "# df_validation['postText'] = df_validation['postText'].apply(clean_data)\n",
    "\n",
    "# df_test['postText'] = df_test['postText'].apply(deEmojify)\n",
    "# df_test['postText'] = df_test['postText'].apply(clean_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0831db53",
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_sentence(sentence, replace_url=False, replace_usr=False):\n",
    "    if not replace_url and not replace_usr:\n",
    "        #print(replace_url,replace_usr)\n",
    "        return sentence\n",
    "    new_sentence = []\n",
    "    for word in sentence.split(\" \"):\n",
    "        # print(word)\n",
    "        # @mentions, @users\n",
    "        if (word.startswith(\"@\") or word.startswith('\"@')) and replace_usr:\n",
    "            new_sentence.append('@user')\n",
    "        # URL: https, http\n",
    "        elif (word.startswith(\"http:\") or word.startswith(\"https:\")) and replace_url:\n",
    "            new_sentence.append('internet_site')\n",
    "        else:\n",
    "            new_sentence.append(word)\n",
    "    # remove extra \" \"\n",
    "    new_sentence = re.sub(' +', ' ', \" \".join(new_sentence))\n",
    "    return new_sentence.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "565ae6d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total amount of train 19538\n",
      "Total amount of validation 2459\n",
      "Total amount of test 18979\n",
      "Labels: ['clickbait', 'no-clickbait']\n"
     ]
    }
   ],
   "source": [
    "def get_dataset(df_train,df_dev,df_test,root,replace_url=False,replace_usr=False):\n",
    "    trainDataset = df_train[['postText', 'truthClass']].copy()\n",
    "    trainDataset['x'] = trainDataset.postText.astype(str).apply(lambda a: normalize_sentence(a,replace_url,replace_usr))\n",
    "    trainDataset['y'] = trainDataset.truthClass.str.strip()\n",
    "    print('Total amount of train',len(trainDataset.index))\n",
    "\n",
    "    validationDataset = df_dev[['postText', 'truthClass']].copy()\n",
    "    validationDataset['x'] = validationDataset.postText.astype(str).apply(lambda a: normalize_sentence(a,replace_url,replace_usr))\n",
    "    validationDataset['y'] = validationDataset.truthClass.str.strip()\n",
    "    print('Total amount of validation',len(validationDataset.index))\n",
    "\n",
    "    testDataset = df_test[['postText', 'truthClass']].copy()\n",
    "    testDataset['x'] = testDataset.postText.astype(str).apply(lambda a: normalize_sentence(a,replace_url,replace_usr))\n",
    "    testDataset['y'] = testDataset.truthClass.str.strip()\n",
    "    print('Total amount of test',len(testDataset.index))\n",
    "\n",
    "    return trainDataset, validationDataset, testDataset\n",
    "\n",
    "trainDataset, validationDataset, testDataset = get_dataset(df_train, df_validation, df_test, \".\", True, True)\n",
    "\n",
    "labels = list(set(trainDataset.truthClass.tolist()))\n",
    "labels.sort(key=lambda item: (-len(item), item), reverse=True)\n",
    "nLabels = len(labels)\n",
    "print('Labels:', labels)\n",
    "\n",
    "trainDataset = trainDataset.drop(['postText', 'truthClass'], axis=1)\n",
    "validationDataset = validationDataset.drop(['postText', 'truthClass'], axis=1)\n",
    "testDataset = testDataset.drop(['postText', 'truthClass'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f1886c83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                   x             y\n",
      "0  Johnny Manziel on Browns' No. 1 pick Myles Gar...  no-clickbait\n",
      "1  Fabio: California Is a 'Mess' Because of Liber...  no-clickbait\n",
      "2            \"He's been huge for us this year, man.\"     clickbait\n",
      "3  New Bears quarterback Mitchell Trubisky was gr...  no-clickbait\n",
      "4  It's not enough to let employees work flexible...  no-clickbait\n"
     ]
    }
   ],
   "source": [
    "print(testDataset.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c845012a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trainer(Trainer):\n",
    "    def evaluate(self, eval_dataset= None, ignore_keys=None):\n",
    "        outputMetrics = super().evaluate(eval_dataset, ignore_keys)\n",
    "#         print('outputMetrics: ', outputMetrics)\n",
    "        return outputMetrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f2ec7f43",
   "metadata": {},
   "outputs": [],
   "source": [
    "class gn_dataset(Dataset):\n",
    "    def __init__(self,data,labels,tokenizer):\n",
    "        self.data = data\n",
    "        self.labels = labels\n",
    "        self.tokenizer = tokenizer\n",
    "\n",
    "    def processText(self, text):\n",
    "        tokenized = self.tokenizer(text, truncation=True)\n",
    "\n",
    "        return tokenized\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data.index)\n",
    "\n",
    "    def __getitem__(self,i):\n",
    "        row = self.data.iloc[i]\n",
    "        x = self.processText(row['x']).data\n",
    "\n",
    "        try:\n",
    "            y = self.labels.index(row['y'])\n",
    "        except:\n",
    "            y = len(self.labels) - 1 \n",
    "\n",
    "        x['labels'] = y\n",
    "        return x\n",
    "\n",
    "    def randomItem(self):\n",
    "        return self.__getitem__(random.randint(0,self.__len__()))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "beebf692",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_computeMetrics = []\n",
    "test_metrics = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "36690d8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(self,modelPath = '',nLabels = 3, labels=None):\n",
    "        self.device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\") # put cpu for more extensive error desc...\n",
    "        print('device: ', self.device)\n",
    "        self.maxLength = 128  # max len we have is 124 for postext\n",
    "        self.nLabels = nLabels\n",
    "        self.loadModel(modelPath) \n",
    "        print('** Model: ', self.loadModel)\n",
    "\n",
    "        self.labels = labels\n",
    "\n",
    "    def model_init(self, dropout = 0.1):\n",
    "        config = AutoConfig.from_pretrained(\n",
    "                    self.MODEL_PATH,\n",
    "                    num_labels=self.nLabels,\n",
    "                    return_dict = True,\n",
    "                    hidden_dropout_prob = dropout\n",
    "                )\n",
    "        print('configconfig', config)\n",
    "        return AutoModelForSequenceClassification.from_pretrained(self.MODEL_PATH,config=config).to(self.device)\n",
    "\n",
    "    def softmax_stable(self,x):\n",
    "        z = x - np.max(x, axis=1)[:, np.newaxis]\n",
    "        softmax = np.exp(z) / np.sum(np.exp(z), axis=1)[:, np.newaxis]\n",
    "        return softmax\n",
    "\n",
    "    def computeMetrics(self,evalPrediction):\n",
    "        yTrue = evalPrediction.label_ids\n",
    "        pp = self.softmax_stable(evalPrediction.predictions)\n",
    "        # take the 1st col\n",
    "        first_col = pp[:, 1:]\n",
    "        # apply new thresh on this col\n",
    "        yPred = (first_col > 0.25).astype(int).flatten()\n",
    "    \n",
    "#     this is default 0.5 thresh\n",
    "#         yPredd = evalPrediction.predictions.argmax(1)\n",
    "\n",
    "        metrics = {}\n",
    "        \n",
    "        metrics['val accuracy'] = accuracy_score(yTrue, yPred)\n",
    "        metrics['f1'] = f1_score(yTrue, yPred)\n",
    "\n",
    "        recall = recall_score(yTrue, yPred) \n",
    "        precision = precision_score(yTrue, yPred)\n",
    "        metrics['precision'] = precision\n",
    "        metrics['recall'] = recall\n",
    "        print(yTrue)\n",
    "        print('@@', yPred, first_col)\n",
    "        precision, recall, thresholds = precision_recall_curve(yTrue, first_col)\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.plot(recall, precision, color='purple')\n",
    "\n",
    "        #add axis labels to plot\n",
    "        ax.set_title('Precision-Recall Curve')\n",
    "        ax.set_ylabel('Precision')\n",
    "        ax.set_xlabel('Recall')\n",
    "\n",
    "        #display plot\n",
    "        plt.show()\n",
    "                \n",
    "        all_computeMetrics.append(metrics)\n",
    "        \n",
    "        return metrics\n",
    "\n",
    "    def loadModel(self,modelPath):\n",
    "        self.MODEL_PATH = modelPath\n",
    "        self.MODEL = self.model_init()\n",
    "        self.TOKENIZER = AutoTokenizer.from_pretrained(self.MODEL_PATH,model_max_length = self.maxLength, use_fast=True)\n",
    "        \n",
    "    def saveModel(self,saveDir):\n",
    "        print('saving model at: ', saveDir)\n",
    "        self.MODEL.save_pretrained(saveDir)\n",
    "        self.TOKENIZER.save_pretrained(saveDir)\n",
    "\n",
    "    def train_loop(self,saveDir,checkpointDir,trainingData,validationData,testData,labels):\n",
    "        trainDataset = gn_dataset(trainingData,labels,self.TOKENIZER)\n",
    "        validationDataset = gn_dataset(validationData,labels,self.TOKENIZER)\n",
    "        testDataset = gn_dataset(testData,labels,self.TOKENIZER)\n",
    "        checkpoints = {}\n",
    "\n",
    "        # TRAIN FUNCTION\n",
    "        runName = experiment + str(len(checkpoints))\n",
    "        print('checkpointDir: ', checkpointDir)\n",
    "\n",
    "        args = TrainingArguments(\n",
    "                                output_dir=checkpointDir,\n",
    "                                save_strategy='no',\n",
    "                                do_train=True, # DEFAULT: False\n",
    "                                do_eval=True, # DEFAULT: False\n",
    "                                do_predict=True, # DEFAULT: False\n",
    "#                                 save_steps = 1200, # DEFAULT: 500\n",
    "#                                 eval_steps = 1, #200, # DEFAULT: 500\n",
    "                                evaluation_strategy = 'epoch', # DEFAULT: \"no\"\n",
    "                                logging_first_step = True, # DEFAULT: False\n",
    "                                dataloader_num_workers = 6, # 6, DEFAULT: 0\n",
    "                                learning_rate = 2e-5,\n",
    "                                num_train_epochs = 3,\n",
    "                                per_device_train_batch_size = 8,\n",
    "                                per_device_eval_batch_size = 8, #16,\n",
    "                                weight_decay = 0.05 ,\n",
    "                                warmup_steps = 0, # DEFAULT: 0\n",
    "                                logging_dir=checkpointDir+\"/logs\",\n",
    "                                metric_for_best_model = 'f1_binary', # DEFAULT: None\n",
    "                                greater_is_better = True, # DEFAULT: None\n",
    "                                \n",
    "        )\n",
    "        model = self.model_init(dropout=0.3)\n",
    "\n",
    "        trainer = Trainer(\n",
    "                    model,\n",
    "                    args = args,\n",
    "                    train_dataset = trainDataset,#train\n",
    "                    tokenizer = self.TOKENIZER,\n",
    "                    eval_dataset = validationDataset,#dev\n",
    "                    compute_metrics = self.computeMetrics,\n",
    "                )\n",
    "\n",
    "        trainer.train()\n",
    "\n",
    "        cp = checkpointDir + '/CheckPointModel_'+ runName\n",
    "\n",
    "        checkpoints[cp] = trainer.evaluate(testDataset) # on test set\n",
    "        print('on test set:', checkpoints[cp]) \n",
    "        test_metrics.append(checkpoints[cp])\n",
    "#         trainer.predict(testDataset)\n",
    "#         trainer.save_model(cp)\n",
    "        \n",
    "    def predict(self,text):\n",
    "        dataset = gn_dataset(None,None,self.TOKENIZER)\n",
    "        batchEncoding = dataset.processText(text).to(self.device)\n",
    "\n",
    "        self.MODEL.eval()\n",
    "        out = self.MODEL(batchEncoding.input_ids,attention_mask = batchEncoding.attention_mask,token_type_ids = batchEncoding.token_type_ids,return_dict = True)\n",
    "\n",
    "        return out.logits.argmax().item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8d586eaf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(name,root,nLabels,labels,experiment,trainDataset,validationDataset,testDataset): \n",
    "    print('name experiment: ', name, experiment)\n",
    "    model = Model(name,nLabels,labels)\n",
    "    print('model model: ', model)\n",
    "    analysis = model.train_loop(root+\"SavedModel/\"+experiment,root+name.split('/')[-1]+\"TrainingCheckpoints\",trainDataset,validationDataset,testDataset,labels)\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "735de030",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name experiment:  google/electra-base-discriminator electra_clickbait\n",
      "device:  cuda\n",
      "configconfig ElectraConfig {\n",
      "  \"_name_or_path\": \"google/electra-base-discriminator\",\n",
      "  \"architectures\": [\n",
      "    \"ElectraForPreTraining\"\n",
      "  ],\n",
      "  \"attention_probs_dropout_prob\": 0.1,\n",
      "  \"classifier_dropout\": null,\n",
      "  \"embedding_size\": 768,\n",
      "  \"hidden_act\": \"gelu\",\n",
      "  \"hidden_dropout_prob\": 0.1,\n",
      "  \"hidden_size\": 768,\n",
      "  \"initializer_range\": 0.02,\n",
      "  \"intermediate_size\": 3072,\n",
      "  \"layer_norm_eps\": 1e-12,\n",
      "  \"max_position_embeddings\": 512,\n",
      "  \"model_type\": \"electra\",\n",
      "  \"num_attention_heads\": 12,\n",
      "  \"num_hidden_layers\": 12,\n",
      "  \"pad_token_id\": 0,\n",
      "  \"position_embedding_type\": \"absolute\",\n",
      "  \"summary_activation\": \"gelu\",\n",
      "  \"summary_last_dropout\": 0.1,\n",
      "  \"summary_type\": \"first\",\n",
      "  \"summary_use_proj\": true,\n",
      "  \"transformers_version\": \"4.24.0\",\n",
      "  \"type_vocab_size\": 2,\n",
      "  \"use_cache\": true,\n",
      "  \"vocab_size\": 30522\n",
      "}\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at google/electra-base-discriminator were not used when initializing ElectraForSequenceClassification: ['discriminator_predictions.dense.bias', 'discriminator_predictions.dense.weight', 'discriminator_predictions.dense_prediction.bias', 'discriminator_predictions.dense_prediction.weight']\n",
      "- This IS expected if you are initializing ElectraForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing ElectraForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "Some weights of ElectraForSequenceClassification were not initialized from the model checkpoint at google/electra-base-discriminator and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "** Model:  <bound method Model.loadModel of <__main__.Model object at 0x7fabc28506d8>>\n",
      "model model:  <__main__.Model object at 0x7fabc28506d8>\n",
      "checkpointDir:  ./electra-base-discriminatorTrainingCheckpoints\n",
      "configconfig ElectraConfig {\n",
      "  \"_name_or_path\": \"google/electra-base-discriminator\",\n",
      "  \"architectures\": [\n",
      "    \"ElectraForPreTraining\"\n",
      "  ],\n",
      "  \"attention_probs_dropout_prob\": 0.1,\n",
      "  \"classifier_dropout\": null,\n",
      "  \"embedding_size\": 768,\n",
      "  \"hidden_act\": \"gelu\",\n",
      "  \"hidden_dropout_prob\": 0.3,\n",
      "  \"hidden_size\": 768,\n",
      "  \"initializer_range\": 0.02,\n",
      "  \"intermediate_size\": 3072,\n",
      "  \"layer_norm_eps\": 1e-12,\n",
      "  \"max_position_embeddings\": 512,\n",
      "  \"model_type\": \"electra\",\n",
      "  \"num_attention_heads\": 12,\n",
      "  \"num_hidden_layers\": 12,\n",
      "  \"pad_token_id\": 0,\n",
      "  \"position_embedding_type\": \"absolute\",\n",
      "  \"summary_activation\": \"gelu\",\n",
      "  \"summary_last_dropout\": 0.1,\n",
      "  \"summary_type\": \"first\",\n",
      "  \"summary_use_proj\": true,\n",
      "  \"transformers_version\": \"4.24.0\",\n",
      "  \"type_vocab_size\": 2,\n",
      "  \"use_cache\": true,\n",
      "  \"vocab_size\": 30522\n",
      "}\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at google/electra-base-discriminator were not used when initializing ElectraForSequenceClassification: ['discriminator_predictions.dense.bias', 'discriminator_predictions.dense.weight', 'discriminator_predictions.dense_prediction.bias', 'discriminator_predictions.dense_prediction.weight']\n",
      "- This IS expected if you are initializing ElectraForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing ElectraForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "Some weights of ElectraForSequenceClassification were not initialized from the model checkpoint at google/electra-base-discriminator and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "/home/charmichokshi4444/venv/lib/python3.7/site-packages/transformers/optimization.py:310: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n",
      "  FutureWarning,\n",
      "***** Running training *****\n",
      "  Num examples = 19538\n",
      "  Num Epochs = 3\n",
      "  Instantaneous batch size per device = 8\n",
      "  Total train batch size (w. parallel, distributed & accumulation) = 8\n",
      "  Gradient Accumulation steps = 1\n",
      "  Total optimization steps = 7329\n",
      "  Number of trainable parameters = 109483778\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='7329' max='7329' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [7329/7329 13:12, Epoch 3/3]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Epoch</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "      <th>Val accuracy</th>\n",
       "      <th>F1</th>\n",
       "      <th>Precision</th>\n",
       "      <th>Recall</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.404700</td>\n",
       "      <td>0.557707</td>\n",
       "      <td>0.771858</td>\n",
       "      <td>0.853333</td>\n",
       "      <td>0.766917</td>\n",
       "      <td>0.961697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.364200</td>\n",
       "      <td>0.675795</td>\n",
       "      <td>0.775925</td>\n",
       "      <td>0.855114</td>\n",
       "      <td>0.772080</td>\n",
       "      <td>0.958161</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.345500</td>\n",
       "      <td>0.816133</td>\n",
       "      <td>0.784872</td>\n",
       "      <td>0.859942</td>\n",
       "      <td>0.780769</td>\n",
       "      <td>0.956983</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "***** Running Evaluation *****\n",
      "  Num examples = 2459\n",
      "  Batch size = 8\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 0 ... 1 1 1]\n",
      "@@ [1 1 1 ... 1 1 1] [[0.94348454]\n",
      " [0.97733784]\n",
      " [0.9762407 ]\n",
      " ...\n",
      " [0.9912861 ]\n",
      " [0.95621127]\n",
      " [0.9882509 ]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "***** Running Evaluation *****\n",
      "  Num examples = 2459\n",
      "  Batch size = 8\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 0 ... 1 1 1]\n",
      "@@ [1 1 1 ... 1 1 1] [[0.9849651 ]\n",
      " [0.98929745]\n",
      " [0.9894531 ]\n",
      " ...\n",
      " [0.99501437]\n",
      " [0.9913975 ]\n",
      " [0.99359316]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "***** Running Evaluation *****\n",
      "  Num examples = 2459\n",
      "  Batch size = 8\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 0 ... 1 1 1]\n",
      "@@ [1 1 1 ... 1 1 1] [[0.99387807]\n",
      " [0.9958633 ]\n",
      " [0.99518687]\n",
      " ...\n",
      " [0.9975501 ]\n",
      " [0.99651885]\n",
      " [0.9975924 ]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Training completed. Do not forget to share your model on huggingface.co/models =)\n",
      "\n",
      "\n",
      "***** Running Evaluation *****\n",
      "  Num examples = 18979\n",
      "  Batch size = 8\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "You're using a ElectraTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='2373' max='2373' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [2373/2373 00:49]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 0 ... 1 1 0]\n",
      "@@ [1 1 0 ... 1 1 0] [[0.99784875]\n",
      " [0.99777967]\n",
      " [0.03095887]\n",
      " ...\n",
      " [0.99808013]\n",
      " [0.99754214]\n",
      " [0.02201697]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "on test set: {'eval_loss': 0.4050244092941284, 'eval_val accuracy': 0.8704884345855946, 'eval_f1': 0.9165308340124966, 'eval_precision': 0.9006273358248799, 'eval_recall': 0.9330060840707964, 'eval_runtime': 50.286, 'eval_samples_per_second': 377.421, 'eval_steps_per_second': 47.19, 'epoch': 3.0}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gc.collect()\n",
    "with torch.no_grad():\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "launch = {\n",
    "'distilbert': 'distilbert-base-uncased',\n",
    "'deberta': 'microsoft/deberta-base',\n",
    "'electra': 'google/electra-base-discriminator',\n",
    "}\n",
    " \n",
    "experiment = list(launch.keys())[2]+\"_clickbait\"\n",
    "model = launch['electra']\n",
    "\n",
    "train(model,root,nLabels,labels,experiment,trainDataset,validationDataset,testDataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0ba5ff17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'val accuracy': 0.771858479056527, 'f1': 0.8533333333333333, 'precision': 0.7669172932330827, 'recall': 0.9616971125515615}, {'val accuracy': 0.7759251728344856, 'f1': 0.8551143833815409, 'precision': 0.7720797720797721, 'recall': 0.9581614614024749}, {'val accuracy': 0.7848718991459943, 'f1': 0.859941752713794, 'precision': 0.7807692307692308, 'recall': 0.9569829110194461}, {'val accuracy': 0.8704884345855946, 'f1': 0.9165308340124966, 'precision': 0.9006273358248799, 'recall': 0.9330060840707964}]\n"
     ]
    }
   ],
   "source": [
    "print(all_computeMetrics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8571d3d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8704884345855946 \n",
      " 0.9165308340124966\n"
     ]
    }
   ],
   "source": [
    "print(test_metrics[0]['eval_val accuracy'], '\\n', test_metrics[0]['eval_f1'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8d8a08d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'eval_loss': 0.4050244092941284,\n",
       "  'eval_val accuracy': 0.8704884345855946,\n",
       "  'eval_f1': 0.9165308340124966,\n",
       "  'eval_precision': 0.9006273358248799,\n",
       "  'eval_recall': 0.9330060840707964,\n",
       "  'eval_runtime': 50.286,\n",
       "  'eval_samples_per_second': 377.421,\n",
       "  'eval_steps_per_second': 47.19,\n",
       "  'epoch': 3.0}]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_metrics"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "language": "python",
   "name": "venv"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}