AdapterRoberta2.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# About Dataset"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The IMDB movie review dataset is a widely-used and well-known dataset in the field of natural language processing (NLP) and sentiment analysis. It consists of a large collection of movie reviews collected from the website IMDb (Internet Movie Database). IMDb is a popular online database that provides information about movies, TV shows, and related content.\n",
    "\n",
    "The dataset contains a balanced collection of movie reviews, with each review labeled as either positive or negative, indicating the sentiment expressed in the text. The reviews cover a wide range of movie genres, including action, drama, comedy, romance, and more."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install datasets\n",
    "%pip install transformers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import numpy as np\n",
    "import torch\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from transformers import RobertaTokenizer, RobertaConfig, RobertaForSequenceClassification\n",
    "from torch.optim import AdamW\n",
    "from tqdm.auto import tqdm\n",
    "from datasets import load_metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda.\n"
     ]
    }
   ],
   "source": [
    "if torch.cuda.is_available():\n",
    "    device_name = torch.device(\"cuda\")\n",
    "else:\n",
    "    device_name = torch.device('cpu')\n",
    "print(\"Using {}.\".format(device_name))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preparing Dataset"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we define a custom dataset class called MovieReviewsDataset and utilizes it to create training and testing datasets for a sentiment analysis task. Here is an explanation of the code:\n",
    "\n",
    "MovieReviewsDataset class: This class is a subclass of the torch.utils.data.Dataset class, which allows us to create custom datasets for PyTorch. It has several methods defined within it:\n",
    "\n",
    "__init__(self, reviews, labels): The constructor method initializes the dataset object with the provided reviews and labels data.\n",
    "\n",
    "__getitem__(self, index): This method allows accessing individual elements of the dataset using the index. It returns a tuple containing the review and its corresponding label.\n",
    "\n",
    "__len__(self): This method returns the length of the dataset, which is the number of reviews in the dataset.\n",
    "\n",
    "filter_reviews(self, review): This method takes a review as input, filters out certain words (defined by filter_words), and adds special tokens ([CLS] and [SEP]) to the filtered review. It then returns the modified review.\n",
    "\n",
    "convert_label(self, label): This method converts the textual label (\"positive\" or \"negative\") to a numerical representation, where \"positive\" is represented as 1 and \"negative\" as 0.\n",
    "\n",
    "Splitting the dataset: The code splits the original dataset (df) into training and testing sets using a specified train ratio (train_ratio). The training set contains 95% of the data, and the testing set contains the remaining 5%. The train_reviews, train_labels, test_reviews, and test_labels variables store the respective splits.\n",
    "\n",
    "Creating dataset instances: Two instances of the MovieReviewsDataset class are created, one for training (train_dataset) and one for testing (test_dataset). The instances are initialized with the corresponding reviews and labels.\n",
    "\n",
    "Converting labels: The labels in both the training and testing datasets are converted from textual representation (\"positive\" or \"negative\") to numerical representation (1 or 0) using the convert_label method of the dataset class.\n",
    "\n",
    "Filtering reviews: The reviews in both the training and testing datasets are filtered using the filter_reviews method of the dataset class. This method removes certain words specified by filter_words, adds special tokens, and modifies the reviews accordingly.\n",
    "\n",
    "Creating data loaders: Finally, DataLoader instances are created for both the training and testing datasets. These data loaders allow efficient loading of data in batches during training and testing. The batch_size parameter determines the number of samples per batch, and the shuffle parameter specifies whether to shuffle the data during training or keep it in the original order during testing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 50000 entries, 0 to 49999\n",
      "Data columns (total 2 columns):\n",
      " #   Column     Non-Null Count  Dtype \n",
      "---  ------     --------------  ----- \n",
      " 0   review     50000 non-null  object\n",
      " 1   sentiment  50000 non-null  object\n",
      "dtypes: object(2)\n",
      "memory usage: 781.4+ KB\n"
     ]
    },
    {
     "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>review</th>\n",
       "      <th>sentiment</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>27660</th>\n",
       "      <td>Being a Harrison Ford fan I am probably being ...</td>\n",
       "      <td>negative</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                  review sentiment\n",
       "27660  Being a Harrison Ford fan I am probably being ...  negative"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Preparing the dataset\n",
    "df = pd.read_csv(\"/home/azimi/IMDB Dataset.csv\")\n",
    "df.info()\n",
    "df.sample(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter_words_1 = ['Mr', 'Jr', 'Sr', 'Fr', 'Ms', 'Mz', 'Dr', 'St', 'Rd', '<br /><br />']\n",
    "filter_words_2 = ['Mrs', 'Rev', 'i\\.e', 'e\\.g', 'Ave', 'Cir', 'Crt']\n",
    "filter_words = \"\"\"(?<!\\.)(?<![A-Z])(?<!\"\"\" + '|'.join(filter_words_1)+\"\"\")(?<!\"\"\" + '|'.join(filter_words_2)+\"\"\")[\\.](?!([a-z]?\\.))\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MovieReviewsDataset(Dataset):\n",
    "    def __init__(self, reviews, labels):\n",
    "      self.reviews = reviews\n",
    "      self.labels = labels\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "      review = self.reviews[index]\n",
    "      label = self.labels[index]\n",
    "      return review, label\n",
    "\n",
    "    def __len__(self):\n",
    "      return len(self.reviews)\n",
    "\n",
    "    def filter_reviews(self, review):\n",
    "      review.replace(filter_words,\"\") \n",
    "      review = \"[CLS] \" + review + \" [SEP]\"\n",
    "      return review  \n",
    "\n",
    "    def convert_label(self, label):\n",
    "      if label == \"positive\":\n",
    "          return 1\n",
    "      elif label == \"negative\":\n",
    "          return 0\n",
    "      else:\n",
    "          raise ValueError(\"Invalid label encountered.\")\n",
    "\n",
    "\n",
    "# Split the dataset into training and testing sets\n",
    "train_ratio = 0.95\n",
    "train_size = int(train_ratio * len(df))\n",
    "train_reviews, train_labels = df[\"review\"][:train_size], df[\"sentiment\"][:train_size]\n",
    "test_reviews, test_labels = df[\"review\"][train_size:].reset_index(drop=True), df[\"sentiment\"][train_size:].reset_index(drop=True)\n",
    "\n",
    "# Create custom dataset instances for training and testing\n",
    "train_dataset = MovieReviewsDataset(train_reviews, train_labels)\n",
    "test_dataset = MovieReviewsDataset(test_reviews, test_labels)\n",
    "\n",
    "# Convert labels to 1 and 0\n",
    "train_dataset.labels = [train_dataset.convert_label(label) for label in train_dataset.labels]\n",
    "test_dataset.labels = [test_dataset.convert_label(label) for label in test_dataset.labels]\n",
    "\n",
    "# filter reviews\n",
    "train_dataset.reviews = [train_dataset.filter_reviews(review) for review in train_dataset.reviews]\n",
    "test_dataset.reviews = [test_dataset.filter_reviews(review) for review in test_dataset.reviews]\n",
    "\n",
    "# Create data loaders for training and testing\n",
    "batch_size = 8\n",
    "train_data_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_data_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adapter Module Designing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "roberta_config = RobertaConfig.from_pretrained(\"roberta-base\")\n",
    "roberta_config.num_labels=2\n",
    "roberta_config.bottleneck_size = 64\n",
    "roberta_config.non_linearity = \"gelu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Designing the Adapter Module\n",
    "class AdapterModule(nn.Module):\n",
    "    def __init__(self, input_size, bottleneck_size, non_linearity):\n",
    "        super(AdapterModule, self).__init__()\n",
    "\n",
    "        self.non_linearity = getattr(F, non_linearity)\n",
    "\n",
    "        self.down_project = nn.Linear(\n",
    "            input_size,\n",
    "            bottleneck_size\n",
    "        )\n",
    "\n",
    "        self.up_project = nn.Linear(\n",
    "            bottleneck_size,\n",
    "            input_size\n",
    "        )\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        output = self.down_project(inputs)\n",
    "        output = self.non_linearity(output)\n",
    "        output = self.up_project(output)\n",
    "        output = output + inputs\n",
    "        return output"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Injecting Adapter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Redefine RobertaSelfOutput layer and inject adapter module\n",
    "class RobertaSelfOutput(nn.Module):\n",
    "    def __init__(self, pretrained_self_dense, pretrained_self_ln, config):\n",
    "        super().__init__()\n",
    "        self.dense = copy.deepcopy(pretrained_self_dense)\n",
    "        self.dropout = nn.Dropout(config.hidden_dropout_prob)\n",
    "        self.adapter = AdapterModule(input_size=roberta_config.hidden_size, bottleneck_size=roberta_config.bottleneck_size, non_linearity=roberta_config.non_linearity)\n",
    "        self.LayerNorm = copy.deepcopy(pretrained_self_ln)\n",
    "\n",
    "    def forward(self, inputs, training=False):\n",
    "        hidden_states = inputs\n",
    "\n",
    "        hidden_states = self.dense(hidden_states)\n",
    "        hidden_states = self.dropout(hidden_states)\n",
    "        hidden_states = self.adapter(hidden_states)\n",
    "        hidden_states = hidden_states + inputs\n",
    "        hidden_states = self.LayerNorm(hidden_states)\n",
    "        return hidden_states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Redefine RobertaOutput layer and inject adapter module\n",
    "class RobertaOutput(nn.Module):\n",
    "    def __init__(self, pretrained_out_dense, pretrained_out_ln, config):\n",
    "        super().__init__()\n",
    "        self.dense = copy.deepcopy(pretrained_out_dense)\n",
    "        self.dropout = nn.Dropout(config.hidden_dropout_prob)\n",
    "        self.adapter = AdapterModule(input_size=config.hidden_size, bottleneck_size=config.bottleneck_size, non_linearity=config.non_linearity)\n",
    "        self.LayerNorm = copy.deepcopy(pretrained_out_ln)\n",
    "        \n",
    "\n",
    "    def forward(self, inputs, training=False):\n",
    "        hidden_states = inputs\n",
    "    \n",
    "        hidden_states = self.dense(hidden_states)\n",
    "        hidden_states_dense = self.dropout(hidden_states)\n",
    "        hidden_states = self.adapter(hidden_states_dense)\n",
    "        hidden_states = hidden_states + hidden_states_dense\n",
    "        hidden_states = self.LayerNorm(hidden_states)\n",
    "        return hidden_states"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at roberta-base were not used when initializing RobertaForSequenceClassification: ['lm_head.layer_norm.bias', 'lm_head.dense.bias', 'lm_head.layer_norm.weight', 'roberta.pooler.dense.weight', 'lm_head.dense.weight', 'roberta.pooler.dense.bias', 'lm_head.bias', 'lm_head.decoder.weight']\n",
      "- This IS expected if you are initializing RobertaForSequenceClassification 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 RobertaForSequenceClassification 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 RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight', 'classifier.dense.bias']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    }
   ],
   "source": [
    "# Loading the Pre-trained RoBERTa Model and Roberta config\n",
    "tokenizer = RobertaTokenizer.from_pretrained(\"roberta-base\")\n",
    "roberta_config = RobertaConfig.from_pretrained(\"roberta-base\")\n",
    "\n",
    "roberta_config.num_labels=2\n",
    "roberta_config.bottleneck_size = 64\n",
    "roberta_config.non_linearity = \"gelu\"\n",
    "\n",
    "Adapter_Roberta = RobertaForSequenceClassification(config=roberta_config).from_pretrained(\"roberta-base\", num_labels=2, ignore_mismatched_sizes=True).to(device_name)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adding and Freezing"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section we replace the old roberta attention output with adapter injected roberta attention output and also we do this for roberta output.\n",
    "\n",
    "Then we freeze other layers to train adapters only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding Adapters\n",
    "for i in range(roberta_config.num_hidden_layers):\n",
    "\n",
    "  Adapter_Roberta.roberta.encoder.layer[i].attention.output = RobertaSelfOutput(\n",
    "        copy.deepcopy(Adapter_Roberta.roberta.encoder.layer[i].attention.output.dense),\n",
    "        copy.deepcopy(Adapter_Roberta.roberta.encoder.layer[i].attention.output.LayerNorm), roberta_config)\n",
    "    \n",
    "  Adapter_Roberta.roberta.encoder.layer[i].output = RobertaOutput(\n",
    "        copy.deepcopy(Adapter_Roberta.roberta.encoder.layer[i].output.dense),\n",
    "        copy.deepcopy(Adapter_Roberta.roberta.encoder.layer[i].output.LayerNorm), roberta_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Adapter_Roberta.to(device_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Freeze RoBERTa\n",
    "Adapter_Roberta.roberta.embeddings.trainable = False\n",
    "for i in range(roberta_config.num_hidden_layers):\n",
    "  Adapter_Roberta.roberta.encoder.layer[i].attention.self.trainable = False\n",
    "  Adapter_Roberta.roberta.encoder.layer[i].attention.output.dense.trainable = False\n",
    "  #Adapter_Roberta.roberta.encoder.layer[i].attention.output.LayerNorm.trainable = False\n",
    "  Adapter_Roberta.roberta.encoder.layer[i].intermediate.trainable = False\n",
    "  Adapter_Roberta.roberta.encoder.layer[i].output.dense.trainable = False\n",
    "  #Adapter_Roberta.roberta.encoder.layer[i].output.LayerNorm.trainable = False"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sample Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input size: torch.Size([8, 512])\n",
      "Sample Logits:\n",
      " tensor([[-0.0435, -0.1560],\n",
      "        [ 0.0638, -0.1258],\n",
      "        [ 0.0281, -0.2893],\n",
      "        [ 0.2269, -0.1279],\n",
      "        [ 0.0334, -0.0425],\n",
      "        [ 0.0895, -0.1392],\n",
      "        [-0.1792, -0.0906],\n",
      "        [ 0.0472, -0.2003]], device='cuda:0', grad_fn=<AddmmBackward0>)\n",
      "Sample Loss:\n",
      " tensor(0.6633, device='cuda:0', grad_fn=<NllLossBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# Sample outputs\n",
    "reviews, labels = next(iter(train_data_loader))\n",
    "inputs = tokenizer.batch_encode_plus(reviews, padding=\"max_length\", truncation=True, return_tensors='pt')[\"input_ids\"]\n",
    "attention_masks = tokenizer.batch_encode_plus(reviews, padding=\"max_length\", truncation=True, return_tensors='pt')[\"attention_mask\"]\n",
    "inputs = inputs.to(device_name)\n",
    "labels = labels.to(device_name)\n",
    "attention_masks = attention_masks.to(device_name)\n",
    "print(\"input size:\", inputs.size())\n",
    "output = Adapter_Roberta(inputs, attention_masks, labels=labels)\n",
    "print(\"Sample Logits:\\n\", output.logits)\n",
    "print(\"Sample Loss:\\n\", output.loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.625"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metric = load_metric(\"accuracy\")\n",
    "predictions = torch.argmax(output.logits, axis=-1)\n",
    "accuracy = metric.compute(predictions=predictions, references=labels)\n",
    "accuracy[\"accuracy\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preparing Parameters for Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "params =[]\n",
    "for i in range(roberta_config.num_hidden_layers):\n",
    "    params.append(Adapter_Roberta.roberta.encoder.layer[i].attention.output.adapter.parameters())\n",
    "    params.append(Adapter_Roberta.roberta.encoder.layer[i].attention.output.LayerNorm.parameters())\n",
    "    params.append(Adapter_Roberta.roberta.encoder.layer[i].output.adapter.parameters())\n",
    "    params.append(Adapter_Roberta.roberta.encoder.layer[i].output.LayerNorm.parameters())\n",
    "params.append(Adapter_Roberta.classifier.parameters())   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "paramsopt = [{\"params\": params[0]}, {\"params\": params[1]}, {\"params\": params[2]}, {\"params\": params[3]}, {\"params\": params[4]}, {\"params\": params[5]},\n",
    "             {\"params\": params[6]}, {\"params\": params[7]}, {\"params\": params[8]}, {\"params\": params[9]}, {\"params\": params[10]}, {\"params\": params[11]},\n",
    "             {\"params\": params[12]}, {\"params\": params[13]}, {\"params\": params[14]}, {\"params\": params[15]}, {\"params\": params[16]}, {\"params\": params[17]},\n",
    "             {\"params\": params[18]}, {\"params\": params[19]}, {\"params\": params[20]}, {\"params\": params[21]}, {\"params\": params[22]}, {\"params\": params[23]},\n",
    "             {\"params\": params[24]}, {\"params\": params[25]}, {\"params\": params[26]}, {\"params\": params[27]}, {\"params\": params[28]}, {\"params\": params[29]},\n",
    "             {\"params\": params[30]}, {\"params\": params[31]}, {\"params\": params[32]}, {\"params\": params[33]}, {\"params\": params[34]}, {\"params\": params[35]},\n",
    "             {\"params\": params[36]}, {\"params\": params[37]}, {\"params\": params[38]}, {\"params\": params[39]}, {\"params\": params[40]}, {\"params\": params[41]},\n",
    "             {\"params\": params[42]}, {\"params\": params[43]}, {\"params\": params[44]}, {\"params\": params[45]}, {\"params\": params[46]}, {\"params\": params[47]},\n",
    "             {\"params\": params[48]}]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training and Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training Parameters\n",
    "num_epochs = 3\n",
    "batch = 8\n",
    "learning_rate = 1e-4\n",
    "optimizer = torch.optim.AdamW(params=paramsopt, lr=learning_rate)\n",
    "test_losses = []\n",
    "accuracies = []\n",
    "iterations = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1defb82e6f7e4c4f836393af7ded85ba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 1:   0%|          | 0/5938 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 0. Test loss: 0.7158970849011272. Test Accuracy: 50.039936102236425%\n",
      "Iteration: 500. Test loss: 0.5514884361634239. Test Accuracy: 73.44249201277955%\n",
      "Iteration: 1000. Test loss: 0.47499399872633596. Test Accuracy: 78.59424920127796%\n",
      "Iteration: 1500. Test loss: 0.4408940419602318. Test Accuracy: 79.55271565495208%\n",
      "Iteration: 2000. Test loss: 0.42683499907485595. Test Accuracy: 80.35143769968052%\n",
      "Iteration: 2500. Test loss: 0.409280787832059. Test Accuracy: 82.22843450479233%\n",
      "Iteration: 3000. Test loss: 0.4154029987252558. Test Accuracy: 83.34664536741214%\n",
      "Iteration: 3500. Test loss: 0.4141309895692542. Test Accuracy: 81.11022364217253%\n",
      "Iteration: 4000. Test loss: 0.3677870159516462. Test Accuracy: 85.38338658146965%\n",
      "Iteration: 4500. Test loss: 0.3582662849809034. Test Accuracy: 84.82428115015975%\n",
      "Iteration: 5000. Test loss: 0.34221889558263097. Test Accuracy: 86.14217252396166%\n",
      "Iteration: 5500. Test loss: 0.36519617273118166. Test Accuracy: 85.90255591054313%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 Train loss: 0.4336 | Test loss: 0.3652\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e8dafc5c81c6421986c3b1813350fedf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 2:   0%|          | 0/5938 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 0. Test loss: 0.33693166305653205. Test Accuracy: 85.90255591054313%\n",
      "Iteration: 500. Test loss: 0.3460197929447642. Test Accuracy: 84.06549520766774%\n",
      "Iteration: 1000. Test loss: 0.33679246339506613. Test Accuracy: 86.0223642172524%\n",
      "Iteration: 1500. Test loss: 0.34754370324337447. Test Accuracy: 85.02396166134186%\n",
      "Iteration: 2000. Test loss: 0.3410382316635249. Test Accuracy: 86.30191693290735%\n",
      "Iteration: 2500. Test loss: 0.34355182450609845. Test Accuracy: 85.70287539936102%\n",
      "Iteration: 3000. Test loss: 0.3411087420896981. Test Accuracy: 85.8626198083067%\n",
      "Iteration: 3500. Test loss: 0.3280382089245434. Test Accuracy: 85.78274760383387%\n",
      "Iteration: 4000. Test loss: 0.3336708822998757. Test Accuracy: 86.06230031948881%\n",
      "Iteration: 4500. Test loss: 0.369389041175191. Test Accuracy: 81.9888178913738%\n",
      "Iteration: 5000. Test loss: 0.36537196948981515. Test Accuracy: 85.70287539936102%\n",
      "Iteration: 5500. Test loss: 0.32462240406832754. Test Accuracy: 86.22204472843451%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 Train loss: 0.3512 | Test loss: 0.3246\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "45a207a492024129b98b4b059fc3fd7e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Epoch 3:   0%|          | 0/5938 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 0. Test loss: 0.39855040943089387. Test Accuracy: 82.98722044728434%\n",
      "Iteration: 500. Test loss: 0.3220317052623715. Test Accuracy: 86.82108626198082%\n",
      "Iteration: 1000. Test loss: 0.4973039446880642. Test Accuracy: 75.0%\n",
      "Iteration: 1500. Test loss: 0.34060857920481946. Test Accuracy: 86.22204472843451%\n",
      "Iteration: 2000. Test loss: 0.3177158946570116. Test Accuracy: 86.42172523961662%\n",
      "Iteration: 2500. Test loss: 0.3135508903370688. Test Accuracy: 87.38019169329074%\n",
      "Iteration: 3000. Test loss: 0.3213110640168952. Test Accuracy: 87.69968051118211%\n",
      "Iteration: 3500. Test loss: 0.3091278586762782. Test Accuracy: 87.46006389776358%\n",
      "Iteration: 4000. Test loss: 0.34984485904415386. Test Accuracy: 82.5479233226837%\n",
      "Iteration: 4500. Test loss: 0.3197284312412952. Test Accuracy: 87.26038338658147%\n",
      "Iteration: 5000. Test loss: 0.3453864849175508. Test Accuracy: 86.22204472843451%\n",
      "Iteration: 5500. Test loss: 0.33043892491168486. Test Accuracy: 86.30191693290735%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 Train loss: 0.3410 | Test loss: 0.3304\n"
     ]
    }
   ],
   "source": [
    "# Define training loop\n",
    "for epoch in range(num_epochs):\n",
    "    train_loss = 0.0\n",
    "    pbar1 = tqdm(train_data_loader, desc=f'Epoch {epoch+1}', unit='batch')\n",
    "\n",
    "    for i, (reviews1, labels1) in enumerate(pbar1):\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        inputs1 = tokenizer.batch_encode_plus(reviews1 , padding=\"max_length\", truncation=True, return_tensors='pt')[\"input_ids\"]\n",
    "        attention_masks1 = tokenizer.batch_encode_plus(reviews1, padding=\"max_length\", truncation=True, return_tensors='pt')[\"attention_mask\"]\n",
    "        inputs1 = inputs1.to(device_name)\n",
    "        labels1 = labels1.to(device_name)\n",
    "        attention_masks1 = attention_masks1.to(device_name)\n",
    "        output1 = Adapter_Roberta(inputs1, attention_masks1, labels=labels1)\n",
    "        loss1 = output1.loss\n",
    "\n",
    "        # Backpropagate and update parameters\n",
    "        loss1.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "\n",
    "        train_loss += loss1.item()\n",
    "        pbar1.set_postfix({'Loss': loss1.item()})\n",
    "\n",
    "        if i%500==0:\n",
    "\n",
    "            total_accuracy = 0\n",
    "            test_loss = 0.0\n",
    "            \n",
    "            for reviews2, labels2 in test_data_loader:\n",
    "\n",
    "                inputs2 = tokenizer.batch_encode_plus(reviews2, padding=\"max_length\", truncation=True, return_tensors='pt')[\"input_ids\"]\n",
    "                attention_masks2 = tokenizer.batch_encode_plus(reviews2, padding=\"max_length\", truncation=True, return_tensors='pt')[\"attention_mask\"]\n",
    "                inputs2 = inputs2.to(device_name)\n",
    "                labels2 = labels2.to(device_name)\n",
    "                attention_masks2 = attention_masks2.to(device_name)\n",
    "       \n",
    "                with torch.no_grad():\n",
    "                    output2 = Adapter_Roberta(inputs2, attention_masks2, labels=labels2)\n",
    "                    loss2 = output2.loss\n",
    "                    test_loss += loss2.item()\n",
    "                    predictions = torch.argmax(output2.logits, axis=-1)\n",
    "                    batch_accuracy = metric.compute(predictions=predictions, references=labels2)\n",
    "                    total_accuracy += batch_accuracy[\"accuracy\"]\n",
    "\n",
    "            print('Iteration: {}. Test loss: {}. Test Accuracy: {}%'.format(i, test_loss/len(test_data_loader), 100*total_accuracy/len(test_data_loader)))\n",
    "                    \n",
    "            avg_test_loss = test_loss / len(test_data_loader)\n",
    "            avg_accuracy = 100 * total_accuracy / len(test_data_loader)\n",
    "\n",
    "            iterations.append(i)\n",
    "            test_losses.append(avg_test_loss)\n",
    "            accuracies.append(avg_accuracy)\n",
    "\n",
    "    # Plot test loss\n",
    "    plt.figure(figsize=(10, 5))\n",
    "    plt.plot(iterations, test_losses, label='Test Loss')\n",
    "    plt.xlabel('Iterations')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.title('Test Loss over Iterations')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "    # Plot accuracy\n",
    "    plt.figure(figsize=(10, 5))\n",
    "    plt.plot(iterations, accuracies, label='Accuracy')\n",
    "    plt.xlabel('Iterations')\n",
    "    plt.ylabel('Accuracy (%)')\n",
    "    plt.title('Accuracy over Iterations')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "    test_losses = []\n",
    "    accuracies = []\n",
    "    iterations = []\n",
    "            \n",
    "    # Print epoch loss\n",
    "    print(f'Epoch {epoch+1} Train loss: {train_loss/len(train_data_loader):.4f} | Test loss: {test_loss/len(test_data_loader):.4f}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "herman_7",
   "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.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}