Deploy gradio Animal Classifier

.gitignore

@@ -0,0 +1,18 @@
+__pycache__/
+
+*.pyc
+
+.env
+
+venv/
+.venv/
+
+.ipynb_checkpoints
+
+.idea/
+
+.vscode/
+
+logs/
+
+.DS_Store

Animal_Classification_with_PyTorch.ipynb

@@ -1,557 +0,0 @@
-{
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "provenance": [],
-      "gpuType": "T4"
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "language_info": {
-      "name": "python"
-    },
-    "accelerator": "GPU"
-  },
-  "cells": [
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "RjttzVZ579G3"
-      },
-      "outputs": [],
-      "source": []
-    },
-    {
-      "cell_type": "markdown",
-      "source": [
-        "## Animal Classification with PyTorch"
-      ],
-      "metadata": {
-        "id": "eDAUjwYyzlX8"
-      }
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# Imports\n",
-        "import torch\n",
-        "import torch.nn as nn\n",
-        "import torch.optim as optim\n",
-        "from torch.utils.data import DataLoader, random_split\n",
-        "from torchvision import datasets, transforms, models"
-      ],
-      "metadata": {
-        "id": "k82-c-BITr7H"
-      },
-      "execution_count": 2,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "!unzip -q \"/content/dataset.zip\" -d /content/dataset\n",
-        "data_dir = '/content/dataset'"
-      ],
-      "metadata": {
-        "id": "x57UatR7pizC"
-      },
-      "execution_count": 4,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "!ls /content/"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "aNXIeY_9NJfr",
-        "outputId": "876269cc-719e-4709-b34d-cd38aad2eeea"
-      },
-      "execution_count": 5,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "dataset  dataset.zip  drive  sample_data\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "\n",
-        "from google.colab import drive\n",
-        "drive.mount('/content/drive')"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "Cd2bJUcW27jF",
-        "outputId": "e8b3a9cc-2e47-4ee0-9a6e-fd86fd77c591"
-      },
-      "execution_count": 2,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# Transforms\n",
-        "# Training transforms include augmentation to reduce overfitting\n",
-        "train_transform = transforms.Compose([\n",
-        "    transforms.Resize((224, 224)),          # ResNet expects 224x224 input\n",
-        "    transforms.RandomHorizontalFlip(),\n",
-        "    transforms.RandomRotation(15),\n",
-        "    transforms.ColorJitter(brightness=0.2, contrast=0.2),\n",
-        "    transforms.ToTensor(),\n",
-        "    transforms.Normalize(mean=[0.485, 0.456, 0.406],   # ImageNet stats —\n",
-        "                          std=[0.229, 0.224, 0.225])    # required since we use pretrained weights\n",
-        "])\n",
-        "\n",
-        "# Validation/test transforms: no augmentation, just resize + normalize\n",
-        "val_transform = transforms.Compose([\n",
-        "    transforms.Resize((224, 224)),\n",
-        "    transforms.ToTensor(),\n",
-        "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
-        "                          std=[0.229, 0.224, 0.225])\n",
-        "])"
-      ],
-      "metadata": {
-        "id": "9I_mKjfyo3H0"
-      },
-      "execution_count": 6,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "\n"
-      ],
-      "metadata": {
-        "id": "HbI3T56qo_q3"
-      },
-      "execution_count": 6,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "!ls /content/dataset/dataset"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "0ywm31h2Tvt4",
-        "outputId": "5a43b8f5-82a3-4767-85bd-37cbaac35421"
-      },
-      "execution_count": 7,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Butterfly  Cat\tChicken  Cow  Dog  Elephant  Horse  Sheep  Spider  Squirrel\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# Load dataset and split\n",
-        "data_dir = '/content/dataset/dataset'  # path to your folder\n",
-        "\n",
-        "full_dataset = datasets.ImageFolder(root=data_dir, transform=train_transform)\n",
-        "class_names = full_dataset.classes\n",
-        "num_classes = len(class_names)\n",
-        "print(f'Classes: {class_names}')\n",
-        "\n",
-        "# Split into train/val (80/20)\n",
-        "train_size = int(0.8 * len(full_dataset))\n",
-        "val_size = len(full_dataset) - train_size\n",
-        "train_dataset, val_dataset = random_split(full_dataset, [train_size, val_size])\n",
-        "\n",
-        "# Val set should use val_transform, not train_transform (no augmentation)\n",
-        "val_dataset.dataset.transform = val_transform\n",
-        "\n",
-        "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=2)\n",
-        "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=2)"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "AL0BnBNopGDM",
-        "outputId": "177857e2-f824-463e-d88e-167cfe03b220"
-      },
-      "execution_count": 8,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Classes: ['Butterfly', 'Cat', 'Chicken', 'Cow', 'Dog', 'Elephant', 'Horse', 'Sheep', 'Spider', 'Squirrel']\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-        "print(device)\n",
-        "print(torch.cuda.is_available())"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "gmf4mQ0mLMio",
-        "outputId": "72498418-0301-4059-c16b-b81693340c6c"
-      },
-      "execution_count": 9,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "cuda\n",
-            "True\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# Model — transfer learning with ResNet18\n",
-        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-        "\n",
-        "model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)\n",
-        "\n",
-        "for param in model.parameters():\n",
-        "    param.requires_grad = False\n",
-        "\n",
-        "model.fc = nn.Linear(model.fc.in_features, num_classes)\n",
-        "model = model.to(device)\n",
-        "\n",
-        "criterion = nn.CrossEntropyLoss()\n",
-        "optimizer = optim.Adam(model.fc.parameters(), lr=1e-3)"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "eiOeXlV1pJA5",
-        "outputId": "e50f56f5-ad82-4d6d-904f-1fbf35b526e3"
-      },
-      "execution_count": 10,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Downloading: \"https://download.pytorch.org/models/resnet18-f37072fd.pth\" to /root/.cache/torch/hub/checkpoints/resnet18-f37072fd.pth\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "100%|██████████| 44.7M/44.7M [00:00<00:00, 177MB/s]\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# Train\n",
-        "def train_model(model, train_loader, val_loader, criterion, optimizer, epochs=10):\n",
-        "    for epoch in range(epochs):\n",
-        "        # --- Training phase ---\n",
-        "        model.train()\n",
-        "        running_loss, correct, total = 0.0, 0, 0\n",
-        "\n",
-        "        for images, labels in train_loader:\n",
-        "            images, labels = images.to(device), labels.to(device)\n",
-        "\n",
-        "            optimizer.zero_grad()\n",
-        "            outputs = model(images)\n",
-        "            loss = criterion(outputs, labels)\n",
-        "            loss.backward()\n",
-        "            optimizer.step()\n",
-        "\n",
-        "            running_loss += loss.item() * images.size(0)\n",
-        "            _, predicted = torch.max(outputs, 1)\n",
-        "            correct += (predicted == labels).sum().item()\n",
-        "            total += labels.size(0)\n",
-        "\n",
-        "        train_loss = running_loss / total\n",
-        "        train_acc = correct / total\n",
-        "\n",
-        "        # --- Validation phase ---\n",
-        "        model.eval()\n",
-        "        val_loss, val_correct, val_total = 0.0, 0, 0\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",
-        "\n",
-        "                val_loss += loss.item() * images.size(0)\n",
-        "                _, predicted = torch.max(outputs, 1)\n",
-        "                val_correct += (predicted == labels).sum().item()\n",
-        "                val_total += labels.size(0)\n",
-        "\n",
-        "        val_loss /= val_total\n",
-        "        val_acc = val_correct / val_total\n",
-        "\n",
-        "        print(f'Epoch {epoch+1}/{epochs} | '\n",
-        "              f'Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f} | '\n",
-        "              f'Val Loss: {val_loss:.4f}, Val Acc: {val_acc:.4f}')\n",
-        "\n",
-        "train_model(model, train_loader, val_loader, criterion, optimizer, epochs=10)"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "Q6QnhlhlpkdC",
-        "outputId": "803f995a-e22b-4100-f912-959de7b73858"
-      },
-      "execution_count": 11,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Epoch 1/10 | Train Loss: 0.5573, Train Acc: 0.8568 | Val Loss: 0.2354, Val Acc: 0.9325\n",
-            "Epoch 2/10 | Train Loss: 0.2344, Train Acc: 0.9328 | Val Loss: 0.1828, Val Acc: 0.9461\n",
-            "Epoch 3/10 | Train Loss: 0.1938, Train Acc: 0.9445 | Val Loss: 0.1665, Val Acc: 0.9493\n",
-            "Epoch 4/10 | Train Loss: 0.1738, Train Acc: 0.9476 | Val Loss: 0.1645, Val Acc: 0.9488\n",
-            "Epoch 5/10 | Train Loss: 0.1591, Train Acc: 0.9517 | Val Loss: 0.1663, Val Acc: 0.9525\n",
-            "Epoch 6/10 | Train Loss: 0.1557, Train Acc: 0.9527 | Val Loss: 0.1569, Val Acc: 0.9525\n",
-            "Epoch 7/10 | Train Loss: 0.1455, Train Acc: 0.9546 | Val Loss: 0.1581, Val Acc: 0.9516\n",
-            "Epoch 8/10 | Train Loss: 0.1315, Train Acc: 0.9585 | Val Loss: 0.1573, Val Acc: 0.9520\n",
-            "Epoch 9/10 | Train Loss: 0.1307, Train Acc: 0.9581 | Val Loss: 0.1571, Val Acc: 0.9498\n",
-            "Epoch 10/10 | Train Loss: 0.1277, Train Acc: 0.9579 | Val Loss: 0.1575, Val Acc: 0.9529\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# unfreeze layer4 and fine-tune\n",
-        "# Unfreeze the last convolutional block so it can adapt to your specific classes\n",
-        "for param in model.layer4.parameters():\n",
-        "    param.requires_grad = True\n",
-        "\n",
-        "# Two learning rates: small for the pretrained layer4 (don't destroy its features),\n",
-        "# normal for the head which still needs to keep adjusting\n",
-        "optimizer = optim.Adam([\n",
-        "    {'params': model.fc.parameters(), 'lr': 1e-3},\n",
-        "    {'params': model.layer4.parameters(), 'lr': 1e-5}\n",
-        "])\n",
-        "\n",
-        "train_model(model, train_loader, val_loader, criterion, optimizer, epochs=10)"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "erBDHDJLqeDa",
-        "outputId": "0d0813ee-e83f-40a8-bedb-481c3e309c43"
-      },
-      "execution_count": 12,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Epoch 1/10 | Train Loss: 0.1284, Train Acc: 0.9574 | Val Loss: 0.1514, Val Acc: 0.9552\n",
-            "Epoch 2/10 | Train Loss: 0.0813, Train Acc: 0.9737 | Val Loss: 0.1519, Val Acc: 0.9556\n",
-            "Epoch 3/10 | Train Loss: 0.0533, Train Acc: 0.9838 | Val Loss: 0.1491, Val Acc: 0.9552\n",
-            "Epoch 4/10 | Train Loss: 0.0362, Train Acc: 0.9915 | Val Loss: 0.1455, Val Acc: 0.9593\n",
-            "Epoch 5/10 | Train Loss: 0.0286, Train Acc: 0.9918 | Val Loss: 0.1477, Val Acc: 0.9547\n",
-            "Epoch 6/10 | Train Loss: 0.0170, Train Acc: 0.9972 | Val Loss: 0.1481, Val Acc: 0.9593\n",
-            "Epoch 7/10 | Train Loss: 0.0151, Train Acc: 0.9971 | Val Loss: 0.1449, Val Acc: 0.9602\n",
-            "Epoch 8/10 | Train Loss: 0.0133, Train Acc: 0.9973 | Val Loss: 0.1628, Val Acc: 0.9570\n",
-            "Epoch 9/10 | Train Loss: 0.0160, Train Acc: 0.9955 | Val Loss: 0.1581, Val Acc: 0.9593\n",
-            "Epoch 10/10 | Train Loss: 0.0081, Train Acc: 0.9986 | Val Loss: 0.1612, Val Acc: 0.9602\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# Confusion matrix — check if horse/elephant confusion actually improved\n",
-        "from sklearn.metrics import confusion_matrix, classification_report\n",
-        "import numpy as np\n",
-        "\n",
-        "model.eval()\n",
-        "all_preds, all_labels = [], []\n",
-        "\n",
-        "with torch.no_grad():\n",
-        "    for images, labels in val_loader:\n",
-        "        images = images.to(device)\n",
-        "        outputs = model(images)\n",
-        "        _, predicted = torch.max(outputs, 1)\n",
-        "        all_preds.extend(predicted.cpu().numpy())\n",
-        "        all_labels.extend(labels.numpy())\n",
-        "\n",
-        "cm = confusion_matrix(all_labels, all_preds)\n",
-        "print(classification_report(all_labels, all_preds, target_names=class_names))"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "TTm0B6vdqxkC",
-        "outputId": "7b6a74d0-8c11-4421-d0b4-fc721fc7764e"
-      },
-      "execution_count": 13,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "              precision    recall  f1-score   support\n",
-            "\n",
-            "   Butterfly       0.94      0.97      0.95       199\n",
-            "         Cat       0.97      0.99      0.98       272\n",
-            "     Chicken       1.00      0.96      0.98       200\n",
-            "         Cow       0.89      0.94      0.91       193\n",
-            "         Dog       0.95      0.98      0.97       345\n",
-            "    Elephant       0.97      0.95      0.96       203\n",
-            "       Horse       0.98      0.92      0.94       215\n",
-            "       Sheep       0.95      0.94      0.94       188\n",
-            "      Spider       0.97      0.95      0.96       196\n",
-            "    Squirrel       0.99      0.97      0.98       198\n",
-            "\n",
-            "    accuracy                           0.96      2209\n",
-            "   macro avg       0.96      0.96      0.96      2209\n",
-            "weighted avg       0.96      0.96      0.96      2209\n",
-            "\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# Save the model\n",
-        "torch.save(model.state_dict(), 'animal_classifier_resnet18.pth')"
-      ],
-      "metadata": {
-        "id": "HMCICAPqpr-p"
-      },
-      "execution_count": 14,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "#Inference on a new image\n",
-        "from PIL import Image\n",
-        "\n",
-        "def predict_image(image_path, model, transform, class_names):\n",
-        "    model.eval()\n",
-        "    image = Image.open(image_path).convert('RGB')\n",
-        "    image_tensor = transform(image).unsqueeze(0).to(device)  # add batch dimension\n",
-        "\n",
-        "    with torch.no_grad():\n",
-        "        output = model(image_tensor)\n",
-        "        _, predicted = torch.max(output, 1)\n",
-        "\n",
-        "    return class_names[predicted.item()]\n",
-        "\n",
-        "# Provide a valid path to an image from your dataset\n",
-        "# For example, using one of the butterfly images that was unzipped earlier\n",
-        "image_to_predict_path = '/content/dataset/dataset/Butterfly/OIP--gEvtip9-FSfOy_MWMXSxQHaJ6.jpeg'\n",
-        "result = predict_image(image_to_predict_path, model, val_transform, class_names)\n",
-        "print(f'Predicted class: {result}')"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "kpUYVRnKpx-r",
-        "outputId": "65eb83b2-fb5c-49a5-86ab-1130e27a01f7"
-      },
-      "execution_count": 15,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Predicted class: Butterfly\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "a5959856",
-        "outputId": "498cf7ca-7c37-4016-cc17-54b57d5b3d7b"
-      },
-      "source": [
-        "import os\n",
-        "\n",
-        "directory_to_check = '/content/dataset/dataset/Butterfly/'\n",
-        "if os.path.isdir(directory_to_check):\n",
-        "    print(f'The directory \"{directory_to_check}\" exists.')\n",
-        "    # Optionally, list some files in the directory to confirm it's not empty\n",
-        "    print('Files in the directory (first 5):')\n",
-        "    print(os.listdir(directory_to_check)[:5])\n",
-        "else:\n",
-        "    print(f'The directory \"{directory_to_check}\" does NOT exist.')"
-      ],
-      "execution_count": 23,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "The directory \"/content/dataset/dataset/Butterfly/\" exists.\n",
-            "Files in the directory (first 5):\n",
-            "['OIP-qugefs9Tnt250B8cygtBJQAAAA.jpeg', 'OIP-WTFhQqD88fBJqFbfVlHSEwHaFa.jpeg', 'OIP-Y5_dpYEmm7Gar2Dyn_EZcAHaHa.jpeg', 'OIP-rME83hQvAoryna1yrFbUDQHaJ5.jpeg', 'OIP-zdZAIubVm0NYpKeBu4zW5QHaFa.jpeg']\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [],
-      "metadata": {
-        "id": "m3FUixF6p3oQ"
-      },
-      "execution_count": null,
-      "outputs": []
-    }
-  ]
-}

