Create app.py

app.py

@@ -0,0 +1,159 @@
+import os
+import joblib
+import numpy as np
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import logging
+import sys
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Bloom Prediction ML API")
+
+# ML Model artifacts (upload these to your Hugging Face Space)
+MODEL_PATH = "mil_bloom_model.joblib"
+SCALER_PATH = "mil_scaler.joblib" 
+FEATURES_PATH = "mil_features.joblib"
+
+# Global variables for ML model
+ML_MODEL = None
+SCALER = None
+FEATURE_COLUMNS = None
+
+class PredictionRequest(BaseModel):
+    features: dict
+    parameters: dict = {}
+
+class PredictionResponse(BaseModel):
+    success: bool
+    bloom_probability: float
+    prediction: str
+    confidence: str
+    message: str = ""
+
+def load_ml_model():
+    """Load the ML model and artifacts"""
+    global ML_MODEL, SCALER, FEATURE_COLUMNS
+    
+    try:
+        ML_MODEL = joblib.load(MODEL_PATH)
+        SCALER = joblib.load(SCALER_PATH)
+        FEATURE_COLUMNS = joblib.load(FEATURES_PATH)
+        logger.info("✅ ML model loaded successfully in Hugging Face Space")
+        logger.info(f"✅ Features: {FEATURE_COLUMNS}")
+    except Exception as e:
+        logger.error(f"❌ Failed to load ML model: {e}")
+        raise
+
+def predict_bloom(features_dict: dict):
+    """
+    ML prediction logic - same as your original but now runs on Hugging Face
+    """
+    if ML_MODEL is None:
+        raise ValueError("ML model not loaded")
+    
+    # Extract features in correct order
+    try:
+        features_array = np.array([[
+            float(features_dict['ndvi']),
+            float(features_dict['ndwi']), 
+            float(features_dict['evi']),
+            float(features_dict['lst']),
+            float(features_dict['cloud_cover']),
+            float(features_dict['month']),
+            float(features_dict['day_of_year'])
+        ]])
+        
+        # Scale features
+        features_scaled = SCALER.transform(features_array)
+        
+        # Get prediction
+        probabilities = ML_MODEL.predict_proba(features_scaled)
+        
+        if probabilities.shape[1] == 2:
+            bloom_probability = probabilities[0, 1]
+        else:
+            bloom_probability = probabilities[0, 0]
+        
+        prediction = ML_MODEL.predict(features_scaled)[0]
+        
+        # Apply your business logic (winter adjustments, etc.)
+        ndvi = features_dict['ndvi']
+        evi = features_dict['evi']
+        month = features_dict['month']
+        
+        # Winter adjustment
+        if month in [11, 12, 1, 2] and evi < 0.8 and ndvi < 0.3:
+            bloom_probability = bloom_probability * 0.5
+            logger.info("❄️ Applied winter adjustment")
+        
+        # Confidence calculation
+        if bloom_probability > 0.75 or bloom_probability < 0.25:
+            confidence = 'HIGH'
+        elif bloom_probability > 0.6 or bloom_probability < 0.4:
+            confidence = 'MEDIUM'
+        else:
+            confidence = 'LOW'
+        
+        return {
+            'bloom_probability': round(float(bloom_probability * 100), 2),
+            'prediction': 'BLOOM' if prediction == 1 else 'NO_BLOOM',
+            'confidence': confidence,
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Prediction error: {e}")
+        raise
+
+@app.on_event("startup")
+async def startup_event():
+    """Load ML model when the app starts"""
+    load_ml_model()
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Bloom Prediction ML API",
+        "status": "active",
+        "model_loaded": ML_MODEL is not None
+    }
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "model_loaded": ML_MODEL is not None
+    }
+
+@app.post("/predict")
+async def predict(request: PredictionRequest):
+    """
+    Main prediction endpoint called by the backend
+    """
+    try:
+        logger.info(f"📊 Received prediction request with features: {request.features}")
+        
+        # Perform ML prediction
+        prediction_result = predict_bloom(request.features)
+        
+        response = PredictionResponse(
+            success=True,
+            bloom_probability=prediction_result['bloom_probability'],
+            prediction=prediction_result['prediction'],
+            confidence=prediction_result['confidence'],
+            message="Prediction completed successfully"
+        )
+        
+        logger.info(f"✅ Prediction completed: {prediction_result['bloom_probability']}%")
+        return response
+        
+    except Exception as e:
+        logger.error(f"❌ Prediction failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+# For Hugging Face Spaces deployment
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)