Enabled model factory and migrated multi-AI app

Signed-off-by: M Q <mingmelvinq@nvidia.com>

Author: MMelQin

examples/apps/ai_livertumor_seg_app/app.py

@@ -61,7 +61,7 @@ def compose(self):
         series_selector_op = DICOMSeriesSelectorOperator(self, rules=Sample_Rules_Text, name="series_selector_op")
         series_to_vol_op = DICOMSeriesToVolumeOperator(self, name="series_to_vol_op")
         # Model specific inference operator, supporting MONAI transforms.
-        liver_tumor_seg_op = LiverTumorSegOperator(self, model_path=model_path, name="seg_op")
+        liver_tumor_seg_op = LiverTumorSegOperator(self, app_context=app_context, model_path=model_path, name="seg_op")
         #     self, model_path=model_path, output_folder=app_output_path, name="seg_op"
         # )
 

examples/apps/ai_livertumor_seg_app/livertumor_seg_operator.py

@@ -12,7 +12,7 @@
 import logging
 from pathlib import Path
 
-from monai.deploy.core import ConditionType, Fragment, Operator, OperatorSpec
+from monai.deploy.core import AppContext, ConditionType, Fragment, Operator, OperatorSpec
 from monai.deploy.operators.monai_seg_inference_operator import InMemImageReader, MonaiSegInferenceOperator
 from monai.transforms import (  # SaveImaged,
     Activationsd,
@@ -57,7 +57,13 @@ class LiverTumorSegOperator(Operator):
     DEFAULT_OUTPUT_FOLDER = Path.cwd() / "output/saved_images_folder"
 
     def __init__(
-        self, frament: Fragment, *args, model_path: Path, output_folder: Path = DEFAULT_OUTPUT_FOLDER, **kwargs
+        self,
+        frament: Fragment,
+        *args,
+        app_context: AppContext,
+        model_path: Path,
+        output_folder: Path = DEFAULT_OUTPUT_FOLDER,
+        **kwargs,
     ):
         self.logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__))
         self._input_dataset_key = "image"
@@ -67,11 +73,13 @@ def __init__(
         self.output_folder = output_folder
         self.output_folder.mkdir(parents=True, exist_ok=True)
         self.fragement = frament  # Cache and later pass the Fragment/Application to contained operator(s)
+        self.app_context = app_context
         self.input_name_image = "image"
         self.output_name_seg = "seg_image"
         self.output_name_saved_images_folder = "saved_images_folder"
 
-        self.fragement = frament  # Cache and later pass the Fragment/Application to contained operator(s)
+        self.fragement = frament
+
         super().__init__(frament, *args, **kwargs)
 
     def setup(self, spec: OperatorSpec):
@@ -109,6 +117,7 @@ def compute(self, op_input, op_output, context):
             pre_transforms=pre_transforms,
             post_transforms=post_transforms,
             overlap=0.6,
+            app_context=self.app_context,
             model_name="",
             model_path=self.model_path,
         )

examples/apps/ai_multi_ai_app/__main__.py

@@ -1,4 +1,10 @@
-# from app import App
+import logging
 
-# if __name__ == "__main__":
-#     App(do_run=True)
+from app import App
+
+from monai.deploy.logger import load_env_log_level
+
+load_env_log_level()
+logging.info(f"Begin {__name__}")
+App.run()
+logging.info(f"End {__name__}")

examples/apps/ai_multi_ai_app/app.py

@@ -49,8 +49,8 @@ class AIPancreasSegApp(Application):
       https://github.com/Project-MONAI/model-zoo/tree/dev/models/pancreas_ct_dints_segmentation
 
     Execution Time Estimate:
-      With a Nvidia GV100 32GB GPU, for a input of 200 DICOM instances, execution time is around 90 seconds, and
-      for 500 instance 180 seconds.
+      With a Nvidia GV100 32GB GPU, the execution time is around 80 seconds for an input DICOM series of 204 instances,
+      and 160 second for a series of 515 instances.
     """
 
     def __init__(self, *args, **kwargs):
@@ -94,6 +94,7 @@ def compose(self):
             self,
             input_mapping=[IOMapping("image", Image, IOType.IN_MEMORY)],
             output_mapping=[IOMapping("pred", Image, IOType.IN_MEMORY)],
+            app_context=app_context,
             bundle_config_names=config_names,
             bundle_path=model_path,
             name="bundle_seg_op",
@@ -103,15 +104,27 @@ def compose(self):
         # the actual algorithm and the pertinent organ/tissue. The segment_label, algorithm_name,
         # and algorithm_version are of DICOM VR LO type, limited to 64 chars.
         # https://dicom.nema.org/medical/dicom/current/output/chtml/part05/sect_6.2.html
+        _algorithm_name = "Pancreas CT DiNTS segmentation from CT image"
+        _algorithm_family = codes.DCM.ArtificialIntelligence
+        _algorithm_version = "0.3.8"
+
         segment_descriptions = [
             SegmentDescription(
                 segment_label="Pancreas",
                 segmented_property_category=codes.SCT.Organ,
                 segmented_property_type=codes.SCT.Pancreas,
-                algorithm_name="volumetric (3D) segmentation of the pancreas from CT image",
-                algorithm_family=codes.DCM.ArtificialIntelligence,
-                algorithm_version="0.3.0",
-            )
+                algorithm_name=_algorithm_name,
+                algorithm_family=_algorithm_family,
+                algorithm_version=_algorithm_version,
+            ),
+            SegmentDescription(
+                segment_label="Tumor",
+                segmented_property_category=codes.SCT.Tumor,
+                segmented_property_type=codes.SCT.Tumor,
+                algorithm_name=_algorithm_name,
+                algorithm_family=_algorithm_family,
+                algorithm_version=_algorithm_version,
+            ),
         ]
 
         custom_tags = {"SeriesDescription": "AI generated Seg for research use only. Not for clinical use."}

examples/apps/ai_pancrea_seg_app/__init__.py renamed to examples/apps/ai_pancreas_seg_app/__init__.py

@@ -47,7 +47,8 @@ class AISpleenSegApp(Application):
       https://github.com/Project-MONAI/model-zoo/tree/dev/models/spleen_ct_segmentation
 
     Execution Time Estimate:
-      With a Nvidia GV100 32GB GPU, for a input of 500 DICOM instances, execution time is around 25 seconds.
+      With a Nvidia GV100 32GB GPU, for an input DICOM Series of 515 instances, the execution time is around
+      25 seconds with saving both DICOM Seg and surface mesh STL file, and 15 seconds with DICOM Seg only.
     """
 
     def __init__(self, *args, **kwargs):
@@ -83,15 +84,15 @@ def compose(self):
         # The model_name is optional when the app has only one model.
         # The bundle_path argument optionally can be set to an accessible bundle file path in the dev
         # environment, so when the app is packaged into a MAP, the operator can complete the bundle parsing
-        # during init to provide the optional packages info, parsed from the bundle, to the packager
-        # for it to install the packages in the MAP docker image.
+        # during init.
 
         config_names = BundleConfigNames(config_names=["inference"])  # Same as the default
 
         bundle_spleen_seg_op = MonaiBundleInferenceOperator(
             self,
             input_mapping=[IOMapping("image", Image, IOType.IN_MEMORY)],
             output_mapping=[IOMapping("pred", Image, IOType.IN_MEMORY)],
+            app_context=app_context,
             bundle_config_names=config_names,
             bundle_path=model_path,
             name="bundle_spleen_seg_op",
@@ -108,7 +109,7 @@ def compose(self):
                 segmented_property_type=codes.SCT.Spleen,
                 algorithm_name="volumetric (3D) segmentation of the spleen from CT image",
                 algorithm_family=codes.DCM.ArtificialIntelligence,
-                algorithm_version="0.1.0",
+                algorithm_version="0.3.2",
             )
         ]
 

examples/apps/ai_pancrea_seg_app/__main__.py renamed to examples/apps/ai_pancreas_seg_app/__main__.py

@@ -61,7 +61,7 @@ def compose(self):
         series_selector_op = DICOMSeriesSelectorOperator(self, rules=Sample_Rules_Text, name="series_selector_op")
         series_to_vol_op = DICOMSeriesToVolumeOperator(self, name="series_to_vol_op")
         # Model specific inference operator, supporting MONAI transforms.
