Update app.py

app.py

@@ -3,33 +3,13 @@ import json
 import torch
 from torch import nn
 from torchvision import models, transforms
-from huggingface_hub import hf_hub_download
 from PIL import Image
-import requests
 import os
-from io import BytesIO
 
 # Define the number of classes
 num_classes = 2
 
-# Download model from Hugging Face
-def download_model():
-    model_path = hf_hub_download(repo_id="jays009/Restnet50", filename="pytorch_model.bin")
-    return model_path
-
-# Load the model from Hugging Face
-def load_model(model_path):
-    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
-
-# Download the model and load it
-model_path = download_model()
-model = load_model(model_path)
-
-# Define the transformation for the input image
+# Define transformation for image processing
 transform = transforms.Compose([
     transforms.Resize(256),
     transforms.CenterCrop(224),
@@ -37,53 +17,53 @@ transform = transforms.Compose([
     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
 ])
 
-# Function to predict from image content
-def predict_from_image(image):
-    print(f"Processing image: {image}")
-    if not isinstance(image, Image.Image):
-        raise ValueError("Invalid image format received. Please provide a valid image.")
+# Function to load and preprocess image
+def load_image_from_path(image_path):
+    if not os.path.exists(image_path):
+        raise FileNotFoundError(f"Image file not found at {image_path}")
+    image = Image.open(image_path)
+    image = transform(image).unsqueeze(0)  # Convert to tensor and add batch dimension
+    return image
 
-    # Apply transformations
-    image_tensor = transform(image).unsqueeze(0)
+# Load the model (Example: ResNet50)
+def load_model():
+    model = models.resnet50(pretrained=True)
+    model.fc = nn.Linear(model.fc.in_features, num_classes)
+    model.load_state_dict(torch.load("model.pth"))
+    model.eval()
+    return model
 
-    # Predict
+# Predict from image tensor
+def predict(image_tensor):
     with torch.no_grad():
         outputs = model(image_tensor)
         predicted_class = torch.argmax(outputs, dim=1).item()
+    return predicted_class
 
-    # Interpret the result
-    if predicted_class == 0:
-        return {"result": "The photo is of fall army worm with problem ID 126."}
-    elif predicted_class == 1:
-        return {"result": "The photo is of a healthy maize image."}
-    else:
-        return {"error": "Unexpected class prediction."}
+# Initialize model
+model = load_model()
 
-# Function to predict from path or URL
-def predict_from_path_or_url(path_or_url):
+# Define the Gradio interface function
+def predict_from_file(file_path):
     try:
-        if path_or_url.startswith("http://") or path_or_url.startswith("https://"):
-            response = requests.get(path_or_url)
-            response.raise_for_status()  # Ensure the request was successful
-            image = Image.open(BytesIO(response.content))
-        elif os.path.isfile(path_or_url):
-            image = Image.open(path_or_url)
-        else:
-            return {"error": "Invalid path or URL. Please provide a valid URL or local file path."}
-        
-        return predict_from_image(image)
+        # Load image from path
+        image_tensor = load_image_from_path(file_path)
+        # Get prediction
+        predicted_class = predict(image_tensor)
+        result = {"result": "Fall armyworm" if predicted_class == 0 else "Healthy maize"}
+        return result
     except Exception as e:
-        return {"error": f"Failed to process the path or URL: {str(e)}"}
+        return {"error": str(e)}
 
-# Gradio interface
+# Gradio Interface
 iface = gr.Interface(
-    fn=predict_from_image,  # Adjust to handle images only
-    inputs=[gr.Image(type="pil", label="Upload an Image")],
-    outputs=gr.JSON(label="Prediction Result"),
+    fn=predict_from_file,
+    inputs=gr.Textbox(label="Image Path (Local)"),
+    outputs=gr.JSON(),
     live=True,
     title="Maize Anomaly Detection",
-    description="Upload an image to detect anomalies in maize crops.",
+    description="Send a local file path via POST request to trigger prediction.",
 )
 
-# Launch the interface
-iface.launch(share=True, show_error=True)
+# Launch the Gradio app
+iface.launch(share=True, server_name="0.0.0.0", server_port=7860)