EfficientNetB3_V3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nImproving loss function, using a loss function that is quadratic - so correlates well with cohens kappa\\n'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Diabetic Retinopathy\n",
    "# Dataset - https://www.kaggle.com/competitions/diabetic-retinopathy-detection/data\n",
    "\n",
    "\"\"\"\n",
    "Improving loss function, using a loss function that is quadratic - so correlates well with cohens kappa\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "from sklearn.model_selection import train_test_split as datasetSplit\n",
    "import numpy as np \n",
    "import os\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision \n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "from PIL import Image\n",
    "import albumentations as A\n",
    "from albumentations.pytorch import ToTensorV2\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.metrics import cohen_kappa_score\n",
    "from efficientnet_pytorch import EfficientNet\n",
    "from tqdm import tqdm\n",
    "\n",
    "from torch.optim import lr_scheduler\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dataset paths containing all the images and image labels\n",
    "dataset_images = \"Data/images_650_V2/\"\n",
    "dataset_labels = \"Data/trainLabels.csv\"\n",
    "\n",
    "BATCHSIZE = 64\n",
    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "LEARNING_RATE = 0.0001\n",
    "WEIGHT_DECAY = 0.0005 #L2 Norm on the model weights\n",
    "NUM_EPOCHS = 100\n",
    "NUM_WORKERS = 0 \n",
    "CHECKPOINT_FOLDER = \"Checkpoints/\"\n",
    "CHECKPOINT_FILE = \"EfNetB3_v3.pth.tar\" #Experiment 3 \n",
    "PATIENCE = 4 #for early stopping\n",
    "\n",
    "PIN_MEMORY = True\n",
    "SAVE_MODEL = True\n",
    "LOAD_MODEL = True\n",
    "\n",
    "INPUT_IMAGE_WIDTH = 120\n",
    "INPUT_IMAGE_HEIGHT = 120\n",
    "\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "writer = SummaryWriter(\"runs/EfNetB3_v3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35126 images found in the dataset_images\n"
     ]
    }
   ],
   "source": [
    "print(f'{len(os.listdir(dataset_images))} images found in the dataset_images') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train Val Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35126 images and 35126 targets found\n"
     ]
    }
   ],
   "source": [
    "inputs = np.array(pd.read_csv(dataset_labels)[\"image\"])\n",
    "targets = np.array(pd.read_csv(dataset_labels)[\"level\"])\n",
    "print(f\"{len(inputs)} images and {len(targets)} targets found\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_inputs, val_inputs, train_labels, val_labels = datasetSplit(inputs,targets,test_size= 0.11,random_state=47,shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset Train Size: 31262, Dataset Test Size:3864\n"
     ]
    }
   ],
   "source": [
    "print(f\"Dataset Train Size: {len(train_inputs)}, Dataset Test Size:{len(val_inputs)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dataset Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DiabeticRetinopathyDataset(Dataset):\n",
    "    def __init__(self,inputs,targets,data_transforms=None):\n",
    "        self.inputs = inputs\n",
    "        self.targets = torch.from_numpy(targets.astype(np.float32))\n",
    "        self.data_transforms = data_transforms\n",
    "        self.n_samples = len(inputs)\n",
    "        \n",
    "    def __getitem__(self,index):\n",
    "        img_path = self.inputs[index]\n",
    "        img = Image.open(dataset_images+img_path+\".jpeg\")\n",
    "        img = np.array(img) #Albumenations takes nd.array as input\n",
    "        # img = torch.from_numpy(img.astype(np.float32))\n",
    "        img_label = self.targets[index]\n",
    "        if self.data_transforms:\n",
    "            img = self.data_transforms(image=img)[\"image\"]\n",
    "            img.type(torch.float32)\n",
    "        return img, img_label, img_path\n",
    "        \n",
    "    def __len__(self):\n",
    "        return self.n_samples\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_transforms = A.Compose([\n",
    "    A.Resize(width=INPUT_IMAGE_WIDTH+7,height=INPUT_IMAGE_HEIGHT+7),\n",
    "    A.RandomCrop(width=INPUT_IMAGE_WIDTH,height=INPUT_IMAGE_HEIGHT),\n",
    "    A.Normalize(mean=[0.3199, 0.2240, 0.1609],std=[0.3020, 0.2183, 0.1741],max_pixel_value = 255.0), \n",
    "    ToTensorV2()\n",
    "    ])\n",
    "\n",
    "#Test with more transformations\n",
    "\n",
    "val_transforms = A.Compose([\n",
    "    A.Resize(width=INPUT_IMAGE_WIDTH,height=INPUT_IMAGE_HEIGHT),\n",
    "    A.Normalize(mean=[0.3199, 0.2240, 0.1609],std=[0.3020, 0.2183, 0.1741],max_pixel_value = 255.0), \n",
    "    ToTensorV2()\n",
    "    ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dataset Loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = DiabeticRetinopathyDataset(train_inputs,train_labels,data_transforms=train_transforms)\n",
    "val_dataset = DiabeticRetinopathyDataset(val_inputs,val_labels,data_transforms=val_transforms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader =DataLoader(train_dataset,batch_size=BATCHSIZE,shuffle=True,num_workers=NUM_WORKERS)\n",
    "val_loader =DataLoader(val_dataset,batch_size=BATCHSIZE,shuffle=False,num_workers=NUM_WORKERS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Having a look at first batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_iter = iter(train_loader)\n",
    "first_batch = train_iter.next()\n",
    "batch_images, batch_labels, batch_files = first_batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([64, 3, 120, 120])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([64])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_labels.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Visualise Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1954e5203a0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "batch_images_grid = torchvision.utils.make_grid(batch_images,nrow=8)\n",
    "writer.add_image(\"Retina Images\",batch_images_grid)\n",
    "writer.close()\n",
    "\n",
    "plt.imshow(batch_images_grid.permute(1, 2, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utility Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_prediction(model,dataloader,output_csv=\"submission.csv\"):\n",
    "    all_preds = []\n",
    "    file_names = []\n",
    "    # total_loss = 0.0\n",
    "    model.eval() #set the model to evaluation state\n",
    "\n",
    "    for inputs, labels, names in enumerate(dataloader):\n",
    "        inputs = inputs.to(DEVICE)\n",
    "        with torch.no_grad():\n",
    "            outs = model(inputs)\n",
    "\n",
    "            # _, batch_preds = torch.max(outs,1)\n",
    "            \n",
    "            preds = outs\n",
    "            preds[preds < 0.5] = 0\n",
    "            preds[(preds >= 0.5) & (preds < 1.5)] = 1\n",
    "            preds[(preds >= 1.5) & (preds < 2.5)] = 2\n",
    "            preds[(preds >= 2.5) & (preds < 3.5)] = 3\n",
    "            preds[preds >= 3.5] = 4\n",
    "            preds = preds.long().squeeze(1)\n",
    "\n",
    "            batch_preds = preds\n",
    "            all_preds.append(batch_preds.cpu().numpy())\n",
    "            file_names.append(names)\n",
    "\n",
    "    df = pd.DataFrame({\"image\":file_names,\"level\":np.concatenate(all_preds, axis=0)})\n",
    "    df.to_csv(output_csv,index=False)\n",
    "    model.train() #Set the model back to training phase\n",
    "\n",
    "def calculate_accuracy(model,dataloader,epoch_num):\n",
    "    model.eval()\n",
    "    total_loss = 0.0\n",
    "    all_preds, all_labels = [],[]\n",
    "    correct_predictions = 0\n",
    "    num_samples = 0\n",
    "    dataiter = tqdm(dataloader)\n",
    "    for batchID, (inputs, labels, names) in enumerate(dataiter):\n",
    "        inputs = inputs.to(DEVICE)\n",
    "        labels = labels.type(torch.LongTensor)\n",
    "        labels = labels.to(DEVICE)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            outs = model(inputs)\n",
    "\n",
    "            # _, batch_preds = torch.max(outs,1)\n",
    "\n",
    "            preds = outs\n",
    "            preds[preds < 0.5] = 0\n",
    "            preds[(preds >= 0.5) & (preds < 1.5)] = 1\n",
    "            preds[(preds >= 1.5) & (preds < 2.5)] = 2\n",
    "            preds[(preds >= 2.5) & (preds < 3.5)] = 3\n",
    "            preds[preds >= 3.5] = 4\n",
    "            batch_preds = preds.long().view(-1)\n",
    "            labels_ = labels.view(-1)\n",
    "\n",
    "\n",
    "            \n",
    "            batch_loss = loss_func(outs,labels)\n",
    "            \n",
    "           \n",
    "            correct_predictions += (batch_preds==labels_).sum().item()\n",
    "            num_samples += outs.shape[0]\n",
    "\n",
    "            all_preds.append(batch_preds.cpu().numpy())\n",
    "            all_labels.append(labels.cpu().numpy())\n",
    "            total_loss += batch_loss.item()\n",
    "        dataiter.set_postfix(loss=batch_loss.item())\n",
    "            \n",
    "            \n",
    "\n",
    "    model.train()\n",
    "    epoch_acc = 100.0*correct_predictions/num_samples\n",
    "    epoch_loss = total_loss/len(dataloader)\n",
    "    # print(f\"Epoch Accuracy: {accuracy:.2f}%. Predicted {correct_predictions} correcctly out of {num_samples} images!\")\n",
    "    all_preds = np.concatenate(all_preds,axis=0,dtype=np.int64)\n",
    "    all_labels = np.concatenate(all_labels,axis=0,dtype=np.int64)\n",
    "    kappa = cohen_kappa_score(all_labels,all_preds,weights='quadratic')\n",
    "    print(f\"Epoch (Val): {epoch_num}, Loss= {epoch_loss}, Accuracy= {epoch_acc}, Kappa= {kappa}\")\n",
    "    writer.add_scalar('val_loss',epoch_loss,global_step=epoch_num)\n",
    "    writer.add_scalar('val_acc',epoch_acc,global_step=epoch_num)\n",
    "    writer.add_scalar('val_kappa',kappa,global_step=epoch_num)\n",
    "    writer.close()\n",
    "    return epoch_acc, kappa \n",
    "\n",
    "            \n",
    "def save_checkpoint(state_dicts):\n",
    "    torch.save(state_dicts,CHECKPOINT_FOLDER+CHECKPOINT_FILE)\n",
    "\n",
    "def load_checkpoint(checkpoint_file,model,optimiser,learning_rate):\n",
    "    checkpoint = torch.load(checkpoint_file)\n",
    "    model.load_state_dict(checkpoint[\"state_dict\"])\n",
    "    optimiser.load_state_dict(checkpoint[\"optimiser\"])\n",
    "\n",
    "    for params in optimiser.param_groups:\n",
    "        params[\"lr\"] = learning_rate\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Design the Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded pretrained weights for efficientnet-b3\n"
     ]
    }
   ],
   "source": [
    "model = EfficientNet.from_pretrained(\"efficientnet-b3\")\n",
    "in_features = model._fc.in_features\n",
    "# model._fc = nn.Linear(in_features,1) #Use just 1 prediction, convert this float value into integer predictions\n",
    "model._fc = nn.Linear(in_features,5)\n",
    "model = model.to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loss Function, Optmiser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loss_func = nn.CrossEntropyLoss()\n",
    "loss_func = nn.MSELoss()\n",
    "optimiser = torch.optim.Adam(model.parameters(),lr=LEARNING_RATE,weight_decay=WEIGHT_DECAY)\n",
    "scaler = torch.cuda.amp.GradScaler()\n",
    "lr_scheduler1 = lr_scheduler.StepLR(optimiser,step_size=7,gamma=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "load_checkpoint('Checkpoints/EfNetB3_v2_B.pth.tar',model,optimiser,LEARNING_RATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "model._fc = nn.Linear(in_features,1) #Use just 1 prediction, convert this float value into integer predictions\n",
    "model = model.to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_epoch(model,dataloader,optimiser,scheduler,loss_func,scaler,epoch_num):\n",
    "    total_loss = 0.0\n",
    "    dataiter = tqdm(dataloader)\n",
    "    correct_predictions = 0\n",
    "    num_samples = 0\n",
    "    all_preds, all_labels = [],[]\n",
    "    for batch_num,(inputs,labels,filenames) in enumerate(dataiter):\n",
    "        inputs = inputs.to(DEVICE)\n",
    "        labels = labels.type(torch.LongTensor)\n",
    "        labels = labels.to(DEVICE)\n",
    "\n",
    "        if batch_num%40 == 0 and epoch_num%10==0 : #visualising few batch images (after transforms) \n",
    "            writer.add_image(\"Batch_\"+str(batch_num),torchvision.utils.make_grid(inputs,nrow=8))\n",
    "            writer.close()\n",
    "\n",
    "        #forward pass\n",
    "        with torch.cuda.amp.autocast():\n",
    "            outs = model(inputs)\n",
    "            # _, batch_preds = torch.max(outs,1)\n",
    "            \n",
    "            # print(outs.shape,labels.shape) \n",
    "            batch_loss = loss_func(outs,labels.unsqueeze(1).float())\n",
    "\n",
    "            preds = outs\n",
    "            preds[preds < 0.5] = 0\n",
    "            preds[(preds >= 0.5) & (preds < 1.5)] = 1\n",
    "            preds[(preds >= 1.5) & (preds < 2.5)] = 2\n",
    "            preds[(preds >= 2.5) & (preds < 3.5)] = 3\n",
    "            preds[preds >= 3.5] = 4\n",
    "\n",
    "            batch_preds = preds.long().view(-1)\n",
    "            labels_ = labels.view(-1)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "        \n",
    "        total_loss += batch_loss.item()\n",
    "        correct_predictions += (batch_preds==labels_).sum().item()\n",
    "        num_samples += outs.shape[0]\n",
    "        all_preds.append(batch_preds.cpu().numpy())\n",
    "        all_labels.append(labels.cpu().numpy())\n",
    "\n",
    "        #backward step\n",
    "        optimiser.zero_grad()\n",
    "        scaler.scale(batch_loss).backward()\n",
    "        scaler.step(optimiser)\n",
    "        # optimiser.step()\n",
    "        scaler.update()\n",
    "        dataiter.set_postfix(loss=batch_loss.item())\n",
    "\n",
    "    epoch_loss = total_loss/len(dataloader)\n",
    "    epoch_acc = 100.0*correct_predictions/num_samples\n",
    "    all_preds = np.concatenate(all_preds,axis=0,dtype=np.int64)\n",
    "    all_labels = np.concatenate(all_labels,axis=0,dtype=np.int64)\n",
    "    scheduler.step()\n",
    "\n",
    "    kappa = cohen_kappa_score(all_labels,all_preds,weights='quadratic')\n",
    "    print(f\"Epoch (Train): {epoch_num}, Loss= {epoch_loss}, Accuracy= {epoch_acc}, Kappa= {kappa}\")\n",
    "    writer.add_scalar('training_loss',epoch_loss,global_step=epoch_num)\n",
    "    writer.add_scalar('training_acc',epoch_acc,global_step=epoch_num)\n",
    "    writer.add_scalar('training_kappa',kappa,global_step=epoch_num)\n",
    "    writer.close()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trainModel(model,trainloader,valloader,optimiser,lr_scheduler1,loss_func,epochs):\n",
    "    \n",
    "    checkpoint_stuff = {\"state_dict\":model.state_dict() ,\"optimiser\":optimiser.state_dict()}\n",
    "    best_kappa = 0.0\n",
    "    best_epoch = 0\n",
    "    es = 0 #early stopper\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "\n",
    "        #Train Phase\n",
    "        model.train()\n",
    "        \n",
    "        train_epoch(model,train_loader,optimiser,lr_scheduler1,loss_func,scaler,epoch)\n",
    "        \n",
    "        #Validation Phase\n",
    "        model.eval()\n",
    "        epoch_acc, kappa  = calculate_accuracy(model,val_loader,epoch)\n",
    "        \n",
    "        #Early stopping and checkpoints\n",
    "        if (kappa > best_kappa) :\n",
    "            best_kappa = kappa\n",
    "            es = 0 \n",
    "            checkpoint_stuff = {\"state_dict\":model.state_dict() ,\"optimiser\":optimiser.state_dict()}\n",
    "            best_epoch = epoch\n",
    "            print(f\"Checkpoint Saved at {best_epoch}\")\n",
    "        else :\n",
    "            es += 1\n",
    "            print(f\"Model performance has not improved in this epoch. Patience: {es}/{PATIENCE}\")\n",
    "            if es>PATIENCE:\n",
    "                print(f\"Early Stopping with {best_kappa} at Epoch {best_epoch}\")\n",
    "                break\n",
    "\n",
    "\n",
    "    model.load_state_dict(checkpoint_stuff[\"state_dict\"]) #load the best model\n",
    "    if SAVE_MODEL:\n",
    "        save_checkpoint(checkpoint_stuff)\n",
    "        # print(\"Checkpoint - Model Saved at {best_epoch}\")\n",
    "    return model #return the trained model\n",
    "    \n",
    "    \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:51<00:00,  1.68it/s, loss=0.412] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 0, Loss= 0.26660310787840125, Accuracy= 79.83814215341309, Kappa= 0.8318386041408425\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:29<00:00,  2.07it/s, loss=1.11] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:29<00:00,  2.09it/s, loss=3.38]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 0, Loss= 1.5667824667008197, Accuracy= 66.51138716356108, Kappa= 0.5778518683603471\n",
      "Checkpoint Saved at 0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:40<00:00,  1.75it/s, loss=0.0868]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 1, Loss= 0.17663988021558535, Accuracy= 84.4027893288977, Kappa= 0.8889122708604313\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:28<00:00,  2.20it/s, loss=1.14] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:28<00:00,  2.16it/s, loss=3.21]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 1, Loss= 1.5432382372559095, Accuracy= 67.59834368530021, Kappa= 0.5729080470245147\n",
      "Model performance has not improved in this epoch. Patience: 1/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:43<00:00,  1.73it/s, loss=0.172] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 2, Loss= 0.1586338958278268, Accuracy= 86.12692725993219, Kappa= 0.9016028144640269\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:28<00:00,  2.14it/s, loss=1.17] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:28<00:00,  2.15it/s, loss=3.21]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 2, Loss= 1.6672296563132865, Accuracy= 67.49482401656314, Kappa= 0.5954176153439061\n",
      "Checkpoint Saved at 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:40<00:00,  1.74it/s, loss=0.314] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 3, Loss= 0.14750472204816853, Accuracy= 86.913825091165, Kappa= 0.9095494341282786\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.17it/s, loss=1.26] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.23it/s, loss=3.4] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 3, Loss= 1.6994001865386963, Accuracy= 68.63354037267081, Kappa= 0.6098630540915193\n",
      "Checkpoint Saved at 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:34<00:00,  1.78it/s, loss=0.422] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 4, Loss= 0.1395058617574793, Accuracy= 87.8190774742499, Kappa= 0.9149628026010627\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.16it/s, loss=1.36] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.22it/s, loss=3.18]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 4, Loss= 1.7397754426862373, Accuracy= 68.2712215320911, Kappa= 0.6152014145677204\n",
      "Checkpoint Saved at 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:34<00:00,  1.78it/s, loss=0.0621]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 5, Loss= 0.12710125494466482, Accuracy= 88.35966988676348, Kappa= 0.9223290866630314\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.22it/s, loss=1.21] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.20it/s, loss=3.35]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 5, Loss= 1.6556443190965495, Accuracy= 67.2360248447205, Kappa= 0.6024832769295198\n",
      "Model performance has not improved in this epoch. Patience: 1/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:40<00:00,  1.74it/s, loss=0.66]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 6, Loss= 0.13064277722883078, Accuracy= 88.31168831168831, Kappa= 0.9200808663214538\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.22it/s, loss=1.33] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.23it/s, loss=3.26]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 6, Loss= 1.6519862120268776, Accuracy= 68.76293995859213, Kappa= 0.6127710304565785\n",
      "Model performance has not improved in this epoch. Patience: 2/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:43<00:00,  1.73it/s, loss=0.0403]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 7, Loss= 0.09550017313860311, Accuracy= 90.9826626575395, Kappa= 0.9434309574988597\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:29<00:00,  1.97it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:30<00:00,  2.03it/s, loss=3.26]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 7, Loss= 1.656548840100648, Accuracy= 70.23809523809524, Kappa= 0.6304349579944746\n",
      "Checkpoint Saved at 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:39<00:00,  1.75it/s, loss=0.0878]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 8, Loss= 0.07737631012889383, Accuracy= 92.71319813191734, Kappa= 0.9549113946113034\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.21it/s, loss=1.29] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.23it/s, loss=3.46]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 8, Loss= 1.6673737393050898, Accuracy= 70.1086956521739, Kappa= 0.628673885885096\n",
      "Model performance has not improved in this epoch. Patience: 1/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:45<00:00,  1.71it/s, loss=0.0361]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 9, Loss= 0.06809514859626507, Accuracy= 93.56727016825539, Kappa= 0.9610181774772883\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:28<00:00,  2.26it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:28<00:00,  2.16it/s, loss=3.41]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 9, Loss= 1.6794633709016393, Accuracy= 70.08281573498965, Kappa= 0.6336814300872514\n",
      "Checkpoint Saved at 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:49<00:00,  1.69it/s, loss=0.228] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 10, Loss= 0.06683887613285905, Accuracy= 93.74000383852601, Kappa= 0.962847164483418\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.17it/s, loss=1.33] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:28<00:00,  2.18it/s, loss=3.51]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 10, Loss= 1.683708484055566, Accuracy= 69.87577639751552, Kappa= 0.6352314214981042\n",
      "Checkpoint Saved at 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:39<00:00,  1.75it/s, loss=0.0341]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 11, Loss= 0.06016940068918259, Accuracy= 94.30618642441303, Kappa= 0.9665856290868369\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:28<00:00,  2.19it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:28<00:00,  2.14it/s, loss=3.51]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 11, Loss= 1.6849491987072054, Accuracy= 70.4192546583851, Kappa= 0.6349340082831427\n",
      "Model performance has not improved in this epoch. Patience: 1/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:39<00:00,  1.75it/s, loss=0.0472]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 12, Loss= 0.05912890075753559, Accuracy= 94.4405348346235, Kappa= 0.9674329320955293\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.19it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:28<00:00,  2.17it/s, loss=3.51]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 12, Loss= 1.6846130050596644, Accuracy= 69.97929606625259, Kappa= 0.6317225989048909\n",
      "Model performance has not improved in this epoch. Patience: 2/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:39<00:00,  1.75it/s, loss=0.0334]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 13, Loss= 0.055968031153875136, Accuracy= 94.84358006525494, Kappa= 0.9693916051068523\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.25it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.19it/s, loss=3.51]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 13, Loss= 1.6859577796498284, Accuracy= 69.7463768115942, Kappa= 0.6331676364032429\n",
      "Model performance has not improved in this epoch. Patience: 3/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:38<00:00,  1.75it/s, loss=0.0779]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 14, Loss= 0.052580285825002904, Accuracy= 95.09628302731751, Kappa= 0.971976783351358\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.21it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.19it/s, loss=3.51]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 14, Loss= 1.6849091756539267, Accuracy= 70.08281573498965, Kappa= 0.6367928073134999\n",
      "Checkpoint Saved at 14\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:38<00:00,  1.76it/s, loss=0.101] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 15, Loss= 0.051628112402536994, Accuracy= 95.20824003582624, Kappa= 0.9725460944483955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.19it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.18it/s, loss=3.51]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 15, Loss= 1.679986340100648, Accuracy= 69.97929606625259, Kappa= 0.6334696707503591\n",
      "Model performance has not improved in this epoch. Patience: 1/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:38<00:00,  1.76it/s, loss=0.0331]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 16, Loss= 0.05083895048435114, Accuracy= 95.41616019448531, Kappa= 0.9734882435457326\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.15it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.19it/s, loss=3.41]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 16, Loss= 1.6840340035860655, Accuracy= 69.77225672877847, Kappa= 0.6308873392617235\n",
      "Model performance has not improved in this epoch. Patience: 2/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:38<00:00,  1.76it/s, loss=0.0349]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 17, Loss= 0.05176692255077491, Accuracy= 95.39696756445525, Kappa= 0.9731789973012407\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.20it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.19it/s, loss=3.41]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 17, Loss= 1.6761654713114753, Accuracy= 70.2639751552795, Kappa= 0.6349410938059048\n",
      "Model performance has not improved in this epoch. Patience: 3/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:38<00:00,  1.75it/s, loss=0.157] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 18, Loss= 0.051885495859375394, Accuracy= 95.32019704433498, Kappa= 0.9728335599439611\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.25it/s, loss=1.29] C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.19it/s, loss=3.46]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 18, Loss= 1.671912353546893, Accuracy= 70.44513457556936, Kappa= 0.6323422806713614\n",
      "Model performance has not improved in this epoch. Patience: 4/4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 489/489 [04:38<00:00,  1.75it/s, loss=0.115] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Train): 19, Loss= 0.049146890943081466, Accuracy= 95.48333439959056, Kappa= 0.9745337720440953\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/61 [00:00<?, ?it/s]C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([64])) that is different to the input size (torch.Size([64, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      " 98%|█████████▊| 60/61 [00:27<00:00,  2.18it/s, loss=1.3]  C:\\Users\\Abhinav Reddy Nimma\\AppData\\Roaming\\Python\\Python38\\site-packages\\torch\\nn\\modules\\loss.py:520: UserWarning: Using a target size (torch.Size([24])) that is different to the input size (torch.Size([24, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  return F.mse_loss(input, target, reduction=self.reduction)\n",
      "100%|██████████| 61/61 [00:27<00:00,  2.18it/s, loss=3.46]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch (Val): 19, Loss= 1.6774835625632865, Accuracy= 70.4968944099379, Kappa= 0.6316843890397585\n",
      "Model performance has not improved in this epoch. Patience: 5/4\n",
      "Early Stopping with 0.6367928073134999 at Epoch 14\n"
     ]
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "trainedModel = trainModel(model,train_loader,val_loader,optimiser,lr_scheduler1,loss_func,40)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13",
   "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.8.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "83bec4cd18966703d39e3fd8209371b7574445e5ac2dfe27a80cb33e9b531167"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}