Upload 21 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Notebooks/PyTorch_Image_Classification.ipynb filter=lfs diff=lfs merge=lfs -text
+Results/PyTorch_Unified_Model_Comparison.mp4 filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,37 @@
+# Use official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set working directory in container
+WORKDIR /app
+
+# Install system dependencies required for PyTorch and image processing
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    libssl-dev \
+    libffi-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port for Gradio
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV GRADIO_SERVER_NAME=0.0.0.0
+ENV GRADIO_SERVER_PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD python -c "import sys; sys.exit(0)" || exit 1
+
+# Run the application
+CMD ["python", "app.py"]

Notebooks/PyTorch_Image_Classification.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf12bb81b637521294883fad25cac2866334c1818b1d2976e53c2b085cdc5641
+size 28301580

Results/PyTorch_Unified_Model_Comparison.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35c3480db4bb26d609bd5cddc64ff007dab3957fe2203a95d592558a9e42d28d
+size 18008325

app.py

@@ -0,0 +1,395 @@
+import os
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Tuple, Dict
+from PIL import Image
+import random
+
+import gradio as gr
+import torch
+from datasets import load_dataset
+
+# Import model handlers
+from model_handlers.basic_cnn_handler import BasicCNNModel
+from model_handlers.hugging_face_handler import HuggingFaceModel
+from model_handlers.xception_handler import XceptionModel
+
+
+# Global Configuration
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MODELS_DIR = os.path.join(BASE_DIR, "models")
+
+MODEL_1_DIR = os.path.join(MODELS_DIR, "basic_cnn")
+MODEL_2_DIR = os.path.join(MODELS_DIR, "hugging_face")
+MODEL_3_DIR = os.path.join(MODELS_DIR, "xception")
+
+# Model instances (loaded at startup)
+basic_cnn_model = None
+hugging_face_model = None
+xception_model = None
+
+# Dataset for random image selection
+dataset = None
+DATASET_NAME = "AIOmarRehan/Vehicles"
+
+MODELS_INFO = {
+    "Model 1: Basic CNN": {
+        "description": "Custom CNN architecture with 4 Conv blocks and BatchNorm",
+        "path": MODEL_1_DIR,
+        "handler_class": BasicCNNModel
+    },
+    "Model 2: Hugging Face Transformers (DeiT-Tiny | Meta)": {
+        "description": "Pre-trained transformer-based model from Hugging Face (DeiT-Tiny | Meta)",
+        "path": MODEL_2_DIR,
+        "handler_class": HuggingFaceModel
+    },
+    "Model 3: Xception CNN": {
+        "description": "Fine-tuned Xception architecture using timm library",
+        "path": MODEL_3_DIR,
+        "handler_class": XceptionModel
+    }
+}
+
+
+# Model Loading
+
+def load_models():
+    """Load all three models at startup"""
+    global basic_cnn_model, hugging_face_model, xception_model
+    
+    print("\n" + "="*60)
+    print("Loading Models...")
+    print("="*60)
+    
+    try:
+        print("\n[1/3] Loading Basic CNN Model...")
+        basic_cnn_model = BasicCNNModel(MODEL_1_DIR)
+        print("Basic CNN Model loaded successfully")
+    except Exception as e:
+        print(f"Failed to load Basic CNN Model: {e}")
+        basic_cnn_model = None
+    
+    try:
+        print("\n[2/3] Loading Hugging Face (DeiT-Tiny | Meta) Model...")
+        hugging_face_model = HuggingFaceModel(MODEL_2_DIR)
+        print("Hugging Face Model loaded successfully")
+    except Exception as e:
+        print(f"Failed to load Hugging Face Model: {e}")
+        hugging_face_model = None
+    
+    try:
+        print("\n[3/3] Loading Xception Model...")
+        xception_model = XceptionModel(MODEL_3_DIR)
+        print("Xception Model loaded successfully")
+    except Exception as e:
+        print(f"Failed to load Xception Model: {e}")
+        xception_model = None
+    
+    print("\n" + "="*60)
+    print("Model Loading Complete!")
+    print("="*60 + "\n")
+
+
+def load_dataset_split():
+    """Load the dataset for random image selection"""
+    global dataset
+    
+    try:
+        print("\nLoading dataset from Hugging Face...")
+        # Load the test split of the dataset
+        dataset = load_dataset(DATASET_NAME, split="train", trust_remote_code=True)
+        print(f"Dataset loaded successfully: {len(dataset)} images available")
+    except Exception as e:
+        print(f"Failed to load dataset: {e}")
+        print("Random image feature will be disabled")
+        dataset = None
+
+
+def get_random_image():
+    """Get a random image from the dataset"""
+    if dataset is None:
+        print("Dataset not loaded, attempting to load...")
+        load_dataset_split()
+        
+    if dataset is None:
+        return None
+    
+    try:
+        # Select a random index
+        random_idx = random.randint(0, len(dataset) - 1)
+        sample = dataset[random_idx]
+        
+        # Get the image (usually stored as 'image' or 'img' key)
+        if 'image' in sample:
+            img = sample['image']
+        elif 'img' in sample:
+            img = sample['img']
+        else:
+            # Try to find the first PIL Image in the sample
+            for value in sample.values():
+                if isinstance(value, Image.Image):
+                    img = value
+                    break
+            else:
+                print(f"Could not find image in sample keys: {sample.keys()}")
+                return None
+        
+        print(f"Loaded random image from index {random_idx}")
+        return img
+    except Exception as e:
+        print(f"Error loading random image: {e}")
+        return None
+
+
+# Prediction Functions
+
+def predict_with_model_1(image: Image.Image) -> Tuple[str, float, Dict]:
+    """Predict with Basic CNN Model"""
+    if basic_cnn_model is None:
+        return "Model 1: Error", 0.0, {}
+    try:
+        label, confidence, prob_dict = basic_cnn_model.predict(image)
+        return label, confidence, prob_dict
+    except Exception as e:
+        print(f"Error in Model 1 prediction: {e}")
+        return "Error", 0.0, {}
+
+
+def predict_with_model_2(image: Image.Image) -> Tuple[str, float, Dict]:
+    """Predict with Hugging Face (DeiT-Tiny | Meta) Model"""
+    if hugging_face_model is None:
+        return "Model 2: Error", 0.0, {}
+    try:
+        label, confidence, prob_dict = hugging_face_model.predict(image)
+        return label, confidence, prob_dict
+    except Exception as e:
+        print(f"Error in Model 2 prediction: {e}")
+        return "Error", 0.0, {}
+
+
+def predict_with_model_3(image: Image.Image) -> Tuple[str, float, Dict]:
+    """Predict with Xception Model"""
+    if xception_model is None:
+        return "Model 3: Error", 0.0, {}
+    try:
+        label, confidence, prob_dict = xception_model.predict(image)
+        return label, confidence, prob_dict
+    except Exception as e:
+        print(f"Error in Model 3 prediction: {e}")
+        return "Error", 0.0, {}
+
+
+def predict_all_models(image: Image.Image):
+    if image is None:
+        empty_result = {"Model": "N/A", "Prediction": "No image", "Confidence": 0.0}
+        empty_probs = {}
+        empty_consensus = "<p>Please upload an image to see results</p>"
+        return empty_result, empty_result, empty_result, "Please upload an image", empty_probs, empty_probs, empty_probs, empty_consensus
+    
+    print("\n" + "="*60)
+    print("Running Predictions with All Models...")
+    print("="*60)
+    
+    # Run predictions in parallel
+    with ThreadPoolExecutor(max_workers=3) as executor:
+        future_1 = executor.submit(predict_with_model_1, image)
+        future_2 = executor.submit(predict_with_model_2, image)
+        future_3 = executor.submit(predict_with_model_3, image)
+        
+        # Wait for all predictions to complete
+        result_1_label, result_1_conf, result_1_probs = future_1.result()
+        result_2_label, result_2_conf, result_2_probs = future_2.result()
+        result_3_label, result_3_conf, result_3_probs = future_3.result()
+    
+    # Format results for display
+    result_1 = {
+        "Model": "Basic CNN",
+        "Prediction": result_1_label,
+        "Confidence": f"{result_1_conf * 100:.2f}%"
+    }
+    
+    result_2 = {
+        "Model": "Hugging Face (DeiT-Tiny | Meta)",
+        "Prediction": result_2_label,
+        "Confidence": f"{result_2_conf * 100:.2f}%"
+    }
+    
+    result_3 = {
+        "Model": "Xception",
+        "Prediction": result_3_label,
+        "Confidence": f"{result_3_conf * 100:.2f}%"
+    }
+    
+    # Check if all models agree
+    all_agree = result_1_label == result_2_label == result_3_label
+    
+    # Create comparison text with HTML styling
+    if all_agree:
+        consensus_html = f"""
+        <div style="background-color: #d4edda; border: 2px solid #28a745; border-radius: 8px; padding: 20px; text-align: center;">
+            <h3 style="color: #155724; margin: 0; font-size: 24px;">All Models Agree!</h3>
+            <p style="color: #155724; margin: 10px 0 0 0; font-size: 18px; font-weight: bold;">{result_1_label}</p>
+        </div>
+        """
+    else:
+        consensus_html = f"""
+        <div style="background-color: #f8d7da; border: 2px solid #dc3545; border-radius: 8px; padding: 20px; text-align: center;">
+            <h3 style="color: #721c24; margin: 0; font-size: 24px;">Models Disagree</h3>
+            <p style="color: #721c24; margin: 10px 0 0 0; font-size: 16px;">Check predictions below for details</p>
+        </div>
+        """
+    
+    comparison_text = f"""
+    ## Comparison Results
+    
+    **Model 1 (Basic CNN):** {result_1_label} ({result_1_conf * 100:.2f}%)
+    
+    **Model 2 (Hugging Face (DeiT-Tiny | Meta)):** {result_2_label} ({result_2_conf * 100:.2f}%)
+    
+    **Model 3 (Xception):** {result_3_label} ({result_3_conf * 100:.2f}%)
+    """
+    
+    print(f"Prediction 1: {result_1_label} ({result_1_conf * 100:.2f}%)")
+    print(f"Prediction 2: {result_2_label} ({result_2_conf * 100:.2f}%)")
+    print(f"Prediction 3: {result_3_label} ({result_3_conf * 100:.2f}%)")
+    print(f"Consensus: {'All agree!' if all_agree else 'Disagreement detected'}")
+    print("="*60 + "\n")
+    
+    return result_1, result_2, result_3, comparison_text, result_1_probs, result_2_probs, result_3_probs, consensus_html
+
+
+# Gradio Interface
+
+def build_interface() -> gr.Blocks:    
+    with gr.Blocks(
+        title="PyTorch Unified Model Comparison",
+        theme=gr.themes.Soft()
+    ) as demo:
+        
+        # Header
+        gr.Markdown("""
+        # PyTorch Unified Model Comparison
+        
+        Upload an image and compare predictions from three different PyTorch models **simultaneously**.
+        
+        This tool helps you understand how different architectures (Basic CNN, Transformers, Xception)
+        classify the same image and identify where they agree or disagree.
+        """)
+        
+        # Model Information
+        with gr.Accordion("Model Information", open=False):
+            gr.Markdown(f"""
+            ### Model 1: Basic CNN
+            - **Description:** {MODELS_INFO['Model 1: Basic CNN']['description']}
+            - **Architecture:** 4 Conv blocks + BatchNorm + Global Avg Pooling
+            - **Input Size:** 224×224
+            
+            ### Model 2: Hugging Face Transformers (DeiT-Tiny | Meta)
+            - **Description:** {MODELS_INFO['Model 2: Hugging Face Transformers (DeiT-Tiny | Meta)']['description']}
+            - **Framework:** transformers library
+            
+            ### Model 3: Xception CNN
+            - **Description:** {MODELS_INFO['Model 3: Xception CNN']['description']}
+            - **Architecture:** Fine-tuned Xception with timm
+            """)
+        
+        # Input Section
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(
+                    type="pil",
+                    label="Upload Image",
+                    sources=["upload", "webcam"]
+                )
+                predict_btn = gr.Button("Predict with All Models", variant="primary", size="lg")
+                random_img_btn = gr.Button("Load Random Image from Dataset", variant="secondary", size="lg")
+        
+        # Output Section
+        gr.Markdown("## Results")
+        
+        with gr.Row():
+            with gr.Column():
+                result_1_box = gr.JSON(label="Model 1: Basic CNN")
+            with gr.Column():
+                result_2_box = gr.JSON(label="Model 2: Hugging Face (DeiT-Tiny)")
+            with gr.Column():
+                result_3_box = gr.JSON(label="Model 3: Xception")
+        
+        # Comparison Section
+        comparison_output = gr.Markdown(label="Comparison Summary")
+        
+        # Consensus Indicator (HTML for colored styling)
+        consensus_output = gr.HTML(value="<p></p>")
+        
+        # Class Probabilities Section
+        gr.Markdown("## Class Probabilities")
+        
+        with gr.Row():
+            with gr.Column():
+                probs_1 = gr.Label(label="Model 1: Basic CNN | Probabilities")
+            with gr.Column():
+                probs_2 = gr.Label(label="Model 2: DeiT-Tiny | Meta | Probabilities")
+            with gr.Column():
+                probs_3 = gr.Label(label="Model 3: Xception | Probabilities")
+        
+        # Connect button click
+        predict_btn.click(
+            fn=predict_all_models,
+            inputs=image_input,
+            outputs=[result_1_box, result_2_box, result_3_box, comparison_output, probs_1, probs_2, probs_3, consensus_output]
+        )
+        
+        # Also trigger on image upload
+        image_input.change(
+            fn=predict_all_models,
+            inputs=image_input,
+            outputs=[result_1_box, result_2_box, result_3_box, comparison_output, probs_1, probs_2, probs_3, consensus_output]
+        )
+        
+        # Connect random image button
+        random_img_btn.click(
+            fn=get_random_image,
+            inputs=None,
+            outputs=image_input
+        )
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        
+        **Available Classes:** Auto Rickshaws | Bikes | Cars | Motorcycles | Planes | Ships | Trains
+        
+        **Dataset:** Random images are loaded from [AIOmarRehan/Vehicles](https://huggingface.co/datasets/AIOmarRehan/Vehicles) on Hugging Face
+        
+        This unified application allows real-time comparison of three different deep learning models
+        to understand their individual strengths and weaknesses.
+        """)
+    
+    return demo
+
+
+# Main Entry Point
+
+if __name__ == "__main__":
+    # Load all models at startup
+    load_models()
+    
+    # Load dataset for random image selection
+    load_dataset_split()
+    
+    # Build and launch Gradio interface
+    demo = build_interface()
+    
+    server_name = os.getenv("GRADIO_SERVER_NAME", "0.0.0.0")
+    server_port = int(os.getenv("GRADIO_SERVER_PORT", "7860"))
+    
+    print(f"\nLaunching Gradio Interface on {server_name}:{server_port}")
+    print("Open your browser and navigate to http://localhost:7860\n")
+    
+    demo.launch(
+        server_name=server_name,
+        server_port=server_port,
+        share=False,
+        show_error=True
+    )

docker-compose.yml

@@ -0,0 +1,25 @@
+version: '3.8'
+
+services:
+  unified-model-app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: pytorch-unified-model-comparison
+    ports:
+      - "7860:7860"
+    environment:
+      PYTHONUNBUFFERED: 1
+      GRADIO_SERVER_NAME: 0.0.0.0
+      GRADIO_SERVER_PORT: 7860
+    volumes:
+      # Optional: Mount models directory if you want to update models without rebuilding
+      - ./models:/app/models
+    restart: unless-stopped
+    # Optional: Increase memory limit if needed
+    # deploy:
+    #   resources:
+    #     limits:
+    #       memory: 8G
+    #     reservations:
+    #       memory: 4G

docker-quickstart.bat

@@ -0,0 +1,16 @@
+@echo off
+REM Quick Docker Compose startup script for Windows
+
+echo Building Docker image...
+docker-compose build
+
+echo.
+echo Starting container...
+docker-compose up -d
+
+echo.
+echo Container is running!
+echo Access the app at: http://localhost:7860
+echo.
+echo To stop the container, run: docker-compose down
+echo To view logs, run: docker-compose logs -f

docker-quickstart.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Quick Docker Compose startup script for Linux/Mac
+
+echo "Building Docker image..."
+docker-compose build
+
+echo ""
+echo "Starting container..."
+docker-compose up -d
+
+echo ""
+echo "Container is running!"
+echo "Access the app at: http://localhost:7860"
+echo ""
+echo "To stop the container, run: docker-compose down"
+echo "To view logs, run: docker-compose logs -f"

model_handlers/__init__.py

@@ -0,0 +1 @@
+# Initialize model_handlers package

model_handlers/basic_cnn_handler.py

@@ -0,0 +1,191 @@
+import json
+import os
+from typing import List, Tuple, Dict
+import torch
+from PIL import Image
+from torchvision import transforms
+import numpy as np
+
+
+class BasicCNNModel:
+    
+    class CNN(torch.nn.Module):
+        def __init__(self, num_classes, dropout_rate=0.4):
+            super(BasicCNNModel.CNN, self).__init__()
+            self.dropout_rate = dropout_rate
+            
+            # Conv Block 1: 3 → 32 channels
+            self.conv1 = torch.nn.Conv2d(3, 32, kernel_size=3, padding=1, bias=False)
+            self.bn1 = torch.nn.BatchNorm2d(32)
+            self.relu1 = torch.nn.ReLU(inplace=True)
+            self.maxpool1 = torch.nn.MaxPool2d(kernel_size=2, stride=2)
+            
+            # Conv Block 2: 32 → 64 channels
+            self.conv2 = torch.nn.Conv2d(32, 64, kernel_size=3, padding=1, bias=False)
+            self.bn2 = torch.nn.BatchNorm2d(64)
+            self.relu2 = torch.nn.ReLU(inplace=True)
+            self.maxpool2 = torch.nn.MaxPool2d(kernel_size=2, stride=2)
+            
+            # Conv Block 3: 64 → 128 channels
+            self.conv3 = torch.nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False)
+            self.bn3 = torch.nn.BatchNorm2d(128)
+            self.relu3 = torch.nn.ReLU(inplace=True)
+            self.maxpool3 = torch.nn.MaxPool2d(kernel_size=2, stride=2)
+            
+            # Conv Block 4: 128 → 256 channels
+            self.conv4 = torch.nn.Conv2d(128, 256, kernel_size=3, padding=1, bias=False)
+            self.bn4 = torch.nn.BatchNorm2d(256)
+            self.relu4 = torch.nn.ReLU(inplace=True)
+            self.maxpool4 = torch.nn.MaxPool2d(kernel_size=2, stride=2)
+            
+            # Global Average Pooling (adaptive pooling to 1x1)
+            self.global_avg_pool = torch.nn.AdaptiveAvgPool2d((1, 1))
+            
+            # Classifier head with Dropout
+            self.dropout1 = torch.nn.Dropout(p=dropout_rate)
+            self.fc1 = torch.nn.Linear(256, 512)
+            self.fc1_relu = torch.nn.ReLU(inplace=True)
+            
+            self.dropout2 = torch.nn.Dropout(p=dropout_rate)
+            self.fc2 = torch.nn.Linear(512, num_classes)
+            
+            # Initialize weights
+            self._init_weights()
+        
+        def _init_weights(self):
+            for m in self.modules():
+                if isinstance(m, torch.nn.Conv2d):
+                    torch.nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                elif isinstance(m, torch.nn.BatchNorm2d):
+                    torch.nn.init.constant_(m.weight, 1)
+                    torch.nn.init.constant_(m.bias, 0)
+                elif isinstance(m, torch.nn.Linear):
+                    torch.nn.init.normal_(m.weight, 0, 0.01)
+                    if m.bias is not None:
+                        torch.nn.init.constant_(m.bias, 0)
+        
+        def forward(self, x):
+            # Block 1
+            x = self.conv1(x)
+            x = self.bn1(x)
+            x = self.relu1(x)
+            x = self.maxpool1(x)
+            
+            # Block 2
+            x = self.conv2(x)
+            x = self.bn2(x)
+            x = self.relu2(x)
+            x = self.maxpool2(x)
+            
+            # Block 3
+            x = self.conv3(x)
+            x = self.bn3(x)
+            x = self.relu3(x)
+            x = self.maxpool3(x)
+            
+            # Block 4
+            x = self.conv4(x)
+            x = self.bn4(x)
+            x = self.relu4(x)
+            x = self.maxpool4(x)
+            
+            # Global Average Pooling
+            x = self.global_avg_pool(x)
+            x = x.view(x.size(0), -1)  # Flatten
+            
+            # Classifier head
+            x = self.dropout1(x)
+            x = self.fc1(x)
+            x = self.fc1_relu(x)
+            
+            x = self.dropout2(x)
+            x = self.fc2(x)
+            
+            return x
+    
+    def __init__(self, model_dir: str):
+        self.model_dir = model_dir
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.transform = None
+        self.class_names = []
+        self.metadata = None
+        
+        print(f"[BasicCNN] Using device: {self.device}")
+        self._load_model()
+    
+    def _load_config(self) -> Dict:
+        config_path = os.path.join(self.model_dir, "deployment_config.json")
+        if not os.path.exists(config_path):
+            raise FileNotFoundError(f"Config not found: {config_path}")
+        with open(config_path, "r") as f:
+            return json.load(f)
+    
+    def _load_metadata(self, metadata_path: str) -> Dict:
+        with open(metadata_path, "r") as f:
+            return json.load(f)
+    
+    def _build_transforms(self, mean: List[float], std: List[float]) -> transforms.Compose:
+        return transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=mean, std=std),
+        ])
+    
+    def _load_model(self):
+        try:
+            config = self._load_config()
+            metadata_path = os.path.join(self.model_dir, config["metadata"])
+            state_dict_path = os.path.join(self.model_dir, config["model_state_dict"])
+            
+            self.metadata = self._load_metadata(metadata_path)
+            
+            # Load model
+            self.model = self.CNN(num_classes=self.metadata["num_classes"], dropout_rate=0.4)
+            state_dict = torch.load(state_dict_path, map_location=self.device)
+            self.model.load_state_dict(state_dict)
+            self.model.to(self.device)
+            self.model.eval()
+            
+            # Load transforms
+            self.transform = self._build_transforms(
+                self.metadata["normalization_mean"],
+                self.metadata["normalization_std"]
+            )
+            
+            # Load class names
+            class_names_dict = self.metadata.get("class_names", {})
+            self.class_names = [class_names_dict[str(i)] for i in range(len(class_names_dict))]
+            
+            print(f"[BasicCNN] Model loaded successfully. Classes: {self.class_names}")
+        
+        except Exception as e:
+            print(f"[BasicCNN] Error loading model: {e}")
+            raise
+    
+    def predict(self, image: Image.Image) -> Tuple[str, float, Dict[str, float]]:
+        if image is None:
+            return "No image provided", 0.0, {}
+        
+        try:
+            # Prepare image
+            if image.mode != "RGB":
+                image = image.convert("RGB")
+            
+            tensor = self.transform(image).unsqueeze(0).to(self.device)
+            
+            # Forward pass
+            with torch.no_grad():
+                logits = self.model(tensor)
+                probs = torch.softmax(logits, dim=1).cpu().numpy()[0]
+            
+            # Get predictions
+            class_idx = int(np.argmax(probs))
+            confidence = float(probs[class_idx])
+            prob_dict = {self.class_names[i]: float(probs[i]) for i in range(len(self.class_names))}
+            
+            return self.class_names[class_idx], confidence, prob_dict
+        
+        except Exception as e:
+            print(f"[BasicCNN] Error during prediction: {e}")
+            raise

model_handlers/hugging_face_handler.py

@@ -0,0 +1,71 @@
+import os
+from typing import Tuple, Dict
+import torch
+import numpy as np
+from PIL import Image
+from transformers import AutoModelForImageClassification, AutoImageProcessor
+
+
+class HuggingFaceModel:
+    
+    def __init__(self, model_dir: str):
+        self.model_dir = model_dir
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.processor = None
+        self.class_names = []
+        
+        print(f"[HuggingFace] Using device: {self.device}")
+        self._load_model()
+    
+    def _load_model(self):
+        try:
+            # Load model and processor
+            self.model = AutoModelForImageClassification.from_pretrained(self.model_dir)
+            self.processor = AutoImageProcessor.from_pretrained(self.model_dir)
+            
+            # Move to device
+            self.model.to(self.device).eval()
+            
+            # Get class names from model config
+            self.class_names = list(self.model.config.id2label.values())
+            
+            print(f"[HuggingFace] Model loaded successfully. Classes: {self.class_names}")
+        
+        except Exception as e:
+            print(f"[HuggingFace] Error loading model: {e}")
+            raise
+    
+    def _preprocess_image(self, img: Image.Image) -> Dict:
+        inputs = self.processor(images=img, return_tensors='pt')
+        return {k: v.to(self.device) for k, v in inputs.items()}
+    
+    def predict(self, image: Image.Image) -> Tuple[str, float, Dict[str, float]]:
+
+        if image is None:
+            return "No image provided", 0.0, {}
+        
+        try:
+            # Ensure image is PIL Image
+            if not isinstance(image, Image.Image):
+                image = Image.fromarray(image)
+            
+            # Preprocess image
+            inputs = self._preprocess_image(image)
+            
+            # Forward pass
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                logits = outputs.logits
+                probs = torch.softmax(logits, dim=-1).cpu().numpy()[0]
+            
+            # Get predictions
+            class_idx = int(np.argmax(probs))
+            confidence = float(probs[class_idx])
+            prob_dict = {self.class_names[i]: float(probs[i]) for i in range(len(self.class_names))}
+            
+            return self.class_names[class_idx], confidence, prob_dict
+        
+        except Exception as e:
+            print(f"[HuggingFace] Error during prediction: {e}")
+            raise

model_handlers/xception_handler.py

@@ -0,0 +1,110 @@
+import os
+from typing import Tuple, Dict
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from PIL import Image
+import timm
+
+
+class XceptionModel:
+    
+    # Class names must match training
+    CLASS_NAMES = ["Auto Rickshaws", "Bikes", "Cars", "Motorcycles", "Planes", "Ships", "Trains"]
+    
+    def __init__(self, model_dir: str, model_file: str = "best_model_finetuned_full.pt"):
+        self.model_dir = model_dir
+        self.model_file = model_file
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.inference_transform = None
+        self.class_names = self.CLASS_NAMES
+        
+        print(f"[Xception] Using device: {self.device}")
+        print(f"[Xception] Classes: {self.class_names}")
+        self._load_model()
+    
+    def _load_model(self):
+        try:
+            model_path = os.path.join(self.model_dir, self.model_file)
+            
+            if not os.path.exists(model_path):
+                raise FileNotFoundError(f"Model file not found: {model_path}")
+            
+            # Disable TorchDynamo (avoids CatchErrorsWrapper issues)
+            torch._dynamo.config.suppress_errors = True
+            torch._dynamo.reset()
+            
+            # Load the model
+            checkpoint = torch.load(model_path, map_location=self.device, weights_only=False)
+            
+            num_classes = len(self.CLASS_NAMES)
+            
+            if isinstance(checkpoint, dict) and not hasattr(checkpoint, "forward"):
+                # State dict: rebuild the model architecture used during training
+                model = timm.create_model("xception", pretrained=False, num_classes=num_classes)
+                in_features = model.get_classifier().in_features
+                model.fc = nn.Sequential(
+                    nn.Linear(in_features, 512),
+                    nn.ReLU(),
+                    nn.Dropout(0.5),
+                    nn.Linear(512, num_classes),
+                )
+                
+                state_dict = checkpoint
+                if any(k.startswith("_orig_mod.") for k in state_dict.keys()):
+                    state_dict = {k.replace("_orig_mod.", ""): v for k, v in state_dict.items()}
+                
+                model.load_state_dict(state_dict)
+            else:
+                # Full model
+                model = checkpoint
+                if hasattr(model, "_orig_mod"):
+                    model = model._orig_mod
+            
+            # Move model to device and set to evaluation mode
+            self.model = model.to(self.device).eval()
+            
+            # Load preprocessing transforms
+            data_config = timm.data.resolve_model_data_config(self.model)
+            self.inference_transform = timm.data.create_transform(**data_config, is_training=False)
+            
+            print(f"[Xception] Model loaded successfully from {model_path}")
+        
+        except Exception as e:
+            print(f"[Xception] Error loading model: {e}")
+            raise
+    
+    def _preprocess_image(self, img: Image.Image) -> torch.Tensor:
+        img = img.convert("RGB")
+        tensor = self.inference_transform(img).unsqueeze(0).to(self.device)
+        return tensor
+    
+    def predict(self, image: Image.Image) -> Tuple[str, float, Dict[str, float]]:
+        if image is None:
+            return "No image provided", 0.0, {}
+        
+        try:
+            # Ensure image is PIL Image
+            if not isinstance(image, Image.Image):
+                image = Image.fromarray(image)
+            
+            # Preprocess image
+            inputs = self._preprocess_image(image)
+            
+            # Forward pass
+            with torch.no_grad():
+                outputs = self.model(inputs)
+                probs = F.softmax(outputs, dim=-1).cpu().numpy()[0]
+            
+            # Get predictions
+            class_idx = int(np.argmax(probs))
+            confidence = float(probs[class_idx])
+            prob_dict = {self.class_names[i]: float(probs[i]) for i in range(len(self.class_names))}
+            
+            return self.class_names[class_idx], confidence, prob_dict
+        
+        except Exception as e:
+            print(f"[Xception] Error during prediction: {e}")
+            raise

models/basic_cnn/cnn_model_statedict_20260226_034332.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d646f75b07abffa476beeaa513f50b81904afab58cb978cee12175b1d9ce5c12
+size 2110727

models/basic_cnn/deployment_config.json

@@ -0,0 +1,11 @@
+{
+    "model_state_dict": "cnn_model_statedict_20260226_034332.pth",
+    "metadata": "model_metadata_20260226_034332.json",
+    "label_encoder": "label_encoder_20260226_034332.pkl",
+    "input_size": [
+        224,
+        224
+    ],
+    "batch_size": 32,
+    "device": "cuda"
+}

models/basic_cnn/model_metadata_20260226_034332.json

@@ -0,0 +1,31 @@
+{
+    "model_architecture": "PowerfulCNN",
+    "num_classes": 7,
+    "input_shape": [
+        3,
+        224,
+        224
+    ],
+    "normalization_mean": [
+        0.46052455367479384,
+        0.5079975089484482,
+        0.5388914703636689
+    ],
+    "normalization_std": [
+        0.2887674684678098,
+        0.2696178694962567,
+        0.2943129167380753
+    ],
+    "class_names": {
+        "0": "Auto Rickshaws",
+        "1": "Bikes",
+        "2": "Cars",
+        "3": "Motorcycles",
+        "4": "Planes",
+        "5": "Ships",
+        "6": "Trains"
+    },
+    "training_device": "cuda",
+    "saved_timestamp": "20260226_034332",
+    "model_size_mb": 2.012946128845215
+}

models/hugging_face/config.json

@@ -0,0 +1,44 @@
+{
+  "architectures": [
+    "ViTForImageClassification"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "dtype": "float32",
+  "encoder_stride": 16,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 192,
+  "id2label": {
+    "0": "Auto Rickshaws",
+    "1": "Bikes",
+    "2": "Cars",
+    "3": "Motorcycles",
+    "4": "Planes",
+    "5": "Ships",
+    "6": "Trains"
+  },
+  "image_size": 224,
+  "initializer_range": 0.02,
+  "intermediate_size": 768,
+  "label2id": {
+    "Auto Rickshaws": 0,
+    "Bikes": 1,
+    "Cars": 2,
+    "Motorcycles": 3,
+    "Planes": 4,
+    "Ships": 5,
+    "Trains": 6
+  },
+  "layer_norm_eps": 1e-12,
+  "model_type": "vit",
+  "num_attention_heads": 3,
+  "num_channels": 3,
+  "num_hidden_layers": 12,
+  "patch_size": 16,
+  "pooler_act": "tanh",
+  "pooler_output_size": 192,
+  "problem_type": "single_label_classification",
+  "qkv_bias": true,
+  "transformers_version": "5.0.0",
+  "use_cache": false
+}

models/hugging_face/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:891a3189e95ea1986818fd118084da21fb73369aebcacc5f1f50171354a20242
+size 22125780

models/hugging_face/preprocessor_config.json

@@ -0,0 +1,23 @@
+{
+  "do_convert_rgb": null,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_processor_type": "ViTImageProcessor",
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 224,
+    "width": 224
+  }
+}

models/xception/best_model_finetuned_full.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d08dd051737336a114b4bf8e73b1d3e6399285d9d1dee6b1d5a3e85b3066db7
+size 87820811

requirements.txt

@@ -0,0 +1,33 @@
+# PyTorch Unified Model Comparison
+# Combined dependencies for all three models
+
+# Web Framework & UI
+gradio
+fastapi
+uvicorn
+python-multipart
+
+# Core ML Framework
+torch
+torchvision
+
+# Hugging Face & Transformers
+transformers
+safetensors
+datasets
+evaluate
+
+# Image Processing & Numerical Computing
+pillow
+numpy
+opencv-python
+
+# Vision Models Library (for Xception)
+timm
+
+# Additional utilities
+pydantic
+huggingface_hub
+
+# Optional: For enhanced performance
+scikit-learn