Upload lightning_module.py

lightning_module.py

@@ -0,0 +1,165 @@
+"""
+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