app.py

@@ -1,75 +1,710 @@
-import streamlit as st
-import torch  
-import torch.nn as nn  
-from torchvision import models, transforms  
+##############################################################
+# Animal Image Classification using ResNet18
+# Developed by: Odeyale Kehinde Musiliudeen
+##############################################################
+
+import os
+import time
+from datetime import datetime
+
+import torch
+import torch.nn as nn
+
+import pandas as pd
+
+import plotly.express as px
+
+import gradio as gr
+
 from PIL import Image
 
+from torchvision import models, transforms
+
+from reportlab.lib import colors
+from reportlab.lib.styles import getSampleStyleSheet
+
+from reportlab.platypus import (
+    SimpleDocTemplate,
+    Paragraph,
+    Table,
+    TableStyle,
+    Spacer
+)
+
+##############################################################
+# Configuration
+##############################################################
 
-# --- Config ---
-CLASS_NAMES = ['Butterfly', 'Cat', 'Chicken','Cow', 'Dog', 'Elephant', 'Horse', 'Sheep', 'Spider','Squirrel']  # replace with your actual class_names, in the same order
-MODEL_PATH = 'animal_classifier_resnet18.pth'
-CONFIDENCE_THRESHOLD = 0.70 
-# --- Load model (cached so it only loads once, not on every interaction) ---
-@st.cache_resource
+CLASS_NAMES = [
+    "Butterfly",
+    "Cat",
+    "Chicken",
+    "Cow",
+    "Dog",
+    "Elephant",
+    "Horse",
+    "Sheep",
+    "Spider",
+    "Squirrel"
+]
+
+MODEL_PATH = "animal_classifier_resnet18.pth"
+
+CONFIDENCE_THRESHOLD = 0.70
+
+MODEL_NAME = "ResNet18"
+
+MODEL_SIZE = "42 MB"
+
+##############################################################
+# Create folders automatically
+##############################################################
+
+os.makedirs("reports", exist_ok=True)
+
+##############################################################
+# Load Model
+##############################################################
+
+@torch.no_grad()
 def load_model():
