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

fastMONAI/vision_patch.py

@@ -18,8 +18,11 @@ from typing import Callable
 from torch.utils.data import DataLoader
 from tqdm.auto import tqdm
 from fastai.data.all import *
+from fastai.learner import Learner
 from .vision_core import MedImage, MedMask, MedBase, med_img_reader
 from .vision_inference import _to_original_orientation, _do_resize
+from .dataset_info import MedDataset, suggest_patch_size
+from .vision_augmentation import SpatialPad
 
 # %% ../nbs/10_vision_patch.ipynb 3
 def _get_default_device() -> torch.device:
@@ -109,7 +112,7 @@ class PatchConfig:
         queue_num_workers: Number of workers for parallel patch extraction.
         aggregation_mode: For inference, how to combine overlapping patches ('crop', 'average', 'hann').
         apply_reorder: Whether to reorder to RAS+ canonical orientation. Must match between
-            training and inference.
+            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.
         padding_mode: Padding mode for CropOrPad when image < patch_size. Default is 0 (zero padding)
@@ -124,7 +127,6 @@ class PatchConfig:
         ...     samples_per_volume=16,
         ...     sampler_type='label',
         ...     label_probabilities={0: 0.1, 1: 0.9},
-        ...     apply_reorder=True,
         ...     target_spacing=[0.5, 0.5, 0.5]
         ... )
     """
@@ -137,7 +139,7 @@ class PatchConfig:
     queue_num_workers: int = 4
     aggregation_mode: str = 'hann'
     # Preprocessing parameters - must match between training and inference
-    apply_reorder: bool = False
+    apply_reorder: bool = True  # Defaults to True (the common case)
     target_spacing: list = None
     padding_mode: int | float | str = 0  # Zero padding (nnU-Net standard)
     # Post-processing (binary segmentation only)
@@ -176,6 +178,74 @@ class PatchConfig:
                         f"Overlap >= patch_size creates step_size <= 0 (infinite patches)."
                     )
 
+    @classmethod
+    def from_dataset(
+        cls,
+        dataset: 'MedDataset',
+        target_spacing: list = None,
+        min_patch_size: list = None,
+        max_patch_size: list = None,
+        divisor: int = 16,
+        **kwargs
+    ) -> 'PatchConfig':
+        """Create PatchConfig with automatic patch_size from dataset analysis.
+
+        Combines dataset preprocessing suggestions with patch size calculation
+        for a complete, DRY configuration.
+
+        Args:
+            dataset: MedDataset instance with analyzed images.
+            target_spacing: Target voxel spacing [x, y, z]. If None, uses
+                dataset.get_suggestion()['target_spacing'].
+            min_patch_size: Minimum per dimension [32, 32, 32].
+            max_patch_size: Maximum per dimension [256, 256, 256].
+            divisor: Divisibility constraint (default 16 for UNet compatibility).
+            **kwargs: Additional PatchConfig parameters (samples_per_volume,
+                sampler_type, label_probabilities, etc.).
+
+        Returns:
+            PatchConfig with suggested patch_size, apply_reorder, target_spacing.
+
+        Example:
+            >>> from fastMONAI.dataset_info import MedDataset
+            >>> dataset = MedDataset(dataframe=df, mask_col='mask_path', dtype=MedMask)
+            >>> 
+            >>> # Use recommended spacing
+            >>> config = PatchConfig.from_dataset(dataset, samples_per_volume=16)
+            >>> 
+            >>> # Use custom spacing
+            >>> config = PatchConfig.from_dataset(
+            ...     dataset,
+            ...     target_spacing=[1.0, 1.0, 2.0],
+            ...     samples_per_volume=16
+            ... )
+        """
+        # Get preprocessing suggestion from dataset
+        suggestion = dataset.get_suggestion()
+
+        # Use explicit spacing or dataset suggestion
+        _target_spacing = target_spacing if target_spacing is not None else suggestion['target_spacing']
+
+        # Calculate patch size for the target spacing
+        patch_size = suggest_patch_size(
+            dataset,
+            target_spacing=_target_spacing,
+            min_patch_size=min_patch_size,
+            max_patch_size=max_patch_size,
+            divisor=divisor
+        )
+
+        # Merge with explicit kwargs (kwargs override defaults)
+        # Use dataset.apply_reorder directly (not from get_suggestion() since it's not data-derived)
+        config_kwargs = {
+            'patch_size': patch_size,
+            'apply_reorder': dataset.apply_reorder,
+            'target_spacing': _target_spacing,
+        }
+        config_kwargs.update(kwargs)
+
+        return cls(**config_kwargs)
+
 # %% ../nbs/10_vision_patch.ipynb 10
 def med_to_subject(
     img: Path | str,
@@ -374,6 +444,9 @@ class MedPatchDataLoader:
             drop_last=drop_last
         )
 
+        # Track cleanup state
+        self._closed = False
+
     def __iter__(self):
         """Iterate over batches, yielding (image, mask) tuples."""
         for batch in self._dl:
@@ -444,6 +517,31 @@ class MedPatchDataLoader:
         """
         return next(iter(self))
 
