final working space

README.md

@@ -10,3 +10,172 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+
+# ResNet50 Image Classifier
+
+This is a Gradio web application that uses a trained ResNet50 model to classify images. The application provides real-time predictions with top-3 confidence scores for uploaded images.
+
+## Live Demo
+
+Visit the application at [Hugging Face Spaces URL]
+
+## Features
+
+- Real-time image classification
+- Top-3 predictions with confidence scores
+- Support for various image formats
+- User-friendly interface
+- Detailed prediction logging
+- Example images for testing
+
+## Using the Application
+
+### Quick Start
+1. Visit the Hugging Face Space
+2. Upload an image using one of these methods:
+   - Click the "Upload Image" button
+   - Drag and drop an image into the input area
+   - Use the provided example images
+
+### Input Requirements
+- Supported formats: JPG, PNG, BMP
+- Both color and grayscale images accepted
+- Images are automatically:
+  - Resized to 256 pixels
+  - Center cropped to 224x224
+  - Normalized using ImageNet statistics
+
+### Output Format
+The model returns:
+1. **Predicted Class**: The most likely class
+2. **Top 3 Predictions**: Three most likely classes with confidence scores
+
+Example output:
+```
+Predicted Class: dog
+Top 3 Predictions:
+dog: 95.32%
+cat: 3.45%
+fox: 1.23%
+```
+
+## Technical Details
+
+### Model Architecture
+- Base model: ResNet50
+- Input size: 224x224 pixels
+- Output: Class probabilities through softmax
+- Model format: PyTorch (.pth)
+
+### Image Processing Pipeline
+```python
+transform = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225]
+    )
+])
+```
+
+### File Structure
+```
+.
+├── app.py              # Main application file
+├── requirements.txt    # Dependencies
+├── README.md          # Documentation
+├── src/
+│   └── model_10.pth   # Trained model weights
+│   └── classes.txt    # Class labels
+├── models/
+│   └── model_n.pth    # other models
+└── examples/          # Example images
+    ├── example1.jpg
+    └── example2.jpg
+```
+
+## Deployment Guide
+
+### Prerequisites
+1. Hugging Face account
+2. Trained ResNet50 model (.pth format)
+3. Class labels file (classes.txt)
+4. Example images (optional)
+
+### Deployment Steps
+1. Create a new Space:
+   - Go to huggingface.co/spaces
+   - Click "Create new Space"
+   - Select "Gradio" as the SDK
+   - Use the provided space configuration from this README
+
+2. Upload required files:
+   - All files from the File Structure section
+   - Ensure correct file paths in app.py
+
+3. The Space will automatically build and deploy
+
+
+### Space Configuration
+```yaml
+title: ResNetonImageNet - ResNet50 Image Classifier
+emoji: 🔍
+colorFrom: blue
+colorTo: red
+sdk: gradio
+sdk_version: 5.9.1
+app_file: app.py
+pinned: false
+```
+
+## Troubleshooting
+
+### Common Issues
+1. **Model Loading Errors**
+   - Verify model path in app.py
+   - Check model format and class count
+
+2. **Image Upload Issues**
+   - Verify supported formats
+   - Check image file size
+
+3. **Prediction Errors**
+   - First prediction may be slower (model loading)
+   - Check input image quality
+
+### Performance Notes
+- CPU inference by default
+- GPU supported if available
+- Batch processing not supported
+- Real-time predictions
+
+## Development
+
+### Requirements
+```
+torch>=2.0.0
+torchvision>=0.15.0
+gradio>=4.19.2
+Pillow>=9.0.0
+numpy>=1.21.0
+```
+
+### Local Development
+1. Clone the repository
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. Run locally:
+   ```bash
+   python app.py
+   ```
+
+## Support
+
+- GitHub Issues: [Repository URL]
+- Hugging Face Forum: [Forum URL]
+- Documentation: [Docs URL]

app.py

@@ -3,212 +3,151 @@ import torch
 import torchvision.transforms as transforms
 from PIL import Image
 from torchvision.models import resnet50
-import os
-import logging
-from typing import Optional, Union
-import numpy as np
 from pathlib import Path
+import logging
+import warnings
+warnings.filterwarnings('ignore')
 
-# Set up logging
+# Setup logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Directory Configuration
-BASE_DIR = Path(__file__).resolve().parent
-MODELS_DIR = BASE_DIR / "models"
-EXAMPLES_DIR = BASE_DIR / "examples"
-STATIC_DIR = BASE_DIR / "static" / "uploaded"
-
-# Ensure directories exist
-STATIC_DIR.mkdir(parents=True, exist_ok=True)
-
-# Global variables
-MODEL_PATH = MODELS_DIR / "resnet_50.pth"
-CLASSES_PATH = BASE_DIR / "classes.txt"
+# Path configurations
+MODEL_PATH = Path('src/model_10.pth')
+CLASSES_PATH = Path('models/classes.txt')
 DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
