Initial deployment: Attention UNet + ZoeDepth + Grad-CAM + Risk Assessment

.gitattributes

@@ -0,0 +1,3 @@
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.keras filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,315 @@
+---
+title: Flood Risk Detection
+emoji: 🌊
+colorFrom: blue
+colorTo: red
+sdk: gradio
+sdk_version: "6.14.0"
+app_file: app.py
+pinned: true
+license: mit
+short_description: Attention UNet flood segmentation + ZoeDepth + risk assessment
+---
+
+# 🌊 Flood Detection & Depth-Aware Risk Assessment
+
+An end-to-end deep learning pipeline for flood detection, explainability, depth estimation, and risk scoring from satellite/aerial imagery.
+
+---
+
+## 🏗️ Project Structure
+
+```
+├── app.py                              ← Gradio UI (HF Spaces entry point)
+├── app/
+│   ├── __init__.py
+│   ├── main.py                         ← FastAPI REST backend
+│   └── model_utils.py                  ← Core engine (model, Grad-CAM, ZoeDepth, risk)
+├── models/
+│   ├── flood_best_model_export.keras   ← Attention UNet weights
+│   └── flood_model_production.pkl      ← Metadata (thresholds, metrics, layer names)
+├── requirements.txt
+└── run_all.py                          ← Local launcher (FastAPI + Gradio together)
+```
+
+---
+
+## ⚙️ Full Pipeline
+
+```
+Input Image
+    │
+    ▼
+1. Preprocessing
+   └─ Convert to RGB → resize 512×512 → normalise [0,1]
+    │
+    ▼
+2. Attention UNet  (flood_best_model_export.keras)
+   └─ Predicts per-pixel flood probability map (512×512)
+   └─ OOD detection: colour check + spatial coherence + coverage cap
+   └─ Threshold 0.5 → binary mask (1=flooded, 0=dry)
+    │
+    ▼
+3. Grad-CAM  (layer: conv2d_130)
+   └─ GradientTape → gradients w.r.t. last conv feature maps
+   └─ Weighted sum → activation map → JET colormap overlay
+    │
+    ▼
+4. ZoeDepth  (Intel/zoedepth-nyu, CPU)
+   └─ Monocular depth estimation → relative depth map
+   └─ Normalise to [0,3m] → stats within flooded pixels only
+    │
+    ▼
+5. Risk Assessment
+   └─ flood_pct + avg_depth_m → Low / Moderate / High / Critical
+   └─ Score = flood_pct×0.7 + depth_score×0.3
+```
+
+---
+
+## 🚀 Deploy to Hugging Face Spaces
+
+### Step 1 — Clone your Space
+```bash
+git clone https://huggingface.co/spaces/YOUR_USERNAME/flood-risk-detection
+cd flood-risk-detection
+```
+
+### Step 2 — Set up Git LFS (for large model files)
+```bash
+git lfs install
+git lfs track "*.keras" "*.pkl"
+git add .gitattributes
+```
+
+### Step 3 — Copy project files
+Copy these into the cloned folder:
+```
+app.py
+app/__init__.py
+app/model_utils.py
+models/flood_best_model_export.keras
+models/flood_model_production.pkl
+requirements.txt
+README.md
+```
+
+### Step 4 — Add HF_TOKEN as a Secret
+In your Space → **Settings → Variables and Secrets → New Secret**:
+```
+Name:  HF_TOKEN
+Value: your_huggingface_token
+```
+This is used by ZoeDepth to download model weights from the Hub.
+
+### Step 5 — Push
+```bash
+git add .
+git commit -m "Deploy flood detection app"
+git push
+```
+HF Spaces will automatically install `requirements.txt` and launch `app.py`.
+
+> **Note:** First inference is slow (~60s) — ZoeDepth downloads ~1.4GB weights on first run, then caches them.
+
+---
+
+## 💻 Run Locally
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Set environment variables
+set HF_TOKEN=your_token          # Windows CMD
+$env:HF_TOKEN="your_token"       # PowerShell
+
+# Start both servers
+python run_all.py
+
+# OR individually:
+python app.py                                          # Gradio → http://localhost:7860
+uvicorn app.main:app --reload --port 8000              # FastAPI → http://localhost:8000/docs
+```
+
+---
+
+## 📡 API Reference
+
+### `POST /predict`
+```bash
+curl -X POST http://localhost:8000/predict \
+  -F "file=@flood_image.jpg"
+```
+Response:
+```json
+{
+  "mask_b64":        "<base64 PNG — binary flood mask>",
+  "overlay_b64":     "<base64 PNG — blue flood overlay>",
+  "gradcam_b64":     "<base64 PNG — JET heatmap>",
+  "depth_map_b64":   "<base64 PNG — PLASMA depth map>",
+  "depth_flood_b64": "<base64 PNG — depth in flood region>",
+  "depth_info": {
+    "avg_depth_m": 0.82,
+    "max_depth_m": 1.45,
+    "depth_category": "Moderate (30 cm – 80 cm)"
+  },
+  "risk": {
+    "risk_level": "High",
+    "risk_score": 43.5,
+    "flood_pct": 38.4,
+    "avg_depth_m": 0.82,
+    "recommendations": ["..."]
+  }
+}
+```
+
+### `GET /health`
+```json
+{"status": "ok"}
+```
+
+---
+
+## 📊 Model Performance
+
+| Model | Pixel Accuracy | IoU (Jaccard) | Dice / F1 | Precision | Recall |
+|-------|---------------|---------------|-----------|-----------|--------|
+| UNet (baseline) | 82.55% | 63.94% | 78.00% | 78.75% | 77.26% |
+| **Attention UNet (deployed)** | **89.36%** | **76.91%** | **86.95%** | **85.41%** | **88.54%** |
+
+---
+
+## 🎓 Viva Questions & Answers
+
+### Architecture
+
+**Q: Why did you choose UNet for flood segmentation?**
+UNet is a fully convolutional encoder-decoder architecture with skip connections. The skip connections preserve spatial detail lost during downsampling — critical for pixel-accurate segmentation. The encoder captures semantic context (what is flooded) while the decoder reconstructs spatial resolution (where exactly).
+
+**Q: What is the difference between UNet and Attention UNet?**
+Attention UNet adds attention gates at each skip connection. These gates learn to suppress feature responses in irrelevant regions (dry land, buildings) and amplify responses in relevant regions (water, flooded areas). This is done by computing a soft attention coefficient per spatial location using the decoder signal as a query. Result: IoU improved from 63.94% to 76.91%.
+
+**Q: How does the attention gate work mathematically?**
+Given encoder feature `x` and decoder signal `g`:
+```
+attention = sigmoid(W_x(x) + W_g(g) + b)
+output = x * attention
+```
+The sigmoid produces values 0–1 per pixel. Multiplying by the encoder feature selectively passes only relevant spatial information to the decoder.
+
+**Q: Why 512×512 input size?**
+Balance between spatial resolution and memory. UNet memory scales quadratically with input size due to skip connections storing intermediate feature maps. 512×512 gives sufficient detail for flood boundary detection while fitting in GPU/CPU memory.
+
+**Q: What loss function did you use and why?**
+Combined BCE + Dice loss:
+- **Binary Cross-Entropy (BCE)**: pixel-level classification loss, handles each pixel independently
+- **Dice Loss**: `1 - (2×intersection)/(sum+sum)` — directly optimises the overlap metric, handles class imbalance (flooded pixels are often a minority in the image)
+- Combined: `L = BCE + Dice` — BCE provides stable gradients early in training, Dice refines the boundary
+
+**Q: What is IoU and how is it calculated?**
+Intersection over Union (Jaccard Index):
+```
+IoU = |Predicted ∩ Ground Truth| / |Predicted ∪ Ground Truth|
+```
+Ranges 0–1. Measures overlap between predicted and actual flood regions. More robust than accuracy for imbalanced segmentation tasks.
+
+---
+
+### Explainability
+
+**Q: What is Grad-CAM and why did you use it?**
+Gradient-weighted Class Activation Mapping. It computes the gradient of the output with respect to the feature maps of a target convolutional layer, then takes a weighted sum of those feature maps. The result is a spatial heatmap showing which image regions most influenced the prediction.
+
+Used because: (1) native to CNNs, (2) computationally cheap — one forward + one backward pass, (3) produces spatial maps that directly overlay on the image, (4) no model modification needed.
+
+**Q: Which layer did you target for Grad-CAM and why?**
+`conv2d_130` — the last convolutional layer before the output head. This layer has the best trade-off: it has learned high-level semantic features (water texture, flood patterns) while still retaining spatial resolution sufficient for meaningful visualisation.
+
+**Q: Why JET colormap for Grad-CAM?**
+JET (blue→cyan→green→yellow→red) is intuitive: red = high attention (model is confident about flooding here), blue = low attention. It matches the mental model of "heat" = importance.
+
+---
+
+### Depth Estimation
+
+**Q: What is ZoeDepth and how does it work?**
+ZoeDepth (Zero-shot Depth Estimation) is a monocular depth estimation model from Intel. It uses a DPT (Dense Prediction Transformer) backbone pretrained on large datasets, then fine-tuned for metric depth. It takes a single RGB image and outputs a per-pixel depth map in metres — no stereo cameras or LiDAR needed.
+
+**Q: Why use ZoeDepth instead of a simpler depth estimate?**
+Rule-based depth estimates (e.g., "flood coverage × constant") are not spatially aware. ZoeDepth provides actual per-pixel depth variation — a flood scene may have shallow water at the edges and deep water in the centre. This spatial depth information makes the risk assessment more accurate.
+
+**Q: ZoeDepth outputs relative depth — how do you convert to metres?**
+ZoeDepth's `Intel/zoedepth-nyu` model outputs relative disparity values. We normalise to [0,1] then map to [0, 3m] — a realistic maximum flood depth for the scenarios in our training data. The depth is only computed within flooded pixels (masked by the UNet output).
+
+---
+
+### Risk Assessment
+
+**Q: How is the risk level determined?**
+Two signals combined:
+1. **Flood coverage %** — what fraction of the image is flooded
+2. **Average depth (m)** — mean ZoeDepth value within flooded pixels
+
+```
+level = max(level_from_pct(flood_pct), level_from_depth(avg_depth_m))
+score = flood_pct × 0.7 + depth_score × 0.3
+```
+
+Thresholds: Low (<15%, <0.3m) → Moderate (15–35%, 0.3–0.8m) → High (35–60%, 0.8–1.5m) → Critical (>60%, >1.5m)
+
+**Q: Why does depth only contribute when flood_pct ≥ 2%?**
+Below 2% coverage, the flooded pixels are likely noise or false positives. Using depth on noise pixels would produce meaningless depth values that could incorrectly escalate the risk level.
+
+---
+
+### OOD Detection
+
+**Q: What is out-of-distribution (OOD) detection and why is it needed?**
+The model was trained only on flood/water imagery. When given a completely different image (car, building, portrait), the model produces garbage predictions — it has never seen these inputs during training. OOD detection identifies such inputs and suppresses the results rather than showing false flood detections.
+
+**Q: How does your OOD detection work?**
+Four signals:
+1. **Brightness gate** — rejects pitch-black (<15) or overexposed (>240) images
+2. **Spatial coherence** — real flood masks are large connected blobs; OOD produces >50 fragmented disconnected regions with the largest blob <25% of total flood pixels
+3. **Coverage cap** — >90% flood coverage is physically implausible
+4. **Colour-coverage cross-check** — if flood coverage >40% but <15% of pixels have water-like colours (blue hue 100–130°, grey low-saturation, brown 8–22°) → OOD
+
+**Q: Why not use a separate classifier for OOD?**
+A separate classifier would require additional training data and labels. Our heuristic approach is training-free, interpretable, and works well for the specific failure modes of this model (non-water textures being misclassified as flood).
+
+---
+
+### Deployment
+
+**Q: Why FastAPI for the backend?**
+FastAPI is async, type-safe (Pydantic models), auto-generates OpenAPI docs, and has excellent performance. The Pydantic response models also prevent schema issues with Gradio's API introspection.
+
+**Q: Why Gradio for the frontend?**
+Gradio is purpose-built for ML demos, integrates directly with Python functions (no JavaScript needed), and deploys natively to Hugging Face Spaces with zero configuration.
+
+**Q: What is the PKL file and what does it store?**
+The `.pkl` file stores metadata only — not the model weights. Contents: threshold (0.5), Grad-CAM target layer name (conv2d_130), risk thresholds, model performance metrics, and custom object keys. The actual weights are in the `.keras` file.
+
+**Q: How would you scale this to production?**
+- Replace CPU inference with GPU (CUDA) for 10–50× speedup
+- Add a message queue (Redis/Celery) for async processing of multiple requests
+- Cache ZoeDepth results for similar images
+- Add authentication to the API
+- Deploy on Kubernetes with horizontal scaling
+- Add monitoring (Prometheus/Grafana) for inference latency and error rates
+
+---
+
+## 📦 Dependencies
+
+| Package | Purpose |
+|---------|---------|
+| `tensorflow-cpu` | Attention UNet inference |
+| `torch` | ZoeDepth (PyTorch model) |
+| `transformers` | ZoeDepth pipeline from HuggingFace |
+| `opencv-python-headless` | Image processing, Grad-CAM, colormaps |
+| `gradio` | Frontend UI |
+| `fastapi` + `uvicorn` | REST API backend |
+| `Pillow` | Image loading/conversion |
+| `numpy` | Array operations |

app.py

@@ -0,0 +1,364 @@
+"""
+Gradio frontend — Flood Detection + ZoeDepth depth estimation.
+Improved UI: dark theme, styled cards, progress steps, metric badges.
+"""
+import gradio as gr
+import numpy as np
+from PIL import Image
+import sys, os
+
+sys.path.insert(0, os.path.dirname(__file__))
+from app.model_utils import run_pipeline
+
+# ── Risk config ────────────────────────────────────────────────────────────────
+RISK_CFG = {
+    "Low":      {"colour": "#27ae60", "bg": "#eafaf1", "icon": "🟢", "bar": 20},
+    "Moderate": {"colour": "#f39c12", "bg": "#fef9e7", "icon": "🟡", "bar": 50},
+    "High":     {"colour": "#e67e22", "bg": "#fdf2e9", "icon": "🟠", "bar": 75},
+    "Critical": {"colour": "#e74c3c", "bg": "#fdedec", "icon": "🔴", "bar": 100},
+}
+
+CSS = """
+/* ── page ── */
+body, .gradio-container { background: #0f1117 !important; color: #e8eaf0 !important; }
+
+/* ── header band ── */
+#header-band {
+    background: linear-gradient(135deg, #0d47a1 0%, #1565c0 40%, #0277bd 100%);
+    border-radius: 16px; padding: 28px 32px 20px; margin-bottom: 20px;
+    box-shadow: 0 4px 24px rgba(0,0,0,0.5);
+}
+#header-band h1 { color: #fff; font-size: 2em; margin: 0 0 6px; }
+#header-band p  { color: #bbdefb; margin: 0; font-size: 0.97em; }
+
+/* ── metric pill row ── */
+.metric-pill {
+    display: inline-block; background: rgba(255,255,255,0.08);
+    border: 1px solid rgba(255,255,255,0.18); border-radius: 20px;
+    padding: 4px 14px; margin: 4px; font-size: 0.88em; color: #e3f2fd;
+}
+.metric-pill strong { color: #64b5f6; }
+
+/* ── upload + button panel ── */
+#left-panel { background: #1a1d27; border-radius: 14px; padding: 16px; }
+
+/* ── analyse button ── */
+#analyse-btn {
+    background: linear-gradient(90deg, #1565c0, #0277bd) !important;
+    color: #fff !important; border: none !important;
+    border-radius: 10px !important; font-size: 1.05em !important;
+    padding: 12px !important; margin-top: 10px !important;
+    box-shadow: 0 3px 12px rgba(2,119,189,0.45) !important;
+    transition: transform .15s, box-shadow .15s !important;
+}
+#analyse-btn:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 6px 20px rgba(2,119,189,0.6) !important;
+}
+
+/* ── section labels ── */
+.section-label {
+    font-size: 0.78em; font-weight: 700; letter-spacing: .08em;
+    text-transform: uppercase; color: #64b5f6; margin: 18px 0 6px;
+}
+
+/* ── image cards ── */
+.image-card { background: #1a1d27 !important; border-radius: 12px !important;
+              border: 1px solid #2a2d3a !important; overflow: hidden; }
+
+/* ── risk card ── */
+#risk-card { border-radius: 14px; overflow: hidden; }
+
+/* ── how-it-works table ── */
+.how-table { width:100%; border-collapse:collapse; font-size:0.9em; }
+.how-table th { background:#1565c0; color:#fff; padding:8px 12px; text-align:left; }
+.how-table td { padding:8px 12px; border-bottom:1px solid #2a2d3a; color:#cfd8dc; }
+.how-table tr:last-child td { border-bottom: none; }
+"""
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+def _score_bar(score: float, colour: str) -> str:
+    """Animated CSS progress bar."""
+    return f"""
+    <div style="background:#2a2d3a; border-radius:8px; height:10px; margin:8px 0 14px; overflow:hidden;">
+      <div style="width:{score}%; background:linear-gradient(90deg,{colour}99,{colour});
+                  height:100%; border-radius:8px;
+                  transition: width 1s ease;"></div>
+    </div>"""
+
+def _stat_row(icon, label, value, colour) -> str:
+    return f"""
+    <div style="display:flex; justify-content:space-between; align-items:center;
+                padding:7px 0; border-bottom:1px solid rgba(255,255,255,0.07);">
+      <span style="color:#90a4ae;">{icon} {label}</span>
+      <span style="font-weight:700; color:{colour};">{value}</span>
+    </div>"""
+
+def build_risk_html(risk: dict, depth_info: dict) -> str:
+    level  = risk["risk_level"]
+    cfg    = RISK_CFG.get(level, RISK_CFG["Low"])
+    c      = cfg["colour"]
+    score  = risk["risk_score"]
+    conf   = risk.get("confidence", 100)
+    warning = risk.get("warning", "")
+
+    # ── Out-of-domain warning banner ──────────────────────────────────────────
+    warning_html = ""
+    if warning:
+        warning_html = f"""
+        <div style="background:#7f1d1d; border:1px solid #ef4444; border-radius:8px;
+                    padding:10px 14px; margin-bottom:14px; font-size:0.9em; color:#fca5a5;">
+          {warning}
+        </div>"""
+
+    recs_html = "".join(
+        f'<li style="margin:5px 0; color:#cfd8dc;">{r}</li>'
+        for r in risk["recommendations"]
+    )
+
+    metrics = risk.get("model_metrics", {})
+    metrics_html = ""
+    if metrics:
+        pills = "".join(
+            f'<span class="metric-pill">{k}: <strong>{v}</strong></span>'
+            for k, v in metrics.items() if k != "Model"
+        )
+        metrics_html = f"""
+        <div style="margin-top:14px; padding-top:12px;
+                    border-top:1px solid rgba(255,255,255,0.1);">
+          <div style="font-size:0.78em; text-transform:uppercase; letter-spacing:.08em;
+                      color:#64b5f6; margin-bottom:6px;">📊 Model Performance</div>
+          {pills}
+        </div>"""
+
+    return f"""
+    <div id="risk-card" style="background:linear-gradient(160deg,#1a1d27 60%,{c}18);
+         border:2px solid {c}; border-radius:14px; padding:20px; font-family:sans-serif;">
+
+      {warning_html}
+
+      <!-- header -->
+      <div style="display:flex; align-items:center; gap:12px; margin-bottom:4px;">
+        <span style="font-size:2.2em;">{cfg['icon']}</span>
+        <div>
+          <div style="font-size:0.75em; text-transform:uppercase; letter-spacing:.1em;
+                      color:{c}; font-weight:700;">Risk Level</div>
+          <div style="font-size:1.9em; font-weight:800; color:{c}; line-height:1.1;">
+            {level}
+          </div>
+        </div>
+        <div style="margin-left:auto; text-align:right;">
+          <div style="font-size:2.4em; font-weight:900; color:{c};">{score}</div>
+          <div style="font-size:0.75em; color:#78909c;">/ 100</div>
+        </div>
+      </div>
+
+      {_score_bar(score, c)}
+
+      <!-- confidence row -->
+      <div style="display:flex; justify-content:space-between; align-items:center;
+                  padding:5px 0 10px; border-bottom:1px solid rgba(255,255,255,0.07);">
+        <span style="color:#90a4ae; font-size:0.88em;">🎯 Model Confidence</span>
+        <span style="font-weight:700; color:{'#27ae60' if conf >= 50 else '#e74c3c'};">
+          {conf}%
+        </span>
+      </div>
+
+      <!-- stats grid -->
+      {_stat_row("🌊", "Flood Coverage",   f"{risk['flood_pct']}%",              c)}
+      {_stat_row("📏", "Avg Flood Depth",  f"{risk['avg_depth_m']} m",           c)}
+      {_stat_row("📐", "Max Flood Depth",  f"{depth_info['max_depth_m']} m",     c)}
+      {_stat_row("🔵", "Depth Category",   depth_info['depth_category'],         c)}
+
+      <!-- recommendations -->
+      <div style="margin-top:14px; padding-top:12px;
+                  border-top:1px solid rgba(255,255,255,0.1);">
+        <div style="font-size:0.78em; text-transform:uppercase; letter-spacing:.08em;
+                    color:#64b5f6; margin-bottom:8px;">📋 Recommendations</div>
+        <ul style="margin:0; padding-left:18px; line-height:1.7;">
+          {recs_html}
+        </ul>
+      </div>
+
+      {metrics_html}
+    </div>"""
+
+
+# ── inference ─────────────────────────────────────────────────────────────────
+def predict(image: Image.Image):
+    if image is None:
+        placeholder = """
+        <div style="background:#1a1d27; border:2px dashed #2a2d3a; border-radius:14px;
+                    padding:40px; text-align:center; color:#546e7a; font-family:sans-serif;">
+          <div style="font-size:2.5em; margin-bottom:10px;">🌊</div>
+          <div style="font-size:1.1em;">Upload an image and click <strong>Analyse</strong></div>
+          <div style="font-size:0.85em; margin-top:6px; color:#37474f;">
+            Supports satellite, aerial, or ground-level flood images
+          </div>
+        </div>"""
+        return None, None, None, None, None, placeholder
+
+    result     = run_pipeline(image)
+    risk       = result["risk"]
+    depth_info = result["depth_info"]
+
+    overlay     = Image.fromarray(result["overlay"])
+    gradcam     = Image.fromarray(result["gradcam"])
+    depth_map   = Image.fromarray(result["depth_map"])
+    depth_flood = Image.fromarray(result["depth_overlay"])
+
+    # B&W mask: white = flooded, black = dry — clean and crisp
+    mask_bw = Image.fromarray((result["mask"] * 255).astype(np.uint8), mode="L")
+
+    risk_html = build_risk_html(risk, depth_info)
+    return overlay, mask_bw, gradcam, depth_map, depth_flood, risk_html
+
+
+# ── UI layout ─────────────────────────────────────────────────────────────────
+with gr.Blocks(title="🌊 Flood Detection AI", theme=gr.themes.Soft()) as demo:
+
+    # ── Header ──────────────────────────────────────────────────────────────
+    gr.HTML("""
+    <div id="header-band">
+      <h1>🌊 Flood Detection &amp; Risk Assessment</h1>
+      <p>
+        Attention UNet segmentation &nbsp;·&nbsp; Grad-CAM explainability
+        &nbsp;·&nbsp; ZoeDepth metric depth &nbsp;·&nbsp; AI-powered risk scoring
+      </p>
+      <div style="margin-top:12px;">
+        <span class="metric-pill">IoU <strong>76.91%</strong></span>
+        <span class="metric-pill">Dice/F1 <strong>86.95%</strong></span>
+        <span class="metric-pill">Pixel Acc <strong>89.36%</strong></span>
+        <span class="metric-pill">Precision <strong>85.41%</strong></span>
+        <span class="metric-pill">Recall <strong>88.54%</strong></span>
+      </div>
+    </div>
+    """)
+
+    # ── Main row: upload + risk card ────────────────────────────────────────
+    with gr.Row(equal_height=False):
+
+        with gr.Column(scale=4, elem_id="left-panel"):
+            gr.HTML('<div class="section-label">📷 Input Image</div>')
+            input_image = gr.Image(
+                type="pil",
+                label="",
+                elem_classes=["image-card"],
+                show_label=False,
+            )
+            run_btn = gr.Button(
+                "🔍  Analyse Flood Risk",
+                variant="primary",
+                elem_id="analyse-btn",
+            )
+            gr.HTML("""
+            <div style="margin-top:12px; padding:10px 14px; background:#12151f;
+                        border-radius:10px; border-left:3px solid #1565c0;">
+              <div style="font-size:0.78em; color:#64b5f6; font-weight:700;
+                          text-transform:uppercase; letter-spacing:.07em; margin-bottom:6px;">
+                Pipeline Steps
+              </div>
+              <div style="font-size:0.85em; color:#90a4ae; line-height:2;">
+                1️⃣ &nbsp;Preprocess → 512×512 RGB, normalise<br>
+                2️⃣ &nbsp;Attention UNet → binary flood mask<br>
+                3️⃣ &nbsp;Grad-CAM → attention heatmap<br>
+                4️⃣ &nbsp;ZoeDepth → per-pixel depth (metres)<br>
+                5️⃣ &nbsp;Risk engine → level + score + advice
+              </div>
+            </div>
+            """)
+
+        with gr.Column(scale=6):
+            gr.HTML('<div class="section-label">⚠️ Risk Assessment</div>')
+            risk_display = gr.HTML(
+                value="""
+                <div style="background:#1a1d27; border:2px dashed #2a2d3a;
+                            border-radius:14px; padding:40px; text-align:center;
+                            color:#546e7a; font-family:sans-serif;">
+                  <div style="font-size:2.5em; margin-bottom:10px;">🌊</div>
+                  <div style="font-size:1.1em;">
+                    Upload an image and click <strong>Analyse</strong>
+                  </div>
+                </div>"""
+            )
+
+    # ── Visual outputs ───────────────────────────────────────────────────────
+    gr.HTML('<div class="section-label">🗺️ Segmentation &amp; Explainability</div>')
+    with gr.Row():
+        overlay_out = gr.Image(
+            label="🔵 Flood Mask Overlay",
+            elem_classes=["image-card"],
+        )
+        mask_bw_out = gr.Image(
+            label="⬜ Binary Flood Mask (White = Flooded)",
+            elem_classes=["image-card"],
+            image_mode="L",
+        )
+        gradcam_out = gr.Image(
+            label="🔥 Grad-CAM (TURBO)",
+            elem_classes=["image-card"],
+        )
+
+    gr.HTML('<div class="section-label">📏 ZoeDepth Estimation</div>')
+    with gr.Row():
+        depth_map_out = gr.Image(
+            label="🌈 Full Depth Map (PLASMA)",
+            elem_classes=["image-card"],
+        )
+        depth_flood_out = gr.Image(
+            label="🌊 Flood-Region Depth",
+            elem_classes=["image-card"],
+        )
+
+    # ── How it works ─────────────────────────────────────────────────────────
+    with gr.Accordion("⚙️  How it works", open=False):
+        gr.HTML("""
+        <table class="how-table">
+          <tr>
+            <th>Step</th><th>Component</th><th>What it does</th>
+          </tr>
+          <tr>
+            <td>1</td>
+            <td><strong>Preprocessing</strong></td>
+            <td>Resize to 512×512, convert to RGB, normalise to [0,1]</td>
+          </tr>
+          <tr>
+            <td>2</td>
+            <td><strong>Attention UNet</strong></td>
+            <td>Predicts binary flood mask — attention gates suppress irrelevant features</td>
+          </tr>
+          <tr>
+            <td>3</td>
+            <td><strong>Grad-CAM</strong></td>
+            <td>Gradient-weighted class activation map at conv2d_130 — TURBO colormap with contour</td>
+          </tr>
+          <tr>
+            <td>4</td>
+            <td><strong>ZoeDepth (Intel/zoedepth-nyu)</strong></td>
+            <td>Monocular metric depth estimation — outputs depth in metres per pixel</td>
+          </tr>
+          <tr>
+            <td>5</td>
+            <td><strong>Risk Engine</strong></td>
+            <td>Combines flood coverage % + avg depth → Low / Moderate / High / Critical</td>
+          </tr>
+        </table>
+        <div style="margin-top:14px; padding:12px 16px; background:#12151f;
+                    border-radius:10px; font-size:0.88em; color:#90a4ae;">
+          <strong style="color:#64b5f6;">Risk thresholds:</strong>
+          &nbsp; 🟢 Low (&lt;15% flood, &lt;0.8m)
+          &nbsp; 🟡 Moderate (15–35%, 0.8–1.5m)
+          &nbsp; 🟠 High (35–60%, 1.5–2.2m)
+          &nbsp; 🔴 Critical (&gt;60% or &gt;2.2m)
+        </div>
+        """)
+
+    # ── Wire up ───────────────────────────────────────────────────────────────
+    run_btn.click(
+        fn=predict,
+        inputs=[input_image],
+        outputs=[overlay_out, mask_bw_out, gradcam_out, depth_map_out, depth_flood_out, risk_display],
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, css=CSS)

app/__init__.py

@@ -0,0 +1,6 @@
+"""
+FastAPI backend for Flood Detection + ZoeDepth.
+Endpoints:
+  POST /predict   — full pipeline (mask + gradcam + depth + risk)
+  GET  /health    — liveness check
+"""

app/main.py

@@ -0,0 +1,105 @@
+"""
+FastAPI backend for Flood Detection + ZoeDepth.
+Endpoints:
+  POST /predict   — full pipeline (mask + gradcam + depth + risk)
+  GET  /health    — liveness check
+"""
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+import numpy as np
+from PIL import Image
+import io
+import base64
+import uvicorn
+
+from app.model_utils import run_pipeline
+
+app = FastAPI(
+    title="Flood Detection API",
+    description="Attention UNet + ZoeDepth flood segmentation with Grad-CAM and risk assessment.",
+    version="2.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ── Response models ────────────────────────────────────────────────────────────
+class DepthInfo(BaseModel):
+    avg_depth_m:    float
+    max_depth_m:    float
+    depth_category: str
+
+class RiskResult(BaseModel):
+    risk_level:      str
+    risk_score:      float
+    colour:          str
+    flood_pct:       float
+    avg_depth_m:     float
+    recommendations: List[str]
+    model_metrics:   Optional[dict] = None
+
+class PredictResponse(BaseModel):
+    mask_b64:         str
+    overlay_b64:      str
+    gradcam_b64:      str
+    depth_map_b64:    str
+    depth_flood_b64:  str
+    depth_info:       DepthInfo
+    risk:             RiskResult
+
+
+def _ndarray_to_b64(arr: np.ndarray) -> str:
+    img = Image.fromarray(arr.astype(np.uint8))
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode("utf-8")
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.post("/predict", response_model=PredictResponse)
+async def predict(file: UploadFile = File(...)):
+    if not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image.")
+
+    try:
+        contents = await file.read()
+        image    = Image.open(io.BytesIO(contents))
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Cannot read image: {e}")
+
+    try:
+        result = run_pipeline(image)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Inference error: {e}")
+
+    mask_uint8  = (result["mask"] * 255).astype(np.uint8)
+    depth_info  = result["depth_info"]
+
+    return PredictResponse(
+        mask_b64        = _ndarray_to_b64(mask_uint8),
+        overlay_b64     = _ndarray_to_b64(result["overlay"]),
+        gradcam_b64     = _ndarray_to_b64(result["gradcam"]),
+        depth_map_b64   = _ndarray_to_b64(result["depth_map"]),
+        depth_flood_b64 = _ndarray_to_b64(result["depth_overlay"]),
+        depth_info      = DepthInfo(
+            avg_depth_m    = depth_info["avg_depth_m"],
+            max_depth_m    = depth_info["max_depth_m"],
+            depth_category = depth_info["depth_category"],
+        ),
+        risk = RiskResult(**result["risk"]),
+    )
+
+
+if __name__ == "__main__":
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=False)

app/model_utils.py

@@ -0,0 +1,501 @@
+"""
+model_utils.py — loads the .pkl metadata + .keras model and exposes inference helpers.
+ZoeDepth is loaded from HuggingFace Hub (CPU) for flood depth estimation.
+
+PKL structure (from flood_model_production.pkl):
+  model_name, model_keras_path, input_shape, output_shape, threshold,
+  preprocessing, gradcam_layer, metrics, risk_thresholds, custom_objects_keys
+"""
+import os
+import pickle
+import numpy as np
+import cv2
+import tensorflow as tf
+from PIL import Image
+import torch
+
+# ── HuggingFace token (set via env var — never hardcode in production) ─────────
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+
+# ── Custom Keras objects ───────────────────────────────────────────────────────
+def iou_metric(y_true, y_pred):
+    y_pred = tf.cast(y_pred > 0.5, tf.float32)
+    intersection = tf.reduce_sum(y_true * y_pred)
+    union = tf.reduce_sum(y_true) + tf.reduce_sum(y_pred) - intersection
+    return intersection / (union + 1e-7)
+
+def dice_loss(y_true, y_pred, smooth=1e-7):
+    intersection = tf.reduce_sum(y_true * y_pred)
+    return 1.0 - (2.0 * intersection + smooth) / (
+        tf.reduce_sum(y_true) + tf.reduce_sum(y_pred) + smooth
+    )
+
+def bce_dice_loss(y_true, y_pred):
+    bce  = tf.keras.losses.binary_crossentropy(y_true, y_pred)
+    dice = dice_loss(y_true, y_pred)
+    return bce + dice
+
+CUSTOM_OBJECTS = {
+    "iou_metric":    iou_metric,
+    "dice_loss":     dice_loss,
+    "bce_dice_loss": bce_dice_loss,
+}
+
+IMAGE_SIZE = (512, 512)
+
+# ── Singletons ─────────────────────────────────────────────────────────────────
+_seg_model  = None   # Attention UNet (TF/Keras)
+_zoe_model  = None   # ZoeDepth (PyTorch, CPU)
+_metadata   = None   # dict from pkl
+
+
+# ── Metadata ───────────────────────────────────────────────────────────────────
+def _load_metadata() -> dict:
+    global _metadata
+    if _metadata is not None:
+        return _metadata
+    pkl_path = os.environ.get("MODEL_PKL", "models/flood_model_production.pkl")
+    if os.path.exists(pkl_path):
+        with open(pkl_path, "rb") as f:
+            _metadata = pickle.load(f)
+    else:
+        _metadata = {}
+    return _metadata
+
+
+# ── Attention UNet loader ──────────────────────────────────────────────────────
+def load_seg_model():
+    global _seg_model
+    if _seg_model is not None:
+        return _seg_model
+    keras_path = os.environ.get("MODEL_KERAS", "models/flood_best_model_export.keras")
+    if not os.path.exists(keras_path):
+        raise FileNotFoundError(
+            f"Keras model not found at '{keras_path}'. "
+            "Set MODEL_KERAS env var to the correct path."
+        )
+    _seg_model = tf.keras.models.load_model(keras_path, custom_objects=CUSTOM_OBJECTS)
+    return _seg_model
+
+
+# ── ZoeDepth loader (CPU, HF Hub) ─────────────────────────────────────────────
+def load_zoe_model():
+    """
+    Loads ZoeDepth (ZoeD_N) from HuggingFace Hub on CPU.
+    Uses the transformers pipeline for simplicity and reliability.
+    Model: Intel/zoedepth-nyu  (indoor/outdoor depth estimation)
+    """
+    global _zoe_model
+    if _zoe_model is not None:
+        return _zoe_model
+
+    from transformers import pipeline as hf_pipeline
+
+    token = HF_TOKEN or os.environ.get("HF_TOKEN", "")
+
+    print("[ZoeDepth] Loading from HuggingFace Hub (CPU)...")
+    _zoe_model = hf_pipeline(
+        task="depth-estimation",
+        model="Intel/zoedepth-nyu",
+        device="cpu",                  # force CPU
+        token=token if token else None,
+    )
+    print("[ZoeDepth] Loaded OK.")
+    return _zoe_model
+
+
+# ── Preprocessing ──────────────────────────────────────────────────────────────
+def preprocess_image(image: Image.Image) -> np.ndarray:
+    """PIL Image → normalised (1, 512, 512, 3) float32 array."""
+    img = image.convert("RGB").resize(IMAGE_SIZE)
+    arr = np.array(img, dtype=np.float32) / 255.0
+    return np.expand_dims(arr, axis=0)          # (1, H, W, 3)
+
+
+# ── OOD / scene validation ─────────────────────────────────────────────────────
+def _is_flood_scene(image: Image.Image, pred: np.ndarray, threshold: float) -> tuple:
+    """
+    Multi-signal check to detect out-of-distribution (non-flood) images.
+
+    Signals used:
+      1. Colour distribution — flood/water images have blue/grey/brown tones.
+         Non-flood scenes (cars, indoor, etc.) have very different hue distributions.
+      2. Spatial coherence — real flood masks are spatially connected large blobs.
+         OOD masks are fragmented noise scattered across the image.
+      3. Raw flood coverage — if >85% of image is "flooded" it's almost certainly OOD
+         (real floods rarely cover the entire frame uniformly).
+
+    Returns:
+        is_valid : bool  — True if image looks like a flood scene
+        reason   : str   — explanation if invalid
+    """
+    img_rgb = np.array(image.convert("RGB").resize((512, 512)), dtype=np.float32)
+    mask    = (pred > threshold).astype(np.uint8)
+
+    # ── Signal 1: colour check ─────────────────────────────────────────────────
+    # Flood scenes have significant blue/grey channel presence.
+    # Compute mean of blue channel relative to red — water is blue-dominant.
+    r_mean = img_rgb[:, :, 0].mean()
+    g_mean = img_rgb[:, :, 1].mean()
+    b_mean = img_rgb[:, :, 2].mean()
+    brightness = (r_mean + g_mean + b_mean) / 3.0
+
+    # Very dark images (night/indoor) or very bright (overexposed) are suspicious
+    if brightness < 15 or brightness > 240:
+        return False, "Image too dark or too bright for flood analysis"
+
+    # ── Signal 2: spatial coherence of the predicted mask ─────────────────────
+    # Real flood masks = large connected regions. OOD = scattered small blobs.
+    flood_pct = float(mask.mean() * 100)
+
+    if flood_pct > 0.5:   # only check if there's something to check
+        num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(
+            mask, connectivity=8
+        )
+        if num_labels > 1:
+            # Largest component area (excluding background label 0)
+            component_areas = stats[1:, cv2.CC_STAT_AREA]
+            largest_area    = int(component_areas.max())
+            total_flood_px  = int(mask.sum())
+            # Coherence = fraction of flood pixels in the largest blob
+            coherence = largest_area / (total_flood_px + 1e-8)
+
+            # If flood pixels are highly fragmented (coherence < 0.3 AND many components)
+            # it's likely OOD noise
+            if coherence < 0.25 and num_labels > 50:
+                return False, f"Flood mask is fragmented ({num_labels} disconnected regions) — likely not a flood scene"
+
+    # ── Signal 3: implausibly high coverage ───────────────────────────────────
+    if flood_pct > 90:
+        return False, f"Flood coverage {flood_pct:.1f}% is implausibly high — image may not be a flood scene"
+
+    # ── Signal 4: colour-coverage cross-check ─────────────────────────────────
+    # High flood coverage (>40%) on an image that is NOT predominantly
+    # blue/grey/brown (water colours) is suspicious.
+    if flood_pct > 40:
+        # Convert to HSV to check hue distribution
+        img_uint8 = img_rgb.astype(np.uint8)
+        hsv       = cv2.cvtColor(img_uint8, cv2.COLOR_RGB2HSV)
+        hue       = hsv[:, :, 0]   # 0-179 in OpenCV
+        sat       = hsv[:, :, 1]   # 0-255
+
+        # Water/flood hues: blue (100-130), grey (any hue, low sat), brown (10-20)
+        blue_mask  = ((hue >= 100) & (hue <= 130) & (sat > 30))
+        grey_mask  = (sat < 40)
+        brown_mask = ((hue >= 8)  & (hue <= 22)  & (sat > 40))
+        water_px   = float((blue_mask | grey_mask | brown_mask).mean() * 100)
+
+        # If less than 15% of the image has water-like colours but >40% is "flooded"
+        # → almost certainly OOD (car, building, vegetation, etc.)
+        if water_px < 15:
+            return False, (
+                f"High flood coverage ({flood_pct:.1f}%) but only {water_px:.1f}% "
+                "water-like colours detected — image does not appear to be a flood scene"
+            )
+
+    return True, ""
+
+
+# ── Segmentation prediction ────────────────────────────────────────────────────
+def predict_mask(image: Image.Image) -> tuple:
+    """
+    Returns:
+        mask        : (H, W) binary float32 array  (0 or 1)
+        flood_pct   : percentage of image covered by flood (0-100)
+        confidence  : float 0-100 (display percentage)
+        low_conf    : bool, True if OOD detected
+        ood_reason  : str, explanation if OOD
+    """
+    meta      = _load_metadata()
+    threshold = meta.get("threshold", 0.5)
+    model     = load_seg_model()
+    inp       = preprocess_image(image)
+    pred      = model.predict(inp, verbose=0)[0, :, :, 0]   # (H, W)
+
+    # Raw confidence metric (how decisive the predictions are)
+    confidence_raw = float(np.mean(np.abs(pred - 0.5)) * 2)
+
+    # OOD detection using multi-signal heuristics
+    is_valid, ood_reason = _is_flood_scene(image, pred, threshold)
+
+    if not is_valid:
+        mask      = np.zeros_like(pred, dtype=np.float32)
+        flood_pct = 0.0
+        low_conf  = True
+    else:
+        mask      = (pred > threshold).astype(np.float32)
+        flood_pct = float(mask.mean() * 100)
+        low_conf  = False
+
+    confidence_pct = round(confidence_raw * 100, 1)
+    return mask, flood_pct, confidence_pct, low_conf, ood_reason
+
+
+# ── Grad-CAM ───────────────────────────────────────────────────────────────────
+def compute_gradcam(image: Image.Image) -> np.ndarray:
+    """
+    Returns an RGB uint8 heatmap overlaid on the original image.
+    Uses conv2d_130 (from PKL) — the last conv before the output head.
+    """
+    meta         = _load_metadata()
+    model        = load_seg_model()
+    inp          = preprocess_image(image)
+    target_layer = meta.get("gradcam_layer", "conv2d_130")
+
+    layer_names = [l.name for l in model.layers]
+    if target_layer not in layer_names:
+        # fallback to last Conv2D
+        target_layer = None
+        for layer in reversed(model.layers):
+            if isinstance(layer, tf.keras.layers.Conv2D):
+                target_layer = layer.name
+                break
+
+    if target_layer is None:
+        return np.array(image.convert("RGB").resize(IMAGE_SIZE))
+
+    grad_model = tf.keras.models.Model(
+        inputs=model.inputs,
+        outputs=[model.get_layer(target_layer).output, model.output]
+    )
+
+    with tf.GradientTape() as tape:
+        inp_tensor = tf.cast(inp, tf.float32)
+        conv_out, predictions = grad_model(inp_tensor)
+        loss = tf.reduce_mean(predictions)
+
+    grads      = tape.gradient(loss, conv_out)
+    pooled     = tf.reduce_mean(grads, axis=(0, 1, 2))
+    cam        = tf.reduce_sum(conv_out[0] * pooled, axis=-1).numpy()
+    cam        = np.maximum(cam, 0)
+    cam        = cam / (cam.max() + 1e-8)
+
+    # Smooth for the classic soft-blob look (like the reference image)
+    cam_resized = cv2.resize(cam, IMAGE_SIZE)
+    cam_smooth  = cv2.GaussianBlur(cam_resized, (15, 15), 0)
+
+    # JET: blue(low) → cyan → green → yellow → red(high) — exactly the reference
+    heatmap_bgr = cv2.applyColorMap(np.uint8(255 * cam_smooth), cv2.COLORMAP_JET)
+    heatmap_rgb = cv2.cvtColor(heatmap_bgr, cv2.COLOR_BGR2RGB).astype(np.float32)
+
+    # Blend 55% heatmap over original — enough to see the image underneath
+    orig    = np.array(image.convert("RGB").resize(IMAGE_SIZE), dtype=np.float32)
+    blended = (orig * 0.45 + heatmap_rgb * 0.55).clip(0, 255).astype(np.uint8)
+    return blended
+
+
+# ── ZoeDepth flood depth estimation ───────────────────────────────────────────
+def estimate_flood_depth(image: Image.Image, mask: np.ndarray) -> dict:
+    """
+    Runs ZoeDepth on the image, then analyses depth only within flooded pixels.
+
+    Returns a dict with:
+        depth_map_vis  : (H, W, 3) uint8 — colourised depth map
+        depth_overlay  : (H, W, 3) uint8 — depth map masked to flood region
+        avg_depth_m    : float — mean depth in flooded area (metres)
+        max_depth_m    : float — max depth in flooded area (metres)
+        depth_category : str   — shallow / moderate / deep / very deep
+    """
+    zoe = load_zoe_model()
+
+    # ZoeDepth expects a PIL RGB image (any size — it handles resize internally)
+    rgb_img = image.convert("RGB")
+
+    # Run depth estimation
+    depth_result = zoe(rgb_img)
+    depth_pil    = depth_result["depth"]          # PIL Image (grayscale, float-like)
+    depth_arr    = np.array(depth_pil, dtype=np.float32)  # (H, W)
+
+    # Resize depth map to 512×512 to match mask
+    depth_512 = cv2.resize(depth_arr, IMAGE_SIZE, interpolation=cv2.INTER_LINEAR)
+
+    # ── Normalise to [0, 1] relative scale ────────────────────────────────────
+    # ZoeDepth returns relative disparity values (not calibrated metres).
+    # We normalise across the whole image so values are comparable.
+    d_min, d_max = depth_512.min(), depth_512.max()
+    depth_norm   = (depth_512 - d_min) / (d_max - d_min + 1e-8)   # 0→1
+
+    # Map relative depth to an estimated flood depth in metres (0–3 m scale).
+    # Higher relative depth in flooded pixels → deeper water estimate.
+    FLOOD_DEPTH_MAX_M = 3.0
+    depth_metres = depth_norm * FLOOD_DEPTH_MAX_M   # (H, W), values 0–3 m
+
+    # Colourised full depth map (PLASMA colormap)
+    depth_vis = cv2.applyColorMap(np.uint8(255 * depth_norm), cv2.COLORMAP_PLASMA)
+    depth_vis = cv2.cvtColor(depth_vis, cv2.COLOR_BGR2RGB)
+
+    # Depth stats within flooded pixels only
+    flood_mask_bool = mask.astype(bool)
+    flooded_depths  = depth_metres[flood_mask_bool]
+
+    if len(flooded_depths) == 0 or flood_mask_bool.sum() < 50:
+        # Fewer than 50 flooded pixels → treat as no flood
+        avg_depth_m = 0.0
+        max_depth_m = 0.0
+    else:
+        avg_depth_m = float(flooded_depths.mean())
+        max_depth_m = float(flooded_depths.max())
+
+    # Depth category (ZoeDepth outputs relative depth in metres approx)
+    if avg_depth_m < 0.3:
+        depth_category = "Shallow (< 30 cm)"
+    elif avg_depth_m < 0.8:
+        depth_category = "Moderate (30 cm – 80 cm)"
+    elif avg_depth_m < 1.5:
+        depth_category = "Deep (80 cm – 1.5 m)"
+    else:
+        depth_category = "Very Deep (> 1.5 m — life-threatening)"
+
+    # Flood-region depth overlay: blend depth_vis with blue flood mask
+    flood_depth_overlay = depth_vis.copy()
+    # Highlight non-flooded areas in grey
+    grey = np.full_like(depth_vis, 128)
+    flood_depth_overlay[~flood_mask_bool] = grey[~flood_mask_bool]
+
+    return {
+        "depth_map_vis":   depth_vis,           # (H, W, 3) uint8
+        "depth_overlay":   flood_depth_overlay, # (H, W, 3) uint8
+        "avg_depth_m":     round(avg_depth_m, 3),
+        "max_depth_m":     round(max_depth_m, 3),
+        "depth_category":  depth_category,
+    }
+
+
+# ── Risk assessment (uses thresholds from PKL + ZoeDepth depth) ───────────────
+def assess_risk(flood_pct: float, avg_depth_m: float = 0.0) -> dict:
+    """
+    Combined risk from flood coverage % AND average depth from ZoeDepth.
+    Thresholds from PKL:
+      low      : flood_pct < 15  AND avg_depth_m < 0.80
+      medium   : flood_pct < 35  AND avg_depth_m < 1.50
+      high     : flood_pct < 60  AND avg_depth_m < 2.20
+      critical : above all
+    """
+    meta       = _load_metadata()
+    thresholds = meta.get("risk_thresholds", {
+        "low":      {"max_flood_pct": 15,  "max_avg_depth_m": 80},
+        "medium":   {"max_flood_pct": 35,  "max_avg_depth_m": 150},
+        "high":     {"max_flood_pct": 60,  "max_avg_depth_m": 220},
+        "critical": {"above_all": True},
+    })
+
+    # PKL stores depth in cm — convert to metres for comparison
+    low_pct   = thresholds.get("low",    {}).get("max_flood_pct", 15)
+    med_pct   = thresholds.get("medium", {}).get("max_flood_pct", 35)
+    high_pct  = thresholds.get("high",   {}).get("max_flood_pct", 60)
+
+    # Depth thresholds in metres (realistic flood water levels)
+    low_dep  = 0.3    # < 30 cm  → Low
+    med_dep  = 0.8    # < 80 cm  → Moderate
+    high_dep = 1.5    # < 150 cm → High  (> 1.5 m → Critical)
+
+    # Depth only contributes to risk when there is meaningful flood coverage.
+    # If flood_pct < 2%, ignore depth entirely (noise / false positives).
+    effective_depth = avg_depth_m if flood_pct >= 2.0 else 0.0
+
+    def _level_from_pct(p):
+        if p < low_pct:  return 0
+        if p < med_pct:  return 1
+        if p < high_pct: return 2
+        return 3
+
+    def _level_from_dep(d):
+        if d < low_dep:  return 0
+        if d < med_dep:  return 1
+        if d < high_dep: return 2
+        return 3
+
+    level_idx = max(_level_from_pct(flood_pct), _level_from_dep(effective_depth))
+    levels    = ["Low", "Moderate", "High", "Critical"]
+    colours   = ["#2ecc71", "#f39c12", "#e67e22", "#e74c3c"]
+    level     = levels[level_idx]
+    colour    = colours[level_idx]
+
+    # Score: flood coverage drives 70%, depth drives 30%
+    pct_score   = min(flood_pct / 100 * 100, 100)
+    depth_score = min(effective_depth / 3.0 * 100, 100)   # 3 m = max realistic scale
+    score       = round(pct_score * 0.7 + depth_score * 0.3, 1)
+
+    recs_map = {
+        "Low": [
+            "Monitor water levels periodically.",
+            "Ensure drainage channels are clear.",
+            "No immediate evacuation required.",
+        ],
+        "Moderate": [
+            "Alert local emergency services.",
+            "Move valuables to higher ground.",
+            "Prepare emergency kit.",
+            "Monitor weather forecasts closely.",
+        ],
+        "High": [
+            "Initiate partial evacuation of vulnerable populations.",
+            "Deploy flood barriers where possible.",
+            "Activate emergency response teams.",
+            "Avoid flooded roads and areas.",
+        ],
+        "Critical": [
+            "IMMEDIATE EVACUATION REQUIRED.",
+            "Contact emergency services (911 / local disaster hotline).",
+            "Do not attempt to cross flooded areas.",
+            "Seek shelter on highest available ground.",
+            "Follow official evacuation routes only.",
+        ],
+    }
+
+    deployed_metrics = meta.get("metrics", {}).get("deployed", {})
+
+    return {
+        "risk_level":      level,
+        "risk_score":      score,
+        "colour":          colour,
+        "flood_pct":       round(flood_pct, 2),
+        "avg_depth_m":     round(avg_depth_m, 3),
+        "recommendations": recs_map[level],
+        "model_metrics":   deployed_metrics,
+    }
+
+
+# ── Full pipeline ──────────────────────────────────────────────────────────────
+def run_pipeline(image: Image.Image) -> dict:
+    """
+    End-to-end:
+      1. Attention UNet → flood mask (with confidence gate)
+      2. Grad-CAM       → explainability heatmap
+      3. ZoeDepth       → per-pixel depth map, flood depth stats
+      4. Risk assessment → level, score, recommendations
+    """
+    # Step 1 — segmentation + OOD detection
+    mask, flood_pct, confidence, low_conf, ood_reason = predict_mask(image)
+
+    # Step 2 — Grad-CAM
+    gradcam_img = compute_gradcam(image)
+
+    # Step 3 — ZoeDepth depth estimation
+    depth_info = estimate_flood_depth(image, mask)
+
+    # Step 4 — risk
+    risk = assess_risk(flood_pct, avg_depth_m=depth_info["avg_depth_m"])
+
+    # Add OOD info to risk dict for display
+    risk["confidence"] = confidence
+    risk["low_conf"]   = low_conf
+    risk["warning"]    = (
+        f"⚠️ Out-of-distribution image detected: {ood_reason}. "
+        "Results suppressed."
+    ) if low_conf else ""
+
+    # Blue-tinted flood overlay on original
+    orig_arr = np.array(image.convert("RGB").resize(IMAGE_SIZE), dtype=np.uint8)
+    mask_3ch = np.stack([mask * 0, mask * 100, mask * 255], axis=-1).astype(np.uint8)
+    overlay  = cv2.addWeighted(orig_arr, 0.7, mask_3ch, 0.3, 0)
+
+    return {
+        "mask":          mask,
+        "overlay":       overlay,
+        "gradcam":       gradcam_img,
+        "depth_map":     depth_info["depth_map_vis"],
+        "depth_overlay": depth_info["depth_overlay"],
+        "depth_info":    depth_info,
+        "risk":          risk,
+    }

models/flood_best_model_export.keras

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

models/flood_model_production.pkl

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

requirements.txt

@@ -0,0 +1,8 @@
+tensorflow-cpu>=2.16.0
+numpy>=1.24.0
+opencv-python-headless>=4.8.0
+Pillow>=10.0.0
+gradio>=6.0.0
+torch>=2.1.0
+transformers>=4.40.0,<4.50.0
+timm>=0.9.0