未用预训练骨干的DeeplabV3+ 3D CT分割DSC偏低原因及优化咨询

Hey there, let's break down why your 3D DeeplabV3+ is hitting only ~0.6 DSC and how to fix it—your setup has several constraints (small dataset, limited GPU memory, no pretrained backbone) that we can work around with targeted tweaks:

1. Supercharge Your Data (Since 20 Cases Is Tiny) #

The biggest bottleneck here is your small dataset—20 cases is nowhere near enough for a 3D model to generalize. Let's squeeze every bit of value out of it:

• CT-specific normalization: Don't skip this! CT scans use HU values—first truncate them to a clinically relevant range (e.g., -1000 to 2000 to focus on soft tissue and bones), then normalize to mean 0 and std 1. This ensures your model isn't distracted by irrelevant intensity variations.
• 3D-aware augmentations: Stick to transforms that preserve anatomical structure (use libraries like monai or torchio for built-in 3D support):
  • Random flips (along axial, coronal, sagittal axes—avoid flipping if targets have left-right asymmetry unless you account for it)
  • Small-angle rotations (max 10-15 degrees; larger rotations warp anatomy beyond recognition)
  • Gentle elastic deformations
  • Gamma correction (randomly adjust intensity contrast to handle scanner variations)
• Smart patch sampling: Prioritize patches containing small/rare targets. Assign higher sampling weights to patches where a rare class occupies >5% of pixels—this prevents your model from ignoring tiny structures.

2. Adapt the 3D DeeplabV3+ to Your Patch Size #

Converting 2D layers to 3D isn't enough—your shallow patch depth (16 slices) requires structural tweaks:

• Simplify the backbone: Without pretrained ResNet3D, a heavy backbone will overfit quickly and eat memory. Swap ResNet50 for a lighter 3D variant like ResNet18 3D, or use a depth-separable 3D convolution backbone (e.g., MobileNetV3 3D) to cut parameters while retaining performance.
• Tweak the ASPP module: Standard ASPP uses large dilation rates (6,12,18) that work for 2D, but in 3D with 16-slice depth, dilation rates >2 in the z-axis cause invalid padding. Reduce depth-axis dilation rates—try (1,6,6), (2,12,12) instead of uniform dilation across all axes.
• Align decoder skip connections: Ensure depth dimensions match when merging encoder/decoder features. Use nn.Upsample(mode='trilinear') instead of transposed convolution for stable upsampling of small depth sizes.

3. Adjust Training for Small Batch Size & No Pretraining #

A batch size of 2 makes SGD unstable—let's fix that:

• Gradient accumulation: Accumulate gradients over 4-8 batches before updating weights. This simulates a larger batch size (e.g., 2*4=8) without extra VRAM. In PyTorch, skip optimizer.zero_grad() every step, accumulate gradients, then call loss.backward() and optimizer.step() after the desired number of steps.
• Lower learning rate + scheduling: 3D models need smaller learning rates than 2D—start with 0.001 for SGD instead of 0.01. Pair with a cosine annealing scheduler or step decay (multiply by 0.1 every 50 epochs) to avoid plateauing. Add a warmup phase: train the first 5-10 epochs with 10% of your target learning rate to stabilize training.
• Proper 3D initialization: Since you have no pretrained weights, use He initialization (nn.init.kaiming_normal_) for nn.Conv3d layers, and initialize batch norm weights to 1, biases to 0. This helps the model learn from scratch more effectively.

4. Fight Overfitting Aggressively #

With 20 cases, overfitting is almost guaranteed—add these safeguards:

• Weight decay: Add a weight decay of 1e-4 to your SGD optimizer:

  optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-4)
  

  This penalizes large weights and prevents memorizing noise.
• 3D DropBlock: Replace standard Dropout with DropBlock for 3D convolutions. It randomly drops contiguous feature blocks, which is more effective for spatial data. Use a small block size (3x3x3) and probability around 0.1-0.2.
• Label smoothing: Modify your CrossEntropy loss to use label smoothing (epsilon=0.1) to reduce overconfidence in hard labels. In PyTorch:

  ce_loss = torch.nn.CrossEntropyLoss(label_smoothing=0.1)
  

5. Refine Your Loss Function for Multi-Target Segmentation #

Dice + CE is a good start, but you can balance it better:

• Adjust loss ratios: Experiment with different weights for Dice and CE. For example:

  loss = 0.5 * dice_loss + 0.5 * ce_loss
  

  Dice excels at imbalanced targets, while CE helps with boundary learning—tune the ratio based on your target sizes.
• Class-weighted loss: Assign higher weights to small/rare classes (inverse of their frequency in the dataset). Apply these weights to both Dice and CE loss to ensure the model doesn't ignore tiny structures.
• Try Focal Loss: Replace CE with Focal Loss to downweight easy-to-classify pixels (like background) and focus on hard cases (boundaries, small targets). Start with a gamma parameter of 2.0.

6. Improve Inference to Boost Final DSC #

Even a well-trained model can underperform with poor inference:

• Sliding window with overlap: Use a sliding window with 50% overlap in all axes. Average predictions in overlapping regions to reduce patch boundary artifacts.
• Post-processing: Apply connected component analysis to filter out noisy small predictions. For each target class, keep only the largest connected component (or components above an anatomy-specific size threshold). Libraries like scipy.ndimage or monai have tools for this.

Start with data preprocessing/augmentation and gradient accumulation first—these are the lowest-hanging fruits. Iterate on model structure and loss tweaks next, and you should see steady improvements in DSC.

内容的提问来源于stack exchange，提问作者Hedwig Huang