fastMONAI 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

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)

fastMONAI/vision_inference.py

@@ -2,7 +2,7 @@
 
 # %% auto 0
 __all__ = ['save_series_pred', 'load_system_resources', 'inference', 'compute_binary_tumor_volume', 'refine_binary_pred_mask',
-           'gradio_image_classifier']
+           'keep_largest', 'gradio_image_classifier']
 
 # %% ../nbs/06_vision_inference.ipynb 1
 from copy import copy
@@ -67,18 +67,18 @@ def load_system_resources(models_path, learner_fn, variables_fn):
 
     learn = load_learner(models_path / learner_fn, cpu=True) 
     vars_fn = models_path / variables_fn
-    _, reorder, resample = load_variables(pkl_fn=vars_fn)
+    _, apply_reorder, target_spacing = load_variables(pkl_fn=vars_fn)
 
-    return learn, reorder, resample
+    return learn, apply_reorder, target_spacing
 
 # %% ../nbs/06_vision_inference.ipynb 8
-def inference(learn_inf, reorder, resample, fn: (str, Path) = '',
+def inference(learn_inf, apply_reorder, target_spacing, fn: (str, Path) = '',
               save_path: (str, Path) = None, org_img=None, input_img=None,
               org_size=None): 
     """Predict on new data using exported model."""         
     
     if None in [org_img, input_img, org_size]: 
-        org_img, input_img, org_size = med_img_reader(fn, reorder, resample, 
+        org_img, input_img, org_size = med_img_reader(fn, apply_reorder, target_spacing, 
                                                       only_tensor=False)
     else: 
         org_img, input_img = copy(org_img), copy(input_img)
@@ -148,6 +148,10 @@ def refine_binary_pred_mask(pred_mask,
     if verbose:
         print(n_components)
 
+    # Handle empty mask case (no foreground components)
+    if n_components == 0:
+        return torch.zeros_like(torch.Tensor(pred_mask)).float()
+
     if remove_size is None:
         sizes = np.bincount(labeled_mask.ravel())
         max_label = sizes[1:].argmax() + 1
@@ -157,14 +161,36 @@ def refine_binary_pred_mask(pred_mask,
     processed_mask = remove_small_objects(
         labeled_mask, min_size=small_objects_threshold)
 
-    return torch.Tensor(processed_mask > 0).float()                          
+    return torch.Tensor(processed_mask > 0).float()
+
+# %% ../nbs/06_vision_inference.ipynb 12
+def keep_largest(pred_mask: torch.Tensor) -> torch.Tensor:
+    """Keep only the largest connected component in a binary mask.
+
+    Args:
+        pred_mask: Binary prediction mask tensor.
+
+    Returns:
+        Binary mask with only the largest connected component.
+    """
+    mask_np = pred_mask.numpy() if isinstance(pred_mask, torch.Tensor) else pred_mask
+    labeled_mask, n_components = label(mask_np)
+
+    if n_components == 0:
+        return torch.zeros_like(pred_mask) if isinstance(pred_mask, torch.Tensor) else mask_np
+
+    sizes = np.bincount(labeled_mask.ravel())
+    largest_label = sizes[1:].argmax() + 1  # Skip background (label 0)
+
+    result = (labeled_mask == largest_label).astype(np.float32)
+    return torch.from_numpy(result) if isinstance(pred_mask, torch.Tensor) else result
 
-# %% ../nbs/06_vision_inference.ipynb 13
-def gradio_image_classifier(file_obj, learn, reorder, resample):
+# %% ../nbs/06_vision_inference.ipynb 14
+def gradio_image_classifier(file_obj, learn, apply_reorder, target_spacing):
     """Predict on images using exported learner and return the result as a dictionary."""
     
     img_path = Path(file_obj.name)
-    img = med_img_reader(img_path, reorder=reorder, resample=resample)
+    img = med_img_reader(img_path, apply_reorder=apply_reorder, target_spacing=target_spacing)
     
     _, _, predictions = learn.predict(img)
     prediction_dict = {index: value.item() for index, value in enumerate(predictions)}