-def load_class_labels() -> Optional[list]:
-    """
-    Load class labels from the classes.txt file
-    """
-    try:
-        if not CLASSES_PATH.exists():
-            raise FileNotFoundError(f"Classes file not found at {CLASSES_PATH}")
-            
-        with open(CLASSES_PATH, 'r') as f:
-            return [line.strip() for line in f.readlines()]
-    except Exception as e:
-        logger.error(f"Error loading class labels: {str(e)}")
-        return None
-
-# Load class labels
-CLASS_NAMES = load_class_labels()
-if CLASS_NAMES is None:
-    raise RuntimeError("Failed to load class labels from classes.txt")
-
-# Cache the model to avoid reloading for each prediction
-model = None
-
-def load_model() -> Optional[torch.nn.Module]:
+# Image preprocessing - using the same transforms as training
+transform = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225]
+    )
+])
+
+def load_classes():
+    with open(CLASSES_PATH) as f:
+        return [line.strip() for line in f.readlines()]
+
+def load_model():
     """
-    Load the ResNet50 model with error handling
+    Load the trained ResNet50 model
     """
-    global model
-    
     try:
-        if model is not None:
-            return model
-            
-        if not MODEL_PATH.exists():
-            raise FileNotFoundError(f"Model file not found at {MODEL_PATH}")
+        # Initialize model
+        model = resnet50(weights=None)
+        num_classes = len(load_classes())
+        model.fc = torch.nn.Linear(model.fc.in_features, num_classes)
         
-        logger.info(f"Loading model on {DEVICE}")
-        model = resnet50(pretrained=False)
-        model.fc = torch.nn.Linear(model.fc.in_features, len(CLASS_NAMES))
+        # Load checkpoint
+        checkpoint = torch.load(MODEL_PATH, map_location=DEVICE)
         
-        # Load the model weights
-        state_dict = torch.load(MODEL_PATH, map_location=DEVICE)
-        
-        if 'state_dict' in state_dict:
-            state_dict = state_dict['state_dict']
+        # Extract state dict from checkpoint
+        if isinstance(checkpoint, dict):
+            if "model" in checkpoint:
+                state_dict = checkpoint["model"]
+            elif "state_dict" in checkpoint:
+                state_dict = checkpoint["state_dict"]
+            elif "model_state_dict" in checkpoint:
+                state_dict = checkpoint["model_state_dict"]
+            else:
+                state_dict = checkpoint
+        else:
+            state_dict = checkpoint
+            
+        # Clean state dict keys
+        new_state_dict = {}
+        for k, v in state_dict.items():
+            name = k.replace("module.", "")
+            if name.startswith("model."):
+                name = name[6:]
+            new_state_dict[name] = v
         
-        model.load_state_dict(state_dict)
+        # Load state dict and set to eval mode
+        model.load_state_dict(new_state_dict, strict=False)
         model.to(DEVICE)
         model.eval()
         
         logger.info("Model loaded successfully")
         return model
-        
+    
     except Exception as e:
-        logger.error(f"Error loading model: {str(e)}")
-        return None
+        logger.error(f"Error loading model: {e}")
+        raise
 
-def preprocess_image(image: Union[np.ndarray, Image.Image]) -> Optional[torch.Tensor]:
-    """
-    Preprocess the input image with error handling
-    """
-    try:
-        if isinstance(image, np.ndarray):
-            image = Image.fromarray(image)
-        
-        transform = transforms.Compose([
-            transforms.Resize((224, 224)),
-            transforms.ToTensor(),
-            transforms.Normalize(
-                mean=[0.485, 0.456, 0.406],
-                std=[0.229, 0.224, 0.225]
-            )
-        ])
-        
-        return transform(image).unsqueeze(0).to(DEVICE)
-        
-    except Exception as e:
-        logger.error(f"Error preprocessing image: {str(e)}")
-        return None
+# Global variables
+CLASSES = load_classes()
+MODEL = load_model()
 
-def predict(image: Union[np.ndarray, None]) -> tuple[str, dict]:
+def predict_image(image):
     """
-    Make predictions on the input image with comprehensive error handling
-    Returns the predicted class and top 5 confidence scores
+    Predict class for input image with top-3 accuracy
     """
     try:
         if image is None:
-            return "Error: No image provided", {}
+            return "No image provided", "Please upload an image"
         
-        model = load_model()
-        if model is None:
-            return "Error: Failed to load model", {}
-            
-        # Ensure model is in eval mode
-        model.eval()
+        # Convert to PIL Image if needed
+        if not isinstance(image, Image.Image):
+            image = Image.fromarray(image)
         
