Production overhaul: pre-trained AdaptFormer model + detection quality improvements

Dockerfile

@@ -19,14 +19,21 @@ WORKDIR /app
 
 # Build-time info + cache-bust:
 # Changing APP_BUILD forces Docker to re-run subsequent layers (including pip install).
-ARG APP_BUILD=13
+ARG APP_BUILD=14
 ENV APP_BUILD=${APP_BUILD}
 RUN echo "Docker build start: APP_BUILD=${APP_BUILD}" && python -V
 
 # Install Python dependencies
 COPY requirements.txt .
-RUN pip install --no-cache-dir --disable-pip-version-check --default-timeout=120 -U pip setuptools wheel
-RUN pip install --no-cache-dir --disable-pip-version-check --default-timeout=120 --prefer-binary -r requirements.txt -v
+RUN pip install --no-cache-dir --disable-pip-version-check --default-timeout=300 -U pip setuptools wheel
+RUN pip install --no-cache-dir --disable-pip-version-check --default-timeout=300 --prefer-binary -r requirements.txt -v
+
+# Pre-download the AdaptFormer model so cold starts are instant
+ENV HF_HOME=/app/.hf_cache
+RUN python -c "from transformers import AutoImageProcessor, AutoModel; \
+    AutoImageProcessor.from_pretrained('deepang/adaptformer-LEVIR-CD', cache_dir='/app/.hf_cache'); \
+    AutoModel.from_pretrained('deepang/adaptformer-LEVIR-CD', cache_dir='/app/.hf_cache'); \
+    print('Model pre-downloaded successfully')"
 
 # Copy application code
 COPY . .

app/detection_engine.py

@@ -177,15 +177,18 @@ def compute_vegetation_mask(img):
 
 def compute_combined_vegetation_suppression(img1, img2):
     """
-    Build a suppression map from both images: if EITHER image shows vegetation
-    in a region, dampen it. Returns a float map in [0, 1] where
-    1.0 = no suppression, ~0.3 = heavy suppression (vegetation area).
+    Asymmetric vegetation handling:
+    - Where BOTH images are vegetated: suppress (likely seasonal noise)
+    - Where only ONE image is vegetated: boost (real vegetation change)
+    Returns a float map where 1.0 = neutral, <1 = suppress, >1 = boost.
     """
     veg1 = compute_vegetation_mask(img1)
     veg2 = compute_vegetation_mask(img2)
-    combined_veg = np.maximum(veg1, veg2)
-    suppression = 1.0 - combined_veg * 0.7
-    return suppression.astype(np.float32)
+    both_veg = np.minimum(veg1, veg2)
+    one_only = np.abs(veg1 - veg2)
+    seasonal_suppression = 1.0 - both_veg * 0.7
+    vegetation_boost = 1.0 + one_only * 0.3
+    return (seasonal_suppression * vegetation_boost).astype(np.float32)
 
 
 # ---------------------------------------------------------------------------
@@ -584,24 +587,29 @@ def _ai_fusion_core(img1, img2, sensitivity=0.5):
 
 def ai_deep_learning_method(img1, img2, sensitivity=0.5):
     """
-    Uses the trained Siamese U-Net when available; falls back to the
+    Uses the pre-trained AdaptFormer model when available; falls back to the
     rule-based multi-channel fusion otherwise.
     """
     from .model_inference import is_model_available, predict_change_mask
 
     if is_model_available():
         threshold = 0.35 + (1.0 - sensitivity) * 0.3
-        change_mask, score_map = predict_change_mask(img1, img2, threshold=threshold)
-        change_mask = _clean_mask(change_mask, sensitivity=sensitivity)
-        debug = {
-            "method": "AI-Based Deep Learning (Siamese U-Net)",
-            "model": "siamese_unet",
-            "threshold_used": int(threshold * 255),
-            "sensitivity": float(sensitivity),
-        }
-        return change_mask, debug
+        try:
+            change_mask, score_map = predict_change_mask(
+                img1, img2, threshold=threshold)
+            change_mask = _clean_mask(change_mask, sensitivity=sensitivity)
+            debug = {
+                "method": "AI-Based Deep Learning (AdaptFormer)",
+                "model": "adaptformer-levir-cd",
+                "threshold_used": int(threshold * 255),
+                "sensitivity": float(sensitivity),
+            }
+            return change_mask, debug
+        except Exception as e:
+            import logging
+            logging.getLogger(__name__).warning(
+                "AdaptFormer inference failed, falling back to rule-based: %s", e)
 
