Implement inference pipeline and Gradio demo app

inference.py: tiled sliding-window inference for any resolution,
reflection padding to patch-size multiples, binary mask + overlay
output, prints percentage of area changed.

app.py: Gradio Blocks UI with before/after uploads, model dropdown,
checkpoint picker, threshold slider. Returns change mask, red overlay,
and Markdown summary with change statistics. Model caching, CPU
fallback, defaults from config.yaml gradio section.

app.py

@@ -1,7 +1,10 @@
-"""Gradio web demo for change detection inference.
+"""Gradio web demo for satellite change detection.
 
-Provides an interactive interface to upload before/after satellite image pairs
-and visualize predicted change masks with overlays.
+Upload before/after satellite image pairs, select a model and checkpoint, and
+view the predicted change mask, overlay, and change-area statistics.
+
+Defaults (model, checkpoint, port, share) are read from the ``gradio`` section
+of ``configs/config.yaml``.
 
 Usage:
     python app.py
@@ -9,7 +12,7 @@ Usage:
 
 import logging
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Any, Dict, Optional, Tuple
 
 import cv2
 import gradio as gr
@@ -18,168 +21,281 @@ import torch
 import yaml
 
 from data.dataset import IMAGENET_MEAN, IMAGENET_STD
-from inference import preprocess_image, sliding_window_inference
+from inference import load_and_preprocess, sliding_window_inference
 from models import get_model
-from utils.visualization import denormalize, overlay_changes
+from utils.visualization import overlay_changes
 
 logger = logging.getLogger(__name__)
 
-# Global model cache
-_model: Optional[torch.nn.Module] = None
-_model_name: Optional[str] = None
+
+# ---------------------------------------------------------------------------
+# Globals (model cache to avoid reloading on every prediction)
+# ---------------------------------------------------------------------------
+
+_cached_model: Optional[torch.nn.Module] = None
+_cached_model_key: Optional[str] = None  # "model_name::checkpoint_path"
 _device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-_config = None
+_config: Optional[Dict[str, Any]] = None
 
 
-def load_config() -> dict:
-    """Load project config from YAML.
+def _load_config() -> Dict[str, Any]:
+    """Load and cache the project config.
 
     Returns:
-        Config dictionary.
+        Full config dict.
     """
-    config_path = Path("configs/config.yaml")
-    with open(config_path, "r") as f:
-        return yaml.safe_load(f)
+    global _config
+    if _config is None:
+        config_path = Path("configs/config.yaml")
+        with open(config_path, "r") as fh:
+            _config = yaml.safe_load(fh)
+    return _config
 
 
-def load_model(model_name: str, checkpoint_path: str) -> torch.nn.Module:
-    """Load a change detection model with caching.
+def _load_model(model_name: str, checkpoint_path: str) -> torch.nn.Module:
+    """Load a model, re-using the cache if name + checkpoint match.
 
     Args:
-        model_name: Name of the model architecture.
-        checkpoint_path: Path to the model checkpoint.
+        model_name: Architecture name (``siamese_cnn``, ``unet_pp``, ``changeformer``).
+        checkpoint_path: Path to the ``.pth`` checkpoint file.
 
     Returns:
-        Loaded model in eval mode.
+        Model in eval mode on the current device.
+
+    Raises:
+        FileNotFoundError: If the checkpoint does not exist.
     """
-    global _model, _model_name, _config
+    global _cached_model, _cached_model_key
 
-    if _config is None:
-        _config = load_config()
+    cache_key = f"{model_name}::{checkpoint_path}"
+    if _cached_model is not None and _cached_model_key == cache_key:
+        return _cached_model
 
-    if _model is not None and _model_name == model_name:
-        return _model
+    config = _load_config()
+    ckpt_path = Path(checkpoint_path)
+    if not ckpt_path.exists():
+        raise FileNotFoundError(f"Checkpoint not found: {ckpt_path}")
 
-    model = get_model(model_name, _config).to(_device)
-    ckpt = torch.load(checkpoint_path, map_location=_device)
+    model = get_model(model_name, config).to(_device)
+    ckpt = torch.load(ckpt_path, map_location=_device)
     model.load_state_dict(ckpt["model_state_dict"])
     model.eval()
 
