Upload 5 files

app.py

@@ -0,0 +1,159 @@
+"""
+Gradio App for Bird Classification - Hugging Face Deployment
+Enhanced model with 76.74% accuracy from Stage 2 training.
+"""
+import gradio as gr
+import torch
+import torch.nn.functional as F
+from PIL import Image
+import json
+import numpy as np
+from torchvision import transforms
+import os
+
+# Import our model architecture
+from models import create_model
+
+# Configuration
+MODEL_PATH = "best_model.pth"
+CLASS_NAMES_PATH = "class_names.json"
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Load class names
+with open(CLASS_NAMES_PATH, 'r') as f:
+    class_names = json.load(f)
+
+NUM_CLASSES = len(class_names)
+
+# Load model
+print("Loading model...")
+model = create_model(
+    num_classes=NUM_CLASSES,
+    model_type='efficientnet_b2',  # Stage 2 architecture
+    pretrained=False,  # We're loading trained weights
+    dropout_rate=0.3   # Stage 2 dropout rate
+)
+
+# Load trained weights
+if os.path.exists(MODEL_PATH):
+    checkpoint = torch.load(MODEL_PATH, map_location=DEVICE)
+    if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+        model.load_state_dict(checkpoint['model_state_dict'])
+    else:
+        model.load_state_dict(checkpoint)
+    print("✅ Model loaded successfully!")
+else:
+    print("⚠️ Model file not found. Please ensure best_model.pth is in the repository.")
+
+model.to(DEVICE)
+model.eval()
+
+# Image preprocessing (Stage 2 configuration)
+transform = transforms.Compose([
+    transforms.Resize((320, 320)),  # Stage 2 image size
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225]
+    )
+])
+
+def predict_bird(image):
+    """
+    Predict bird species from uploaded image.
+    """
+    try:
+        # Preprocess image
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image.astype('uint8'))
+        
+        # Convert to RGB if needed
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Apply transformations
+        input_tensor = transform(image).unsqueeze(0).to(DEVICE)
+        
+        # Prediction
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            probabilities = F.softmax(outputs, dim=1)
+            confidence, predicted = torch.max(probabilities, 1)
+            
+            # Get top 5 predictions
+            top5_prob, top5_indices = torch.topk(probabilities, 5)
+            
+            # Format results
+            results = {}
+            for i in range(5):
+                class_idx = top5_indices[0][i].item()
+                prob = top5_prob[0][i].item()
+                class_name = class_names[class_idx].replace('_', ' ')
+                results[class_name] = float(prob)
+        
+        return results
+        
+    except Exception as e:
+        return {"Error": f"Prediction failed: {str(e)}"}
+
+# Create Gradio interface
+title = "🐦 Bird Species Classifier"
+description = """
+## Advanced Bird Classification Model (76.74% Accuracy)
+
+This model can classify **200 different bird species** using advanced deep learning techniques:
+
+### Model Details:
+- **Architecture**: EfficientNet-B2 with enhanced regularization
+- **Training Strategy**: Progressive training with MixUp augmentation
+- **Performance**: 76.74% test accuracy (Stage 2 results)
+- **Dataset**: CUB-200-2011 (200 bird species)
+
+### How to use:
+1. Upload a clear image of a bird
+2. The model will predict the top 5 most likely species
+3. Confidence scores show the model's certainty
+
+### Best Results Tips:
+- Use high-quality, well-lit images
+- Ensure the bird is clearly visible
+- Close-up shots work better than distant ones
+- Natural lighting produces better results
+
+**Note**: This model was trained on the CUB-200-2011 dataset and works best with North American bird species.
+"""
+
+article = """
+### Technical Implementation:
+- **Framework**: PyTorch with EfficientNet-B2 backbone
+- **Training**: Progressive training with MixUp data augmentation
+- **Regularization**: Optimized dropout rates (0.3) and advanced augmentation
+- **Image Size**: 320x320 pixels for optimal detail capture
+
+### About the Model:
+This bird classifier was developed using advanced machine learning techniques including:
+- Transfer learning from ImageNet-pretrained EfficientNet
+- Progressive training strategy across multiple stages
+- MixUp augmentation for improved generalization
+- Comprehensive evaluation on 200 bird species
+
+For more details about the training process and methodology, please refer to the repository documentation.
+"""
+
+# Create the interface
+iface = gr.Interface(
+    fn=predict_bird,
+    inputs=gr.Image(type="pil", label="Upload Bird Image"),
+    outputs=gr.Label(num_top_classes=5, label="Predictions"),
+    title=title,
+    description=description,
+    article=article,
+    examples=[
+        # You can add example images here if you have them
+    ],
+    allow_flagging="never",
+    theme=gr.themes.Soft()
+)
+
+if __name__ == "__main__":
+    iface.launch(debug=True)

