version 1

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code and model files
+COPY main.py .
+COPY Random_forest_model.pkl .
+COPY XGBOOST.pkl .
+
+# Expose port
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

Random_forest_model.pkl

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

XGBOOST.pkl

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

app.py

@@ -0,0 +1,278 @@
+import joblib
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
+import numpy as np
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any
+import json
+from datetime import datetime
+
+# FastAPI app with enhanced metadata
+app = FastAPI(
+    title="Flood Disaster Management API",
+    description="ML-powered API for flood prediction and damage assessment using Random Forest and XGBoost models",
+    version="1.0.0",
+    docs_url="/",  # Swagger UI at root
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware for web frontend compatibility
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class PredictionInput(BaseModel):
+    features: List[float] = Field(
+        ...,
+        description="List of input features for prediction",
+        example=[40.7128, -74.0060, 100, 25.5, 80, 1013.25]
+    )
+
+
+class PredictionResponse(BaseModel):
+    prediction: List[float]
+    timestamp: str
+    model_used: str
+
+
+class BatchPredictionInput(BaseModel):
+    batch_features: List[List[float]] = Field(
+        ...,
+        description="List of feature arrays for batch prediction",
+        example=[[40.7128, -74.0060, 100, 25.5, 80, 1013.25], [41.8781, -87.6298, 120, 22.3, 75, 1015.2]]
+    )
+
+
+class ModelInfo(BaseModel):
+    model_name: str
+    model_type: str
+    feature_count: int
+    description: str
+
+
+# Load models with error handling
+try:
+    with open('Random_forest_model.pkl', 'rb') as file:
+        model = joblib.load(file)
+        print("✅ Random Forest model loaded successfully")
+except Exception as e:
+    print(f"❌ Error loading Random Forest model: {e}")
+    model = None
+
+try:
+    with open('XGBOOST.pkl', 'rb') as file:
+        model2 = joblib.load(file)
+        print("✅ XGBoost model loaded successfully")
+except Exception as e:
+    print(f"❌ Error loading XGBoost model: {e}")
+    model2 = None
+
+
+def transform_features(features: List[float]) -> np.ndarray:
+    """Convert lat/lon to sin/cos and keep rest of features."""
+    lat, lon = features[0], features[1]
+    lat_sin, lat_cos = np.sin(np.radians(lat)), np.cos(np.radians(lat))
+    lon_sin, lon_cos = np.sin(np.radians(lon)), np.cos(np.radians(lon))
+
+    # Build final array
+    # arr = [lat_sin, lat_cos, lon_sin, lon_cos] + features[2:]
+    arr = features
+    return np.array(arr).reshape(1, -1)
+
+
+@app.post("/predict/happen", response_model=PredictionResponse, tags=["Predictions"])
+async def predict_happen(input_data: PredictionInput):
+    """Predict flood occurrence probability using Random Forest model."""
+    if model is None:
+        raise HTTPException(status_code=500, detail="Random Forest model not available")
+
+    try:
+        arr = transform_features(input_data.features)
+        prediction = model.predict(arr)
+        return PredictionResponse(
+            prediction=prediction.tolist(),
+            timestamp=datetime.now().isoformat(),
+            model_used="Random Forest"
+        )
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Prediction error: {str(e)}")
+
+
+@app.post("/predict/damage", response_model=PredictionResponse, tags=["Predictions"])
+async def predict_damage(input_data: PredictionInput):
+    """Predict flood damage assessment using XGBoost model."""
+    if model2 is None:
+        raise HTTPException(status_code=500, detail="XGBoost model not available")
+
+    try:
+        arr = transform_features(input_data.features)
+        prediction = model2.predict(arr)  # <- Correct model used
+        return PredictionResponse(
+            prediction=prediction.tolist(),
+            timestamp=datetime.now().isoformat(),
+            model_used="XGBoost"
+        )
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Prediction error: {str(e)}")
+
+
+@app.post("/predict/batch", tags=["Predictions"])
+async def predict_batch(input_data: BatchPredictionInput, model_type: str = "happen"):
+    """Make batch predictions for multiple samples."""
+    if model_type not in ["happen", "damage"]:
+        raise HTTPException(status_code=400, detail="model_type must be 'happen' or 'damage'")
+
+    selected_model = model if model_type == "happen" else model2
+    model_name = "Random Forest" if model_type == "happen" else "XGBoost"
+
+    if selected_model is None:
+        raise HTTPException(status_code=500, detail=f"{model_name} model not available")
+
+    try:
+        predictions = []
+        for features in input_data.batch_features:
+            arr = transform_features(features)
+            pred = selected_model.predict(arr)
+            predictions.append(pred.tolist()[0])
+
+        return {
+            "predictions": predictions,
+            "count": len(predictions),
+            "model_used": model_name,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Batch prediction error: {str(e)}")
+
+
+@app.get("/models/info", response_model=List[ModelInfo], tags=["Model Information"])
+async def get_model_info():
+    """Get information about loaded models."""
+    models_info = []
+
+    if model is not None:
+        try:
+            feature_count = model.n_features_in_ if hasattr(model, 'n_features_in_') else "Unknown"
+        except:
+            feature_count = "Unknown"
+
+        models_info.append(ModelInfo(
+            model_name="Random Forest",
+            model_type="Classification/Regression",
+            feature_count=feature_count,
+            description="Used for flood occurrence prediction"
+        ))
+
+    if model2 is not None:
+        try:
+            feature_count = model2.n_features_in_ if hasattr(model2, 'n_features_in_') else "Unknown"
+        except:
+            feature_count = "Unknown"
+
+        models_info.append(ModelInfo(
+            model_name="XGBoost",
+            model_type="Gradient Boosting",
+            feature_count=feature_count,
+            description="Used for flood damage assessment"
+        ))
+
+    return models_info
+
+
+@app.get("/predict/demo", response_class=HTMLResponse, tags=["Demo"])
+async def demo_interface():
+    """Simple HTML demo interface for testing the API."""
+    return HTMLResponse(content="""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Flood Prediction Demo</title>
+        <style>
+            body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+            .container { background: #f5f5f5; padding: 20px; border-radius: 10px; margin: 10px 0; }
+            input, button { margin: 5px; padding: 8px; }
+            button { background: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer; }
+            button:hover { background: #0056b3; }
+            .result { background: #e9ecef; padding: 10px; border-radius: 4px; margin-top: 10px; }
+        </style>
+    </head>
+    <body>
+        <h1>🌊 Flood Disaster Management API Demo</h1>
+
+        <div class="container">
+            <h3>Test Flood Occurrence Prediction</h3>
+            <p>Enter features (comma-separated): Latitude, Longitude, Elevation, Temperature, Humidity, Pressure</p>
+            <input type="text" id="features1" placeholder="40.7128,-74.0060,100,25.5,80,1013.25" style="width: 400px;">
+            <button onclick="testHappen()">Predict Occurrence</button>
+            <div id="result1" class="result" style="display: none;"></div>
+        </div>
+
+        <div class="container">
+            <h3>Test Damage Assessment</h3>
+            <p>Enter features (comma-separated):</p>
+            <input type="text" id="features2" placeholder="40.7128,-74.0060,100,25.5,80,1013.25" style="width: 400px;">
+            <button onclick="testDamage()">Predict Damage</button>
+            <div id="result2" class="result" style="display: none;"></div>
+        </div>
+
+        <script>
+            async function testHappen() {
+                const features = document.getElementById('features1').value.split(',').map(x => parseFloat(x.trim()));
+                const response = await fetch('/predict/happen', {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'},
+                    body: JSON.stringify({features: features})
+                });
+                const result = await response.json();
+                document.getElementById('result1').style.display = 'block';
+                document.getElementById('result1').innerHTML = '<strong>Result:</strong> ' + JSON.stringify(result, null, 2);
+            }
+
+            async function testDamage() {
+                const features = document.getElementById('features2').value.split(',').map(x => parseFloat(x.trim()));
+                const response = await fetch('/predict/damage', {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'},
+                    body: JSON.stringify({features: features})
+                });
+                const result = await response.json();
+                document.getElementById('result2').style.display = 'block';
+                document.getElementById('result2').innerHTML = '<strong>Result:</strong> ' + JSON.stringify(result, null, 2);
+            }
+        </script>
+    </body>
+    </html>
+    """)
+
+
+@app.api_route("/health", methods=["GET", "HEAD"], tags=["Health"])
+async def health_check():
+    """Health check endpoint with detailed system status."""
+    return {
+        "status": "alive",
+        "service": "flood-disaster-management",
+        "timestamp": datetime.now().isoformat(),
+        "models": {
+            "random_forest": "loaded" if model is not None else "failed",
+            "xgboost": "loaded" if model2 is not None else "failed"
+        },
+        "version": "1.0.0"
+    }
+
+
+@app.get("/", tags=["Documentation"])
+async def root():
+    """Root endpoint redirects to API documentation."""
+    return {
+        "message": "Flood Disaster Management API",
+        "documentation": "/docs",
+        "demo": "/predict/demo",
+        "health": "/health",
+        "version": "1.0.0"
+    }

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.112.0
+uvicorn==0.30.0
+scikit-learn==1.6.1
+numpy==1.26.4
+pydantic==2.8.0
+gunicorn==22.0.0
+joblib==1.4.2
+xgboost>=2.1.0
+imbalanced-learn>=0.12.0