-    _model = model
-    _model_name = model_name
-    logger.info("Loaded model: %s from %s", model_name, checkpoint_path)
+    _cached_model = model
+    _cached_model_key = cache_key
+    logger.info("Loaded model %s from %s", model_name, checkpoint_path)
     return model
 
 
+# ---------------------------------------------------------------------------
+# Preprocessing helper (numpy RGB uint8 → tensor)
+# ---------------------------------------------------------------------------
+
+def _numpy_to_tensor(
+    img: np.ndarray,
+    patch_size: int = 256,
+) -> Tuple[torch.Tensor, Tuple[int, int]]:
+    """Convert a uint8 RGB numpy image to a normalised, padded tensor.
+
+    Args:
+        img: Input image ``[H, W, 3]``, uint8, RGB.
+        patch_size: Pad to a multiple of this value.
+
+    Returns:
+        Tuple of ``(tensor [1, 3, H_pad, W_pad], (orig_h, orig_w))``.
+    """
+    orig_h, orig_w = img.shape[:2]
+
+    pad_h = (patch_size - orig_h % patch_size) % patch_size
+    pad_w = (patch_size - orig_w % patch_size) % patch_size
+    if pad_h > 0 or pad_w > 0:
+        img = np.pad(img, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
+
+    img_f = img.astype(np.float32) / 255.0
+    mean = np.array(IMAGENET_MEAN, dtype=np.float32)
+    std = np.array(IMAGENET_STD, dtype=np.float32)
+    img_f = (img_f - mean) / std
+
+    tensor = torch.from_numpy(img_f).permute(2, 0, 1).unsqueeze(0).float()
+    return tensor, (orig_h, orig_w)
+
+
+# ---------------------------------------------------------------------------
+# Prediction function (called by Gradio)
+# ---------------------------------------------------------------------------
+
 def predict(
-    before_image: np.ndarray,
-    after_image: np.ndarray,
+    before_image: Optional[np.ndarray],
+    after_image: Optional[np.ndarray],
     model_name: str,
     checkpoint_path: str,
     threshold: float,
-) -> Tuple[np.ndarray, np.ndarray]:
-    """Run change detection on a pair of images.
+) -> Tuple[Optional[np.ndarray], Optional[np.ndarray], str]:
+    """Run change detection and return visualisations + summary text.
 
     Args:
-        before_image: Before image as numpy array (RGB, uint8).
-        after_image: After image as numpy array (RGB, uint8).
-        model_name: Model architecture name.
-        checkpoint_path: Path to model weights.
-        threshold: Binarization threshold.
+        before_image: Before image as numpy ``[H, W, 3]`` RGB uint8.
+        after_image: After image as numpy ``[H, W, 3]`` RGB uint8.
+        model_name: Architecture name.
+        checkpoint_path: Path to checkpoint file.
+        threshold: Binarisation threshold for predictions.
 
     Returns:
-        Tuple of (binary change mask, overlay visualization).
+        Tuple of ``(change_mask, overlay_image, summary_text)``.
+        - ``change_mask``: uint8 grayscale ``[H, W]`` (0 or 255).
+        - ``overlay_image``: uint8 RGB ``[H, W, 3]``.
+        - ``summary_text``: Markdown string with change statistics.
     """
-    model = load_model(model_name, checkpoint_path)
-    patch_size = 256
-
-    # Preprocess both images
-    def _to_tensor(img: np.ndarray) -> torch.Tensor:
-        h, w = img.shape[:2]
-        pad_h = (patch_size - h % patch_size) % patch_size
-        pad_w = (patch_size - w % patch_size) % patch_size
-        if pad_h > 0 or pad_w > 0:
-            img = np.pad(img, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
-        img_f = img.astype(np.float32) / 255.0
-        mean = np.array(IMAGENET_MEAN, dtype=np.float32)
-        std = np.array(IMAGENET_STD, dtype=np.float32)
-        img_f = (img_f - mean) / std
-        return torch.from_numpy(img_f).permute(2, 0, 1).unsqueeze(0).float()
-
-    orig_h, orig_w = before_image.shape[:2]
-    tensor_a = _to_tensor(before_image)
-    tensor_b = _to_tensor(after_image)
-
-    # Run inference
+    if before_image is None or after_image is None:
+        return None, None, "Please upload both before and after images."
+
+    config = _load_config()
+    patch_size: int = config.get("dataset", {}).get("patch_size", 256)
+
+    # Load model
+    try:
+        model = _load_model(model_name, checkpoint_path)
+    except FileNotFoundError as exc:
+        return None, None, f"Error: {exc}"
+
+    # Preprocess
+    tensor_a, (orig_h, orig_w) = _numpy_to_tensor(before_image, patch_size)
+    tensor_b, _ = _numpy_to_tensor(after_image, patch_size)
+
+    # Tiled inference
     prob_map = sliding_window_inference(model, tensor_a, tensor_b, patch_size, _device)
     prob_map = prob_map[:, :, :orig_h, :orig_w]
+    prob_np = prob_map.squeeze().numpy()  # [H, W]
 
-    # Binary mask
-    mask_np = prob_map.squeeze().numpy()
-    binary_mask = (mask_np > threshold).astype(np.uint8) * 255
+    # Binary change mask
+    binary_mask = (prob_np > threshold).astype(np.uint8) * 255
 
     # Overlay on after image
-    overlay = after_image.copy().astype(np.float32) / 255.0
-    change_pixels = mask_np > threshold
-    overlay[change_pixels, 0] = np.clip(overlay[change_pixels, 0] * 0.6 + 0.4, 0, 1)
-    overlay[change_pixels, 1] = overlay[change_pixels, 1] * 0.6
-    overlay[change_pixels, 2] = overlay[change_pixels, 2] * 0.6
-    overlay = (overlay * 255).astype(np.uint8)
+    pred_tensor = (prob_map.squeeze(0) >= threshold).float()  # [1, H, W]
+    img_b_tensor = tensor_b.squeeze()[:, :orig_h, :orig_w]    # [3, H, W]
+    overlay_rgb = overlay_changes(
+        img_after=img_b_tensor,
+        mask_pred=pred_tensor,
+        alpha=0.4,
+        color=(255, 0, 0),
+    )
 
-    return binary_mask, overlay
+    # Change statistics
+    total_pixels = orig_h * orig_w
+    changed_pixels = int(binary_mask.sum() // 255)
+    pct_changed = (changed_pixels / total_pixels) * 100.0
+
+    summary = (
+        f"### Change Detection Summary\n"
+        f"- **Image size**: {orig_w} x {orig_h}\n"
+        f"- **Total pixels**: {total_pixels:,}\n"
+        f"- **Changed pixels**: {changed_pixels:,}\n"
+        f"- **Area changed**: {pct_changed:.2f}%\n"
+        f"- **Model**: {model_name}\n"
+        f"- **Threshold**: {threshold}"
+    )
+
+    return binary_mask, overlay_rgb, summary
 
 
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+
 def build_demo() -> gr.Blocks:
-    """Build the Gradio demo interface.
+    """Construct the Gradio Blocks interface.
 
     Returns:
-        Gradio Blocks application.
+        A ``gr.Blocks`` application ready to ``.launch()``.
     """
-    config = load_config()
+    config = _load_config()
     gradio_cfg = config.get("gradio", {})
 
-    with gr.Blocks(title="Military Base Change Detection") as demo:
-        gr.Markdown("# Military Base Change Detection")
-        gr.Markdown("Upload before/after satellite image pairs to detect construction and infrastructure changes.")
+    with gr.Blocks(
+        title="Military Base Change Detection",
+        theme=gr.themes.Soft(),
+    ) as demo:
 
-        with gr.Row():
-            with gr.Column():
-                before_img = gr.Image(label="Before Image", type="numpy")
-                after_img = gr.Image(label="After Image", type="numpy")
-            with gr.Column():
-                change_mask = gr.Image(label="Change Mask")
-                overlay_img = gr.Image(label="Overlay")
+        gr.Markdown(
+            "# Military Base Change Detection\n"
+            "Upload **before** and **after** satellite images to detect "
+            "construction, infrastructure changes, and runway development."
+        )
 
+        # ---- Inputs ---------------------------------------------------
+        with gr.Row():
+            with gr.Column(scale=1):
+                before_img = gr.Image(
+                    label="Before Image",
+                    type="numpy",
+                    sources=["upload", "clipboard"],
+                )
+            with gr.Column(scale=1):
+                after_img = gr.Image(
+                    label="After Image",
+                    type="numpy",
+                    sources=["upload", "clipboard"],
+                )
+
+        # ---- Controls -------------------------------------------------
         with gr.Row():
             model_dropdown = gr.Dropdown(
                 choices=["siamese_cnn", "unet_pp", "changeformer"],
                 value=gradio_cfg.get("default_model", "unet_pp"),
-                label="Model",
+                label="Model Architecture",
             )
             checkpoint_input = gr.Textbox(
                 value=gradio_cfg.get("default_checkpoint", "checkpoints/unet_pp_best.pth"),
                 label="Checkpoint Path",
             )
             threshold_slider = gr.Slider(
-                minimum=0.1, maximum=0.9, value=0.5, step=0.05,
+                minimum=0.1,
+                maximum=0.9,
+                value=0.5,
+                step=0.05,
                 label="Detection Threshold",
             )
 
-        detect_btn = gr.Button("Detect Changes", variant="primary")
+        detect_btn = gr.Button("Detect Changes", variant="primary", size="lg")
+
+        # ---- Outputs --------------------------------------------------
+        with gr.Row():
+            with gr.Column(scale=1):
+                change_mask_out = gr.Image(label="Change Mask")
+            with gr.Column(scale=1):
+                overlay_out = gr.Image(label="Overlay (changes in red)")
+
+        summary_out = gr.Markdown(label="Summary")
+
+        # ---- Wiring ---------------------------------------------------
         detect_btn.click(
             fn=predict,
-            inputs=[before_img, after_img, model_dropdown, checkpoint_input, threshold_slider],
-            outputs=[change_mask, overlay_img],
+            inputs=[
+                before_img,
+                after_img,
+                model_dropdown,
+                checkpoint_input,
+                threshold_slider,
+            ],
+            outputs=[change_mask_out, overlay_out, summary_out],
         )
 
     return demo
 
 
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
 def main() -> None:
-    """Launch the Gradio demo."""
-    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+    """Launch the Gradio demo server."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
 
-    config = load_config()
+    config = _load_config()
     gradio_cfg = config.get("gradio", {})
 
     demo = build_demo()

inference.py

@@ -1,11 +1,16 @@
-"""Run inference on arbitrary before/after image pairs.
+"""Run change-detection inference on arbitrary before/after image pairs.
 
-Loads a trained change detection model and produces binary change masks
-for new satellite image pairs.
+Handles images of any resolution by tiling into 256x256 patches, running the
+model on each patch, and stitching the probability map back together.  Outputs
+a binary change mask PNG, an overlay visualisation, and prints the percentage
+of area changed.
 
 Usage:
     python inference.py --before path/to/before.png --after path/to/after.png \
         --model changeformer --checkpoint checkpoints/changeformer_best.pth
+
+    python inference.py --before big_before.tif --after big_after.tif \
+        --checkpoint checkpoints/unet_pp_best.pth --output results/
 """
 
 import argparse
@@ -17,55 +22,67 @@ import cv2
 import numpy as np
 import torch
 import torch.nn as nn
-import torch.nn.functional as F
 import yaml
 
 from data.dataset import IMAGENET_MEAN, IMAGENET_STD
 from models import get_model
-from utils.visualization import overlay_changes, plot_prediction
+from utils.visualization import overlay_changes
 
 logger = logging.getLogger(__name__)
 
 
-def preprocess_image(
+# ---------------------------------------------------------------------------
+# Image preprocessing
+# ---------------------------------------------------------------------------
+
+def load_and_preprocess(
     image_path: Path,
     patch_size: int = 256,
 ) -> Tuple[torch.Tensor, Tuple[int, int]]:
-    """Load and preprocess a single image for inference.
-
-    Reads the image, pads to a multiple of patch_size, and applies
-    ImageNet normalization.
+    """Load an image from disk, pad to a patch-size multiple, and normalise.
 
     Args:
-        image_path: Path to the input image.
-        patch_size: Patch size the model expects.
+        image_path: Path to the input image (any format OpenCV supports).
+        patch_size: Spatial size the model expects per patch.
 
     Returns:
-        Tuple of (preprocessed tensor [1, 3, H, W], original (H, W)).
+        Tuple of ``(tensor, original_size)`` where tensor has shape
+        ``[1, 3, H_padded, W_padded]`` and ``original_size`` is
+        ``(orig_h, orig_w)`` before padding.
+
+    Raises:
+        FileNotFoundError: If the image cannot be read.
     """
     img = cv2.imread(str(image_path), cv2.IMREAD_COLOR)
     if img is None:
         raise FileNotFoundError(f"Could not read image: {image_path}")
     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
     orig_h, orig_w = img.shape[:2]
+    logger.info("Loaded %s (%d x %d)", image_path.name, orig_w, orig_h)
 
-    # Pad to multiple of patch_size
+    # Pad to the nearest multiple of patch_size using reflection
     pad_h = (patch_size - orig_h % patch_size) % patch_size
     pad_w = (patch_size - orig_w % patch_size) % patch_size
     if pad_h > 0 or pad_w > 0:
         img = np.pad(img, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
 
-    # Normalize
+    # uint8 → float32 [0,1] → ImageNet normalisation
     img = img.astype(np.float32) / 255.0
     mean = np.array(IMAGENET_MEAN, dtype=np.float32)
     std = np.array(IMAGENET_STD, dtype=np.float32)
     img = (img - mean) / std
 
-    # HWC -> CHW, add batch dim
+    # HWC → CHW, add batch dim
     tensor = torch.from_numpy(img).permute(2, 0, 1).unsqueeze(0).float()
     return tensor, (orig_h, orig_w)
 
 
+# ---------------------------------------------------------------------------
+# Tiled (sliding-window) inference
+# ---------------------------------------------------------------------------
+
+@torch.no_grad()
 def sliding_window_inference(
     model: nn.Module,
     img_a: torch.Tensor,
@@ -73,103 +90,203 @@ def sliding_window_inference(
     patch_size: int = 256,
     device: torch.device = torch.device("cpu"),
 ) -> torch.Tensor:
-    """Run inference using sliding window for large images.
+    """Run inference by tiling large images into non-overlapping patches.
 
-    Splits images into non-overlapping patches, runs model on each,
-    and stitches results back together.
+    Each patch pair is fed through the model independently; the resulting
+    probability maps are stitched back into a single full-resolution output.
 
     Args:
-        model: Trained change detection model.
-        img_a: Before image tensor [1, 3, H, W].
-        img_b: After image tensor [1, 3, H, W].
-        patch_size: Size of each patch.
-        device: Inference device.
+        model: Trained change-detection model (set to eval internally).
+        img_a: Before image ``[1, 3, H, W]`` (padded to patch-size multiples).
+        img_b: After image ``[1, 3, H, W]`` (same spatial size as ``img_a``).
+        patch_size: Tile size in pixels.
+        device: Inference device (CUDA or CPU).
 
     Returns:
-        Probability map [1, 1, H, W] (after sigmoid).
+        Probability map ``[1, 1, H, W]`` with values in ``[0, 1]`` (after
+        sigmoid), on CPU.
     """
+    model.eval()
     _, _, h, w = img_a.shape
-    output = torch.zeros(1, 1, h, w, device="cpu")
+    output = torch.zeros(1, 1, h, w)
 
-    model.eval()
-    with torch.no_grad():
-        for y in range(0, h, patch_size):
-            for x in range(0, w, patch_size):
-                patch_a = img_a[:, :, y:y + patch_size, x:x + patch_size].to(device)
-                patch_b = img_b[:, :, y:y + patch_size, x:x + patch_size].to(device)
+    n_tiles = (h // patch_size) * (w // patch_size)
+    tile_idx = 0
+
+    for y in range(0, h, patch_size):
+        for x in range(0, w, patch_size):
+            patch_a = img_a[:, :, y:y + patch_size, x:x + patch_size].to(device)
+            patch_b = img_b[:, :, y:y + patch_size, x:x + patch_size].to(device)
+
+            logits = model(patch_a, patch_b)
+            probs = torch.sigmoid(logits).cpu()
+            output[:, :, y:y + patch_size, x:x + patch_size] = probs
 
-                logits = model(patch_a, patch_b)
-                probs = torch.sigmoid(logits).cpu()
-                output[:, :, y:y + patch_size, x:x + patch_size] = probs
+            tile_idx += 1
 
+    logger.info("Inference complete: %d tiles processed", n_tiles)
     return output
 
 
-def save_change_mask(
-    mask: np.ndarray,
+# ---------------------------------------------------------------------------
+# Output helpers
+# ---------------------------------------------------------------------------
+
+def save_binary_mask(
+    prob_map: np.ndarray,
     save_path: Path,
     threshold: float = 0.5,
 ) -> None:
-    """Save binary change mask as an image.
+    """Binarise a probability map and save as a PNG.
 
     Args:
-        mask: Probability map [H, W] with values in [0, 1].
-        save_path: Output file path.
-        threshold: Binarization threshold.
+        prob_map: Probability values ``[H, W]`` in ``[0, 1]``.
+        save_path: Destination file path.
+        threshold: Decision threshold.
     """
-    binary = (mask > threshold).astype(np.uint8) * 255
+    binary = (prob_map > threshold).astype(np.uint8) * 255
     save_path.parent.mkdir(parents=True, exist_ok=True)
     cv2.imwrite(str(save_path), binary)
-    logger.info("Saved change mask: %s", save_path)
+    logger.info("Saved binary mask: %s", save_path)
+
+
+def save_overlay(
+    img_b_tensor: torch.Tensor,
+    pred_tensor: torch.Tensor,
+    save_path: Path,
+    threshold: float = 0.5,
+) -> None:
+    """Create and save an overlay visualisation.
+
+    Args:
+        img_b_tensor: After image ``[3, H, W]`` (ImageNet-normalised).
+        pred_tensor: Prediction mask ``[1, H, W]`` (probability).
+        save_path: Destination file path.
+        threshold: Binarisation threshold applied before overlay.
+    """
+    binary_pred = (pred_tensor >= threshold).float()
+    overlay_rgb = overlay_changes(
+        img_after=img_b_tensor,
+        mask_pred=binary_pred,
+        alpha=0.4,
+        color=(255, 0, 0),
+    )
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(str(save_path), cv2.cvtColor(overlay_rgb, cv2.COLOR_RGB2BGR))
+    logger.info("Saved overlay: %s", save_path)
 
 
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
 def main() -> None:
-    """Main inference entry point."""
-    parser = argparse.ArgumentParser(description="Run change detection inference")
-    parser.add_argument("--before", type=Path, required=True, help="Path to before image")
-    parser.add_argument("--after", type=Path, required=True, help="Path to after image")
-    parser.add_argument("--model", type=str, default=None, help="Model name")
-    parser.add_argument("--checkpoint", type=Path, required=True, help="Path to model checkpoint")
-    parser.add_argument("--config", type=Path, default=Path("configs/config.yaml"))
-    parser.add_argument("--output", type=Path, default=Path("outputs/inference"))
-    parser.add_argument("--threshold", type=float, default=0.5)
+    """Entry point — parse CLI args, run inference, save outputs."""
+    parser = argparse.ArgumentParser(
+        description="Run change-detection inference on a before/after image pair",
+    )
+    parser.add_argument(
+        "--before", type=Path, required=True,
+        help="Path to the *before* image.",
+    )
+    parser.add_argument(
+        "--after", type=Path, required=True,
+        help="Path to the *after* image.",
+    )
+    parser.add_argument(
+        "--model", type=str, default=None,
+        help="Model name (overrides config). One of: siamese_cnn, unet_pp, changeformer.",
+    )
+    parser.add_argument(
+        "--checkpoint", type=Path, required=True,
+        help="Path to the model checkpoint (.pth).",
+    )
+    parser.add_argument(
+        "--config", type=Path, default=Path("configs/config.yaml"),
+        help="Path to the YAML configuration file.",
+    )
+    parser.add_argument(
+        "--output", type=Path, default=Path("outputs/inference"),
+        help="Output directory for results.",
+    )
+    parser.add_argument(
+        "--threshold", type=float, default=None,
+        help="Binarisation threshold (default: from config).",
+    )
     args = parser.parse_args()
 
-    logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    # ---- Config -------------------------------------------------------
+    with open(args.config, "r") as fh:
+        config: Dict[str, Any] = yaml.safe_load(fh)
 
-    # Load config
-    with open(args.config, "r") as f:
-        config = yaml.safe_load(f)
+    model_name: str = args.model or config["model"]["name"]
+    threshold: float = args.threshold or config.get("evaluation", {}).get("threshold", 0.5)
+    patch_size: int = config.get("dataset", {}).get("patch_size", 256)
 
-    model_name = args.model or config["model"]["name"]
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    patch_size = config.get("dataset", {}).get("patch_size", 256)
+    logger.info("Device: %s | Model: %s | Threshold: %.2f", device, model_name, threshold)
 
-    # Load model
+    # ---- Load model ---------------------------------------------------
     model = get_model(model_name, config).to(device)
     ckpt = torch.load(args.checkpoint, map_location=device)
     model.load_state_dict(ckpt["model_state_dict"])
-    logger.info("Loaded model '%s' from %s", model_name, args.checkpoint)
-
-    # Preprocess images
-    img_a, (orig_h, orig_w) = preprocess_image(args.before, patch_size)
-    img_b, _ = preprocess_image(args.after, patch_size)
-
-    # Run inference
+    logger.info(
+        "Loaded checkpoint: %s (epoch %d)",
+        args.checkpoint, ckpt.get("epoch", -1),
+    )
+
+    # ---- Preprocess images --------------------------------------------
+    img_a, (orig_h, orig_w) = load_and_preprocess(args.before, patch_size)
+    img_b, (orig_h_b, orig_w_b) = load_and_preprocess(args.after, patch_size)
+
+    if (orig_h, orig_w) != (orig_h_b, orig_w_b):
+        logger.warning(
+            "Image sizes differ: before=(%d,%d) after=(%d,%d). "
+            "Using before dimensions for cropping.",
+            orig_h, orig_w, orig_h_b, orig_w_b,
+        )
+
+    # ---- Run tiled inference ------------------------------------------
     prob_map = sliding_window_inference(model, img_a, img_b, patch_size, device)
 
-    # Crop back to original size and save
+    # Crop back to original resolution (remove padding)
     prob_map = prob_map[:, :, :orig_h, :orig_w]
-    mask_np = prob_map.squeeze().numpy()
-
-    args.output.mkdir(parents=True, exist_ok=True)
-    save_change_mask(mask_np, args.output / "change_mask.png", args.threshold)
-
-    # Save overlay visualization
-    overlay = overlay_changes(img_b.squeeze()[:, :orig_h, :orig_w], prob_map.squeeze(0))
-    overlay_uint8 = (overlay * 255).astype(np.uint8)
-    cv2.imwrite(str(args.output / "overlay.png"), cv2.cvtColor(overlay_uint8, cv2.COLOR_RGB2BGR))
-    logger.info("Saved overlay: %s", args.output / "overlay.png")
+    prob_np = prob_map.squeeze().numpy()  # [H, W]
+
+    # ---- Compute change statistics ------------------------------------
+    binary_np = (prob_np > threshold).astype(np.float32)
+    total_pixels = orig_h * orig_w
+    changed_pixels = int(binary_np.sum())
+    pct_changed = (changed_pixels / total_pixels) * 100.0
+
+    logger.info("=" * 50)
+    logger.info("  CHANGE DETECTION RESULTS")
+    logger.info("=" * 50)
+    logger.info("  Image size     : %d x %d", orig_w, orig_h)
+    logger.info("  Total pixels   : %d", total_pixels)
+    logger.info("  Changed pixels : %d", changed_pixels)
+    logger.info("  Area changed   : %.2f%%", pct_changed)
+    logger.info("=" * 50)
+
+    # ---- Save outputs -------------------------------------------------
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Binary change mask
+    save_binary_mask(prob_np, output_dir / "change_mask.png", threshold)
+
+    # Overlay visualisation
+    img_b_cropped = img_b.squeeze()[:, :orig_h, :orig_w]  # [3, H, W]
+    pred_cropped = prob_map.squeeze(0)[:, :orig_h, :orig_w]  # [1, H, W]
+    save_overlay(img_b_cropped, pred_cropped, output_dir / "overlay.png", threshold)
+
+    logger.info("All outputs saved to: %s", output_dir)
 
 
 if __name__ == "__main__":