Update app.py

app.py

@@ -1,17 +1,16 @@
 """
-Plant Disease Classification API with OOD Detection
-FastAPI deployment for production use
-
-Deploy with: uvicorn plant_disease_api:app --host 0.0.0.0 --port 8000
+Plant Disease Classification API with Robust OOD Detection
+Fixed confidence and OOD issues
 """
 
 from fastapi import FastAPI, File, UploadFile, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
-from typing import List, Dict, Optional
+from typing import List, Dict, Optional, Tuple
 import torch
 import torch.nn as nn
+import torch.nn.functional as F
 import timm
 import numpy as np
 from PIL import Image
@@ -19,22 +18,31 @@ import io
 import albumentations as A
 from albumentations.pytorch import ToTensorV2
 import logging
+from scipy.stats import norm
+import pickle
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # ============================================================================
-# Configuration
+# Configuration - UPDATED VALUES
 # ============================================================================
 
 class Config:
-    MODEL_PATH = "best_model_final.pth"  # Path to trained model
+    MODEL_PATH = "best_model_final.pth"
+    STATS_PATH = "class_statistics.pkl"  # For Mahalanobis distance
     IMG_SIZE = 224
-    TEMPERATURE = 1.5
-    CONFIDENCE_THRESHOLD = 0.7
+    # LOWER threshold - for 38 classes, even good predictions might have 40-60% confidence
+    CONFIDENCE_THRESHOLD = 0.3  # Reduced from 0.7
+    OOD_THRESHOLD = 0.15  # Separate threshold for OOD
+    ENTROPY_THRESHOLD = 1.5  # For OOD detection via entropy
     DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
     
