Add CIFAR-100 ResNet-18 Gradio app with 77.45% accuracy model

.gitignore

@@ -0,0 +1,46 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyTorch
+*.pth
+*.pt
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environment
+.env
+.venv
+env/
+venv/
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp
+*.log

README.md

@@ -1,13 +1,63 @@
 ---
-title: ERA V4 S8 Assignment
-emoji: ⚡
-colorFrom: pink
-colorTo: green
+title: 🏆 CIFAR-100 ResNet-18 Classifier
+emoji: 🎯
+colorFrom: blue
+colorTo: purple
 sdk: gradio
 sdk_version: 5.49.1
 app_file: app.py
 pinned: false
-short_description: ERA V4 S8 Assignment
+short_description: CIFAR-100 ResNet-18 model achieving 77.45% accuracy - Upload images for instant classification!
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🏆 CIFAR-100 ResNet-18 Classifier - 77.45% Accuracy
+
+**Upload an image to classify it into one of 100 CIFAR-100 categories!**
+
+## 🎯 Model Performance
+
+| Metric | Target | Achieved | Status |
+|--------|--------|----------|--------|
+| 🏅 **Test Accuracy** | 73% | **77.45%** | ✅ **+4.45%** |
+| 📦 **Parameters** | ~11M | **11.22M** | ✅ **Optimal** |
+| ⏱️ **Training Time** | 100 epochs | **49 minutes** | ⚡ **Fast** |
+| 🎯 **Target Achievement** | Epoch 100 | **Epoch 58** | ✅ **58% through** |
+
+## 🏗️ Model Architecture
+
+- **ResNet-18** with BasicBlocks optimized for CIFAR-100
+- **11.22M parameters** with 133-pixel receptive field
+- **Advanced augmentation** pipeline (Albumentations + Mixup + CutMix)
+- **OneCycle scheduler** for optimal learning rate progression
+
+## 🏆 Top Performing Classes
+
+| Rank | Class | Accuracy | Performance |
+|------|-------|----------|-------------|
+| 1 | **wardrobe** | 97.00% | 🏆 Exceptional |
+| 2 | **motorcycle** | 93.00% | 🥈 Excellent |
+| 3 | **bicycle** | 93.00% | 🥉 Excellent |
+| 4 | **aquarium_fish** | 92.00% | ⭐ Strong |
+
+## 📚 CIFAR-100 Categories
+
+The model classifies images into **100 fine-grained categories** across **20 superclasses**:
+
+- **Animals:** mammals, fish, insects, reptiles
+- **Vehicles:** cars, trucks, motorcycles, bicycles
+- **Household:** furniture, electrical devices, containers
+- **Nature:** trees, flowers, natural landscapes
+- **People:** different age groups and genders
+
+## 🚀 Usage
+
+Simply upload an image and get instant predictions with confidence scores for the top 5 most likely classes.
+
+## 📖 Documentation
+
+For complete technical details, training logs, and model analysis, visit the [GitHub Repository](https://github.com/santhoshv6/era_v4_s8_assignment).
+
+---
+
+**Model trained as part of ERA V4 Course Session 8 - Deep Learning Specialization**

app.py

@@ -0,0 +1,214 @@
+import gradio as gr
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+from PIL import Image
+import numpy as np
+import requests
+from io import BytesIO
+
+# CIFAR-100 class names
+CIFAR100_CLASSES = [
+    'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle', 
+    'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel', 
+    'can', 'castle', 'caterpillar', 'cattle', 'chair', 'chimpanzee', 'clock', 
+    'cloud', 'cockroach', 'couch', 'crab', 'crocodile', 'cup', 'dinosaur', 
+    'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster', 
+    'house', 'kangaroo', 'keyboard', 'lamp', 'lawn_mower', 'leopard', 'lion', 
+    'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain', 'mouse', 
+    'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear', 
+    'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine', 
+    'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose', 'sea', 
+    'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake', 
+    'spider', 'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table', 
+    'tank', 'telephone', 'television', 'tiger', 'tractor', 'train', 'trout', 
+    'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman', 
+    'worm'
+]
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion*planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion*planes)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+class ResNet18(nn.Module):
+    def __init__(self, num_classes=100):
+        super(ResNet18, self).__init__()
+        self.in_planes = 64
+
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.layer1 = self._make_layer(BasicBlock, 64, 2, stride=1)
+        self.layer2 = self._make_layer(BasicBlock, 128, 2, stride=2)
+        self.layer3 = self._make_layer(BasicBlock, 256, 2, stride=2)
+        self.layer4 = self._make_layer(BasicBlock, 512, 2, stride=2)
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.linear = nn.Linear(512*BasicBlock.expansion, num_classes)
+
+    def _make_layer(self, block, planes, num_blocks, stride):
+        strides = [stride] + [1]*(num_blocks-1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_planes, planes, stride))
+            self.in_planes = planes * block.expansion
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.layer1(out)
+        out = self.layer2(out)
+        out = self.layer3(out)
+        out = self.layer4(out)
+        out = self.avgpool(out)
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+# Initialize model
+model = ResNet18(num_classes=100)
+
+# Load the pre-trained model
+@torch.no_grad()
+def load_model():
+    try:
+        # Try to download the model from your GitHub releases
+        model_url = "https://github.com/santhoshv6/era_v4_s8_assignment/releases/download/v1.0/model_best.pth"
+        response = requests.get(model_url)
+        response.raise_for_status()
+        
+        # Load the model state dict
+        checkpoint = torch.load(BytesIO(response.content), map_location='cpu')
+        model.load_state_dict(checkpoint['state_dict'])
+        model.eval()
+        return True
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        return False
+
+# Define image preprocessing
+transform = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.ToTensor(),
+    transforms.Normalize((0.5071, 0.4867, 0.4408), (0.2675, 0.2565, 0.2761))
+])
+
+def predict(image):
+    """
+    Predict the class of an input image using the trained ResNet-18 model.
+    
+    Args:
+        image: PIL Image or numpy array
+    
+    Returns:
+        Dictionary with predictions and confidence scores
+    """
+    try:
+        # Convert to PIL Image if needed
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        
+        # Convert to RGB if needed
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Preprocess the image
+        input_tensor = transform(image).unsqueeze(0)
+        
+        # Make prediction
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            probabilities = F.softmax(outputs, dim=1)
+            
+        # Get top 5 predictions
+        top5_prob, top5_idx = torch.topk(probabilities, 5, dim=1)
+        
+        # Create results dictionary
+        results = {}
+        for i in range(5):
+            class_idx = top5_idx[0][i].item()
+            class_name = CIFAR100_CLASSES[class_idx]
+            confidence = top5_prob[0][i].item()
+            results[f"{class_name}"] = confidence
+        
+        return results
+        
+    except Exception as e:
+        return {"Error": f"Prediction failed: {str(e)}"}
+
+# Load model on startup
+model_loaded = load_model()
+
+# Create Gradio interface
+def create_interface():
+    if not model_loaded:
+        return gr.Interface(
+            fn=lambda x: {"Error": "Model failed to load. Please try again later."},
+            inputs=gr.Image(type="pil"),
+            outputs=gr.Label(num_top_classes=5),
+            title="❌ Model Loading Error",
+            description="The CIFAR-100 ResNet model could not be loaded."
+        )
+    
+    return gr.Interface(
+        fn=predict,
+        inputs=gr.Image(type="pil", label="Upload an Image"),
+        outputs=gr.Label(num_top_classes=5, label="Top 5 Predictions"),
+        title="🏆 CIFAR-100 ResNet-18 Classifier - 77.45% Accuracy",
+        description="""
+        **Upload an image to classify it into one of 100 CIFAR-100 categories!**
+        
+        🎯 **Model Performance:** 77.45% test accuracy (4.45% above target)  
+        🏗️ **Architecture:** ResNet-18 with 11.22M parameters  
+        📊 **Training:** 100 epochs on Tesla P100, reached target at epoch 58  
+        
+        **Best performing classes:** wardrobe (97%), motorcycle (93%), bicycle (93%), aquarium_fish (92%)
+        
+        *This model excels at furniture, vehicles, and distinctive objects. For best results, upload clear images similar to CIFAR-100 style.*
+        """,
+        examples=[
+            # You can add example images here if available
+        ],
+        article="""
+        ### 📚 About This Model
+        
+        This ResNet-18 model was trained on CIFAR-100 dataset achieving **77.45% accuracy**, exceeding the 73% target by 4.45%.
+        
+        **Key Features:**
+        - 🏗️ **Optimized Architecture:** ResNet-18 with BasicBlocks
+        - 🎨 **Advanced Augmentation:** Albumentations + Mixup + CutMix
+        - ⚡ **Fast Training:** OneCycle learning rate scheduler
+        - 🔍 **Interpretable:** GradCAM visualizations available
+        
+        **CIFAR-100 Categories:** 100 fine-grained classes across 20 superclasses including animals, vehicles, household items, and natural objects.
+        
+        📖 **Full Documentation:** [GitHub Repository](https://github.com/santhoshv6/era_v4_s8_assignment)
+        """,
+        theme=gr.themes.Soft(),
+        allow_flagging="never"
+    )
+
+# Create and launch the interface
+demo = create_interface()
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,6 @@
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=9.0.0
+numpy>=1.21.0
+requests>=2.25.0
+gradio>=4.0.0