fastMONAI 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

fastMONAI/vision_augmentation.py

@@ -3,8 +3,8 @@
 # %% auto 0
 __all__ = ['CustomDictTransform', 'do_pad_or_crop', 'PadOrCrop', 'ZNormalization', 'RescaleIntensity', 'NormalizeIntensity',
            'BraTSMaskConverter', 'BinaryConverter', 'RandomGhosting', 'RandomSpike', 'RandomNoise', 'RandomBiasField',
-           'RandomBlur', 'RandomGamma', 'RandomMotion', 'RandomElasticDeformation', 'RandomAffine', 'RandomFlip',
-           'OneOf']
+           'RandomBlur', 'RandomGamma', 'RandomIntensityScale', 'RandomMotion', 'RandomElasticDeformation',
+           'RandomAffine', 'RandomFlip', 'OneOf']
 
 # %% ../nbs/03_vision_augment.ipynb 2
 from fastai.data.all import *
@@ -14,10 +14,10 @@ from monai.transforms import NormalizeIntensity as MonaiNormalizeIntensity
 
 # %% ../nbs/03_vision_augment.ipynb 5
 class CustomDictTransform(ItemTransform):
-    """A class that serves as a wrapper to perform an identical transformation on both 
+    """A class that serves as a wrapper to perform an identical transformation on both
     the image and the target (if it's a mask).
     """
-    
+
     split_idx = 0  # Only perform transformations on training data. Use TTA() for transformations on validation data.
 
     def __init__(self, aug):
@@ -28,31 +28,42 @@ class CustomDictTransform(ItemTransform):
         """
         self.aug = aug
 
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform.
+
+        This property enables using fastMONAI wrappers in patch-based workflows
+        where raw TorchIO transforms are needed for tio.Compose().
+        """
+        return self.aug
+
     def encodes(self, x):
         """
-        Applies the stored transformation to an image, and the same random transformation 
+        Applies the stored transformation to an image, and the same random transformation
         to the target if it is a mask. If the target is not a mask, it returns the target as is.
 
         Args:
-            x (Tuple[MedImage, Union[MedMask, TensorCategory]]): A tuple containing the 
+            x (Tuple[MedImage, Union[MedMask, TensorCategory]]): A tuple containing the
             image and the target.
 
         Returns:
-            Tuple[MedImage, Union[MedMask, TensorCategory]]: The transformed image and target. 
-            If the target is a mask, it's transformed identically to the image. If the target 
+            Tuple[MedImage, Union[MedMask, TensorCategory]]: The transformed image and target.
+            If the target is a mask, it's transformed identically to the image. If the target
             is not a mask, the original target is returned.
         """
         img, y_true = x
+        
+        # Use identity affine if MedImage.affine_matrix is not set
+        affine = MedImage.affine_matrix if MedImage.affine_matrix is not None else np.eye(4)
 
         if isinstance(y_true, (MedMask)):
-            aug = self.aug(tio.Subject(img=tio.ScalarImage(tensor=img, affine=MedImage.affine_matrix), 
-                                        mask=tio.LabelMap(tensor=y_true, affine=MedImage.affine_matrix)))
+            aug = self.aug(tio.Subject(img=tio.ScalarImage(tensor=img, affine=affine),
+                                        mask=tio.LabelMap(tensor=y_true, affine=affine)))
             return MedImage.create(aug['img'].data), MedMask.create(aug['mask'].data)
 
         aug = self.aug(tio.Subject(img=tio.ScalarImage(tensor=img)))
         return MedImage.create(aug['img'].data), y_true
 
-
 # %% ../nbs/03_vision_augment.ipynb 7
 def do_pad_or_crop(o, target_shape, padding_mode, mask_name, dtype=torch.Tensor):
     #TODO:refactorize
@@ -72,6 +83,11 @@ class PadOrCrop(DisplayedTransform):
                                     padding_mode=padding_mode, 
                                     mask_name=mask_name)
 
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.pad_or_crop
+
     def encodes(self, o: (MedImage, MedMask)):
         return type(o)(self.pad_or_crop(o))
 
@@ -85,6 +101,11 @@ class ZNormalization(DisplayedTransform):
         self.z_normalization = tio.ZNormalization(masking_method=masking_method)
         self.channel_wise = channel_wise
 
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.z_normalization
+
     def encodes(self, o: MedImage):
         try:
             if self.channel_wise:
@@ -132,7 +153,12 @@ class RescaleIntensity(DisplayedTransform):
     
     def __init__(self, out_min_max: tuple[float, float], in_min_max: tuple[float, float]):
         self.rescale = tio.RescaleIntensity(out_min_max=out_min_max, in_min_max=in_min_max)
-    
+
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.rescale
+
     def encodes(self, o: MedImage):
         return MedImage.create(self.rescale(o))
         
@@ -211,8 +237,17 @@ class RandomGhosting(DisplayedTransform):
     def __init__(self, intensity=(0.5, 1), p=0.5):
         self.add_ghosts = tio.RandomGhosting(intensity=intensity, p=p)
 
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.add_ghosts
+
     def encodes(self, o: MedImage):
-        return MedImage.create(self.add_ghosts(o))
+        result = self.add_ghosts(o)
+        # Handle potential complex values from k-space operations
+        if result.is_complex():
+            result = torch.real(result)
+        return MedImage.create(result)
 
     def encodes(self, o: MedMask):
         return o
@@ -221,26 +256,40 @@ class RandomGhosting(DisplayedTransform):
 class RandomSpike(DisplayedTransform):
     '''Apply TorchIO `RandomSpike`.'''
     
-    split_idx,order=0,1
+    split_idx, order = 0, 1
 
     def __init__(self, num_spikes=1, intensity=(1, 3), p=0.5):
         self.add_spikes = tio.RandomSpike(num_spikes=num_spikes, intensity=intensity, p=p)
 
-    def encodes(self, o:MedImage): 
-        return MedImage.create(self.add_spikes(o))
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.add_spikes
+
+    def encodes(self, o: MedImage): 
+        result = self.add_spikes(o)
+        # Handle potential complex values from k-space operations
+        if result.is_complex():
+            result = torch.real(result)
+        return MedImage.create(result)
         
-    def encodes(self, o:MedMask):
+    def encodes(self, o: MedMask):
         return o
 
 # %% ../nbs/03_vision_augment.ipynb 16
 class RandomNoise(DisplayedTransform):
     '''Apply TorchIO `RandomNoise`.'''
 
-    split_idx,order=0,1
+    split_idx, order = 0, 1
 
     def __init__(self, mean=0, std=(0, 0.25), p=0.5):
         self.add_noise = tio.RandomNoise(mean=mean, std=std, p=p)
 
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.add_noise
+
     def encodes(self, o: MedImage): 
         return MedImage.create(self.add_noise(o))
     
@@ -251,11 +300,16 @@ class RandomNoise(DisplayedTransform):
 class RandomBiasField(DisplayedTransform):
     '''Apply TorchIO `RandomBiasField`.'''
 
-    split_idx,order=0,1
+    split_idx, order = 0, 1
 
     def __init__(self, coefficients=0.5, order=3, p=0.5):
         self.add_biasfield = tio.RandomBiasField(coefficients=coefficients, order=order, p=p)
 
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.add_biasfield
+
     def encodes(self, o: MedImage): 
         return MedImage.create(self.add_biasfield(o))
         
@@ -264,13 +318,18 @@ class RandomBiasField(DisplayedTransform):
 
 # %% ../nbs/03_vision_augment.ipynb 18
 class RandomBlur(DisplayedTransform):
-    '''Apply TorchIO `RandomBiasField`.'''
+    '''Apply TorchIO `RandomBlur`.'''
 
-    split_idx,order=0,1
+    split_idx, order = 0, 1
 
     def __init__(self, std=(0, 2), p=0.5):
         self.add_blur = tio.RandomBlur(std=std, p=p)
-        
+
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.add_blur
+
     def encodes(self, o: MedImage): 
         return MedImage.create(self.add_blur(o))
     
@@ -281,12 +340,16 @@ class RandomBlur(DisplayedTransform):
 class RandomGamma(DisplayedTransform):
     '''Apply TorchIO `RandomGamma`.'''
 
-
-    split_idx,order=0,1
+    split_idx, order = 0, 1
 
     def __init__(self, log_gamma=(-0.3, 0.3), p=0.5):
         self.add_gamma = tio.RandomGamma(log_gamma=log_gamma, p=p)
 
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.add_gamma
+
     def encodes(self, o: MedImage): 
         return MedImage.create(self.add_gamma(o))
     
@@ -294,6 +357,38 @@ class RandomGamma(DisplayedTransform):
         return o
 
 # %% ../nbs/03_vision_augment.ipynb 20
+class RandomIntensityScale(DisplayedTransform):
+    """Randomly scale image intensities by a multiplicative factor.
+
+    Useful for domain generalization across different acquisition protocols
+    with varying intensity ranges.
+
+    Args:
+        scale_range (tuple[float, float]): Range of scale factors (min, max).
+            Values > 1 increase intensity, < 1 decrease intensity.
+        p (float): Probability of applying the transform (default: 0.5)
+
+    Example:
+        # Scale intensities randomly between 0.5x and 2.0x
+        transform = RandomIntensityScale(scale_range=(0.5, 2.0), p=0.3)
+    """
+
+    split_idx, order = 0, 1
+
+    def __init__(self, scale_range: tuple[float, float] = (0.5, 2.0), p: float = 0.5):
+        self.scale_range = scale_range
+        self.p = p
+
+    def encodes(self, o: MedImage):
+        if torch.rand(1).item() > self.p:
+            return o
+        scale = torch.empty(1).uniform_(self.scale_range[0], self.scale_range[1]).item()
+        return MedImage.create(o * scale)
+
+    def encodes(self, o: MedMask):
+        return o
+
+# %% ../nbs/03_vision_augment.ipynb 21
 class RandomMotion(DisplayedTransform):
     """Apply TorchIO `RandomMotion`."""
 
@@ -315,13 +410,22 @@ class RandomMotion(DisplayedTransform):
             p=p
         )
 
+    @property
+    def tio_transform(self):
+        """Return the underlying TorchIO transform."""
+        return self.add_motion
+
     def encodes(self, o: MedImage):
-        return MedImage.create(self.add_motion(o))
+        result = self.add_motion(o)
+        # Handle potential complex values from k-space operations
+        if result.is_complex():
+            result = torch.real(result)
+        return MedImage.create(result)
 
     def encodes(self, o: MedMask):
         return o
 
-# %% ../nbs/03_vision_augment.ipynb 22
+# %% ../nbs/03_vision_augment.ipynb 23
 class RandomElasticDeformation(CustomDictTransform):
     """Apply TorchIO `RandomElasticDeformation`."""
 
@@ -334,7 +438,7 @@ class RandomElasticDeformation(CustomDictTransform):
             image_interpolation=image_interpolation,
             p=p))
 
-# %% ../nbs/03_vision_augment.ipynb 23
+# %% ../nbs/03_vision_augment.ipynb 24
 class RandomAffine(CustomDictTransform):
     """Apply TorchIO `RandomAffine`."""
 
@@ -350,14 +454,14 @@ class RandomAffine(CustomDictTransform):
             default_pad_value=default_pad_value,
             p=p))
 
-# %% ../nbs/03_vision_augment.ipynb 24
+# %% ../nbs/03_vision_augment.ipynb 25
 class RandomFlip(CustomDictTransform):
     """Apply TorchIO `RandomFlip`."""
 
     def __init__(self, axes='LR', p=0.5):
         super().__init__(tio.RandomFlip(axes=axes, flip_probability=p))
 
-# %% ../nbs/03_vision_augment.ipynb 25
+# %% ../nbs/03_vision_augment.ipynb 26
 class OneOf(CustomDictTransform):
     """Apply only one of the given transforms using TorchIO `OneOf`."""
 

fastMONAI/vision_core.py

@@ -1,7 +1,7 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/01_vision_core.ipynb.
 
 # %% auto 0
-__all__ = ['med_img_reader', 'MetaResolver', 'MedBase', 'MedImage', 'MedMask', 'VSCodeProgressCallback', 'setup_vscode_progress']
+__all__ = ['med_img_reader', 'MetaResolver', 'MedBase', 'MedImage', 'MedMask']
 
 # %% ../nbs/01_vision_core.ipynb 2
 from .vision_plot import *
@@ -10,26 +10,26 @@ from torchio import ScalarImage, LabelMap, ToCanonical, Resample
 import copy
 
 # %% ../nbs/01_vision_core.ipynb 5
-def _preprocess(obj, reorder, resample):
+def _preprocess(obj, apply_reorder, target_spacing):
     """
     Preprocesses the given object.
 
     Args:
         obj: The object to preprocess.
-        reorder: Whether to reorder the object.
-        resample: Whether to resample the object.
+        apply_reorder: Whether to reorder the object.
+        target_spacing: Whether to resample the object.
 
     Returns:
         The preprocessed object and its original size.
     """
-    if reorder:
+    if apply_reorder:
         transform = ToCanonical()
         obj = transform(obj)
 
     original_size = obj.shape[1:]
 
-    if resample and not all(np.isclose(obj.spacing, resample)):
-        transform = Resample(resample)
+    if target_spacing and not all(np.isclose(obj.spacing, target_spacing)):
+        transform = Resample(target_spacing)
         obj = transform(obj)
 
     if MedBase.affine_matrix is None:
@@ -38,33 +38,33 @@ def _preprocess(obj, reorder, resample):
     return obj, original_size
 
 # %% ../nbs/01_vision_core.ipynb 6
-def _load_and_preprocess(file_path, reorder, resample, dtype):
+def _load_and_preprocess(file_path, apply_reorder, target_spacing, dtype):
     """
     Helper function to load and preprocess an image.
 
     Args:
         file_path: Image file path.
-        reorder: Whether to reorder data for canonical (RAS+) orientation.
-        resample: Whether to resample image to different voxel sizes and dimensions.
+        apply_reorder: Whether to reorder data for canonical (RAS+) orientation.
+        target_spacing: Whether to resample image to different voxel sizes and dimensions.
         dtype: Desired datatype for output.
 
     Returns:
         tuple: Original image, preprocessed image, and its original size.
     """
     org_img = LabelMap(file_path) if dtype is MedMask else ScalarImage(file_path) #_load(file_path, dtype=dtype) 
-    input_img, org_size = _preprocess(org_img, reorder, resample)
+    input_img, org_size = _preprocess(org_img, apply_reorder, target_spacing)
     
     return org_img, input_img, org_size
 
 # %% ../nbs/01_vision_core.ipynb 7
-def _multi_channel(image_paths: L | list, reorder: bool, resample: list, only_tensor: bool, dtype):
+def _multi_channel(image_paths: L | list, apply_reorder: bool, target_spacing: list, only_tensor: bool, dtype):
     """
     Load and preprocess multisequence data.
 
     Args:
         image_paths: List of image paths (e.g., T1, T2, T1CE, DWI).
-        reorder: Whether to reorder data for canonical (RAS+) orientation.
-        resample: Whether to resample image to different voxel sizes and dimensions.
+        apply_reorder: Whether to reorder data for canonical (RAS+) orientation.
+        target_spacing: Whether to resample image to different voxel sizes and dimensions.
         only_tensor: Whether to return only image tensor.
         dtype: Desired datatype for output.
 
@@ -72,7 +72,7 @@ def _multi_channel(image_paths: L | list, reorder: bool, resample: list, only_te
         torch.Tensor: A stacked 4D tensor, if `only_tensor` is True.
         tuple: Original image, preprocessed image, original size, if `only_tensor` is False.
     """
-    image_data = [_load_and_preprocess(image, reorder, resample, dtype) for image in image_paths]
+    image_data = [_load_and_preprocess(image, apply_reorder, target_spacing, dtype) for image in image_paths]
     org_img, input_img, org_size = image_data[-1]
 
     tensor = torch.stack([img.data[0] for _, img, _ in image_data], dim=0)
@@ -84,15 +84,15 @@ def _multi_channel(image_paths: L | list, reorder: bool, resample: list, only_te
     return org_img, input_img, org_size
 
 # %% ../nbs/01_vision_core.ipynb 8
-def med_img_reader(file_path: str | Path | L | list, reorder: bool = False, resample: list = None, 
+def med_img_reader(file_path: str | Path | L | list, apply_reorder: bool = False, target_spacing: list = None, 
                    only_tensor: bool = True, dtype = torch.Tensor):
     """Loads and preprocesses a medical image.
 
     Args:
         file_path: Path to the image. Can be a string, Path object or a list.
-        reorder: Whether to reorder the data to be closest to canonical 
+        apply_reorder: Whether to reorder the data to be closest to canonical 
             (RAS+) orientation. Defaults to False.
-        resample: Whether to resample image to different voxel sizes and 
+        target_spacing: Whether to resample image to different voxel sizes and 
             image dimensions. Defaults to None.
         only_tensor: Whether to return only image tensor. Defaults to True.
         dtype: Datatype for the return value. Defaults to torch.Tensor.
@@ -104,10 +104,10 @@ def med_img_reader(file_path: str | Path | L | list, reorder: bool = False, resa
     """
     
     if isinstance(file_path, (list, L)):
-        return _multi_channel(file_path, reorder, resample, only_tensor, dtype)
+        return _multi_channel(file_path, apply_reorder, target_spacing, only_tensor, dtype)
 
     org_img, input_img, org_size = _load_and_preprocess(
-        file_path, reorder, resample, dtype)
+        file_path, apply_reorder, target_spacing, dtype)
 
     if only_tensor:
         return dtype(input_img.data.type(torch.float))
@@ -129,7 +129,7 @@ class MedBase(torch.Tensor, metaclass=MetaResolver):
     
     _bypass_type = torch.Tensor
     _show_args = {'cmap':'gray'}
-    resample, reorder = None, False
+    target_spacing, apply_reorder = None, False
     affine_matrix = None
 
     @classmethod
@@ -150,7 +150,7 @@ class MedBase(torch.Tensor, metaclass=MetaResolver):
         if isinstance(fn, torch.Tensor):
             return cls(fn)
 
-        return med_img_reader(fn, resample=cls.resample, reorder=cls.reorder, dtype=cls)
+        return med_img_reader(fn, target_spacing=cls.target_spacing, apply_reorder=cls.apply_reorder, dtype=cls)
 
     def __new__(cls, x, **kwargs):
         """Creates a new instance of MedBase from a tensor."""
@@ -196,18 +196,18 @@ class MedBase(torch.Tensor, metaclass=MetaResolver):
         return copied
 
     @classmethod
-    def item_preprocessing(cls, resample: (list, int, tuple), reorder: bool):
+    def item_preprocessing(cls, target_spacing: (list, int, tuple), apply_reorder: bool):
         """
-        Changes the values for the class variables `resample` and `reorder`.
+        Changes the values for the class variables `target_spacing` and `apply_reorder`.
 
         Args:
-            resample : (list, int, tuple)
+            target_spacing : (list, int, tuple)
                 A list with voxel spacing.
-            reorder : bool
+            apply_reorder : bool
                 Whether to reorder the data to be closest to canonical (RAS+) orientation.
         """
-        cls.resample = resample
-        cls.reorder = reorder
+        cls.target_spacing = target_spacing
+        cls.apply_reorder = apply_reorder
 
     def show(self, ctx=None, channel: int = 0, slice_index: int = None, anatomical_plane: int = 0, **kwargs):
         """
@@ -230,7 +230,7 @@ class MedBase(torch.Tensor, metaclass=MetaResolver):
         """
         return show_med_img(
             self, ctx=ctx, channel=channel, slice_index=slice_index, 
-            anatomical_plane=anatomical_plane, voxel_size=self.resample,  
+            anatomical_plane=anatomical_plane, voxel_size=self.target_spacing,  
             **merge(self._show_args, kwargs)
         )
 
@@ -247,106 +247,3 @@ class MedImage(MedBase):
 class MedMask(MedBase):
     """Subclass of MedBase that represents an mask object."""
     _show_args = {'alpha':0.5, 'cmap':'tab20'}
-
-# %% ../nbs/01_vision_core.ipynb 14
-import os
-from fastai.callback.progress import ProgressCallback
-from fastai.callback.core import Callback
-import sys
-from IPython import get_ipython
-
-class VSCodeProgressCallback(ProgressCallback):
-    """Enhanced progress callback that works better in VS Code notebooks."""
-    
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.is_vscode = self._detect_vscode_environment()
-        self.lr_find_progress = None
-        
-    def _detect_vscode_environment(self):
-        """Detect if running in VS Code Jupyter environment."""
-        ipython = get_ipython()
-        if ipython is None:
-            return True  # Assume VS Code if no IPython (safer default)
-        # VS Code detection - more comprehensive check
-        kernel_name = str(type(ipython.kernel)).lower() if hasattr(ipython, 'kernel') else ''
-        return ('vscode' in kernel_name or 
-                'zmq' in kernel_name or  # VS Code often uses ZMQInteractiveShell
-                not hasattr(ipython, 'display_pub'))  # Missing display publisher often indicates VS Code
-    
-    def before_fit(self):
-        """Initialize progress tracking before training."""
-        if self.is_vscode:
-            if hasattr(self.learn, 'lr_finder') and self.learn.lr_finder:
-                # This is lr_find, handle differently
-                print("🔍 Starting Learning Rate Finder...")
-                self.lr_find_progress = 0
-            else:
-                # Regular training
-                print(f"🚀 Training for {self.learn.n_epoch} epochs...")
-        super().before_fit()
-            
-    def before_epoch(self):
-        """Initialize epoch progress."""
-        if self.is_vscode:
-            if hasattr(self.learn, 'lr_finder') and self.learn.lr_finder:
-                print(f"📊 LR Find - Testing learning rates...")
-            else:
-                print(f"📈 Epoch {self.epoch+1}/{self.learn.n_epoch}")
-            sys.stdout.flush()
-        super().before_epoch()
-            
-    def after_batch(self):
-        """Update progress after each batch."""
-        super().after_batch()
-        if self.is_vscode:
-            if hasattr(self.learn, 'lr_finder') and self.learn.lr_finder:
-                # Special handling for lr_find
-                self.lr_find_progress = getattr(self, 'iter', 0) + 1
-                total = getattr(self, 'n_iter', 100)
-                if self.lr_find_progress % max(1, total // 10) == 0:
-                    progress = (self.lr_find_progress / total) * 100
-                    print(f"⏳ LR Find Progress: {self.lr_find_progress}/{total} ({progress:.1f}%)")
-                    sys.stdout.flush()
-            else:
-                # Regular training progress
-                if hasattr(self, 'iter') and hasattr(self, 'n_iter'):
-                    if self.iter % max(1, self.n_iter // 20) == 0:
-                        progress = (self.iter / self.n_iter) * 100
-                        print(f"⏳ Batch {self.iter}/{self.n_iter} ({progress:.1f}%)")
-                        sys.stdout.flush()
-                        
-    def after_fit(self):
-        """Complete progress tracking after training."""
-        if self.is_vscode:
-            if hasattr(self.learn, 'lr_finder') and self.learn.lr_finder:
-                print("✅ Learning Rate Finder completed!")
-            else:
-                print("✅ Training completed!")
-            sys.stdout.flush()
-        super().after_fit()
-                
-    def before_validate(self):
-        """Update before validation."""
-        if self.is_vscode and not (hasattr(self.learn, 'lr_finder') and self.learn.lr_finder):
-            print("🔄 Validating...")
-            sys.stdout.flush()
-        super().before_validate()
-        
-    def after_validate(self):
-        """Update after validation."""
-        if self.is_vscode and not (hasattr(self.learn, 'lr_finder') and self.learn.lr_finder):
-            print("✅ Validation completed")
-            sys.stdout.flush()
-        super().after_validate()
-
-def setup_vscode_progress():
-    """Configure fastai to use VS Code-compatible progress callback."""
-    from fastai.learner import defaults
-    
-    # Replace default ProgressCallback with VSCodeProgressCallback
-    if ProgressCallback in defaults.callbacks:
-        defaults.callbacks = [cb if cb != ProgressCallback else VSCodeProgressCallback 
-                            for cb in defaults.callbacks]
-    
-    print("✅ Configured VS Code-compatible progress callback")

fastMONAI/vision_data.py

@@ -27,7 +27,7 @@ def pred_to_multiclass_mask(pred: torch.Tensor) -> torch.Tensor:
     
     pred = pred.softmax(dim=0)
 
-    return pred.argmax(dim=0, keepdims=True)
+    return pred.argmax(dim=0, keepdim=True)
 
 # %% ../nbs/02_vision_data.ipynb 6
 def batch_pred_to_multiclass_mask(pred: torch.Tensor) -> (torch.Tensor, int):
@@ -68,12 +68,12 @@ class MedDataBlock(DataBlock):
     #TODO add get_x
     def __init__(self, blocks: list = None, dl_type: TfmdDL = None, getters: list = None,
                  n_inp: int | None = None, item_tfms: list = None, batch_tfms: list = None,
-                 reorder: bool = False, resample: (int, list) = None, **kwargs):
+                 apply_reorder: bool = False, target_spacing: (int, list) = None, **kwargs):
 
         super().__init__(blocks, dl_type, getters, n_inp, item_tfms,
                          batch_tfms, **kwargs)
 
-        MedBase.item_preprocessing(resample, reorder)
+        MedBase.item_preprocessing(target_spacing, apply_reorder)
 
 # %% ../nbs/02_vision_data.ipynb 11
 def MedMaskBlock():
@@ -88,7 +88,7 @@ class MedImageDataLoaders(DataLoaders):
     @delegates(DataLoaders.from_dblock)
     def from_df(cls, df, valid_pct=0.2, seed=None, fn_col=0, folder=None, suff='',
                 label_col=1, label_delim=None, y_block=None, valid_col=None,
-                item_tfms=None, batch_tfms=None, reorder=False, resample=None, **kwargs):
+                item_tfms=None, batch_tfms=None, apply_reorder=False, target_spacing=None, **kwargs):
         """Create from DataFrame."""
                     
         if y_block is None:
@@ -104,8 +104,8 @@ class MedImageDataLoaders(DataLoaders):
             get_y=ColReader(label_col, label_delim=label_delim),
             splitter=splitter,
             item_tfms=item_tfms,
-            reorder=reorder,
-            resample=resample
+            apply_reorder=apply_reorder,
+            target_spacing=target_spacing
         )
 
         return cls.from_dblock(dblock, df, **kwargs)