xception_2fc.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyP7pG/EQ5jUkUf6mu0h6yaJ",
      "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/xception_2fc.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#importing necessary libraries\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F\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\n"
      ],
      "metadata": {
        "id": "_JiGXT2pFka8"
      },
      "execution_count": 36,
      "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.RandomVerticalFlip(),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean = [0.8245, 0.8547, 0.9387], std = [0.1323, 0.1431, 0.0530])\n",
        "])\n",
        "\n",
        "val_test_transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean = [0.8245, 0.8547, 0.9387], std = [0.1323, 0.1431, 0.0530])\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)"
      ],
      "metadata": {
        "id": "xmGk_RSQFnIe"
      },
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "class DepthwiseSeparableConv(nn.Module):\n",
        "    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):\n",
        "        super(DepthwiseSeparableConv, self).__init__()\n",
        "        self.depthwise = nn.Conv2d(in_channels, in_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=in_channels)\n",
        "        self.pointwise = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.depthwise(x)\n",
        "        x = self.pointwise(x)\n",
        "        return x\n",
        "\n",
        "class SimplifiedXception(nn.Module):\n",
        "    def __init__(self, num_classes=2):\n",
        "        super(SimplifiedXception, self).__init__()\n",
        "        self.flow = nn.Sequential(\n",
        "            DepthwiseSeparableConv(3, 64, kernel_size=3, stride=2, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.BatchNorm2d(64),\n",
        "            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
        "        )\n",
        "\n",
        "        # Dropout layers\n",
        "        self.dropout1 = nn.Dropout(p=0.5)\n",
        "        self.dropout2 = nn.Dropout(p=0.5)\n",
        "\n",
        "        # Adaptive pooling to fix the output size\n",
        "        self.adaptive_pool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "\n",
        "        # Fully connected layers\n",
        "        self.fc1 = nn.Linear(in_features=64, out_features=32)  # First FC layer with 32 units\n",
        "        self.fc2 = nn.Linear(in_features=32, out_features=num_classes)  # Second FC layer for final output\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.flow(x)\n",
        "        x = self.dropout1(x)\n",
        "\n",
        "        # Adaptive pooling and flattening\n",
        "        x = self.adaptive_pool(x)\n",
        "        x = torch.flatten(x, 1)  # Flatten the tensor\n",
        "\n",
        "        # Pass through the fully connected layers with ReLU activation\n",
        "        x = self.fc1(x)\n",
        "        x = nn.ReLU()(x)\n",
        "        x = self.dropout2(x)\n",
        "        x = self.fc2(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "model = SimplifiedXception(num_classes=2).to(device)\n",
        "\n",
        "print(model)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-3yk2qwUFpef",
        "outputId": "a084b040-b316-4915-8862-80fe4ea115a7"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SimplifiedXception(\n",
            "  (flow): Sequential(\n",
            "    (0): DepthwiseSeparableConv(\n",
            "      (depthwise): Conv2d(3, 3, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=3)\n",
            "      (pointwise): Conv2d(3, 64, kernel_size=(1, 1), stride=(1, 1))\n",
            "    )\n",
            "    (1): ReLU()\n",
            "    (2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
            "  )\n",
            "  (dropout1): Dropout(p=0.5, inplace=False)\n",
            "  (dropout2): Dropout(p=0.5, inplace=False)\n",
            "  (adaptive_pool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
            "  (fc1): Linear(in_features=64, out_features=32, bias=True)\n",
            "  (fc2): Linear(in_features=32, out_features=2, bias=True)\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "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": "lBgfqj5bFsHF",
        "outputId": "54f7bf8d-9c7c-46bb-ec4a-eb1ac30eb777"
      },
      "execution_count": 39,
      "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": [
        "from torch.optim import lr_scheduler\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "model = model.to(device)\n",
        "criterion = nn.CrossEntropyLoss(weight=class_weights_tensor.to(device))\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n"
      ],
      "metadata": {
        "id": "4GKsmlK8Fuoq"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "num_epochs = 40\n",
        "\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "train_accuracies = []\n",
        "val_accuracies = []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    correct = 0\n",
        "    total = 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",
        "        _, predicted = torch.max(outputs, 1)\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "\n",
        "    train_loss = running_loss / len(train_loader.dataset)\n",
        "    train_accuracy = 100 * correct / total\n",
        "    train_losses.append(train_loss)\n",
        "    train_accuracies.append(train_accuracy)\n",
        "\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    correct = 0\n",
        "    total = 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 += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "\n",
        "    val_loss = val_loss / len(val_loader.dataset)\n",
        "    val_accuracy = 100 * correct / total\n",
        "    val_losses.append(val_loss)\n",
        "    val_accuracies.append(val_accuracy)\n",
        "\n",
        "    print(f\"Epoch {epoch+1}/{num_epochs}, \"\n",
        "          f\"Training Loss: {train_loss:.4f}, \"\n",
        "          f\"Validation Loss: {val_loss:.4f}, \"\n",
        "          f\"Validation Accuracy: {val_accuracy:.2f}%\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4qqyyxOYFwt9",
        "outputId": "67d7bf81-17d0-46d1-cffa-5ba6c68ebc42"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/40, Training Loss: 0.7078, Validation Loss: 0.6439, Validation Accuracy: 59.38%\n",
            "Epoch 2/40, Training Loss: 0.6636, Validation Loss: 0.6383, Validation Accuracy: 52.00%\n",
            "Epoch 3/40, Training Loss: 0.6326, Validation Loss: 0.6151, Validation Accuracy: 65.23%\n",
            "Epoch 4/40, Training Loss: 0.6073, Validation Loss: 0.5944, Validation Accuracy: 71.08%\n",
            "Epoch 5/40, Training Loss: 0.5779, Validation Loss: 0.5907, Validation Accuracy: 69.54%\n",
            "Epoch 6/40, Training Loss: 0.5578, Validation Loss: 0.5500, Validation Accuracy: 76.62%\n",
            "Epoch 7/40, Training Loss: 0.5404, Validation Loss: 0.5463, Validation Accuracy: 75.38%\n",
            "Epoch 8/40, Training Loss: 0.5327, Validation Loss: 0.5078, Validation Accuracy: 79.08%\n",
            "Epoch 9/40, Training Loss: 0.5177, Validation Loss: 0.5083, Validation Accuracy: 78.77%\n",
            "Epoch 10/40, Training Loss: 0.4996, Validation Loss: 0.4974, Validation Accuracy: 78.77%\n",
            "Epoch 11/40, Training Loss: 0.4818, Validation Loss: 0.4750, Validation Accuracy: 80.31%\n",
            "Epoch 12/40, Training Loss: 0.4816, Validation Loss: 0.4670, Validation Accuracy: 80.31%\n",
            "Epoch 13/40, Training Loss: 0.4746, Validation Loss: 0.4543, Validation Accuracy: 80.62%\n",
            "Epoch 14/40, Training Loss: 0.4607, Validation Loss: 0.4352, Validation Accuracy: 82.77%\n",
            "Epoch 15/40, Training Loss: 0.4405, Validation Loss: 0.4216, Validation Accuracy: 83.38%\n",
            "Epoch 16/40, Training Loss: 0.4325, Validation Loss: 0.4288, Validation Accuracy: 82.46%\n",
            "Epoch 17/40, Training Loss: 0.4191, Validation Loss: 0.4127, Validation Accuracy: 82.77%\n",
            "Epoch 18/40, Training Loss: 0.4144, Validation Loss: 0.4092, Validation Accuracy: 82.77%\n",
            "Epoch 19/40, Training Loss: 0.4030, Validation Loss: 0.3796, Validation Accuracy: 85.23%\n",
            "Epoch 20/40, Training Loss: 0.3988, Validation Loss: 0.3738, Validation Accuracy: 85.54%\n",
            "Epoch 21/40, Training Loss: 0.3827, Validation Loss: 0.3559, Validation Accuracy: 85.23%\n",
            "Epoch 22/40, Training Loss: 0.3782, Validation Loss: 0.3534, Validation Accuracy: 85.23%\n",
            "Epoch 23/40, Training Loss: 0.3618, Validation Loss: 0.3492, Validation Accuracy: 85.23%\n",
            "Epoch 24/40, Training Loss: 0.3550, Validation Loss: 0.3315, Validation Accuracy: 86.15%\n",
            "Epoch 25/40, Training Loss: 0.3590, Validation Loss: 0.3190, Validation Accuracy: 87.08%\n",
            "Epoch 26/40, Training Loss: 0.3388, Validation Loss: 0.3149, Validation Accuracy: 86.77%\n",
            "Epoch 27/40, Training Loss: 0.3483, Validation Loss: 0.3120, Validation Accuracy: 87.08%\n",
            "Epoch 28/40, Training Loss: 0.3271, Validation Loss: 0.3043, Validation Accuracy: 87.38%\n",
            "Epoch 29/40, Training Loss: 0.3212, Validation Loss: 0.3079, Validation Accuracy: 86.46%\n",
            "Epoch 30/40, Training Loss: 0.3146, Validation Loss: 0.2818, Validation Accuracy: 90.15%\n",
            "Epoch 31/40, Training Loss: 0.3023, Validation Loss: 0.2815, Validation Accuracy: 89.85%\n",
            "Epoch 32/40, Training Loss: 0.3059, Validation Loss: 0.2785, Validation Accuracy: 89.85%\n",
            "Epoch 33/40, Training Loss: 0.2974, Validation Loss: 0.2812, Validation Accuracy: 89.54%\n",
            "Epoch 34/40, Training Loss: 0.2906, Validation Loss: 0.2698, Validation Accuracy: 89.85%\n",
            "Epoch 35/40, Training Loss: 0.2838, Validation Loss: 0.2610, Validation Accuracy: 89.85%\n",
            "Epoch 36/40, Training Loss: 0.2740, Validation Loss: 0.2598, Validation Accuracy: 89.85%\n",
            "Epoch 37/40, Training Loss: 0.2755, Validation Loss: 0.2485, Validation Accuracy: 90.15%\n",
            "Epoch 38/40, Training Loss: 0.2550, Validation Loss: 0.2223, Validation Accuracy: 92.00%\n",
            "Epoch 39/40, Training Loss: 0.2544, Validation Loss: 0.2328, Validation Accuracy: 90.15%\n",
            "Epoch 40/40, Training Loss: 0.2484, Validation Loss: 0.2112, Validation Accuracy: 92.00%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.figure(figsize=(12, 4))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(range(num_epochs), train_losses, label='Training Loss')\n",
        "plt.plot(range(num_epochs), val_losses, label='Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(range(num_epochs), train_accuracies, label='Training Accuracy')\n",
        "plt.plot(range(num_epochs), val_accuracies, label='Validation Accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 349
        },
        "id": "txwkXW1JGhYz",
        "outputId": "b1411fc4-2c4a-4b33-f335-d018b1ac5457"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x400 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, classification_report, precision_score, recall_score, f1_score, accuracy_score\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",
        "    cm = confusion_matrix(all_labels, all_preds)\n",
        "    print(\"Confusion Matrix:\\n\", cm)\n",
        "\n",
        "    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Class 0', 'Class 1'])\n",
        "    disp.plot(cmap=plt.cm.Blues)\n",
        "    plt.show()\n",
        "\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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 761
        },
        "id": "qKc1XmFGJ9vx",
        "outputId": "bdbd99a4-e2cc-4764-cbc5-6dfbb3412f82"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Loss: 0.2707\n",
            "Test Accuracy: 0.8930\n",
            "Test Precision: 0.9216\n",
            "Test Recall: 0.8930\n",
            "Test F1-score: 0.9010\n",
            "Confusion Matrix:\n",
            " [[ 46   5]\n",
            " [ 30 246]]\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.61      0.90      0.72        51\n",
            "     Class 1       0.98      0.89      0.93       276\n",
            "\n",
            "    accuracy                           0.89       327\n",
            "   macro avg       0.79      0.90      0.83       327\n",
            "weighted avg       0.92      0.89      0.90       327\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.save(model, '/content/drive/MyDrive/custom_xception_2fc.pth')"
      ],
      "metadata": {
        "id": "GSORvOq8KVnG"
      },
      "execution_count": 45,
      "outputs": []
    }
  ]
}