Update app.py

app.py

@@ -9,67 +9,84 @@ import base64
 from io import BytesIO
 
 # Define the number of classes
-num_classes = 2  # Update with the actual number of classes in your dataset (e.g., 2 for healthy and anomalous)
+num_classes = 2  # Update with the actual number of classes in your dataset
 
 # Download model from Hugging Face
 def download_model():
-    model_path = hf_hub_download(repo_id="jays009/Restnet50", filename="pytorch_model.bin")
-    return model_path
+    try:
+        model_path = hf_hub_download(repo_id="jays009/Restnet50", filename="pytorch_model.bin")
+        return model_path
+    except Exception as e:
+        print(f"Error downloading model: {e}")
+        return None
 
 # Load the model from Hugging Face
 def load_model(model_path):
-    model = models.resnet50(pretrained=False)  # Set pretrained=False because you're loading custom weights
-    model.fc = nn.Linear(model.fc.in_features, num_classes)  # Adjust for the number of classes in your dataset
-    model.load_state_dict(torch.load(model_path, map_location=torch.device("cpu")))  # Load model on CPU for compatibility
-    model.eval()  # Set to evaluation mode
-    return model
+    try:
+        model = models.resnet50(pretrained=False)
+        model.fc = nn.Linear(model.fc.in_features, num_classes)
+        model.load_state_dict(torch.load(model_path, map_location=torch.device("cpu")))
+        model.eval()
+        return model
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        return None
 
 # Download the model and load it
-model_path = download_model()  # Downloads the model from Hugging Face Hub
-model = load_model(model_path)
+model_path = download_model()
+model = load_model(model_path) if model_path else None
 
 # Define the transformation for the input image
 transform = transforms.Compose([
-    transforms.Resize(256),  # Resize the image to 256x256
-    transforms.CenterCrop(224),  # Crop the image to 224x224
-    transforms.ToTensor(),  # Convert the image to a Tensor
-    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),  # Normalize the image (ImageNet mean and std)
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
 ])
 
-
 def predict(image):
     # Check if the input contains a base64-encoded string
     if isinstance(image, dict) and image.get("data"):
-        # Decode the base64 string into a PIL image
-        image_data = base64.b64decode(image["data"])
-        image = Image.open(BytesIO(image_data))
+        try:
+            image_data = base64.b64decode(image["data"])
+            image = Image.open(BytesIO(image_data))
+        except Exception as e:
+            return f"Error decoding base64 image: {e}"
+
+    elif isinstance(image, str):
+        try:
+            response = requests.get(image)
+            image = Image.open(BytesIO(response.content))
+        except Exception as e:
+            return f"Error fetching image from URL: {e}"
+
+    # Apply transformations
+    try:
+        image = transform(image).unsqueeze(0)
+        image = image.to(torch.device("cuda" if torch.cuda.is_available() else "cpu"))
 
-    # Apply your existing transformations
-    image = transform(image).unsqueeze(0)  # Transform and add batch dimension
-    image = image.to(torch.device("cuda" if torch.cuda.is_available() else "cpu"))
+        with torch.no_grad():
+            outputs = model(image)
+            predicted_class = torch.argmax(outputs, dim=1).item()
 
-    # Perform inference
-    with torch.no_grad():
-        outputs = model(image)
-        predicted_class = torch.argmax(outputs, dim=1).item()
-    
-    # Create a response based on the predicted class
-    if predicted_class == 0:
-        return "The photo you've sent is of fall army worm with problem ID 126."
-    elif predicted_class == 1:
-        return "The photo you've sent is of a healthy maize image."
-    else:
-        return "Unexpected class prediction."
+        if predicted_class == 0:
+            return "The photo you've sent is of fall army worm with problem ID 126."
+        elif predicted_class == 1:
+            return "The photo you've sent is of a healthy maize image."
+        else:
+            return "Unexpected class prediction."
+    except Exception as e:
+        return f"Error processing image: {e}"
 
 # Create the Gradio interface
 iface = gr.Interface(
-    fn=predict,  # Function for prediction
-    inputs=gr.Image(type="pil"),  # Image input
-    outputs=gr.Textbox(),  # Output: Predicted class
-    live=True,  # Updates as the user uploads an image
+    fn=predict,
+    inputs=gr.Image(type="pil"),
+    outputs=gr.Textbox(),
+    live=True,
     title="Maize Anomaly Detection",
     description="Upload an image of maize to detect anomalies like disease or pest infestation. You can provide local paths, URLs, or base64-encoded images."
 )
 
 # Launch the Gradio interface
-iface.launch(share=True)  
+iface.launch(share=True)