Loading...
Loading...
Use this skill when implementing or evaluating image segmentation in PyTorch. Triggers include "implement semantic segmentation", "which loss function for segmentation", "compute mIoU in PyTorch", "set up a UNet with segmentation_models_pytorch", "evaluate segmentation with torchmetrics", "my Dice score is wrong", "class imbalance in segmentation", "multi-class segmentation evaluation", or "benchmark segmentation models". Handles architecture selection, loss functions, metric computation, data pipelines, and evaluation protocol. Do not use for instance segmentation benchmarks like COCO — use a separate detection skill.
npx skill4agent add vios-s/vios-research-skills pytorch-segmentationtorchmetricsalbumentationssegmentation_models_pytorchmmsegmentationmonaisegmentation_models_pytorchimport segmentation_models_pytorch as smp
model = smp.Unet(
encoder_name="resnet50", # or "efficientnet-b4", "mit_b2" (SegFormer encoder)
encoder_weights="imagenet", # None to train from scratch
in_channels=1, # 1 for grayscale (MRI, X-ray), 3 for RGB
classes=4, # number of output classes including background
activation=None, # return logits; apply softmax/sigmoid outside
)| Architecture | When to use |
|---|---|
| Default for medical imaging; strong skip connections for fine detail |
| Natural images; ASPP captures multi-scale context |
| Large datasets; transformer encoder; best ImageNet transfer |
| Multi-scale attention; useful when object scales vary |
| 3D volumetric segmentation (CT, MRI volumes) |
monaiimport segmentation_models_pytorch as smp
# Recommended default: Dice + BCE combo
loss_fn = smp.losses.DiceLoss(mode="binary") + smp.losses.SoftBCEWithLogitsLoss()
# Focal loss: better when foreground is very rare (<5% of pixels)
loss_fn = smp.losses.FocalLoss(mode="binary", alpha=0.25, gamma=2.0)# Dice loss averaged over classes (macro) — treats all classes equally
loss_fn = smp.losses.DiceLoss(mode="multiclass", classes=None) # None = all classes
# Ignore index for unlabelled pixels (common in cityscapes-style datasets)
loss_fn = smp.losses.DiceLoss(mode="multiclass", ignore_index=255)
# Tversky loss: control FP/FN trade-off (alpha=FP weight, beta=FN weight)
loss_fn = smp.losses.TverskyLoss(mode="multiclass", alpha=0.3, beta=0.7)
# alpha < 0.5 = penalise FP more; beta > 0.5 = penalise FN more
# Use alpha=0.3, beta=0.7 when missing a positive (FN) is clinically worseDiceLoss1 - Dicetorchmetricstorchmetricsfrom torchmetrics.segmentation import MeanIoU
from torchmetrics import Dice
dice_metric = Dice(num_classes=1, threshold=0.5).to(device)
iou_metric = MeanIoU(num_classes=2).to(device) # 2 = background + foreground
# Inside eval loop:
preds = torch.sigmoid(logits) # (B, 1, H, W) — probabilities
preds_binary = (preds > 0.5).long() # (B, 1, H, W) — binary
dice_metric.update(preds_binary, masks)
iou_metric.update(preds_binary, masks)
# After all batches:
print(dice_metric.compute()) # scalar — accumulated over full dataset
print(iou_metric.compute()) # scalar — accumulated over full dataset
dice_metric.reset()
iou_metric.reset()from torchmetrics.segmentation import MeanIoU
# num_classes includes background
miou_metric = MeanIoU(num_classes=num_classes, per_class=True).to(device)
preds_class = logits.argmax(dim=1) # (B, H, W) — class indices
miou_metric.update(preds_class, masks) # masks: (B, H, W) — class indices
per_class_iou = miou_metric.compute() # tensor of shape (num_classes,)
miou = per_class_iou.mean() # scalar mean IoU
miou_metric.reset()| Context | Primary metric |
|---|---|
| Medical imaging (binary or few classes) | Dice coefficient |
| Computer vision benchmarks (ADE20K, Cityscapes, Pascal VOC) | mIoU |
| MICCAI challenges | Usually Dice; check the challenge page |
| Both audiences | Report both |
IoU = Dice / (2 - Dice)import albumentations as A
from albumentations.pytorch import ToTensorV2
train_transform = A.Compose([
A.RandomResizedCrop(height=512, width=512, scale=(0.5, 1.0)),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.3), # skip for MRI — intensity is clinically meaningful
A.Normalize(mean=[0.485, 0.456, 0.406], # ImageNet stats for RGB; use dataset stats otherwise
std=[0.229, 0.224, 0.225]),
ToTensorV2(),
])
val_transform = A.Compose([
A.Resize(512, 512),
A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2(),
])mask=maskA.Normalize(mean=0, std=1)optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)
for epoch in range(num_epochs):
model.train()
for images, masks in train_loader:
images, masks = images.to(device), masks.to(device)
logits = model(images)
loss = loss_fn(logits, masks)
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
model.eval()
with torch.no_grad():
for images, masks in val_loader:
images, masks = images.to(device), masks.to(device)
logits = model(images)
preds = logits.argmax(dim=1)
miou_metric.update(preds, masks)
val_miou = miou_metric.compute()
miou_metric.reset()accumulation_steps = 4
optimizer.zero_grad()
for i, (images, masks) in enumerate(train_loader):
loss = loss_fn(model(images), masks) / accumulation_steps
loss.backward()
if (i + 1) % accumulation_steps == 0:
optimizer.step()
optimizer.zero_grad()torchmetricsboundary_ioutorchmetricstorch.nn.CrossEntropyLosssoftmaxsmp.losses.DiceLosssoftmaxargmaxcardiac-mri-analysisfairness-medical-imagingmedical-image-synthesis