best_model.pth

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

class_names.json

@@ -0,0 +1,52 @@
+[
+  "Black_footed_Albatross", "Laysan_Albatross", "Sooty_Albatross", "Groove_billed_Ani",
+  "Crested_Auklet", "Least_Auklet", "Parakeet_Auklet", "Rhinoceros_Auklet",
+  "Brewer_Blackbird", "Red_winged_Blackbird", "Rusty_Blackbird", "Yellow_headed_Blackbird",
+  "Bobolink", "Indigo_Bunting", "Lazuli_Bunting", "Painted_Bunting",
+  "Cardinal", "Spotted_Catbird", "Gray_Catbird", "Yellow_breasted_Chat",
+  "Eastern_Towhee", "Chuck_will_Widow", "Brandt_Cormorant", "Red_faced_Cormorant",
+  "Pelagic_Cormorant", "Bronzed_Cowbird", "Shiny_Cowbird", "Brown_Creeper",
+  "American_Crow", "Fish_Crow", "Black_billed_Cuckoo", "Mangrove_Cuckoo",
+  "Yellow_billed_Cuckoo", "Gray_crowned_Rosy_Finch", "Purple_Finch", "Northern_Flicker",
+  "Acadian_Flycatcher", "Great_Crested_Flycatcher", "Least_Flycatcher", "Olive_sided_Flycatcher",
+  "Scissor_tailed_Flycatcher", "Vermilion_Flycatcher", "Yellow_bellied_Flycatcher", "Frigatebird",
+  "Northern_Fulmar", "Gadwall", "American_Goldfinch", "European_Goldfinch",
+  "Boat_tailed_Grackle", "Eared_Grebe", "Horned_Grebe", "Pied_billed_Grebe",
+  "Western_Grebe", "Blue_Grosbeak", "Evening_Grosbeak", "Pine_Grosbeak",
+  "Rose_breasted_Grosbeak", "Pigeon_Guillemot", "California_Gull", "Glaucous_winged_Gull",
+  "Heermann_Gull", "Herring_Gull", "Ivory_Gull", "Ring_billed_Gull",
+  "Slaty_backed_Gull", "Western_Gull", "Anna_Hummingbird", "Ruby_throated_Hummingbird",
+  "Rufous_Hummingbird", "Green_Violetear", "Long_tailed_Jaeger", "Pomarine_Jaeger",
+  "Blue_Jay", "Florida_Jay", "Green_Jay", "Dark_eyed_Junco",
+  "Tropical_Kingbird", "Gray_Kingbird", "Belted_Kingfisher", "Green_Kingfisher",
+  "Pied_Kingfisher", "Ringed_Kingfisher", "White_breasted_Kingfisher", "Red_legged_Kittiwake",
+  "Horned_Lark", "Pacific_Lark", "Mallard", "Western_Meadowlark",
+  "Hooded_Merganser", "Red_breasted_Merganser", "Mockingbird", "Nighthawk",
+  "Clark_Nutcracker", "White_breasted_Nuthatch", "Baltimore_Oriole", "Hooded_Oriole",
+  "Orchard_Oriole", "Scott_Oriole", "Ovenbird", "Brown_Pelican",
+  "White_Pelican", "Western_Wood_Pewee", "Sayornis", "American_Pipit",
+  "Whip_poor_Will", "Horned_Puffin", "Common_Raven", "White_necked_Raven",
+  "American_Redstart", "Geococcyx", "Loggerhead_Shrike", "Great_Grey_Shrike",
+  "Baird_Sparrow", "Black_throated_Sparrow", "Brewer_Sparrow", "Chipping_Sparrow",
+  "Clay_colored_Sparrow", "House_Sparrow", "Field_Sparrow", "Fox_Sparrow",
+  "Grasshopper_Sparrow", "Harris_Sparrow", "Henslow_Sparrow", "Le_Conte_Sparrow",
+  "Lincoln_Sparrow", "Nelson_Sharp_tailed_Sparrow", "Savannah_Sparrow", "Seaside_Sparrow",
+  "Song_Sparrow", "Tree_Sparrow", "Vesper_Sparrow", "White_crowned_Sparrow",
+  "White_throated_Sparrow", "Cape_Glossy_Starling", "Bank_Swallow", "Barn_Swallow",
+  "Cliff_Swallow", "Tree_Swallow", "Scarlet_Tanager", "Summer_Tanager",
+  "Artic_Tern", "Black_Tern", "Caspian_Tern", "Common_Tern",
+  "Elegant_Tern", "Forsters_Tern", "Least_Tern", "Green_tailed_Towhee",
+  "Brown_Thrasher", "Sage_Thrasher", "Black_capped_Vireo", "Blue_headed_Vireo",
+  "Philadelphia_Vireo", "Red_eyed_Vireo", "Warbling_Vireo", "White_eyed_Vireo",
+  "Yellow_throated_Vireo", "Bay_breasted_Warbler", "Black_and_white_Warbler", "Black_throated_Blue_Warbler",
+  "Blue_winged_Warbler", "Canada_Warbler", "Cape_May_Warbler", "Cerulean_Warbler",
+  "Chestnut_sided_Warbler", "Golden_winged_Warbler", "Hooded_Warbler", "Kentucky_Warbler",
+  "Magnolia_Warbler", "Mourning_Warbler", "Myrtle_Warbler", "Nashville_Warbler",
+  "Orange_crowned_Warbler", "Palm_Warbler", "Pine_Warbler", "Prairie_Warbler",
+  "Prothonotary_Warbler", "Tennessee_Warbler", "Wilson_Warbler", "Worm_eating_Warbler",
+  "Yellow_Warbler", "Northern_Waterthrush", "Louisiana_Waterthrush", "Bohemian_Waxwing",
+  "Cedar_Waxwing", "American_Three_toed_Woodpecker", "Pileated_Woodpecker", "Red_bellied_Woodpecker",
+  "Red_cockaded_Woodpecker", "Red_headed_Woodpecker", "Downy_Woodpecker", "Bewick_Wren",
+  "Cactus_Wren", "Carolina_Wren", "House_Wren", "Marsh_Wren",
+  "Rock_Wren", "Winter_Wren", "Common_Yellowthroat"
+]

