Fix notebook: use HuggingFace datasets CDN instead of flaky Google Drive links

train_change_detection_model.ipynb

@@ -1,586 +1,625 @@
 {
- "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",
-    "**Run in Google Colab** with a GPU runtime (Runtime → Change runtime type → T4 GPU).\n",
-    "\n",
-    "Training takes ~2-3 hours on a free T4."
-   ]
+  "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",
+        "**Run in Google Colab** with a GPU runtime (Runtime → Change runtime type → T4 GPU).\n",
+        "\n",
+        "Training takes ~2-3 hours on a free T4."
+      ]
+    },
+    {
+      "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 = 8\n",
+        "train_dl = DataLoader(train_ds, batch_size=BATCH, shuffle=True, num_workers=2, pin_memory=True)\n",
+        "val_dl = DataLoader(val_ds, batch_size=BATCH, shuffle=False, num_workers=2, pin_memory=True)\n",
+        "test_dl = DataLoader(test_ds, batch_size=BATCH, shuffle=False, num_workers=2, pin_memory=True)\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** (ResNet34, ImageNet pretrained) processes both images\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",
+        "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=\"resnet34\", pretrained=True):\n",
+        "        super().__init__()\n",
+        "        # Build a standard U-Net to reuse its encoder and decoder pieces\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",
+        "        # The decoder expects concatenated features (2x channels at each level)\n",
+        "        encoder_channels = self.encoder.out_channels  # e.g. (3,64,64,128,256,512)\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",
+        "        # Shared encoder for both temporal images\n",
+        "        feats_a = self.encoder(img_a)\n",
+        "        feats_b = self.encoder(img_b)\n",
+        "\n",
+        "        # Concatenate features at every level\n",
+        "        feats_cat = [torch.cat([fa, fb], dim=1) for fa, fb in zip(feats_a, feats_b)]\n",
+        "\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=\"resnet34\", 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\")"
+      ],
+      "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": [
+        "from tqdm.auto import tqdm\n",
+        "\n",
+        "NUM_EPOCHS = 50\n",
+        "LR = 1e-4\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",
+        "\n",
+        "for epoch in range(1, NUM_EPOCHS + 1):\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",
+        "    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",
+        "    )\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",
+        "print(f\"\\nTraining complete. 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"
+    }
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. Install Dependencies"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install -q torch torchvision segmentation-models-pytorch albumentations gdown tqdm matplotlib"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Download LEVIR-CD Dataset\n",
-    "\n",
-    "LEVIR-CD contains 637 pairs of 1024×1024 Google Earth images with pixel-level\n",
-    "building change annotations. We download the pre-cut 256×256 patch version."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os, zipfile, gdown\n",
-    "\n",
-    "DATA_ROOT = \"./levir_cd_256\"\n",
-    "\n",
-    "if not os.path.isdir(DATA_ROOT):\n",
-    "    # LEVIR-CD 256x256 patches (hosted mirror)\n",
-    "    url = \"https://drive.google.com/uc?id=1RUFY5Z4Bf5LAoYXC8Iq9k5GloJmVDmfF\"\n",
-    "    zip_path = \"levir_cd_256.zip\"\n",
-    "    print(\"Downloading LEVIR-CD 256×256 patches (~540 MB)...\")\n",
-    "    gdown.download(url, zip_path, quiet=False)\n",
-    "    print(\"Extracting...\")\n",
-    "    with zipfile.ZipFile(zip_path, \"r\") as z:\n",
-    "        z.extractall(\".\")\n",
-    "    os.remove(zip_path)\n",
-    "    print(\"Done. Dataset at:\", DATA_ROOT)\n",
-    "else:\n",
-    "    print(\"Dataset already present at\", DATA_ROOT)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Dataset & DataLoader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "from PIL import Image\n",
-    "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 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",
-    "            # Apply same spatial transform to all three\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 = 8\n",
-    "train_dl = DataLoader(train_ds, batch_size=BATCH, shuffle=True, num_workers=2, pin_memory=True)\n",
-    "val_dl = DataLoader(val_ds, batch_size=BATCH, shuffle=False, num_workers=2, pin_memory=True)\n",
-    "test_dl = DataLoader(test_ds, batch_size=BATCH, shuffle=False, num_workers=2, pin_memory=True)\n",
-    "\n",
-    "print(f\"Train: {len(train_ds)}, Val: {len(val_ds)}, Test: {len(test_ds)}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Siamese U-Net Model\n",
-    "\n",
-    "Architecture:\n",
-    "- **Shared encoder** (ResNet34, ImageNet pretrained) processes both images\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",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import segmentation_models_pytorch as smp\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=\"resnet34\", pretrained=True):\n",
-    "        super().__init__()\n",
-    "        # Build a standard U-Net to reuse its encoder and decoder pieces\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",
-    "        # The decoder expects concatenated features (2x channels at each level)\n",
-    "        encoder_channels = self.encoder.out_channels  # e.g. (3,64,64,128,256,512)\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",
-    "        # Shared encoder for both temporal images\n",
-    "        feats_a = self.encoder(img_a)\n",
-    "        feats_b = self.encoder(img_b)\n",
-    "\n",
-    "        # Concatenate features at every level\n",
-    "        feats_cat = [torch.cat([fa, fb], dim=1) for fa, fb in zip(feats_a, feats_b)]\n",
-    "\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=\"resnet34\", 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\")"
-   ]
-  },
-  {
-   "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",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. Training Loop"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from tqdm.auto import tqdm\n",
-    "\n",
-    "NUM_EPOCHS = 50\n",
-    "LR = 1e-4\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",
-    "\n",
-    "for epoch in range(1, NUM_EPOCHS + 1):\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",
-    "    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",
-    "    )\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",
-    "print(f\"\\nTraining complete. Best val F1: {best_f1:.4f}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Training Curves"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 8. Evaluate on Test Set"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 9. Visualize Predictions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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()"
-   ]
-  },
-  {
-   "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",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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.\")"
-   ]
-  },
-  {
-   "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",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.11.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
+  "nbformat": 4,
+  "nbformat_minor": 4
+}