Deploy Forest Segmentation API with LFS

.dockerignore

@@ -0,0 +1,27 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+dist/
+build/
+.venv
+venv/
+env/
+server/
+.git
+.gitignore
+.env
+.env.local
+*.md
+*.txt
+!requirements.txt
+logs/
+*.hdf5
+.DS_Store
+.vscode/
+.idea/
+*.log
+test_*.py
+*_test.py

Dockerfile

@@ -0,0 +1,47 @@
+# Use official Python runtime as base image
+FROM python:3.11-slim
+
+# Set working directory in container
+WORKDIR /app
+
+# Install system dependencies (OpenCV, HDF5 support)
+RUN apt-get update && apt-get install -y \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libhdf5-dev \
+    pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY main.py .
+COPY model.py .
+COPY schemas.py .
+COPY inference/ ./inference/
+
+# Copy pre-trained model (use .keras format only)
+COPY models/Forest_Segmentation_Best.keras ./models/
+
+# Create logs directory
+RUN mkdir -p logs
+
+# Expose port (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Set environment for production
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+ENV HOST=0.0.0.0
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health')" || exit 1
+
+# Run FastAPI application with uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""
+Entry point for FastAPI application.
+Runs uvicorn server on configurable host/port.
+"""
+
+import os
+import uvicorn
+from main import app
+
+if __name__ == "__main__":
+    host = os.getenv("HOST", "0.0.0.0")
+    port = int(os.getenv("PORT", "7860"))
+    
+    print(f"Starting Forest Segmentation API on {host}:{port}")
+    
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        log_level="info"
+    )

inference/forest.py

@@ -0,0 +1,261 @@
+from tensorflow.keras.models import load_model
+import numpy as np
+import base64
+import logging
+
+MODEL_PATH = "models/Forest_Segmentation_Best.keras"
+model = None
+EPS = 1e-6
+
+# Setup logging
+logger = logging.getLogger("forest_segmentation.inference")
+
+def load():
+    global model
+    if model is None:
+        logger.info("[INFERENCE] Loading model from: " + MODEL_PATH)
+        model = load_model(MODEL_PATH, compile=False)
+        logger.info("[INFERENCE] Model loaded successfully")
+
+def decode_band_float32(b64):
+    """Decode base64-encoded float32 band data to array"""
+    raw = base64.b64decode(b64)
+    arr = np.frombuffer(raw, dtype=np.float32)
+    side = int(np.sqrt(arr.size))
+    return arr.reshape((side, side))
+
+def validate_landsat_data(bands_dict):
+    """
+    Validate that input data matches Landsat 8 Collection 2 Level 2 format
+    Expected range: [-0.2, 0.6] for optical bands, [-1, 1] for indices
+    """
+    for band_name, data in bands_dict.items():
+        if data.ndim != 2:
+            raise ValueError(f"{band_name}: Expected 2D array, got shape {data.shape}")
+        if data.dtype != np.float32:
+            data = data.astype(np.float32)
+    return bands_dict
+
+def ndvi(red, nir):
+    """Normalized Difference Vegetation Index"""
+    return (nir - red) / (nir + red + EPS)
+
+def ndwi(green, nir):
+    """Normalized Difference Water Index"""
+    return (green - nir) / (green + nir + EPS)
+
+def nbr(nir, swir2):
+    """Normalized Burn Ratio"""
+    return (nir - swir2) / (nir + swir2 + EPS)
+
+def analyze_input_bands(bands):
+    """Analyze input bands and return statistics"""
+    stats = {}
+    
+    logger.info("[ANALYSIS] === INPUT BAND ANALYSIS ===")
+    
+    for band_name in ['Blue', 'Green', 'Red', 'NIR', 'SWIR1', 'SWIR2', 'NDVI', 'NDWI', 'NBR']:
+        if band_name in bands:
+            data = bands[band_name]
+            stats[band_name] = {
+                "min": float(data.min()),
+                "max": float(data.max()),
+                "mean": float(data.mean()),
+                "std": float(data.std())
+            }
+            logger.info(f"[ANALYSIS] {band_name}: min={stats[band_name]['min']:.4f}, max={stats[band_name]['max']:.4f}, mean={stats[band_name]['mean']:.4f}")
+    
+    # Analyze vegetation coverage
+    if 'NDVI' in bands:
+        ndvi_data = bands['NDVI']
+        veg_pixels = np.sum(ndvi_data > 0.5)
+        veg_pct = (veg_pixels / ndvi_data.size) * 100
+        logger.info(f"[ANALYSIS] NDVI > 0.5 (vegetation): {veg_pct:.2f}% of pixels")
+        stats['vegetation_coverage_pct'] = veg_pct
+    
+    return stats
+
+def preprocess_for_model(bands, clip_optical=False, clip_indices=False):
+    """
+    Preprocess bands to match model training expectations
+    
+    Args:
+        bands: Dictionary of band arrays
+        clip_optical: If True, clip optical bands to [-0.2, 0.6]
+        clip_indices: If True, clip indices to [-1, 1]
+    
+    Returns:
+        Preprocessed bands dictionary
+    """
+    processed = {}
+    
+    if clip_optical:
+        logger.info("[PREPROCESS] Clipping optical bands to [-0.2, 0.6]")
+        for name in ['Blue', 'Green', 'Red', 'NIR', 'SWIR1', 'SWIR2']:
+            if name in bands:
+                processed[name] = np.clip(bands[name], -0.2, 0.6)
+            else:
+                processed[name] = bands.get(name)
+    else:
+        for name in ['Blue', 'Green', 'Red', 'NIR', 'SWIR1', 'SWIR2']:
+            if name in bands:
+                processed[name] = bands[name]
+    
+    if clip_indices:
+        logger.info("[PREPROCESS] Clipping indices to [-1.0, 1.0]")
+        for name in ['NDVI', 'NDWI', 'NBR']:
+            if name in bands:
+                processed[name] = np.clip(bands[name], -1.0, 1.0)
+            else:
+                processed[name] = bands.get(name)
+    else:
+        for name in ['NDVI', 'NDWI', 'NBR']:
+            if name in bands:
+                processed[name] = bands[name]
+    
+    return processed
+
+def build_input_tensor(bands):
+    """
+    Build 9-channel input tensor from Landsat 8 bands
+    
+    Expected band dict keys:
+      - Blue, Green, Red: Optical bands (indices 0-2)
+      - NIR, SWIR1, SWIR2: Infrared bands (indices 3-5)
+      - NDVI, NDWI, NBR: Pre-calculated or computed indices (indices 6-8)
+    
+    Returns: (1, 256, 256, 9) array ready for model inference
+    """
+    # Extract optical bands
+    blue   = decode_band_float32(bands["Blue"])   if isinstance(bands["Blue"], str) else bands["Blue"]
+    green  = decode_band_float32(bands["Green"])  if isinstance(bands["Green"], str) else bands["Green"]
+    red    = decode_band_float32(bands["Red"])    if isinstance(bands["Red"], str) else bands["Red"]
+    nir    = decode_band_float32(bands["NIR"])    if isinstance(bands["NIR"], str) else bands["NIR"]
+    swir1  = decode_band_float32(bands["SWIR1"])  if isinstance(bands["SWIR1"], str) else bands["SWIR1"]
+    swir2  = decode_band_float32(bands["SWIR2"])  if isinstance(bands["SWIR2"], str) else bands["SWIR2"]
+
+    # Use pre-calculated indices if provided, otherwise compute them
+    if isinstance(bands.get("NDVI"), str) or isinstance(bands.get("NDVI"), np.ndarray):
+        ndvi_map = decode_band_float32(bands["NDVI"]) if isinstance(bands["NDVI"], str) else bands["NDVI"]
+    else:
+        ndvi_map = ndvi(red, nir)
+    
+    if isinstance(bands.get("NDWI"), str) or isinstance(bands.get("NDWI"), np.ndarray):
+        ndwi_map = decode_band_float32(bands["NDWI"]) if isinstance(bands["NDWI"], str) else bands["NDWI"]
+    else:
+        ndwi_map = ndwi(green, nir)
+    
+    if isinstance(bands.get("NBR"), str) or isinstance(bands.get("NBR"), np.ndarray):
+        nbr_map = decode_band_float32(bands["NBR"]) if isinstance(bands["NBR"], str) else bands["NBR"]
+    else:
+        nbr_map = nbr(nir, swir2)
+
+    # Stack into 9-channel tensor: (H, W, 9)
+    stacked = np.stack([
+        blue,
+        green,
+        red,
+        nir,
+        swir1,
+        swir2,
+        ndvi_map,
+        ndwi_map,
+        nbr_map
+    ], axis=-1).astype(np.float32)
+
+    # Validate data range matches training expectations
+    opt_min, opt_max = np.min(stacked[..., :6]), np.max(stacked[..., :6])
+    if opt_min < -0.3 or opt_max > 1.0:
+        logger.warning(f"[BUILD] WARNING: Optical bands range [{opt_min:.4f}, {opt_max:.4f}] outside expected [-0.2, 0.6]")
+
+    # Add batch dimension: (1, H, W, 9)
+    stacked = np.expand_dims(stacked, axis=0)
+    return stacked
+
+def predict_forest(bands, debug=False, clip_optical=False, clip_indices=False):
+    """
+    Predict forest segmentation mask from Landsat 8 9-band input
+    
+    Args:
+        bands: Dictionary with keys: Blue, Green, Red, NIR, SWIR1, SWIR2, NDVI, NDWI, NBR
+        debug: If True, return detailed debug statistics
+        clip_optical: If True, clip optical bands to [-0.2, 0.6]
+        clip_indices: If True, clip indices to [-1, 1]
+    
+    Returns:
+        Dictionary with mask, confidence scores, and optional debug data
+    """
+    load()
+    
+    # Analyze input
+    logger.info("[PREDICT] Starting prediction...")
+    input_stats = analyze_input_bands(bands)
+    
+    # Preprocess if requested
+    if clip_optical or clip_indices:
+        logger.info("[PREDICT] Applying preprocessing (clip_optical={}, clip_indices={})...".format(clip_optical, clip_indices))
+        bands = preprocess_for_model(bands, clip_optical=clip_optical, clip_indices=clip_indices)
+    
+    # Build input tensor
+    logger.info("[PREDICT] Building input tensor...")
+    x = build_input_tensor(bands)
+    
+    # Run inference
+    logger.info("[PREDICT] Running model inference...")
+    pred = model.predict(x, verbose=0)[0, :, :, 0]  # Extract (H, W) from (1, H, W, 1)
+    
+    # Analyze output
+    logger.info("[PREDICT] === RAW MODEL OUTPUT ===")
+    logger.info(f"[PREDICT] Output shape: {pred.shape}, dtype: {pred.dtype}")
+    logger.info(f"[PREDICT] Output range: [{pred.min():.4f}, {pred.max():.4f}]")
+    logger.info(f"[PREDICT] Output mean: {pred.mean():.4f}, std: {pred.std():.4f}")
+    logger.info(f"[PREDICT] Pixels > 0.5: {np.sum(pred > 0.5):,} / {pred.size:,} ({100*np.sum(pred > 0.5)/pred.size:.2f}%)")
+    logger.info(f"[PREDICT] Pixels > 0.8: {np.sum(pred > 0.8):,} / {pred.size:,}")
+    
+    # Generate binary mask
+    mask = (pred > 0.5).astype(np.uint8) * 255
+    
+    # Calculate statistics
+    forest_confidence = float(np.mean(pred[pred > 0.5])) if np.any(pred > 0.5) else 0.0
+    forest_percentage = float((pred > 0.5).sum() / pred.size * 100)
+
+    result = {
+        "mask": mask.tolist(),
+        "forest_confidence": forest_confidence,
+        "forest_percentage": forest_percentage,
+        "mean_prediction": float(pred.mean()),
+        "classes": ["forest", "non-forest"],
+        "model_version": "landsat8_trained"
+    }
+    
+    if debug:
+        logger.info("[PREDICT] Adding debug information...")
+        result["debug"] = {
+            "input_stats": input_stats,
+            "output_distribution": {
+                "min": float(pred.min()),
+                "max": float(pred.max()),
+                "mean": float(pred.mean()),
+                "std": float(pred.std()),
+                "percentile_10": float(np.percentile(pred, 10)),
+                "percentile_25": float(np.percentile(pred, 25)),
+                "percentile_50": float(np.percentile(pred, 50)),
+                "percentile_75": float(np.percentile(pred, 75)),
+                "percentile_90": float(np.percentile(pred, 90)),
+                "histogram": {
+                    "0.0-0.1": int(np.sum((pred >= 0.0) & (pred < 0.1))),
+                    "0.1-0.2": int(np.sum((pred >= 0.1) & (pred < 0.2))),
+                    "0.2-0.3": int(np.sum((pred >= 0.2) & (pred < 0.3))),
+                    "0.3-0.4": int(np.sum((pred >= 0.3) & (pred < 0.4))),
+                    "0.4-0.5": int(np.sum((pred >= 0.4) & (pred < 0.5))),
+                    "0.5-0.6": int(np.sum((pred >= 0.5) & (pred < 0.6))),
+                    "0.6-0.7": int(np.sum((pred >= 0.6) & (pred < 0.7))),
+                    "0.7-0.8": int(np.sum((pred >= 0.7) & (pred < 0.8))),
+                    "0.8-0.9": int(np.sum((pred >= 0.8) & (pred < 0.9))),
+                    "0.9-1.0": int(np.sum((pred >= 0.9) & (pred <= 1.0)))
+                }
+            }
+        }
+    
+    logger.info("[PREDICT] Forest prediction: {:.2f}%".format(forest_percentage))
+    return result

main.py

@@ -0,0 +1,258 @@
+# main.py
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
+import tensorflow as tf
+import numpy as np
+import base64
+import logging
+import os
+import sys
+import time
+from datetime import datetime
+from logging.handlers import RotatingFileHandler
+
+from inference.forest import predict_forest, build_input_tensor
+from schemas import PredictRequest, PredictResponse
+
+# =============================================================================
+# LOGGING CONFIGURATION
+# =============================================================================
+
+os.makedirs("logs", exist_ok=True)
+
+logger = logging.getLogger("forest_segmentation")
+logger.setLevel(logging.DEBUG)
+
+console_handler = logging.StreamHandler(sys.stdout)
+console_handler.setLevel(logging.DEBUG)
+console_handler.setFormatter(
+    logging.Formatter(
+        "%(asctime)s | %(levelname)-8s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+)
+
+file_handler = RotatingFileHandler(
+    "logs/server.log", maxBytes=10_000_000, backupCount=5, encoding="utf-8"
+)
+file_handler.setFormatter(console_handler.formatter)
+
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)
+
+logger.info("=" * 80)
+logger.info("FOREST SEGMENTATION SERVER STARTING")
+logger.info("=" * 80)
+
+# =============================================================================
+# INVERSION DETECTION
+# =============================================================================
+
+def detect_inversion(image_stack, confidence_map, ndvi_threshold=0.3):
+    """
+    Detect if model output is inverted using NDVI correlation.
+    image_stack: (H, W, 9)
+    confidence_map: (H, W)
+    """
+    ndvi = image_stack[:, :, 6]  # NDVI channel
+
+    vegetation_mask = ndvi > ndvi_threshold
+
+    veg_conf = (
+        confidence_map[vegetation_mask].mean()
+        if vegetation_mask.any() else 0.5
+    )
+
+    non_veg_conf = (
+        confidence_map[~vegetation_mask].mean()
+        if (~vegetation_mask).any() else 0.5
+    )
+
+    is_inverted = non_veg_conf > veg_conf
+    correlation = veg_conf - non_veg_conf
+
+    return bool(is_inverted), float(correlation)
+
+# =============================================================================
+# FASTAPI APP
+# =============================================================================
+
+app = FastAPI(
+    title="Forest Segmentation API",
+    description="Landsat 8 Forest Segmentation",
+    version="1.0.0"
+)
+
+IMG_SIZE = 256
+LANDSAT_BANDS = [
+    "Blue", "Green", "Red",
+    "NIR", "SWIR1", "SWIR2",
+    "NDVI", "NDWI", "NBR"
+]
+
+# =============================================================================
+# MIDDLEWARE
+# =============================================================================
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    start = time.time()
+    response = await call_next(request)
+    duration = time.time() - start
+    logger.info(
+        f"{request.method} {request.url.path} | "
+        f"{response.status_code} | {duration:.3f}s"
+    )
+    return response
+
+# =============================================================================
+# HEALTH
+# =============================================================================
+
+@app.get("/health")
+def health():
+    return {
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat()
+    }
+
+# =============================================================================
+# PREDICT ENDPOINT (FIXED - CONTINUOUS VALUES)
+# =============================================================================
+
+@app.post("/predict", response_model=PredictResponse)
+def predict(payload: PredictRequest):
+
+    try:
+        logger.info("[PREDICT] Request received")
+
+        if not payload.bands:
+            raise ValueError("No bands provided")
+
+        # ---------------------------------------------------------------------
+        # Decode bands
+        # ---------------------------------------------------------------------
+        decoded_bands = {}
+
+        for band, data in payload.bands.items():
+            if isinstance(data, str):
+                raw = base64.b64decode(data)
+                arr = np.frombuffer(raw, dtype=np.float32)
+                side = int(np.sqrt(arr.size))
+                decoded_bands[band] = arr.reshape((side, side))
+            else:
+                decoded_bands[band] = np.array(data, dtype=np.float32)
+
+        logger.info(f"[PREDICT] Decoded {len(decoded_bands)} bands")
+
+        # ---------------------------------------------------------------------
+        # Build input tensor
+        # ---------------------------------------------------------------------
+        input_tensor = build_input_tensor(decoded_bands)  # (1, H, W, 9)
+        input_stack = input_tensor[0]                     # (H, W, 9)
+
+        # ---------------------------------------------------------------------
+        # Run model (raw confidence)
+        # ---------------------------------------------------------------------
+        model = tf.keras.models.load_model(
+            "models/Forest_Segmentation_Best.keras",
+            compile=False
+        )
+
+        confidence_map = model.predict(
+            input_tensor, verbose=0
+        )[0, :, :, 0]
+
+        # Log raw model output stats
+        logger.info(
+            f"[MODEL OUTPUT] Raw confidence: min={confidence_map.min():.4f}, "
+            f"max={confidence_map.max():.4f}, mean={confidence_map.mean():.4f}"
+        )
+
+        # ---------------------------------------------------------------------
+        # Inversion detection & correction
+        # ---------------------------------------------------------------------
+        is_inverted, corr = detect_inversion(
+            input_stack, confidence_map
+        )
+
+        if is_inverted:
+            logger.warning(
+                f"[INVERSION] Detected | NDVI correlation={corr:.4f} | FIX APPLIED"
+            )
+            corrected_conf = 1.0 - confidence_map
+        else:
+            logger.info(
+                f"[INVERSION] Not detected | NDVI correlation={corr:.4f}"
+            )
+            corrected_conf = confidence_map
+
+        # ---------------------------------------------------------------------
+        # Create masks (CONTINUOUS values for density visualization)
+        # ---------------------------------------------------------------------
+        # Use continuous confidence scaled to 0-255 (NOT binary!)
+        mask_255 = (corrected_conf * 255).astype(np.uint8)
+        inverted_mask_255 = (255 - mask_255).astype(np.uint8)
+
+        # Calculate stats using threshold for percentage
+        forest_percentage = float((corrected_conf > 0.5).sum() / corrected_conf.size * 100)
+        forest_confidence = float(corrected_conf.mean())
+
+        # Log mask stats to verify continuous values
+        logger.info(
+            f"[MASK] Range: [{mask_255.min()}, {mask_255.max()}] | "
+            f"Unique values: {len(np.unique(mask_255))}"
+        )
+
+        logger.info(
+            f"[PREDICT] Forest={forest_percentage:.2f}% | "
+            f"Confidence={forest_confidence:.4f}"
+        )
+
+        # ---------------------------------------------------------------------
+        # Response
+        # ---------------------------------------------------------------------
+        return {
+            "mask": mask_255.flatten().tolist(),
+            "inverted_mask": inverted_mask_255.flatten().tolist(),
+            "forest_percentage": forest_percentage,
+            "forest_confidence": forest_confidence,
+            "mean_prediction": forest_confidence,
+            "classes": {"forest": 1, "non_forest": 0},
+            "model_info": {
+                "name": "Forest_Segmentation_Best",
+                "bands": LANDSAT_BANDS
+            },
+            "debug": {
+                "was_inverted": is_inverted,
+                "inversion_correlation": corr,
+                "mask_min": int(mask_255.min()),
+                "mask_max": int(mask_255.max()),
+                "unique_values": int(len(np.unique(mask_255)))
+            }
+        }
+
+    except ValueError as e:
+        logger.error(f"[PREDICT] Validation error: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+    except Exception as e:
+        logger.exception("[PREDICT] Inference failed")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# =============================================================================
+# STARTUP / SHUTDOWN
+# =============================================================================
+
+@app.on_event("startup")
+async def startup():
+    logger.info("=" * 80)
+    logger.info("SERVER READY")
+    logger.info("=" * 80)
+
+@app.on_event("shutdown")
+async def shutdown():
+    logger.info("=" * 80)
+    logger.info("SERVER SHUTDOWN")
+    logger.info("=" * 80)

model.py

@@ -0,0 +1,152 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+import base64
+import io
+
+MODEL_PATH = "models/Forest_Segmentation_Best.keras"
+EPS = 1e-6
+model = None
+
+# ----------------------------
+# Load model once
+# ----------------------------
+def load_segmentation_model():
+    global model
+    if model is None:
+        model = load_model(MODEL_PATH, compile=False)
+
+# ----------------------------
+# Decode Landsat band from base64
+# ----------------------------
+def decode_band_float32(b64):
+    """Decode base64-encoded float32 data to 2D array"""
+    raw = base64.b64decode(b64)
+    arr = np.frombuffer(raw, dtype=np.float32)
+    side = int(np.sqrt(arr.size))  # assumes square tile
+    arr = arr.reshape((side, side))
+    return arr
+
+# ----------------------------
+# Spectral Indices (matching training pipeline)
+# ----------------------------
+def ndvi(red, nir):
+    """Normalized Difference Vegetation Index"""
+    return (nir - red) / (nir + red + EPS)
+
+def ndwi(green, nir):
+    """Normalized Difference Water Index"""
+    return (green - nir) / (green + nir + EPS)
+
+def nbr(nir, swir2):
+    """Normalized Burn Ratio"""
+    return (nir - swir2) / (nir + swir2 + EPS)
+
+# ----------------------------
+# Build 9-channel tensor from Landsat 8
+# ----------------------------
+def build_input_tensor(bands):
+    """
+    Build 9-channel input tensor from Landsat 8 Collection 2 Level 2 data
+    
+    Args:
+        bands: Dictionary with keys:
+          - Blue, Green, Red: Optical bands (0-2)
+          - NIR, SWIR1, SWIR2: Infrared bands (3-5)
+          - NDVI, NDWI, NBR: Indices (6-8)
+          
+          Values can be:
+          - Base64-encoded float32 strings (from API)
+          - Numpy arrays (from direct processing)
+    
+    Returns:
+        (1, H, W, 9) array ready for model inference
+        
+    Expected value range:
+        - Optical bands: [-0.2, 0.6]
+        - Indices: [-1, 1]
+    """
+    # Extract and decode optical bands
+    blue  = decode_band_float32(bands["Blue"]) if isinstance(bands["Blue"], str) else bands["Blue"]
+    green = decode_band_float32(bands["Green"]) if isinstance(bands["Green"], str) else bands["Green"]
+    red   = decode_band_float32(bands["Red"]) if isinstance(bands["Red"], str) else bands["Red"]
+    nir   = decode_band_float32(bands["NIR"]) if isinstance(bands["NIR"], str) else bands["NIR"]
+    swir1 = decode_band_float32(bands["SWIR1"]) if isinstance(bands["SWIR1"], str) else bands["SWIR1"]
+    swir2 = decode_band_float32(bands["SWIR2"]) if isinstance(bands["SWIR2"], str) else bands["SWIR2"]
+
+    # Use pre-calculated indices if provided, otherwise compute them
+    if "NDVI" in bands and bands["NDVI"] is not None:
+        ndvi_map = decode_band_float32(bands["NDVI"]) if isinstance(bands["NDVI"], str) else bands["NDVI"]
+    else:
+        ndvi_map = ndvi(red, nir)
+    
+    if "NDWI" in bands and bands["NDWI"] is not None:
+        ndwi_map = decode_band_float32(bands["NDWI"]) if isinstance(bands["NDWI"], str) else bands["NDWI"]
+    else:
+        ndwi_map = ndwi(green, nir)
+    
+    if "NBR" in bands and bands["NBR"] is not None:
+        nbr_map = decode_band_float32(bands["NBR"]) if isinstance(bands["NBR"], str) else bands["NBR"]
+    else:
+        nbr_map = nbr(nir, swir2)
+
+    # Stack into (H, W, 9) - matches training data format exactly
+    stacked = np.stack([
+        blue,
+        green,
+        red,
+        nir,
+        swir1,
+        swir2,
+        ndvi_map,
+        ndwi_map,
+        nbr_map
+    ], axis=-1)
+
+    stacked = stacked.astype(np.float32)
+    stacked = np.expand_dims(stacked, axis=0)  # (1, H, W, 9)
+
+    return stacked
+
+# ----------------------------
+# Inference
+# ----------------------------
+def predict_segmentation(bands):
+    """
+    Predict forest segmentation mask
+    
+    Args:
+        bands: Dictionary with Landsat 8 bands
+        
+    Returns:
+        Dictionary with:
+          - mask: (H, W) binary segmentation
+          - forest_percentage: % of pixels classified as forest
+          - forest_confidence: average confidence on forest pixels
+          - metadata: model and input information
+    """
+    load_segmentation_model()
+
+    x = build_input_tensor(bands)
+    pred = model.predict(x, verbose=0)[0, :, :, 0]
+
+    # Generate binary mask
+    mask = (pred > 0.5).astype(np.uint8) * 255
+    
+    # Calculate statistics
+    forest_confidence = float(np.mean(pred[pred > 0.5])) if np.any(pred > 0.5) else 0.0
+    forest_percentage = float((pred > 0.5).sum() / pred.size * 100)
+
+    return {
+        "mask": mask.tolist(),
+        "forest_percentage": forest_percentage,
+        "forest_confidence": forest_confidence,
+        "mean_prediction": float(pred.mean()),
+        "classes": ["forest", "non-forest"],
+        "model_info": {
+            "training_data": "Landsat 8 Collection 2 Level 2",
+            "bands": ["Blue", "Green", "Red", "NIR", "SWIR1", "SWIR2", "NDVI", "NDWI", "NBR"],
+            "patch_size": 256,
+            "value_range": "[-0.2, 0.6] for optical, [-1, 1] for indices"
+        }
+    }

models/Forest_Segmentation_Best.keras

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

schemas.py

@@ -0,0 +1,41 @@
+from pydantic import BaseModel
+from typing import Dict, List, Optional, Union
+
+class PredictRequest(BaseModel):
+    """
+    Forest segmentation prediction request
+    
+    Supports Landsat 8 Collection 2 Level 2 data format.
+    Each band can be provided as:
+    - Base64-encoded float32 data (for remote API calls)
+    - Array/list format (for direct server calls)
+    
+    Required bands:
+      - Blue, Green, Red: Optical bands
+      - NIR, SWIR1, SWIR2: Infrared bands
+      - NDVI, NDWI, NBR: Spectral indices (or server will compute them)
+    
+    Optional special keys:
+      - _invert_mask: Set to true to invert forest/non-forest in response
+    
+    Value range expectations:
+      - Optical bands: [-0.2, 0.6]
+      - Indices: [-1, 1]
+    """
+    model_name: str = "forest_segmentation"
+    model_version: str = "landsat8_v1"
+    bands: Dict[str, Union[str, List, int]]  # Band data as base64 or array
+
+
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+
+class PredictResponse(BaseModel):
+    mask: List[int]                    # 1D flat list ✓
+    inverted_mask: List[int]           # 1D flat list ✓
+    forest_percentage: float
+    forest_confidence: float
+    mean_prediction: float
+    classes: Dict[str, int]
+    model_info: Dict[str, Any]
+    debug: Optional[Dict[str, Any]] = None