-    model = models.resnet18(weights=None)  # architecture only, no pretrained weights needed here
-    model.fc = nn.Linear(model.fc.in_features, len(CLASS_NAMES))
-    model.load_state_dict(torch.load(MODEL_PATH, map_location=torch.device('cpu')))
+
+    model = models.resnet18(weights=None)
+
+    model.fc = nn.Linear(
+        model.fc.in_features,
+        len(CLASS_NAMES)
+    )
+
+    state = torch.load(
+        MODEL_PATH,
+        map_location="cpu"
+    )
+
+    model.load_state_dict(state)
+
     model.eval()
+
     return model
 
+
 model = load_model()
 
-# --- Same transform used for validation/inference during training ---
+##############################################################
+# Image Preprocessing
+##############################################################
+
 transform = transforms.Compose([
-    transforms.Resize((224, 224)),
+
+    transforms.Resize((224,224)),
+
     transforms.ToTensor(),
-    transforms.Normalize(mean=[0.485, 0.456, 0.406],
-                          std=[0.229, 0.224, 0.225])
+
+    transforms.Normalize(
+
+        mean=[0.485,0.456,0.406],
+
+        std=[0.229,0.224,0.225]
+
+    )
+
 ])
 
-# --- UI ---
-st.title("Animal Image Classifier ")
+##############################################################
+# CSV Report
+##############################################################
 