+    def close(self):
+        """Shut down TorchIO Queue workers. Safe to call multiple times."""
+        if self._closed:
+            return
+        self._closed = True
+        try:
+            # Trigger cleanup of Queue's internal DataLoader iterator
+            if hasattr(self, 'queue') and hasattr(self.queue, '_subjects_iterable'):
+                self.queue._subjects_iterable = None
+        except Exception:
+            pass  # Suppress cleanup errors
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
 # %% ../nbs/10_vision_patch.ipynb 18
 class MedPatchDataLoaders:
     """fastai-compatible DataLoaders for patch-based training with LAZY loading.
@@ -454,6 +552,12 @@ class MedPatchDataLoaders:
     Memory-efficient: Volumes are loaded on-demand by Queue workers,
     keeping memory usage constant (~150 MB) regardless of dataset size.
 
+    **Automatic padding**: Images smaller than patch_size are **automatically padded**
+    using SpatialPad (zero padding, nnU-Net standard). Dimensions larger than patch_size
+    are preserved. A message is printed at DataLoader creation to inform you that
+    automatic padding is enabled. This ensures training matches inference behavior
+    where both pad small dimensions to minimum patch_size.
+
     Note: Validation uses the same sampling as training (pseudo Dice).
     For true validation metrics, use PatchInferenceEngine with GridSampler
     for full-volume sliding window inference.
@@ -491,6 +595,9 @@ class MedPatchDataLoaders:
         self._train_dl.to(self._device)
         self._valid_dl.to(self._device)
 
+        # Track cleanup state
+        self._closed = False
+
     @classmethod
     def from_df(
         cls,
@@ -528,6 +635,7 @@ class MedPatchDataLoaders:
                 target_spacing) can be set here for DRY usage with PatchInferenceEngine.
             pre_patch_tfms: TorchIO transforms applied before patch extraction
                            (after reorder/resample). Example: [tio.ZNormalization()].
+                           Accepts both fastMONAI wrappers and raw TorchIO transforms.
             patch_tfms: TorchIO transforms applied to extracted patches (training only).
             apply_reorder: If True, reorder to RAS+ orientation. If None, uses
                 patch_config.apply_reorder. Explicit value overrides config.
@@ -595,9 +703,19 @@ class MedPatchDataLoaders:
         if _target_spacing is not None:
             all_pre_tfms.append(tio.Resample(_target_spacing))
 
-        # Add user-provided transforms
+        # Add user-provided transforms (normalize to raw TorchIO transforms)
         if pre_patch_tfms:
-            all_pre_tfms.extend(pre_patch_tfms)
+            all_pre_tfms.extend(normalize_patch_transforms(pre_patch_tfms))
+
+        # Add SpatialPad to ensure minimum patch_size
+        # Pads small dimensions to patch_size while preserving large dimensions.
+        # Uses zero padding (nnU-Net standard) to match inference behavior.
+        # Placed AFTER normalization ensures consistent intensity preprocessing.
+        spatial_pad = SpatialPad(spatial_size=patch_config.patch_size)
+        all_pre_tfms.append(spatial_pad.tio_transform)
+
+        # Inform user about automatic padding (transparency)
+        print(f"ℹ️  Automatic padding enabled: dimensions smaller than patch_size {patch_config.patch_size} will be padded (larger dimensions preserved)")
 
         # Create subjects datasets with lazy loading (paths only, ~0 MB)
         train_subjects = create_subjects_dataset(
@@ -743,9 +861,36 @@ class MedPatchDataLoaders:
             def to(self, device):
                 self._device = device
                 return self
+            def cpu(self):
+                """Move to CPU. Required for load_learner compatibility."""
+                return self.to(torch.device('cpu'))
 
         return EmptyMedPatchDataLoaders(self._device)
 
+    def close(self):
+        """Shut down all DataLoader workers. Safe to call multiple times."""
+        if self._closed:
+            return
+        self._closed = True
+        if hasattr(self, '_train_dl') and self._train_dl is not None:
+            self._train_dl.close()
+        if hasattr(self, '_valid_dl') and self._valid_dl is not None:
+            self._valid_dl.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+        return False
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
+
 # %% ../nbs/10_vision_patch.ipynb 20
 import numbers
 
@@ -806,7 +951,8 @@ class PatchInferenceEngine:
     GridAggregator to reconstruct the full volume from predictions.
     
     Args:
-        learner: PyTorch model or fastai Learner.
+        learner: fastai Learner or PyTorch model (nn.Module). When passing a raw
+            PyTorch model, load weights first with model.load_state_dict().
         config: PatchConfig with inference settings. Preprocessing params (apply_reorder,
             target_spacing, padding_mode) can be set here for DRY usage.
         apply_reorder: Whether to reorder to RAS+ orientation. If None, uses config value.
@@ -815,21 +961,18 @@ class PatchInferenceEngine:
         pre_inference_tfms: List of TorchIO transforms to apply before patch extraction.
             IMPORTANT: Should match the pre_patch_tfms used during training (e.g., [tio.ZNormalization()]).
             This ensures preprocessing consistency between training and inference.
+            Accepts both fastMONAI wrappers and raw TorchIO transforms.
     
     Example:
-        >>> # DRY pattern: use same config for training and inference
-        >>> config = PatchConfig(
-        ...     patch_size=[96, 96, 96],
-        ...     apply_reorder=True,
-        ...     target_spacing=[1.0, 1.0, 1.0]
-        ... )
-        >>> # Training
-        >>> dls = MedPatchDataLoaders.from_df(df, 'img', 'mask', patch_config=config)
-        >>> # Inference - no need to repeat params!
-        >>> engine = PatchInferenceEngine(
-        ...     learn, config,
-        ...     pre_inference_tfms=[tio.ZNormalization()]
-        ... )
+        >>> # Option 1: From fastai Learner
+        >>> engine = PatchInferenceEngine(learn, config, pre_inference_tfms=[ZNormalization()])
+        >>> pred = engine.predict('image.nii.gz')
+        
+        >>> # Option 2: From raw PyTorch model (recommended for deployment)
+        >>> model = UNet(spatial_dims=3, in_channels=1, out_channels=2, ...)
+        >>> model.load_state_dict(torch.load('weights.pth'))
+        >>> model.cuda().eval()
+        >>> engine = PatchInferenceEngine(model, config, pre_inference_tfms=[ZNormalization()])
         >>> pred = engine.predict('image.nii.gz')
     """
     
