custom_vgg.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyP4HR2yT5TLO/MMYQU9FVVL",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/eshal26/Convolutional-Neural-Networks/blob/main/custom_vgg.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import datasets, transforms, models\n",
        "import os\n",
        "import shutil\n",
        "import sklearn\n",
        "from sklearn.model_selection import train_test_split"
      ],
      "metadata": {
        "id": "1_bISzmVjqvy"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_dir = 'train_dataset'\n",
        "val_dir = 'validation_dataset'\n",
        "test_dir = 'test_dataset'\n",
        "\n",
        "# Define transformations for training, validation, and testing data\n",
        "train_transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    transforms.RandomRotation(degrees=15),\n",
        "    transforms.RandomVerticalFlip(),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.8238, 0.8539, 0.9391], std=[0.1325, 0.1437, 0.0529])\n",
        "])\n",
        "\n",
        "val_test_transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.8238, 0.8539, 0.9391], std=[0.1325, 0.1437, 0.0529])\n",
        "])\n",
        "\n",
        "# Create datasets\n",
        "train_dataset = datasets.ImageFolder(root=train_dir, transform=train_transform)\n",
        "val_dataset = datasets.ImageFolder(root=val_dir, transform=val_test_transform)\n",
        "test_dataset = datasets.ImageFolder(root=test_dir, transform=val_test_transform)\n",
        "\n",
        "# Create data loaders\n",
        "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
        "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n",
        "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)\n"
      ],
      "metadata": {
        "id": "4DIkXvDHjxm5"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "class CustomVGG(nn.Module):\n",
        "    def __init__(self, num_classes=2):\n",
        "        super(CustomVGG, self).__init__()\n",
        "\n",
        "        self.features = nn.Sequential(\n",
        "            nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),  # Output: 112x112x64\n",
        "\n",
        "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),  # Output: 56x56x128\n",
        "        )\n",
        "\n",
        "        self.classifier = nn.Sequential(\n",
        "            nn.Dropout(p=0.5),\n",
        "            nn.Linear(128 * 56 * 56, 512),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Dropout(p=0.5),\n",
        "            nn.Linear(512, num_classes)\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.features(x)\n",
        "        x = x.view(x.size(0), -1)  # Flatten\n",
        "        x = self.classifier(x)\n",
        "        return x\n",
        "\n",
        "# Instantiate the model\n",
        "model = CustomVGG(num_classes=2)\n",
        "print(model)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZSlWAkAPjzrL",
        "outputId": "5ab9e038-dfe0-4b0d-c84d-9886d271ace5"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CustomVGG(\n",
            "  (features): Sequential(\n",
            "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (1): ReLU(inplace=True)\n",
            "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (4): ReLU(inplace=True)\n",
            "    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "  )\n",
            "  (classifier): Sequential(\n",
            "    (0): Dropout(p=0.5, inplace=False)\n",
            "    (1): Linear(in_features=401408, out_features=512, bias=True)\n",
            "    (2): ReLU(inplace=True)\n",
            "    (3): Dropout(p=0.5, inplace=False)\n",
            "    (4): Linear(in_features=512, out_features=2, bias=True)\n",
            "  )\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "from collections import Counter\n",
        "import numpy as np\n",
        "\n",
        "all_labels = [label for _, label in train_dataset]\n",
        "all_labels = np.array(all_labels)\n",
        "\n",
        "\n",
        "unique_labels, counts = np.unique(all_labels, return_counts=True)\n",
        "print(f\"Unique Labels: {unique_labels}\")\n",
        "print(f\"Counts: {counts}\")\n",
        "\n",
        "# Calculate class weights\n",
        "num_samples = len(all_labels)\n",
        "num_classes = len(unique_labels)\n",
        "class_counts = Counter(all_labels)\n",
        "class_weights = {class_id: num_samples / (num_classes * count) for class_id, count in class_counts.items()}\n",
        "class_weights_tensor = torch.tensor([class_weights[i] for i in range(num_classes)], dtype=torch.float32)\n",
        "\n",
        "print(f\"Class Weights: {class_weights}\")\n",
        "print(f\"Class Weights Tensor: {class_weights_tensor}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5ojIEPDRj1vA",
        "outputId": "7b7b86e9-1b60-4e7a-e2e6-aa94d45ac74c"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Unique Labels: [0 1]\n",
            "Counts: [ 403 2201]\n",
            "Class Weights: {0: 3.230769230769231, 1: 0.5915492957746479}\n",
            "Class Weights Tensor: tensor([3.2308, 0.5915])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "model = model.to(device)\n",
        "\n",
        "criterion = nn.CrossEntropyLoss(weight=class_weights_tensor.to(device))\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)"
      ],
      "metadata": {
        "id": "McNwhCmYj-6d"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "train_accuracies = []\n",
        "val_accuracies = []\n",
        "\n",
        "num_epochs = 30\n",
        "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5)\n",
        "\n",
        "# Training loop\n",
        "for epoch in range(num_epochs):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    correct_train = 0\n",
        "    total_train = 0\n",
        "\n",
        "    for images, labels in train_loader:\n",
        "        images, labels = images.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item() * images.size(0)\n",
        "\n",
        "        _, predicted = torch.max(outputs, 1)\n",
        "        total_train += labels.size(0)\n",
        "        correct_train += (predicted == labels).sum().item()\n",
        "\n",
        "    epoch_loss = running_loss / len(train_loader.dataset)\n",
        "    train_losses.append(epoch_loss)\n",
        "    train_accuracy = 100 * correct_train / total_train\n",
        "    train_accuracies.append(train_accuracy)\n",
        "\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    correct_val = 0\n",
        "    total_val = 0\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for images, labels in val_loader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "            val_loss += loss.item() * images.size(0)\n",
        "            _, predicted = torch.max(outputs, 1)\n",
        "            total_val += labels.size(0)\n",
        "            correct_val += (predicted == labels).sum().item()\n",
        "\n",
        "    val_loss = val_loss / len(val_loader.dataset)\n",
        "    val_losses.append(val_loss)\n",
        "    val_accuracy = 100 * correct_val / total_val\n",
        "    val_accuracies.append(val_accuracy)\n",
        "\n",
        "    # Step the scheduler\n",
        "    scheduler.step()\n",
        "\n",
        "    print(f\"Epoch {epoch+1}/{num_epochs}, \"\n",
        "          f\"Training Loss: {epoch_loss:.4f}, \"\n",
        "          f\"Training Accuracy: {train_accuracy:.2f}%, \"\n",
        "          f\"Validation Loss: {val_loss:.4f}, \"\n",
        "          f\"Validation Accuracy: {val_accuracy:.2f}%\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "80kaIcvNkBse",
        "outputId": "3a00cc80-c6bc-4dfc-bf35-05848e4164c7"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30, Training Loss: 1.1198, Training Accuracy: 68.70%, Validation Loss: 0.4500, Validation Accuracy: 78.77%\n",
            "Epoch 2/30, Training Loss: 0.4274, Training Accuracy: 79.80%, Validation Loss: 0.2721, Validation Accuracy: 89.23%\n",
            "Epoch 3/30, Training Loss: 0.3249, Training Accuracy: 89.36%, Validation Loss: 0.3360, Validation Accuracy: 85.23%\n",
            "Epoch 4/30, Training Loss: 0.2503, Training Accuracy: 92.36%, Validation Loss: 0.1674, Validation Accuracy: 94.15%\n",
            "Epoch 5/30, Training Loss: 0.1941, Training Accuracy: 94.12%, Validation Loss: 0.2862, Validation Accuracy: 86.15%\n",
            "Epoch 6/30, Training Loss: 0.1554, Training Accuracy: 95.55%, Validation Loss: 0.1018, Validation Accuracy: 96.92%\n",
            "Epoch 7/30, Training Loss: 0.1347, Training Accuracy: 96.43%, Validation Loss: 0.1843, Validation Accuracy: 92.62%\n",
            "Epoch 8/30, Training Loss: 0.1108, Training Accuracy: 97.08%, Validation Loss: 0.0978, Validation Accuracy: 97.23%\n",
            "Epoch 9/30, Training Loss: 0.1041, Training Accuracy: 97.12%, Validation Loss: 0.1255, Validation Accuracy: 94.77%\n",
            "Epoch 10/30, Training Loss: 0.0870, Training Accuracy: 97.27%, Validation Loss: 0.0588, Validation Accuracy: 98.15%\n",
            "Epoch 11/30, Training Loss: 0.0766, Training Accuracy: 97.93%, Validation Loss: 0.0608, Validation Accuracy: 98.46%\n",
            "Epoch 12/30, Training Loss: 0.0709, Training Accuracy: 97.81%, Validation Loss: 0.0597, Validation Accuracy: 98.15%\n",
            "Epoch 13/30, Training Loss: 0.0686, Training Accuracy: 98.00%, Validation Loss: 0.0845, Validation Accuracy: 96.31%\n",
            "Epoch 14/30, Training Loss: 0.0715, Training Accuracy: 97.43%, Validation Loss: 0.0482, Validation Accuracy: 98.46%\n",
            "Epoch 15/30, Training Loss: 0.0677, Training Accuracy: 97.81%, Validation Loss: 0.0696, Validation Accuracy: 96.92%\n",
            "Epoch 16/30, Training Loss: 0.0572, Training Accuracy: 98.16%, Validation Loss: 0.0683, Validation Accuracy: 97.54%\n",
            "Epoch 17/30, Training Loss: 0.0578, Training Accuracy: 98.00%, Validation Loss: 0.0630, Validation Accuracy: 97.54%\n",
            "Epoch 18/30, Training Loss: 0.0561, Training Accuracy: 98.23%, Validation Loss: 0.0828, Validation Accuracy: 96.31%\n",
            "Epoch 19/30, Training Loss: 0.0495, Training Accuracy: 98.39%, Validation Loss: 0.0517, Validation Accuracy: 97.85%\n",
            "Epoch 20/30, Training Loss: 0.0514, Training Accuracy: 98.04%, Validation Loss: 0.0533, Validation Accuracy: 98.15%\n",
            "Epoch 21/30, Training Loss: 0.0550, Training Accuracy: 98.20%, Validation Loss: 0.0479, Validation Accuracy: 98.15%\n",
            "Epoch 22/30, Training Loss: 0.0480, Training Accuracy: 98.23%, Validation Loss: 0.0472, Validation Accuracy: 98.46%\n",
            "Epoch 23/30, Training Loss: 0.0468, Training Accuracy: 98.39%, Validation Loss: 0.0434, Validation Accuracy: 99.08%\n",
            "Epoch 24/30, Training Loss: 0.0460, Training Accuracy: 98.46%, Validation Loss: 0.0426, Validation Accuracy: 98.46%\n",
            "Epoch 25/30, Training Loss: 0.0487, Training Accuracy: 98.46%, Validation Loss: 0.0407, Validation Accuracy: 99.38%\n",
            "Epoch 26/30, Training Loss: 0.0496, Training Accuracy: 98.43%, Validation Loss: 0.0431, Validation Accuracy: 99.38%\n",
            "Epoch 27/30, Training Loss: 0.0485, Training Accuracy: 98.62%, Validation Loss: 0.0456, Validation Accuracy: 98.46%\n",
            "Epoch 28/30, Training Loss: 0.0481, Training Accuracy: 98.50%, Validation Loss: 0.0452, Validation Accuracy: 98.46%\n",
            "Epoch 29/30, Training Loss: 0.0484, Training Accuracy: 98.43%, Validation Loss: 0.0430, Validation Accuracy: 98.77%\n",
            "Epoch 30/30, Training Loss: 0.0441, Training Accuracy: 98.46%, Validation Loss: 0.0392, Validation Accuracy: 99.38%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.figure(figsize=(12, 5))\n",
        "\n",
        "# Plotting loss curves\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(range(1, num_epochs + 1), train_losses, label='Training Loss')\n",
        "plt.plot(range(1, num_epochs + 1), val_losses, label='Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Loss Curves')\n",
        "plt.legend()\n",
        "\n",
        "# Plotting accuracy curves\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(range(1, num_epochs + 1), train_accuracies, label='Training Accuracy')\n",
        "plt.plot(range(1, num_epochs + 1), val_accuracies, label='Validation Accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy (%)')\n",
        "plt.title('Accuracy Curves')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "id": "TU2LTHYUnT6N",
        "outputId": "145e6aad-30b2-430d-da82-6a17f3bd2adc"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, classification_report, precision_score, recall_score, f1_score, accuracy_score\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def evaluate_model(model, dataloader, criterion, device):\n",
        "    model.eval()\n",
        "    test_loss = 0.0\n",
        "    all_labels = []\n",
        "    all_preds = []\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for inputs, labels in dataloader:\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "\n",
        "            # Get the predicted labels\n",
        "            _, preds = torch.max(outputs, 1)\n",
        "\n",
        "            # Convert predictions and labels to numpy for metrics calculation\n",
        "            all_labels.extend(labels.cpu().numpy())\n",
        "            all_preds.extend(preds.cpu().numpy())\n",
        "\n",
        "            # Compute loss\n",
        "            loss = criterion(outputs, labels)\n",
        "            test_loss += loss.item() * inputs.size(0)\n",
        "\n",
        "    # Compute average test loss\n",
        "    test_loss /= len(dataloader.dataset)\n",
        "\n",
        "    # Calculate metrics\n",
        "    accuracy = accuracy_score(all_labels, all_preds)\n",
        "    precision = precision_score(all_labels, all_preds, average='weighted')\n",
        "    recall = recall_score(all_labels, all_preds, average='weighted')\n",
        "    f1 = f1_score(all_labels, all_preds, average='weighted')\n",
        "\n",
        "    print(f'Test Loss: {test_loss:.4f}')\n",
        "    print(f'Test Accuracy: {accuracy:.4f}')\n",
        "    print(f'Test Precision: {precision:.4f}')\n",
        "    print(f'Test Recall: {recall:.4f}')\n",
        "    print(f'Test F1-score: {f1:.4f}')\n",
        "\n",
        "    # Compute confusion matrix\n",
        "    cm = confusion_matrix(all_labels, all_preds)\n",
        "    print(\"Confusion Matrix:\\n\", cm)\n",
        "\n",
        "    # Plot confusion matrix\n",
        "    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Class 0', 'Class 1'])\n",
        "    disp.plot(cmap=plt.cm.Blues)\n",
        "    plt.show()\n",
        "\n",
        "    # Print classification report\n",
        "    class_report = classification_report(all_labels, all_preds, target_names=['Class 0', 'Class 1'])\n",
        "    print(\"Classification Report:\\n\", class_report)\n",
        "\n",
        "    return test_loss, accuracy, precision, recall, f1, cm, class_report\n",
        "\n",
        "test_loss, test_accuracy, test_precision, test_recall, test_f1, cm, class_report = evaluate_model(model, test_loader, criterion, device)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 761
        },
        "id": "PpUdPsk2nUj6",
        "outputId": "c2d9004d-1bf2-45d1-f80c-fc904c5c57d0"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Loss: 0.0617\n",
            "Test Accuracy: 0.9847\n",
            "Test Precision: 0.9854\n",
            "Test Recall: 0.9847\n",
            "Test F1-score: 0.9849\n",
            "Confusion Matrix:\n",
            " [[ 50   1]\n",
            " [  4 272]]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "     Class 0       0.93      0.98      0.95        51\n",
            "     Class 1       1.00      0.99      0.99       276\n",
            "\n",
            "    accuracy                           0.98       327\n",
            "   macro avg       0.96      0.98      0.97       327\n",
            "weighted avg       0.99      0.98      0.98       327\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "eNqi0aFLnW_d"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}