model and lightning module

lightning_module.py

@@ -1,165 +0,0 @@
-"""
-PyTorch Lightning modules for roof segmentation.
-"""
-import torch
-import torch.nn as nn
-import pytorch_lightning as pl
-from torch.utils.data import DataLoader
-from typing import Dict, Any, Optional
-
-from utils.dataset import create_dataloaders
-from utils.losses import DiceBCELoss
-from utils.metrics import get_segmentation_metrics
-from utils.models import get_unet_model
-from config import (
-    TRAIN_IMAGES_DIR, TRAIN_MASKS_DIR,
-    VALID_IMAGES_DIR, VALID_MASKS_DIR,
-    TRAINING_CONFIG
-)
-
-
-class SegmentationLightningModule(pl.LightningModule):
-    """Lightning module for segmentation training."""
-    
-    def __init__(self, config: Dict[str, Any]):
-        super().__init__()
-        self.save_hyperparameters(config)
-        self.config = config
-        
-        # Model
-        self.model = get_unet_model(
-            n_channels=config["in_channels"],
-            n_classes=config["classes"],
-            base_channels=config.get("base_channels", 32),
-            bilinear=config.get("bilinear", True)
-        )
-        
-        # Loss function
-        self.criterion = DiceBCELoss(
-            dice_weight=config["dice_weight"],
-            bce_weight=config["bce_weight"]
-        )
-        
-        # Metrics
-        self.train_metrics = get_segmentation_metrics()
-        self.val_metrics = get_segmentation_metrics()
-        
-    def forward(self, x):
-        return self.model(x)
-    
-    def training_step(self, batch, batch_idx):
-        images = batch['image']
-        masks = batch['mask']
-        
-        # Ensure masks have the right dimensions [B, 1, H, W]
-        if masks.dim() == 3:
-            masks = masks.unsqueeze(1)  # Add channel dimension
-        
-        outputs = self(images)
-        loss = self.criterion(outputs, masks)
-        
-        # Calculate metrics
-        preds_sigmoid = torch.sigmoid(outputs)
-        
-        # For torchmetrics, we need to squeeze the channel dimension and convert to binary
-        masks_squeezed = masks.squeeze(1)  # [B, H, W]
-        preds_squeezed = preds_sigmoid.squeeze(1)  # [B, H, W]
-        
-        # Update metrics
-        self.train_metrics.update(preds_squeezed, masks_squeezed.int())
-        
-        # Log metrics
-        self.log('train_loss', loss, on_step=True, on_epoch=True, prog_bar=True)
-        
-        return loss
-    
-    def on_train_epoch_end(self):
-        # Log training metrics
-        computed_metrics = self.train_metrics.compute()
-        for name, value in computed_metrics.items():
-            self.log(f'train_{name}', value, on_epoch=True, prog_bar=True)
-        self.train_metrics.reset()
-    
-    def validation_step(self, batch, batch_idx):
-        images = batch['image']
-        masks = batch['mask']
-        
-        # Ensure masks have the right dimensions [B, 1, H, W]
-        if masks.dim() == 3:
-            masks = masks.unsqueeze(1)  # Add channel dimension
-        
-        outputs = self(images)
-        loss = self.criterion(outputs, masks)
-        
-        # Calculate metrics
-        preds_sigmoid = torch.sigmoid(outputs)
-        
-        # For torchmetrics, we need to squeeze the channel dimension and convert to binary
-        masks_squeezed = masks.squeeze(1)  # [B, H, W]
-        preds_squeezed = preds_sigmoid.squeeze(1)  # [B, H, W]
-        
-        # Update metrics
-        self.val_metrics.update(preds_squeezed, masks_squeezed.int())
-        
-        # Log metrics
-        self.log('val_loss', loss, on_step=False, on_epoch=True, prog_bar=True)
-        
-        return loss
-    
-    def on_validation_epoch_end(self):
-        # Log validation metrics
-        computed_metrics = self.val_metrics.compute()
-        for name, value in computed_metrics.items():
-            self.log(f'val_{name}', value, on_epoch=True, prog_bar=True)
-        self.val_metrics.reset()
-    
-    def configure_optimizers(self):
-        optimizer = torch.optim.AdamW(
-            self.parameters(),
-            lr=self.config["learning_rate"],
-            weight_decay=self.config["weight_decay"]
-        )
-        
-        scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
-            optimizer,
-            mode='min',
-            patience=self.config["reduce_lr_patience"],
-            factor=self.config["reduce_lr_factor"],
-        )
-        
-        return {
-            "optimizer": optimizer,
-            "lr_scheduler": {
-                "scheduler": scheduler,
-                "monitor": "val_loss",
-                "frequency": 1
-            }
-        }
-
-
-class SegmentationDataModule(pl.LightningDataModule):
-    """Lightning data module for segmentation."""
-    
-    def __init__(self, config: Dict[str, Any]):
-        super().__init__()
-        self.config = config
-        self.train_loader = None
-        self.val_loader = None
-        
-    def setup(self, stage: Optional[str] = None):
-        if stage == "fit" or stage is None:
-            self.train_loader, self.val_loader = create_dataloaders(
-                train_images_dir=TRAIN_IMAGES_DIR,
-                train_masks_dir=TRAIN_MASKS_DIR,
-                val_images_dir=VALID_IMAGES_DIR,
-                val_masks_dir=VALID_MASKS_DIR,
-                batch_size=self.config["batch_size"],
-                num_workers=self.config["num_workers"],
-                image_size=self.config["image_size"]
-            )
-    
-    def train_dataloader(self):
-        return self.train_loader
-    
-    def val_dataloader(self):
-        return self.val_loader

