test

app.py

@@ -0,0 +1,74 @@
+import torch
+import joblib
+from torchvision import transforms
+from PIL import Image
+from models.freshness_model import MultiOutputModel
+import torch.nn.functional as F  # For applying sigmoid
+import gradio as gr
+import json
+
+# Define the paths
+MODEL_PATH = 'models/multi_output_model.pth'
+LABEL_ENCODER_TYPE_PATH = 'models/label_encoder_type.pkl'
+
+# Load the label encoder
+label_encoder_type = joblib.load(LABEL_ENCODER_TYPE_PATH)
+
+# Load the model
+model = MultiOutputModel(num_classes_type=len(label_encoder_type.classes_))
+model.load_state_dict(torch.load(MODEL_PATH))
+model.eval()  # Set the model to evaluation mode
+
+# Define the image transformations
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),  # Resize to match the input size of the model
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # Normalize using ImageNet stats
+])
+
+def preprocess_image(image: Image.Image):
+    """Preprocess the input image."""
+    return transform(image).unsqueeze(0)  # Add batch dimension
+
+def run_inference(image: Image.Image):
+    """Run inference on a single image."""
+    # Preprocess the image
+    input_tensor = preprocess_image(image)
+    
+    # Move to device (GPU if available)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+    input_tensor = input_tensor.to(device)
+    
+    # Forward pass
+    with torch.no_grad():
+        type_output, freshness_output = model(input_tensor)
+    
+    # Apply sigmoid to freshness output (to get probability)
+    freshness_output = torch.sigmoid(freshness_output.squeeze())  # Sigmoid for binary classification
+    
+    # Decode predictions
+    _, predicted_type_idx = torch.max(type_output, 1)
+    predicted_type = label_encoder_type.inverse_transform([predicted_type_idx.item()])
+    
+    output = {}
+    output['type'] = str(predicted_type[0])
+    output['freshness'] = str(float(freshness_output.item()))
+
+    json_output = json.dumps(output)
+    return str(json_output)
+
+
+# Define Gradio input and output components
+image_input = gr.Image(type="pil")
+
+# Create the Gradio interface
+demo = gr.Interface(
+    fn=run_inference,
+    inputs=image_input,
+    outputs='text',
+    title="Frshness prediction",
+    description="Upload an image, and the model will detect objects and return the number of objects along with the image showing the bounding boxes."
+)
+
+demo.launch(share=True)

models/freshness_model.py

@@ -0,0 +1,45 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+
+class MultiOutputModel(nn.Module):
+    def __init__(self, num_classes_type):
+        super(MultiOutputModel, self).__init__()
+        
+        # Load a pretrained ResNet model
+        self.resnet = models.resnet50(pretrained=True)
+        
+        # Freeze ResNet layers if needed
+        for param in self.resnet.parameters():
+            param.requires_grad = False
+        
+        # Get the in_features from the fully connected layer of ResNet
+        in_features = self.resnet.fc.in_features
+        
+        # Modify the fully connected layer for type classification
+        self.resnet.fc = nn.Linear(in_features, 512)
+
+        self.type_head = nn.Sequential(
+            nn.Linear(512, 512),  # Adding another fully connected layer
+            nn.ReLU(),            # Activation function for the new layer
+            nn.Dropout(0.3),       # Optional dropout for regularization
+            nn.Linear(512, num_classes_type)  # Output layer
+        )
+
+        self.freshness_head = nn.Sequential(
+            nn.Linear(512, 256),
+            nn.ReLU(),
+            nn.Dropout(0.4),
+            nn.Linear(256, 128),    # Adding a new layer for more complexity
+            nn.ReLU(),              # Activation for the new layer
+            nn.Linear(128, 1)       # Final output layer
+        )
+
+    def forward(self, x):
+        x = self.resnet(x)
+        # Type classification
+        type_output = self.type_head(x)
+        # Freshness classification
+        freshness_output = self.freshness_head(x)
+        
+        return type_output, freshness_output

models/label_encoder_type.pkl

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

models/multi_output_model.pth

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

requirements.txt

@@ -0,0 +1,5 @@
+joblib
+torch
+torchvision
+pillow
+gradio