clipnaturetraining.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cN2rsaCpcYNC",
        "outputId": "11db48a7-6c96-4ecf-ae25-1eb3f43cf22e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ],
      "source": [
        "# needed to import dataset from google drive into colab\n",
        "from google.colab import drive\n",
        "drive.mount(\"/content/gdrive\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cd gdrive"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s33b5qrPcnzj",
        "outputId": "435b7db9-6cfa-4e65-d90f-953b984f4568"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/gdrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cd MyDrive"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q-OvvWRTc3s_",
        "outputId": "5af93814-83c2-4624-e80e-d29f593f96cb"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/gdrive/MyDrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pip install git+https://github.com/openai/CLIP.git"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Bnkuzurc_dU",
        "outputId": "03f8329a-f5a0-4403-c2a6-6c365a41b4a0"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting git+https://github.com/openai/CLIP.git\n",
            "  Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-xghezaon\n",
            "  Running command git clone --filter=blob:none --quiet https://github.com/openai/CLIP.git /tmp/pip-req-build-xghezaon\n",
            "  Resolved https://github.com/openai/CLIP.git to commit a1d071733d7111c9c014f024669f959182114e33\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Collecting ftfy (from clip==1.0)\n",
            "  Downloading ftfy-6.1.1-py3-none-any.whl (53 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m53.1/53.1 kB\u001b[0m \u001b[31m1.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.10/dist-packages (from clip==1.0) (2023.6.3)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from clip==1.0) (4.66.1)\n",
            "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (from clip==1.0) (2.0.1+cu118)\n",
            "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (from clip==1.0) (0.15.2+cu118)\n",
            "Requirement already satisfied: wcwidth>=0.2.5 in /usr/local/lib/python3.10/dist-packages (from ftfy->clip==1.0) (0.2.6)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch->clip==1.0) (3.12.2)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch->clip==1.0) (4.7.1)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch->clip==1.0) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch->clip==1.0) (3.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch->clip==1.0) (3.1.2)\n",
            "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.10/dist-packages (from torch->clip==1.0) (2.0.0)\n",
            "Requirement already satisfied: cmake in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch->clip==1.0) (3.27.2)\n",
            "Requirement already satisfied: lit in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch->clip==1.0) (16.0.6)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision->clip==1.0) (1.23.5)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from torchvision->clip==1.0) (2.31.0)\n",
            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision->clip==1.0) (9.4.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch->clip==1.0) (2.1.3)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision->clip==1.0) (3.2.0)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision->clip==1.0) (3.4)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision->clip==1.0) (2.0.4)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->torchvision->clip==1.0) (2023.7.22)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch->clip==1.0) (1.3.0)\n",
            "Building wheels for collected packages: clip\n",
            "  Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369497 sha256=6bea2e681d6fc66fa85e42c8347a12e5be1254e1c578d2294037cc0862cf761b\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-bih3a9uv/wheels/da/2b/4c/d6691fa9597aac8bb85d2ac13b112deb897d5b50f5ad9a37e4\n",
            "Successfully built clip\n",
            "Installing collected packages: ftfy, clip\n",
            "Successfully installed clip-1.0 ftfy-6.1.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import cv2\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, Dataset\n",
        "from torchvision import transforms\n",
        "import clip\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
        "from sklearn.model_selection import train_test_split"
      ],
      "metadata": {
        "id": "JADCT01mc7RG"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "cnn_data_folder = 'cnn_dataset'"
      ],
      "metadata": {
        "id": "bumYHpvJdJnP"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 7: Load and Preprocess Images for Nature Classification\n",
        "class ImageDataset(Dataset):\n",
        "    def __init__(self, data_folder, transform=None):\n",
        "        self.data_folder = data_folder\n",
        "        self.transform = transform\n",
        "        self.images, self.labels = self.load_images()\n",
        "\n",
        "    def load_images(self):\n",
        "        images = []\n",
        "        labels = []\n",
        "        for class_label, class_name in enumerate(os.listdir(self.data_folder)):\n",
        "            class_folder = os.path.join(self.data_folder, class_name)\n",
        "            if not os.path.isdir(class_folder):\n",
        "                continue\n",
        "            for file_name in os.listdir(class_folder):\n",
        "                file_path = os.path.join(class_folder, file_name)\n",
        "                image = cv2.imread(file_path)\n",
        "                image = cv2.resize(image, (224, 224))  # Resize image to fit CLIP model input shape\n",
        "                label = class_label\n",
        "                images.append(image)\n",
        "                labels.append(label)\n",
        "        return np.array(images), np.array(labels)\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.images)\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        image = self.images[index]\n",
        "        label = self.labels[index]\n",
        "        if self.transform:\n",
        "            image = self.transform(image)\n",
        "        return image, label"
      ],
      "metadata": {
        "id": "E5cZvhB9dR2M"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the transformation to normalize and convert image to tensor\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])\n",
        "])"
      ],
      "metadata": {
        "id": "pVmpjOU_dR5A"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the fine-tuned CLIP model and tokenizer\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "model, preprocess = clip.load('ViT-B/32', device)"
      ],
      "metadata": {
        "id": "8xsIgUdvdR8Y"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#  Split the dataset into train, validation, and test sets\n",
        "cnn_data_folder = 'cnn_dataset'\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])\n",
        "])\n",
        "dataset = ImageDataset(cnn_data_folder, transform=transform)\n",
        "\n",
        "train_ratio = 0.7\n",
        "val_ratio = 0.15\n",
        "test_ratio = 0.15\n",
        "\n",
        "num_samples = len(dataset)\n",
        "num_train = int(train_ratio * num_samples)\n",
        "num_val = int(val_ratio * num_samples)\n",
        "num_test = num_samples - num_train - num_val\n",
        "\n",
        "train_set, temp_set = train_test_split(dataset, train_size=num_train)\n",
        "val_set, test_set = train_test_split(temp_set, train_size=num_val)\n",
        "\n",
        "train_loader = DataLoader(train_set, batch_size=32, shuffle=True)\n",
        "val_loader = DataLoader(val_set, batch_size=32, shuffle=False)\n",
        "test_loader = DataLoader(test_set, batch_size=32, shuffle=False)"
      ],
      "metadata": {
        "id": "bk7ZJtbkHPNb"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8e70lcgNGzKd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the classification head\n",
        "num_classes = len(set(dataset.labels))\n",
        "classifier_head = nn.Linear(512, num_classes).to(device)"
      ],
      "metadata": {
        "id": "Pc4HDyDDdZ4o"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the optimizer and loss function\n",
        "optimizer = optim.Adam(classifier_head.parameters(), lr=0.001)\n",
        "criterion = nn.CrossEntropyLoss()"
      ],
      "metadata": {
        "id": "OfJ2jBf_eY6R"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the classification head\n",
        "num_epochs = 100\n",
        "for epoch in range(num_epochs):\n",
        "    classifier_head.train()\n",
        "    total_loss = 0.0\n",
        "    total_correct = 0\n",
        "    total_samples = 0\n",
        "\n",
        "    for images, labels in train_loader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        with torch.no_grad():\n",
        "            image_features = model.encode_image(images)\n",
        "\n",
        "        # Convert the data type of image_features to match the classifier's weight matrix\n",
        "        image_features = image_features.to(classifier_head.weight.dtype)\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        logits = classifier_head(image_features)\n",
        "\n",
        "        # Convert logits data type to torch.float32 for softmax\n",
        "        logits = logits.to(torch.float32)\n",
        "\n",
        "        loss = criterion(logits, labels)  # No need to convert labels to torch.long data type\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        total_loss += loss.item()\n",
        "        _, predicted_labels = logits.max(1)\n",
        "        total_correct += (predicted_labels == labels).sum().item()\n",
        "        total_samples += labels.size(0)\n",
        "\n",
        "    # Calculate accuracy\n",
        "    accuracy = total_correct / total_samples\n",
        "\n",
        "    print(f\"Epoch [{epoch+1}/{num_epochs}] - Loss: {total_loss:.4f} - Accuracy: {accuracy:.4f}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lFci99mWddoD",
        "outputId": "909ec061-e077-48db-e7c7-0cdde77a01ae"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/100] - Loss: 24.7738 - Accuracy: 0.7350\n",
            "Epoch [2/100] - Loss: 19.7557 - Accuracy: 0.8043\n",
            "Epoch [3/100] - Loss: 17.9082 - Accuracy: 0.8179\n",
            "Epoch [4/100] - Loss: 16.7418 - Accuracy: 0.8429\n",
            "Epoch [5/100] - Loss: 15.8821 - Accuracy: 0.8550\n",
            "Epoch [6/100] - Loss: 15.4141 - Accuracy: 0.8529\n",
            "Epoch [7/100] - Loss: 14.7263 - Accuracy: 0.8679\n",
            "Epoch [8/100] - Loss: 14.3261 - Accuracy: 0.8664\n",
            "Epoch [9/100] - Loss: 13.8878 - Accuracy: 0.8757\n",
            "Epoch [10/100] - Loss: 13.6610 - Accuracy: 0.8771\n",
            "Epoch [11/100] - Loss: 13.3734 - Accuracy: 0.8793\n",
            "Epoch [12/100] - Loss: 13.0265 - Accuracy: 0.8821\n",
            "Epoch [13/100] - Loss: 12.7824 - Accuracy: 0.8879\n",
            "Epoch [14/100] - Loss: 12.5594 - Accuracy: 0.8900\n",
            "Epoch [15/100] - Loss: 12.2828 - Accuracy: 0.8979\n",
            "Epoch [16/100] - Loss: 12.1541 - Accuracy: 0.8964\n",
            "Epoch [17/100] - Loss: 12.0887 - Accuracy: 0.8964\n",
            "Epoch [18/100] - Loss: 11.8951 - Accuracy: 0.8971\n",
            "Epoch [19/100] - Loss: 11.5670 - Accuracy: 0.9036\n",
            "Epoch [20/100] - Loss: 11.4439 - Accuracy: 0.9043\n",
            "Epoch [21/100] - Loss: 11.2599 - Accuracy: 0.9093\n",
            "Epoch [22/100] - Loss: 11.1625 - Accuracy: 0.9100\n",
            "Epoch [23/100] - Loss: 11.0349 - Accuracy: 0.9100\n",
            "Epoch [24/100] - Loss: 10.9327 - Accuracy: 0.9136\n",
            "Epoch [25/100] - Loss: 10.7295 - Accuracy: 0.9129\n",
            "Epoch [26/100] - Loss: 10.6401 - Accuracy: 0.9129\n",
            "Epoch [27/100] - Loss: 10.5184 - Accuracy: 0.9143\n",
            "Epoch [28/100] - Loss: 10.4008 - Accuracy: 0.9171\n",
            "Epoch [29/100] - Loss: 10.2697 - Accuracy: 0.9157\n",
            "Epoch [30/100] - Loss: 10.2067 - Accuracy: 0.9186\n",
            "Epoch [31/100] - Loss: 10.1119 - Accuracy: 0.9171\n",
            "Epoch [32/100] - Loss: 10.0332 - Accuracy: 0.9179\n",
            "Epoch [33/100] - Loss: 9.9543 - Accuracy: 0.9193\n",
            "Epoch [34/100] - Loss: 9.8510 - Accuracy: 0.9221\n",
            "Epoch [35/100] - Loss: 9.8125 - Accuracy: 0.9214\n",
            "Epoch [36/100] - Loss: 9.6859 - Accuracy: 0.9214\n",
            "Epoch [37/100] - Loss: 9.6481 - Accuracy: 0.9200\n",
            "Epoch [38/100] - Loss: 9.6016 - Accuracy: 0.9250\n",
            "Epoch [39/100] - Loss: 9.4690 - Accuracy: 0.9286\n",
            "Epoch [40/100] - Loss: 9.3719 - Accuracy: 0.9229\n",
            "Epoch [41/100] - Loss: 9.3448 - Accuracy: 0.9243\n",
            "Epoch [42/100] - Loss: 9.2919 - Accuracy: 0.9286\n",
            "Epoch [43/100] - Loss: 9.1996 - Accuracy: 0.9279\n",
            "Epoch [44/100] - Loss: 9.1826 - Accuracy: 0.9250\n",
            "Epoch [45/100] - Loss: 9.0516 - Accuracy: 0.9243\n",
            "Epoch [46/100] - Loss: 9.0490 - Accuracy: 0.9257\n",
            "Epoch [47/100] - Loss: 8.9592 - Accuracy: 0.9300\n",
            "Epoch [48/100] - Loss: 8.9222 - Accuracy: 0.9293\n",
            "Epoch [49/100] - Loss: 8.8212 - Accuracy: 0.9264\n",
            "Epoch [50/100] - Loss: 8.8752 - Accuracy: 0.9293\n",
            "Epoch [51/100] - Loss: 8.7343 - Accuracy: 0.9314\n",
            "Epoch [52/100] - Loss: 8.6346 - Accuracy: 0.9364\n",
            "Epoch [53/100] - Loss: 8.7203 - Accuracy: 0.9336\n",
            "Epoch [54/100] - Loss: 8.5444 - Accuracy: 0.9329\n",
            "Epoch [55/100] - Loss: 8.5946 - Accuracy: 0.9307\n",
            "Epoch [56/100] - Loss: 8.5133 - Accuracy: 0.9343\n",
            "Epoch [57/100] - Loss: 8.4316 - Accuracy: 0.9329\n",
            "Epoch [58/100] - Loss: 8.3647 - Accuracy: 0.9364\n",
            "Epoch [59/100] - Loss: 8.3738 - Accuracy: 0.9307\n",
            "Epoch [60/100] - Loss: 8.3214 - Accuracy: 0.9329\n",
            "Epoch [61/100] - Loss: 8.2448 - Accuracy: 0.9321\n",
            "Epoch [62/100] - Loss: 8.2458 - Accuracy: 0.9386\n",
            "Epoch [63/100] - Loss: 8.2806 - Accuracy: 0.9350\n",
            "Epoch [64/100] - Loss: 8.1416 - Accuracy: 0.9343\n",
            "Epoch [65/100] - Loss: 8.0934 - Accuracy: 0.9386\n",
            "Epoch [66/100] - Loss: 8.0515 - Accuracy: 0.9386\n",
            "Epoch [67/100] - Loss: 8.0050 - Accuracy: 0.9400\n",
            "Epoch [68/100] - Loss: 8.0025 - Accuracy: 0.9400\n",
            "Epoch [69/100] - Loss: 7.9757 - Accuracy: 0.9393\n",
            "Epoch [70/100] - Loss: 7.9103 - Accuracy: 0.9386\n",
            "Epoch [71/100] - Loss: 7.8716 - Accuracy: 0.9371\n",
            "Epoch [72/100] - Loss: 7.8581 - Accuracy: 0.9364\n",
            "Epoch [73/100] - Loss: 7.8252 - Accuracy: 0.9400\n",
            "Epoch [74/100] - Loss: 7.7378 - Accuracy: 0.9379\n",
            "Epoch [75/100] - Loss: 7.6947 - Accuracy: 0.9393\n",
            "Epoch [76/100] - Loss: 7.7166 - Accuracy: 0.9407\n",
            "Epoch [77/100] - Loss: 7.6775 - Accuracy: 0.9379\n",
            "Epoch [78/100] - Loss: 7.6241 - Accuracy: 0.9414\n",
            "Epoch [79/100] - Loss: 7.6134 - Accuracy: 0.9436\n",
            "Epoch [80/100] - Loss: 7.5409 - Accuracy: 0.9414\n",
            "Epoch [81/100] - Loss: 7.5537 - Accuracy: 0.9429\n",
            "Epoch [82/100] - Loss: 7.5456 - Accuracy: 0.9400\n",
            "Epoch [83/100] - Loss: 7.4668 - Accuracy: 0.9436\n",
            "Epoch [84/100] - Loss: 7.4498 - Accuracy: 0.9436\n",
            "Epoch [85/100] - Loss: 7.4166 - Accuracy: 0.9429\n",
            "Epoch [86/100] - Loss: 7.4007 - Accuracy: 0.9421\n",
            "Epoch [87/100] - Loss: 7.3771 - Accuracy: 0.9471\n",
            "Epoch [88/100] - Loss: 7.3079 - Accuracy: 0.9443\n",
            "Epoch [89/100] - Loss: 7.2984 - Accuracy: 0.9464\n",
            "Epoch [90/100] - Loss: 7.2395 - Accuracy: 0.9457\n",
            "Epoch [91/100] - Loss: 7.1527 - Accuracy: 0.9464\n",
            "Epoch [92/100] - Loss: 7.2142 - Accuracy: 0.9479\n",
            "Epoch [93/100] - Loss: 7.1505 - Accuracy: 0.9471\n",
            "Epoch [94/100] - Loss: 7.1635 - Accuracy: 0.9457\n",
            "Epoch [95/100] - Loss: 7.1560 - Accuracy: 0.9464\n",
            "Epoch [96/100] - Loss: 7.1481 - Accuracy: 0.9479\n",
            "Epoch [97/100] - Loss: 7.1496 - Accuracy: 0.9450\n",
            "Epoch [98/100] - Loss: 7.0657 - Accuracy: 0.9471\n",
            "Epoch [99/100] - Loss: 7.0047 - Accuracy: 0.9457\n",
            "Epoch [100/100] - Loss: 7.0141 - Accuracy: 0.9471\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 9: Model Evaluation for Nature Classification\n",
        "nature_pred = []\n",
        "nature_labels = []\n",
        "classifier_head.eval()\n",
        "with torch.no_grad():\n",
        "    for images, labels in train_loader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        image_features = model.encode_image(images)\n",
        "\n",
        "        # Convert the data type of image_features to match the classifier's weight matrix\n",
        "        image_features = image_features.to(classifier_head.weight.dtype)\n",
        "\n",
        "        logits = classifier_head(image_features)\n",
        "        pred = logits.argmax(dim=-1).cpu().numpy()\n",
        "        nature_pred.extend(pred)\n",
        "        nature_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "nature_accuracy = accuracy_score(nature_labels, nature_pred)\n",
        "nature_precision = precision_score(nature_labels, nature_pred, average='weighted')\n",
        "nature_recall = recall_score(nature_labels, nature_pred, average='weighted')\n",
        "nature_f1_score = f1_score(nature_labels, nature_pred, average='weighted')\n",
        "\n",
        "print(\"Nature Accuracy:\", nature_accuracy)\n",
        "print(\"Nature Precision:\", nature_precision)\n",
        "print(\"Nature Recall:\", nature_recall)\n",
        "print(\"Nature F1-score:\", nature_f1_score)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uJX7b_irddwf",
        "outputId": "ef432506-395e-4b0c-a5cc-cb523bb695f5"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nature Accuracy: 0.9492857142857143\n",
            "Nature Precision: 0.9494514443156722\n",
            "Nature Recall: 0.9492857142857143\n",
            "Nature F1-score: 0.9492867234011351\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "# Step 14: Visualize evaluation metrics\n",
        "metrics_names = ['Nature Accuracy', 'Nature Precision', 'Nature Recall', 'Nature F1-score']\n",
        "metrics_values = [nature_accuracy, nature_precision, nature_recall, nature_f1_score]\n",
        "\n",
        "plt.figure(figsize=(10, 6))\n",
        "plt.bar(metrics_names, metrics_values, color=['blue', 'green', 'orange', 'red'])\n",
        "plt.xlabel('Metrics')\n",
        "plt.ylabel('Values')\n",
        "plt.title('Evaluation Metrics for Nature Classification')\n",
        "plt.ylim(0, 1)  # Set the y-axis limits between 0 and 1\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "h0SX0r2zIbt4",
        "outputId": "5166ea31-8a46-42da-893d-f1f590f5e923"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nature_pred = []\n",
        "nature_labels = []\n",
        "classifier_head.eval()\n",
        "with torch.no_grad():\n",
        "    for images, labels in train_loader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        image_features = model.encode_image(images)\n",
        "\n",
        "        # Convert the data type of image_features to match the classifier's weight matrix\n",
        "        image_features = image_features.to(classifier_head.weight.dtype)\n",
        "\n",
        "        logits = classifier_head(image_features)\n",
        "        pred = logits.argmax(dim=-1).cpu().numpy()\n",
        "        nature_pred.extend(pred)\n",
        "        nature_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "nature_accuracy = accuracy_score(nature_labels, nature_pred)\n",
        "\n",
        "print(\"Nature Accuracy:\", nature_accuracy)\n",
        "\n",
        "# Plotting the accuracy as a bar\n",
        "plt.bar(['Nature Accuracy'], [nature_accuracy], color='blue')\n",
        "plt.xlabel('Metrics')\n",
        "plt.ylabel('Scores')\n",
        "plt.title('Nature Classification Accuracy')\n",
        "plt.ylim(0.0, 1.0)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "8a9yuAwWzV4e",
        "outputId": "34f427b1-8bff-4d06-90dd-ea0aeeab8b34"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nature Accuracy: 0.9492857142857143\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Inside the training loop\n",
        "for epoch in range(num_epochs):\n",
        "    # ... (other training code)\n",
        "\n",
        "    # Calculate accuracy\n",
        "    accuracy = total_correct / total_samples\n",
        "\n",
        "    # Append loss and accuracy to their respective lists\n",
        "    loss_values.append(total_loss)\n",
        "    accuracy_values.append(accuracy)\n",
        "\n",
        "    print(f\"Epoch [{epoch+1}/{num_epochs}] - Loss: {total_loss:.4f} - Accuracy: {accuracy:.4f}\")\n",
        "\n",
        "# After the training loop\n",
        "plt.figure(figsize=(10, 6))\n",
        "plt.plot(range(1, num_epochs+1), loss_values, label='Loss', color='red')\n",
        "plt.plot(range(1, num_epochs+1), accuracy_values, label='Accuracy', color='blue')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Value')\n",
        "plt.title('Loss and Accuracy During Training')\n",
        "plt.legend()\n",
        "plt.grid()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "OlH1GzLM22Ze",
        "outputId": "05174e1a-1f08-40f3-8f27-8d658a186c3d"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [2/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [3/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [4/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [5/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [6/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [7/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [8/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [9/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [10/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [11/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [12/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [13/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [14/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [15/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [16/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [17/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [18/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [19/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [20/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [21/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [22/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [23/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [24/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [25/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [26/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [27/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [28/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [29/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [30/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [31/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [32/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [33/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [34/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [35/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [36/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [37/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [38/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [39/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [40/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [41/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [42/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [43/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [44/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [45/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [46/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [47/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [48/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [49/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [50/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [51/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [52/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [53/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [54/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [55/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [56/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [57/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [58/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [59/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [60/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [61/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [62/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [63/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [64/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [65/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [66/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [67/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [68/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [69/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [70/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [71/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [72/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [73/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [74/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [75/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [76/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [77/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [78/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [79/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [80/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [81/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [82/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [83/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [84/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [85/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [86/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [87/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [88/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [89/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [90/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [91/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [92/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [93/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [94/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [95/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [96/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [97/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [98/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [99/100] - Loss: 7.0141 - Accuracy: 0.9471\n",
            "Epoch [100/100] - Loss: 7.0141 - Accuracy: 0.9471\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 10: Save Nature Model\n",
        "# Save the fine-tuned classifier head\n",
        "nature_model_file = 'nature--model.pt'\n",
        "torch.save(classifier_head.state_dict(), nature_model_file)\n",
        "print(\"Nature Model saved successfully.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HDDxYPHFdoti",
        "outputId": "d59b531c-169c-430b-a646-c96ba3618fad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Nature Model saved successfully.\n"
          ]
        }
      ]
    }
  ]
}