added model of fine tuning

distilbert_finetuing.ipynb

@@ -0,0 +1,1184 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#!pip install \"modin[all]\" # Install Ray and Dask\n",
+    "# !pip install pytorch \n",
+    "# !pip install intel-extension-for-pytorch\n",
+    "# !pip install transformers\n",
+    "# !pip install datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "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>Questions</th>\n",
+       "      <th>Category</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>About what proportion of the population of the...</td>\n",
+       "      <td>BT1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Correctly label the brain lobes indicated on t...</td>\n",
+       "      <td>BT1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Define compound interest.</td>\n",
+       "      <td>BT1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Define four types of traceability</td>\n",
+       "      <td>BT1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Define mercantilism.</td>\n",
+       "      <td>BT1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8762</th>\n",
+       "      <td>Distinguish between different types of soil st...</td>\n",
+       "      <td>BT4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8763</th>\n",
+       "      <td>Invent a blockchain-based solution for transpa...</td>\n",
+       "      <td>BT6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8764</th>\n",
+       "      <td>Compare the advantages and disadvantages of us...</td>\n",
+       "      <td>BT4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8765</th>\n",
+       "      <td>Describe the purpose of the \"volatile\" keyword...</td>\n",
+       "      <td>BT1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8766</th>\n",
+       "      <td>Explain the concept of noise in communication ...</td>\n",
+       "      <td>BT2</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>8767 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                              Questions Category\n",
+       "0     About what proportion of the population of the...      BT1\n",
+       "1     Correctly label the brain lobes indicated on t...      BT1\n",
+       "2                             Define compound interest.      BT1\n",
+       "3                     Define four types of traceability      BT1\n",
+       "4                                  Define mercantilism.      BT1\n",
+       "...                                                 ...      ...\n",
+       "8762  Distinguish between different types of soil st...      BT4\n",
+       "8763  Invent a blockchain-based solution for transpa...      BT6\n",
+       "8764  Compare the advantages and disadvantages of us...      BT4\n",
+       "8765  Describe the purpose of the \"volatile\" keyword...      BT1\n",
+       "8766  Explain the concept of noise in communication ...      BT2\n",
+       "\n",
+       "[8767 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import modin.pandas as pd\n",
+    "df = pd.read_csv('blooms_taxonomy_dataset.csv')\n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mapping = {\"BT1\": 0, \"BT2\": 1, \"BT3\": 2, \"BT4\": 3, \"BT5\": 4, \"BT6\": 5}\n",
+    "df[\"Category\"] = df[\"Category\"].map(mapping)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "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>Questions</th>\n",
+       "      <th>Category</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>About what proportion of the population of the...</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Correctly label the brain lobes indicated on t...</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Define compound interest.</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Define four types of traceability</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Define mercantilism.</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8762</th>\n",
+       "      <td>Distinguish between different types of soil st...</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8763</th>\n",
+       "      <td>Invent a blockchain-based solution for transpa...</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8764</th>\n",
+       "      <td>Compare the advantages and disadvantages of us...</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8765</th>\n",
+       "      <td>Describe the purpose of the \"volatile\" keyword...</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8766</th>\n",
+       "      <td>Explain the concept of noise in communication ...</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>8767 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                              Questions  Category\n",
+       "0     About what proportion of the population of the...         0\n",
+       "1     Correctly label the brain lobes indicated on t...         0\n",
+       "2                             Define compound interest.         0\n",
+       "3                     Define four types of traceability         0\n",
+       "4                                  Define mercantilism.         0\n",
+       "...                                                 ...       ...\n",
+       "8762  Distinguish between different types of soil st...         3\n",
+       "8763  Invent a blockchain-based solution for transpa...         5\n",
+       "8764  Compare the advantages and disadvantages of us...         3\n",
+       "8765  Describe the purpose of the \"volatile\" keyword...         0\n",
+       "8766  Explain the concept of noise in communication ...         1\n",
+       "\n",
+       "[8767 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/anaconda3/envs/pytorch_env/lib/python3.11/site-packages/transformers/tokenization_utils_base.py:1601: FutureWarning: `clean_up_tokenization_spaces` was not set. It will be set to `True` by default. This behavior will be depracted in transformers v4.45, and will be then set to `False` by default. For more details check this issue: https://github.com/huggingface/transformers/issues/31884\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'input_ids': tensor([[  101,  2055,  2054,  ...,     0,     0,     0],\n",
+       "        [  101, 11178,  3830,  ...,     0,     0,     0],\n",
+       "        [  101,  9375,  7328,  ...,     0,     0,     0],\n",
+       "        ...,\n",
+       "        [  101, 12826,  1996,  ...,     0,     0,     0],\n",
+       "        [  101,  6235,  1996,  ...,     0,     0,     0],\n",
+       "        [  101,  4863,  1996,  ...,     0,     0,     0]]), 'attention_mask': tensor([[1, 1, 1,  ..., 0, 0, 0],\n",
+       "        [1, 1, 1,  ..., 0, 0, 0],\n",
+       "        [1, 1, 1,  ..., 0, 0, 0],\n",
+       "        ...,\n",
+       "        [1, 1, 1,  ..., 0, 0, 0],\n",
+       "        [1, 1, 1,  ..., 0, 0, 0],\n",
+       "        [1, 1, 1,  ..., 0, 0, 0]])}"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from transformers import DistilBertTokenizer\n",
+    "import torch\n",
+    "\n",
+    "# Load the DistilBERT tokenizer\n",
+    "tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')\n",
+    "\n",
+    "# Tokenize the 'Questions' column\n",
+    "inputs = tokenizer(list(df['Questions']), padding=True, truncation=True, return_tensors='pt', max_length=2048)\n",
+    "inputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([8767, 123])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inputs['input_ids'].size()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([0, 0, 0,  ..., 3, 0, 1])"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "labels = torch.tensor(df['Category'].values)\n",
+    "labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of DistilBertForSequenceClassification were not initialized from the model checkpoint at distilbert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight', 'pre_classifier.bias', 'pre_classifier.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import DistilBertForSequenceClassification\n",
+    "\n",
+    "# Load the model with a classification head\n",
+    "model = DistilBertForSequenceClassification.from_pretrained('distilbert-base-uncased', num_labels=6)  # 6 classes: 0 to 5\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "# Split the data into training and validation sets\n",
+    "train_inputs, val_inputs, train_labels, val_labels = train_test_split(inputs['input_ids'], labels, test_size=0.2, random_state=42)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from torch.utils.data import DataLoader, TensorDataset\n",
+    "\n",
+    "# Create datasets for training and validation\n",
+    "train_dataset = TensorDataset(train_inputs, train_labels)\n",
+    "val_dataset = TensorDataset(val_inputs, val_labels)\n",
+    "\n",
+    "# Create DataLoader for both training and validation\n",
+    "train_dataloader = DataLoader(train_dataset, batch_size=20, shuffle=True)\n",
+    "val_dataloader = DataLoader(val_dataset, batch_size=20)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cpu\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/anaconda3/envs/pytorch_env/lib/python3.11/site-packages/transformers/optimization.py:591: 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",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import AdamW\n",
+    "from torch.optim.lr_scheduler import StepLR\n",
+    "\n",
+    "# Set up the optimizer\n",
+    "optimizer = AdamW(model.parameters(), lr=0.0001)\n",
+    "\n",
+    "# Define the training loop\n",
+    "epochs = 1\n",
+    "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
+    "model.to(device)\n",
+    "\n",
+    "print(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor(0.1266, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2361, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0948, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0170, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5257, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0933, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1646, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2118, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0173, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1543, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3518, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5005, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3083, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1673, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0377, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1693, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3132, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3724, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0699, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1015, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0627, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0439, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3108, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1622, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2091, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1177, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5044, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0834, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1307, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0162, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1507, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4310, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1047, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3400, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5385, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0468, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0655, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0421, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2367, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1999, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3367, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5989, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0349, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4536, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2197, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2861, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1133, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2491, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2210, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1425, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1268, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2085, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2444, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3229, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1340, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2742, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2652, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1091, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3718, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1806, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1180, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1474, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2807, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2696, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4681, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0877, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3703, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4087, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5539, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1504, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0107, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5127, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5999, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1659, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0303, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2197, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2298, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3073, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3306, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2281, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0406, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1882, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2777, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3764, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2865, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1368, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3605, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1100, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2140, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4161, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2829, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2951, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2776, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0665, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4622, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1903, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1492, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3531, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1535, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4230, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2674, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1988, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1032, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.6737, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0771, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0759, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2127, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2328, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4041, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3188, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2907, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1548, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2523, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3066, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2681, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1790, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1407, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4857, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3541, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2105, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2170, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3173, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1405, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2956, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5343, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3510, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1565, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.7312, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4818, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3232, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2504, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0905, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2030, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3142, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4711, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0577, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1709, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1811, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4690, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1305, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1392, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1633, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1361, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2246, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1142, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4056, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0341, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.7735, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5424, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0938, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2202, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0883, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5231, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3891, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0318, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2012, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2682, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4051, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0735, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0473, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0671, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3305, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2791, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3031, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1154, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1411, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2358, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4483, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1316, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4731, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1665, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0311, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2365, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5279, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4144, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1594, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2623, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2407, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4914, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2589, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3578, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1238, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3464, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1637, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1750, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4039, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3257, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3095, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1030, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2661, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3043, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4696, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2800, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1741, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1582, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0720, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5691, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2497, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3357, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2267, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1167, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0201, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1358, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1345, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.8850, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0556, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0690, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3296, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1559, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3681, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1394, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2133, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2564, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3522, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3458, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2390, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2744, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0902, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3074, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2031, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1170, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5067, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2392, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1138, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4484, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1577, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2137, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1273, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1333, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1629, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1824, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.8445, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2046, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1296, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1347, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.6210, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2479, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3683, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2815, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4198, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5143, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1253, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3922, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2052, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3182, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3578, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2138, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2801, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4023, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2817, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1442, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5465, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0325, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4592, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2917, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4769, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5182, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2828, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2595, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5020, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1517, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3279, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1594, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0840, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3132, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1184, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0184, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2888, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0821, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2481, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0216, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2419, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3978, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1400, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0140, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4252, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0495, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4713, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0973, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1307, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0592, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4353, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3089, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1569, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2282, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4177, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0643, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4958, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3452, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1051, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4404, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3820, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1086, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2805, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4529, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1772, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1061, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1318, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3808, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3329, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1924, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3695, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2400, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2193, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1588, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1683, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3439, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2541, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2351, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2033, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0757, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1629, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3000, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.6601, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1748, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4209, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0594, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2206, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2674, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0595, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2141, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1375, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4534, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2570, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2481, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4599, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2221, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2963, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1427, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4567, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1509, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3520, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3681, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.5287, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3123, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3609, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1110, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2717, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1092, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2693, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.2787, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1664, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0727, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.0400, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1332, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4125, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.3152, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.4981, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1758, grad_fn=<NllLossBackward0>)\n",
+      "tensor(0.1878, grad_fn=<NllLossBackward0>)\n",
+      "tensor(1.1352, grad_fn=<NllLossBackward0>)\n",
+      "Epoch 1 | Loss: 0.25651482065232134\n"
+     ]
+    }
+   ],
+   "source": [
+    "for epoch in range(epochs):\n",
+    "    model.train()\n",
+    "    total_loss = 0\n",
+    "    for batch in train_dataloader:\n",
+    "        input_ids, labels = batch\n",
+    "        input_ids, labels = input_ids.to(device), labels.to(device)\n",
+    "\n",
+    "        # Zero the gradients\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = model(input_ids, labels=labels)\n",
+    "        loss = outputs.loss\n",
+    "        total_loss += loss.item()\n",
+    "\n",
+    "        # Backward pass\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        print(loss)\n",
+    "    print(f\"Epoch {epoch + 1} | Loss: {total_loss / len(train_dataloader)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Accuracy: 78.96%\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "correct_predictions = 0\n",
+    "total_predictions = 0\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    for batch in val_dataloader:\n",
+    "        input_ids, labels = batch\n",
+    "        input_ids, labels = input_ids.to(device), labels.to(device)\n",
+    "        # Forward pass\n",
+    "        outputs = model(input_ids)\n",
+    "        predictions = torch.argmax(outputs.logits, dim=-1)\n",
+    "\n",
+    "        correct_predictions += (predictions == labels).sum().item()\n",
+    "        total_predictions += labels.size(0)\n",
+    "\n",
+    "accuracy = correct_predictions / total_predictions\n",
+    "print(f\"Validation Accuracy: {accuracy * 100:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "def predict(text):\n",
+    "    inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512)\n",
+    "    input_ids = inputs['input_ids'].to(device)\n",
+    "    \n",
+    "    model.eval()\n",
+    "    with torch.no_grad():\n",
+    "        outputs = model(input_ids)\n",
+    "        prediction = torch.argmax(outputs.logits, dim=-1)\n",
+    "    return prediction.item()\n",
+    "\n",
+    "# Example prediction\n",
+    "question = \"Compare two dog food commercials. What is the difference between them and how do they both sell their products?\"\n",
+    "print(predict(question))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Remembering: 0.6210\n",
+      "Understanding: 0.2401\n",
+      "Applying: 0.0801\n",
+      "Analyzing: 0.0533\n",
+      "Evaluating: 0.0028\n",
+      "Creating: 0.0026\n"
+     ]
+    }
+   ],
+   "source": [
+    "from torch.nn.functional import softmax\n",
+    "\n",
+    "# The mapping of class labels to numeric labels\n",
+    "mapping = {\"Remembering\": 0, \"Understanding\": 1, \"Applying\": 2, \"Analyzing\": 3, \"Evaluating\": 4, \"Creating\": 5}\n",
+    "\n",
+    "# Reverse the mapping to get the class name from the index\n",
+    "reverse_mapping = {v: k for k, v in mapping.items()}\n",
+    "\n",
+    "def predict(text):\n",
+    "    # Tokenize the input text\n",
+    "    inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512)\n",
+    "    input_ids = inputs['input_ids'].to(device)\n",
+    "    \n",
+    "    model.eval()\n",
+    "    with torch.no_grad():\n",
+    "        # Get the raw logits from the model\n",
+    "        outputs = model(input_ids)\n",
+    "        logits = outputs.logits\n",
+    "        \n",
+    "        # Apply softmax to get probabilities\n",
+    "        probabilities = softmax(logits, dim=-1)\n",
+    "    \n",
+    "    # Convert probabilities to a list or dictionary of class probabilities\n",
+    "    probabilities = probabilities.squeeze().cpu().numpy()\n",
+    "    \n",
+    "    # Map the probabilities to the class labels using the reverse mapping\n",
+    "    class_probabilities = {reverse_mapping[i]: prob for i, prob in enumerate(probabilities)}\n",
+    "    \n",
+    "    return class_probabilities\n",
+    "\n",
+    "# Example prediction\n",
+    "question = \"State and explain rules of inference.\"\n",
+    "class_probabilities = predict(question)\n",
+    "\n",
+    "# Display the probabilities for each class label\n",
+    "for class_label, prob in class_probabilities.items():\n",
+    "    print(f\"{class_label}: {prob:.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('./fine_tuned_distilbert/tokenizer_config.json',\n",
+       " './fine_tuned_distilbert/special_tokens_map.json',\n",
+       " './fine_tuned_distilbert/vocab.txt',\n",
+       " './fine_tuned_distilbert/added_tokens.json')"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.save_pretrained('./fine_tuned_distilbert')\n",
+    "\n",
+    "# Save the tokenizer\n",
+    "tokenizer.save_pretrained('./fine_tuned_distilbert')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import DistilBertForSequenceClassification, DistilBertTokenizer\n",
+    "\n",
+    "# Load the saved model\n",
+    "model = DistilBertForSequenceClassification.from_pretrained('./fine_tuned_distilbert')\n",
+    "\n",
+    "# Load the saved tokenizer\n",
+    "tokenizer = DistilBertTokenizer.from_pretrained('./fine_tuned_distilbert')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Remembering: 0.0049\n",
+      "Understanding: 0.0040\n",
+      "Applying: 0.3104\n",
+      "Analyzing: 0.2497\n",
+      "Evaluating: 0.3769\n",
+      "Creating: 0.0542\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example of using the loaded model for prediction\n",
+    "def predict_with_loaded_model(text):\n",
+    "    # Tokenize the input text\n",
+    "    inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=512)\n",
+    "    input_ids = inputs['input_ids'].to(device)\n",
+    "\n",
+    "    model.eval()\n",
+    "    with torch.no_grad():\n",
+    "        outputs = model(input_ids)\n",
+    "        logits = outputs.logits\n",
+    "        probabilities = softmax(logits, dim=-1)\n",
+    "        \n",
+    "    # Map probabilities to class labels\n",
+    "    probabilities = probabilities.squeeze().cpu().numpy()\n",
+    "    class_probabilities = {reverse_mapping[i]: prob for i, prob in enumerate(probabilities)}\n",
+    "    \n",
+    "    return class_probabilities\n",
+    "\n",
+    "# Example usage with the saved model\n",
+    "question = \"The accuracy of each position in a sequence of GGTACTGAT is 98%, 95%, 97%, 97%, 98%, 99%, 94%, 93%, and 97% respectively.(a) What is the average PHRED quality score of this sequence?\"\n",
+    "class_probabilities = predict_with_loaded_model(question)\n",
+    "\n",
+    "# Display class probabilities\n",
+    "for class_label, prob in class_probabilities.items():\n",
+    "    print(f\"{class_label}: {prob:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "e = ['@ What are the key differences between classification and regression tasks in supervised learning, and how do you determine which algorithm to use for a specific problem?',\n",
+    " '@ How does clustering differ from dimensionality reduction, and can you provide real-world examples of where each is applied?',\n",
+    " '@ What are common evaluation metrics for classification models, and how do precision, recall, and F1-score relate to each other?',\n",
+    " '@ How do convolutional neural networks (CNNs) and recurrent neural networks (RNNs) differ in their architecture and applications?',\n",
+    " '@ What steps can be taken to identify and mitigate bias in machine learning models, and why is this an important consideration?']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Remembering': 0.10612957, 'Understanding': 0.019418646, 'Applying': 0.06178399, 'Analyzing': 0.06437193, 'Evaluating': 0.02016813, 'Creating': 0.7281277}\n",
+      "{'Remembering': 0.0023775953, 'Understanding': 0.007248114, 'Applying': 0.030584276, 'Analyzing': 0.03784482, 'Evaluating': 0.011662786, 'Creating': 0.9102824}\n",
+      "{'Remembering': 0.77779603, 'Understanding': 0.00137261, 'Applying': 0.030797651, 'Analyzing': 0.01779477, 'Evaluating': 0.015782129, 'Creating': 0.15645678}\n",
+      "{'Remembering': 0.0041304147, 'Understanding': 0.0012872498, 'Applying': 0.0071271434, 'Analyzing': 0.08727108, 'Evaluating': 0.012631507, 'Creating': 0.8875526}\n",
+      "{'Remembering': 0.02713421, 'Understanding': 0.0032449323, 'Applying': 0.0559042, 'Analyzing': 0.021534933, 'Evaluating': 0.015711982, 'Creating': 0.8764698}\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in e:\n",
+    "    class_probabilities = predict_with_loaded_model(i)\n",
+    "    print(class_probabilities)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "weights = {\n",
+    "    'Remembering': 0.5,\n",
+    "    'Understanding': 0.5,\n",
+    "    'Applying': 0.5,\n",
+    "    'Analyzing': 0.5,\n",
+    "    'Evaluating': 0.5,\n",
+    "    'Creating':0.5,\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "questions = [\n",
+    "    {'Remembering': 0.10612957, 'Understanding': 0.019418646, 'Applying': 0.06178399, 'Analyzing': 0.06437193, 'Evaluating': 0.02016813, 'Creating': 0.7281277},\n",
+    "    {'Remembering': 0.0023775953, 'Understanding': 0.007248114, 'Applying': 0.030584276, 'Analyzing': 0.03784482, 'Evaluating': 0.011662786, 'Creating': 0.9102824},\n",
+    "    {'Remembering': 0.77779603, 'Understanding': 0.00137261, 'Applying': 0.030797651, 'Analyzing': 0.01779477, 'Evaluating': 0.015782129, 'Creating': 0.15645678},\n",
+    "    {'Remembering': 0.0041304147, 'Understanding': 0.0012872498, 'Applying': 0.0071271434, 'Analyzing': 0.08727108, 'Evaluating': 0.012631507, 'Creating': 0.8875526},\n",
+    "    {'Remembering': 0.02713421, 'Understanding': 0.0032449323, 'Applying': 0.0559042, 'Analyzing': 0.021534933, 'Evaluating': 0.015711982, 'Creating': 0.8764698}\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.49999998975 18.0 90.0\n",
+      "Normalized Score of the Paper: 0.0278\n"
+     ]
+    }
+   ],
+   "source": [
+    "def calculate_score(question, weights):\n",
+    "    score = sum(question[level] * weight for level, weight in weights.items())\n",
+    "    return score\n",
+    "\n",
+    "total_score = sum(calculate_score(q, weights) for q in questions)\n",
+    "max_score_per_question = sum([weights[level] for level in weights]) * 6  \n",
+    "max_total_score = max_score_per_question * len(questions) \n",
+    "normalized_score = (total_score - 0) / (max_total_score - 0)\n",
+    "print(total_score, max_score_per_question, max_total_score)\n",
+    "print(f\"Normalized Score of the Paper: {normalized_score:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Remembering': 0.10612957, 'Understanding': 0.019418646, 'Applying': 0.06178399, 'Analyzing': 0.06437193, 'Evaluating': 0.02016813, 'Creating': 0.7281277}\n",
+      "{'Remembering': 0.0023775953, 'Understanding': 0.007248114, 'Applying': 0.030584276, 'Analyzing': 0.03784482, 'Evaluating': 0.011662786, 'Creating': 0.9102824}\n",
+      "{'Remembering': 0.77779603, 'Understanding': 0.00137261, 'Applying': 0.030797651, 'Analyzing': 0.01779477, 'Evaluating': 0.015782129, 'Creating': 0.15645678}\n",
+      "{'Remembering': 0.0041304147, 'Understanding': 0.0012872498, 'Applying': 0.0071271434, 'Analyzing': 0.08727108, 'Evaluating': 0.012631507, 'Creating': 0.8875526}\n",
+      "{'Remembering': 0.02713421, 'Understanding': 0.0032449323, 'Applying': 0.0559042, 'Analyzing': 0.021534933, 'Evaluating': 0.015711982, 'Creating': 0.8764698}\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in e:\n",
+    "    class_probabilities = predict_with_loaded_model(i)\n",
+    "    print(class_probabilities)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

t5_training.ipynb

@@ -0,0 +1,269 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d071d3d0-aa2f-4582-8e43-12f22e64bbee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# !pip install pytorch \n",
+    "# !pip install intel-extension-for-pytorch\n",
+    "# !pip install transformers\n",
+    "# !pip install datasets\n",
+    "# !pip install onnxruntime\n",
+    "# !pip install neural_compressor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d21c5cb-8042-4d63-8534-eb686acf4bf6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import T5ForConditionalGeneration, T5Tokenizer\n",
+    "from datasets import Dataset\n",
+    "from transformers import Trainer, TrainingArguments\n",
+    "\n",
+    "# Load pre-trained FLAN-T5 model and tokenizer\n",
+    "model_name = \"google/flan-t5-large\"  # FLAN-T5 Base Model\n",
+    "tokenizer = T5Tokenizer.from_pretrained(model_name)\n",
+    "model = T5ForConditionalGeneration.from_pretrained(model_name)\n",
+    "\n",
+    "# Example input-output pair for fine-tuning\n",
+    "data = {\n",
+    "    \"input_text\": [\n",
+    "        \"What are the key differences between classification and regression tasks in supervised learning, and how do you determine which algorithm to use for a specific problem? e How does clustering differ from dimensionality reduction, and can you provide real-world examples of where each is applied?\"\n",
+    "    ],\n",
+    "    \"output_text\": [\n",
+    "        \"@ What are the key differences between classification and regression tasks in supervised learning, and how do you determine which algorithm to use for a specific problem? @ How does clustering differ from dimensionality reduction, and can you provide real-world examples of where each is applied?\"\n",
+    "    ]\n",
+    "}\n",
+    "\n",
+    "# Convert the data to a Hugging Face dataset\n",
+    "dataset = Dataset.from_dict(data)\n",
+    "\n",
+    "# Tokenize the data\n",
+    "def preprocess_function(examples):\n",
+    "    model_inputs = tokenizer(examples['input_text'], padding=\"max_length\", truncation=True, max_length=2048)\n",
+    "    labels = tokenizer(examples['output_text'], padding=\"max_length\", truncation=True, max_length=2048)\n",
+    "    model_inputs['labels'] = labels['input_ids']\n",
+    "    return model_inputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e0d06e8-f50a-4a22-93b7-44152f06e462",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenized_datasets = dataset.map(preprocess_function, batched=True)\n",
+    "\n",
+    "# Set up the training arguments\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"./flan_t5_results\",  # Output directory for model checkpoints\n",
+    "    eval_strategy=\"epoch\",     # Evaluation strategy to use\n",
+    "    learning_rate=2e-5,              # Learning rate for fine-tuning\n",
+    "    per_device_train_batch_size=1,   # Batch size for training\n",
+    "    num_train_epochs=1,              # Number of epochs\n",
+    "    weight_decay=0.01,               # Weight decay for regularization\n",
+    "    save_steps=10,                   # Save model every 10 steps\n",
+    "    save_total_limit=1,             # Limit the number of saved models\n",
+    "    fp16=False,  # Disable mixed precision\n",
+    "    use_cpu=True  # Force CPU-only training\n",
+    ")\n",
+    "\n",
+    "# Initialize the Trainer class\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=tokenized_datasets,\n",
+    "    eval_dataset=tokenized_datasets  # Use the same dataset for evaluation since we only have one data point\n",
+    ")\n",
+    "\n",
+    "# Start training (this will fine-tune the model on the given example)\n",
+    "trainer.train()\n",
+    "\n",
+    "# Save the fine-tuned model\n",
+    "#trainer.save_model(\"./flan_t5_finetuned\")\n",
+    "model.save_pretrained(\"./flan_t5_finetuned\")\n",
+    "tokenizer.save_pretrained(\"./flan_t5_finetuned\")\n",
+    "\n",
+    "# Evaluate the model on the training data (for a single example)\n",
+    "model.eval()\n",
+    "inputs = tokenizer(\"What are the key differences between classification and regression tasks in supervised learning, and how do you determine which algorithm to use for a specific problem? e How does clustering differ from dimensionality reduction, and can you provide real-world examples of where each is applied?\", return_tensors=\"pt\", padding=True)\n",
+    "outputs = model.generate(inputs['input_ids'], max_length=1024)\n",
+    "\n",
+    "# Decode the generated output\n",
+    "generated_output = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "print(generated_output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4b97afe-f09a-4bee-9139-ed9802da712e",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import T5ForConditionalGeneration, T5Tokenizer\n",
+    "from neural_compressor.quantization import fit\n",
+    "from neural_compressor.config import PostTrainingQuantConfig\n",
+    "\n",
+    "# Load your FP32 model\n",
+    "model_path = \"./flan_t5_finetuned\"\n",
+    "model = T5ForConditionalGeneration.from_pretrained(model_path)\n",
+    "tokenizer = T5Tokenizer.from_pretrained(model_path)\n",
+    "\n",
+    "# Define the quantization configuration\n",
+    "quant_config = PostTrainingQuantConfig(approach='dynamic')  # Dynamic quantization\n",
+    "\n",
+    "# Quantize the model\n",
+    "q_model = fit(model=model, conf=quant_config)\n",
+    "\n",
+    "# Save the quantized model\n",
+    "quantized_model_path = \"./flan_t5_quantized_fp16\"\n",
+    "q_model.save_pretrained(quantized_model_path)\n",
+    "tokenizer.save_pretrained(quantized_model_path)\n",
+    "\n",
+    "print(f\"Quantized model saved at: {quantized_model_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a152f3d9-7042-479b-b3ba-ff5c957be518",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from transformers import T5ForConditionalGeneration, T5Tokenizer\n",
+    "import os\n",
+    "\n",
+    "# Load the FP16 model\n",
+    "model_path = \"./flan_t5_fp16\"\n",
+    "model = T5ForConditionalGeneration.from_pretrained(model_path)\n",
+    "tokenizer = T5Tokenizer.from_pretrained(model_path)\n",
+    "\n",
+    "# Set the model to evaluation mode\n",
+    "model.eval()\n",
+    "\n",
+    "# Example input text\n",
+    "input_text = \"Translate English to French: How are you?\"\n",
+    "inputs = tokenizer(input_text, return_tensors=\"pt\", padding=True, truncation=True)\n",
+    "\n",
+    "# Prepare decoder input: <pad> token is used as the first decoder input\n",
+    "decoder_start_token_id = tokenizer.pad_token_id\n",
+    "decoder_input_ids = torch.tensor([[decoder_start_token_id]])\n",
+    "\n",
+    "# Create output directory if it doesn't exist\n",
+    "onnx_output_dir = \"./flant5\"\n",
+    "os.makedirs(onnx_output_dir, exist_ok=True)\n",
+    "\n",
+    "# Define the path for the ONNX model\n",
+    "onnx_model_path = os.path.join(onnx_output_dir, \"flan_t5_fp16.onnx\")\n",
+    "\n",
+    "# Export the model to ONNX\n",
+    "torch.onnx.export(\n",
+    "    model,                                    # Model to be converted\n",
+    "    (inputs[\"input_ids\"], inputs[\"attention_mask\"], decoder_input_ids),  # Input tuple\n",
+    "    onnx_model_path,                         # Path to save the ONNX model\n",
+    "    export_params=True,                      # Store the trained parameters\n",
+    "    opset_version=13,                        # ONNX version\n",
+    "    do_constant_folding=True,                # Optimize constants\n",
+    "    input_names=[\"input_ids\", \"attention_mask\", \"decoder_input_ids\"],  # Input tensor names\n",
+    "    output_names=[\"output\"],                 # Output tensor name\n",
+    "    dynamic_axes={                           # Dynamic shapes for batching\n",
+    "        \"input_ids\": {0: \"batch_size\", 1: \"sequence_length\"},\n",
+    "        \"attention_mask\": {0: \"batch_size\", 1: \"sequence_length\"},\n",
+    "        \"decoder_input_ids\": {0: \"batch_size\", 1: \"sequence_length\"},\n",
+    "        \"output\": {0: \"batch_size\", 1: \"sequence_length\"}\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "print(f\"ONNX model saved at: {onnx_model_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "055abefb-2d0f-4819-b859-86b77270c0be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import onnxruntime as ort\n",
+    "import numpy as np\n",
+    "from transformers import T5Tokenizer\n",
+    "\n",
+    "# Load the ONNX model and tokenizer\n",
+    "onnx_model_path = \"./flan_t5_fp16.onnx\"\n",
+    "tokenizer = T5Tokenizer.from_pretrained(\"./flan_t5_fp16\")\n",
+    "ort_session = ort.InferenceSession(onnx_model_path)\n",
+    "\n",
+    "# Input text for the model\n",
+    "input_text = \"Translate English to French: How are you?\"\n",
+    "inputs = tokenizer(input_text, return_tensors=\"np\", padding=True, truncation=True)\n",
+    "\n",
+    "# Ensure inputs are numpy arrays\n",
+    "input_ids = np.array(inputs[\"input_ids\"], dtype=np.int64)\n",
+    "attention_mask = np.array(inputs[\"attention_mask\"], dtype=np.int64)\n",
+    "\n",
+    "# Prepare the decoder input (<pad> token for initial input to the decoder)\n",
+    "decoder_start_token_id = tokenizer.pad_token_id\n",
+    "decoder_input_ids = np.array([[decoder_start_token_id]], dtype=np.int64)\n",
+    "\n",
+    "# ONNX model inputs\n",
+    "onnx_inputs = {\n",
+    "    \"input_ids\": input_ids,\n",
+    "    \"attention_mask\": attention_mask,\n",
+    "    \"decoder_input_ids\": decoder_input_ids\n",
+    "}\n",
+    "\n",
+    "# Run the ONNX model\n",
+    "onnx_outputs = ort_session.run(None, onnx_inputs)\n",
+    "\n",
+    "# Convert logits to token IDs\n",
+    "logits = onnx_outputs[0]  # Shape: [batch_size, sequence_length, vocab_size]\n",
+    "token_ids = np.argmax(logits, axis=-1)  # Get token IDs with the highest scores\n",
+    "\n",
+    "# Decode the token IDs into text\n",
+    "decoded_output = tokenizer.decode(token_ids[0], skip_special_tokens=True)\n",
+    "\n",
+    "print(f\"ONNX Model Output: {decoded_output}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9110235-9c49-46ef-86e1-f446b3f12d67",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}