added

app.py

@@ -1,7 +1,144 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+from PIL import Image
 import gradio as gr
+import os
 
-def greet(name):
-    return "Hello " + name + "!!"
+class_names = ["Pinus pinaster", "Eucalyptus globulus", "Quercus suber"]
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+model_aliases = {
+    "model.pth": "GBIF Model",
+    "resnet_model.pth": "ResNet Model"
+}
+
+# Image transformations
+transform = transforms.Compose([
+    transforms.Resize((128, 128)),
+    transforms.ToTensor()
+])
+
+# ResNet model class
+class ResnetModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=False)
+        self.model.fc = torch.nn.Linear(self.model.fc.in_features, len(class_names))
+
+    def forward(self, x):
+        return self.model(x)
+
+# Global variable for the loaded model
+model = None
+
+# Custom CNN model class
+class DeeperCNN(nn.Module):
+    def __init__(self, num_classes):
+        super(DeeperCNN, self).__init__()
+        
+        self.features = nn.Sequential(
+            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),  # Downsample from 128 to 64
+            nn.Dropout(0.25),
+
+            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),  # Downsample from 64 to 32
+            nn.Dropout(0.25),
+
+            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.Dropout(0.25),
+        )
+
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(128 * 32 * 32, 256),
+            nn.ReLU(),
+            nn.Dropout(0.5),
+            nn.Linear(256, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = self.classifier(x)
+        return x
+
+# Number of classes in your task
+num_classes = 3
+
+# Function to load model given a selected model filename
+def load_model(selected_model):
+    global model
+    model_path = os.path.join("models", selected_model)
+    model_path = os.path.normpath(model_path)
+    try:
+        model = torch.load(model_path, map_location=torch.device("cpu"), weights_only=False)
+        model.eval()
+        alias = model_aliases.get(selected_model, selected_model)
+        return f"{alias} loaded successfully."
+    except Exception as e:
+        return f"Error loading {model_aliases.get(selected_model, selected_model)}: {str(e)}"
+
+# Prediction function
+def predict(image):
+    if model is None:
+        return {}, "Please load a model first."
+    image = transform(image).unsqueeze(0)
+    with torch.no_grad():
+        outputs = model(image)
+        probs = F.softmax(outputs, dim=1)[0]
+        probs_dict = {class_names[i]: float(probs[i]) for i in range(len(class_names))}
+        max_prob = max(probs_dict.values())
+        if max_prob < 0.6:
+            final_label = "Unknown"
+        else:
+            final_label = max(probs_dict, key=probs_dict.get)
+        return probs_dict, final_label
+
+# Gradio UI elements
+model_selector = gr.Dropdown(
+    choices=[(alias, filename) for filename, alias in model_aliases.items()],
+    label="Select Model",
+    value="model.pth"
+)
+
+load_button = gr.Button("Load Model")
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        # Left column: model selector, load button, load status
+        with gr.Column(scale=1):
+            model_selector.render()
+            load_button.render()
+            load_output = gr.Textbox(label="Model Status")
+        
+        # Center column: image input and predict button
+        with gr.Column(scale=1):
+            image_input = gr.Image(type="pil", interactive=True, label="", height=400)
+            predict_button = gr.Button("Predict")
+
+        # Right column: prediction output label
+        with gr.Column(scale=1):
+            label_output = gr.Label(label="")
+            final_output = gr.Textbox(label="Final Prediction", interactive=False)
+
+    # Events
+    load_button.click(fn=load_model, inputs=model_selector, outputs=load_output)
+    predict_button.click(fn=predict, inputs=image_input, outputs=[label_output, final_output])
+
+demo.launch()

models/model.pth

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

models/resnet_model.pth

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

requirements.txt

@@ -0,0 +1,6 @@
+torch
+torch.nn
+torchvision
+gradio
+Pillow
+os