model_and_lightning_module.py

@@ -0,0 +1,152 @@
+"""
+PyTorch Lightning modules for roof segmentation.
+"""
+from typing import Any, Dict
+
+import pytorch_lightning as pl
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class DoubleConv(nn.Module):
+    """Double convolution block: (conv => BN => ReLU) * 2"""
+    
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+        self.double_conv = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True)
+        )
+    
+    def forward(self, x):
+        return self.double_conv(x)
+
+
+class Down(nn.Module):
+    """Downscaling with maxpool then double conv"""
+    
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+        self.maxpool_conv = nn.Sequential(
+            nn.MaxPool2d(2),
+            DoubleConv(in_channels, out_channels)
+        )
+    
+    def forward(self, x):
+        return self.maxpool_conv(x)
+
+
+class Up(nn.Module):
+    """Upscaling then double conv"""
+    
+    def __init__(self, in_channels, out_channels, bilinear=True):
+        super().__init__()
+        
+        # Use bilinear upsampling or transpose convolution
+        if bilinear:
+            self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
+            self.conv = DoubleConv(in_channels, out_channels)
+        else:
+            self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
+            self.conv = DoubleConv(in_channels, out_channels)
+    
+    def forward(self, x1, x2):
+        x1 = self.up(x1)
+        
+        # Input is CHW
+        diffY = x2.size()[2] - x1.size()[2]
+        diffX = x2.size()[3] - x1.size()[3]
+        
+        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
+                        diffY // 2, diffY - diffY // 2])
+        
+        # Concatenate along channel dimension
+        x = torch.cat([x2, x1], dim=1)
+        return self.conv(x)
+
+
+class OutConv(nn.Module):
+    """Output convolution"""
+    
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
+    
+    def forward(self, x):
+        return self.conv(x)
+
+
+class UNet(nn.Module):
+    """Simple U-Net implementation with configurable base channels"""
+    
+    def __init__(self, n_channels=3, n_classes=1, base_channels=32, bilinear=True):
+        super().__init__()
+        self.n_channels = n_channels
+        self.n_classes = n_classes
+        self.bilinear = bilinear
+        
+        # Use configurable base channels (default 32 instead of 64)
+        c = base_channels
+        
+        # Encoder (downsampling path)
+        self.inc = DoubleConv(n_channels, c)
+        self.down1 = Down(c, c*2)
+        self.down2 = Down(c*2, c*4)
+        self.down3 = Down(c*4, c*8)
+        factor = 2 if bilinear else 1
+        self.down4 = Down(c*8, c*16 // factor)
+        
+        # Decoder (upsampling path)
+        self.up1 = Up(c*16, c*8 // factor, bilinear)
+        self.up2 = Up(c*8, c*4 // factor, bilinear)
+        self.up3 = Up(c*4, c*2 // factor, bilinear)
+        self.up4 = Up(c*2, c, bilinear)
+        self.outc = OutConv(c, n_classes)
+    
+    def forward(self, x):
+        # Encoder
+        x1 = self.inc(x)
+        x2 = self.down1(x1)
+        x3 = self.down2(x2)
+        x4 = self.down3(x3)
+        x5 = self.down4(x4)
+        
+        # Decoder with skip connections
+        x = self.up1(x5, x4)
+        x = self.up2(x, x3)
+        x = self.up3(x, x2)
+        x = self.up4(x, x1)
+        logits = self.outc(x)
+        return logits
+
+
+def get_unet_model(n_channels=3, n_classes=1, base_channels=32, bilinear=True):
+    """
+    Create a U-Net model.
+    
+    Args:
+        n_channels: Number of input channels
+        n_classes: Number of output classes
+        base_channels: Base number of channels (32 = lighter, 64 = standard)
+        bilinear: Use bilinear upsampling
+    """
+    return UNet(n_channels=n_channels, n_classes=n_classes, base_channels=base_channels, bilinear=bilinear)
+
+
+class SegmentationLightningModule(pl.LightningModule):
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__()
+        self.model = get_unet_model(
+            n_channels=config["in_channels"],
+            n_classes=config["classes"],
+            base_channels=config.get("base_channels", 32),
+            bilinear=config.get("bilinear", True)
+        )
+
+    def forward(self, x):
+        return self.model(x)