Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| 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 | |
| import logging | |
| # Set up basic logging | |
| logging.basicConfig(level=logging.INFO) | |
| # 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 | |
| transform = transforms.Compose([ | |
| transforms.Resize(256), | |
| transforms.CenterCrop(224), | |
| transforms.ToTensor(), | |
| transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), | |
| ]) | |
| # Global variable to store the file path | |
| file_path = None | |
| # Function to predict from image content | |
| def predict_from_image(image): | |
| # Ensure the image is a PIL Image | |
| if not isinstance(image, Image.Image): | |
| raise ValueError("Invalid image format received. Please provide a valid image.") | |
| # Apply transformations | |
| image_tensor = transform(image).unsqueeze(0) | |
| # Predict | |
| with torch.no_grad(): | |
| outputs = model(image_tensor) | |
| predicted_class = torch.argmax(outputs, dim=1).item() | |
| # 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."} | |
| # Function to handle the file path sent via POST request | |
| def process_file_path(file_path_input): | |
| global file_path | |
| file_path = file_path_input # Store the file path | |
| logging.info(f"Received file path: {file_path}") | |
| if not os.path.exists(file_path): | |
| logging.error(f"File not found at {file_path}") | |
| return {"error": f"File not found at {file_path}"} | |
| image = Image.open(file_path) | |
| logging.info(f"Processing image from path: {file_path}") | |
| return predict_from_image(image) | |
| # Function to fetch the result (for the GET request) | |
| def fetch_result(): | |
| if file_path: | |
| image = Image.open(file_path) | |
| logging.info(f"Making prediction for image at path: {file_path}") | |
| return predict_from_image(image) | |
| else: | |
| logging.warning("No file path available. Please send a POST request with a file path first.") | |
| return {"error": "No file path available. Please send a POST request with a file path first."} | |
| # Gradio interface | |
| iface = gr.Interface( | |
| fn=process_file_path, | |
| inputs=[ | |
| gr.Textbox(label="Enter Local Image Path", placeholder="Provide the local image path"), | |
| ], | |
| outputs=gr.JSON(label="Prediction Result"), | |
| live=False, | |
| title="Maize Anomaly Detection", | |
| description="Provide a local file path via POST request to process an image.", | |
| ) | |
| # Launch the interface | |
| iface.launch(share=True, show_error=True) | |