-    # Fallback: rule-based fusion
     change_mask, core_debug = _ai_fusion_core(img1, img2, sensitivity=sensitivity)
     debug = {
         "method": "AI-Based Deep Learning (rule-based fallback)",
@@ -723,16 +731,33 @@ def _clean_mask(mask, sensitivity=0.5, border_margin=12):
 
 def _severity_from_region(region, total_pixels):
     """
-    Classify change severity from area and confidence.
-    Green = minor, Yellow = moderate, Red = major.
-    Area is the primary signal; confidence acts as a small bonus.
+    Type-aware severity classification.
+    Building/structural changes use area + confidence.
+    Vegetation changes weight confidence (NDVI delta) more heavily.
     """
     area = region.get("area", 0)
     confidence = region.get("confidence", 0.0)
+    obj_type = region.get("object_type", "")
     if total_pixels <= 0:
         return "minor"
     area_ratio = area / total_pixels
-    # Area-dominant score: area ratio (0-1) mapped to 0-10, confidence adds 0-0.3
+
+    if obj_type in _VEGETATION_TYPES or "Vegetation" in (obj_type or ""):
+        score = area_ratio * 600 + confidence * 0.6
+        if score < 0.8:
+            return "minor"
+        if score < 3.0:
+            return "moderate"
+        return "major"
+
+    if obj_type in _STRUCTURAL_TYPES or obj_type in _BUILDING_TYPES:
+        score = area_ratio * 1200 + confidence * 0.4
+        if score < 1.2:
+            return "minor"
+        if score < 4.5:
+            return "moderate"
+        return "major"
+
     score = area_ratio * 1000 + confidence * 0.3
     if score < 1.0:
         return "minor"
@@ -900,11 +925,91 @@ def _is_transient_object(area, w, h, features):
     return False
 
 
-def classify_object_type(image_region, bbox):
+def _count_line_segments(gray_crop):
+    """Count straight line segments using LSD — buildings have many, vegetation has few."""
+    if gray_crop.size == 0 or gray_crop.shape[0] < 5 or gray_crop.shape[1] < 5:
+        return 0, 0.0
+    lsd = cv2.createLineSegmentDetector(0)
+    lines, _, _, _ = lsd.detect(gray_crop.astype(np.uint8))
+    if lines is None:
+        return 0, 0.0
+    n_lines = len(lines)
+    total_length = sum(
+        np.sqrt((l[0][2] - l[0][0])**2 + (l[0][3] - l[0][1])**2)
+        for l in lines
+    )
+    return n_lines, float(total_length)
+
+
+def _count_corners(gray_crop):
+    """Count strong corners — buildings have clustered grid-like corners."""
+    if gray_crop.size == 0 or gray_crop.shape[0] < 5 or gray_crop.shape[1] < 5:
+        return 0
+    corners = cv2.goodFeaturesToTrack(
+        gray_crop.astype(np.uint8), maxCorners=100,
+        qualityLevel=0.05, minDistance=5)
+    return 0 if corners is None else len(corners)
+
+
+def _rectangular_hull_ratio(gray_crop, threshold=128):
+    """Ratio of non-zero area to bounding rect — buildings fill their box."""
+    if gray_crop.size == 0:
+        return 0.0
+    _, binary = cv2.threshold(gray_crop.astype(np.uint8), threshold, 255, cv2.THRESH_BINARY)
+    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return 0.0
+    biggest = max(contours, key=cv2.contourArea)
+    contour_area = cv2.contourArea(biggest)
+    _, _, rw, rh = cv2.boundingRect(biggest)
+    rect_area = max(rw * rh, 1)
+    return contour_area / rect_area
+
+
+def _extract_differential_features(before_crop, after_crop):
+    """Extract features from BOTH before and after crops plus their deltas."""
+    feat_b = extract_advanced_features(before_crop)
+    feat_a = extract_advanced_features(after_crop)
+    if feat_b is None or feat_a is None:
+        return None
+
+    gray_b = cv2.cvtColor(before_crop, cv2.COLOR_RGB2GRAY)
+    gray_a = cv2.cvtColor(after_crop, cv2.COLOR_RGB2GRAY)
+
+    lines_b, linelen_b = _count_line_segments(gray_b)
+    lines_a, linelen_a = _count_line_segments(gray_a)
+    corners_b = _count_corners(gray_b)
+    corners_a = _count_corners(gray_a)
+    hull_a = _rectangular_hull_ratio(gray_a)
+
+    lab_b = cv2.cvtColor(before_crop, cv2.COLOR_RGB2LAB).astype(np.float32)
+    lab_a = cv2.cvtColor(after_crop, cv2.COLOR_RGB2LAB).astype(np.float32)
+    lab_dist = float(np.mean(np.sqrt(np.sum((lab_a - lab_b) ** 2, axis=2))))
+
+    return {
+        "before": feat_b, "after": feat_a,
+        "delta_ndvi": feat_a["ndvi"] - feat_b["ndvi"],
+        "delta_green_ratio": feat_a["green_ratio"] - feat_b["green_ratio"],
+        "delta_edge_density": feat_a["edge_density"] - feat_b["edge_density"],
+        "delta_brightness": feat_a["brightness"] - feat_b["brightness"],
+        "delta_texture_std": feat_a["texture_std"] - feat_b["texture_std"],
+        "delta_saturation": feat_a["saturation"] - feat_b["saturation"],
+        "delta_orientation_entropy": feat_a["orientation_entropy"] - feat_b["orientation_entropy"],
+        "delta_lines": lines_a - lines_b,
+        "delta_line_length": linelen_a - linelen_b,
+        "delta_corners": corners_a - corners_b,
+        "lines_after": lines_a, "corners_after": corners_a,
+        "lines_before": lines_b, "corners_before": corners_b,
+        "hull_ratio_after": hull_a,
+        "lab_color_distance": lab_dist,
+    }
+
+
+def classify_object_type(image_region, bbox, before_region=None):
     """
-    Classify GROUND-LEVEL structural changes only.
-    Categories: construction, demolition, vegetation, water, road, bare land.
-    Transient objects (people, cars, animals) are filtered out.
+    Classify the type of change in a region.
+    When before_region is provided, uses differential (before vs after) analysis
+    for dramatically better accuracy. Falls back to single-image analysis otherwise.
     """
     x, y, w, h = bbox
     pad = 5
@@ -912,119 +1017,175 @@ def classify_object_type(image_region, bbox):
     y2 = min(image_region.shape[0], y + h + pad)
     x1 = max(0, x - pad)
     x2 = min(image_region.shape[1], x + w + pad)
-    region = image_region[y1:y2, x1:x2]
+    after_crop = image_region[y1:y2, x1:x2]
 
-    if region.size == 0 or region.shape[0] < 3 or region.shape[1] < 3:
+    if after_crop.size == 0 or after_crop.shape[0] < 3 or after_crop.shape[1] < 3:
         return "Unclassified", 0.0
 
-    features = extract_advanced_features(region)
-    if features is None:
+    feat_a = extract_advanced_features(after_crop)
+    if feat_a is None:
         return "Unclassified", 0.0
 
     area = w * h
-
-    # Filter out transient objects (people, cars, animals)
-    if _is_transient_object(area, w, h, features):
-        return None, 0.0  # signal to exclude this region
+    if _is_transient_object(area, w, h, feat_a):
+        return None, 0.0
 
     aspect_ratio = max(w, h) / max(min(w, h), 1)
     compactness = (4 * np.pi * area) / ((2 * (w + h)) ** 2 + 1e-6)
 
+    # --- Differential classification when before image is available ---
+    diff = None
+    if before_region is not None:
+        by1 = max(0, y - pad)
+        by2 = min(before_region.shape[0], y + h + pad)
+        bx1 = max(0, x - pad)
+        bx2 = min(before_region.shape[1], x + w + pad)
+        before_crop = before_region[by1:by2, bx1:bx2]
+        if before_crop.size > 0 and before_crop.shape[0] >= 3 and before_crop.shape[1] >= 3:
+            diff = _extract_differential_features(before_crop, after_crop)
+
     scores = {}
 
     # ---- Water Body Change ----
     water = 0.0
-    if features["blue_ratio"] > 0.36:
+    if feat_a["blue_ratio"] > 0.36:
         water += 0.22
-    if features["texture_std"] < 28:
+    if feat_a["texture_std"] < 28:
         water += 0.18
-    if features["edge_density"] < 35:
+    if feat_a["edge_density"] < 35:
         water += 0.14
-    if 90 <= features["hue"] <= 135:
+    if 90 <= feat_a["hue"] <= 135:
         water += 0.18
-    if features["lbp_variance"] < 0.05:
+    if feat_a["lbp_variance"] < 0.05:
         water += 0.14
-    if features["glcm_contrast"] < 500:
+    if feat_a["glcm_contrast"] < 500:
         water += 0.10
     if area > 800:
         water += 0.04
     scores["Water Body Change"] = water
 
-    # ---- Vegetation Change (deforestation, new growth, crop change) ----
+    # ---- Vegetation Change ----
     veg = 0.0
-    if features["ndvi"] > 0.05:
-        veg += 0.22
-    if features["ndvi"] > 0.15:
-        veg += 0.10
-    if features["green_ratio"] > 0.36:
-        veg += 0.18
-    if 35 <= features["hue"] <= 85:
-        veg += 0.15
-    if features["texture_std"] > 18:
-        veg += 0.08
-    if features["lbp_variance"] > 0.03:
-        veg += 0.08
-    if features["saturation"] > 40:
-        veg += 0.10
-    if features["orientation_entropy"] > 2.5:
-        veg += 0.05
-    if area > 500:
-        veg += 0.04
+    if diff:
+        # Differential: detect actual vegetation gain or loss
+        if abs(diff["delta_ndvi"]) > 0.08:
+            veg += 0.30
+        if abs(diff["delta_green_ratio"]) > 0.04:
+            veg += 0.20
+        if diff["lab_color_distance"] > 15 and (
+                diff["before"]["ndvi"] > 0.05 or diff["after"]["ndvi"] > 0.05):
+            veg += 0.15
+        if abs(diff["delta_saturation"]) > 15 and (
+                diff["before"]["green_ratio"] > 0.34 or diff["after"]["green_ratio"] > 0.34):
+            veg += 0.15
+        if diff["delta_lines"] < 3 and diff["delta_corners"] < 5:
+            veg += 0.08
+        if area > 500:
+            veg += 0.04
+    else:
+        if feat_a["ndvi"] > 0.05:
+            veg += 0.22
+        if feat_a["ndvi"] > 0.15:
+            veg += 0.10
+        if feat_a["green_ratio"] > 0.36:
+            veg += 0.18
+        if 35 <= feat_a["hue"] <= 85:
+            veg += 0.15
+        if feat_a["saturation"] > 40:
+            veg += 0.10
+        if feat_a["orientation_entropy"] > 2.5:
+            veg += 0.05
+        if area > 500:
+            veg += 0.04
     scores["Vegetation Change"] = veg
 
     # ---- New Construction/Building ----
     bld = 0.0
-    if features["orientation_entropy"] < 2.5:
-        bld += 0.18
-    if features["color_homogeneity"] < 28:
-        bld += 0.15
-    if 1.0 <= aspect_ratio <= 4.0:
-        bld += 0.12
-    if 0.3 <= compactness <= 0.9:
-        bld += 0.10
-    if features["edge_density"] > 30:
-        bld += 0.12
-    if features["glcm_contrast"] > 400:
-        bld += 0.10
-    if features["saturation"] < 90:
-        bld += 0.10
-    if 40 <= features["brightness"] <= 90:
-        bld += 0.08
-    if area > 1000:
-        bld += 0.05
+    if diff:
+        if diff["delta_edge_density"] > 15:
+            bld += 0.20
+        if diff["delta_orientation_entropy"] < -0.4:
+            bld += 0.15
+        if diff["delta_lines"] > 5:
+            bld += 0.15
+        if diff["delta_corners"] > 8:
+            bld += 0.12
+        if diff["after"]["ndvi"] < 0.05 and diff["before"]["ndvi"] > 0.03:
+            bld += 0.12
+        if diff["hull_ratio_after"] > 0.55:
+            bld += 0.10
+        if 1.0 <= aspect_ratio <= 4.0:
+            bld += 0.08
+        if area > 1000:
+            bld += 0.05
+    else:
+        if feat_a["orientation_entropy"] < 2.5:
+            bld += 0.18
+        if feat_a["color_homogeneity"] < 28:
+            bld += 0.15
+        if 1.0 <= aspect_ratio <= 4.0:
+            bld += 0.12
+        if 0.3 <= compactness <= 0.9:
+            bld += 0.10
+        if feat_a["edge_density"] > 30:
+            bld += 0.12
+        if feat_a["glcm_contrast"] > 400:
+            bld += 0.10
+        if feat_a["saturation"] < 90:
+            bld += 0.10
+        if 40 <= feat_a["brightness"] <= 90:
+            bld += 0.08
+        if area > 1000:
+            bld += 0.05
     scores["New Construction/Building"] = bld
 
     # ---- Demolition/Clearing ----
     demo = 0.0
-    if features["texture_std"] > 30:
-        demo += 0.18
-    if features["orientation_entropy"] > 2.8:
-        demo += 0.15
-    if features["color_homogeneity"] > 25:
-        demo += 0.15
-    if features["brightness"] > 60:
-        demo += 0.10
-    if features["ndvi"] < 0.05:
-        demo += 0.12
-    if features["saturation"] < 70:
-        demo += 0.10
-    if area > 800:
-        demo += 0.05
+    if diff:
+        if diff["delta_edge_density"] < -15:
+            demo += 0.22
+        if diff["delta_lines"] < -5:
+            demo += 0.18
+        if diff["delta_corners"] < -8:
+            demo += 0.15
+        if diff["delta_texture_std"] > 8:
+            demo += 0.12
+        if diff["delta_brightness"] > 10:
+            demo += 0.12
+        if diff["after"]["ndvi"] > 0.03 and diff["before"]["ndvi"] < 0.02:
+            demo += 0.08
+        if area > 800:
+            demo += 0.05
+    else:
+        if feat_a["texture_std"] > 30:
+            demo += 0.18
+        if feat_a["orientation_entropy"] > 2.8:
+            demo += 0.15
+        if feat_a["color_homogeneity"] > 25:
+            demo += 0.15
+        if feat_a["brightness"] > 60:
+            demo += 0.10
+        if feat_a["ndvi"] < 0.05:
+            demo += 0.12
+        if feat_a["saturation"] < 70:
+            demo += 0.10
+        if area > 800:
+            demo += 0.05
     scores["Demolition/Clearing"] = demo
 
     # ---- Road/Pavement Change ----
     road = 0.0
     if aspect_ratio > 2.5:
         road += 0.22
-    if features["color_homogeneity"] < 22:
+    if feat_a["color_homogeneity"] < 22:
         road += 0.18
-    if features["texture_std"] < 32:
+    if feat_a["texture_std"] < 32:
         road += 0.15
-    if features["saturation"] < 65:
+    if feat_a["saturation"] < 65:
         road += 0.12
-    if features["orientation_entropy"] < 2.0:
+    if feat_a["orientation_entropy"] < 2.0:
         road += 0.15
-    if 35 <= features["brightness"] <= 75:
+    if 35 <= feat_a["brightness"] <= 75:
         road += 0.10
     if compactness < 0.3:
         road += 0.05
@@ -1034,24 +1195,22 @@ def classify_object_type(image_region, bbox):
 
     # ---- Bare Land/Soil Change ----
     soil = 0.0
-    if features["red_ratio"] > 0.34 and features["green_ratio"] < 0.36:
+    if feat_a["red_ratio"] > 0.34 and feat_a["green_ratio"] < 0.36:
         soil += 0.20
-    if 8 <= features["hue"] <= 38:
+    if 8 <= feat_a["hue"] <= 38:
         soil += 0.18
-    if features["ndvi"] < 0.05:
+    if feat_a["ndvi"] < 0.05:
         soil += 0.18
-    if features["texture_std"] < 35:
+    if feat_a["texture_std"] < 35:
         soil += 0.12
-    if features["lbp_variance"] < 0.04:
+    if feat_a["lbp_variance"] < 0.04:
         soil += 0.12
-    if 40 <= features["saturation"] <= 130:
+    if 40 <= feat_a["saturation"] <= 130:
         soil += 0.10
-    if 45 <= features["brightness"] <= 82:
+    if 45 <= feat_a["brightness"] <= 82:
         soil += 0.10
     scores["Bare Land/Soil Change"] = soil
 
-    # Use raw scores as confidence (each rule set sums to ~1.0 max)
-    # Do NOT normalize by max_score — that inflates weak matches to 1.0
     best = max(scores, key=scores.get)
     conf = scores[best]
 
@@ -1060,10 +1219,10 @@ def classify_object_type(image_region, bbox):
     return best, min(conf, 1.0)
 
 
-def classify_with_ensemble(image_region, bbox):
+def classify_with_ensemble(image_region, bbox, before_region=None):
     """Ensemble: classify full region + sub-regions, vote with confidence weighting."""
     x, y, w, h = bbox
-    sub_boxes = [(x, y, w, h)]  # full region
+    sub_boxes = [(x, y, w, h)]
 
     if w > 20 and h > 20:
         hw, hh = w // 2, h // 2
@@ -1079,7 +1238,8 @@ def classify_with_ensemble(image_region, bbox):
     confidences = []
     transient_count = 0
     for sb in sub_boxes:
-        obj_type, conf = classify_object_type(image_region, sb)
+        obj_type, conf = classify_object_type(image_region, sb,
+                                              before_region=before_region)
         if obj_type is None:
             transient_count += 1
             continue
@@ -1087,14 +1247,13 @@ def classify_with_ensemble(image_region, bbox):
             classifications.append(obj_type)
             confidences.append(conf)
 
-    # Only exclude if majority of sub-regions are transient
     if transient_count > len(sub_boxes) // 2:
         return None, 0.0
 
     if not classifications:
-        return classify_object_type(image_region, (x, y, w, h))
+        return classify_object_type(image_region, (x, y, w, h),
+                                    before_region=before_region)
 
-    # Weighted voting
     weighted = {}
     counts = Counter(classifications)
     for ot, c in zip(classifications, confidences):
@@ -1767,9 +1926,11 @@ def analyze_change_regions(change_mask, image, min_area=400, use_ensemble=True,
         cx, cy = centroids[i]
 
         if use_ensemble and raw_area > 500:
-            object_type, confidence = classify_with_ensemble(image, (x, y, w, h))
+            object_type, confidence = classify_with_ensemble(
+                image, (x, y, w, h), before_region=before_img)
         else:
-            object_type, confidence = classify_object_type(image, (x, y, w, h))
+            object_type, confidence = classify_object_type(
+                image, (x, y, w, h), before_region=before_img)
 
         if object_type is None:
             # Do not silently drop large coherent regions; keep them as generic

app/model_inference.py

@@ -1,16 +1,14 @@
 """
-Siamese U-Net inference for satellite change detection.
+AdaptFormer inference for satellite change detection.
 
-Loads a TorchScript model exported from the training notebook and runs
+Downloads a pre-trained AdaptFormer model from HuggingFace Hub and runs
 tile-based inference on arbitrary-size image pairs, producing a binary
 change mask compatible with the rest of the detection pipeline.
 
-Set CHANGE_MODEL_PATH env var to the .pt file location.
-Falls back to the rule-based AI fusion when no model is available.
+Falls back gracefully when torch/transformers are not installed.
 """
 import logging
 import os
-from pathlib import Path
 
 import cv2
 import numpy as np
@@ -18,72 +16,72 @@ import numpy as np
 logger = logging.getLogger(__name__)
 
 _MODEL = None
-_MODEL_PATH = os.environ.get("CHANGE_MODEL_PATH", "data/siamese_unet.pt")
-_TILE_SIZE = 256
-_MEAN = np.array([0.485, 0.456, 0.406], dtype=np.float32)
-_STD = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+_PROCESSOR = None
+_DEVICE = None
+_MODEL_ID = "deepang/adaptformer-LEVIR-CD"
+_TILE_SIZE = 512
+_AVAILABLE = None
 
 
-def _get_torch():
-    """Lazy import torch — only when model exists."""
+def _try_import():
     try:
         import torch
-        return torch
+        from transformers import AutoImageProcessor, AutoModel
+        return torch, AutoImageProcessor, AutoModel
     except ImportError:
-        return None
+        return None, None, None
 
 
 def is_model_available():
-    """Check if a trained model file exists and torch is installed."""
-    return Path(_MODEL_PATH).is_file() and _get_torch() is not None
+    """Check if torch and transformers are installed."""
+    global _AVAILABLE
+    if _AVAILABLE is not None:
+        return _AVAILABLE
+    torch, _, _ = _try_import()
+    _AVAILABLE = torch is not None
+    return _AVAILABLE
 
 
 def _load_model():
-    global _MODEL
+    global _MODEL, _PROCESSOR, _DEVICE
     if _MODEL is not None:
-        return _MODEL
-    torch = _get_torch()
+        return _MODEL, _PROCESSOR
+
+    torch, AutoImageProcessor, AutoModel = _try_import()
     if torch is None:
-        raise RuntimeError("PyTorch is not installed")
-    path = Path(_MODEL_PATH)
-    if not path.is_file():
-        raise FileNotFoundError(f"Model not found at {path}")
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    _MODEL = torch.jit.load(str(path), map_location=device)
-    _MODEL.eval()
-    logger.info("Loaded Siamese U-Net from %s on %s", path, device)
-    return _MODEL
+        raise RuntimeError("PyTorch/transformers not installed")
 
+    _DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-def _preprocess_tile(tile):
-    """Normalize a (H, W, 3) uint8 RGB tile to (1, 3, H, W) float tensor."""
-    torch = _get_torch()
-    img = tile.astype(np.float32) / 255.0
-    img = (img - _MEAN) / _STD
-    tensor = torch.from_numpy(img.transpose(2, 0, 1)).unsqueeze(0)
-    return tensor
+    cache_dir = os.environ.get("HF_HOME", None)
+    logger.info("Loading AdaptFormer from %s ...", _MODEL_ID)
+    _PROCESSOR = AutoImageProcessor.from_pretrained(_MODEL_ID, cache_dir=cache_dir)
+    _MODEL = AutoModel.from_pretrained(_MODEL_ID, cache_dir=cache_dir)
+    _MODEL.to(_DEVICE)
+    _MODEL.eval()
+    logger.info("AdaptFormer loaded on %s", _DEVICE)
+    return _MODEL, _PROCESSOR
 
 
 def predict_change_mask(img1, img2, threshold=0.5):
     """
-    Run Siamese U-Net inference on two RGB numpy arrays (H, W, 3).
+    Run AdaptFormer inference on two RGB numpy arrays (H, W, 3).
     Images are split into overlapping tiles, predicted individually,
     and stitched back into a full-resolution binary mask.
 
-    Returns a uint8 mask (0 or 255) at the input resolution.
+    Returns (uint8 mask [0 or 255], float32 score map [0-1]).
     """
-    torch = _get_torch()
-    model = _load_model()
-    device = next(model.parameters()).device
+    torch, _, _ = _try_import()
+    model, processor = _load_model()
+    from PIL import Image as PILImage
 
     if img1.shape != img2.shape:
         img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))
 
     h, w = img1.shape[:2]
     tile = _TILE_SIZE