-        seg_op = UnetrSegOperator(self, model_path=model_path, name="seg_op")
+        seg_op = UnetrSegOperator(self, app_context=app_context, model_path=model_path, name="seg_op")
 
         # Create the surface mesh STL conversion operator, for all segments
         stl_conversion_op = STLConversionOperator(

examples/apps/ai_pancrea_seg_app/app.py renamed to examples/apps/ai_pancreas_seg_app/app.py

@@ -14,7 +14,7 @@
 
 from numpy import uint8
 
-from monai.deploy.core import ConditionType, Fragment, Operator, OperatorSpec
+from monai.deploy.core import AppContext, ConditionType, Fragment, Operator, OperatorSpec
 from monai.deploy.operators.monai_seg_inference_operator import InMemImageReader, MonaiSegInferenceOperator
 from monai.transforms import (
     Activationsd,
@@ -55,7 +55,13 @@ class UnetrSegOperator(Operator):
     DEFAULT_OUTPUT_FOLDER = Path.cwd() / "output/saved_images_folder"
 
     def __init__(
-        self, frament: Fragment, *args, model_path: Path, output_folder: Path = DEFAULT_OUTPUT_FOLDER, **kwargs
+        self,
+        frament: Fragment,
+        *args,
+        app_context: AppContext,
+        model_path: Path,
+        output_folder: Path = DEFAULT_OUTPUT_FOLDER,
+        **kwargs,
     ):
         self.logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__))
 
@@ -66,11 +72,11 @@ def __init__(
         self.output_folder = output_folder
         self.output_folder.mkdir(parents=True, exist_ok=True)
         self.fragement = frament  # Cache and later pass the Fragment/Application to contained operator(s)
+        self.app_context = app_context
         self.input_name_image = "image"
         self.output_name_seg = "seg_image"
         self.output_name_saved_images_folder = "saved_images_folder"
 
-        self.fragement = frament  # Cache and later pass the Fragment/Application to contained operator(s)
         super().__init__(frament, *args, **kwargs)
 
     def setup(self, spec: OperatorSpec):
@@ -105,6 +111,7 @@ def compute(self, op_input, op_output, context):
             pre_transforms=pre_transforms,
             post_transforms=post_transforms,
             overlap=0.5,
+            app_context=self.app_context,
             model_path=self.model_path,
         )
 

examples/apps/ai_spleen_seg_app/app.py

@@ -46,12 +46,10 @@ def compose(self):
         study_loader_op = DICOMDataLoaderOperator(
             self, CountCondition(self, 1), input_folder=app_input_path, name="study_loader_op"
         )