@@ -845,11 +988,20 @@ class PatchInferenceEngine:
         if batch_size <= 0:
             raise ValueError(f"batch_size must be positive, got {batch_size}")
         
-        # Extract model from Learner if needed
-        self.model = learner.model if hasattr(learner, 'model') else learner
+        # Extract model from Learner if needed (use isinstance for robust detection)
+        # Note: We check for Learner explicitly because some models (e.g., MONAI UNet)
+        # have a .model attribute that is NOT the full model but an internal Sequential.
+        if isinstance(learner, Learner):
+            self.model = learner.model
+        else:
+            self.model = learner  # Assume it's already a PyTorch model
+        
         self.config = config
         self.batch_size = batch_size
-        self.pre_inference_tfms = tio.Compose(pre_inference_tfms) if pre_inference_tfms else None
+        
+        # Normalize transforms to raw TorchIO (accepts both fastMONAI wrappers and raw TorchIO)
+        normalized_tfms = normalize_patch_transforms(pre_inference_tfms)
+        self.pre_inference_tfms = tio.Compose(normalized_tfms) if normalized_tfms else None
         
         # Use config values, allow explicit overrides for backward compatibility
         self.apply_reorder = apply_reorder if apply_reorder is not None else config.apply_reorder
@@ -1024,7 +1176,7 @@ class PatchInferenceEngine:
         self.model.to(device)
         return self
 
