메뉴
Consult MONAI, TorchIO, and nnU-Net documentation and source code for implementation guidance in fastMONAI. Use this skill proactively when implementing new transforms, loss functions, metrics, preprocessing pipelines, or patch-based workflows. Helps ensure fastMONAI implementations align with upstream library patterns and medical imaging best practices.
Proactive code review skill for comprehensive analysis covering code quality, security, and performance. Specialized for Python codebases with fastMONAI/nbdev/medical imaging focus. This skill should be used when Claude detects code changes, new implementations, or when asked to review code quality. Provides flexible output format adapting to context.
Generate Docker Compose and Dockerfile configurations for local development through interactive Q&A. Supports PHP/Laravel, WordPress, Drupal, Joomla, Node.js, and Python stacks with Nginx, Supervisor/PM2, databases, Redis, and email testing. Always asks clarifying questions before generating configurations.
Work with ROR (Research-Information-System) for DICOM data exploration, workflow setup, and series selection in research PACS environments. This skill should be used when exploring medical imaging datasets, setting up processing workflows, querying DICOM series/studies by modality or metadata, or filtering patients/studies for batch processing.
Proactive staff engineer review for technical plans. This skill should be used when Claude detects implementation plans, architecture designs, migration plans, or refactoring proposals to provide senior engineering feedback with a focus on risks, simplicity, and completeness.
| name | fastmonai-upstream-guide |
| description | Consult MONAI, TorchIO, and nnU-Net documentation and source code for implementation guidance in fastMONAI. Use this skill proactively when implementing new transforms, loss functions, metrics, preprocessing pipelines, or patch-based workflows. Helps ensure fastMONAI implementations align with upstream library patterns and medical imaging best practices. |
This skill provides implementation guidance by consulting MONAI, TorchIO, and nnU-Net patterns via live documentation and source code fetching.
Use this skill proactively when:
| fastMONAI Module | Primary Upstream | What to Check |
|---|---|---|
| vision_augmentation | TorchIO | Transform classes, wrapper patterns |
| vision_metrics | MONAI + nnU-Net | Metric functions, accumulated patterns |
| vision_loss | MONAI | Loss class signatures, parameters |
| vision_patch | TorchIO | Queue, Sampler, GridAggregator |
| vision_core | TorchIO | ScalarImage, LabelMap, resampling |
Identify the implementation area
Fetch relevant documentation Use WebFetch to retrieve the appropriate documentation page from the URLs above.
Fetch source code if needed For implementation details, fetch the raw GitHub file to see:
Identify the pattern
Apply to fastMONAI context
nbs/*.ipynb notebooks (not .py files)nbdev_prepare after changesAll transform wrappers must expose .tio_transform property:
class MyTransform(DictTransform):
def __init__(self, ...):
self._transform = tio.SomeTransform(...)
@property
def tio_transform(self):
return self._transform
Always use padding_mode=0 (zero padding) for CropOrPad - this aligns with nnU-Net standards:
tio.CropOrPad(target_size, padding_mode=0) # Correct
tio.CropOrPad(target_size) # Avoid - uses TorchIO default
For patch-based training, use accumulated TP/FP/FN rather than per-batch averaging:
class AccumulatedDice(Metric):
# Accumulates across batches, not averages
Architecture: The nnunetv2/ package is organized into: preprocessing, training, inference, evaluation, experiment_planning, postprocessing, utilities.
Normalization schemes (in default_normalization_schemes.py):
ZScoreNormalization - z-score with optional foreground masking (default for MR)CTNormalization - clip to 0.5th-99.5th percentiles then z-score (for CT)NoNormalization - passthrough (dtype conversion only)RescaleTo01Normalization - min-max to [0,1]RGBTo01Normalization - divide uint8 by 255Loss functions (in training/loss/):
SoftDiceLoss(apply_nonlin, batch_dice, do_bg, smooth=1.0, ddp, clip_tp) - standard soft DiceMemoryEfficientSoftDiceLoss - same API, ~1.6GB less memory via no-grad one-hot encodingDC_and_CE_loss(soft_dice_kwargs, ce_kwargs, weight_ce=1, weight_dice=1, ignore_label) - Dice + Cross-Entropy (default nnU-Net loss)DC_and_BCE_loss(bce_kwargs, soft_dice_kwargs, weight_ce=1, weight_dice=1) - Dice + Binary CEDC_and_topk_loss(soft_dice_kwargs, ce_kwargs, weight_ce=1, weight_dice=1) - Dice + TopKEvaluation metrics (in evaluation/evaluate_predictions.py):
compute_tp_fp_fn_tn(mask_ref, mask_pred, ignore_mask) - core confusion matrixcompute_metrics(reference_file, prediction_file, image_reader_writer, labels_or_regions, ignore_label) - per-file metricscompute_metrics_on_folder() / compute_metrics_on_folder_simple() - batch evaluation with multiprocessingSliding window inference (in inference/sliding_window_prediction.py):
compute_steps_for_sliding_window(image_size, tile_size, tile_step_size) - tile_step_size is 0-1 (0.5 = 50% overlap)compute_gaussian(tile_size) - Gaussian importance weighting for smooth tile aggregation (center-weighted, no zeros)Trainer variants (in training/nnUNetTrainer/variants/):
Subdirectories for: benchmarking, data_augmentation, loss, lr_schedule, network_architecture, optimizer, sampling, training_length
nbs/*.ipynbnbdev_prepare to regenerate .py files and run testsfastMONAI/*.py directlyWhen implementing, fetch relevant docs/code:
"I need to implement a new spatial transform" → Fetch TorchIO spatial transform docs and source
"What's the signature for MONAI's compute_dice?" → Fetch MONAI metrics documentation
"How does nnU-Net handle validation metrics?" → Fetch nnU-Net v2 evaluation code for TP/FP/FN accumulation patterns
"What loss does nnU-Net v2 use by default?" → Fetch compound_losses.py for DC_and_CE_loss (Dice + Cross-Entropy)
"How does nnU-Net v2 do sliding window inference?" → Fetch sliding_window_prediction.py for tile stepping and Gaussian weighting
"What normalization does nnU-Net v2 use for MR images?" → Fetch default_normalization_schemes.py for ZScoreNormalization
"I want to add a new loss function" → Fetch MONAI losses documentation and nnU-Net v2 compound_losses.py
To check upstream implementations during development:
# TorchIO transform documentation
WebFetch: https://torchio.readthedocs.io/transforms/augmentation.html
# MONAI metric implementation
WebFetch: https://raw.githubusercontent.com/Project-MONAI/MONAI/dev/monai/metrics/meandice.py
# nnU-Net v2 usage guide
WebFetch: https://github.com/MIC-DKFZ/nnUNet/blob/master/documentation/how_to_use_nnunet.md
# nnU-Net v2 normalization schemes (ZScore, CT, RescaleTo01, etc.)
WebFetch: https://raw.githubusercontent.com/MIC-DKFZ/nnUNet/master/nnunetv2/preprocessing/normalization/default_normalization_schemes.py
# nnU-Net v2 default loss (Dice + CE compound)
WebFetch: https://raw.githubusercontent.com/MIC-DKFZ/nnUNet/master/nnunetv2/training/loss/compound_losses.py
# nnU-Net v2 Dice loss implementation
WebFetch: https://raw.githubusercontent.com/MIC-DKFZ/nnUNet/master/nnunetv2/training/loss/dice.py
# nnU-Net v2 evaluation metrics (Dice, IoU, TP/FP/FN)
WebFetch: https://raw.githubusercontent.com/MIC-DKFZ/nnUNet/master/nnunetv2/evaluation/evaluate_predictions.py
# nnU-Net v2 sliding window inference (Gaussian weighting)
WebFetch: https://raw.githubusercontent.com/MIC-DKFZ/nnUNet/master/nnunetv2/inference/sliding_window_prediction.py
# nnU-Net v2 base trainer (training loop, validation, scheduling)
WebFetch: https://raw.githubusercontent.com/MIC-DKFZ/nnUNet/master/nnunetv2/training/nnUNetTrainer/nnUNetTrainer.py
# nnU-Net v2 extending guide (custom trainers, architectures)
WebFetch: https://github.com/MIC-DKFZ/nnUNet/blob/master/documentation/extending_nnunet.md