Update app.py

app.py

@@ -2,176 +2,100 @@ import torch
 import gradio as gr
 import torch.nn as nn
 import torch.nn.functional as F
+import os
+from pathlib import Path
 from torch.nn import init
 import torchvision.transforms as transforms
 from PIL import Image
 
-# MobileNetV3 Model Definition (keep this exactly as in your original code)
-class hswish(nn.Module):
-    def forward(self, x):
-        return x * F.relu6(x + 3) / 6
+# ... [Keep all your existing model definitions and initialization code] ...
 
-class hsigmoid(nn.Module):
-    def forward(self, x):
-        return F.relu6(x + 3) / 6
+# Precompute example image paths
+example_dir = "examples"
+example_images = [os.path.join(example_dir, f) for f in os.listdir(example_dir) 
+                 if f.lower().endswith(('.png', '.jpg', '.jpeg', '.webp'))]
 
-class SeModule(nn.Module):
-    def __init__(self, in_size, reduction=4):
-        super().__init__()
-        self.se = nn.Sequential(
-            nn.AdaptiveAvgPool2d(1),
-            nn.Conv2d(in_size, in_size//reduction, 1, bias=False),
-            nn.BatchNorm2d(in_size//reduction),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(in_size//reduction, in_size, 1, bias=False),
-            nn.BatchNorm2d(in_size),
-            hsigmoid()
-        )
-
-    def forward(self, x):
-        return x * self.se(x)
-
-class Block(nn.Module):
-    def __init__(self, kernel_size, in_size, expand_size, out_size, nolinear, semodule, stride):
-        super().__init__()
-        self.stride = stride
-        self.se = semodule
-        self.conv1 = nn.Conv2d(in_size, expand_size, 1, 1, 0, bias=False)
-        self.bn1 = nn.BatchNorm2d(expand_size)
-        self.nolinear1 = nolinear
-        self.conv2 = nn.Conv2d(expand_size, expand_size, kernel_size, stride, kernel_size//2, groups=expand_size, bias=False)
-        self.bn2 = nn.BatchNorm2d(expand_size)
-        self.nolinear2 = nolinear
-        self.conv3 = nn.Conv2d(expand_size, out_size, 1, 1, 0, bias=False)
-        self.bn3 = nn.BatchNorm2d(out_size)
-        self.shortcut = nn.Sequential()
-        if stride == 1 and in_size != out_size:
-            self.shortcut = nn.Sequential(
-                nn.Conv2d(in_size, out_size, 1, 1, 0, bias=False),
-                nn.BatchNorm2d(out_size),
-            )
-
-    def forward(self, x):
-        out = self.nolinear1(self.bn1(self.conv1(x)))
-        out = self.nolinear2(self.bn2(self.conv2(out)))
-        out = self.bn3(self.conv3(out))
-        if self.se: out = self.se(out)
-        return out + self.shortcut(x) if self.stride==1 else out
-
-class MobileNetV3_Small(nn.Module):
-    def __init__(self, num_classes=30):
-        super().__init__()
-        self.conv1 = nn.Conv2d(3, 16, 3, 2, 1, bias=False)
-        self.bn1 = nn.BatchNorm2d(16)
-        self.hs1 = hswish()
-        self.bneck = nn.Sequential(
-            Block(3, 16, 16, 16, nn.ReLU(), SeModule(16), 2),
-            Block(3, 16, 72, 24, nn.ReLU(), None, 2),
-            Block(3, 24, 88, 24, nn.ReLU(), None, 1),
-            Block(5, 24, 96, 40, hswish(), SeModule(40), 2),
-            Block(5, 40, 240, 40, hswish(), SeModule(40), 1),
-            Block(5, 40, 240, 40, hswish(), SeModule(40), 1),
-            Block(5, 40, 120, 48, hswish(), SeModule(48), 1),
-            Block(5, 48, 144, 48, hswish(), SeModule(48), 1),
-            Block(5, 48, 288, 96, hswish(), SeModule(96), 2),
-            Block(5, 96, 576, 96, hswish(), SeModule(96), 1),
-            Block(5, 96, 576, 96, hswish(), SeModule(96), 1),
-        )
-        self.conv2 = nn.Conv2d(96, 576, 1, 1, 0, bias=False)
-        self.bn2 = nn.BatchNorm2d(576)
-        self.hs2 = hswish()
-        self.linear3 = nn.Linear(576, 1280)
-        self.bn3 = nn.BatchNorm1d(1280)
-        self.hs3 = hswish()
-        self.linear4 = nn.Linear(1280, num_classes)
-        
-        for m in self.modules():
-            if isinstance(m, nn.Conv2d):
-                init.kaiming_normal_(m.weight, mode='fan_out')
-                if m.bias is not None: init.constant_(m.bias, 0)
-            elif isinstance(m, nn.BatchNorm2d):
-                init.constant_(m.weight, 1)
-                init.constant_(m.bias, 0)
-            elif isinstance(m, nn.Linear):
-                init.normal_(m.weight, std=0.001)
-                if m.bias is not None: init.constant_(m.bias, 0)
-
-    def forward(self, x):
-        x = self.hs1(self.bn1(self.conv1(x)))
-        x = self.bneck(x)
-        x = self.hs2(self.bn2(self.conv2(x)))
-        x = F.avg_pool2d(x, x.size()[2:])
-        x = x.view(x.size(0), -1)
-        x = self.hs3(self.bn3(self.linear3(x)))
-        return self.linear4(x)
-
-# Initialize Model
-model = MobileNetV3_Small().cpu()
-model.load_state_dict(torch.load("MobileNet3_small_StateDictionary.pth", map_location='cpu'))
-model.eval()
-
-# Class Labels
-classes = [
-    'antelope', 'buffalo', 'chimpanzee', 'cow', 'deer', 'dolphin',
-    'elephant', 'fox', 'giant+panda', 'giraffe', 'gorilla', 'grizzlybear',
-    'hamster', 'hippopotamus', 'horse', 'humpbackwhale', 'leopard', 'lion',
-    'moose', 'otter', 'ox', 'pig', 'polarbear', 'rabbit', 'rhinoceros',
-    'seal', 'sheep', 'squirrel', 'tiger', 'zebra'
-]
-
-# Preprocessing
-preprocess = transforms.Compose([
-    transforms.Resize(256),
-    transforms.CenterCrop(224),
-    transforms.ToTensor(),
-    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-])
-
-def predict(images):
-    """Process multiple images and return predictions"""
-    predictions = []
-    
-    # Batch processing
-    batch = torch.stack([preprocess(Image.open(img).convert('RGB')) for img in images])
-    
-    with torch.inference_mode():
-        outputs = model(batch)
-        _, preds = torch.max(outputs, 1)
-    
-    return ", ".join([classes[p] for p in preds.cpu().numpy()])
+# Custom CSS for styling
+css = """
+.centered-examples {
+    margin: 0 auto !important;
+    justify-content: center !important;
+    gap: 8px !important;
+}
+.centered-examples .thumb {
+    height: 100px !important;
+    width: 100px !important;
+    object-fit: cover !important;
+}
+"""
 
-# Gradio Interface
-with gr.Blocks(title="Animal Classifier") as demo:
+with gr.Blocks(title="Animal Classifier", css=css) as demo:
     gr.Markdown("## 🐾 Animal Classifier")
     gr.Markdown("Upload multiple animal images to get predictions!")
-    gr.Markdown("Detectable Classes: antelope, buffalo, chimpanzee, cow, deer, dolphin, elephant, fox, giantpanda, giraffe, gorilla, grizzlybear, hamster, hippopotamus, horse, humpbackwhale, leopard, lion, moose, otter, ox, pig, polarbear, rabbit, rhinoceros, seal, sheep, squirrel, tiger, zebra")
+    
+    # Store uploaded and example file paths
+    all_files_state = gr.State([])
+    
     with gr.Row():
-        inputs = gr.File(
-            file_count="multiple",
-            file_types=["image"],
-            label="Upload Animal Images"
-        )
+        inputs = gr.File(file_count="multiple", file_types=["image"], label="Upload Animal Images")
         submit = gr.Button("Classify 🚀", variant="primary")
     
     with gr.Row():
         gallery = gr.Gallery(label="Upload Preview", columns=4)
         outputs = gr.Textbox(label="Predictions", lines=5)
-    with gr.Row():
-        gr.Markdown("Test Images")
-        gr.Gallery(
-            columns = 7,
-            preview = True,
-            height = 200
+    
+    # Example gallery with click handling
+    with gr.Row(variant="panel"):
+        examples_gallery = gr.Gallery(
+            value=example_images,
+            label="Example Images (Click to Add)",
+            columns=7,
+            height=120,
+            allow_preview=False,
+            elem_classes=["centered-examples"]
         )
     
+    # Update state when files are uploaded
+    def update_state(new_files):
+        return [f.name for f in new_files] if new_files else []
+    
+    inputs.change(update_state, inputs, all_files_state)
+    
+    # Handle example selection
+    def add_example(example_index, current_files):
+        selected_path = example_images[example_index]
+        return current_files + [selected_path]
+    
+    examples_gallery.select(
+        add_example,
+        [all_files_state],
+        all_files_state,
+        show_progress=False
+    )
+    
+    # Update gallery preview
+    def update_gallery(files):
+        return files if files else []
+    
+    all_files_state.change(update_gallery, all_files_state, gallery)
+    
+    # Modified prediction function
+    def predict(files):
+        if not files:
+            return ""
+        try:
+            batch = torch.stack([preprocess(Image.open(img).convert('RGB')) for img in files])
+            with torch.inference_mode():
+                outputs = model(batch)
+                _, preds = torch.max(outputs, 1)
+            return ", ".join([classes[p] for p in preds.cpu().numpy()])
+        except Exception as e:
+            return f"Error: {str(e)}"
     
     submit.click(
-        fn=lambda files: (
-            [f.name for f in files],  # Update gallery
-            predict([f.name for f in files])  # Get predictions
-        ),
-        inputs=inputs,
-        outputs=[gallery, outputs]
+        fn=predict,
+        inputs=all_files_state,
+        outputs=outputs
     )
 
 if __name__ == "__main__":