resnet_2fc.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyOYsC/Xivh71rPoB/VwWFmS",
      "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/resnet_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": 10,
      "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": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "class BasicBlock(nn.Module):\n",
        "    def __init__(self, in_channels, out_channels):\n",
        "        super(BasicBlock, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=False)\n",
        "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
        "\n",
        "        # Adjust shortcut to match dimensions if needed\n",
        "        if in_channels != out_channels:\n",
        "            self.shortcut = nn.Sequential(\n",
        "                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),\n",
        "                nn.BatchNorm2d(out_channels)\n",
        "            )\n",
        "        else:\n",
        "            self.shortcut = nn.Identity()\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = self.conv1(x)\n",
        "        out = self.bn1(out)\n",
        "        out = self.relu(out)\n",
        "        out = self.conv2(out)\n",
        "        out = self.bn2(out)\n",
        "        shortcut = self.shortcut(x)\n",
        "        out += shortcut\n",
        "        out = self.relu(out)\n",
        "        return out\n",
        "\n",
        "class SimpleResNet(nn.Module):\n",
        "    def __init__(self, num_classes=2):\n",
        "        super(SimpleResNet, self).__init__()\n",
        "\n",
        "        # First Residual Block\n",
        "        self.layer1 = BasicBlock(3, 64)\n",
        "\n",
        "        # Second Residual Block\n",
        "        self.layer2 = BasicBlock(64, 128)\n",
        "\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.dropout1 = nn.Dropout(p=0.5)\n",
        "        self.dropout2 = nn.Dropout(p=0.5)\n",
        "\n",
        "        # Pooling and Fully Connected Layers\n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "        self.fc1 = nn.Linear(128, 32)       # Adjusted input features to match 128 channels\n",
        "        self.fc2 = nn.Linear(32, num_classes)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.layer1(x)\n",
        "        x = self.layer2(x)\n",
        "        x = self.dropout1(x)\n",
        "\n",
        "        x = self.avgpool(x)\n",
        "        x = torch.flatten(x, 1)  # Flatten\n",
        "        x = self.fc1(x)\n",
        "        x = self.relu(x)         # Apply ReLU after first FC layer\n",
        "        x = self.dropout2(x)\n",
        "        x = self.fc2(x)\n",
        "        return x\n",
        "\n",
        "model = SimpleResNet(num_classes=2)\n",
        "print(model)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-3yk2qwUFpef",
        "outputId": "64cb1fce-6b5c-45f4-cfba-b6ad1d4ea636"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SimpleResNet(\n",
            "  (layer1): BasicBlock(\n",
            "    (conv1): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    (relu): ReLU(inplace=True)\n",
            "    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "    (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    (shortcut): Sequential(\n",
            "      (0): Conv2d(3, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
            "      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    )\n",
            "  )\n",
            "  (layer2): BasicBlock(\n",
            "    (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "    (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    (relu): ReLU(inplace=True)\n",
            "    (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "    (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    (shortcut): Sequential(\n",
            "      (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
            "      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    )\n",
            "  )\n",
            "  (relu): ReLU(inplace=True)\n",
            "  (dropout1): Dropout(p=0.5, inplace=False)\n",
            "  (dropout2): Dropout(p=0.5, inplace=False)\n",
            "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
            "  (fc1): Linear(in_features=128, 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": "73a652bb-0d8e-4c14-a982-91560a1df5e3"
      },
      "execution_count": 13,
      "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": 14,
      "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": "2c3a128a-7938-426c-b3b6-5c8b6dd2e2f9"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/40, Training Loss: 0.5220, Validation Loss: 0.4263, Validation Accuracy: 88.92%\n",
            "Epoch 2/40, Training Loss: 0.3824, Validation Loss: 0.3213, Validation Accuracy: 92.62%\n",
            "Epoch 3/40, Training Loss: 0.3117, Validation Loss: 0.2139, Validation Accuracy: 96.62%\n",
            "Epoch 4/40, Training Loss: 0.2622, Validation Loss: 0.1946, Validation Accuracy: 96.62%\n",
            "Epoch 5/40, Training Loss: 0.2324, Validation Loss: 0.2156, Validation Accuracy: 94.46%\n",
            "Epoch 6/40, Training Loss: 0.1983, Validation Loss: 0.1078, Validation Accuracy: 97.85%\n",
            "Epoch 7/40, Training Loss: 0.1933, Validation Loss: 0.1410, Validation Accuracy: 96.92%\n",
            "Epoch 8/40, Training Loss: 0.1561, Validation Loss: 0.1266, Validation Accuracy: 96.31%\n",
            "Epoch 9/40, Training Loss: 0.1402, Validation Loss: 0.0733, Validation Accuracy: 98.77%\n",
            "Epoch 10/40, Training Loss: 0.1322, Validation Loss: 0.1088, Validation Accuracy: 96.62%\n",
            "Epoch 11/40, Training Loss: 0.1169, Validation Loss: 0.0694, Validation Accuracy: 97.23%\n",
            "Epoch 12/40, Training Loss: 0.1283, Validation Loss: 0.0429, Validation Accuracy: 99.08%\n",
            "Epoch 13/40, Training Loss: 0.1098, Validation Loss: 0.0374, Validation Accuracy: 99.38%\n",
            "Epoch 14/40, Training Loss: 0.1127, Validation Loss: 0.0391, Validation Accuracy: 99.38%\n",
            "Epoch 15/40, Training Loss: 0.0880, Validation Loss: 0.0298, Validation Accuracy: 99.69%\n",
            "Epoch 16/40, Training Loss: 0.0880, Validation Loss: 0.0627, Validation Accuracy: 97.85%\n",
            "Epoch 17/40, Training Loss: 0.0761, Validation Loss: 0.0385, Validation Accuracy: 98.46%\n",
            "Epoch 18/40, Training Loss: 0.1260, Validation Loss: 0.0393, Validation Accuracy: 99.08%\n",
            "Epoch 19/40, Training Loss: 0.0858, Validation Loss: 0.0572, Validation Accuracy: 97.85%\n",
            "Epoch 20/40, Training Loss: 0.0724, Validation Loss: 0.0226, Validation Accuracy: 100.00%\n",
            "Epoch 21/40, Training Loss: 0.0609, Validation Loss: 0.0345, Validation Accuracy: 99.08%\n",
            "Epoch 22/40, Training Loss: 0.0669, Validation Loss: 0.0606, Validation Accuracy: 96.92%\n",
            "Epoch 23/40, Training Loss: 0.0639, Validation Loss: 0.0324, Validation Accuracy: 98.77%\n",
            "Epoch 24/40, Training Loss: 0.0660, Validation Loss: 0.0330, Validation Accuracy: 99.38%\n",
            "Epoch 25/40, Training Loss: 0.0581, Validation Loss: 0.0223, Validation Accuracy: 99.38%\n",
            "Epoch 26/40, Training Loss: 0.0636, Validation Loss: 0.0190, Validation Accuracy: 100.00%\n",
            "Epoch 27/40, Training Loss: 0.0486, Validation Loss: 0.0247, Validation Accuracy: 99.08%\n",
            "Epoch 28/40, Training Loss: 0.0615, Validation Loss: 0.0398, Validation Accuracy: 98.15%\n",
            "Epoch 29/40, Training Loss: 0.0531, Validation Loss: 0.0324, Validation Accuracy: 99.08%\n",
            "Epoch 30/40, Training Loss: 0.0568, Validation Loss: 0.0231, Validation Accuracy: 99.08%\n",
            "Epoch 31/40, Training Loss: 0.0492, Validation Loss: 0.0338, Validation Accuracy: 98.46%\n",
            "Epoch 32/40, Training Loss: 0.0579, Validation Loss: 0.0205, Validation Accuracy: 99.08%\n",
            "Epoch 33/40, Training Loss: 0.0431, Validation Loss: 0.0296, Validation Accuracy: 99.08%\n",
            "Epoch 34/40, Training Loss: 0.0428, Validation Loss: 0.0128, Validation Accuracy: 100.00%\n",
            "Epoch 35/40, Training Loss: 0.0501, Validation Loss: 0.0142, Validation Accuracy: 100.00%\n",
            "Epoch 36/40, Training Loss: 0.0500, Validation Loss: 0.0157, Validation Accuracy: 99.38%\n",
            "Epoch 37/40, Training Loss: 0.0437, Validation Loss: 0.0262, Validation Accuracy: 99.38%\n",
            "Epoch 38/40, Training Loss: 0.0442, Validation Loss: 0.0329, Validation Accuracy: 98.15%\n",
            "Epoch 39/40, Training Loss: 0.0406, Validation Loss: 0.0418, Validation Accuracy: 98.15%\n",
            "Epoch 40/40, Training Loss: 0.0520, Validation Loss: 0.0129, Validation Accuracy: 100.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": 348
        },
        "id": "txwkXW1JGhYz",
        "outputId": "b051d21f-d3de-476d-8423-43fdf46b5dd3"
      },
      "execution_count": 16,
      "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": "2aa5c4c0-6744-43e5-8993-0f37a4d63213"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Loss: 0.0327\n",
            "Test Accuracy: 0.9908\n",
            "Test Precision: 0.9909\n",
            "Test Recall: 0.9908\n",
            "Test F1-score: 0.9909\n",
            "Confusion Matrix:\n",
            " [[ 50   1]\n",
            " [  2 274]]\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.96      0.98      0.97        51\n",
            "     Class 1       1.00      0.99      0.99       276\n",
            "\n",
            "    accuracy                           0.99       327\n",
            "   macro avg       0.98      0.99      0.98       327\n",
            "weighted avg       0.99      0.99      0.99       327\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bSF8QULkKARD",
        "outputId": "bc799fc4-3a03-4742-e946-65e915358360"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.save(model, '/content/drive/MyDrive/custom_resnet_2fc.pth')"
      ],
      "metadata": {
        "id": "GSORvOq8KVnG"
      },
      "execution_count": 21,
      "outputs": []
    }
  ]
}