-    stride = tile * 3 // 4  # 75% overlap for smoother stitching
+    stride = tile * 3 // 4
 
-    # Pad to make dimensions divisible by tile size
     pad_h = (tile - h % tile) % tile
     pad_w = (tile - w % tile) % tile
     if pad_h or pad_w:
@@ -97,17 +95,32 @@ def predict_change_mask(img1, img2, threshold=0.5):
     with torch.no_grad():
         for y0 in range(0, ph - tile + 1, stride):
             for x0 in range(0, pw - tile + 1, stride):
-                t1 = _preprocess_tile(img1[y0:y0+tile, x0:x0+tile])
-                t2 = _preprocess_tile(img2[y0:y0+tile, x0:x0+tile])
-                logits = model(t1.to(device), t2.to(device))
-                prob = torch.sigmoid(logits).squeeze().cpu().numpy()
-                score_sum[y0:y0+tile, x0:x0+tile] += prob
+                t1 = img1[y0:y0+tile, x0:x0+tile]
+                t2 = img2[y0:y0+tile, x0:x0+tile]
+
+                pil1 = PILImage.fromarray(t1)
+                pil2 = PILImage.fromarray(t2)
+
+                inputs = processor(images=(pil1, pil2), return_tensors="pt")
+                inputs = {k: v.to(_DEVICE) for k, v in inputs.items()}
+
+                outputs = model(**inputs)
+                logits = outputs.logits
+                probs = torch.softmax(logits, dim=1)
+
+                # Class 1 = change
+                prob_map = probs[0, 1].cpu().numpy()
+
+                out_h, out_w = prob_map.shape
+                if out_h != tile or out_w != tile:
+                    prob_map = cv2.resize(prob_map, (tile, tile),
+                                          interpolation=cv2.INTER_LINEAR)
+
+                score_sum[y0:y0+tile, x0:x0+tile] += prob_map
                 count[y0:y0+tile, x0:x0+tile] += 1.0
 
     count = np.maximum(count, 1.0)
     avg_score = score_sum / count
