hugging face version 1

app.py

@@ -0,0 +1,400 @@
+from fastapi import FastAPI, HTTPException, Request, Response
+from pydantic import BaseModel
+import pandas as pd
+import joblib
+import requests
+from datetime import timedelta
+from math import sin, cos, radians, pi
+import logging
+import gc
+import os
+from huggingface_hub import hf_hub_download
+from contextlib import asynccontextmanager
+
+# -------------------------
+# Logger setup
+# -------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# -------------------------
+# Global variables for lazy loading (memory optimization)
+# -------------------------
+REPO_ID = "Vikctor/Drought_Disaster_Management"
+_occurrence_model = None
+_occurrence_scaler = None
+_severity_model = None
+_severity_scaler = None
+
+# -------------------------
+# NASA POWER setup
+# -------------------------
+API_BASE = "https://power.larc.nasa.gov/api/temporal/daily/point"
+PARAMS = "PRECTOT,T2M,T2M_MAX,T2M_MIN,ALLSKY_SFC_SW_DWN,RH2M,WS2M"
+
+FEATURE_ORDER = [
+    "RH2M", "T2M_MAX", "T2M_MIN", "WS2M", "T2M",
+    "ALLSKY_SFC_SW_DWN", "PRECTOTCORR",
+    "lat_sin", "lat_cos", "lon_sin", "lon_cos",
+    "month_sin", "month_cos"
+]
+
+
+# -------------------------
+# Memory management
+# -------------------------
+def cleanup_memory():
+    """Force garbage collection to free up memory"""
+    gc.collect()
+
+
+def safe_model_load(filename: str):
+    """Load model with comprehensive error handling"""
+    try:
+        logging.info(f"🔄 Attempting to download {filename}...")
+        model_path = hf_hub_download(
+            repo_id=REPO_ID,
+            filename=filename,
+            cache_dir="/tmp/hf_cache",
+            resume_download=True
+        )
+        logging.info(f"📁 Model downloaded to: {model_path}")
+
+        # Check file exists and has content
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"Downloaded file not found: {model_path}")
+
+        file_size = os.path.getsize(model_path)
+        if file_size == 0:
+            raise ValueError(f"Downloaded file is empty: {model_path}")
+
+        logging.info(f"📊 File size: {file_size / (1024 * 1024):.1f} MB")
+
+        # Load the model
+        model = joblib.load(model_path)
+        logging.info(f"✅ Successfully loaded {filename}")
+        return model
+
+    except Exception as e:
+        logging.error(f"❌ Failed to load {filename}: {str(e)}")
+        logging.error(f"❌ Error type: {type(e).__name__}")
+        raise HTTPException(status_code=500, detail=f"Model loading failed: {filename} - {str(e)}")
+
+
+# -------------------------
+# Lazy loading functions
+# -------------------------
+def get_occurrence_model_and_scaler():
+    global _occurrence_model, _occurrence_scaler
+    if _occurrence_model is None or _occurrence_scaler is None:
+        logging.info("Loading occurrence model and scaler...")
+        _occurrence_model = safe_model_load("drought_occurrence_model.joblib")
+        _occurrence_scaler = safe_model_load("drought_occurrence_scaler.joblib")
+        cleanup_memory()
+    return _occurrence_model, _occurrence_scaler
+
+
+def get_severity_model_and_scaler():
+    global _severity_model, _severity_scaler
+    if _severity_model is None or _severity_scaler is None:
+        logging.info("Loading severity model and scaler...")
+        _severity_model = safe_model_load("drought_severity_model.joblib")
+        _severity_scaler = safe_model_load("drought_severity_scaler.joblib")
+        cleanup_memory()
+    return _severity_model, _severity_scaler
+
+
+# -------------------------
+# Lifespan event handler (replaces deprecated on_event)
+# -------------------------
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    logging.info("🚀 Drought API starting - models will load on first request")
+    cleanup_memory()
+
+    yield
+
+    # Shutdown
+    logging.info("🛑 Drought API shutting down")
+    global _occurrence_model, _occurrence_scaler, _severity_model, _severity_scaler
+    _occurrence_model = _occurrence_scaler = _severity_model = _severity_scaler = None
+    cleanup_memory()
+
+
+# -------------------------
+# Request schema
+# -------------------------
+class PredictionRequest(BaseModel):
+    lat: float
+    lon: float
+    time: str  # YYYY-MM-DD
+
+
+# -------------------------
+# FastAPI app with lifespan
+# -------------------------
+app = FastAPI(
+    title="🌍 Drought Prediction API",
+    version="2.4",
+    description="Memory-optimized drought prediction API",
+    lifespan=lifespan
+)
+
+
+# -------------------------
+# NASA fetcher (memory optimized)
+# -------------------------
+def fetch_features(lat, lon, time_str: str) -> dict:
+    end = pd.to_datetime(time_str)
+    start = end - pd.Timedelta(days=90)
+
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "start": start.strftime("%Y%m%d"),
+        "end": end.strftime("%Y%m%d"),
+        "parameters": PARAMS,
+        "format": "JSON",
+        "community": "AG"
+    }
+
+    try:
+        response = requests.get(API_BASE, params=params, timeout=30)
+        if response.status_code != 200:
+            logging.error(f"NASA API error {response.status_code}")
+            raise HTTPException(status_code=502, detail="NASA API error")
+
+        data = response.json().get("properties", {}).get("parameter", {})
+        if not data:
+            raise HTTPException(status_code=502, detail="No data from NASA API")
+
+        features = {}
+        for p, values in data.items():
+            vals = [v for v in values.values() if v is not None]
+            if vals:
+                if p == "PRECTOT":
+                    features["PRECTOTCORR"] = sum(vals)
+                else:
+                    features[p] = sum(vals) / len(vals)
+
+        # Clear response from memory
+        del data, response, vals
+        cleanup_memory()
+
+        # Derived features
+        features.update({
+            "lat_sin": sin(radians(lat)),
+            "lat_cos": cos(radians(lat)),
+            "lon_sin": sin(radians(lon)),
+            "lon_cos": cos(radians(lon)),
+            "month_sin": sin(2 * pi * end.month / 12),
+            "month_cos": cos(2 * pi * end.month / 12)
+        })
+
+        missing = [f for f in FEATURE_ORDER if f not in features]
+        if missing:
+            raise HTTPException(status_code=500, detail=f"Missing features: {missing}")
+
+        return features
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logging.error(f"NASA API fetch error: {e}")
+        raise HTTPException(status_code=502, detail="NASA API request failed")
+
+
+# -------------------------
+# Prediction endpoint (memory optimized with detailed debugging)
+# -------------------------
+@app.post("/predict")
+async def predict(req: PredictionRequest):
+    try:
+        logging.info(f"🔄 Starting prediction for lat={req.lat}, lon={req.lon}, time={req.time}")
+
+        # Validate input
+        try:
+            pd.to_datetime(req.time)
+        except Exception as e:
+            logging.error(f"Invalid time format: {req.time}")
+            raise HTTPException(status_code=400, detail=f"Invalid time format: {req.time}. Use YYYY-MM-DD")
+
+        # Get features
+        logging.info("📡 Fetching NASA data...")
+        features = fetch_features(req.lat, req.lon, req.time)
+        logging.info(f"✅ Features fetched: {len(features)} features")
+
+        X = pd.DataFrame([[features[col] for col in FEATURE_ORDER]], columns=FEATURE_ORDER)
+        logging.info(f"📊 DataFrame created: {X.shape}")
+
+        # Occurrence prediction
+        logging.info("🔮 Loading occurrence model...")
+        try:
+            occ_model, occ_scaler = get_occurrence_model_and_scaler()
+            logging.info("✅ Occurrence model loaded")
+        except Exception as e:
+            logging.error(f"❌ Failed to load occurrence model: {e}")
+            raise HTTPException(status_code=500, detail=f"Failed to load occurrence model: {str(e)}")
+
+        try:
+            X_occ = occ_scaler.transform(X)
+            occurrence_pred = int(occ_model.predict(X_occ)[0])
+            occurrence_proba = occ_model.predict_proba(X_occ)[0].tolist()
+            logging.info(f"✅ Occurrence prediction: {occurrence_pred}")
+        except Exception as e:
+            logging.error(f"❌ Occurrence prediction failed: {e}")
+            raise HTTPException(status_code=500, detail=f"Occurrence prediction failed: {str(e)}")
+
+        del X_occ  # Free memory
+        cleanup_memory()
+
+        # Severity prediction
+        logging.info("🔮 Loading severity model...")
+        try:
+            sev_model, sev_scaler = get_severity_model_and_scaler()
+            logging.info("✅ Severity model loaded")
+        except Exception as e:
+            logging.error(f"❌ Failed to load severity model: {e}")
+            raise HTTPException(status_code=500, detail=f"Failed to load severity model: {str(e)}")
+
+        try:
+            X_sev = sev_scaler.transform(X)
+            severity_pred = int(sev_model.predict(X_sev)[0])
+            severity_proba = sev_model.predict_proba(X_sev)[0].tolist()
+            logging.info(f"✅ Severity prediction: {severity_pred}")
+        except Exception as e:
+            logging.error(f"❌ Severity prediction failed: {e}")
+            raise HTTPException(status_code=500, detail=f"Severity prediction failed: {str(e)}")
+
+        del X_sev  # Free memory
+        cleanup_memory()
+
+        result = {
+            "input": {"lat": req.lat, "lon": req.lon, "time": req.time},
+            "occurrence": {
+                "prediction": occurrence_pred,
+                "probabilities": occurrence_proba
+            },
+            "severity": {
+                "prediction": severity_pred,
+                "probabilities": severity_proba
+            },
+            "features_used": {k: round(v, 4) for k, v in zip(FEATURE_ORDER, X.iloc[0].tolist())}
+        }
+
+        # Final cleanup
+        del X, features
+        cleanup_memory()
+
+        logging.info(f"✅ Prediction complete: Occurrence={occurrence_pred}, Severity={severity_pred}")
+        return result
+
+    except HTTPException as http_err:
+        logging.error(f"HTTP Error: {http_err.detail}")
+        cleanup_memory()
+        raise http_err
+    except Exception as e:
+        logging.error(f"❌ Unexpected prediction error: {str(e)}")
+        logging.error(f"❌ Error type: {type(e).__name__}")
+        import traceback
+        logging.error(f"❌ Traceback: {traceback.format_exc()}")
+        cleanup_memory()
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+
+# -------------------------
+# Debug endpoint to test individual components
+# -------------------------
+@app.get("/debug")
+async def debug_info():
+    """Debug endpoint to check system status"""
+    try:
+        debug_data = {
+            "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}.{os.sys.version_info.micro}",
+            "feature_order": FEATURE_ORDER,
+            "repo_id": REPO_ID,
+            "api_base": API_BASE,
+            "models_loaded": {
+                "occurrence_model": _occurrence_model is not None,
+                "occurrence_scaler": _occurrence_scaler is not None,
+                "severity_model": _severity_model is not None,
+                "severity_scaler": _severity_scaler is not None
+            }
+        }
+
+        # Test NASA API with a simple request
+        try:
+            test_response = requests.get("https://power.larc.nasa.gov", timeout=10)
+            debug_data["nasa_api_accessible"] = test_response.status_code == 200
+        except:
+            debug_data["nasa_api_accessible"] = False
+
+        # Test HuggingFace Hub access
+        try:
+            from huggingface_hub import list_repo_files
+            files = list_repo_files(REPO_ID)
+            debug_data["hf_hub_accessible"] = len(files) > 0
+            debug_data["hf_files_found"] = list(files)
+        except Exception as e:
+            debug_data["hf_hub_accessible"] = False
+            debug_data["hf_error"] = str(e)
+
+        return debug_data
+
+    except Exception as e:
+        return {"debug_error": str(e)}
+
+
+# -------------------------
+# Test prediction with sample data
+# -------------------------
+@app.get("/test")
+async def test_prediction():
+    """Test endpoint with hardcoded values"""
+    try:
+        # Use a recent date and valid coordinates
+        test_request = PredictionRequest(
+            lat=40.7128,  # New York
+            lon=-74.0060,
+            time="2024-08-15"
+        )
+
+        result = await predict(test_request)
+        return {"test_status": "success", "result": result}
+
+    except Exception as e:
+        return {"test_status": "failed", "error": str(e)}
+
+
+# -------------------------
+# Health check (lightweight)
+# -------------------------
+@app.api_route("/health", methods=["GET", "HEAD"])
+async def health_check(request: Request):
+    if request.method == "HEAD":
+        return Response(status_code=200)
+
+    return {
+        "status": "healthy",
+        "api_version": "2.4",
+        "python_version": f"{os.sys.version_info.major}.{os.sys.version_info.minor}"
+    }
+
+
+# -------------------------
+# Root endpoint
+# -------------------------
+@app.get("/")
+async def root():
+    return {
+        "message": "🌍 Drought Prediction API",
+        "version": "2.4",
+        "endpoints": {
+            "predict": "/predict",
+            "health": "/health",
+            "docs": "/docs"
+        }
+    }

drought_occurrence_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8cb05be867a6b3268f9d49d8b960f70ecad14eab065a23ec3c362f00806e4942
+size 336273753

drought_occurrence_model_scaler.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0e56fd359b86b018ad105f0b58b4a3957900331285b01dd4101a29ea9d4b617
+size 1295

drought_severity_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e457728dd7ad92a8c3d15b77d61857a5b69df195f7bded6558c4149db20dae0
+size 288980609

drought_severity_model_scaler.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7929d7ec1460b3849fbba09209616b8c1fb6ee748b982f9035e059a785243117
+size 1295