-st.write("This app uses a pre-trained ResNet18 model to classify images of animals. ")
-st.write("The model was trained on a dataset of 10 different animals, and it can predict which animal is in the uploaded image.")   
+def create_csv(top5_df):
 
-st.write("Upload an image and the model will predict which animal it is.")
+    filename = os.path.join(
 
-st.caption(
-    f"⚠️ This model can only recognize: **{', '.join(CLASS_NAMES)}**. "
-    f"Uploading other animals or objects may produce incorrect or misleading results."
-)
+        "reports",
+
+        f"prediction_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+
+    )
+
+    top5_df.to_csv(filename,index=False)
+
+    return filename
+
+##############################################################
+# PDF Report
+##############################################################
+
+def create_pdf(
+
+    prediction,
+
+    confidence,
+
+    inference_time,
+
+    top5_df
+
+):
+
+    filename = os.path.join(
+
+        "reports",
+
+        f"prediction_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+
+    )
+
+    doc = SimpleDocTemplate(filename)
+
+    styles = getSampleStyleSheet()
+
+    elements = []
+
+    elements.append(
+
+        Paragraph(
+
+            "Animal Image Classification Report",
+
+            styles["Title"]
+
+        )
+
+    )
+
+    elements.append(Spacer(1,15))
+
+    elements.append(
+
+        Paragraph(
+
+            f"<b>Date:</b> {datetime.now()}",
+
+            styles["Normal"]
+
+        )
+
+    )
+
+    elements.append(
+
+        Paragraph(
+
+            f"<b>Prediction:</b> {prediction}",
+
+            styles["Normal"]
+
+        )
 
-uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+    )
 
