img_clfipynb.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",
      "source": [
        "pip install torch torchvision\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tKVLYZoHnPfX",
        "outputId": "549f6513-87c5-4d4d-ca27-27aacdbb091c"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.4.1+cu121)\n",
            "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (0.19.1+cu121)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.16.1)\n",
            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch) (4.12.2)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch) (1.13.3)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.3)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.4)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2024.6.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision) (1.26.4)\n",
            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision) (10.4.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (2.1.5)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->torch) (1.3.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torchvision.transforms as transforms\n",
        "import torchvision.datasets as datasets\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import models\n"
      ],
      "metadata": {
        "id": "yErBYi9enroF"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Hyperparameters\n",
        "batch_size = 32\n",
        "learning_rate = 0.001\n",
        "num_epochs = 10  # You can adjust this as needed\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n"
      ],
      "metadata": {
        "id": "LPhbbPiynwVX"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Data transformations\n",
        "transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # Normalization values for pretrained models\n",
        "])\n"
      ],
      "metadata": {
        "id": "QVO3eaCyn1CL"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load datasets\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "train_dataset = datasets.ImageFolder(root='/content/drive/MyDrive/Train', transform=transform)\n",
        "test_dataset = datasets.ImageFolder(root=r'/content/drive/MyDrive/Test', transform=transform)\n",
        "\n",
        "# Create data loaders\n",
        "train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
        "test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xkqd1sHKn3Q_",
        "outputId": "5cc3effe-c4f3-4c46-b4bb-d65d5738db0f"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load a pre-trained model\n",
        "model = models.resnet50(pretrained=True)\n",
        "\n",
        "# Modify the final layer to match the number of classes in your dataset\n",
        "num_classes = len(train_dataset.classes)  # Number of unique celebrity classes\n",
        "model.fc = nn.Linear(model.fc.in_features, num_classes)\n",
        "\n",
        "# Move the model to the specified device\n",
        "model = model.to(device)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ilGLOrj2n5pE",
        "outputId": "9ebfc809-0f69-410b-f798-273ee03a4074"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
            "  warnings.warn(msg)\n",
            "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n",
            "100%|██████████| 97.8M/97.8M [00:00<00:00, 109MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Loss function and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "#optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
        "#optimizer = optim.Adam(model.parameters(), lr=0.0001)  # Try a lower learning rate\n",
        "# Initialize the optimizer\n",
        "#optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
        "# Using SGD with momentum\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
        "\n",
        "\n",
        "\n",
        "# Learning rate scheduler\n",
        "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)  # Decrease learning rate every 5 epochs\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "YCWvWXKPrmJG"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize best validation loss for model checkpointing\n",
        "best_val_loss = float('inf')\n",
        "\n",
        "# Training loop\n",
        "for epoch in range(num_epochs):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "\n",
        "    for i, (images, labels) in enumerate(train_loader):\n",
        "        images, labels = images.to(device), labels.to(device)\n",
        "\n",
        "        optimizer.zero_grad()  # Zero the gradients\n",
        "        outputs = model(images)  # Forward pass\n",
        "        loss = criterion(outputs, labels)  # Compute loss\n",
        "        loss.backward()  # Backward pass\n",
        "        optimizer.step()  # Update weights\n",
        "\n",
        "        running_loss += loss.item()\n",
        "\n",
        "        # Optional: Print training progress every 100 batches\n",
        "        if (i + 1) % 100 == 0:\n",
        "            print(f\"Batch [{i + 1}/{len(train_loader)}], Loss: {loss.item():.4f}\")\n",
        "\n",
        "    print(f\"Epoch [{epoch + 1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}\")\n",
        "\n",
        "    # Validate the model at the end of each epoch\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for images, labels in test_loader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "            val_loss += loss.item()\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "\n",
        "    print(f\"Validation Loss: {val_loss/len(test_loader):.4f}, Accuracy: {100 * correct / total:.2f}%\")\n",
        "\n",
        "    # Checkpoint the model if validation loss improves\n",
        "    if val_loss < best_val_loss:\n",
        "        best_val_loss = val_loss\n",
        "        torch.save(model.state_dict(), 'best_model.pth')\n",
        "\n",
        "    # Update learning rate\n",
        "    scheduler.step()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_MmFc5iKrvYG",
        "outputId": "f3700da5-b9e4-44ac-8f47-47b3efedd85f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/10], Loss: 0.4353\n",
            "Validation Loss: 1.9292, Accuracy: 57.06%\n",
            "Epoch [2/10], Loss: 0.3962\n",
            "Validation Loss: 1.9468, Accuracy: 53.03%\n",
            "Epoch [3/10], Loss: 0.1527\n",
            "Validation Loss: 1.5186, Accuracy: 61.96%\n",
            "Epoch [4/10], Loss: 0.3519\n",
            "Validation Loss: 1.7566, Accuracy: 59.08%\n",
            "Epoch [5/10], Loss: 0.3727\n",
            "Validation Loss: 1.8158, Accuracy: 60.23%\n",
            "Epoch [6/10], Loss: 0.1294\n",
            "Validation Loss: 0.8283, Accuracy: 75.50%\n",
            "Epoch [7/10], Loss: 0.0420\n",
            "Validation Loss: 0.8182, Accuracy: 76.08%\n",
            "Epoch [8/10], Loss: 0.0280\n",
            "Validation Loss: 0.8198, Accuracy: 75.79%\n",
            "Epoch [9/10], Loss: 0.0171\n",
            "Validation Loss: 0.8052, Accuracy: 74.64%\n",
            "Epoch [10/10], Loss: 0.0235\n",
            "Validation Loss: 0.8092, Accuracy: 75.22%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize best validation loss for model checkpointing\n",
        "best_val_loss = float('inf')\n",
        "\n",
        "# Training loop\n",
        "for epoch in range(num_epochs):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "\n",
        "    for i, (images, labels) in enumerate(train_loader):\n",
        "        images, labels = images.to(device), labels.to(device)\n",
        "\n",
        "        optimizer.zero_grad()  # Zero the gradients\n",
        "        outputs = model(images)  # Forward pass\n",
        "        loss = criterion(outputs, labels)  # Compute loss\n",
        "        loss.backward()  # Backward pass\n",
        "        optimizer.step()  # Update weights\n",
        "\n",
        "        running_loss += loss.item()\n",
        "\n",
        "        # Optional: Print training progress every 100 batches\n",
        "        if (i + 1) % 100 == 0:\n",
        "            print(f\"Batch [{i + 1}/{len(train_loader)}], Loss: {loss.item():.4f}\")\n",
        "\n",
        "    print(f\"Epoch [{epoch + 1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}\")\n",
        "\n",
        "    # Validate the model at the end of each epoch\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for images, labels in test_loader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "            val_loss += loss.item()\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "\n",
        "    print(f\"Validation Loss: {val_loss/len(test_loader):.4f}, Accuracy: {100 * correct / total:.2f}%\")\n",
        "\n",
        "    # Checkpoint the model if validation loss improves\n",
        "    if val_loss < best_val_loss:\n",
        "        best_val_loss = val_loss\n",
        "        torch.save(model.state_dict(), 'best_model.pth')\n",
        "\n",
        "    # Update learning rate\n",
        "    scheduler.step()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y-5r7uGlr6cS",
        "outputId": "b02b6e41-dc16-4c7d-bf34-a52accf7ece8"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/10], Loss: 0.8722\n",
            "Validation Loss: 1.5539, Accuracy: 55.04%\n",
            "Epoch [2/10], Loss: 0.4115\n",
            "Validation Loss: 1.0478, Accuracy: 65.71%\n",
            "Epoch [3/10], Loss: 0.1837\n",
            "Validation Loss: 1.3196, Accuracy: 68.59%\n",
            "Epoch [4/10], Loss: 0.1674\n",
            "Validation Loss: 1.4253, Accuracy: 66.86%\n",
            "Epoch [5/10], Loss: 0.0611\n",
            "Validation Loss: 0.6597, Accuracy: 80.69%\n",
            "Epoch [6/10], Loss: 0.0157\n",
            "Validation Loss: 0.6109, Accuracy: 79.83%\n",
            "Epoch [7/10], Loss: 0.0108\n",
            "Validation Loss: 0.6151, Accuracy: 79.54%\n",
            "Epoch [8/10], Loss: 0.0100\n",
            "Validation Loss: 0.5893, Accuracy: 80.69%\n",
            "Epoch [9/10], Loss: 0.0113\n",
            "Validation Loss: 0.5947, Accuracy: 82.13%\n",
            "Epoch [10/10], Loss: 0.0062\n",
            "Validation Loss: 0.5873, Accuracy: 80.98%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# To load the model later\n",
        "model.load_state_dict(torch.load('best_model.pth'))\n",
        "model.eval()  # Set the model to evaluation mode\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m2LQ7s2B4pGU",
        "outputId": "9cd8a001-da8e-4236-80d6-e05adc785264"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-10-064669419721>:2: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
            "  model.load_state_dict(torch.load('best_model.pth'))\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ResNet(\n",
              "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
              "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (relu): ReLU(inplace=True)\n",
              "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
              "  (layer1): Sequential(\n",
              "    (0): Bottleneck(\n",
              "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): Bottleneck(\n",
              "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (2): Bottleneck(\n",
              "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "  )\n",
              "  (layer2): Sequential(\n",
              "    (0): Bottleneck(\n",
              "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): Bottleneck(\n",
              "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (2): Bottleneck(\n",
              "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (3): Bottleneck(\n",
              "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "  )\n",
              "  (layer3): Sequential(\n",
              "    (0): Bottleneck(\n",
              "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (2): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (3): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (4): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (5): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "  )\n",
              "  (layer4): Sequential(\n",
              "    (0): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): Bottleneck(\n",
              "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (2): Bottleneck(\n",
              "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "  )\n",
              "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
              "  (fc): Linear(in_features=2048, out_features=17, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import classification_report, confusion_matrix\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# Get predictions\n",
        "all_labels = []\n",
        "all_preds = []\n",
        "\n",
        "with torch.no_grad():\n",
        "    for images, labels in test_loader:\n",
        "        images, labels = images.to(device), labels.to(device)\n",
        "        outputs = model(images)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        all_labels.extend(labels.cpu().numpy())\n",
        "        all_preds.extend(predicted.cpu().numpy())\n",
        "\n",
        "# Classification report\n",
        "print(classification_report(all_labels, all_preds))\n",
        "\n",
        "# Confusion Matrix\n",
        "cm = confusion_matrix(all_labels, all_preds)\n",
        "plt.figure(figsize=(10, 8))\n",
        "sns.heatmap(cm, annot=True, fmt='d')\n",
        "plt.title('Confusion Matrix')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('True')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "hNP1LabN6tYP",
        "outputId": "dc6aa4d2-5a0c-4b8e-edf1-49cf5b49652c"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.71      0.79      0.75        19\n",
            "           1       0.86      0.67      0.75        18\n",
            "           2       0.80      0.80      0.80        20\n",
            "           3       0.78      0.90      0.84        20\n",
            "           4       0.94      0.75      0.83        20\n",
            "           5       0.94      0.79      0.86        19\n",
            "           6       0.71      0.60      0.65        20\n",
            "           7       0.80      0.80      0.80        20\n",
            "           8       0.95      0.95      0.95        19\n",
            "           9       0.65      0.68      0.67        19\n",
            "          10       0.70      0.84      0.76        19\n",
            "          11       0.83      0.75      0.79        20\n",
            "          12       0.94      0.84      0.89        19\n",
            "          13       0.78      0.84      0.81        37\n",
            "          14       0.81      0.89      0.85        19\n",
            "          15       0.86      0.95      0.90        19\n",
            "          16       0.86      0.90      0.88        20\n",
            "\n",
            "    accuracy                           0.81       347\n",
            "   macro avg       0.82      0.81      0.81       347\n",
            "weighted avg       0.82      0.81      0.81       347\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x800 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from torchvision import transforms\n",
        "from PIL import Image\n"
      ],
      "metadata": {
        "id": "VSEpO3GE6yC5"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load a pre-trained model\n",
        "model = models.resnet50(pretrained=True)\n",
        "\n",
        "# Modify the final layer to match the number of classes in your dataset\n",
        "num_classes = len(train_dataset.classes)  # Number of unique celebrity classes\n",
        "model.fc = nn.Linear(model.fc.in_features, num_classes)\n",
        "\n",
        "# Move the model to the specified device\n",
        "#model = model.to(device)\n",
        "\n",
        "model.load_state_dict(torch.load('best_model.pth'))\n",
        "model.eval()  # Set the model to evaluation mode\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z_JAEIsH688e",
        "outputId": "408cc752-1436-40a6-a297-535535d1826f"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
            "  warnings.warn(msg)\n",
            "<ipython-input-13-ca19110d0559>:11: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
            "  model.load_state_dict(torch.load('best_model.pth'))\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ResNet(\n",
              "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
              "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (relu): ReLU(inplace=True)\n",
              "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
              "  (layer1): Sequential(\n",
              "    (0): Bottleneck(\n",
              "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): Bottleneck(\n",
              "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (2): Bottleneck(\n",
              "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "  )\n",
              "  (layer2): Sequential(\n",
              "    (0): Bottleneck(\n",
              "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): Bottleneck(\n",
              "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (2): Bottleneck(\n",
              "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (3): Bottleneck(\n",
              "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=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",
              "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "  )\n",
              "  (layer3): Sequential(\n",
              "    (0): Bottleneck(\n",
              "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (2): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (3): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (4): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (5): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "  )\n",
              "  (layer4): Sequential(\n",
              "    (0): Bottleneck(\n",
              "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): Bottleneck(\n",
              "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "    (2): Bottleneck(\n",
              "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
              "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "    )\n",
              "  )\n",
              "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
              "  (fc): Linear(in_features=2048, out_features=17, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#import torch\n",
        "#from torchvision import transforms\n",
        "#from PIL import Image\n",
        "\n",
        "# Check if GPU is available and set the device\n",
        "\n",
        "\n",
        "\n",
        "#device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Load your model and move it to the correct device\n",
        "#model = models.resnet18(num_classes=len(train_dataset.classes))  # Adjust if using a different architecture\n",
        "#model.load_state_dict(torch.load('best_model.pth'))\n",
        "#model.to(device)  # Move model to GPU or CPU\n",
        "#model.eval()  # Set the model to evaluation mode\n",
        "\n",
        "# Define the transformations\n",
        "import torch\n",
        "from torchvision import transforms\n",
        "from PIL import Image\n",
        "\n",
        "def load_image(image_path, device=None):\n",
        "    try:\n",
        "        image = Image.open(image_path).convert('RGB')\n",
        "        transform = transforms.Compose([\n",
        "            transforms.Resize((224, 224)),\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
        "        ])\n",
        "        image = transform(image)\n",
        "\n",
        "        # Add batch dimension if the model expects a batch\n",
        "        if device is not None and torch.cuda.is_available():\n",
        "            image = image.unsqueeze(0).to(device)\n",
        "\n",
        "        return image\n",
        "\n",
        "    except Exception as e:\n",
        "        print(f\"Error loading image: {e}\")\n",
        "        return None  # Or return a default value\n",
        "\n",
        "def predict(image_path, model, device=None):\n",
        "    image = load_image(image_path, device)\n",
        "    if image is None:\n",
        "        return None  # Handle loading errors\n",
        "\n",
        "    # Move image to the same device as the model\n",
        "    if device is not None and not next(model.parameters()).is_cuda:\n",
        "        model.to(device)\n",
        "    image = image.to(device)\n",
        "\n",
        "    with torch.no_grad():\n",
        "        outputs = model(image)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "\n",
        "    predicted_class_index = predicted.item()\n",
        "    try:\n",
        "        predicted_class_name = train_dataset.classes[predicted_class_index]\n",
        "    except IndexError:\n",
        "        print(f\"Invalid class index: {predicted_class_index}\")\n",
        "        return None  # Or return a default value\n",
        "\n",
        "    return predicted_class_name\n",
        "\n",
        "# Example usage\n",
        "image_path = '/content/jdp.jpg'  # Replace with your image path\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")  # Explicitly set device\n",
        "predicted_class_name = predict(image_path, model, device)\n",
        "\n",
        "if predicted_class_name:\n",
        "    print(f'Predicted celebrity: {predicted_class_name}')\n",
        "else:\n",
        "    print(\"Error predicting class\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nxr3ARf47W0R",
        "outputId": "f25b2aab-3071-424a-eca1-9b38a6c17d8a"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted celebrity: Johnny Depp\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "3aXH9uT4D7b6"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}