Restore union-based detection fusion for higher recall.

Gated fusion was too strict once AdaptFormer loaded, yielding only 1-2 regions.
Revert to AdaptFormer+classical union, looser thresholds, and prior cleanup.

Co-authored-by: Cursor <cursoragent@cursor.com>

Dockerfile

@@ -19,7 +19,7 @@ WORKDIR /app
 
 # Build-time info + cache-bust:
 # Changing APP_BUILD forces Docker to re-run subsequent layers (including pip install).
-ARG APP_BUILD=24
+ARG APP_BUILD=25
 ENV APP_BUILD=${APP_BUILD}
 RUN echo "Docker build start: APP_BUILD=${APP_BUILD}" && python -V
 

app/detection_engine.py

@@ -774,7 +774,8 @@ def _ai_fusion_core(img1, img2, sensitivity=0.5, registration_ok=True):
         img1, img2, registration_ok=registration_ok)
 
     sens = float(np.clip(sensitivity, 0.0, 1.0))
-    q = float(np.clip(0.96 - (sens - 0.5) * 0.04, 0.92, 0.98))
+    # Looser percentile than gated fusion — keeps recall for multi-region detection
+    q = float(np.clip(0.93 - (sens - 0.5) * 0.06, 0.85, 0.96))
     thr_score = float(np.quantile(classical_score, q))
     change_mask = (classical_score >= thr_score).astype(np.uint8) * 255
     change_mask = _clean_mask(change_mask, sensitivity=sens)
@@ -797,39 +798,45 @@ def _ai_fusion_core(img1, img2, sensitivity=0.5, registration_ok=True):
 
 
 def ai_deep_learning_method(img1, img2, sensitivity=0.5, registration_ok=True):
-    """AdaptFormer + confidence-gated classical fusion (no blind union)."""
+    """
+    Dual-engine approach: AdaptFormer for structure + classical fusion for
+    vegetation/texture. Union (not gated AND) maximizes recall.
+    """
     from .model_inference import is_model_available, predict_change_mask
 
-    dl_score = None
+    model_mask = None
     model_ok = False
-    T_dl = 0.40 + (1.0 - float(np.clip(sensitivity, 0, 1))) * 0.25
+    threshold = 0.25 + (1.0 - float(np.clip(sensitivity, 0, 1))) * 0.25
 
     if is_model_available():
         try:
-            _, dl_score = predict_change_mask(img1, img2, threshold=2.0)
-            model_ok = dl_score is not None
+            model_mask, _ = predict_change_mask(img1, img2, threshold=threshold)
+            model_mask = _clean_mask(model_mask, sensitivity=sensitivity)
+            model_ok = model_mask is not None
         except Exception as e:
             _log.warning("AdaptFormer inference failed: %s", e)
 
-    classical_score, _ = _compute_classical_score_map(
-        img1, img2, registration_ok=registration_ok)
+    rule_mask, _, core_debug = _ai_fusion_core(
+        img1, img2, sensitivity=sensitivity, registration_ok=registration_ok)
 
-    if model_ok and dl_score is not None:
-        combined, _, fuse_debug = fuse_dl_and_classical(
-            dl_score, classical_score, img1, img2, sensitivity=sensitivity)
+    if model_ok and model_mask is not None:
+        combined = np.maximum(model_mask, rule_mask)
+        combined = _clean_mask(combined, sensitivity=sensitivity)
         debug = {
-            "method": "AI-Based Deep Learning (AdaptFormer + gated fusion)",
+            "method": "AI-Based Deep Learning (AdaptFormer + rule-based union)",
             "model": "adaptformer-levir-cd",
-            "threshold_used": int(T_dl * 255),
+            "fusion": "union",
+            "threshold_used": int(threshold * 255),
             "sensitivity": float(sensitivity),
-            **fuse_debug,
+            "model_changed_px": int(np.sum(model_mask > 127)),
+            "rule_changed_px": int(np.sum(rule_mask > 127)),
+            "combined_changed_px": int(np.sum(combined > 127)),
         }
         return combined, debug
 
-    rule_mask, _, core_debug = _ai_fusion_core(
-        img1, img2, sensitivity=sensitivity, registration_ok=registration_ok)
     debug = {
         "method": "AI-Based Deep Learning (classical fallback)",
+        "threshold_used": core_debug.get("threshold_used"),
         "sensitivity": float(sensitivity),
         "core": core_debug,
     }
@@ -852,9 +859,9 @@ def hybrid_method(img1, img2, sensitivity=0.5, registration_ok=True):
         0.5 * ai_mask.astype(np.float32)
     )
 
-    base_thr = 110
+    base_thr = 98
     sens = float(np.clip(sensitivity, 0.0, 1.0))
-    hybrid_thr = int(np.clip(base_thr + int((0.5 - sens) * 36), 70, 160))
+    hybrid_thr = int(np.clip(base_thr + int((0.5 - sens) * 36), 60, 150))
     _, final_mask = cv2.threshold(combined.astype(np.uint8), hybrid_thr, 255, cv2.THRESH_BINARY)
     final_mask = _clean_mask(final_mask, sensitivity=sensitivity)
     debug = {
@@ -901,49 +908,73 @@ def _build_confidence_map_from_channels(img1, img2, dl_score=None):
     return build_confidence_map(channels, weights)
 
 
+def _multiscale_classical(img1, img2, sensitivity=0.5, registration_ok=True):
+    """Run classical fusion at multiple scales and OR-combine for better recall."""
+    from .cd_models.model_utils import multiscale_detect
+
+    def _single_scale_detect(s1, s2):
+        mask, _, _ = _ai_fusion_core(
+            s1, s2, sensitivity=sensitivity, registration_ok=registration_ok)
+        return mask
+
+    return multiscale_detect(_single_scale_detect, img1, img2, scales=(1.0, 0.5))
+
+
 def hybrid_ai_method(img1, img2, sensitivity=0.5, registration_ok=True):
-    """Hybrid AI: same confidence-gated fusion as default AI path."""
+    """Hybrid AI: DL mask + multi-scale classical mask with confidence weighting."""
     if img1.shape != img2.shape:
         img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))
 
     from .model_inference import is_model_available, predict_change_mask
 