models.py

@@ -0,0 +1,247 @@
+"""
+Bird classification model architectures with overfitting prevention.
+"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision import models
+from typing import Optional
+
+# Try to import EfficientNet
+try:
+    from efficientnet_pytorch import EfficientNet
+    EFFICIENTNET_AVAILABLE = True
+except ImportError:
+    EFFICIENTNET_AVAILABLE = False
+    print("EfficientNet not available. Install with: pip install efficientnet-pytorch")
+
+
+class BirdClassifier(nn.Module):
+    """
+    Bird classification model with ResNet backbone and overfitting prevention.
+    """
+    
+    def __init__(self, num_classes: int, architecture: str = 'resnet50', 
+                 pretrained: bool = True, dropout_rate: float = 0.5,
+                 freeze_backbone: bool = False):
+        """
+        Initialize the bird classifier.
+        
+        Args:
+            num_classes: Number of bird classes
+            architecture: Backbone architecture ('resnet50', 'resnet18', 'efficientnet_b0')
+            pretrained: Whether to use pretrained weights
+            dropout_rate: Dropout rate for regularization
+            freeze_backbone: Whether to freeze backbone weights
+        """
+        super(BirdClassifier, self).__init__()
+        
+        self.num_classes = num_classes
+        self.dropout_rate = dropout_rate
+        
+        # Choose backbone architecture
+        if architecture == 'resnet50':
+            self.backbone = models.resnet50(pretrained=pretrained)
+            num_features = self.backbone.fc.in_features
+            self.backbone.fc = nn.Identity()  # Remove original classifier
+        elif architecture == 'resnet18':
+            self.backbone = models.resnet18(pretrained=pretrained)
+            num_features = self.backbone.fc.in_features
+            self.backbone.fc = nn.Identity()
+        elif architecture == 'resnet101':
+            self.backbone = models.resnet101(pretrained=pretrained)
+            num_features = self.backbone.fc.in_features
+            self.backbone.fc = nn.Identity()
+        elif architecture == 'efficientnet_b0':
+            self.backbone = models.efficientnet_b0(pretrained=pretrained)
+            num_features = self.backbone.classifier[1].in_features
+            self.backbone.classifier = nn.Identity()
+        elif architecture in ['efficientnet_b1', 'efficientnet_b2', 'efficientnet_b3', 'efficientnet_b4'] and EFFICIENTNET_AVAILABLE:
+            model_name = architecture.replace('_', '-')
+            if pretrained:
+                self.backbone = EfficientNet.from_pretrained(model_name)
+            else:
+                self.backbone = EfficientNet.from_name(model_name)
+            num_features = self.backbone._fc.in_features
+            self.backbone._fc = nn.Identity()
+        else:
+            raise ValueError(f"Unsupported architecture: {architecture}")
+        
+        # Freeze backbone if requested
+        if freeze_backbone:
+            for param in self.backbone.parameters():
+                param.requires_grad = False
+        
+        # Enhanced classifier head with batch normalization and progressive dimension reduction
+        # Optimized regularization for Stage 2 performance (76.74% accuracy)
+        self.classifier = nn.Sequential(
+            nn.Dropout(p=dropout_rate * 0.6),  # Stage 2 optimization: 0.3 * 0.6 = 0.18
+            nn.Linear(num_features, 512),  # Optimized size
+            nn.BatchNorm1d(512),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=dropout_rate * 0.5),  # Stage 2 optimization: 0.3 * 0.5 = 0.15
+            nn.Linear(512, 256),
+            nn.BatchNorm1d(256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=dropout_rate * 0.3),  # Stage 2 optimization: 0.3 * 0.3 = 0.09
+            nn.Linear(256, num_classes)
+        )
+        
+        # Initialize weights
+        self._initialize_weights()
+    
+    def _initialize_weights(self):
+        """Initialize classifier weights with better initialization."""
+        for m in self.classifier.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight, gain=nn.init.calculate_gain('relu'))
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm1d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+    
+    def forward(self, x):
+        """Forward pass."""
+        features = self.backbone(x)
+        output = self.classifier(features)
+        return output
+
+
+class LightweightBirdClassifier(nn.Module):
+    """
+    Lightweight CNN model for bird classification with batch normalization.
+    """
+    
+    def __init__(self, num_classes: int, dropout_rate: float = 0.5):
+        """
+        Initialize lightweight classifier.
+        
+        Args:
+            num_classes: Number of bird classes
+            dropout_rate: Dropout rate for regularization
+        """
+        super(LightweightBirdClassifier, self).__init__()
+        
+        self.features = nn.Sequential(
+            # Block 1
+            nn.Conv2d(3, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(32, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(p=dropout_rate/2),
+            
+            # Block 2
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(p=dropout_rate/2),
+            
+            # Block 3
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout2d(p=dropout_rate/2),
+            
+            # Block 4
+            nn.Conv2d(128, 256, kernel_size=3, padding=1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(inplace=True),
+            nn.AdaptiveAvgPool2d((1, 1)),
+        )
+        
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            nn.Dropout(p=dropout_rate),
+            nn.Linear(256, 128),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=dropout_rate),
+            nn.Linear(128, num_classes)
+        )
+        
+        self._initialize_weights()
+    
+    def _initialize_weights(self):
+        """Initialize model weights."""
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                nn.init.constant_(m.bias, 0)
+    
+    def forward(self, x):
+        """Forward pass."""
+        x = self.features(x)
+        x = self.classifier(x)
+        return x
+
+
+def create_model(num_classes: int, model_type: str = 'resnet50', 
+                pretrained: bool = True, dropout_rate: float = 0.5,
+                freeze_backbone: bool = False) -> nn.Module:
+    """
+    Create a bird classification model.
+    
+    Args:
+        num_classes: Number of bird classes
+        model_type: Type of model ('resnet50', 'resnet18', 'efficientnet_b0', 'lightweight')
+        pretrained: Whether to use pretrained weights
+        dropout_rate: Dropout rate for regularization
+        freeze_backbone: Whether to freeze backbone weights (ignored for lightweight model)
+    
+    Returns:
+        PyTorch model
+    """
+    if model_type == 'lightweight':
+        return LightweightBirdClassifier(num_classes, dropout_rate)
+    else:
+        return BirdClassifier(num_classes, model_type, pretrained, 
+                             dropout_rate, freeze_backbone)
+
+
+class ModelEnsemble(nn.Module):
+    """
+    Ensemble of multiple models for improved performance.
+    """
+    
+    def __init__(self, models_list: list):
+        """
+        Initialize model ensemble.
+        
+        Args:
+            models_list: List of trained models to ensemble
+        """
+        super(ModelEnsemble, self).__init__()
+        self.models = nn.ModuleList(models_list)
+        
+    def forward(self, x):
+        """Forward pass through all models and average predictions."""
+        predictions = []
+        for model in self.models:
+            with torch.no_grad():
+                pred = F.softmax(model(x), dim=1)
+                predictions.append(pred)
+        
+        # Average predictions
+        ensemble_pred = torch.stack(predictions, dim=0).mean(dim=0)
+        return torch.log(ensemble_pred + 1e-8)  # Convert back to log probabilities

requirements.txt

@@ -0,0 +1,11 @@
+torch>=1.12.0
+torchvision>=0.13.0
+numpy>=1.21.0
+Pillow>=8.3.0
+matplotlib>=3.5.0
+scikit-learn>=1.1.0
+tqdm>=4.64.0
+pandas>=1.4.0
+seaborn>=0.11.0
+efficientnet-pytorch>=0.7.1
+gradio>=3.40.0