Phase 2.2-2.3: Remove dummy validation dataset and make deep supervision configurable

Changes:
1. Phase 2.2: Remove dummy validation dataset workaround (lit_data.py)
   - Replaced DummyDataset with proper warning when validation fails
   - More honest error handling instead of masking configuration issues

2. Phase 2.3: Make hardcoded deep supervision values configurable (hydra_config.py, lit_model.py)
   - Added ModelConfig fields:
     * deep_supervision_weights (default: [1.0, 0.5, 0.25, 0.125, 0.0625])
     * deep_supervision_clamp_min (default: -20.0)
     * deep_supervision_clamp_max (default: 20.0)
   - Updated lit_model.py to use configurable values in 3 locations:
     * Multi-task output clamping
     * Deep supervision output clamping
     * Deep supervision scale weights with validation

Benefits:
- Users can now customize deep supervision behavior without code changes
- Removes technical debt items #2 and #4 from REFACTORING_PLAN.md
- Better error handling for missing validation data

Author: claude

connectomics/config/hydra_config.py

@@ -182,6 +182,9 @@ class ModelConfig:
 
     # Deep supervision (supported by MedNeXt, RSUNet, and some MONAI models)
     deep_supervision: bool = False
+    deep_supervision_weights: Optional[List[float]] = None  # None = auto: [1.0, 0.5, 0.25, 0.125, 0.0625]
+    deep_supervision_clamp_min: float = -20.0  # Clamp logits to prevent numerical instability
+    deep_supervision_clamp_max: float = 20.0   # Especially important at coarser scales
 
     # Loss configuration
     loss_functions: List[str] = field(default_factory=lambda: ["DiceLoss", "BCEWithLogitsLoss"])

connectomics/lightning/lit_data.py

@@ -7,8 +7,9 @@
 
 from __future__ import annotations
 from typing import Dict, List, Any, Optional, Union, Tuple
-import numpy as np
+import warnings
 
+import numpy as np
 import torch
 import pytorch_lightning as pl
 from torch.utils.data import DataLoader
@@ -179,29 +180,16 @@ def val_dataloader(self) -> Union[DataLoader, List[DataLoader]]:
             return []
 
         dataloader = self._create_dataloader(self.val_dataset, shuffle=False)
-        if dataloader is None:
-            from torch.utils.data import Dataset
-
-            class DummyDataset(Dataset):
-                def __len__(self):
-                    return 1
 
-                def __getitem__(self, idx):
-                    zero = torch.zeros(1, dtype=torch.float32)
-                    return {
-                        "image": zero,
-                        "label": zero,
-                    }
-
-            return DataLoader(
-                dataset=DummyDataset(),
-                batch_size=1,
-                shuffle=False,
-                num_workers=0,
-                pin_memory=False,
-                persistent_workers=False,
-                collate_fn=self._collate_fn,
+        # If validation dataset exists but dataloader creation failed,
+        # skip validation rather than using dummy data
+        if dataloader is None:
+            warnings.warn(
+                "Validation dataloader creation failed despite validation dataset being provided. "
+                "Skipping validation. Check your data configuration.",
+                UserWarning
             )
+            return []
 
         return dataloader
 

connectomics/lightning/lit_model.py

@@ -1114,7 +1114,9 @@ def _compute_loss_for_scale(
                 # At coarser scales (especially with mixed precision), logits can explode
                 # BCEWithLogitsLoss: clamp to [-20, 20] (sigmoid maps to [2e-9, 1-2e-9])
                 # MSELoss with tanh: clamp to [-10, 10] (tanh maps to [-0.9999, 0.9999])
-                task_output = torch.clamp(task_output, min=-20.0, max=20.0)
+                clamp_min = getattr(self.cfg.model, 'deep_supervision_clamp_min', -20.0)
+                clamp_max = getattr(self.cfg.model, 'deep_supervision_clamp_max', 20.0)
+                task_output = torch.clamp(task_output, min=clamp_min, max=clamp_max)
 
                 # Apply specified losses for this task
                 for loss_idx in loss_indices:
@@ -1142,7 +1144,9 @@ def _compute_loss_for_scale(
         else:
             # Standard deep supervision: apply all losses to all outputs
             # Clamp outputs to prevent numerical instability at coarser scales
-            output_clamped = torch.clamp(output, min=-20.0, max=20.0)
+            clamp_min = getattr(self.cfg.model, 'deep_supervision_clamp_min', -20.0)
+            clamp_max = getattr(self.cfg.model, 'deep_supervision_clamp_max', 20.0)
+            output_clamped = torch.clamp(output, min=clamp_min, max=clamp_max)
 
             for loss_fn, weight in zip(self.loss_functions, self.loss_weights):
                 loss = loss_fn(output_clamped, target)
@@ -1191,7 +1195,19 @@ def _compute_deep_supervision_loss(
         main_output = outputs['output']
         ds_outputs = [outputs[f'ds_{i}'] for i in range(1, 5) if f'ds_{i}' in outputs]
 
-        ds_weights = [1.0] + [0.5 ** i for i in range(1, len(ds_outputs) + 1)]
+        # Use configured weights or default exponential decay
+        if hasattr(self.cfg.model, 'deep_supervision_weights') and self.cfg.model.deep_supervision_weights is not None:
+            ds_weights = self.cfg.model.deep_supervision_weights
+            # Ensure we have enough weights for all outputs
+            if len(ds_weights) < len(ds_outputs) + 1:
+                warnings.warn(
+                    f"deep_supervision_weights has {len(ds_weights)} weights but "
+                    f"{len(ds_outputs) + 1} outputs. Using exponential decay for missing weights."
+                )
+                ds_weights = [1.0] + [0.5 ** i for i in range(1, len(ds_outputs) + 1)]
+        else:
+            ds_weights = [1.0] + [0.5 ** i for i in range(1, len(ds_outputs) + 1)]
+
         all_outputs = [main_output] + ds_outputs
 
         total_loss = 0.0