-    dl_score = None
+    dl_mask = np.zeros(img1.shape[:2], dtype=np.uint8)
+    dl_score = np.zeros(img1.shape[:2], dtype=np.float32)
     dl_method = "none"
+    thr = 0.25 + (1.0 - float(np.clip(sensitivity, 0, 1))) * 0.25
 
     if is_model_available():
         try:
-            _, dl_score = predict_change_mask(img1, img2, threshold=2.0)
+            dl_mask, dl_score = predict_change_mask(img1, img2, threshold=thr)
             dl_method = "adaptformer"
         except Exception:
             pass
 
     if dl_method == "none":
         try:
-            from .cd_models.change_model import has_siamese_weights, predict_siamese
-            if has_siamese_weights():
-                _, dl_score = predict_siamese(img1, img2, threshold=2.0)
+            from .cd_models.change_model import is_siamese_available, predict_siamese
+            if is_siamese_available():
+                dl_mask, dl_score = predict_siamese(img1, img2, threshold=thr)
                 dl_method = "siamese_unet"
         except Exception:
             pass
 
-    classical_score, _ = _compute_classical_score_map(
-        img1, img2, registration_ok=registration_ok)
+    classical_mask = _multiscale_classical(
+        img1, img2, sensitivity=sensitivity, registration_ok=registration_ok)
+    conf_map = _build_confidence_map_from_channels(
+        img1, img2, dl_score=dl_score if dl_method != "none" else None)
 
-    if dl_method != "none" and dl_score is not None:
-        final_mask, _, fuse_debug = fuse_dl_and_classical(
-            dl_score, classical_score, img1, img2, sensitivity=sensitivity)
-        debug = {
-            "method": f"Hybrid AI ({dl_method} + gated fusion)",
-            "dl_method": dl_method,
-            "sensitivity": float(sensitivity),
-            **fuse_debug,
-        }
-        return final_mask, debug
+    dl_w = 0.7 if dl_method != "none" else 0.0
+    cl_w = 1.0 - dl_w
+    fused = dl_w * dl_mask.astype(np.float32) + cl_w * classical_mask.astype(np.float32)
 
-    mask, _, core_debug = _ai_fusion_core(
-        img1, img2, sensitivity=sensitivity, registration_ok=registration_ok)
-    return mask, {"method": "Hybrid AI (classical fallback)", "core": core_debug}
+    if conf_map is not None:
+        conf_boost = np.clip(conf_map * 1.5, 0, 1)
+        fused = fused * (0.6 + 0.4 * conf_boost)
+
+    fused_thr = max(80, int(128 - (sensitivity - 0.5) * 60))
+    _, final_mask = cv2.threshold(fused.astype(np.uint8), fused_thr, 255, cv2.THRESH_BINARY)
+    final_mask = _clean_mask(final_mask, sensitivity=sensitivity)
+
+    debug = {
+        "method": f"Hybrid AI ({dl_method} + multi-scale classical)",
+        "dl_method": dl_method,
+        "threshold_used": fused_thr,
+        "sensitivity": float(sensitivity),
+        "dl_changed_px": int(np.sum(dl_mask > 127)),
+        "classical_changed_px": int(np.sum(classical_mask > 127)),
+        "final_changed_px": int(np.sum(final_mask > 127)),
+    }
+    return final_mask, debug
 
 
 ALIGNMENT_WARNING_MSG = (
@@ -999,7 +1030,7 @@ def _clean_mask(mask, sensitivity=0.5, border_margin=12):
     filled = cv2.dilate(filled, k_break, iterations=1)
 
     # 7. Component-level filtering: remove tiny survivors and elongated noise
-    min_component_px = max(200, int(h * w * 0.00003))
+    min_component_px = max(50, int(h * w * 0.00003))
     num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(filled, connectivity=8)
     clean = np.zeros_like(filled)
     for i in range(1, num_labels):

app/main.py

@@ -70,7 +70,7 @@ except Exception as e:
     import logging
     logging.getLogger("uvicorn.error").warning("Startup migration skipped: %s", e)
 
-app = FastAPI(title="AI Change Detection", version="2.2.1")
+app = FastAPI(title="AI Change Detection", version="2.2.2")
 
 
 @app.get("/health")
@@ -82,7 +82,7 @@ def health():
     model = get_model_status()
     return {
         "status": "ok" if model.get("available") else "degraded",
-        "version": "2.2.1",
+        "version": "2.2.2",
         "server_time_ist": _isoformat_ist(datetime.now(timezone.utc)),
         "adaptFormer": model,
     }

app/model_inference.py

@@ -98,14 +98,14 @@ def preload_model():
 def get_model_status() -> dict:
     """Status for /health — shows whether AI detection or classical fallback is active."""
     if _AVAILABLE is True:
-        mode = "adaptformer_gated_fusion"
+        mode = "adaptformer_union_fusion"
         available = True
     elif _LOAD_FAILED:
         mode = "classical_fallback"
         available = False
     else:
         available = is_model_available()
-        mode = "adaptformer_gated_fusion" if available else "classical_fallback"
+        mode = "adaptformer_union_fusion" if available else "classical_fallback"
 
     return {
         "modelId": _MODEL_ID,