fastMONAI 0.4.0.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

fastMONAI/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.0.2"
+__version__ = "0.5.1"

fastMONAI/_modidx.py

@@ -47,7 +47,41 @@ d = { 'settings': { 'branch': 'master',
                                                                                                'fastMONAI/external_data.py')},
             'fastMONAI.research_utils': { 'fastMONAI.research_utils.pred_postprocess': ( 'research_utils.html#pred_postprocess',
                                                                                          'fastMONAI/research_utils.py')},
-            'fastMONAI.utils': { 'fastMONAI.utils.load_variables': ('utils.html#load_variables', 'fastMONAI/utils.py'),
+            'fastMONAI.utils': { 'fastMONAI.utils.MLflowUIManager': ('utils.html#mlflowuimanager', 'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.MLflowUIManager.__init__': ('utils.html#mlflowuimanager.__init__', 'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.MLflowUIManager.check_mlflow_installed': ( 'utils.html#mlflowuimanager.check_mlflow_installed',
+                                                                                             'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.MLflowUIManager.find_available_port': ( 'utils.html#mlflowuimanager.find_available_port',
+                                                                                          'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.MLflowUIManager.is_mlflow_running': ( 'utils.html#mlflowuimanager.is_mlflow_running',
+                                                                                        'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.MLflowUIManager.is_port_available': ( 'utils.html#mlflowuimanager.is_port_available',
+                                                                                        'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.MLflowUIManager.start_ui': ('utils.html#mlflowuimanager.start_ui', 'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.MLflowUIManager.status': ('utils.html#mlflowuimanager.status', 'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.MLflowUIManager.stop': ('utils.html#mlflowuimanager.stop', 'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback': ('utils.html#modeltrackingcallback', 'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback.__init__': ( 'utils.html#modeltrackingcallback.__init__',
+                                                                                     'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback._build_config': ( 'utils.html#modeltrackingcallback._build_config',
+                                                                                          'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback._extract_epoch_metrics': ( 'utils.html#modeltrackingcallback._extract_epoch_metrics',
+                                                                                                   'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback._extract_training_params': ( 'utils.html#modeltrackingcallback._extract_training_params',
+                                                                                                     'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback._register_pytorch_model': ( 'utils.html#modeltrackingcallback._register_pytorch_model',
+                                                                                                    'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback._save_model_artifacts': ( 'utils.html#modeltrackingcallback._save_model_artifacts',
+                                                                                                  'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback.after_epoch': ( 'utils.html#modeltrackingcallback.after_epoch',
+                                                                                        'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback.after_fit': ( 'utils.html#modeltrackingcallback.after_fit',
+                                                                                      'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback.before_fit': ( 'utils.html#modeltrackingcallback.before_fit',
+                                                                                       'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.ModelTrackingCallback.extract_all_params': ( 'utils.html#modeltrackingcallback.extract_all_params',
+                                                                                               'fastMONAI/utils.py'),
+                                 'fastMONAI.utils.load_variables': ('utils.html#load_variables', 'fastMONAI/utils.py'),
                                  'fastMONAI.utils.print_colab_gpu_info': ('utils.html#print_colab_gpu_info', 'fastMONAI/utils.py'),
                                  'fastMONAI.utils.store_variables': ('utils.html#store_variables', 'fastMONAI/utils.py')},
             'fastMONAI.vision_all': {},
@@ -138,23 +172,51 @@ d = { 'settings': { 'branch': 'master',
                                                'fastMONAI.vision_augmentation.do_pad_or_crop': ( 'vision_augment.html#do_pad_or_crop',
                                                                                                  'fastMONAI/vision_augmentation.py')},
             'fastMONAI.vision_core': { 'fastMONAI.vision_core.MedBase': ('vision_core.html#medbase', 'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.MedBase.__copy__': ( 'vision_core.html#medbase.__copy__',
+                                                                                   'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.MedBase.__deepcopy__': ( 'vision_core.html#medbase.__deepcopy__',
+                                                                                       'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.MedBase.__new__': ( 'vision_core.html#medbase.__new__',
+                                                                                  'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core.MedBase.__repr__': ( 'vision_core.html#medbase.__repr__',
                                                                                    'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core.MedBase.create': ( 'vision_core.html#medbase.create',
                                                                                  'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core.MedBase.item_preprocessing': ( 'vision_core.html#medbase.item_preprocessing',
                                                                                              'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.MedBase.new_empty': ( 'vision_core.html#medbase.new_empty',
+                                                                                    'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core.MedBase.show': ('vision_core.html#medbase.show', 'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core.MedImage': ('vision_core.html#medimage', 'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core.MedMask': ('vision_core.html#medmask', 'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core.MetaResolver': ('vision_core.html#metaresolver', 'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.VSCodeProgressCallback': ( 'vision_core.html#vscodeprogresscallback',
+                                                                                         'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.VSCodeProgressCallback.__init__': ( 'vision_core.html#vscodeprogresscallback.__init__',
+                                                                                                  'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.VSCodeProgressCallback._detect_vscode_environment': ( 'vision_core.html#vscodeprogresscallback._detect_vscode_environment',
+                                                                                                                    'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.VSCodeProgressCallback.after_batch': ( 'vision_core.html#vscodeprogresscallback.after_batch',
+                                                                                                     'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.VSCodeProgressCallback.after_fit': ( 'vision_core.html#vscodeprogresscallback.after_fit',
+                                                                                                   'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.VSCodeProgressCallback.after_validate': ( 'vision_core.html#vscodeprogresscallback.after_validate',
+                                                                                                        'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.VSCodeProgressCallback.before_epoch': ( 'vision_core.html#vscodeprogresscallback.before_epoch',
+                                                                                                      'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.VSCodeProgressCallback.before_fit': ( 'vision_core.html#vscodeprogresscallback.before_fit',
+                                                                                                    'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.VSCodeProgressCallback.before_validate': ( 'vision_core.html#vscodeprogresscallback.before_validate',
+                                                                                                         'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core._load_and_preprocess': ( 'vision_core.html#_load_and_preprocess',
                                                                                        'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core._multi_channel': ( 'vision_core.html#_multi_channel',
                                                                                  'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core._preprocess': ('vision_core.html#_preprocess', 'fastMONAI/vision_core.py'),
                                        'fastMONAI.vision_core.med_img_reader': ( 'vision_core.html#med_img_reader',
-                                                                                 'fastMONAI/vision_core.py')},
+                                                                                 'fastMONAI/vision_core.py'),
+                                       'fastMONAI.vision_core.setup_vscode_progress': ( 'vision_core.html#setup_vscode_progress',
+                                                                                        'fastMONAI/vision_core.py')},
             'fastMONAI.vision_data': { 'fastMONAI.vision_data.MedDataBlock': ('vision_data.html#meddatablock', 'fastMONAI/vision_data.py'),
                                        'fastMONAI.vision_data.MedDataBlock.__init__': ( 'vision_data.html#meddatablock.__init__',
                                                                                         'fastMONAI/vision_data.py'),

fastMONAI/dataset_info.py

@@ -69,12 +69,12 @@ class MedDataset:
     def suggestion(self):
         """Voxel value that appears most often in dim_0, dim_1 and dim_2, and whether the data should be reoriented."""
         
-        resample = [self.df.voxel_0.mode()[0], self.df.voxel_1.mode()[0], self.df.voxel_2.mode()[0]]
+        resample = [float(self.df.voxel_0.mode()[0]), float(self.df.voxel_1.mode()[0]), float(self.df.voxel_2.mode()[0])]
         return resample, self.reorder
 
     def _get_data_info(self, fn: str):
         """Private method to collect information about an image file."""
-        _, o, _ = med_img_reader(fn, dtype=self.dtype, reorder=self.reorder, only_tensor=False)
+        _, o, _ = med_img_reader(fn, reorder=self.reorder, only_tensor=False, dtype=self.dtype)
 
         info_dict = {'path': fn, 'dim_0': o.shape[1], 'dim_1': o.shape[2], 'dim_2': o.shape[3],
                      'voxel_0': round(o.spacing[0], 4), 'voxel_1': round(o.spacing[1], 4), 'voxel_2': round(o.spacing[2], 4),
@@ -98,10 +98,10 @@ class MedDataset:
 
             ratio = org_voxels/resample
             new_dims = (org_dims * ratio).T
-            dims = [new_dims[0].max().round(), new_dims[1].max().round(), new_dims[2].max().round()]
+            dims = [float(new_dims[0].max().round()), float(new_dims[1].max().round()), float(new_dims[2].max().round())]
 
         else:
-            dims = [df.dim_0.max(), df.dim_1.max(), df.dim_2.max()]
+            dims = [float(self.df.dim_0.max()), float(self.df.dim_1.max()), float(self.df.dim_2.max())]
 
         return dims
 

fastMONAI/utils.py

@@ -1,15 +1,23 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/07_utils.ipynb.
 
 # %% auto 0
-__all__ = ['store_variables', 'load_variables', 'print_colab_gpu_info']
+__all__ = ['store_variables', 'load_variables', 'print_colab_gpu_info', 'ModelTrackingCallback', 'MLflowUIManager']
 
 # %% ../nbs/07_utils.ipynb 1
 import pickle
 import torch
 from pathlib import Path
+import mlflow
+import mlflow.pytorch
+import os
+import tempfile
+import json
+from fastai.callback.core import Callback
+from fastcore.foundation import L
+from typing import Any
 
 # %% ../nbs/07_utils.ipynb 3
-def store_variables(pkl_fn: (str, Path), size: list, reorder: bool, resample: (int, list)):
+def store_variables(pkl_fn: str | Path, size: list, reorder: bool, resample: int | list):
     """Save variable values in a pickle file."""
     
     var_vals = [size, reorder, resample]
@@ -43,3 +51,361 @@ def print_colab_gpu_info():
     
     if torch.cuda.is_available(): print('GPU attached.')
     else: print(colab_gpu_msg)
+
+# %% ../nbs/07_utils.ipynb 6
+class ModelTrackingCallback(Callback):
+    """
+    A FastAI callback for comprehensive MLflow experiment tracking.
+    
+    This callback automatically logs hyperparameters, metrics, model artifacts,
+    and configuration to MLflow during training.
+    """
+    
+    def __init__(
+        self, 
+        model_name: str, 
+        loss_function: str, 
+        item_tfms: list[Any],
+        size: list[int], 
+        resample: list[float], 
+        reorder: bool
+    ):
+        """
+        Initialize the MLflow tracking callback.
+        
+        Args:
+            model_name: Name of the model architecture for registration
+            loss_function: Name of the loss function being used
+            size: Model input dimensions
+            resample: Resampling dimensions
+            reorder: Whether reordering augmentation is applied
+        """
+        self.model_name = model_name
+        self.loss_function = loss_function
+        self.item_tfms = item_tfms
+        self.size = size
+        self.resample = resample
+        self.reorder = reorder
+        
+        self.config = self._build_config()
+        
+    def extract_all_params(self, tfm):
+        """
+        Extract all parameters from a transform object for detailed logging.
+        
+        Args:
+            tfm: Transform object to extract parameters from
+            
+        Returns:
+            dict: Dictionary with 'name' and 'params' keys containing transform details
+        """
+        class_name = tfm.__class__.__name__
+        params = {}
+        
+        for key, value in tfm.__dict__.items():
+            if not key.startswith('_') and key != '__signature__':
+                if hasattr(value, '__dict__') and hasattr(value, 'target_shape'):
+                    params['target_shape'] = value.target_shape
+                elif hasattr(value, '__dict__') and not key.startswith('_'):
+                    nested_params = {k: v for k, v in value.__dict__.items() 
+                                   if not k.startswith('_') and isinstance(v, (int, float, str, bool, tuple, list))}
+                    params.update(nested_params)
+                elif isinstance(value, (int, float, str, bool, tuple, list)):
+                    params[key] = value
+        
+        return {
+            'name': class_name,
+            'params': params
+        }
+        
+    def _build_config(self) -> dict[str, Any]:
+        """Build configuration dictionary from initialization parameters."""
+        # Extract detailed transform information
+        transform_details = [self.extract_all_params(tfm) for tfm in self.item_tfms]
+        
+        return {
+            "model_name": self.model_name,
+            "loss_function": self.loss_function,
+            "transform_details": transform_details,
+            "size": self.size,
+            "resample": self.resample,
+            "reorder": self.reorder,
+        }
+    
+    def _extract_training_params(self) -> dict[str, Any]:
+        """Extract training hyperparameters from the learner."""
+        params = {}
+        
+        params["epochs"] = self.learn.n_epoch
+        params["learning_rate"] = float(self.learn.lr)
+        params["optimizer"] = self.learn.opt_func.__name__
+        params["batch_size"] = self.learn.dls.bs
+        
+        params["loss_function"] = self.config["loss_function"]
+        params["size"] = self.config["size"]
+        params["resample"] = self.config["resample"]
+        params["reorder"] = self.config["reorder"]
+        
+        params["transformations"] = json.dumps(
+            self.config["transform_details"], 
+            indent=2, 
+            separators=(',', ': ')
+        )
+        
+        return params
+    
+    def _extract_epoch_metrics(self) -> dict[str, float]:
+        """Extract metrics from the current epoch."""
+        recorder = self.learn.recorder
+        
+        # Get custom metric names and values (skip 'epoch' and 'time')
+        metric_names = recorder.metric_names[2:]
+        raw_metric_values = recorder.log[2:]
+        
+        metrics = {}
+        
+        # Process each metric, handling both scalars and tensors
+        for name, val in zip(metric_names, raw_metric_values):
+            if val is None:
+                continue  # Skip None values during inference
+            if isinstance(val, torch.Tensor):
+                if val.numel() == 1:
+                    # Single value tensor (like binary dice score)
+                    metrics[name] = float(val)
+                else:
+                    # Multi-element tensor (like multiclass dice scores)
+                    val_list = val.tolist() if hasattr(val, 'tolist') else list(val)
+                    # Log individual class scores
+                    for i, class_score in enumerate(val_list):
+                        metrics[f"{name}_class_{i+1}"] = float(class_score)
+                    # Log mean across classes
+                    metrics[f"{name}_mean"] = float(torch.mean(val))
+            else:
+                metrics[name] = float(val)
+        
+        # Handle loss values
+        if len(recorder.log) >= 2:
+            if recorder.log[1] is not None:
+                metrics['train_loss'] = float(recorder.log[1])
+            if len(recorder.log) >= 3 and recorder.log[2] is not None:
+                metrics['valid_loss'] = float(recorder.log[2])
+                
+        return metrics
+    
+    def _save_model_artifacts(self, temp_dir: Path) -> None:
+        """Save model weights, learner, and configuration as artifacts."""
+        weights_path = temp_dir / "weights"
+        self.learn.save(str(weights_path))
+        
+        weights_file = f"{weights_path}.pth"
+        if os.path.exists(weights_file):
+            mlflow.log_artifact(weights_file, "model")
+        
+        # Remove MLflow callbacks before exporting learner for inference
+        # This prevents the callback from being triggered during inference
+        original_cbs = self.learn.cbs.copy()  # Save original callbacks
+        
+        # Remove ModelTrackingCallback instances from learner using proper collection type
+        filtered_cbs = L([cb for cb in self.learn.cbs if not isinstance(cb, ModelTrackingCallback)])
+        self.learn.cbs = filtered_cbs
+        
+        # Export clean learner without MLflow callbacks
+        learner_path = temp_dir / "learner.pkl"
+        self.learn.export(str(learner_path))
+        mlflow.log_artifact(str(learner_path), "model")
+        
+        # Restore original callbacks for current session
+        self.learn.cbs = original_cbs
+        
+        config_path = temp_dir / "inference_settings.pkl"
+        store_variables(config_path, self.size, self.reorder, self.resample)
+        mlflow.log_artifact(str(config_path), "config")
+    
+    def _register_pytorch_model(self) -> None:
+        """Register the PyTorch model with MLflow."""
+        mlflow.pytorch.log_model(
+            pytorch_model=self.learn.model,
+            registered_model_name=self.model_name
+        )
+    
+    def before_fit(self) -> None:
+        """Log hyperparameters before training starts."""
+        params = self._extract_training_params()
+        mlflow.log_params(params)
+    
+    def after_epoch(self) -> None:
+        """Log metrics after each epoch."""
+        metrics = self._extract_epoch_metrics()
+        if metrics:
+            mlflow.log_metrics(metrics, step=self.learn.epoch)
+    
+    def after_fit(self) -> None:
+        """Log model artifacts after training completion."""
+        print("\nTraining finished. Logging model artifacts to MLflow...")
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            self._save_model_artifacts(temp_path)
+            
+            self._register_pytorch_model()
+            
+        print(f"MLflow run completed. Run ID: {mlflow.active_run().info.run_id}")
+
+# %% ../nbs/07_utils.ipynb 7
+import subprocess
+import threading
+import time
+import socket
+import os
+from IPython.display import display, HTML, clear_output
+from IPython.core.magic import register_line_magic
+from IPython import get_ipython
+import requests
+import shutil
+
+class MLflowUIManager:
+    def __init__(self):
+        self.process = None
+        self.thread = None
+        self.port = 5001
+        self.host = '0.0.0.0'
+        self.backend_store_uri = './mlruns'
+        
+    def is_port_available(self, port):
+        """Check if a port is available."""
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(('localhost', port))
+                return True
+            except OSError:
+                return False
+    
+    def is_mlflow_running(self):
+        """Check if MLflow UI is actually responding."""
+        try:
+            response = requests.get(f'http://localhost:{self.port}', timeout=2)
+            return response.status_code == 200
+        except:
+            return False
+    
+    def find_available_port(self, start_port=5001):
+        """Find an available port starting from start_port."""
+        for port in range(start_port, start_port + 10):
+            if self.is_port_available(port):
+                return port
+        return None
+    
+    def check_mlflow_installed(self):
+        """Check if MLflow is installed."""
+        return shutil.which('mlflow') is not None
+    
+    def start_ui(self, auto_open=True, quiet=False):
+        """Start MLflow UI with better error handling and user feedback."""
+        
+        # Check if MLflow is installed
+        if not self.check_mlflow_installed():
+            if not quiet:
+                display(HTML('<div style="color: #d32f2f; font-weight: bold; font-size: 14px;">❌ MLflow not installed. Run: pip install mlflow</div>'))
+            return False
+        
+        # Find available port
+        available_port = self.find_available_port(self.port)
+        if available_port is None:
+            if not quiet:
+                display(HTML('<div style="color: #d32f2f; font-weight: bold; font-size: 14px;">❌ No available ports found (5001-5010)</div>'))
+            return False
+        
+        self.port = available_port
+        
+        # Start MLflow UI in a separate thread
+        def run_mlflow():
+            try:
+                self.process = subprocess.Popen([
+                    'mlflow', 'ui', 
+                    '--host', self.host,
+                    '--port', str(self.port),
+                    '--backend-store-uri', self.backend_store_uri
+                ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                self.process.wait()
+            except Exception as e:
+                if not quiet:
+                    display(HTML(f'<div style="color: #d32f2f; font-weight: bold; font-size: 14px;">❌ Error: {str(e)}</div>'))
+        
+        self.thread = threading.Thread(target=run_mlflow, daemon=True)
+        self.thread.start()
+        
+        # Wait and check if server started successfully
+        max_wait = 10
+        for i in range(max_wait):
+            time.sleep(1)
+            if self.is_mlflow_running():
+                if quiet:
+                    # Bright, visible link for quiet mode
+                    display(HTML(f'''
+                        <a href="http://localhost:{self.port}" target="_blank" 
+                           style="color: #1976d2; font-weight: bold; font-size: 16px; text-decoration: underline;">
+                           🔗 MLflow UI (Port {self.port})
+                        </a>
+                    '''))
+                else:
+                    # Success message with high contrast colors
+                    display(HTML(f'''
+                        <div style="background-color: #c8e6c9; border: 2px solid #388e3c; padding: 15px; border-radius: 8px; margin: 10px 0;">
+                            <div style="color: #1b5e20; font-weight: bold; font-size: 16px; margin-bottom: 10px;">
+                                ✅ MLflow UI is running successfully!
+                            </div>
+                            <a href="http://localhost:{self.port}" target="_blank" 
+                               style="background-color: #1976d2; color: white; padding: 12px 24px; text-decoration: none; border-radius: 6px; font-weight: bold; font-size: 14px; display: inline-block; margin: 5px 0;">
+                                🔗 Open MLflow UI
+                            </a>
+                            <div style="margin-top: 10px;">
+                                <div style="color: #424242; font-size: 13px;">URL: http://localhost:{self.port}</div>
+                            </div>
+                        </div>
+                    '''))
+                return True
+        
+        # If we get here, server didn't start properly
+        if not quiet:
+            display(HTML('<div style="color: #d32f2f; font-weight: bold; font-size: 14px;">❌ Failed to start MLflow UI</div>'))
+        return False
+    
+    def stop(self):
+        """Stop the MLflow UI server."""
+        if self.process:
+            self.process.terminate()
+            self.process = None
+            display(HTML('''
+                <div style="background-color: #ffecb3; border: 2px solid #f57c00; padding: 10px; border-radius: 6px;">
+                    <span style="color: #e65100; font-weight: bold; font-size: 14px;">🛑 MLflow UI stopped</span>
+                </div>
+            '''))
+        else:
+            display(HTML('''
+                <div style="background-color: #f0f0f0; border: 2px solid #757575; padding: 10px; border-radius: 6px;">
+                    <span style="color: #424242; font-weight: bold; font-size: 14px;">ℹ️ MLflow UI is not currently running</span>
+                </div>
+            '''))
+    
+    def status(self):
+        """Check MLflow UI status."""
+        if self.is_mlflow_running():
+            display(HTML(f'''
+                <div style="background-color: #c8e6c9; border: 2px solid #388e3c; padding: 10px; border-radius: 6px;">
+                    <div style="color: #1b5e20; font-weight: bold; font-size: 14px;">✅ MLflow UI is running</div>
+                    <a href="http://localhost:{self.port}" target="_blank" 
+                       style="color: #1976d2; font-weight: bold; text-decoration: underline;">
+                       http://localhost:{self.port}
+                    </a>
+                </div>
+            '''))
+        else:
+            display(HTML('''
+                <div style="background-color: #ffcdd2; border: 2px solid #d32f2f; padding: 10px; border-radius: 6px;">
+                    <div style="color: #b71c1c; font-weight: bold; font-size: 14px;">❌ MLflow UI is not running</div>
+                    <div style="color: #424242; font-size: 13px; margin-top: 5px;">
+                        Run <code style="background-color: #f5f5f5; padding: 2px 4px; border-radius: 3px;">mlflow_ui.start_ui()</code> to start it.
+                    </div>
+                </div>
+            '''))

fastMONAI/vision_core.py

@@ -1,12 +1,13 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/01_vision_core.ipynb.
 
 # %% auto 0
-__all__ = ['med_img_reader', 'MetaResolver', 'MedBase', 'MedImage', 'MedMask']
+__all__ = ['med_img_reader', 'MetaResolver', 'MedBase', 'MedImage', 'MedMask', 'VSCodeProgressCallback', 'setup_vscode_progress']
 
 # %% ../nbs/01_vision_core.ipynb 2
 from .vision_plot import *
 from fastai.data.all import *
 from torchio import ScalarImage, LabelMap, ToCanonical, Resample
+import copy
 
 # %% ../nbs/01_vision_core.ipynb 5
 def _preprocess(obj, reorder, resample):
@@ -56,7 +57,7 @@ def _load_and_preprocess(file_path, reorder, resample, dtype):
     return org_img, input_img, org_size
 
 # %% ../nbs/01_vision_core.ipynb 7
-def _multi_channel(image_paths: (L, list), reorder: bool, resample: list, dtype, only_tensor: bool):
+def _multi_channel(image_paths: L | list, reorder: bool, resample: list, only_tensor: bool, dtype):
     """
     Load and preprocess multisequence data.
 
@@ -64,8 +65,8 @@ def _multi_channel(image_paths: (L, list), reorder: bool, resample: list, dtype,
         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.
-        dtype: Desired datatype for output.
         only_tensor: Whether to return only image tensor.
+        dtype: Desired datatype for output.
 
     Returns:
         torch.Tensor: A stacked 4D tensor, if `only_tensor` is True.
@@ -82,33 +83,28 @@ def _multi_channel(image_paths: (L, list), reorder: bool, resample: list, dtype,
     input_img.set_data(tensor)
     return org_img, input_img, org_size
 
-
 # %% ../nbs/01_vision_core.ipynb 8
-def med_img_reader(file_path: (str, Path, L, list), dtype=torch.Tensor, reorder: bool = False,
-                   resample: list = None, only_tensor: bool = True
-):
+def med_img_reader(file_path: str | Path | L | list, reorder: bool = False, resample: 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.
-        dtype: Datatype for the return value. Defaults to torch.Tensor.
         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 
             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.
 
     Returns:
         The preprocessed image. Returns only the image tensor if 
         only_tensor is True, otherwise returns original image, 
         preprocessed image, and original size.
     """
-    # if isinstance(file_path, str) and ';' in file_path:
-    #     return _multi_channel(
-    #         file_path.split(';'), reorder, resample, dtype, only_tensor)
     
-    if isinstance(file_path, (L, list)):
-        return _multi_channel(file_path, reorder, resample, dtype, only_tensor)
+    if isinstance(file_path, (list, L)):
+        return _multi_channel(file_path, reorder, resample, only_tensor, dtype)
 
     org_img, input_img, org_size = _load_and_preprocess(
         file_path, reorder, resample, dtype)
@@ -154,7 +150,50 @@ class MedBase(torch.Tensor, metaclass=MetaResolver):
         if isinstance(fn, torch.Tensor):
             return cls(fn)
 
-        return med_img_reader(fn, dtype=cls, resample=cls.resample, reorder=cls.reorder)
+        return med_img_reader(fn, resample=cls.resample, reorder=cls.reorder, dtype=cls)
+
+    def __new__(cls, x, **kwargs):
+        """Creates a new instance of MedBase from a tensor."""
+        if isinstance(x, torch.Tensor):
+            # Create tensor of the same type and copy data
+            res = torch.Tensor._make_subclass(cls, x.data, x.requires_grad)
+            # Copy any additional attributes
+            if hasattr(x, 'affine_matrix'):
+                res.affine_matrix = x.affine_matrix
+            return res
+        else:
+            # Handle other types by converting to tensor first
+            tensor = torch.as_tensor(x, **kwargs)
+            return cls.__new__(cls, tensor)
+
+    def new_empty(self, size, **kwargs):
+        """Create a new empty tensor of the same type."""
+        # Create new tensor with same type and device/dtype
+        kwargs.setdefault('dtype', self.dtype)
+        kwargs.setdefault('device', self.device)
+        new_tensor = torch.empty(size, **kwargs)
+        # Use __new__ to create proper subclass instance
+        return self.__class__.__new__(self.__class__, new_tensor)
+
+    def __copy__(self):
+        """Shallow copy implementation."""
+        copied = self.__class__.__new__(self.__class__, self.clone())
+        # Copy class attributes
+        if hasattr(self, 'affine_matrix'):
+            copied.affine_matrix = self.affine_matrix
+        return copied
+
+    def __deepcopy__(self, memo):
+        """Deep copy implementation."""
+        # Create a deep copy of the tensor data
+        copied_data = self.clone()
+        copied = self.__class__.__new__(self.__class__, copied_data)
+        # Deep copy class attributes
+        if hasattr(self, 'affine_matrix') and self.affine_matrix is not None:
+            copied.affine_matrix = copy.deepcopy(self.affine_matrix, memo)
+        else:
+            copied.affine_matrix = None
+        return copied
 
     @classmethod
     def item_preprocessing(cls, resample: (list, int, tuple), reorder: bool):
@@ -208,3 +247,106 @@ 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

@@ -5,10 +5,12 @@ __all__ = ['pred_to_multiclass_mask', 'batch_pred_to_multiclass_mask', 'pred_to_
            'MedImageDataLoaders', 'show_batch', 'show_results', 'plot_top_losses']
 
 # %% ../nbs/02_vision_data.ipynb 2
+import torch
 from fastai.data.all import *
 from fastai.vision.data import *
 from .vision_core import *
 from .vision_plot import find_max_slice
+from plum import dispatch
 
 # %% ../nbs/02_vision_data.ipynb 5
 def pred_to_multiclass_mask(pred: torch.Tensor) -> torch.Tensor:
@@ -65,7 +67,7 @@ class MedDataBlock(DataBlock):
     """Container to quickly build dataloaders."""
     #TODO add get_x
     def __init__(self, blocks: list = None, dl_type: TfmdDL = None, getters: list = None,
-                 n_inp: int = None, item_tfms: list = None, batch_tfms: list = None,
+                 n_inp: int | None = None, item_tfms: list = None, batch_tfms: list = None,
                  reorder: bool = False, resample: (int, list) = None, **kwargs):
 
         super().__init__(blocks, dl_type, getters, n_inp, item_tfms,
@@ -109,7 +111,7 @@ class MedImageDataLoaders(DataLoaders):
         return cls.from_dblock(dblock, df, **kwargs)
 
 # %% ../nbs/02_vision_data.ipynb 16
-@typedispatch
+@dispatch
 def show_batch(x: MedImage, y, samples, ctxs=None, max_n=6, nrows=None, 
                ncols=None, figsize=None, channel=0, slice_index=None,
                anatomical_plane=0, **kwargs):
@@ -131,7 +133,7 @@ def show_batch(x: MedImage, y, samples, ctxs=None, max_n=6, nrows=None,
     return ctxs
 
 # %% ../nbs/02_vision_data.ipynb 17
-@typedispatch
+@dispatch
 def show_batch(x: MedImage, y: MedMask, samples, ctxs=None, max_n=6, nrows=None,
                ncols=None, figsize=None, channel=0, slice_index=None,
                anatomical_plane=0, **kwargs):
@@ -162,10 +164,10 @@ def show_batch(x: MedImage, y: MedMask, samples, ctxs=None, max_n=6, nrows=None,
     return ctxs
 
 # %% ../nbs/02_vision_data.ipynb 19
-@typedispatch
+@dispatch
 def show_results(x: MedImage, y: torch.Tensor, samples, outs, ctxs=None, max_n: int = 6,
-                 nrows: int = None, ncols: int = None, figsize=None, channel: int = 0,
-                 slice_index: int = None, anatomical_plane: int = 0, **kwargs):
+                 nrows: int | None = None, ncols: int | None = None, figsize=None, channel: int = 0,
+                 slice_index: int | None = None, anatomical_plane: int = 0, **kwargs):
     """Showing samples and their corresponding predictions for regression tasks."""
 
     if ctxs is None:
@@ -188,10 +190,10 @@ def show_results(x: MedImage, y: torch.Tensor, samples, outs, ctxs=None, max_n:
     return ctxs
 
 # %% ../nbs/02_vision_data.ipynb 20
-@typedispatch
+@dispatch
 def show_results(x: MedImage, y: TensorCategory, samples, outs, ctxs=None, 
-                 max_n: int = 6, nrows: int = None, ncols: int = None, figsize=None, channel: int = 0, 
-                 slice_index: int = None, anatomical_plane: int = 0, **kwargs):
+                 max_n: int = 6, nrows: int | None = None, ncols: int | None = None, figsize=None, channel: int = 0, 
+                 slice_index: int | None = None, anatomical_plane: int = 0, **kwargs):
     """Showing samples and their corresponding predictions for classification tasks."""
 
     if ctxs is None: 
@@ -209,10 +211,10 @@ def show_results(x: MedImage, y: TensorCategory, samples, outs, ctxs=None,
     return ctxs
 
 # %% ../nbs/02_vision_data.ipynb 21
-@typedispatch
+@dispatch
 def show_results(x: MedImage, y: MedMask, samples, outs, ctxs=None, max_n: int = 6, 
-                 nrows: int = None, ncols: int = 3, figsize=None, channel: int = 0, 
-                 slice_index: int = None, anatomical_plane: int = 0, **kwargs):
+                 nrows: int | None = None, ncols: int = 3, figsize=None, channel: int = 0, 
+                 slice_index: int | None = None, anatomical_plane: int = 0, **kwargs):
     """Showing decoded samples and their corresponding predictions for segmentation tasks."""
     
     if ctxs is None: 
@@ -240,9 +242,9 @@ def show_results(x: MedImage, y: MedMask, samples, outs, ctxs=None, max_n: int =
     return ctxs
 
 # %% ../nbs/02_vision_data.ipynb 23
-@typedispatch
-def plot_top_losses(x: MedImage, y: TensorCategory, samples, outs, raws, losses, nrows: int = None, 
-                    ncols: int = None, figsize=None, channel: int = 0, slice_index: int = None, 
+@dispatch
+def plot_top_losses(x: MedImage, y: TensorCategory, samples, outs, raws, losses, nrows: int | None = None, 
+                    ncols: int | None = None, figsize=None, channel: int = 0, slice_index: int | None = None, 
                     anatomical_plane: int = 0, **kwargs):
     """Show images in top_losses along with their prediction, actual, loss, and probability of actual class."""
 
@@ -258,10 +260,10 @@ def plot_top_losses(x: MedImage, y: TensorCategory, samples, outs, raws, losses,
             ax.set_title(f'{o[0]}/{s[1]} / {l.item():.2f} / {r.max().item():.2f}')
 
 # %% ../nbs/02_vision_data.ipynb 24
-@typedispatch
+@dispatch
 def plot_top_losses(x: MedImage, y: TensorMultiCategory, samples, outs, raws, 
-                    losses, nrows: int = None, ncols: int = None, figsize=None, 
-                    channel: int = 0, slice_index: int = None, 
+                    losses, nrows: int | None = None, ncols: int | None = None, figsize=None, 
+                    channel: int = 0, slice_index: int | None = None, 
                     anatomical_plane: int = 0, **kwargs):
     # TODO: not tested yet
     axs = get_grid(len(samples), nrows=nrows, ncols=ncols, figsize=figsize)

fastMONAI/vision_inference.py

@@ -94,14 +94,28 @@ def inference(learn_inf, reorder, resample, fn: (str, Path) = '',
     reoriented_array = _to_original_orientation(input_img.as_sitk(), 
                                                 ('').join(org_img.orientation))
     
-    org_img.set_data(reoriented_array)
+    # Create new TorchIO image with proper affine matrix
+    # Spatial properties (spacing, origin, direction) are automatically derived from affine
+    from torchio import ScalarImage
+    import numpy as np
+    
+    # Ensure we have a valid affine matrix
+    if hasattr(org_img, 'affine') and org_img.affine is not None:
+        affine_matrix = org_img.affine.copy()
+    elif MedBase.affine_matrix is not None:
+        affine_matrix = MedBase.affine_matrix.copy()
+    else:
+        # Fallback to identity affine if no affine available
+        affine_matrix = np.eye(4, dtype=np.float64)
+    
+    pred_img = ScalarImage(tensor=reoriented_array, affine=affine_matrix)
 
     if save_path:
         save_fn = Path(save_path)/('pred_' + Path(fn).parts[-1])
-        org_img.save(save_fn)
+        pred_img.save(save_fn)
         return save_fn
     
-    return org_img
+    return pred_img
 
 # %% ../nbs/06_vision_inference.ipynb 9
 def compute_binary_tumor_volume(mask_data: Image):

fastmonai-0.5.1.dist-info/METADATA

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: fastMONAI
+Version: 0.5.1
+Summary: fastMONAI library
+Home-page: https://github.com/MMIV-ML/fastMONAI
+Author: Satheshkumar Kaliyugarasan
+Author-email: skaliyugarasan@hotmail.com
+License: Apache Software License 2.0
+Keywords: deep learning,medical imaging
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastai==2.8.3
+Requires-Dist: monai==1.5.0
+Requires-Dist: torchio==0.20.19
+Requires-Dist: xlrd>=1.2.0
+Requires-Dist: scikit-image==0.25.2
+Requires-Dist: imagedata==3.8.4
+Requires-Dist: mlflow==3.3.1
+Requires-Dist: huggingface-hub
+Requires-Dist: gdown
+Requires-Dist: gradio
+Requires-Dist: opencv-python
+Requires-Dist: plum-dispatch
+Provides-Extra: dev
+Requires-Dist: ipywidgets; extra == "dev"
+Requires-Dist: nbdev; extra == "dev"
+Requires-Dist: tabulate; extra == "dev"
+Requires-Dist: quarto; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Overview
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+![](https://raw.githubusercontent.com/skaliy/skaliy.github.io/master/assets/fastmonai_v1.png)
+
+![CI](https://github.com/MMIV-ML/fastMONAI/workflows/CI/badge.svg)
+[![Docs](https://github.com/MMIV-ML/fastMONAI/actions/workflows/deploy.yaml/badge.svg)](https://fastmonai.no)
+[![PyPI](https://img.shields.io/pypi/v/fastMONAI?color=blue&label=PyPI%20version&logo=python&logoColor=white.png)](https://pypi.org/project/fastMONAI)
+
+A low-code Python-based open source deep learning library built on top
+of [fastai](https://github.com/fastai/fastai),
+[MONAI](https://monai.io/), [TorchIO](https://torchio.readthedocs.io/),
+and [Imagedata](https://imagedata.readthedocs.io/).
+
+fastMONAI simplifies the use of state-of-the-art deep learning
+techniques in 3D medical image analysis for solving classification,
+regression, and segmentation tasks. fastMONAI provides the users with
+functionalities to step through data loading, preprocessing, training,
+and result interpretations.
+
+<b>Note:</b> This documentation is also available as interactive
+notebooks.
+
+## Requirements
+
+- **Python:** 3.10, 3.11, or 3.12 (Python 3.11 recommended)
+- **GPU:** CUDA-compatible GPU recommended for training (CPU supported
+  for inference)
+
+# Installation
+
+## Environment setup (recommended)
+
+We recommend using a conda environment to avoid dependency conflicts:
+
+`conda create -n fastmonai python=3.11`
+
+`conda activate fastmonai`
+
+## Quick Install [(PyPI)](https://pypi.org/project/fastMONAI/)
+
+`pip install fastMONAI`
+
+## Development install [(GitHub)](https://github.com/MMIV-ML/fastMONAI)
+
+If you want to install an editable version of fastMONAI for development:
+
+    git clone https://github.com/MMIV-ML/fastMONAI
+    cd fastMONAI
+
+    # Create development environment
+    conda create -n fastmonai-dev python=3.11
+    conda activate fastmonai-dev
+
+    # Install in development mode
+    pip install -e '.[dev]'
+
+# Getting started
+
+The best way to get started using fastMONAI is to read our
+[paper](https://www.sciencedirect.com/science/article/pii/S2665963823001203)
+and dive into our beginner-friendly [video
+tutorial](https://fastmonai.no/tutorial_beginner_video). For a deeper
+understanding and hands-on experience, our comprehensive instructional
+notebooks will walk you through model training for various tasks like
+classification, regression, and segmentation. See the docs at
+https://fastmonai.no for more information.
+
+| Notebook | 1-Click Notebook |
+|:---|----|
+| [10a_tutorial_classification.ipynb](https://nbviewer.org/github/MMIV-ML/fastMONAI/blob/master/nbs/10a_tutorial_classification.ipynb) <br>shows how to construct a binary classification model based on MRI data. | [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MMIV-ML/fastMONAI/blob/master/nbs/10a_tutorial_classification.ipynb) |
+| [10b_tutorial_regression.ipynb](https://nbviewer.org/github/MMIV-ML/fastMONAI/blob/master/nbs/10b_tutorial_regression.ipynb) <br>shows how to construct a model to predict the age of a subject from MRI scans (“brain age”). | [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MMIV-ML/fastMONAI/blob/master/nbs/10b_tutorial_regression.ipynb) |
+| [10c_tutorial_binary_segmentation.ipynb](https://nbviewer.org/github/MMIV-ML/fastMONAI/blob/master/nbs/10c_tutorial_binary_segmentation.ipynb) <br>shows how to do binary segmentation (extract the left atrium from monomodal cardiac MRI). | [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MMIV-ML/fastMONAI/blob/master/nbs/10c_tutorial_binary_segmentation.ipynb) |
+| [10d_tutorial_multiclass_segmentation.ipynb](https://nbviewer.org/github/MMIV-ML/fastMONAI/blob/master/nbs/10d_tutorial_multiclass_segmentation.ipynb) <br>shows how to perform segmentation from multimodal MRI (brain tumor segmentation). | [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MMIV-ML/fastMONAI/blob/master/nbs/10d_tutorial_multiclass_segmentation.ipynb) |
+
+# How to contribute
+
+We welcome contributions! See
+[CONTRIBUTING.md](https://github.com/MMIV-ML/fastMONAI/blob/master/CONTRIBUTING.md)
+
+# Citing fastMONAI
+
+If you are using fastMONAI in your research, please use the following
+citation:
+
+    @article{KALIYUGARASAN2023100583,
+    title = {fastMONAI: A low-code deep learning library for medical image analysis},
+    journal = {Software Impacts},
+    pages = {100583},
+    year = {2023},
+    issn = {2665-9638},
+    doi = {https://doi.org/10.1016/j.simpa.2023.100583},
+    url = {https://www.sciencedirect.com/science/article/pii/S2665963823001203},
+    author = {Satheshkumar Kaliyugarasan and Alexander S. Lundervold},
+    keywords = {Deep learning, Medical imaging, Radiology},
+    abstract = {We introduce fastMONAI, an open-source Python-based deep learning library for 3D medical imaging. Drawing upon the strengths of fastai, MONAI, and TorchIO, fastMONAI simplifies the use of advanced techniques for tasks like classification, regression, and segmentation. The library's design addresses domain-specific demands while promoting best practices, facilitating efficient model development. It offers newcomers an easier entry into the field while keeping the option to make advanced, lower-level customizations if needed. This paper describes the library's design, impact, limitations, and plans for future work.}
+    }

fastmonai-0.5.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+fastMONAI/__init__.py,sha256=eZ1bOun1DDVV0YLOBW4wj2FP1ajReLjbIrGmzN7ASBw,22
+fastMONAI/_modidx.py,sha256=iuYWVoaM3bmpb_Dv6lMQU8zOVPA76hYfnyFxVgKyuBg,37759
+fastMONAI/dataset_info.py,sha256=aJ-utYZ1OrA32RIQbF7jHxcDE8SgOZE3Vt1AojxnvZc,5026
+fastMONAI/external_data.py,sha256=IVj9GbIRFh9bTFkIa2wySUObSnNfZiaVtuzFxOFAi0Q,12219
+fastMONAI/research_utils.py,sha256=LZu62g8BQAVYS4dD7qDsKHJXZnDd1uLkJ6LoaMDhUhk,590
+fastMONAI/utils.py,sha256=jG8SiYebcrPJsmnmMZh4SokWRj7McdJ_gftINnfcE1A,16590
+fastMONAI/vision_all.py,sha256=_l6F8ZlUaPYcplNG6mg1-1xssYforByEe4zECbPzTck,359
+fastMONAI/vision_augmentation.py,sha256=lAlrLm8jbXRmk9a6e8_o_CNTS6Pyp-KKNXwjpelUUJc,9070
+fastMONAI/vision_core.py,sha256=k4RUBzZuh9W8J4zbcVzXCKfJxkKCsBDG0oSRMwiCNp0,13848
+fastMONAI/vision_data.py,sha256=VCB3hyBN7dYuLiYGSGeuWlBTMvb2cLVo_sbENrRWe5Q,11510
+fastMONAI/vision_inference.py,sha256=3SaJbKGbgaf9ON9PH5DtvfNlhAurov_Idnrlp4jyU9w,6625
+fastMONAI/vision_loss.py,sha256=NrHnk1yD4EBKsp6aippppXU4l-mwmsZOqE_bsZP3ZNI,3591
+fastMONAI/vision_metrics.py,sha256=CVxdOBPaMJT6Mo5jF3WoQj6a3C-_FsnBicMAU_ZrFS8,3549
+fastMONAI/vision_plot.py,sha256=-X_nNBXx7lYCZSFBIN1587ZTA3T_-2ASBM4K31wU660,3792
+fastmonai-0.5.1.dist-info/licenses/LICENSE,sha256=xV8xoN4VOL0uw9X8RSs2IMuD_Ss_a9yAbtGNeBWZwnw,11337
+fastmonai-0.5.1.dist-info/METADATA,sha256=VZcJOlNQR7g3mJZkMnnoukPPJZ0yt_B5T9r5yPdCLBk,7094
+fastmonai-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fastmonai-0.5.1.dist-info/entry_points.txt,sha256=mVBsykSXMairzzk3hJaQ8c-UiwUZqGnn4aFZ24CpsBM,40
+fastmonai-0.5.1.dist-info/top_level.txt,sha256=o8y7SWF9odtnIT3jvYtUn9okbJRlaAMCy7oPFCeQvQ8,10
+fastmonai-0.5.1.dist-info/RECORD,,

{fastMONAI-0.4.0.2.dist-info → fastmonai-0.5.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

fastMONAI-0.4.0.2.dist-info/METADATA

@@ -1,104 +0,0 @@
-Metadata-Version: 2.1
-Name: fastMONAI
-Version: 0.4.0.2
-Summary: fastMONAI library
-Home-page: https://github.com/MMIV-ML/fastMONAI
-Author: Satheshkumar Kaliyugarasan
-Author-email: skaliyugarasan@hotmail.com
-License: Apache Software License 2.0
-Keywords: deep learning,medical imaging
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastai (==2.7.12)
-Requires-Dist: monai (==1.2.0)
-Requires-Dist: torchio (==0.18.91)
-Requires-Dist: xlrd (>=1.2.0)
-Requires-Dist: scikit-image (==0.19.3)
-Requires-Dist: imagedata (==2.1.3)
-Requires-Dist: huggingface-hub
-Requires-Dist: gdown
-Requires-Dist: gradio
-Requires-Dist: opencv-python
-Provides-Extra: dev
-Requires-Dist: ipywidgets ; extra == 'dev'
-Requires-Dist: nbdev ; extra == 'dev'
-Requires-Dist: tabulate ; extra == 'dev'
-
-Overview
-================
-
-<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
-
-![](https://raw.githubusercontent.com/skaliy/skaliy.github.io/master/assets/fastmonai_v1.png)
-
-![CI](https://github.com/MMIV-ML/fastMONAI/workflows/CI/badge.svg)
-[![Docs](https://github.com/MMIV-ML/fastMONAI/actions/workflows/deploy.yaml/badge.svg)](https://fastmonai.no)
-[![PyPI](https://img.shields.io/pypi/v/fastMONAI?color=blue&label=PyPI%20version&logo=python&logoColor=white.png)](https://pypi.org/project/fastMONAI)
-
-A low-code Python-based open source deep learning library built on top of [fastai](https://github.com/fastai/fastai), [MONAI](https://monai.io/), [TorchIO](https://torchio.readthedocs.io/), and [Imagedata](https://imagedata.readthedocs.io/).
-
-fastMONAI simplifies the use of state-of-the-art deep learning
-techniques in 3D medical image analysis for solving classification,
-regression, and segmentation tasks. fastMONAI provides the users with
-functionalities to step through data loading, preprocessing, training,
-and result interpretations.
-
-<b>Note:</b> This documentation is also available as interactive
-notebooks.
-
-# Installing
-
-## From [PyPI](https://pypi.org/project/fastMONAI/)
-
-`pip install fastMONAI`
-
-## From [GitHub](https://github.com/MMIV-ML/fastMONAI)
-
-If you want to install an editable version of fastMONAI run:
-
-- `git clone https://github.com/MMIV-ML/fastMONAI`
-- `pip install -e 'fastMONAI[dev]'`
-
-# Getting started
-
-The best way to get started using fastMONAI is to read our [paper](https://www.sciencedirect.com/science/article/pii/S2665963823001203) and dive into our beginner-friendly [video tutorial](https://fastmonai.no/tutorial_beginner_video). For a deeper understanding and hands-on experience, our comprehensive instructional notebooks will walk you through model training for various tasks like classification, regression, and segmentation. See the docs at https://fastmonai.no for more information.
-
-| Notebook                                                                                                                                                                                                                                     | 1-Click Notebook                                                                                                                                                                                   |
-|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| [10a_tutorial_classification.ipynb](https://nbviewer.org/github/MMIV-ML/fastMONAI/blob/master/nbs/10a_tutorial_classification.ipynb) <br>shows how to construct a binary classification model based on MRI data.                             | [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MMIV-ML/fastMONAI/blob/master/nbs/10a_tutorial_classification.ipynb)          |
-| [10b_tutorial_regression.ipynb](https://nbviewer.org/github/MMIV-ML/fastMONAI/blob/master/nbs/10b_tutorial_regression.ipynb) <br>shows how to construct a model to predict the age of a subject from MRI scans (“brain age”).                | [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MMIV-ML/fastMONAI/blob/master/nbs/10b_tutorial_regression.ipynb)              |
-| [10c_tutorial_binary_segmentation.ipynb](https://nbviewer.org/github/MMIV-ML/fastMONAI/blob/master/nbs/10c_tutorial_binary_segmentation.ipynb) <br>shows how to do binary segmentation (extract the left atrium from monomodal cardiac MRI). | [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MMIV-ML/fastMONAI/blob/master/nbs/10c_tutorial_binary_segmentation.ipynb)     |
-| [10d_tutorial_multiclass_segmentation.ipynb](https://nbviewer.org/github/MMIV-ML/fastMONAI/blob/master/nbs/10d_tutorial_multiclass_segmentation.ipynb) <br>shows how to perform segmentation from multimodal MRI (brain tumor segmentation). | [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MMIV-ML/fastMONAI/blob/master/nbs/10d_tutorial_multiclass_segmentation.ipynb) |
-
-# How to contribute
-
-See
-[CONTRIBUTING.md](https://github.com/MMIV-ML/fastMONAI/blob/master/CONTRIBUTING.md)
-
-# Citing fastMONAI
-
-If you are using fastMONAI in your research, please use the following citation:
-
-```
-@article{KALIYUGARASAN2023100583,
-title = {fastMONAI: A low-code deep learning library for medical image analysis},
-journal = {Software Impacts},
-pages = {100583},
-year = {2023},
-issn = {2665-9638},
-doi = {https://doi.org/10.1016/j.simpa.2023.100583},
-url = {https://www.sciencedirect.com/science/article/pii/S2665963823001203},
-author = {Satheshkumar Kaliyugarasan and Alexander S. Lundervold},
-keywords = {Deep learning, Medical imaging, Radiology},
-abstract = {We introduce fastMONAI, an open-source Python-based deep learning library for 3D medical imaging. Drawing upon the strengths of fastai, MONAI, and TorchIO, fastMONAI simplifies the use of advanced techniques for tasks like classification, regression, and segmentation. The library's design addresses domain-specific demands while promoting best practices, facilitating efficient model development. It offers newcomers an easier entry into the field while keeping the option to make advanced, lower-level customizations if needed. This paper describes the library's design, impact, limitations, and plans for future work.}
-}
-```

fastMONAI-0.4.0.2.dist-info/RECORD

@@ -1,20 +0,0 @@
-fastMONAI/__init__.py,sha256=q8C3BwoPX4eeCOynkPZhIOcrFKxXKQQU16YGyth8EAs,24
-fastMONAI/_modidx.py,sha256=qlr-dyFcDjvXOZgM6-r-pYRHtodH07QRsioHD8n72cc,29553
-fastMONAI/dataset_info.py,sha256=w5LKGmEzFtlqhxqzhFLWUfyVkUL0EYypZQCH9Ay6jgg,4948
-fastMONAI/external_data.py,sha256=IVj9GbIRFh9bTFkIa2wySUObSnNfZiaVtuzFxOFAi0Q,12219
-fastMONAI/research_utils.py,sha256=LZu62g8BQAVYS4dD7qDsKHJXZnDd1uLkJ6LoaMDhUhk,590
-fastMONAI/utils.py,sha256=9I5nl6Sb0NbTxhr6FDnW4dapDhzPtmxGcJeXkkY4v3E,1406
-fastMONAI/vision_all.py,sha256=_l6F8ZlUaPYcplNG6mg1-1xssYforByEe4zECbPzTck,359
-fastMONAI/vision_augmentation.py,sha256=lAlrLm8jbXRmk9a6e8_o_CNTS6Pyp-KKNXwjpelUUJc,9070
-fastMONAI/vision_core.py,sha256=PBovhzMzzE16t5V-DYLdpWDqYCKPZdmTUQErsev8kmg,7603
-fastMONAI/vision_data.py,sha256=I7i1rzCaubfZVmU3CyJ0aITcin-fMO9jrb50Edpiro0,11394
-fastMONAI/vision_inference.py,sha256=7sX_ZCE_6myW_hTpJbnPG6s78WN8V7flVRRke1g__jc,5995
-fastMONAI/vision_loss.py,sha256=NrHnk1yD4EBKsp6aippppXU4l-mwmsZOqE_bsZP3ZNI,3591
-fastMONAI/vision_metrics.py,sha256=CVxdOBPaMJT6Mo5jF3WoQj6a3C-_FsnBicMAU_ZrFS8,3549
-fastMONAI/vision_plot.py,sha256=-X_nNBXx7lYCZSFBIN1587ZTA3T_-2ASBM4K31wU660,3792
-fastMONAI-0.4.0.2.dist-info/LICENSE,sha256=xV8xoN4VOL0uw9X8RSs2IMuD_Ss_a9yAbtGNeBWZwnw,11337
-fastMONAI-0.4.0.2.dist-info/METADATA,sha256=kaDdvzXsqWr1x2qIxo8gtFnuQsdaMwkQ4bZWTqhbSFI,7095
-fastMONAI-0.4.0.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-fastMONAI-0.4.0.2.dist-info/entry_points.txt,sha256=mVBsykSXMairzzk3hJaQ8c-UiwUZqGnn4aFZ24CpsBM,40
-fastMONAI-0.4.0.2.dist-info/top_level.txt,sha256=o8y7SWF9odtnIT3jvYtUn9okbJRlaAMCy7oPFCeQvQ8,10
-fastMONAI-0.4.0.2.dist-info/RECORD,,