-if uploaded_file is not None:
-    image = Image.open(uploaded_file).convert('RGB')
-    st.image(image, caption='Uploaded Image', width='stretch')
+    elements.append(
 
-    image_tensor = transform(image).unsqueeze(0)
+        Paragraph(
+
+            f"<b>Confidence:</b> {confidence}",
+
+            styles["Normal"]
+
+        )
+
+    )
+
+    elements.append(
+
+        Paragraph(
+
+            f"<b>Inference Time:</b> {inference_time}",
+
+            styles["Normal"]
+
+        )
+
+    )
+
+    elements.append(Spacer(1,15))
+
+    table_data = [list(top5_df.columns)]
+
+    table_data.extend(
+
+        top5_df.values.tolist()
+
+    )
+
+    table = Table(table_data)
+
+    table.setStyle(
+
+        TableStyle([
+
+            ("BACKGROUND",(0,0),(-1,0),colors.darkgreen),
+
+            ("TEXTCOLOR",(0,0),(-1,0),colors.white),
+
+            ("GRID",(0,0),(-1,-1),1,colors.black),
+
+            ("BACKGROUND",(0,1),(-1,-1),colors.beige),
+
+            ("ALIGN",(0,0),(-1,-1),"CENTER")
+
+        ])
+
+    )
+
+    elements.append(table)
+
+    doc.build(elements)
+
+    return filename
+
+##############################################################
+# Prediction Function
+##############################################################
+
+def predict(image):
+
+    if image is None:
+
+        return (
+
+            None,
+
+            "Please upload an image.",
+
+            "",
+
+            "",
+
+            "",
+
+            pd.DataFrame(),
+
+            None,
+
+            None,
+
+            None
+
+        )
+
+    start = time.time()
+
+    image = image.convert("RGB")
+
+    tensor = transform(image).unsqueeze(0)
 
     with torch.no_grad():