-        input_tensor = preprocess_image(image)
-        if input_tensor is None:
-            return "Error: Failed to preprocess image", {}
-            
+        # Preprocess image
+        input_tensor = transform(image).unsqueeze(0).to(DEVICE)
+        
+        # Get prediction
         with torch.no_grad():
-            input_tensor = input_tensor.to(DEVICE)
-            output = model(input_tensor)
+            output = MODEL(input_tensor)
             probabilities = torch.nn.functional.softmax(output[0], dim=0)
-            
-        # Get predictions and confidences
-        top_5_probs, top_5_indices = torch.topk(probabilities, k=5)
         
-        # Format confidences with exactly 2 decimal places
-        confidences = {
-            CLASS_NAMES[idx.item()]: "{:.2f}".format(float(prob.item() * 100))
-            for prob, idx in zip(top_5_probs, top_5_indices)
-        }
+        # Get top-3 predictions
+        top3_prob, top3_indices = torch.topk(probabilities, k=3)
         
-        predicted_class = CLASS_NAMES[top_5_indices[0].item()]
+        # Format predictions
+        predictions = []
+        for prob, idx in zip(top3_prob, top3_indices):
+            class_name = CLASSES[idx]
+            confidence = prob.item() * 100
+            predictions.append(f"{class_name}: {confidence:.2f}%")
         
-        return predicted_class, confidences
-                
-    except Exception as e:
-        logger.error(f"Prediction error: {str(e)}")
-        return f"Error during prediction: {str(e)}", {}
-
-def get_example_list() -> list:
-    """
-    Get list of example images from the examples directory
-    """
-    try:
-        examples = []
-        for ext in ['.jpg', '.jpeg', '.png']:
-            examples.extend(list(EXAMPLES_DIR.glob(f'*{ext}')))
-        return [[str(ex)] for ex in sorted(examples)]
-    except Exception as e:
-        logger.error(f"Error loading examples: {str(e)}")
-        return []
-
-# Create Gradio interface with error handling
-try:
-    with gr.Blocks(theme=gr.themes.Base()) as iface:
-        gr.Markdown("# Image Classification with ResNet50")
-        gr.Markdown("Upload an image to classify. The model will predict the class and show top 5 confidence scores.")
+        # Join predictions with newlines
+        predictions_text = "\n".join(predictions)
         
-        with gr.Row():
-            with gr.Column(scale=1):
-                input_image = gr.Image(type="numpy", label="Upload Image")
-                predict_btn = gr.Button("Predict")
-            
-            with gr.Column(scale=1):
-                output_label = gr.Label(label="Predicted Class", num_top_classes=1)
-                confidence_label = gr.Label(label="Top 5 Predictions", num_top_classes=5)
-
-        # Add examples
-        gr.Examples(
-            examples=get_example_list(),
-            inputs=input_image,
-            outputs=[output_label, confidence_label],
-            fn=predict,
-            cache_examples=True
-        )
-
-        # Set up prediction event
-        predict_btn.click(
-            fn=predict,
-            inputs=input_image,
-            outputs=[output_label, confidence_label]
-        )
-        input_image.change(
-            fn=predict,
-            inputs=input_image,
-            outputs=[output_label, confidence_label]
-        )
-
-except Exception as e:
-    logger.error(f"Error creating Gradio interface: {str(e)}")
-    raise
-
-if __name__ == "__main__":
-    try:
-        load_model()  # Pre-load the model
-        iface.launch(
-            share=False,
-            server_name="0.0.0.0",
-            server_port=7860,
-            debug=False
-        )
+        # Get top prediction
+        predicted_class = CLASSES[top3_indices[0]]
+        
+        # Log predictions
+        logger.info(f"Predicted class: {predicted_class}")
+        logger.info(f"Top 3 predictions:\n{predictions_text}")
+        
+        return predicted_class, predictions_text
+    
     except Exception as e:
-        logger.error(f"Error launching application: {str(e)}")
+        logger.error(f"Prediction error: {e}")
+        return "Error in prediction", str(e)
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_image,
+    inputs=gr.Image(type="pil", label="Upload Image"),
+    outputs=[
+        gr.Textbox(label="Predicted Class"),
+        gr.Textbox(label="Top 3 Predictions", lines=3)
+    ],
+    title="ResNet50 Image Classifier",
+    description=(
+        "Upload an image to classify.\n"
+        "The model will predict the class and show confidence scores for the top 3 predictions."
+    ),
+    examples=[
+        ["examples/example1.jpg"],
+        ["examples/example2.jpg"]
+    ] if Path("examples").exists() else None,
+    theme=gr.themes.Base()
+)
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()