-# %% ../nbs/10_vision_patch.ipynb 21
+# %% ../nbs/10_vision_patch.ipynb 22
 def patch_inference(
     learner,
     config: PatchConfig,

fastMONAI/vision_plot.py

@@ -1,7 +1,7 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/00_vision_plot.ipynb.
 
 # %% auto 0
-__all__ = ['validate_anatomical_plane', 'show_med_img', 'find_max_slice']
+__all__ = ['validate_anatomical_plane', 'show_med_img', 'find_max_slice', 'show_segmentation_comparison']
 
 # %% ../nbs/00_vision_plot.ipynb 1
 import warnings
@@ -115,3 +115,91 @@ def find_max_slice(mask_data, anatomical_plane):
     idx = np.argmax(sums)
 
     return idx
+
+# %% ../nbs/00_vision_plot.ipynb 7
+def show_segmentation_comparison(
+    image, ground_truth, prediction,
+    slice_index: int = None,
+    anatomical_plane: int = 2,
+    metric_value: float = None,
+    metric_name: str = 'DSC',
+    channel: int = 0,
+    figsize: tuple = (15, 5),
+    cmap_img: str = 'gray',
+    cmap_mask: str = 'gray',
+    voxel_size = None
+):
+    """Display 3-panel comparison: Image | Ground Truth | Prediction.
+    
+    Useful for validating segmentation results, especially after patch-based 
+    inference where results are not in standard fastai batch format.
+    
+    Args:
+        image: Input image (MedImage, MedMask, or tensor [C, H, W, D])
+        ground_truth: Ground truth mask (MedMask or tensor [C, H, W, D])
+        prediction: Predicted mask (tensor [C, H, W, D])
+        slice_index: Slice to display. If None, uses find_max_slice on ground_truth.
+        anatomical_plane: 0=sagittal, 1=coronal, 2=axial (default)
+        metric_value: Optional metric value to display in prediction title
+        metric_name: Name of metric for title (default 'DSC')
+        channel: Channel to display for multi-channel data (default 0)
+        figsize: Figure size (default (15, 5))
+        cmap_img: Colormap for image (default 'gray')
+        cmap_mask: Colormap for masks (default 'gray')
+        voxel_size: Voxel spacing for aspect ratio. If None, aspect=1.
+
+    Example::
+    
+        # After patch_inference()
+        show_segmentation_comparison(
+            image=val_img,
+            ground_truth=val_gt,
+            prediction=predictions[0],
+            metric_value=results_df.iloc[0]['DSC'],
+            anatomical_plane=2
+        )
+    """
+    validate_anatomical_plane(anatomical_plane)
+    
+    # Ensure we have tensor data
+    img_data = image.data if hasattr(image, 'data') else image
+    gt_data = ground_truth.data if hasattr(ground_truth, 'data') else ground_truth
+    pred_data = prediction.data if hasattr(prediction, 'data') else prediction
+    
+    # Move to CPU if needed
+    if hasattr(img_data, 'cpu'): img_data = img_data.cpu()
+    if hasattr(gt_data, 'cpu'): gt_data = gt_data.cpu()
+    if hasattr(pred_data, 'cpu'): pred_data = pred_data.cpu()
+    
+    # Find optimal slice if not provided
+    if slice_index is None:
+        gt_np = gt_data[channel].numpy()
+        slice_index = find_max_slice(gt_np, anatomical_plane)
+    
+    # Create figure
+    fig, axes = plt.subplots(1, 3, figsize=figsize)
+    
+    # Get slices with proper aspect ratio using existing _get_slice helper
+    img_slice, img_aspect = _get_slice(img_data, channel, slice_index, anatomical_plane, voxel_size)
+    gt_slice, gt_aspect = _get_slice(gt_data, channel, slice_index, anatomical_plane, voxel_size)
+    pred_slice, pred_aspect = _get_slice(pred_data, channel, slice_index, anatomical_plane, voxel_size)
+    
+    # Plot panels
+    axes[0].imshow(img_slice, cmap=cmap_img, aspect=img_aspect)
+    axes[0].set_title('Input Image')
+    axes[0].axis('off')
+    
+    axes[1].imshow(gt_slice, cmap=cmap_mask, aspect=gt_aspect)
+    axes[1].set_title('Ground Truth')
+    axes[1].axis('off')
+    
+    # Build prediction title
+    pred_title = 'Prediction'
+    if metric_value is not None:
+        pred_title = f'Prediction ({metric_name}: {metric_value:.4f})'
+    
+    axes[2].imshow(pred_slice, cmap=cmap_mask, aspect=pred_aspect)
+    axes[2].set_title(pred_title)
+    axes[2].axis('off')
+    
+    plt.tight_layout()

{fastmonai-0.5.4.dist-info → fastmonai-0.6.1.dist-info}/METADATA

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

fastmonai-0.6.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+fastMONAI/__init__.py,sha256=baAcEjLSYFIeNZF51tOMmA_zAMhN8HvKael-UU-Ruec,22
+fastMONAI/_modidx.py,sha256=x9tW-MTHa2dTdBrQPd15CxAiBtTVMGKTkW54SCu0u6A,67370
+fastMONAI/dataset_info.py,sha256=hLNX0Jps8dPCbF6HYPO2PScZtn2qqAQBH07LtSubeFM,16306
+fastMONAI/external_data.py,sha256=Ofa6RmSKYj8LKlzWqPGfg9lu9lTjBmolJTo1zVgTe6g,12263
+fastMONAI/research_utils.py,sha256=LZu62g8BQAVYS4dD7qDsKHJXZnDd1uLkJ6LoaMDhUhk,590
+fastMONAI/utils.py,sha256=8avga5wIGK4IlJ04SrN_Ba5STkBSuEA5G06EvdDHNBs,30493
+fastMONAI/vision_all.py,sha256=L2JVYQq77X7Ko2SmzKUGAXwVjw898V_skGuQuYxjVd8,385
+fastMONAI/vision_augmentation.py,sha256=ym7scsWCRQ5Zh7MGwK653IFWyhEYYGgggJkwR4mhOCA,27276
+fastMONAI/vision_core.py,sha256=xXGnutYD3sdWzpoMZHSfClUFmphsB7yFsDcY91Fa844,9539
+fastMONAI/vision_data.py,sha256=_SgwSlNm4ZOooFnrp5vYnA7ZAweV60a3XaOnozDKm6w,11569
+fastMONAI/vision_inference.py,sha256=fRPgIO-3XifBlCZY7qaucgymSLQQajcKvmZKWg0XfS4,7688
+fastMONAI/vision_loss.py,sha256=NrHnk1yD4EBKsp6aippppXU4l-mwmsZOqE_bsZP3ZNI,3591
+fastMONAI/vision_metrics.py,sha256=OED2ewWaZUtmkqc5CjmBWDboTVUlpsnsuFU-ZrIw4tI,18572
+fastMONAI/vision_patch.py,sha256=1TFDGPL0SiJM9vIS217mMgChqVtnipuJQ7xoXM-3nAU,51204
+fastMONAI/vision_plot.py,sha256=7HLkKQAwmwPvwrDxWlKP5IIHNNwWIrLkdsejqlOc27k,7282
+fastmonai-0.6.1.dist-info/licenses/LICENSE,sha256=xV8xoN4VOL0uw9X8RSs2IMuD_Ss_a9yAbtGNeBWZwnw,11337
+fastmonai-0.6.1.dist-info/METADATA,sha256=qP179D1B953PnbEo3ee9EufYLZxKv7nuqeHNSDC6fOQ,7075
+fastmonai-0.6.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+fastmonai-0.6.1.dist-info/entry_points.txt,sha256=mVBsykSXMairzzk3hJaQ8c-UiwUZqGnn4aFZ24CpsBM,40
+fastmonai-0.6.1.dist-info/top_level.txt,sha256=o8y7SWF9odtnIT3jvYtUn9okbJRlaAMCy7oPFCeQvQ8,10
+fastmonai-0.6.1.dist-info/RECORD,,

fastmonai-0.5.4.dist-info/RECORD

@@ -1,21 +0,0 @@
-fastMONAI/__init__.py,sha256=DITpct-LrdIsTgwx2NgH5Ghx5y8Xgz1YMimy1ZV5RTY,22
-fastMONAI/_modidx.py,sha256=eEccmLX_gTevLLfGe2ywec46xRkZrduEndx1lDMEync,59028
-fastMONAI/dataset_info.py,sha256=BzbTZAGTQ5idyXqf-tna84No5tu9Fjo2RJA6lTqhaW8,11043
-fastMONAI/external_data.py,sha256=Ofa6RmSKYj8LKlzWqPGfg9lu9lTjBmolJTo1zVgTe6g,12263
-fastMONAI/research_utils.py,sha256=LZu62g8BQAVYS4dD7qDsKHJXZnDd1uLkJ6LoaMDhUhk,590
-fastMONAI/utils.py,sha256=6bUgyVzUenkAUtf9gxJXeRsz2xc8uzjqsvzU2UVDKNI,19944
-fastMONAI/vision_all.py,sha256=L2JVYQq77X7Ko2SmzKUGAXwVjw898V_skGuQuYxjVd8,385
-fastMONAI/vision_augmentation.py,sha256=EFEUkpU7xaGJGZd6iCqOfDe56zVrgAV8t_UC0iAAum0,15611
-fastMONAI/vision_core.py,sha256=xXGnutYD3sdWzpoMZHSfClUFmphsB7yFsDcY91Fa844,9539
-fastMONAI/vision_data.py,sha256=_SgwSlNm4ZOooFnrp5vYnA7ZAweV60a3XaOnozDKm6w,11569
-fastMONAI/vision_inference.py,sha256=fRPgIO-3XifBlCZY7qaucgymSLQQajcKvmZKWg0XfS4,7688
-fastMONAI/vision_loss.py,sha256=NrHnk1yD4EBKsp6aippppXU4l-mwmsZOqE_bsZP3ZNI,3591
-fastMONAI/vision_metrics.py,sha256=OED2ewWaZUtmkqc5CjmBWDboTVUlpsnsuFU-ZrIw4tI,18572
-fastMONAI/vision_patch.py,sha256=C-LQEYt1bYCdmWG9PZJdCqlB1ucqNEA40qVF5gDA_Bs,44927
-fastMONAI/vision_plot.py,sha256=hdQQtS2fRdImKQABaUtK0vpmRw4hHEE8oZnsKAGy-0o,3808
-fastmonai-0.5.4.dist-info/licenses/LICENSE,sha256=xV8xoN4VOL0uw9X8RSs2IMuD_Ss_a9yAbtGNeBWZwnw,11337
-fastmonai-0.5.4.dist-info/METADATA,sha256=ssu77BruDlG-RdrjO2ee7x43WzbPN1WSytpmLgkd4YE,7075
-fastmonai-0.5.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-fastmonai-0.5.4.dist-info/entry_points.txt,sha256=mVBsykSXMairzzk3hJaQ8c-UiwUZqGnn4aFZ24CpsBM,40
-fastmonai-0.5.4.dist-info/top_level.txt,sha256=o8y7SWF9odtnIT3jvYtUn9okbJRlaAMCy7oPFCeQvQ8,10
-fastmonai-0.5.4.dist-info/RECORD,,