-        series_selector_op = DICOMSeriesSelectorOperator(
-            self, rules_json_str=Sample_Rules_Text, name="series_selector_op"
-        )
+        series_selector_op = DICOMSeriesSelectorOperator(self, rules=Sample_Rules_Text, name="series_selector_op")
         series_to_vol_op = DICOMSeriesToVolumeOperator(self, name="series_to_vol_op")
         classifier_op = ClassifierOperator(
-            self, output_folder=app_output_path, model_path=model_path, name="classifier_op"
+            self, app_context=app_context, output_folder=app_output_path, model_path=model_path, name="classifier_op"
         )
         sr_writer_op = DICOMTextSRWriterOperator(
             self,

examples/apps/ai_unetr_seg_app/app.py

@@ -6,7 +6,7 @@
 import torch
 
 from monai.data import DataLoader, Dataset
-from monai.deploy.core import ConditionType, Fragment, Image, Operator, OperatorSpec
+from monai.deploy.core import AppContext, ConditionType, Fragment, Image, Operator, OperatorSpec
 from monai.deploy.operators.monai_seg_inference_operator import InMemImageReader
 from monai.transforms import (
     Activations,
@@ -42,6 +42,7 @@ def __init__(
         frament: Fragment,
         *args,
         model_name: Optional[str] = "",
+        app_context: AppContext,
         model_path: Path = MODEL_LOCAL_PATH,
         output_folder: Path = DEFAULT_OUTPUT_FOLDER,
         **kwargs,
@@ -73,9 +74,34 @@ def __init__(
         # Need the path to load the models when they are not loaded in the execution context
         self.model_path = model_path
 
-        # This needs to be at the end of the constructor.
+        # Use AppContect object for getting the loaded models
+        self.app_context = app_context
+
+        self.model = self._get_model(self.app_context, self.model_path, self._model_name)
+
         super().__init__(frament, *args, **kwargs)
 
+    def _get_model(self, app_context: AppContext, model_path: Path, model_name: str):
+        """Load the model with the given name from context or model path
+
+        Args:
+            app_context (AppContext): The application context object holding the model(s)
+            model_path (Path): The path to the model file, as a backup to load model directly
+            model_name (str): The name of the model, when multiples are loaded in the context
+        """
+
+        if app_context.models:
+            # `app_context.models.get(model_name)` returns a model instance if exists.
+            # If model_name is not specified and only one model exists, it returns that model.
+            model = app_context.models.get(model_name)
+        else:
+            model = torch.jit.load(
+                ClassifierOperator.MODEL_LOCAL_PATH,
+                map_location=torch.device("cuda" if torch.cuda.is_available() else "cpu"),
+            )
+
+        return model
+
     def setup(self, spec: OperatorSpec):
         """Set up the operator named input and named output, both are in-memory objects."""
 

examples/apps/ai_unetr_seg_app/unetr_seg_operator.py

@@ -14,6 +14,8 @@
 from pathlib import Path
 from typing import Optional
 
+import torch
+
 from monai.deploy.conditions import CountCondition
 from monai.deploy.core import AppContext, Application, ConditionType, Fragment, Image, Operator, OperatorSpec
 from monai.deploy.operators.dicom_text_sr_writer_operator import DICOMTextSRWriterOperator, EquipmentInfo, ModelInfo
@@ -99,6 +101,7 @@ def __init__(
         self,
         frament: Fragment,
         *args,
+        app_context: AppContext,
         model_name: Optional[str] = "",
         model_path: Path = MODEL_LOCAL_PATH,
         output_folder: Path = DEFAULT_OUTPUT_FOLDER,
@@ -130,10 +133,33 @@ def __init__(
         self._model_name = model_name.strip() if isinstance(model_name, str) else ""
         # Need the path to load the models when they are not loaded in the execution context
         self.model_path = model_path
+        self.app_context = app_context
+        self.model = self._get_model(self.app_context, self.model_path, self._model_name)
 
         # This needs to be at the end of the constructor.
         super().__init__(frament, *args, **kwargs)
 
+    def _get_model(self, app_context: AppContext, model_path: Path, model_name: str):
+        """Load the model with the given name from context or model path
+
+        Args:
+            app_context (AppContext): The application context object holding the model(s)
+            model_path (Path): The path to the model file, as a backup to load model directly
+            model_name (str): The name of the model, when multiples are loaded in the context
+        """
+
+        if app_context.models:
+            # `app_context.models.get(model_name)` returns a model instance if exists.
+            # If model_name is not specified and only one model exists, it returns that model.
+            model = app_context.models.get(model_name)
+        else:
+            model = torch.jit.load(
+                MedNISTClassifierOperator.MODEL_LOCAL_PATH,
+                map_location=torch.device("cuda" if torch.cuda.is_available() else "cpu"),
+            )
+
+        return model
+
     def setup(self, spec: OperatorSpec):
         """Set up the operator named input and named output, both are in-memory objects."""
 
@@ -157,12 +183,8 @@ def compute(self, op_input, op_output, context):
         device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         image_tensor = image_tensor.to(device)
 
-        # Need to get the model from context, when it is re-implemented, and for now, load it directly here.
-        # model = context.models.get()  # get a TorchScriptModel object
-        model = torch.jit.load(self.model_path, map_location=device)
-
         with torch.no_grad():
-            outputs = model(image_tensor)
+            outputs = self.model(image_tensor)
 
         _, output_classes = outputs.max(dim=1)
 
@@ -189,7 +211,7 @@ def compose(self):
         model_path = Path(app_context.model_path)
         load_pil_op = LoadPILOperator(self, CountCondition(self, 1), input_folder=app_input_path, name="pil_loader_op")
         classifier_op = MedNISTClassifierOperator(
-            self, output_folder=app_output_path, model_path=model_path, name="classifier_op"
+            self, app_context=app_context, output_folder=app_output_path, model_path=model_path, name="classifier_op"
         )
 
         my_model_info = ModelInfo("MONAI WG Trainer", "MEDNIST Classifier", "0.1", "xyz")

examples/apps/breast_density_classifer_app/app.py

@@ -38,3 +38,17 @@
 from .runtime_env import RuntimeEnv
 
 # from .resource import resource
+
+
+# Create function to add to the Application class
+def load_models(modle_path: str):
+    """_summary_
+
+    Args:
+        modle_path (str): _description_
+    """
+
+    return ModelFactory.create(modle_path)
+
+
+Application.load_models = load_models