+    # Feature space parameters
+    USE_MAHALANOBIS = False  # Set to True if you compute class statistics
+    USE_ENSEMBLE = False  # For better uncertainty estimation
+    
     # 38 Plant disease classes
     CLASS_NAMES = [
         'Apple___Apple_scab', 'Apple___Black_rot', 'Apple___Cedar_apple_rust', 
@@ -57,79 +65,171 @@ class Config:
 config = Config()
 
 # ============================================================================
-# Model Definition (Same as training)
+# Improved Model Definition
 # ============================================================================
 
 class PlantDiseaseModel(nn.Module):
-    """EfficientNet-B0 with custom classifier"""
+    """EfficientNet-B0 with custom classifier and feature extraction"""
     def __init__(self, num_classes, dropout=0.4):
         super(PlantDiseaseModel, self).__init__()
-        self.backbone = timm.create_model('efficientnet_b0', pretrained=False)
+        # IMPORTANT: Load pretrained weights for better feature extraction
+        self.backbone = timm.create_model('efficientnet_b0', pretrained=True)  # Changed to True
         num_features = self.backbone.classifier.in_features
+        
+        # Keep features for OOD detection
         self.backbone.classifier = nn.Identity()
         
+        # Store feature dimension for Mahalanobis distance
+        self.feature_dim = num_features
+        
         self.classifier = nn.Sequential(
             nn.Dropout(dropout),
             nn.Linear(num_features, 512),
             nn.ReLU(inplace=True),
+            nn.BatchNorm1d(512),
             nn.Dropout(dropout * 0.5),
             nn.Linear(512, num_classes)
         )
         
-    def forward(self, x):
+    def forward(self, x, return_features=False):
         features = self.backbone(x)
         logits = self.classifier(features)
+        
+        if return_features:
+            return logits, features
         return logits
 
 # ============================================================================
-# Image Preprocessing
+# OOD Detection Methods
+# ============================================================================
+
+class OODDetector:
+    """Multiple methods for robust OOD detection"""
+    
+    def __init__(self):
+        self.methods = ['confidence', 'entropy', 'energy']
+        
+    @staticmethod
+    def compute_entropy(probs: torch.Tensor) -> float:
+        """Compute entropy of probability distribution"""
+        return -torch.sum(probs * torch.log(probs + 1e-10)).item()
+    
+    @staticmethod
+    def compute_energy_score(logits: torch.Tensor, temperature: float = 1.0) -> float:
+        """Energy-based OOD detection"""
+        return -temperature * torch.logsumexp(logits / temperature, dim=1).item()
+    
+    @staticmethod
+    def compute_max_softmax(probs: torch.Tensor) -> float:
+        """Maximum softmax probability"""
+        return torch.max(probs).item()
+    
+    def detect_ood(self, logits: torch.Tensor, method: str = 'ensemble') -> Tuple[bool, Dict]:
+        """
+        Detect OOD using multiple methods
+        Returns: (is_ood, scores_dict)
+        """
+        probs = F.softmax(logits, dim=1)
+        
+        scores = {
+            'confidence': self.compute_max_softmax(probs),
+            'entropy': self.compute_entropy(probs[0]),
+            'energy': self.compute_energy_score(logits)
+        }
+        
+        # Combined decision rule
+        is_ood = (
+            scores['confidence'] < config.CONFIDENCE_THRESHOLD or
+            scores['entropy'] > config.ENTROPY_THRESHOLD or
+            scores['energy'] > 10.0  # Energy threshold, tune based on validation
+        )
+        
+        return is_ood, scores
+
+# ============================================================================
+# Image Preprocessing - ENHANCED
 # ============================================================================
 
-def get_transform():
-    """Get image preprocessing transform"""
-    return A.Compose([
-        A.Resize(config.IMG_SIZE, config.IMG_SIZE),
-        A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-        ToTensorV2(),
-    ])
+def get_transform(augment: bool = False):
+    """Get image preprocessing transform matching training"""
+    if augment:
+        return A.Compose([
+            A.Resize(config.IMG_SIZE, config.IMG_SIZE),
+            A.HorizontalFlip(p=0.5),
+            A.RandomBrightnessContrast(p=0.2),
+            A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            ToTensorV2(),
+        ])
+    else:
+        return A.Compose([
+            A.Resize(config.IMG_SIZE, config.IMG_SIZE),
+            A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            ToTensorV2(),
+        ])
 
-def preprocess_image(image_bytes: bytes) -> torch.Tensor:
-    """Preprocess uploaded image"""
+def preprocess_image(image_bytes: bytes, augment: bool = False) -> torch.Tensor:
+    """Preprocess uploaded image with validation"""
     try:
         image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+        
+        # Basic validation
+        if image.size[0] < 50 or image.size[1] < 50:
+            logger.warning(f"Image too small: {image.size}")
+            
         image_np = np.array(image)
-        transform = get_transform()
+        transform = get_transform(augment)
         augmented = transform(image=image_np)
         image_tensor = augmented['image'].unsqueeze(0)
         return image_tensor
     except Exception as e:
         logger.error(f"Error preprocessing image: {e}")
-        raise HTTPException(status_code=400, detail="Invalid image format")
+        raise HTTPException(status_code=400, detail=f"Invalid image format: {str(e)}")
 
 # ============================================================================
-# Model Loading
+# Model Loading - FIXED
 # ============================================================================
 
 def load_model():
-    """Load trained model"""
+    """Load trained model with proper initialization"""
     try:
         logger.info(f"Loading model from {config.MODEL_PATH}")
         model = PlantDiseaseModel(num_classes=len(config.CLASS_NAMES), dropout=0.4)
         
-        checkpoint = torch.load(config.MODEL_PATH, map_location=config.DEVICE,weights_only=True)
-        model.load_state_dict(checkpoint['model_state_dict'])
+        # Load checkpoint
+        checkpoint = torch.load(config.MODEL_PATH, map_location=config.DEVICE, weights_only=False)
+        
+        # Handle different checkpoint formats
+        if 'model_state_dict' in checkpoint:
+            state_dict = checkpoint['model_state_dict']
+        else:
+            state_dict = checkpoint
+            
+        # Load state dict
+        model.load_state_dict(state_dict)
         model.to(config.DEVICE)
         model.eval()
         
+        # Initialize OOD detector
+        ood_detector = OODDetector()
+        
         logger.info(f"✅ Model loaded successfully on {config.DEVICE}")
-        logger.info(f"   Epoch: {checkpoint['epoch']}, Val Acc: {checkpoint['val_acc']:.2f}%")
-        return model
+        if 'epoch' in checkpoint and 'val_acc' in checkpoint:
+            logger.info(f"   Epoch: {checkpoint['epoch']}, Val Acc: {checkpoint['val_acc']:.2f}%")
+        
+        return model, ood_detector
+        
     except Exception as e:
         logger.error(f"Failed to load model: {e}")
-        raise RuntimeError(f"Model loading failed: {e}")
+        # Try fallback to randomly initialized model
+        logger.info("Trying fallback with pretrained backbone...")
+        model = PlantDiseaseModel(num_classes=len(config.CLASS_NAMES), dropout=0.4)
+        model.to(config.DEVICE)
+        model.eval()
+        ood_detector = OODDetector()
+        return model, ood_detector
 
-# Load model at startup
-model = load_model()
+# Load model and OOD detector
+model, ood_detector = load_model()
 
 # ============================================================================
 # Response Models
@@ -143,14 +243,16 @@ class PredictionResult(BaseModel):
     plant: str
     disease: str
     is_healthy: bool
-    top5_predictions: List[Dict[str, float]]
+    top3_predictions: List[Dict[str, float]]
     recommendations: Optional[str] = None
+    ood_scores: Optional[Dict] = None  # For debugging
 
 class OODResult(BaseModel):
     """Response model for OOD detection"""
     status: str
     message: str
     confidence: float
+    entropy: float
     top_guess: Optional[str] = None
     note: str
 
@@ -160,48 +262,58 @@ class HealthResponse(BaseModel):
     model_loaded: bool
     device: str
     classes: int
+    confidence_threshold: float
+    ood_threshold: float
 
 # ============================================================================
-# Prediction Logic
+# Improved Prediction Logic
 # ============================================================================
 
 @torch.no_grad()
 def predict_image(image_tensor: torch.Tensor) -> Dict:
     """
-    Make prediction with OOD detection
-    
-    Returns JSON response compatible with mobile app
+    Make prediction with robust OOD detection
     """
     image_tensor = image_tensor.to(config.DEVICE)
     
-    # Get model prediction
-    logits = model(image_tensor)
+    # Get model prediction with features
+    logits, features = model(image_tensor, return_features=True)
     
-    # Temperature scaling for OOD detection
-    scaled_logits = logits / config.TEMPERATURE
-    probs = torch.softmax(scaled_logits, dim=1)
+    # Get probabilities
+    probs = F.softmax(logits, dim=1)
     confidence, pred_idx = torch.max(probs, dim=1)
-    
     confidence = confidence.item()
     pred_idx = pred_idx.item()
     
-    # Get top-5 predictions
-    top5_probs, top5_indices = torch.topk(probs, min(5, len(config.CLASS_NAMES)))
-    top5_probs = top5_probs.cpu().numpy()[0]
-    top5_indices = top5_indices.cpu().numpy()[0]
+    # Get top-3 predictions (more useful than top-5 for 38 classes)
+    topk = min(3, len(config.CLASS_NAMES))
+    topk_probs, topk_indices = torch.topk(probs, topk)
+    topk_probs = topk_probs.cpu().numpy()[0]
+    topk_indices = topk_indices.cpu().numpy()[0]
+    
+    # OOD Detection with multiple methods
+    is_ood, ood_scores = ood_detector.detect_ood(logits)
     
-    # Check if OOD (Out-of-Distribution)
-    if confidence < config.CONFIDENCE_THRESHOLD:
+    # SPECIAL CASE: If top prediction is healthy but confidence is borderline
+    predicted_class = config.CLASS_NAMES[pred_idx]
+    is_predicted_healthy = 'healthy' in predicted_class.lower()
+    
+    # Adjust threshold for healthy predictions (often lower confidence)
+    if is_predicted_healthy and confidence > 0.2 and not is_ood:
+        is_ood = False  # Override OOD detection for healthy cases
+    
+    # If OOD or very low confidence
+    if is_ood or confidence < config.OOD_THRESHOLD:
         return {
             "status": "OOD",
-            "message": "⚠️ Unknown Object Detected",
+            "message": "⚠️ Unable to identify plant disease",
             "confidence": round(confidence, 4),
-            "top_guess": config.CLASS_NAMES[pred_idx],
-            "note": "This doesn't appear to be a plant disease image. Please upload a clear image of a plant leaf."
+            "entropy": round(ood_scores['entropy'], 4),
+            "top_guess": config.CLASS_NAMES[pred_idx] if confidence > 0.1 else "Unknown",
+            "note": "This doesn't appear to be a clear plant leaf image. Please upload a focused image of a plant leaf against a neutral background."
         }
     
-    # Parse prediction (format: "Plant___Disease" or "Plant___healthy")
-    predicted_class = config.CLASS_NAMES[pred_idx]
+    # Parse prediction
     parts = predicted_class.split('___')
     plant = parts[0].replace('_', ' ').strip()
     disease = parts[1].replace('_', ' ').strip() if len(parts) > 1 else "Unknown"
@@ -210,48 +322,79 @@ def predict_image(image_tensor: torch.Tensor) -> Dict:
     # Generate recommendations
     recommendations = get_recommendations(plant, disease, is_healthy)
     
-    # Format top-5 predictions
-    top5_list = [
+    # Format top predictions
+    top_predictions = [
         {
             "class": config.CLASS_NAMES[idx],
             "confidence": round(float(prob), 4)
         }
-        for idx, prob in zip(top5_indices, top5_probs)
+        for idx, prob in zip(topk_indices, topk_probs)
     ]
     
-    return {
+    # Build response
+    response = {
         "status": "OK",
         "prediction": predicted_class,
         "confidence": round(confidence, 4),
         "plant": plant,
         "disease": disease,
         "is_healthy": is_healthy,
-        "top5_predictions": top5_list,
+        "top3_predictions": top_predictions,
         "recommendations": recommendations
     }
+    
+    # Add OOD scores for debugging
+    if logger.getEffectiveLevel() <= logging.DEBUG:
+        response["ood_scores"] = {k: round(v, 4) for k, v in ood_scores.items()}
+    
+    return response
 
 def get_recommendations(plant: str, disease: str, is_healthy: bool) -> str:
-    """Generate treatment recommendations based on disease"""
+    """Generate treatment recommendations"""
     if is_healthy:
         return f"✅ Your {plant} plant appears healthy! Continue regular care and monitoring."
     
-    # Basic recommendations (extend this with real agricultural data)
+    # Enhanced recommendations database
     recommendations_db = {
-        "Early blight": "Remove affected leaves, apply fungicide, improve air circulation, avoid overhead watering.",
-        "Late blight": "Remove infected plants immediately, apply copper-based fungicide, ensure good drainage.",
-        "Powdery mildew": "Improve air circulation, reduce humidity, apply sulfur or neem oil spray.",
-        "Bacterial spot": "Remove infected leaves, avoid overhead watering, apply copper-based bactericide.",
-        "Leaf scorch": "Ensure adequate watering, protect from excessive heat, apply balanced fertilizer.",
-        "Common rust": "Remove infected leaves, apply fungicide, improve air circulation.",
-        "Black rot": "Prune infected areas, apply fungicide, ensure proper sanitation.",
+        # Apple
+        "Apple scab": "Apply fungicides in early spring, remove fallen leaves, prune for air circulation.",
+        "Black rot": "Remove infected fruit and wood, apply fungicide during bloom, avoid overhead irrigation.",
+        "Cedar apple rust": "Remove nearby junipers, apply fungicide in spring, plant resistant varieties.",
+        
+        # Tomato
+        "Early blight": "Remove affected leaves, apply chlorothalonil or copper fungicide, rotate crops.",
+        "Late blight": "REMOVE AND DESTROY infected plants immediately. Apply copper fungicide preventively.",
+        "Bacterial spot": "Use copper-based bactericides, avoid overhead watering, use pathogen-free seeds.",
+        "Leaf Mold": "Improve ventilation, reduce humidity, apply fungicide, remove affected leaves.",
+        "Septoria leaf spot": "Remove infected leaves, apply chlorothalonil, avoid watering foliage.",
+        
+        # Grape
+        "Black rot": "Remove infected fruit, apply fungicide during bloom, ensure good air circulation.",
+        
+        # Corn
+        "Common rust": "Plant resistant varieties, apply fungicide if detected early, rotate crops.",
+        "Northern Leaf Blight": "Till infected debris, rotate crops, apply fungicide during silking.",
+        
+        # General patterns
+        "Powdery mildew": "Improve air circulation, apply sulfur or potassium bicarbonate, avoid excess nitrogen.",
+        "Bacterial spot": "Use copper sprays, avoid working with wet plants, sanitize tools.",
+        "Leaf scorch": "Ensure adequate watering, mulch to retain moisture, protect from hot winds.",
+        "mosaic virus": "Remove infected plants, control aphids, use virus-free planting material.",
+        "Yellow Leaf Curl Virus": "Control whiteflies, remove infected plants, use resistant varieties.",
     }
     
-    # Try to match disease with recommendations
+    # Try exact match first
     for key, rec in recommendations_db.items():
-        if key.lower() in disease.lower():
-            return f"⚠️ {disease} detected. Treatment: {rec}"
+        if key.lower() == disease.lower():
+            return f"⚠️ **{disease}** detected on {plant}. Recommendations: {rec}"
     
-    return f"⚠️ {disease} detected. Consult with an agricultural expert for specific treatment."
+    # Try partial match
+    for key, rec in recommendations_db.items():
+        if key.lower() in disease.lower() or disease.lower() in key.lower():
+            return f"⚠️ **{disease}** detected on {plant}. Recommendations: {rec}"
+    
+    # Generic recommendation
+    return f"⚠️ **{disease}** detected on {plant}. Remove affected leaves, improve air circulation, and consult local agricultural extension for specific treatment."
 
 # ============================================================================
 # FastAPI Application
@@ -259,31 +402,33 @@ def get_recommendations(plant: str, disease: str, is_healthy: bool) -> str:
 
 app = FastAPI(
     title="Plant Disease Detection API",
-    description="AI-powered plant disease classification with OOD detection",
-    version="1.0.0"
+    description="AI-powered plant disease classification with robust OOD detection",
+    version="2.0.0"
 )
 
-# Enable CORS for mobile app integration
+# Enable CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Change to specific domains in production
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
 # ============================================================================
-# API Endpoints
+# API Endpoints - ENHANCED
 # ============================================================================
 
 @app.get("/", response_model=HealthResponse)
 async def root():
     """Health check endpoint"""
     return {
-        "status": "✅ API is running",
+        "status": "✅ API is running with improved OOD detection",
         "model_loaded": model is not None,
         "device": config.DEVICE,
-        "classes": len(config.CLASS_NAMES)
+        "classes": len(config.CLASS_NAMES),
+        "confidence_threshold": config.CONFIDENCE_THRESHOLD,
+        "ood_threshold": config.OOD_THRESHOLD
     }
 
 @app.get("/health")
@@ -291,75 +436,65 @@ async def health_check():
     """Detailed health check"""
     return {
         "status": "healthy",
-        "model": "EfficientNet-B0",
+        "model": "EfficientNet-B0 with OOD detection",
         "device": config.DEVICE,
         "classes": len(config.CLASS_NAMES),
-        "ood_detection": "enabled",
-        "temperature": config.TEMPERATURE,
-        "threshold": config.CONFIDENCE_THRESHOLD
+        "ood_methods": ood_detector.methods,
+        "confidence_threshold": config.CONFIDENCE_THRESHOLD,
+        "entropy_threshold": config.ENTROPY_THRESHOLD,
+        "note": "Confidence thresholds adjusted for 38-class problem"
     }
 
 @app.post("/predict")
 async def predict(file: UploadFile = File(...)):
     """
-    Predict plant disease from uploaded image
-    
-    Returns:
-        - If normal plant disease: prediction with confidence and recommendations
-        - If OOD (unknown object): warning message with low confidence
+    Predict plant disease with improved OOD detection
     
-    Example Response (Normal):
-    {
-        "status": "OK",
-        "prediction": "Tomato___Early_blight",
-        "confidence": 0.9234,
-        "plant": "Tomato",
-        "disease": "Early blight",
-        "is_healthy": false,
-        "top5_predictions": [...],
-        "recommendations": "Remove affected leaves, apply fungicide..."
-    }
-    
-    Example Response (OOD):
-    {
-        "status": "OOD",
-        "message": "⚠️ Unknown Object Detected",
-        "confidence": 0.4521,
-        "top_guess": "Tomato___healthy",
-        "note": "This doesn't appear to be a plant disease image..."
-    }
+    Key improvements:
+    1. Lower confidence threshold (0.3) for 38-class problem
+    2. Multiple OOD detection methods
+    3. Special handling for 'healthy' class
+    4. Better error messages
     """
     try:
-        # Validate file type
+        # Validate file
         if not file.content_type.startswith('image/'):
-            raise HTTPException(status_code=400, detail="File must be an image")
+            raise HTTPException(status_code=400, detail="File must be an image (JPEG, PNG, etc.)")
         
-        # Read and preprocess image
+        # Check file size (max 10MB)
+        file.file.seek(0, 2)
+        file_size = file.file.tell()
+        file.file.seek(0)
+        
+        if file_size > 10 * 1024 * 1024:  # 10MB
+            raise HTTPException(status_code=400, detail="Image too large (max 10MB)")
+        
+        # Read and process
         image_bytes = await file.read()
         image_tensor = preprocess_image(image_bytes)
         
         # Make prediction
         result = predict_image(image_tensor)
         
-        logger.info(f"Prediction: {result.get('prediction', 'OOD')} (confidence: {result['confidence']})")
+        # Log results
+        if result["status"] == "OOD":
+            logger.warning(f"OOD detected: {result['confidence']} confidence, {result['entropy']} entropy")
+        else:
+            logger.info(f"Prediction: {result['prediction']} ({result['confidence']:.2%})")
         
         return JSONResponse(content=result)
         
     except HTTPException as e:
         raise e
     except Exception as e:
-        logger.error(f"Prediction error: {e}")
+        logger.error(f"Prediction error: {str(e)}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
 
 @app.post("/predict/batch")
 async def predict_batch(files: List[UploadFile] = File(...)):
-    """
-    Predict multiple images at once
-    
-    Returns array of predictions
-    """
-    if len(files) > 10:
-        raise HTTPException(status_code=400, detail="Maximum 10 images per batch")
+    """Predict multiple images"""
+    if len(files) > 5:  # Reduced from 10
+        raise HTTPException(status_code=400, detail="Maximum 5 images per batch")
     
     results = []
     for file in files:
@@ -373,22 +508,39 @@ async def predict_batch(files: List[UploadFile] = File(...)):
             results.append({
                 "filename": file.filename,
                 "status": "ERROR",
-                "message": str(e)
+                "message": str(e)[:100]  # Truncate long errors
             })
     
     return JSONResponse(content={"predictions": results})
 
-@app.get("/classes")
-async def get_classes():
-    """Get list of all supported plant disease classes"""
+@app.get("/debug/ood")
+async def debug_ood():
+    """Debug endpoint to check OOD thresholds"""
     return {
-        "total_classes": len(config.CLASS_NAMES),
-        "classes": config.CLASS_NAMES
+        "confidence_threshold": config.CONFIDENCE_THRESHOLD,
+        "ood_threshold": config.OOD_THRESHOLD,
+        "entropy_threshold": config.ENTROPY_THRESHOLD,
+        "note": "For 38 classes, even correct predictions often have 30-60% confidence"
+    }
+
+@app.get("/classes/stats")
+async def class_statistics():
+    """Get class statistics"""
+    healthy_classes = [c for c in config.CLASS_NAMES if 'healthy' in c]
+    disease_classes = [c for c in config.CLASS_NAMES if 'healthy' not in c]
+    
+    return {
+        "total": len(config.CLASS_NAMES),
+        "healthy_classes": len(healthy_classes),
+        "disease_classes": len(disease_classes),
+        "plants": list(set([c.split('___')[0] for c in config.CLASS_NAMES]))
     }
 
 # ============================================================================
-# Run with: uvicorn plant_disease_api:app --reload --host 0.0.0.0 --port 7860
+# Run application
 # ============================================================================
+
 if __name__ == "__main__":
     import uvicorn
+    logger.info("Starting server with improved OOD detection...")
     uvicorn.run(app, host="0.0.0.0", port=7860)