fastMONAI 0.8.0__tar.gz → 0.8.2__tar.gz

{fastmonai-0.8.0/fastMONAI.egg-info → fastmonai-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastMONAI
-Version: 0.8.0
+Version: 0.8.2
 Summary: fastMONAI library
 Home-page: https://github.com/MMIV-ML/fastMONAI
 Author: Satheshkumar Kaliyugarasan

fastmonai-0.8.2/fastMONAI/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.2"

{fastmonai-0.8.0 → fastmonai-0.8.2}/fastMONAI/_modidx.py

@@ -38,6 +38,8 @@ d = { 'settings': { 'branch': 'main',
                                                                                                'fastMONAI/dataset_info.py'),
                                         'fastMONAI.dataset_info.get_class_weights': ( 'dataset_info.html#get_class_weights',
                                                                                       'fastMONAI/dataset_info.py'),
+                                        'fastMONAI.dataset_info.preprocess_dataset': ( 'dataset_info.html#preprocess_dataset',
+                                                                                       'fastMONAI/dataset_info.py'),
                                         'fastMONAI.dataset_info.suggest_patch_size': ( 'dataset_info.html#suggest_patch_size',
                                                                                        'fastMONAI/dataset_info.py')},
             'fastMONAI.external_data': { 'fastMONAI.external_data.MURLs': ('external_data.html#murls', 'fastMONAI/external_data.py'),
@@ -139,6 +141,28 @@ d = { 'settings': { 'branch': 'main',
                                                                                                               'fastMONAI/vision_augmentation.py'),
                                                'fastMONAI.vision_augmentation.CustomDictTransform.tio_transform': ( 'vision_augment.html#customdicttransform.tio_transform',
                                                                                                                     'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation': ( 'vision_augment.html#gpupatchaugmentation',
+                                                                                                       'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation.__call__': ( 'vision_augment.html#gpupatchaugmentation.__call__',
+                                                                                                                'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation.__init__': ( 'vision_augment.html#gpupatchaugmentation.__init__',
+                                                                                                                'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation.__repr__': ( 'vision_augment.html#gpupatchaugmentation.__repr__',
+                                                                                                                'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation._apply_affine': ( 'vision_augment.html#gpupatchaugmentation._apply_affine',
+                                                                                                                     'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation._apply_anisotropy': ( 'vision_augment.html#gpupatchaugmentation._apply_anisotropy',
+                                                                                                                         'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation._apply_blur': ( 'vision_augment.html#gpupatchaugmentation._apply_blur',
+                                                                                                                   'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation._apply_flip': ( 'vision_augment.html#gpupatchaugmentation._apply_flip',
+                                                                                                                   'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation._apply_gamma': ( 'vision_augment.html#gpupatchaugmentation._apply_gamma',
+                                                                                                                    'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation._apply_intensity_scale': ( 'vision_augment.html#gpupatchaugmentation._apply_intensity_scale',
+                                                                                                                              'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.GpuPatchAugmentation._apply_noise': ( 'vision_augment.html#gpupatchaugmentation._apply_noise',
+                                                                                                                    'fastMONAI/vision_augmentation.py'),
                                                'fastMONAI.vision_augmentation.NormalizeIntensity': ( 'vision_augment.html#normalizeintensity',
                                                                                                      'fastMONAI/vision_augmentation.py'),
                                                'fastMONAI.vision_augmentation.NormalizeIntensity.__init__': ( 'vision_augment.html#normalizeintensity.__init__',
@@ -289,10 +313,18 @@ d = { 'settings': { 'branch': 'main',
                                                                                                                     'fastMONAI/vision_augmentation.py'),
                                                'fastMONAI.vision_augmentation._TioRandomIntensityScale.apply_transform': ( 'vision_augment.html#_tiorandomintensityscale.apply_transform',
                                                                                                                            'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation._build_rotation_matrix_3d': ( 'vision_augment.html#_build_rotation_matrix_3d',
+                                                                                                            'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation._compute_patch_aug_params': ( 'vision_augment.html#_compute_patch_aug_params',
+                                                                                                            'fastMONAI/vision_augmentation.py'),
                                                'fastMONAI.vision_augmentation._create_ellipsoid_mask': ( 'vision_augment.html#_create_ellipsoid_mask',
                                                                                                          'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation._foreground_masking': ( 'vision_augment.html#_foreground_masking',
+                                                                                                      'fastMONAI/vision_augmentation.py'),
                                                'fastMONAI.vision_augmentation.do_pad_or_crop': ( 'vision_augment.html#do_pad_or_crop',
                                                                                                  'fastMONAI/vision_augmentation.py'),
+                                               'fastMONAI.vision_augmentation.gpu_patch_augmentations': ( 'vision_augment.html#gpu_patch_augmentations',
+                                                                                                          'fastMONAI/vision_augmentation.py'),
                                                'fastMONAI.vision_augmentation.suggest_patch_augmentations': ( 'vision_augment.html#suggest_patch_augmentations',
                                                                                                               'fastMONAI/vision_augmentation.py')},
             'fastMONAI.vision_core': { 'fastMONAI.vision_core.MedBase': ('vision_core.html#medbase', 'fastMONAI/vision_core.py'),

{fastmonai-0.8.0 → fastmonai-0.8.2}/fastMONAI/dataset_info.py

@@ -1,15 +1,17 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/08_dataset_info.ipynb.
 
 # %% auto #0
-__all__ = ['MedDataset', 'suggest_patch_size', 'get_class_weights']
+__all__ = ['MedDataset', 'suggest_patch_size', 'preprocess_dataset', 'get_class_weights']
 
 # %% ../nbs/08_dataset_info.ipynb #027f016a-a80c-4842-b9dc-0bddb358a00c
 from .vision_core import *
 from .vision_plot import find_max_slice
 
 from sklearn.utils.class_weight import compute_class_weight
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tqdm.auto import tqdm
 from pathlib import Path
+import torchio as tio
 import pandas as pd
 import numpy as np
 import torch
@@ -548,6 +550,144 @@ def suggest_patch_size(
 
     return patch_size
 
+# %% ../nbs/08_dataset_info.ipynb #mbn5svtmzkh
+def preprocess_dataset(df, img_col, mask_col=None, output_dir='preprocessed',
+                       target_spacing=None, apply_reorder=True, transforms=None,
+                       max_workers=4, skip_existing=True):
+    """Preprocess dataset to disk, creating new columns for preprocessed paths.
+
+    Processes images (and optionally masks) through a transform pipeline,
+    saves to output_dir, then creates new '{col}_preprocessed' columns in
+    the DataFrame. Original columns are preserved unchanged.
+
+    Transform pipeline order:
+        CopyAffine (if masks) -> ToCanonical (if apply_reorder)
+        -> Resample (if target_spacing) -> user transforms
+
+    Args:
+        df: DataFrame with file paths.
+        img_col: Column name for image paths.
+        mask_col: Optional column name for mask paths.
+        output_dir: Output directory. Creates images/ and masks/ subdirectories.
+        target_spacing: Target voxel spacing for resampling (e.g., [1.0, 1.0, 1.0]).
+        apply_reorder: Whether to reorder to RAS+ canonical orientation.
+        transforms: Additional TorchIO or fastMONAI transforms to apply after
+            reordering and resampling.
+        max_workers: Number of parallel workers. Each worker loads a full 3D
+            volume into memory, so reduce for large volumes.
+        skip_existing: Skip files that already exist on disk (with size > 0).
+    """
+    # Input validation
+    if len(df) == 0:
+        raise ValueError("DataFrame is empty")
+    if img_col not in df.columns:
+        raise ValueError(f"Column '{img_col}' not found in DataFrame")
+    if mask_col is not None and mask_col not in df.columns:
+        raise ValueError(f"Column '{mask_col}' not found in DataFrame")
+
+    img_names = [Path(p).name for p in df[img_col]]
+    if len(set(img_names)) != len(img_names):
+        dupes = set(n for n in img_names if img_names.count(n) > 1)
+        raise ValueError(f"Duplicate image file names: {dupes}")
+
+    if mask_col is not None:
+        mask_names = [Path(p).name for p in df[mask_col]]
+        if len(set(mask_names)) != len(mask_names):
+            dupes = set(n for n in mask_names if mask_names.count(n) > 1)
+            raise ValueError(f"Duplicate mask file names: {dupes}")
+
+    # Build transform pipeline (canonical order)
+    all_tfms = []
+    if mask_col is not None:
+        all_tfms.append(tio.CopyAffine(target='image'))
+    if apply_reorder:
+        all_tfms.append(tio.ToCanonical())
+    if target_spacing is not None:
+        all_tfms.append(tio.Resample(target_spacing))
+    if transforms:
+        all_tfms.extend([getattr(t, 'tio_transform', t) for t in transforms])
+    pipeline = tio.Compose(all_tfms) if all_tfms else None
+
+    # Create output directories
+    output_dir = Path(output_dir)
+    img_dir = output_dir / 'images'
+    img_dir.mkdir(parents=True, exist_ok=True)
+    if mask_col is not None:
+        mask_dir = output_dir / 'masks'
+        mask_dir.mkdir(parents=True, exist_ok=True)
+
+    # Build work items, filtering skip_existing
+    work_items = []
+    skipped = 0
+    for idx in range(len(df)):
+        img_path = df[img_col].iloc[idx]
+        out_img = img_dir / Path(img_path).name
+
+        mask_path = df[mask_col].iloc[idx] if mask_col is not None else None
+        out_mask = (mask_dir / Path(mask_path).name) if mask_col is not None else None
+
+        if skip_existing:
+            img_ok = out_img.exists() and out_img.stat().st_size > 0
+            mask_ok = out_mask is None or (out_mask.exists() and out_mask.stat().st_size > 0)
+            if img_ok and mask_ok:
+                skipped += 1
+                continue
+
+        work_items.append({
+            'idx': idx, 'img_path': img_path, 'mask_path': mask_path,
+            'out_img': out_img, 'out_mask': out_mask,
+        })
+
+    # Process cases
+    processed = 0
+    failed = 0
+    failed_cases = []
+
+    def _process_case(item):
+        subject_dict = {'image': tio.ScalarImage(item['img_path'])}
+        if item['mask_path'] is not None:
+            subject_dict['mask'] = tio.LabelMap(item['mask_path'])
+
+        subject = tio.Subject(**subject_dict)
+        if pipeline is not None:
+            subject = pipeline(subject)
+
+        # Atomic write: save to temp file (with valid NIfTI extension), then rename
+        out_img = item['out_img']
+        tmp_img = out_img.parent / f'.tmp_{out_img.name}'
+        subject['image'].save(str(tmp_img))
+        os.rename(str(tmp_img), str(out_img))
+
+        if item['out_mask'] is not None:
+            out_mask = item['out_mask']
+            tmp_mask = out_mask.parent / f'.tmp_{out_mask.name}'
+            subject['mask'].save(str(tmp_mask))
+            os.rename(str(tmp_mask), str(out_mask))
+
+    if work_items:
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = {executor.submit(_process_case, item): item for item in work_items}
+            for future in tqdm(as_completed(futures), total=len(futures),
+                               desc='Preprocessing'):
+                item = futures[future]
+                try:
+                    future.result()
+                    processed += 1
+                except Exception as e:
+                    failed += 1
+                    failed_cases.append(Path(item['img_path']).name)
+                    warnings.warn(f"Failed to process {item['img_path']}: {e}")
+
+    # Create new columns for preprocessed paths (preserve originals)
+    df[f'{img_col}_preprocessed'] = [str(img_dir / Path(p).name) for p in df[img_col]]
+
+    if mask_col is not None:
+        df[f'{mask_col}_preprocessed'] = [str(mask_dir / Path(p).name) for p in df[mask_col]]
+
+    print(f"Preprocessing complete: {processed} processed, {skipped} skipped, {failed} failed")
+    if failed_cases:
+        print(f"Failed cases: {failed_cases}")
+
 # %% ../nbs/08_dataset_info.ipynb #9b81f6e8-abd7-4bf6-be4c-4118986c308a
 def get_class_weights(labels: (np.array, list), class_weight: str = 'balanced') -> torch.Tensor: 
     """Calculates and returns the class weights.

{fastmonai-0.8.0 → fastmonai-0.8.2}/fastMONAI/utils.py

@@ -237,6 +237,7 @@ def _extract_patch_config(learn) -> dict:
             'aggregation_mode': patch_config.aggregation_mode,
             'padding_mode': patch_config.padding_mode,
             'keep_largest_component': patch_config.keep_largest_component,
+            'preprocessed': patch_config.preprocessed,
         }
     else:
         config['patch_config'] = None

{fastmonai-0.8.0 → fastmonai-0.8.2}/fastMONAI/vision_augmentation.py

@@ -4,11 +4,14 @@
 __all__ = ['CustomDictTransform', 'do_pad_or_crop', 'PadOrCrop', 'ZNormalization', 'RescaleIntensity', 'NormalizeIntensity',
            'BraTSMaskConverter', 'BinaryConverter', 'RandomGhosting', 'RandomSpike', 'RandomNoise', 'RandomBiasField',
            'RandomBlur', 'RandomGamma', 'RandomIntensityScale', 'RandomMotion', 'RandomAnisotropy', 'RandomCutout',
-           'RandomElasticDeformation', 'RandomAffine', 'RandomFlip', 'OneOf', 'suggest_patch_augmentations']
+           'RandomElasticDeformation', 'RandomAffine', 'RandomFlip', 'OneOf', 'GpuPatchAugmentation',
+           'gpu_patch_augmentations', 'suggest_patch_augmentations']
 
 # %% ../nbs/03_vision_augment.ipynb #2d6694aa
 from fastai.data.all import *
 from .vision_core import *
+import torch.nn.functional as F
+import math
 import torchio as tio
 from monai.transforms import NormalizeIntensity as MonaiNormalizeIntensity
 
@@ -91,6 +94,11 @@ class PadOrCrop(DisplayedTransform):
     def encodes(self, o: (MedImage, MedMask)):
         return type(o)(self.pad_or_crop(o))
 
+# %% ../nbs/03_vision_augment.ipynb #534509q2nn
+def _foreground_masking(tensor):
+    """Mask for non-zero voxels (nnU-Net-style foreground normalization)."""
+    return tensor > 0
+
 # %% ../nbs/03_vision_augment.ipynb #ca95a690
 class ZNormalization(DisplayedTransform):
     """Apply TorchIO `ZNormalization`."""
@@ -98,6 +106,8 @@ class ZNormalization(DisplayedTransform):
     order = 0
 
     def __init__(self, masking_method=None, channel_wise=True):
+        if masking_method == 'foreground':
+            masking_method = _foreground_masking
         self.z_normalization = tio.ZNormalization(masking_method=masking_method)
         self.channel_wise = channel_wise
 
@@ -784,19 +794,19 @@ class OneOf(CustomDictTransform):
     def __init__(self, transform_dict, p=1):
         super().__init__(tio.OneOf(transform_dict, p=p))
 
-# %% ../nbs/03_vision_augment.ipynb #t6hak044rc
-def suggest_patch_augmentations(patch_size, target_spacing,
-                                anisotropy_threshold=3.0,
-                                translation_fraction=0.15):
-    """Suggest patch-based augmentations with nnU-Net-inspired defaults.
+# %% ../nbs/03_vision_augment.ipynb #lqet5pabzy
+def _compute_patch_aug_params(patch_size, target_spacing,
+                              anisotropy_threshold=3.0,
+                              translation_fraction=0.15):
+    """Compute geometry-aware augmentation parameters from patch/spacing metadata.
 
-    Derives rotation degrees, translation, and RandomAnisotropy axes from
-    patch geometry and voxel spacing. Returns a list of fastMONAI transform
-    instances ready for the ``patch_tfms`` parameter in MedPatchDataLoaders.
+    Shared logic used by both suggest_patch_augmentations (CPU/TorchIO) and
+    gpu_patch_augmentations (GPU-batched). Extracts rotation degrees, translation
+    offsets, and RandomAnisotropy axes from the spatial configuration.
 
     Anisotropy detection: if max(spacing)/min(spacing) >= threshold, rotation
     is restricted to 5 deg out-of-plane and 30 deg in-plane. Otherwise 30 deg
-    symmetric. Translation is patch_size * fraction per axis.
+    symmetric.
 
     Args:
         patch_size: List/tuple of 3 ints -- patch dimensions.
@@ -805,38 +815,507 @@ def suggest_patch_augmentations(patch_size, target_spacing,
         translation_fraction: Fraction of patch_size for translation (default 0.15).
 
     Returns:
-        list: fastMONAI transform instances (7 normally, 6 if RandomAnisotropy omitted).
-
-    Example::
-
-        >>> patch_tfms = suggest_patch_augmentations([128, 128, 32], [0.5, 0.5, 1.5])
-        >>> dls = MedPatchDataLoaders.from_config(..., patch_tfms=patch_tfms)
+        dict with keys:
+            'degrees': tuple of 3 ints (per-axis max rotation in degrees)
+            'translation': tuple of 3 ints (per-axis translation in voxels)
+            'aniso_axes': tuple of ints (axes where patch_size > 1)
+            'is_aniso': bool (whether spacing is anisotropic)
     """
     if len(patch_size) != 3:
         raise ValueError(f"patch_size must have 3 elements, got {len(patch_size)}")
     if len(target_spacing) != 3:
         raise ValueError(f"target_spacing must have 3 elements, got {len(target_spacing)}")
 
-    # Determine anisotropy
     spacing = list(target_spacing)
     ratio = max(spacing) / min(spacing)
     is_aniso = ratio >= anisotropy_threshold
     aniso_axis = spacing.index(max(spacing)) if is_aniso else None
 
-    # Rotation degrees
     if is_aniso:
         degrees = [5, 5, 5]
         degrees[aniso_axis] = 30
         degrees = tuple(degrees)
     else:
-        degrees = 30
+        degrees = (30, 30, 30)
 
-    # Translation
     translation = tuple(round(p * translation_fraction) for p in patch_size)
-
-    # RandomAnisotropy axes: all axes where patch_size > 1
     aniso_axes = tuple(i for i in range(3) if patch_size[i] > 1)
 
+    return {
+        'degrees': degrees,
+        'translation': translation,
+        'aniso_axes': aniso_axes,
+        'is_aniso': is_aniso,
+    }
+
+# %% ../nbs/03_vision_augment.ipynb #oef9rtzvbw
+def _build_rotation_matrix_3d(angles_rad):
+    """Build [N, 3, 3] rotation matrices from [N, 3] Euler angles (XYZ extrinsic).
+
+    Computes R = Rz @ Ry @ Rx for each sample in the batch.
+
+    Args:
+        angles_rad: Tensor of shape [N, 3] with rotation angles in radians
+                    for each axis (x, y, z).
+
+    Returns:
+        Tensor of shape [N, 3, 3] -- rotation matrices.
+    """
+    cos = torch.cos(angles_rad)
+    sin = torch.sin(angles_rad)
+    cx, cy, cz = cos[:, 0], cos[:, 1], cos[:, 2]
+    sx, sy, sz = sin[:, 0], sin[:, 1], sin[:, 2]
+
+    # R = Rz @ Ry @ Rx (combined formula)
+    r00 = cy * cz;          r01 = sx * sy * cz - cx * sz;  r02 = cx * sy * cz + sx * sz
+    r10 = cy * sz;          r11 = sx * sy * sz + cx * cz;  r12 = cx * sy * sz - sx * cz
+    r20 = -sy;              r21 = sx * cy;                  r22 = cx * cy
+
+    R = torch.stack([
+        torch.stack([r00, r01, r02], dim=-1),
+        torch.stack([r10, r11, r12], dim=-1),
+        torch.stack([r20, r21, r22], dim=-1),
+    ], dim=-2)
+    return R
+
+# %% ../nbs/03_vision_augment.ipynb #ts2kolv83z
+class GpuPatchAugmentation:
+    """GPU-batched augmentation for patch-based training.
+
+    Operates on [B, C, D, H, W] tensors already on GPU. All operations run
+    under torch.no_grad() since augmentation does not need gradient tracking.
+
+    Transform order: spatial (affine, anisotropy, flip) then intensity
+    (gamma, intensity_scale, noise, blur). Spatial transforms apply the
+    same parameters to both image and mask. Intensity transforms skip the mask.
+
+    Each transform is controlled by a parameter dict with at minimum a 'p' key
+    for per-sample probability. Pass None to disable a transform.
+
+    Args:
+        affine: dict with keys 'scales', 'degrees', 'translation',
+                'default_pad_value', 'p'. None to disable.
+        anisotropy: dict with keys 'axes', 'downsampling', 'p'. None to disable.
+        flip: dict with keys 'axes', 'p'. None to disable.
+        gamma: dict with keys 'log_gamma', 'p'. None to disable.
+        intensity_scale: dict with keys 'scale_range', 'p'. None to disable.
+        noise: dict with keys 'std', 'p'. None to disable.
+        blur: dict with keys 'std', 'p'. None to disable.
+
+    Example::
+
+        >>> gpu_aug = GpuPatchAugmentation(
+        ...     affine={'scales': (0.7, 1.4), 'degrees': (30, 30, 30),
+        ...             'translation': (25, 25, 10), 'default_pad_value': 0., 'p': 0.2},
+        ...     gamma={'log_gamma': (-0.3, 0.3), 'p': 0.3},
+        ...     flip={'axes': (0, 1, 2), 'p': 0.5},
+        ... )
+        >>> img_aug, mask_aug = gpu_aug(img_gpu, mask_gpu)
+    """
+
+    def __init__(self, affine=None, anisotropy=None, flip=None,
+                 gamma=None, intensity_scale=None, noise=None, blur=None):
+        self.affine = affine
+        self.anisotropy = anisotropy
+        self.flip = flip
+        self.gamma = gamma
+        self.intensity_scale = intensity_scale
+        self.noise = noise
+        self.blur = blur
+
+    def __call__(self, img, mask=None):
+        """Apply GPU augmentations to a batch.
+
+        Args:
+            img: Tensor [B, C, D, H, W] (float).
+            mask: Tensor [B, C, D, H, W] (float), or None.
+
+        Returns:
+            Tuple (img, mask). mask is None if input was None.
+        """
+        with torch.no_grad():
+            # Spatial transforms (same params for img and mask)
+            if self.affine is not None:
+                img, mask = self._apply_affine(img, mask)
+            if self.anisotropy is not None:
+                img, mask = self._apply_anisotropy(img, mask)
+            if self.flip is not None:
+                img, mask = self._apply_flip(img, mask)
+            # Intensity transforms (img only)
+            if self.gamma is not None:
+                img = self._apply_gamma(img)
+            if self.intensity_scale is not None:
+                img = self._apply_intensity_scale(img)
+            if self.noise is not None:
+                img = self._apply_noise(img)
+            if self.blur is not None:
+                img = self._apply_blur(img)
+        return img, mask
+
+    def _apply_affine(self, img, mask):
+        """Batched random affine via F.affine_grid + F.grid_sample."""
+        cfg = self.affine
+        B = img.shape[0]
+        device = img.device
+        dtype = img.dtype
+
+        # Per-sample probability
+        do_tfm = torch.rand(B, device=device) < cfg['p']
+        if not do_tfm.any():
+            return img, mask
+
+        # Start with identity theta [B, 3, 4]
+        theta = torch.zeros(B, 3, 4, device=device, dtype=dtype)
+        theta[:, 0, 0] = 1.0
+        theta[:, 1, 1] = 1.0
+        theta[:, 2, 2] = 1.0
+
+        idx = do_tfm.nonzero(as_tuple=True)[0]
+        n = idx.shape[0]
+
+        # Random scales per axis
+        s_lo, s_hi = cfg['scales']
+        scales = torch.empty(n, 3, device=device, dtype=dtype).uniform_(s_lo, s_hi)
+
+        # Random rotation angles (degrees -> radians)
+        degrees = cfg['degrees']
+        if not isinstance(degrees, (list, tuple)):
+            degrees = (degrees, degrees, degrees)
+        angles_deg = torch.stack([
+            torch.empty(n, device=device, dtype=dtype).uniform_(-degrees[0], degrees[0]),
+            torch.empty(n, device=device, dtype=dtype).uniform_(-degrees[1], degrees[1]),
+            torch.empty(n, device=device, dtype=dtype).uniform_(-degrees[2], degrees[2]),
+        ], dim=1)  # [n, 3]
+        angles_rad = angles_deg * (math.pi / 180.0)
+
+        # Build rotation matrices [n, 3, 3]
+        R = _build_rotation_matrix_3d(angles_rad)
+
+        # Scale matrix: S @ R -> [n, 3, 3]
+        S = torch.diag_embed(scales)  # [n, 3, 3]
+        SR = S @ R  # [n, 3, 3]
+
+        # Random translation (voxels -> normalized [-1, 1] coords)
+        translation = cfg['translation']
+        if not isinstance(translation, (list, tuple)):
+            translation = (translation, translation, translation)
+        spatial_size = img.shape[2:]  # (D, H, W)
+        t_norm = torch.stack([
+            torch.empty(n, device=device, dtype=dtype).uniform_(
+                -translation[i], translation[i]
+            ) * 2.0 / spatial_size[i]
+            for i in range(3)
+        ], dim=1)  # [n, 3]
+
+        # Assemble theta for active samples
+        theta[idx, :3, :3] = SR
+        theta[idx, :3, 3] = t_norm
+
+        # Apply grid_sample
+        grid = F.affine_grid(theta, img.shape, align_corners=False)
+        pad_val = cfg.get('default_pad_value', 0.)
+        # For non-zero padding, shift values, sample, shift back
+        if pad_val != 0.:
+            img = img - pad_val
+        img = F.grid_sample(img, grid, mode='bilinear',
+                            padding_mode='zeros', align_corners=False)
+        if pad_val != 0.:
+            img = img + pad_val
+
+        if mask is not None:
+            mask = F.grid_sample(mask.float(), grid, mode='nearest',
+                                 padding_mode='zeros', align_corners=False)
+        return img, mask
+
+    def _apply_anisotropy(self, img, mask):
+        """Per-sample anisotropy simulation via F.interpolate.
+
+        Downsample along a random axis with nearest interpolation,
+        then upsample back with trilinear (matches TorchIO behavior).
+        Only affects img, not mask (anisotropy is intensity degradation).
+        """
+        cfg = self.anisotropy
+        B = img.shape[0]
+        device = img.device
+        ds_lo, ds_hi = cfg['downsampling']
+        axes = cfg['axes']
+
+        for i in range(B):
+            if torch.rand(1, device=device).item() >= cfg['p']:
+                continue
+            # Pick random axis and downsampling factor
+            axis_idx = torch.randint(len(axes), (1,), device=device).item()
+            axis = axes[axis_idx]
+            factor = torch.empty(1, device=device).uniform_(ds_lo, ds_hi).item()
+
+            sample = img[i:i+1]  # [1, C, D, H, W]
+            orig_size = list(sample.shape[2:])
+            down_size = list(orig_size)
+            down_size[axis] = max(1, round(orig_size[axis] / factor))
+
+            # Downsample with nearest, upsample with trilinear
+            down = F.interpolate(sample, size=down_size, mode='nearest')
+            up = F.interpolate(down, size=orig_size, mode='trilinear',
+                               align_corners=False)
+            img[i:i+1] = up
+
+        return img, mask
+
+    def _apply_flip(self, img, mask):
+        """Per-sample random flip along configured axes."""
+        cfg = self.flip
+        B = img.shape[0]
+        device = img.device
+        axes = cfg['axes']
+        p = cfg['p']
+
+        for i in range(B):
+            # Each axis is independently flipped with probability p
+            flip_dims = []
+            for axis in axes:
+                if torch.rand(1, device=device).item() < p:
+                    # axis 0 -> dim 2 (D), axis 1 -> dim 3 (H), axis 2 -> dim 4 (W)
+                    # but img[i] is [C, D, H, W], so axis 0 -> dim 1, etc.
+                    flip_dims.append(axis + 2)  # +2 for batch and channel dims
+            if flip_dims:
+                img[i] = torch.flip(img[i], dims=[d - 1 for d in flip_dims])  # -1 since no batch dim
+                if mask is not None:
+                    mask[i] = torch.flip(mask[i], dims=[d - 1 for d in flip_dims])
+
+        return img, mask
+
+    def _apply_gamma(self, img):
+        """Batched gamma correction with per-sample random gamma."""
+        cfg = self.gamma
+        B = img.shape[0]
+        device = img.device
+        dtype = img.dtype
+        log_lo, log_hi = cfg['log_gamma']
+
+        active = torch.rand(B, device=device) < cfg['p']
+        if not active.any():
+            return img
+
+        # Only apply clamp + pow to active samples (clamp destroys negatives)
+        active_idx = active.nonzero(as_tuple=True)[0]
+        log_gamma = torch.empty(active_idx.shape[0], device=device, dtype=dtype).uniform_(log_lo, log_hi)
+        gamma = torch.exp(log_gamma).view(-1, 1, 1, 1, 1)
+        img[active_idx] = img[active_idx].clamp(min=0).pow(gamma)
+        return img
+
+    def _apply_intensity_scale(self, img):
+        """Batched intensity scaling with per-sample random factors."""
+        cfg = self.intensity_scale
+        B = img.shape[0]
+        device = img.device
+        dtype = img.dtype
+        s_lo, s_hi = cfg['scale_range']
+
+        # Per-sample scale (inactive get scale=1)
+        scale = torch.empty(B, device=device, dtype=dtype).uniform_(s_lo, s_hi)
+        active = torch.rand(B, device=device) < cfg['p']
+        scale = torch.where(active, scale, torch.ones_like(scale))
+
+        img = img * scale.view(B, 1, 1, 1, 1)
+        return img
+
+    def _apply_noise(self, img):
+        """Batched additive Gaussian noise with per-sample random std."""
+        cfg = self.noise
+        B = img.shape[0]
+        device = img.device
+        dtype = img.dtype
+
+        std_val = cfg['std']
+        if isinstance(std_val, (list, tuple)):
+            std_lo, std_hi = std_val
+            per_std = torch.empty(B, device=device, dtype=dtype).uniform_(std_lo, std_hi)
+        else:
+            per_std = torch.full((B,), std_val, device=device, dtype=dtype)
+
+        # Zero std for inactive samples
+        active = torch.rand(B, device=device) < cfg['p']
+        per_std = torch.where(active, per_std, torch.zeros_like(per_std))
+
+        noise = torch.randn_like(img) * per_std.view(B, 1, 1, 1, 1)
+        img = img + noise
+        return img
+
+    def _apply_blur(self, img):
+        """Batched separable 3D Gaussian blur via F.conv3d with groups trick."""
+        cfg = self.blur
+        B, C, D, H, W = img.shape
+        device = img.device
+        dtype = img.dtype
+
+        std_val = cfg['std']
+        if isinstance(std_val, (list, tuple)):
+            std_lo, std_hi = std_val
+        else:
+            std_lo, std_hi = 0.0, std_val
+
+        # Per-sample sigma
+        sigma = torch.empty(B, device=device, dtype=dtype).uniform_(std_lo, std_hi)
+        active = torch.rand(B, device=device) < cfg['p']
+        if not active.any():
+            return img
+
+        # Fixed kernel size from max sigma
+        max_sigma = max(std_hi, 0.01)
+        kernel_radius = int(math.ceil(3 * max_sigma))
+        kernel_size = 2 * kernel_radius + 1
+
+        # Build per-sample 1D Gaussian kernels [B, kernel_size]
+        x = torch.arange(-kernel_radius, kernel_radius + 1,
+                          device=device, dtype=dtype)
+        # Avoid division by zero for sigma=0
+        safe_sigma = torch.where(active, sigma, torch.ones_like(sigma))
+        kernels = torch.exp(-x.unsqueeze(0)**2 / (2 * safe_sigma.unsqueeze(1)**2))
+        kernels = kernels / kernels.sum(dim=1, keepdim=True)
+
+        # For inactive samples, use delta kernel
+        delta = torch.zeros(B, kernel_size, device=device, dtype=dtype)
+        delta[:, kernel_radius] = 1.0
+        kernels = torch.where(active.unsqueeze(1), kernels, delta)
+
+        # Expand kernels for all channels: [B*C, kernel_size]
+        kernels_bc = kernels.unsqueeze(1).expand(B, C, kernel_size).reshape(B * C, kernel_size)
+
+        # Reshape img for grouped convolution: [1, B*C, D, H, W]
+        img_grouped = img.reshape(1, B * C, D, H, W)
+
+        # Separable 3D convolution: D-axis, H-axis, W-axis
+        pad = kernel_radius
+
+        # D-axis: kernel shape [B*C, 1, K, 1, 1]
+        k_d = kernels_bc.reshape(B * C, 1, kernel_size, 1, 1)
+        img_grouped = F.pad(img_grouped, (0, 0, 0, 0, pad, pad), mode='replicate')
+        img_grouped = F.conv3d(img_grouped, k_d, groups=B * C)
+
+        # H-axis: kernel shape [B*C, 1, 1, K, 1]
+        k_h = kernels_bc.reshape(B * C, 1, 1, kernel_size, 1)
+        img_grouped = F.pad(img_grouped, (0, 0, pad, pad, 0, 0), mode='replicate')
+        img_grouped = F.conv3d(img_grouped, k_h, groups=B * C)
+
+        # W-axis: kernel shape [B*C, 1, 1, 1, K]
+        k_w = kernels_bc.reshape(B * C, 1, 1, 1, kernel_size)
+        img_grouped = F.pad(img_grouped, (pad, pad, 0, 0, 0, 0), mode='replicate')
+        img_grouped = F.conv3d(img_grouped, k_w, groups=B * C)
+
+        return img_grouped.reshape(B, C, D, H, W)
+
+    def __repr__(self):
+        parts = []
+        for name in ['affine', 'anisotropy', 'flip', 'gamma',
+                      'intensity_scale', 'noise', 'blur']:
+            cfg = getattr(self, name)
+            if cfg is not None:
+                parts.append(f"{name}(p={cfg['p']})")
+        return f"GpuPatchAugmentation({', '.join(parts)})"
+
+# %% ../nbs/03_vision_augment.ipynb #pdbh1nqo0j7
+def gpu_patch_augmentations(patch_size, target_spacing,
+                            anisotropy_threshold=3.0,
+                            translation_fraction=0.15,
+                            affine_p=0.2, anisotropy_p=0.25,
+                            gamma_p=0.3, intensity_scale_p=0.1,
+                            noise_p=0.1, blur_p=0.2, flip_p=0.5):
+    """Create GpuPatchAugmentation with nnU-Net-inspired defaults.
+
+    Factory function that mirrors suggest_patch_augmentations but returns
+    a GpuPatchAugmentation for GPU-batched operation. Uses the same shared
+    parameter logic via _compute_patch_aug_params.
+
+    Args:
+        patch_size: List/tuple of 3 ints -- patch dimensions.
+        target_spacing: List/tuple of 3 floats -- voxel spacing.
+        anisotropy_threshold: Ratio threshold for anisotropy detection (default 3.0).
+        translation_fraction: Fraction of patch_size for translation (default 0.15).
+        affine_p: Probability for RandomAffine (default 0.2).
+        anisotropy_p: Probability for RandomAnisotropy (default 0.25).
+        gamma_p: Probability for RandomGamma (default 0.3).
+        intensity_scale_p: Probability for RandomIntensityScale (default 0.1).
+        noise_p: Probability for RandomNoise (default 0.1).
+        blur_p: Probability for RandomBlur (default 0.2).
+        flip_p: Probability for RandomFlip per axis (default 0.5).
+
+    Returns:
+        GpuPatchAugmentation instance.
+
+    Example::
+
+        >>> gpu_aug = gpu_patch_augmentations([128, 128, 32], [0.5, 0.5, 1.5])
+        >>> dls = MedPatchDataLoaders.from_df(..., gpu_augmentation=gpu_aug)
+    """
+    params = _compute_patch_aug_params(
+        patch_size, target_spacing, anisotropy_threshold, translation_fraction
+    )
+
+    affine_cfg = {
+        'scales': (0.7, 1.4),
+        'degrees': params['degrees'],
+        'translation': params['translation'],
+        'default_pad_value': 0.,
+        'p': affine_p,
+    }
+
+    aniso_cfg = None
+    if len(params['aniso_axes']) > 0:
+        aniso_cfg = {
+            'axes': params['aniso_axes'],
+            'downsampling': (1.5, 4),
+            'p': anisotropy_p,
+        }
+
+    return GpuPatchAugmentation(
+        affine=affine_cfg,
+        anisotropy=aniso_cfg,
+        flip={'axes': (0, 1, 2), 'p': flip_p},
+        gamma={'log_gamma': (-0.3, 0.3), 'p': gamma_p},
+        intensity_scale={'scale_range': (0.75, 1.25), 'p': intensity_scale_p},
+        noise={'std': 0.1, 'p': noise_p},
+        blur={'std': (0.5, 1.0), 'p': blur_p},
+    )
+
+# %% ../nbs/03_vision_augment.ipynb #t6hak044rc
+def suggest_patch_augmentations(patch_size, target_spacing,
+                                anisotropy_threshold=3.0,
+                                translation_fraction=0.15):
+    """Suggest patch-based augmentations with nnU-Net-inspired defaults.
+
+    Derives rotation degrees, translation, and RandomAnisotropy axes from
+    patch geometry and voxel spacing. Returns a list of fastMONAI transform
+    instances ready for the ``patch_tfms`` parameter in MedPatchDataLoaders.
+
+    Anisotropy detection: if max(spacing)/min(spacing) >= threshold, rotation
+    is restricted to 5 deg out-of-plane and 30 deg in-plane. Otherwise 30 deg
+    symmetric. Translation is patch_size * fraction per axis.
+
+    Args:
+        patch_size: List/tuple of 3 ints -- patch dimensions.
+        target_spacing: List/tuple of 3 floats -- voxel spacing.
+        anisotropy_threshold: Ratio threshold for anisotropy detection (default 3.0).
+        translation_fraction: Fraction of patch_size for translation (default 0.15).
+
+    Returns:
+        list: fastMONAI transform instances (7 normally, 6 if RandomAnisotropy omitted).
+
+    Example::
+
+        >>> patch_tfms = suggest_patch_augmentations([128, 128, 32], [0.5, 0.5, 1.5])
+        >>> dls = MedPatchDataLoaders.from_df(..., patch_tfms=patch_tfms)
+    """
+    params = _compute_patch_aug_params(
+        patch_size, target_spacing, anisotropy_threshold, translation_fraction
+    )
+    degrees = params['degrees']
+    translation = params['translation']
+    aniso_axes = params['aniso_axes']
+
+    # For TorchIO: pass scalar 30 when isotropic (TorchIO expands to symmetric)
+    if not params['is_aniso']:
+        degrees = 30
+
     transforms = [
         RandomAffine(scales=(0.7, 1.4), degrees=degrees, translation=translation,
                      default_pad_value=0., p=0.2),

{fastmonai-0.8.0 → fastmonai-0.8.2}/fastMONAI/vision_patch.py

@@ -116,6 +116,11 @@ class PatchConfig:
             training and inference. Defaults to True (the common case).
         target_spacing: Target voxel spacing [x, y, z] for resampling. Must match between
             training and inference.
+        preprocessed: If True, data has been preprocessed externally (e.g., via
+            preprocess_dataset()). Training will skip reorder, resample, AND
+            pre_patch_tfms (e.g., normalization) since they were already applied.
+            Inference is unaffected and always applies pre_inference_tfms to raw
+            images. Defaults to False.
         padding_mode: Padding mode for CropOrPad when image < patch_size. Default is 0 (zero padding)
             to align with nnU-Net's approach. Can be int, float, or string (e.g., 'minimum', 'mean').
         keep_largest_component: If True, keep only the largest connected component
@@ -142,6 +147,7 @@ class PatchConfig:
     # Preprocessing parameters - must match between training and inference
     apply_reorder: bool = True  # Defaults to True (the common case)
     target_spacing: list = None
+    preprocessed: bool = False  # True = data already preprocessed, skip all preprocessing during training
     padding_mode: int | float | str = 0  # Zero padding (nnU-Net standard)
     # Post-processing (binary segmentation only)
     keep_largest_component: bool = False
@@ -403,7 +409,10 @@ class MedPatchDataLoader:
         patch_tfms: Transforms to apply to extracted patches (training only).
             Accepts both fastMONAI wrappers (e.g., RandomAffine, RandomGamma) and
             raw TorchIO transforms. fastMONAI wrappers are automatically normalized
-            to raw TorchIO for internal use.
+            to raw TorchIO for internal use. Mutually exclusive with gpu_augmentation.
+        gpu_augmentation: GpuPatchAugmentation instance for GPU-batched augmentation.
+            Operates on [B,C,D,H,W] tensors already on GPU, avoiding per-sample CPU
+            overhead. Mutually exclusive with patch_tfms. Training only.
         shuffle: Whether to shuffle subjects and patches.
         drop_last: Whether to drop last incomplete batch.
     """
@@ -414,18 +423,20 @@ class MedPatchDataLoader:
         config: PatchConfig,
         batch_size: int = 4,
         patch_tfms: list = None,
+        gpu_augmentation=None,
         shuffle: bool = True,
         drop_last: bool = False
     ):
         if batch_size <= 0:
             raise ValueError(f"batch_size must be positive, got {batch_size}")
-        
+
         self.subjects_dataset = subjects_dataset
         self.config = config
         self.bs = batch_size
         self.shuffle = shuffle
         self.drop_last = drop_last
         self._device = _get_default_device()
+        self.gpu_augmentation = gpu_augmentation
 
         # Create sampler
         self.sampler = create_patch_sampler(config)
@@ -464,14 +475,12 @@ class MedPatchDataLoader:
             img = batch['image'][tio.DATA]  # [B, C, H, W, D]
             has_mask = 'mask' in batch
 
-            # Apply patch transforms if provided
+            # Apply CPU patch transforms if provided (per-sample TorchIO loop)
             if self.patch_tfms is not None:
-                # Apply transforms to each sample in batch
                 transformed_imgs = []
                 transformed_masks = [] if has_mask else None
 
                 for i in range(img.shape[0]):
-                    # Build subject dict with image, and mask if available
                     subject_dict = {'image': tio.ScalarImage(tensor=batch['image'][tio.DATA][i])}
                     if has_mask:
                         subject_dict['mask'] = tio.LabelMap(tensor=batch['mask'][tio.DATA][i])
@@ -487,10 +496,19 @@ class MedPatchDataLoader:
             else:
                 mask = batch['mask'][tio.DATA] if has_mask else None
 
-            # Convert to MedImage/MedMask and move to device
-            img = MedImage(img).to(self._device)
+            # Move to device
+            img = img.to(self._device)
             if mask is not None:
-                mask = MedMask(mask).to(self._device)
+                mask = mask.to(self._device)
+
+            # Apply GPU augmentation if provided (batched, on-device)
+            if self.gpu_augmentation is not None:
+                img, mask = self.gpu_augmentation(img, mask)
+
+            # Wrap as MedImage/MedMask
+            img = MedImage(img)
+            if mask is not None:
+                mask = MedMask(mask)
 
             yield img, mask
 
@@ -613,6 +631,7 @@ class MedPatchDataLoaders:
         patch_config: PatchConfig = None,
         pre_patch_tfms: list = None,
         patch_tfms: list = None,
+        gpu_augmentation=None,
         apply_reorder: bool = None,
         target_spacing: list = None,
         bs: int = 4,
@@ -640,7 +659,12 @@ class MedPatchDataLoaders:
             pre_patch_tfms: TorchIO transforms applied before patch extraction
                            (after reorder/resample). Example: [tio.ZNormalization()].
                            Accepts both fastMONAI wrappers and raw TorchIO transforms.
+                           Skipped when preprocessed=True (include in preprocess_dataset()
+                           transforms instead). Still needed for inference via pre_inference_tfms.
             patch_tfms: TorchIO transforms applied to extracted patches (training only).
+                Mutually exclusive with gpu_augmentation.
+            gpu_augmentation: GpuPatchAugmentation instance for GPU-batched augmentation
+                (training only). Mutually exclusive with patch_tfms.
             apply_reorder: If True, reorder to RAS+ orientation. If None, uses
                 patch_config.apply_reorder. Explicit value overrides config.
             target_spacing: Target voxel spacing [x, y, z]. If None, uses
@@ -656,22 +680,32 @@ class MedPatchDataLoaders:
             MedPatchDataLoaders instance.
 
         Example:
-            >>> # New pattern: config contains preprocessing params
-            >>> config = PatchConfig(
-            ...     patch_size=[96, 96, 96],
-            ...     apply_reorder=True,
-            ...     target_spacing=[0.5, 0.5, 0.5],
-            ...     label_probabilities={0: 0.1, 1: 0.9}
-            ... )
+            >>> # CPU augmentation path (existing)
             >>> dls = MedPatchDataLoaders.from_df(
             ...     df, img_col='image', mask_col='label',
             ...     patch_config=config,
-            ...     pre_patch_tfms=[tio.ZNormalization()],
             ...     patch_tfms=[tio.RandomAffine(degrees=10), tio.RandomFlip()],
             ...     bs=4
             ... )
-            >>> # Memory: ~150 MB (queue buffer only)
+            >>>
+            >>> # GPU augmentation path (new, faster for long training runs)
+            >>> from fastMONAI.vision_augmentation import gpu_patch_augmentations
+            >>> gpu_aug = gpu_patch_augmentations(config.patch_size, config.target_spacing)
+            >>> dls = MedPatchDataLoaders.from_df(
+            ...     df, img_col='image', mask_col='label',
+            ...     patch_config=config,
+            ...     gpu_augmentation=gpu_aug,
+            ...     bs=4
+            ... )
         """
+        # Validate mutual exclusivity
+        if gpu_augmentation is not None and patch_tfms is not None:
+            raise ValueError(
+                "Cannot use both gpu_augmentation and patch_tfms. "
+                "gpu_augmentation operates on GPU tensors batch-wise, while "
+                "patch_tfms uses per-sample CPU TorchIO transforms. Choose one."
+            )
+
         if patch_config is None:
             patch_config = PatchConfig()
 
@@ -699,17 +733,19 @@ class MedPatchDataLoaders:
         # Build preprocessing transforms
         all_pre_tfms = []
 
-        # Add reorder transform (reorder to RAS+ orientation)
-        if _apply_reorder:
-            all_pre_tfms.append(tio.ToCanonical())
+        # Skip all preprocessing if data was already preprocessed externally
+        if not patch_config.preprocessed:
+            # Add reorder transform (reorder to RAS+ orientation)
+            if _apply_reorder:
+                all_pre_tfms.append(tio.ToCanonical())
 
-        # Add resample transform
-        if _target_spacing is not None:
-            all_pre_tfms.append(tio.Resample(_target_spacing))
+            # Add resample transform
+            if _target_spacing is not None:
+                all_pre_tfms.append(tio.Resample(_target_spacing))
 
-        # Add user-provided transforms (normalize to raw TorchIO transforms)
-        if pre_patch_tfms:
-            all_pre_tfms.extend(normalize_patch_transforms(pre_patch_tfms))
+            # Add user-provided transforms (normalize to raw TorchIO transforms)
+            if pre_patch_tfms:
+                all_pre_tfms.extend(normalize_patch_transforms(pre_patch_tfms))
 
         # Create subjects datasets with lazy loading (paths only, ~0 MB)
         train_subjects = create_subjects_dataset(
@@ -726,11 +762,14 @@ class MedPatchDataLoaders:
         # Create DataLoaders (both use same patch_config for consistent sampling)
         train_dl = MedPatchDataLoader(
             train_subjects, patch_config, bs,
-            patch_tfms=patch_tfms, shuffle=True, drop_last=True
+            patch_tfms=patch_tfms,
+            gpu_augmentation=gpu_augmentation,
+            shuffle=True, drop_last=True
         )
         valid_dl = MedPatchDataLoader(
             valid_subjects, patch_config, bs,
             patch_tfms=None,  # No augmentation for validation
+            gpu_augmentation=None,  # No augmentation for validation
             shuffle=False, drop_last=False
         )
 
@@ -847,7 +886,8 @@ class MedPatchDataLoaders:
         return self.to(torch.device('cpu'))
 
     def show_batch(self, dl_idx=0, max_n=6, figsize=None, channel=0,
-                   slice_index=None, anatomical_plane=0, overlay=False, **kwargs):
+                   slice_index=None, anatomical_plane=0, overlay=False,
+                   voxel_size=None, **kwargs):
         """Show a batch of patch samples for visualization."""
 
         dl = self[dl_idx]
@@ -886,15 +926,15 @@ class MedPatchDataLoaders:
             imgs.extend(im_channels)
             slice_idxs.extend([idx] * len(im_channels))
 
-        voxel_size = self.target_spacing
+        _voxel_size = voxel_size if voxel_size is not None else self.target_spacing
         ctxs = [im.show(ax=ax, slice_index=idx, anatomical_plane=anatomical_plane,
-                        voxel_size=voxel_size)
+                        voxel_size=_voxel_size)
                 for im, ax, idx in zip(imgs, flat_axs, slice_idxs)]
 
         if overlay and has_mask:
             for mask, ax, idx in zip(masks_for_overlay, flat_axs, slice_idxs):
                 mask.show(ax=ax, slice_index=idx, anatomical_plane=anatomical_plane,
-                          voxel_size=voxel_size)
+                          voxel_size=_voxel_size)
 
         plt.tight_layout()
         plt.show()

{fastmonai-0.8.0 → fastmonai-0.8.2/fastMONAI.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastMONAI
-Version: 0.8.0
+Version: 0.8.2
 Summary: fastMONAI library
 Home-page: https://github.com/MMIV-ML/fastMONAI
 Author: Satheshkumar Kaliyugarasan

{fastmonai-0.8.0 → fastmonai-0.8.2}/settings.ini

@@ -5,7 +5,7 @@
 ### Python Library ###
 lib_name = fastMONAI
 min_python = 3.10
-version = 0.8.0
+version = 0.8.2
 ### OPTIONAL ###
 
 requirements = fastai==2.8.6 monai==1.5.2 torchio==0.21.2 xlrd>=1.2.0 scikit-image==0.26.0 imagedata==3.8.14 mlflow==3.9.0 huggingface-hub gdown gradio opencv-python plum-dispatch

fastmonai-0.8.0/fastMONAI/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.8.0"