Code.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "95b46a12-1cd2-4ac1-8849-2e5a360bce13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/bin/bash: line 1: conda: command not found\n",
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Requirement already satisfied: ftfy in /home/cshah/.local/lib/python3.10/site-packages (6.1.3)\n",
      "Requirement already satisfied: regex in /home/cshah/.local/lib/python3.10/site-packages (2023.12.25)\n",
      "Requirement already satisfied: tqdm in /home/cshah/.local/lib/python3.10/site-packages (4.66.2)\n",
      "Requirement already satisfied: wcwidth<0.3.0,>=0.2.12 in /home/cshah/.local/lib/python3.10/site-packages (from ftfy) (0.2.13)\n",
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Collecting git+https://github.com/openai/CLIP.git\n",
      "  Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-7ebp4yen\n",
      "  Running command git clone --filter=blob:none --quiet https://github.com/openai/CLIP.git /tmp/pip-req-build-7ebp4yen\n",
      "  Resolved https://github.com/openai/CLIP.git to commit a1d071733d7111c9c014f024669f959182114e33\n",
      "  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25hRequirement already satisfied: ftfy in /home/cshah/.local/lib/python3.10/site-packages (from clip==1.0) (6.1.3)\n",
      "Requirement already satisfied: regex in /home/cshah/.local/lib/python3.10/site-packages (from clip==1.0) (2023.12.25)\n",
      "Requirement already satisfied: torch in /home/cshah/.local/lib/python3.10/site-packages (from clip==1.0) (2.2.0)\n",
      "Requirement already satisfied: torchvision in /home/cshah/.local/lib/python3.10/site-packages (from clip==1.0) (0.17.0)\n",
      "Requirement already satisfied: tqdm in /home/cshah/.local/lib/python3.10/site-packages (from clip==1.0) (4.66.2)\n",
      "Requirement already satisfied: wcwidth<0.3.0,>=0.2.12 in /home/cshah/.local/lib/python3.10/site-packages (from ftfy->clip==1.0) (0.2.13)\n",
      "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (11.0.2.54)\n",
      "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (12.1.105)\n",
      "Requirement already satisfied: networkx in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (3.2.1)\n",
      "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (12.1.105)\n",
      "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (12.1.105)\n",
      "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (12.1.3.1)\n",
      "Requirement already satisfied: nvidia-nccl-cu12==2.19.3 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (2.19.3)\n",
      "Requirement already satisfied: jinja2 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (3.1.3)\n",
      "Requirement already satisfied: sympy in /usr/lib/python3/dist-packages (from torch->clip==1.0) (1.9)\n",
      "Requirement already satisfied: fsspec in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (2024.2.0)\n",
      "Requirement already satisfied: filelock in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (3.13.1)\n",
      "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (11.4.5.107)\n",
      "Requirement already satisfied: triton==2.2.0 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (2.2.0)\n",
      "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (8.9.2.26)\n",
      "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (12.1.105)\n",
      "Requirement already satisfied: typing-extensions>=4.8.0 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (4.9.0)\n",
      "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (12.1.0.106)\n",
      "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /home/cshah/.local/lib/python3.10/site-packages (from torch->clip==1.0) (10.3.2.106)\n",
      "Requirement already satisfied: nvidia-nvjitlink-cu12 in /home/cshah/.local/lib/python3.10/site-packages (from nvidia-cusolver-cu12==11.4.5.107->torch->clip==1.0) (12.3.101)\n",
      "Requirement already satisfied: numpy in /home/cshah/.local/lib/python3.10/site-packages (from torchvision->clip==1.0) (1.24.0)\n",
      "Requirement already satisfied: requests in /home/cshah/.local/lib/python3.10/site-packages (from torchvision->clip==1.0) (2.31.0)\n",
      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/lib/python3/dist-packages (from torchvision->clip==1.0) (9.0.1)\n",
      "Requirement already satisfied: MarkupSafe>=2.0 in /home/cshah/.local/lib/python3.10/site-packages (from jinja2->torch->clip==1.0) (2.1.4)\n",
      "Requirement already satisfied: charset-normalizer<4,>=2 in /home/cshah/.local/lib/python3.10/site-packages (from requests->torchvision->clip==1.0) (3.3.2)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /usr/lib/python3/dist-packages (from requests->torchvision->clip==1.0) (2020.6.20)\n",
      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/lib/python3/dist-packages (from requests->torchvision->clip==1.0) (1.26.5)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /usr/lib/python3/dist-packages (from requests->torchvision->clip==1.0) (3.3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_4875/2139800475.py:18: DeprecationWarning: \n",
      "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n",
      "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n",
      "but was not found to be installed on your system.\n",
      "If this would cause problems for you,\n",
      "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n",
      "        \n",
      "  import pandas as pd\n"
     ]
    }
   ],
   "source": [
    "# Setting Up Everything\n",
    "! conda install --yes -c pytorch pytorch=1.7.1 torchvision cudatoolkit=11.0\n",
    "! pip install ftfy regex tqdm\n",
    "! pip install git+https://github.com/openai/CLIP.git\n",
    "\n",
    "import os\n",
    "import torch\n",
    "import torchvision\n",
    "from torchvision import datasets, transforms\n",
    "from torchvision.transforms import ToTensor, Compose, Resize, Normalize\n",
    "import matplotlib.pyplot as plt\n",
    "import clip\n",
    "from transformers import CLIPProcessor, CLIPModel\n",
    "from PIL import Image\n",
    "from torch import nn\n",
    "from tqdm import tqdm\n",
    "import random\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from torch.utils.data import Dataset, DataLoader\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "838789a7-1803-49bd-b633-6c6865c22143",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['RN50',\n",
       " 'RN101',\n",
       " 'RN50x4',\n",
       " 'RN50x16',\n",
       " 'RN50x64',\n",
       " 'ViT-B/32',\n",
       " 'ViT-B/16',\n",
       " 'ViT-L/14',\n",
       " 'ViT-L/14@336px']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Displaying all available models in Clip\n",
    "clip.available_models()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7a4ca047-ee64-4b40-985a-9bc4c2afea32",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-18 19:40:12.972862: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2024-02-18 19:40:12.972944: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2024-02-18 19:40:12.996179: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2024-02-18 19:40:13.045695: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-02-18 19:40:13.860033: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model parameters: 151,277,313\n",
      "Input resolution: 224\n",
      "Context length: 77\n",
      "Vocab size: 49408\n"
     ]
    }
   ],
   "source": [
    "# Selecting the Device\n",
    "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "# Load the Model\n",
    "model = CLIPModel.from_pretrained(\"openai/clip-vit-base-patch32\")\n",
    "processor = CLIPProcessor.from_pretrained(\"openai/clip-vit-base-patch32\")\n",
    "\n",
    "model, preprocess = clip.load(\"ViT-B/32\", device=device, jit=False)\n",
    "\n",
    "# Printing the model size and parameters\n",
    "input_resolution = model.visual.input_resolution\n",
    "context_length = model.context_length\n",
    "vocab_size = model.vocab_size\n",
    "\n",
    "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n",
    "print(\"Input resolution:\", input_resolution)\n",
    "print(\"Context length:\", context_length)\n",
    "print(\"Vocab size:\", vocab_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2f3c9643-0e17-4b77-a1e1-a761682c6063",
   "metadata": {},
   "outputs": [],
   "source": [
    "allImagesPathsandTexts = []\n",
    "\n",
    "# Path to data directory\n",
    "dataDir = \"/home/cshah/workspaces/Deep Learning/DL Project/data/256_ObjectCategories/\"\n",
    "\n",
    "# Loading the Data and saving it in the right format\n",
    "for file in os.listdir(dataDir):\n",
    "\n",
    "    dotInFileName = os.path.basename(file).rfind(\".\")\n",
    "    if dotInFileName == 0:\n",
    "        continue\n",
    "    name = os.path.basename(file)[dotInFileName+1:]\n",
    "    filePath = os.path.join(dataDir, os.path.basename(file))\n",
    "\n",
    "    for fileImages in [fileImages for fileImages in os.listdir(filePath) if fileImages.endswith(\".jpg\")]:\n",
    "        \n",
    "        allImagesPathsandTexts.append((os.path.join(filePath, fileImages),name))\n",
    "        \n",
    "# Define a custom dataset nad data preprocessing\n",
    "class imageDataset():\n",
    "    def __init__(self, imagePathsAndlstTxts):\n",
    "        # Initialize image paths and corresponding texts\n",
    "\n",
    "        imagePathList = [pair[0] for pair in imagePathsAndlstTxts]\n",
    "        txtList = [pair[1] for pair in imagePathsAndlstTxts]\n",
    "        self.imagePaths = imagePathList\n",
    "        # Tokenize text using CLIP's tokenizer\n",
    "        self.title  = clip.tokenize(txtList)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.title)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        # Preprocess image using CLIP's preprocessing function\n",
    "        imageReturn = preprocess(Image.open(self.imagePaths[idx]))\n",
    "        title = self.title[idx]\n",
    "        return imageReturn, title\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "924daa0d-417c-4fc6-b3cd-675c8408706d",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Parameters\n",
    "batch_size = 8\n",
    "\n",
    "# Splitting into training(80%) and Validation Sets(20%)\n",
    "trainingDataPer = 30; \n",
    "trainDataLen = int(len(allImagesPathsandTexts) * trainingDataPer / 100)\n",
    "validationDataPer = 5;\n",
    "validationDataLen = int(len(allImagesPathsandTexts) * validationDataPer / 100)\n",
    "\n",
    "# Shuffle the dataset\n",
    "random.shuffle(allImagesPathsandTexts)\n",
    "\n",
    "# Setting up the dataset\n",
    "# Training Dataset\n",
    "trainingDataset = imageDataset(allImagesPathsandTexts[0:trainDataLen][:])\n",
    "trainDatasetLoader = DataLoader(trainingDataset, batch_size=batch_size, shuffle=True, num_workers=8)\n",
    "\n",
    "# Validation Dataset\n",
    "validationDataset = imageDataset(allImagesPathsandTexts[len(allImagesPathsandTexts)-validationDataLen:len(allImagesPathsandTexts)][:])\n",
    "validationDatasetLoader = DataLoader(validationDataset, batch_size=batch_size, shuffle=False, num_workers=8)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "251f7279-3c19-4312-8760-f763b1c35461",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_models_to_fp32(model): \n",
    "    for p in model.parameters(): \n",
    "        p.data = p.data.float() \n",
    "        p.grad.data = p.grad.data.float() \n",
    "\n",
    "# Check if the device is set to CPU\n",
    "if device == \"cpu\":\n",
    "    model.float()  # Convert the model's parameters to float if using CPU\n",
    "\n",
    "# Prepare the optimizer\n",
    "optimizer = torch.optim.Adam(\n",
    "    model.parameters(), lr=5e-5, betas=(0.9, 0.98), eps=1e-6 ,weight_decay=0.2) \n",
    "\n",
    "# Specify the loss function for images\n",
    "lossImg = nn.CrossEntropyLoss()\n",
    "\n",
    "# Specify the loss function for text\n",
    "lossTxt = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "19138989-e32b-4af3-8dbb-8dbc0ade209a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model Evaluation\n",
    "def evaluateModel(model, dataLoader, device):\n",
    "    model.eval()\n",
    "    correctPredictions = 0\n",
    "    total = 0\n",
    "    with torch.no_grad():\n",
    "        for batch in dataLoader:\n",
    "            features, labels = batch\n",
    "            \n",
    "            features = features.to(device)\n",
    "            labels = labels.to(device)\n",
    "\n",
    "            # Calculate Logit and prob\n",
    "            logitsPerImage, logitsPerText = model(features, labels)\n",
    "\n",
    "            # Ground Truth\n",
    "            groundTruth = torch.arange(len(features), dtype=torch.long, device=device)\n",
    "\n",
    "            # Take argmax of logits\n",
    "            argMaxImages = torch.argmax(logitsPerImage, dim=1);\n",
    "            argMaxText = torch.argmax(logitsPerText, dim=0);\n",
    "\n",
    "            # Calculate accuracy\n",
    "            compareImages = (argMaxImages == groundTruth);\n",
    "            compareTexts = (argMaxImages == groundTruth);\n",
    "            correctPredictions += (torch.sum(compareImages).item() + torch.sum(compareTexts).item())/2\n",
    "                         \n",
    "            total += labels.size(0)\n",
    "        \n",
    "    accuracy = 100 * correctPredictions / total\n",
    "    return accuracy\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "76123901-f910-46a6-bbb5-b846d1a36ef2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 0/100, Loss: 1.0566: 100%|██████████████| 230/230 [00:22<00:00, 10.19it/s]\n",
      "Epoch 1/100, Loss: 1.3252: 100%|██████████████| 230/230 [00:19<00:00, 11.66it/s]\n",
      "Epoch 2/100, Loss: 1.3652: 100%|██████████████| 230/230 [00:19<00:00, 11.62it/s]\n",
      "Epoch 3/100, Loss: 1.3301: 100%|██████████████| 230/230 [00:19<00:00, 11.60it/s]\n",
      "Epoch 4/100, Loss: 0.9570: 100%|██████████████| 230/230 [00:19<00:00, 11.64it/s]\n",
      "Epoch 5/100, Loss: 1.3887: 100%|██████████████| 230/230 [00:19<00:00, 11.60it/s]\n",
      "Epoch 6/100, Loss: 1.2090: 100%|██████████████| 230/230 [00:19<00:00, 11.60it/s]\n",
      "Epoch 7/100, Loss: 1.2793: 100%|██████████████| 230/230 [00:19<00:00, 11.57it/s]\n",
      "Epoch 8/100, Loss: 1.3926: 100%|██████████████| 230/230 [00:19<00:00, 11.60it/s]\n",
      "Epoch 9/100, Loss: 1.3721: 100%|██████████████| 230/230 [00:19<00:00, 11.56it/s]\n",
      "Epoch 10/100, Loss: 1.2188: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 11/100, Loss: 1.2793: 100%|█████████████| 230/230 [00:19<00:00, 11.57it/s]\n",
      "Epoch 12/100, Loss: 1.4434: 100%|█████████████| 230/230 [00:19<00:00, 11.52it/s]\n",
      "Epoch 13/100, Loss: 1.3887: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 14/100, Loss: 1.4043: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 15/100, Loss: 1.1680: 100%|█████████████| 230/230 [00:19<00:00, 11.57it/s]\n",
      "Epoch 16/100, Loss: 0.7666: 100%|█████████████| 230/230 [00:19<00:00, 11.52it/s]\n",
      "Epoch 17/100, Loss: 1.3789: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 18/100, Loss: 1.4551: 100%|█████████████| 230/230 [00:19<00:00, 11.58it/s]\n",
      "Epoch 19/100, Loss: 1.1201: 100%|█████████████| 230/230 [00:19<00:00, 11.56it/s]\n",
      "Epoch 20/100, Loss: 1.8145: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 21/100, Loss: 0.9395: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 22/100, Loss: 0.8901: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 23/100, Loss: 1.1670: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 24/100, Loss: 1.4238: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 25/100, Loss: 0.7520: 100%|█████████████| 230/230 [00:19<00:00, 11.60it/s]\n",
      "Epoch 26/100, Loss: 0.8428: 100%|█████████████| 230/230 [00:19<00:00, 11.56it/s]\n",
      "Epoch 27/100, Loss: 1.3340: 100%|█████████████| 230/230 [00:19<00:00, 11.59it/s]\n",
      "Epoch 28/100, Loss: 0.9590: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 29/100, Loss: 0.7773: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 30/100, Loss: 1.6465: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 31/100, Loss: 1.3789: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 32/100, Loss: 1.4160: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 33/100, Loss: 1.5371: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 34/100, Loss: 1.4453: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 35/100, Loss: 0.8398: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 36/100, Loss: 0.8901: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 37/100, Loss: 0.7588: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 38/100, Loss: 1.1309: 100%|█████████████| 230/230 [00:19<00:00, 11.58it/s]\n",
      "Epoch 39/100, Loss: 1.0176: 100%|█████████████| 230/230 [00:19<00:00, 11.58it/s]\n",
      "Epoch 40/100, Loss: 0.8809: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 41/100, Loss: 0.8975: 100%|█████████████| 230/230 [00:19<00:00, 11.51it/s]\n",
      "Epoch 42/100, Loss: 0.8589: 100%|█████████████| 230/230 [00:19<00:00, 11.59it/s]\n",
      "Epoch 43/100, Loss: 0.9414: 100%|█████████████| 230/230 [00:19<00:00, 11.51it/s]\n",
      "Epoch 44/100, Loss: 1.5020: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 45/100, Loss: 1.0293: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 46/100, Loss: 0.8848: 100%|█████████████| 230/230 [00:20<00:00, 11.47it/s]\n",
      "Epoch 47/100, Loss: 0.9678: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 48/100, Loss: 1.5352: 100%|█████████████| 230/230 [00:20<00:00, 11.48it/s]\n",
      "Epoch 49/100, Loss: 0.9502: 100%|█████████████| 230/230 [00:19<00:00, 11.57it/s]\n",
      "Epoch 50/100, Loss: 1.1904: 100%|█████████████| 230/230 [00:20<00:00, 11.23it/s]\n",
      "Epoch 51/100, Loss: 1.1387: 100%|█████████████| 230/230 [00:20<00:00, 11.37it/s]\n",
      "Epoch 52/100, Loss: 1.4434: 100%|█████████████| 230/230 [00:20<00:00, 11.43it/s]\n",
      "Epoch 53/100, Loss: 1.3438: 100%|█████████████| 230/230 [00:20<00:00, 11.45it/s]\n",
      "Epoch 54/100, Loss: 1.2705: 100%|█████████████| 230/230 [00:20<00:00, 11.47it/s]\n",
      "Epoch 55/100, Loss: 0.7988: 100%|█████████████| 230/230 [00:20<00:00, 11.40it/s]\n",
      "Epoch 56/100, Loss: 1.5371: 100%|█████████████| 230/230 [00:20<00:00, 11.42it/s]\n",
      "Epoch 57/100, Loss: 0.7930: 100%|█████████████| 230/230 [00:20<00:00, 11.42it/s]\n",
      "Epoch 58/100, Loss: 1.2021: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 59/100, Loss: 0.5957: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 60/100, Loss: 0.6963: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 61/100, Loss: 1.4746: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 62/100, Loss: 0.7861: 100%|█████████████| 230/230 [00:19<00:00, 11.56it/s]\n",
      "Epoch 63/100, Loss: 0.7378: 100%|█████████████| 230/230 [00:19<00:00, 11.56it/s]\n",
      "Epoch 64/100, Loss: 0.4294: 100%|█████████████| 230/230 [00:20<00:00, 11.44it/s]\n",
      "Epoch 65/100, Loss: 0.7505: 100%|█████████████| 230/230 [00:20<00:00, 11.50it/s]\n",
      "Epoch 66/100, Loss: 1.3916: 100%|█████████████| 230/230 [00:19<00:00, 11.52it/s]\n",
      "Epoch 67/100, Loss: 0.8721: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 68/100, Loss: 1.0400: 100%|█████████████| 230/230 [00:19<00:00, 11.52it/s]\n",
      "Epoch 69/100, Loss: 0.7852: 100%|█████████████| 230/230 [00:20<00:00, 11.45it/s]\n",
      "Epoch 70/100, Loss: 1.0762: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 71/100, Loss: 0.9482: 100%|█████████████| 230/230 [00:19<00:00, 11.52it/s]\n",
      "Epoch 72/100, Loss: 0.9126: 100%|█████████████| 230/230 [00:19<00:00, 11.56it/s]\n",
      "Epoch 73/100, Loss: 0.9814: 100%|█████████████| 230/230 [00:19<00:00, 11.50it/s]\n",
      "Epoch 74/100, Loss: 0.6875: 100%|█████████████| 230/230 [00:19<00:00, 11.56it/s]\n",
      "Epoch 75/100, Loss: 0.8618: 100%|█████████████| 230/230 [00:20<00:00, 11.50it/s]\n",
      "Epoch 76/100, Loss: 0.9121: 100%|█████████████| 230/230 [00:20<00:00, 11.49it/s]\n",
      "Epoch 77/100, Loss: 1.0430: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 78/100, Loss: 1.1260: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 79/100, Loss: 0.3115: 100%|█████████████| 230/230 [00:19<00:00, 11.51it/s]\n",
      "Epoch 80/100, Loss: 1.0322: 100%|█████████████| 230/230 [00:19<00:00, 11.60it/s]\n",
      "Epoch 81/100, Loss: 0.9565: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 82/100, Loss: 0.8423: 100%|█████████████| 230/230 [00:20<00:00, 11.48it/s]\n",
      "Epoch 83/100, Loss: 1.0723: 100%|█████████████| 230/230 [00:19<00:00, 11.52it/s]\n",
      "Epoch 84/100, Loss: 0.4746: 100%|█████████████| 230/230 [00:19<00:00, 11.50it/s]\n",
      "Epoch 85/100, Loss: 1.3105: 100%|█████████████| 230/230 [00:19<00:00, 11.50it/s]\n",
      "Epoch 86/100, Loss: 0.6289: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 87/100, Loss: 0.6787: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 88/100, Loss: 0.7148: 100%|█████████████| 230/230 [00:19<00:00, 11.57it/s]\n",
      "Epoch 89/100, Loss: 1.4395: 100%|█████████████| 230/230 [00:19<00:00, 11.54it/s]\n",
      "Epoch 90/100, Loss: 0.5791: 100%|█████████████| 230/230 [00:19<00:00, 11.52it/s]\n",
      "Epoch 91/100, Loss: 1.1426: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 92/100, Loss: 0.9209: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 93/100, Loss: 0.5156: 100%|█████████████| 230/230 [00:19<00:00, 11.53it/s]\n",
      "Epoch 94/100, Loss: 0.4741: 100%|█████████████| 230/230 [00:19<00:00, 11.51it/s]\n",
      "Epoch 95/100, Loss: 1.5088: 100%|█████████████| 230/230 [00:19<00:00, 11.55it/s]\n",
      "Epoch 96/100, Loss: 3.0781: 100%|█████████████| 230/230 [00:19<00:00, 11.56it/s]\n",
      "Epoch 97/100, Loss: 0.5435: 100%|█████████████| 230/230 [00:19<00:00, 11.56it/s]\n",
      "Epoch 98/100, Loss: 0.5933: 100%|█████████████| 230/230 [00:19<00:00, 11.52it/s]\n",
      "Epoch 99/100, Loss: 0.8662: 100%|█████████████| 230/230 [00:20<00:00, 11.45it/s]\n"
     ]
    }
   ],
   "source": [
    "# Model Training\n",
    "trainingLoss = []\n",
    "whileTrainAcc = []\n",
    "\n",
    "num_epochs = 100\n",
    "for epoch in range(num_epochs):\n",
    "    totalLossValue = 0\n",
    "    pbar = tqdm(trainDatasetLoader, total=len(trainDatasetLoader))\n",
    "    for batch in pbar:\n",
    "        optimizer.zero_grad()\n",
    "        images,texts = batch \n",
    "        images= images.to(device)\n",
    "        texts = texts.to(device)\n",
    "\n",
    "        \n",
    "        logitsPerImage, logitsPerText = model(images, texts)\n",
    "\n",
    "        groundTruth = torch.arange(len(images), dtype=torch.long, device=device)\n",
    "        totalLoss = (lossImg(logitsPerImage, groundTruth) + lossTxt(logitsPerText, groundTruth)) / 2\n",
    "\n",
    "        # Backward pass and update the model's parameters\n",
    "        totalLoss.backward()\n",
    "        \n",
    "        # If the device is CPU, directly update the model\n",
    "        if device == \"cpu\":\n",
    "            optimizer.step()\n",
    "        else:\n",
    "            # Convert model's parameters to FP32 format, update, and convert back\n",
    "            convert_models_to_fp32(model)\n",
    "            optimizer.step()\n",
    "            clip.model.convert_weights(model)\n",
    "\n",
    "        # Update the progress bar with the current epoch and loss\n",
    "        pbar.set_description(f\"Epoch {epoch}/{num_epochs}, Loss: {totalLoss.item():.4f}\")\n",
    "        totalLossValue += totalLoss.item()\n",
    "\n",
    "    # Storing the loss\n",
    "    trainingLoss.append(totalLossValue/len(pbar))\n",
    "    # Storing the accuracy\n",
    "    midAcc = evaluateModel(model, validationDatasetLoader, device)\n",
    "    whileTrainAcc.append(midAcc)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5beda0d3-d118-497c-8ca7-5a8b6f60a157",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# trainingLoss1 = [(8/230) * x for x in trainingLoss]\n",
    "# Plotting a Curve below\n",
    "x = np.linspace(0, num_epochs-1, num_epochs-1)\n",
    "\n",
    "# Create a figure and two subplots side by side\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))  # figsize=(width, height) in inches\n",
    "\n",
    "# Plot on the first subplot (left)\n",
    "ax1.plot(x, trainingLoss[1:], color='blue')\n",
    "ax1.set_xlabel('Number of Epochs')\n",
    "ax1.set_ylabel('Training Loss')\n",
    "ax1.set_title('Loss vs Number of Epochs')\n",
    "ax1.legend()\n",
    "\n",
    "# Plot on the second subplot (right)\n",
    "ax2.plot(x, whileTrainAcc[1:], color='red')\n",
    "ax2.set_xlabel('Number of Epochs')\n",
    "ax2.set_ylabel('Accuracy (%)')\n",
    "ax2.set_title('Accuracy vs Number of Epochs')\n",
    "ax2.legend()\n",
    "\n",
    "# Adjust layout\n",
    "plt.tight_layout()\n",
    "\n",
    "# Show plot\n",
    "plt.show()"
   ]
  }
 ],
 "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}