-        output = model(image_tensor)
-        probabilities = torch.softmax(output, dim=1)[0]
-        predicted_idx = torch.argmax(probabilities).item()
-        confidence = probabilities[predicted_idx].item()
+
+        output = model(tensor)
+
+        probabilities = torch.softmax(
+
+            output,
+
+            dim=1
+
+        )[0]
+
+    inference_time = round(
+
+        time.time()-start,
+
+        3
+
+    )
+
+    confidence,pred = torch.max(
+
+        probabilities,
+
+        0
+
+    )
+
+    confidence = confidence.item()
+
+    predicted_class = CLASS_NAMES[pred.item()]
+
+    if confidence >= 0.90:
+
+        status = "🟢 High Confidence"
+
+    elif confidence >= 0.75:
+
+        status = "🟡 Medium Confidence"
+
+    else:
+
+        status = "🔴 Low Confidence"
 
     if confidence < CONFIDENCE_THRESHOLD:
-        st.subheader("Prediction: Not confident enough to classify")
-        st.write(
-            f"The model's best guess was **{CLASS_NAMES[predicted_idx]}** "
-            f"at only {confidence * 100:.2f}% confidence, which is below the "
-            f"{CONFIDENCE_THRESHOLD * 100:.0f}% threshold. This usually means the "
-            f"uploaded image isn't one of the animals this model was trained on."
-        )
+
+        prediction_html = f"""
+
+        <h2 style='color:red;'>
+
+        Not confident enough
+
+        </h2>
+
+        <p>
+
+        Best Guess:
+
+        <b>{predicted_class}</b>
+
+        </p>
+
+        """
+
     else:
-        st.subheader(f"Prediction: **{CLASS_NAMES[predicted_idx]}**")
-        st.write(f"Confidence: {confidence * 100:.2f}%")
 
-    # Show all class probabilities regardless, for transparency
-    st.write("All class probabilities:")
-    for i, class_name in enumerate(CLASS_NAMES):
-        st.write(f"- {class_name}: {probabilities[i].item() * 100:.2f}%")
+        prediction_html = f"""
+
+        <h1 style='color:green;'>
+
+        {predicted_class}
+
+        </h1>
+
+        """
+
+    ##########################################################
+    # Top-5 Predictions
+    ##########################################################
+
+    top5 = torch.topk(
+
+        probabilities,
+
+        5
+
+    )
+
+    top5_df = pd.DataFrame({
+
+        "Rank":
+
+        range(1,6),
+
+        "Animal":[
+
+            CLASS_NAMES[i]
+
+            for i in top5.indices.tolist()
+
+        ],
+
+        "Probability (%)":[
+
+            round(
+
+                float(v)*100,
+
+                2
+
+            )
+
+            for v in top5.values.tolist()
+
+        ]
+
+    })
+
+    ##########################################################
+    # Plotly Confidence Chart
+    ##########################################################
+
+    fig = px.bar(
+
+        top5_df,
+
+        x="Probability (%)",
+
+        y="Animal",
+
+        orientation="h",
+
+        text="Probability (%)",
+
+        color="Probability (%)",
+
+        color_continuous_scale="Viridis"
+
+    )
+
+    fig.update_layout(
+
+        height=420,
+
+        template="plotly_white",
+
+        coloraxis_showscale=False,
+
+        title="Top-5 Prediction Confidence"
+
+    )
+
+    fig.update_traces(
+
+        texttemplate="%{text:.2f}%",
+
+        textposition="outside"
+
+    )
+
+    ##########################################################
+    # Model Information
+    ##########################################################
+
+    model_information = f"""
+
+Architecture : {MODEL_NAME}
+
+Framework : PyTorch
+
+Classes : {len(CLASS_NAMES)}
+
+Input Size : 224 × 224
+
+Model Size : {MODEL_SIZE}
+
+Confidence Threshold : {CONFIDENCE_THRESHOLD}
+
+Prediction Status : {status}
+
+"""
+
+    ##########################################################
+    # Reports
+    ##########################################################
+
+    csv_file = create_csv(top5_df)
+
+    pdf_file = create_pdf(
+
+        predicted_class,
+
+        f"{confidence*100:.2f}%",
+
+        f"{inference_time:.3f} sec",
+
+        top5_df
+
+    )
+
+    ##########################################################
+    # Return Outputs
+    ##########################################################
+
+    return (
+
+        image,
+
+        prediction_html,
+
+        f"{confidence*100:.2f}%",
+
+        f"{inference_time:.3f} sec",
+
+        model_information,
+
+        top5_df,
+
+        fig,
+
+        csv_file,
+
+        pdf_file
+
+    )
+
+
+##############################################################
+# User Interface
+##############################################################
+
+with gr.Blocks(
+    title="Animal Image Classification"
+) as demo:
+
+    gr.Markdown(
+        """
+# 🐾 Animal Image Classification using Deep Learning
+
+This application uses a **ResNet18** convolutional neural network trained to classify **10 animal species**.
+
+### Supported Classes
+
+Butterfly • Cat • Chicken • Cow • Dog • Elephant • Horse • Sheep • Spider • Squirrel
+"""
+    )
+
+    ##########################################################
+    # Main Layout
+    ##########################################################
+
+    with gr.Row():
+
+        ######################################################
+        # Left Panel
+        ######################################################
+
+        with gr.Column(scale=1):
+
+            input_image = gr.Image(
+                type="pil",
+                label="Upload Animal Image"
+            )
+
+            with gr.Row():
+
+                predict_btn = gr.Button(
+                    "🔍 Predict",
+                    variant="primary"
+                )
+
+                clear_btn = gr.ClearButton(
+                    components=[input_image]
+                )
+
+        ######################################################
+        # Right Panel
+        ######################################################
+
+        with gr.Column(scale=1):
+
+            output_image = gr.Image(
+                label="Uploaded Image"
+            )
+
+            prediction = gr.HTML(
+                label="Prediction"
+            )
+
+            confidence = gr.Textbox(
+                label="Confidence"
+            )
+
+            inference_time = gr.Textbox(
+                label="Inference Time"
+            )
+
+    ##########################################################
+    # Top-5 Prediction + Confidence Chart
+    ##########################################################
+
+    gr.Markdown("## 📊 Prediction Analysis")
+
+    with gr.Row():
+
+        with gr.Column():
+
+            top5_table = gr.Dataframe(
+                headers=[
+                    "Rank",
+                    "Animal",
+                    "Probability (%)"
+                ],
+                interactive=False,
+                label="Top-5 Predictions"
+            )
+
+        with gr.Column():
+
+            confidence_chart = gr.Plot(
+                label="Confidence Distribution"
+            )
+
+    ##########################################################
+    # Model Information
+    ##########################################################
+
+    with gr.Accordion(
+        "ℹ️ Model Information",
+        open=False
+    ):
+
+        info = gr.Textbox(
+            lines=8,
+            interactive=False,
+            label="Model Details"
+        )
+
+    ##########################################################
+    # Download Reports
+    ##########################################################
+
+    gr.Markdown("## 📥 Download Reports")
+
+    with gr.Row():
+
+        csv_download = gr.File(
+            label="CSV Report"
+        )
+
+        pdf_download = gr.File(
+            label="PDF Report"
+        )
+
+    ##########################################################
+    # Footer
+    ##########################################################
+
+    gr.Markdown(
+        """
+---
+
+### Developed by
+
+**Odeyale Kehinde Musiliudeen**
+
+Alphatech AI Research Laboratory
+
+Powered by **PyTorch + Gradio**
+"""
+    )
+
+    ##########################################################
+    # Prediction Event
+    ##########################################################
+
+    predict_btn.click(
+
+        fn=predict,
+
+        inputs=input_image,
+
+        outputs=[
+
+            output_image,
+
+            prediction,
+
+            confidence,
+
+            inference_time,
+
+            info,
+
+            top5_table,
+
+            confidence_chart,
+
+            csv_download,
+
+            pdf_download
+
+        ]
+
+    )
+
+##############################################################
+# Launch Application
+##############################################################
+
+if __name__ == "__main__":
 
-    st.write("Developed by: Odeyale Kehinde Musiliudeen(Alphatech)")
+    demo.launch(
+        debug=True,
+        show_error=True
+    )

requirements.txt

@@ -1,4 +1,13 @@
-streamlit
-torch
-torchvision
-Pillow
+gradio==5.38.2
+
+torch>=2.3
+
+torchvision>=0.18
+
+pillow
+
+pandas
+
+plotly
+
+reportlab