-
-    # Crop back to original size
     avg_score = avg_score[:h, :w]
 
     mask = (avg_score >= threshold).astype(np.uint8) * 255

requirements.txt

@@ -1,3 +1,7 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch
+torchvision
+transformers>=4.35.0
 fastapi>=0.104.0
 uvicorn[standard]>=0.24.0
 python-multipart>=0.0.6

templates/index.html

@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>AI Change Detection</title>
-  <link rel="stylesheet" href="/static/css/style.css?v=21" />
+  <link rel="stylesheet" href="/static/css/style.css?v=22" />
 </head>
 <body>
   <div class="app">
@@ -360,6 +360,6 @@
     </div>
   </div>
 
-  <script src="/static/js/app.js?v=36"></script>
+  <script src="/static/js/app.js?v=37"></script>
 </body>
 </html>

train_change_detection_model.ipynb

@@ -1,633 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Satellite Change Detection — Siamese U-Net Training\n",
-        "\n",
-        "This notebook trains a **Siamese U-Net** on the **LEVIR-CD+** dataset for pixel-level\n",
-        "satellite image change detection. The exported model plugs directly into the\n",
-        "AI Change Detection web app.\n",
-        "\n",
-        "**Optimized for CPU** — uses a lightweight MobileNetV2 encoder and 15 epochs.\n",
-        "Training takes ~3-4 hours on a Colab CPU runtime."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 1. Install Dependencies"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "!pip install -q torch torchvision segmentation-models-pytorch albumentations datasets tqdm matplotlib"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 2. Download & Prepare LEVIR-CD+ Dataset\n",
-        "\n",
-        "LEVIR-CD+ contains 985 pairs of 1024×1024 Google Earth images with pixel-level\n",
-        "building change annotations. We download it from **Hugging Face** (reliable CDN,\n",
-        "no Google Drive rate limits), then cut each image into 256×256 patches."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "import os\n",
-        "import numpy as np\n",
-        "from PIL import Image\n",
-        "from datasets import load_dataset\n",
-        "\n",
-        "DATA_ROOT = \"./levir_cd_256\"\n",
-        "PATCH_SIZE = 256\n",
-        "\n",
-        "def save_patches(split_data, out_dir, start_idx=0):\n",
-        "    \"\"\"Cut 1024×1024 images into 256×256 patches and save to disk.\"\"\"\n",
-        "    os.makedirs(os.path.join(out_dir, \"A\"), exist_ok=True)\n",
-        "    os.makedirs(os.path.join(out_dir, \"B\"), exist_ok=True)\n",
-        "    os.makedirs(os.path.join(out_dir, \"label\"), exist_ok=True)\n",
-        "    patch_id = start_idx\n",
-        "    for row in split_data:\n",
-        "        img_a = np.array(row[\"image1\"].convert(\"RGB\"))\n",
-        "        img_b = np.array(row[\"image2\"].convert(\"RGB\"))\n",
-        "        mask  = np.array(row[\"mask\"].convert(\"L\"))\n",
-        "        h, w = img_a.shape[:2]\n",
-        "        for y in range(0, h - PATCH_SIZE + 1, PATCH_SIZE):\n",
-        "            for x in range(0, w - PATCH_SIZE + 1, PATCH_SIZE):\n",
-        "                pa = img_a[y:y+PATCH_SIZE, x:x+PATCH_SIZE]\n",
-        "                pb = img_b[y:y+PATCH_SIZE, x:x+PATCH_SIZE]\n",
-        "                pm = mask[y:y+PATCH_SIZE, x:x+PATCH_SIZE]\n",
-        "                name = f\"{patch_id:05d}.png\"\n",
-        "                Image.fromarray(pa).save(os.path.join(out_dir, \"A\", name))\n",
-        "                Image.fromarray(pb).save(os.path.join(out_dir, \"B\", name))\n",
-        "                Image.fromarray(pm).save(os.path.join(out_dir, \"label\", name))\n",
-        "                patch_id += 1\n",
-        "    return patch_id\n",
-        "\n",
-        "if not os.path.isdir(DATA_ROOT):\n",
-        "    print(\"Downloading LEVIR-CD+ from Hugging Face (~3.8 GB)...\")\n",
-        "    ds = load_dataset(\"blanchon/LEVIR_CDPlus\")\n",
-        "\n",
-        "    # The dataset has 'train' and 'test' splits\n",
-        "    train_data = ds[\"train\"]\n",
-        "    test_data  = ds[\"test\"]\n",
-        "\n",
-        "    # Use last 10% of train as validation\n",
-        "    n_train = len(train_data)\n",
-        "    n_val = max(1, int(n_train * 0.1))\n",
-        "    val_indices   = list(range(n_train - n_val, n_train))\n",
-        "    train_indices = list(range(0, n_train - n_val))\n",
-        "\n",
-        "    print(f\"Total train images: {n_train}, using {len(train_indices)} train + {len(val_indices)} val\")\n",
-        "    print(f\"Test images: {len(test_data)}\")\n",
-        "\n",
-        "    print(\"Cutting into 256×256 patches (this takes a few minutes)...\")\n",
-        "    n = save_patches(train_data.select(train_indices), os.path.join(DATA_ROOT, \"train\"))\n",
-        "    print(f\"  Train patches: {n}\")\n",
-        "    n = save_patches(train_data.select(val_indices), os.path.join(DATA_ROOT, \"val\"))\n",
-        "    print(f\"  Val patches:   {n}\")\n",
-        "    n = save_patches(test_data, os.path.join(DATA_ROOT, \"test\"))\n",
-        "    print(f\"  Test patches:  {n}\")\n",
-        "    print(\"Done! Dataset at:\", DATA_ROOT)\n",
-        "else:\n",
-        "    print(\"Dataset already present at\", DATA_ROOT)"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "# Verify structure — adjust paths if your zip extracts differently\n",
-        "for split in [\"train\", \"val\", \"test\"]:\n",
-        "    for sub in [\"A\", \"B\", \"label\"]:\n",
-        "        p = os.path.join(DATA_ROOT, split, sub)\n",
-        "        if os.path.isdir(p):\n",
-        "            n = len(os.listdir(p))\n",
-        "            print(f\"{split}/{sub}: {n} files\")\n",
-        "        else:\n",
-        "            print(f\"WARNING: {p} not found — check extracted folder name\")"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 3. Dataset & DataLoader"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "from torch.utils.data import Dataset, DataLoader\n",
-        "import albumentations as A\n",
-        "from albumentations.pytorch import ToTensorV2\n",
-        "\n",
-        "\n",
-        "class LEVIRCDDataset(Dataset):\n",
-        "    \"\"\"LEVIR-CD patch dataset: before (A), after (B), binary label.\"\"\"\n",
-        "\n",
-        "    def __init__(self, root, split=\"train\", transform=None):\n",
-        "        self.dir_a = os.path.join(root, split, \"A\")\n",
-        "        self.dir_b = os.path.join(root, split, \"B\")\n",
-        "        self.dir_label = os.path.join(root, split, \"label\")\n",
-        "        self.fnames = sorted(os.listdir(self.dir_a))\n",
-        "        self.transform = transform\n",
-        "\n",
-        "    def __len__(self):\n",
-        "        return len(self.fnames)\n",
-        "\n",
-        "    def __getitem__(self, idx):\n",
-        "        name = self.fnames[idx]\n",
-        "        img_a = np.array(Image.open(os.path.join(self.dir_a, name)).convert(\"RGB\"))\n",
-        "        img_b = np.array(Image.open(os.path.join(self.dir_b, name)).convert(\"RGB\"))\n",
-        "        label = np.array(Image.open(os.path.join(self.dir_label, name)).convert(\"L\"))\n",
-        "        label = (label > 127).astype(np.float32)\n",
-        "\n",
-        "        if self.transform:\n",
-        "            aug = self.transform(\n",
-        "                image=img_a,\n",
-        "                image_b=img_b,\n",
-        "                mask=label,\n",
-        "            )\n",
-        "            img_a = aug[\"image\"]        # (3, H, W) tensor\n",
-        "            img_b = aug[\"image_b\"]      # (3, H, W) tensor\n",
-        "            label = aug[\"mask\"].unsqueeze(0)  # (1, H, W)\n",
-        "        return img_a, img_b, label\n",
-        "\n",
-        "\n",
-        "train_transform = A.Compose(\n",
-        "    [\n",
-        "        A.HorizontalFlip(p=0.5),\n",
-        "        A.VerticalFlip(p=0.5),\n",
-        "        A.RandomRotate90(p=0.5),\n",
-        "        A.RandomBrightnessContrast(p=0.3, brightness_limit=0.15, contrast_limit=0.15),\n",
-        "        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),\n",
-        "        ToTensorV2(),\n",
-        "    ],\n",
-        "    additional_targets={\"image_b\": \"image\"},\n",
-        ")\n",
-        "\n",
-        "val_transform = A.Compose(\n",
-        "    [\n",
-        "        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),\n",
-        "        ToTensorV2(),\n",
-        "    ],\n",
-        "    additional_targets={\"image_b\": \"image\"},\n",
-        ")\n",
-        "\n",
-        "train_ds = LEVIRCDDataset(DATA_ROOT, \"train\", train_transform)\n",
-        "val_ds = LEVIRCDDataset(DATA_ROOT, \"val\", val_transform)\n",
-        "test_ds = LEVIRCDDataset(DATA_ROOT, \"test\", val_transform)\n",
-        "\n",
-        "BATCH = 4  # smaller batch for CPU\n",
-        "train_dl = DataLoader(train_ds, batch_size=BATCH, shuffle=True, num_workers=0, pin_memory=False)\n",
-        "val_dl = DataLoader(val_ds, batch_size=BATCH, shuffle=False, num_workers=0, pin_memory=False)\n",
-        "test_dl = DataLoader(test_ds, batch_size=BATCH, shuffle=False, num_workers=0, pin_memory=False)\n",
-        "\n",
-        "print(f\"Train: {len(train_ds)}, Val: {len(val_ds)}, Test: {len(test_ds)}\")"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 4. Siamese U-Net Model\n",
-        "\n",
-        "Architecture:\n",
-        "- **Shared encoder** (MobileNetV2, ImageNet pretrained) — lightweight and fast on CPU\n",
-        "- Feature maps from both branches are **concatenated** at each decoder level\n",
-        "- Standard U-Net decoder produces a binary change mask"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "import torch\n",
-        "import torch.nn as nn\n",
-        "import segmentation_models_pytorch as smp\n",
-        "\n",
-        "\n",
-        "ENCODER_NAME = \"mobilenet_v2\"  # lightweight encoder for CPU training\n",
-        "\n",
-        "\n",
-        "class SiameseUNet(nn.Module):\n",
-        "    \"\"\"\n",
-        "    Siamese U-Net for change detection.\n",
-        "    Shared encoder extracts features from both images;\n",
-        "    concatenated features are decoded into a binary change mask.\n",
-        "    \"\"\"\n",
-        "\n",
-        "    def __init__(self, encoder_name=ENCODER_NAME, pretrained=True):\n",
-        "        super().__init__()\n",
-        "        aux = smp.Unet(\n",
-        "            encoder_name=encoder_name,\n",
-        "            encoder_weights=\"imagenet\" if pretrained else None,\n",
-        "            in_channels=3,\n",
-        "            classes=1,\n",
-        "        )\n",
-        "        self.encoder = aux.encoder\n",
-        "\n",
-        "        encoder_channels = self.encoder.out_channels\n",
-        "        doubled = tuple(c * 2 for c in encoder_channels)\n",
-        "\n",
-        "        self.decoder = smp.decoders.unet.decoder.UnetDecoder(\n",
-        "            encoder_channels=doubled,\n",
-        "            decoder_channels=(256, 128, 64, 32, 16),\n",
-        "            n_blocks=5,\n",
-        "            use_batchnorm=True,\n",
-        "            attention_type=None,\n",
-        "        )\n",
-        "\n",
-        "        self.head = nn.Conv2d(16, 1, kernel_size=1)\n",
-        "\n",
-        "    def forward(self, img_a, img_b):\n",
-        "        feats_a = self.encoder(img_a)\n",
-        "        feats_b = self.encoder(img_b)\n",
-        "        feats_cat = [torch.cat([fa, fb], dim=1) for fa, fb in zip(feats_a, feats_b)]\n",
-        "        decoded = self.decoder(*feats_cat)\n",
-        "        logits = self.head(decoded)\n",
-        "        return logits\n",
-        "\n",
-        "\n",
-        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-        "model = SiameseUNet(encoder_name=ENCODER_NAME, pretrained=True).to(device)\n",
-        "\n",
-        "total_params = sum(p.numel() for p in model.parameters()) / 1e6\n",
-        "print(f\"Model on {device}, {total_params:.1f}M parameters\")\n",
-        "if device.type == \"cpu\":\n",
-        "    print(\"Running on CPU — training will take ~3-4 hours for 15 epochs\")"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 5. Loss Function & Metrics\n",
-        "\n",
-        "Combined **BCE + Dice** loss handles class imbalance (most pixels are unchanged)."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "class BCEDiceLoss(nn.Module):\n",
-        "    def __init__(self, bce_weight=0.5):\n",
-        "        super().__init__()\n",
-        "        self.bce = nn.BCEWithLogitsLoss()\n",
-        "        self.bce_weight = bce_weight\n",
-        "\n",
-        "    def forward(self, logits, targets):\n",
-        "        bce_loss = self.bce(logits, targets)\n",
-        "        probs = torch.sigmoid(logits)\n",
-        "        smooth = 1.0\n",
-        "        intersection = (probs * targets).sum()\n",
-        "        dice = (2.0 * intersection + smooth) / (probs.sum() + targets.sum() + smooth)\n",
-        "        dice_loss = 1.0 - dice\n",
-        "        return self.bce_weight * bce_loss + (1 - self.bce_weight) * dice_loss\n",
-        "\n",
-        "\n",
-        "def compute_metrics(preds, targets, threshold=0.5):\n",
-        "    \"\"\"Compute precision, recall, F1, and IoU.\"\"\"\n",
-        "    preds_bin = (preds > threshold).float()\n",
-        "    tp = (preds_bin * targets).sum().item()\n",
-        "    fp = (preds_bin * (1 - targets)).sum().item()\n",
-        "    fn = ((1 - preds_bin) * targets).sum().item()\n",
-        "    precision = tp / (tp + fp + 1e-8)\n",
-        "    recall = tp / (tp + fn + 1e-8)\n",
-        "    f1 = 2 * precision * recall / (precision + recall + 1e-8)\n",
-        "    iou = tp / (tp + fp + fn + 1e-8)\n",
-        "    return {\"precision\": precision, \"recall\": recall, \"f1\": f1, \"iou\": iou}"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 6. Training Loop"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "import time\n",
-        "from tqdm.auto import tqdm\n",
-        "\n",
-        "NUM_EPOCHS = 15  # fewer epochs for CPU training\n",
-        "LR = 3e-4       # slightly higher LR to converge faster\n",
-        "\n",
-        "criterion = BCEDiceLoss(bce_weight=0.5)\n",
-        "optimizer = torch.optim.Adam(model.parameters(), lr=LR, weight_decay=1e-4)\n",
-        "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=NUM_EPOCHS, eta_min=1e-6)\n",
-        "\n",
-        "best_f1 = 0.0\n",
-        "history = {\"train_loss\": [], \"val_loss\": [], \"val_f1\": [], \"val_iou\": []}\n",
-        "train_start = time.time()\n",
-        "\n",
-        "for epoch in range(1, NUM_EPOCHS + 1):\n",
-        "    epoch_start = time.time()\n",
-        "\n",
-        "    # --- Train ---\n",
-        "    model.train()\n",
-        "    running_loss = 0.0\n",
-        "    for img_a, img_b, label in tqdm(train_dl, desc=f\"Epoch {epoch}/{NUM_EPOCHS} [train]\", leave=False):\n",
-        "        img_a = img_a.to(device)\n",
-        "        img_b = img_b.to(device)\n",
-        "        label = label.to(device)\n",
-        "\n",
-        "        logits = model(img_a, img_b)\n",
-        "        loss = criterion(logits, label)\n",
-        "\n",
-        "        optimizer.zero_grad()\n",
-        "        loss.backward()\n",
-        "        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n",
-        "        optimizer.step()\n",
-        "        running_loss += loss.item() * img_a.size(0)\n",
-        "\n",
-        "    train_loss = running_loss / len(train_ds)\n",
-        "    scheduler.step()\n",
-        "\n",
-        "    # --- Validate ---\n",
-        "    model.eval()\n",
-        "    val_loss_sum = 0.0\n",
-        "    all_preds, all_targets = [], []\n",
-        "    with torch.no_grad():\n",
-        "        for img_a, img_b, label in val_dl:\n",
-        "            img_a = img_a.to(device)\n",
-        "            img_b = img_b.to(device)\n",
-        "            label = label.to(device)\n",
-        "\n",
-        "            logits = model(img_a, img_b)\n",
-        "            val_loss_sum += criterion(logits, label).item() * img_a.size(0)\n",
-        "            all_preds.append(torch.sigmoid(logits).cpu())\n",
-        "            all_targets.append(label.cpu())\n",
-        "\n",
-        "    val_loss = val_loss_sum / len(val_ds)\n",
-        "    preds_cat = torch.cat(all_preds)\n",
-        "    targets_cat = torch.cat(all_targets)\n",
-        "    metrics = compute_metrics(preds_cat, targets_cat)\n",
-        "\n",
-        "    history[\"train_loss\"].append(train_loss)\n",
-        "    history[\"val_loss\"].append(val_loss)\n",
-        "    history[\"val_f1\"].append(metrics[\"f1\"])\n",
-        "    history[\"val_iou\"].append(metrics[\"iou\"])\n",
-        "\n",
-        "    elapsed_min = (time.time() - epoch_start) / 60\n",
-        "    total_min = (time.time() - train_start) / 60\n",
-        "    eta_min = elapsed_min * (NUM_EPOCHS - epoch)\n",
-        "\n",
-        "    print(\n",
-        "        f\"Epoch {epoch:02d} | \"\n",
-        "        f\"train_loss={train_loss:.4f} | \"\n",
-        "        f\"val_loss={val_loss:.4f} | \"\n",
-        "        f\"F1={metrics['f1']:.4f} | \"\n",
-        "        f\"IoU={metrics['iou']:.4f} | \"\n",
-        "        f\"P={metrics['precision']:.4f} R={metrics['recall']:.4f} | \"\n",
-        "        f\"{elapsed_min:.1f}min (ETA: {eta_min:.0f}min)\"\n",
-        "    )\n",
-        "\n",
-        "    if metrics[\"f1\"] > best_f1:\n",
-        "        best_f1 = metrics[\"f1\"]\n",
-        "        torch.save(model.state_dict(), \"best_siamese_unet.pth\")\n",
-        "        print(f\"  >> Saved best model (F1={best_f1:.4f})\")\n",
-        "\n",
-        "total_time = (time.time() - train_start) / 60\n",
-        "print(f\"\\nTraining complete in {total_time:.1f} minutes. Best val F1: {best_f1:.4f}\")"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 7. Training Curves"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "import matplotlib.pyplot as plt\n",
-        "\n",
-        "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n",
-        "\n",
-        "axes[0].plot(history[\"train_loss\"], label=\"Train\")\n",
-        "axes[0].plot(history[\"val_loss\"], label=\"Val\")\n",
-        "axes[0].set_title(\"Loss\")\n",
-        "axes[0].legend()\n",
-        "\n",
-        "axes[1].plot(history[\"val_f1\"])\n",
-        "axes[1].set_title(\"Val F1 Score\")\n",
-        "\n",
-        "axes[2].plot(history[\"val_iou\"])\n",
-        "axes[2].set_title(\"Val IoU\")\n",
-        "\n",
-        "for ax in axes:\n",
-        "    ax.set_xlabel(\"Epoch\")\n",
-        "    ax.grid(True, alpha=0.3)\n",
-        "\n",
-        "plt.tight_layout()\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 8. Evaluate on Test Set"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "# Load best checkpoint\n",
-        "model.load_state_dict(torch.load(\"best_siamese_unet.pth\", map_location=device))\n",
-        "model.eval()\n",
-        "\n",
-        "all_preds, all_targets = [], []\n",
-        "with torch.no_grad():\n",
-        "    for img_a, img_b, label in tqdm(test_dl, desc=\"Testing\"):\n",
-        "        logits = model(img_a.to(device), img_b.to(device))\n",
-        "        all_preds.append(torch.sigmoid(logits).cpu())\n",
-        "        all_targets.append(label)\n",
-        "\n",
-        "preds = torch.cat(all_preds)\n",
-        "targets = torch.cat(all_targets)\n",
-        "test_metrics = compute_metrics(preds, targets)\n",
-        "\n",
-        "print(f\"\\nTest Results:\")\n",
-        "print(f\"  F1 Score:  {test_metrics['f1']:.4f}\")\n",
-        "print(f\"  IoU:       {test_metrics['iou']:.4f}\")\n",
-        "print(f\"  Precision: {test_metrics['precision']:.4f}\")\n",
-        "print(f\"  Recall:    {test_metrics['recall']:.4f}\")"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 9. Visualize Predictions"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "MEAN = np.array([0.485, 0.456, 0.406])\n",
-        "STD = np.array([0.229, 0.224, 0.225])\n",
-        "\n",
-        "def denorm(tensor):\n",
-        "    img = tensor.permute(1, 2, 0).numpy()\n",
-        "    img = img * STD + MEAN\n",
-        "    return np.clip(img, 0, 1)\n",
-        "\n",
-        "fig, axes = plt.subplots(4, 4, figsize=(16, 16))\n",
-        "sample_indices = np.random.choice(len(test_ds), 4, replace=False)\n",
-        "\n",
-        "for row, idx in enumerate(sample_indices):\n",
-        "    img_a, img_b, label = test_ds[idx]\n",
-        "    with torch.no_grad():\n",
-        "        logit = model(img_a.unsqueeze(0).to(device), img_b.unsqueeze(0).to(device))\n",
-        "        pred = (torch.sigmoid(logit) > 0.5).squeeze().cpu().numpy()\n",
-        "\n",
-        "    axes[row, 0].imshow(denorm(img_a))\n",
-        "    axes[row, 0].set_title(\"Before\")\n",
-        "    axes[row, 1].imshow(denorm(img_b))\n",
-        "    axes[row, 1].set_title(\"After\")\n",
-        "    axes[row, 2].imshow(label.squeeze(), cmap=\"gray\")\n",
-        "    axes[row, 2].set_title(\"Ground Truth\")\n",
-        "    axes[row, 3].imshow(pred, cmap=\"gray\")\n",
-        "    axes[row, 3].set_title(\"Prediction\")\n",
-        "\n",
-        "for ax in axes.flat:\n",
-        "    ax.axis(\"off\")\n",
-        "plt.tight_layout()\n",
-        "plt.show()"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 10. Export Model for Deployment\n",
-        "\n",
-        "Export as TorchScript for the web app. Download the `.pt` file and place it in\n",
-        "your app's `data/` folder, then set the environment variable:\n",
-        "\n",
-        "```\n",
-        "CHANGE_MODEL_PATH=data/siamese_unet.pt\n",
-        "```"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "model.eval()\n",
-        "model_cpu = model.cpu()\n",
-        "\n",
-        "# Trace with example inputs\n",
-        "example_a = torch.randn(1, 3, 256, 256)\n",
-        "example_b = torch.randn(1, 3, 256, 256)\n",
-        "traced = torch.jit.trace(model_cpu, (example_a, example_b))\n",
-        "\n",
-        "export_path = \"siamese_unet.pt\"\n",
-        "traced.save(export_path)\n",
-        "size_mb = os.path.getsize(export_path) / 1e6\n",
-        "print(f\"Exported TorchScript model: {export_path} ({size_mb:.1f} MB)\")\n",
-        "print(\"\\nDownload this file and place it in your app's data/ directory.\")\n",
-        "print('Then set: CHANGE_MODEL_PATH=data/siamese_unet.pt')"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "# Quick sanity check: verify exported model produces same output\n",
-        "loaded = torch.jit.load(export_path)\n",
-        "with torch.no_grad():\n",
-        "    out_orig = model_cpu(example_a, example_b)\n",
-        "    out_loaded = loaded(example_a, example_b)\n",
-        "    diff = (out_orig - out_loaded).abs().max().item()\n",
-        "    print(f\"Max diff between original and exported: {diff:.8f}\")\n",
-        "    assert diff < 1e-5, \"Export verification failed!\"\n",
-        "    print(\"Export verified successfully.\")"
-      ],
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 11. Download from Colab\n",
-        "\n",
-        "Run this cell to trigger a browser download of the model file."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
-      "source": [
-        "try:\n",
-        "    from google.colab import files\n",
-        "    files.download(\"siamese_unet.pt\")\n",
-        "    files.download(\"best_siamese_unet.pth\")\n",
-        "except ImportError:\n",
-        "    print(\"Not running in Colab. Files saved locally:\")\n",
-        "    print(f\"  - {export_path}\")\n",
-        "    print(f\"  - best_siamese_unet.pth\")"
-      ],
-      "execution_count": null,
-      "outputs": []
-    }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "Python 3",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "name": "python",
-      "version": "3.11.0"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 4
-}