address comments

Signed-off-by: YunLiu <[email protected]>

Author: KumoLiu

monai/bundle/workflows.py

@@ -51,7 +51,7 @@ class BundleWorkflow(ABC):
             default to `None` for common workflow.
         properties_path: the path to the JSON file of properties. If `workflow_type` is specified, properties will be
             loaded from the file based on the provided `workflow_type` and meta. If no `workflow_type` is specified,
-            properties will default to loading from "train". If the specified file is unavailable, default properties
+            properties will default to loading from "meta". If the specified file is unavailable, default properties
             will be sourced from "monai/bundle/properties.py" based on the workflow_type:
             For a training workflow, properties load from `TrainProperties` and `MetaProperties`.
             For a inference workflow, properties load from `InferProperties` and `MetaProperties`.
@@ -116,8 +116,7 @@ def __init__(
             if not properties_path.is_file():
                 raise ValueError(f"Property file {properties_path} does not exist.")
             if workflow_type is None:
-                workflow_type = "train"
-                logger.info("No workflow type specified, default to 'train' for property file loading.")
+                logger.info("No workflow type specified, default to load meta properties from property file.")
             with open(properties_path) as json_file:
                 try:
                     properties = json.load(json_file)
@@ -249,9 +248,13 @@ def check_properties(self) -> list[str] | None:
 class PythonicWorkflow(BundleWorkflow):
     """
     Base class for the pythonic workflow specification in bundle, it can be a training, evaluation or inference workflow.
-    It defines the basic interfaces for the bundle workflow behavior: `initialize`, `run`, `finalize`, etc.
+    It defines the basic interfaces for the bundle workflow behavior: `initialize`, `finalize`, etc.
     This also provides the interface to get / set public properties to interact with a bundle workflow through
     defined `get_<property>` accessor methods or directly defining members of the object.
+    For how to set the properties, users can define the `_set_<property>` methods or directly set the members of the object.
+    The `initialize` method is called to set up the workflow before running. This method sets up internal state and prepares properties.
+    If properties are modified after the workflow has been initialized, `self._is_initialized` is set to `False`. Before running the
+    workflow again, `initialize` should be called to ensure that the workflow is properly set up with the new property values.
 
     Args:
         workflow_type: specifies the workflow type: "train" or "training" for a training workflow,
@@ -264,7 +267,7 @@ class PythonicWorkflow(BundleWorkflow):
             default to `None` for common workflow.
         properties_path: the path to the JSON file of properties. If `workflow_type` is specified, properties will be
             loaded from the file based on the provided `workflow_type` and meta. If no `workflow_type` is specified,
-            properties will default to loading from "train". If the specified file is unavailable, default properties
+            properties will default to loading from "meta". If the specified file is unavailable, default properties
             will be sourced from "monai/bundle/properties.py" based on the workflow_type:
             For a training workflow, properties load from `TrainProperties` and `MetaProperties`.
             For a inference workflow, properties load from `InferProperties` and `MetaProperties`.
@@ -302,12 +305,14 @@ def __init__(
 
         # the rest key-values in the _args are to override config content
         self.parser.update(pairs=override)
+        self._is_initialized: bool = False
 
     def initialize(self, *args: Any, **kwargs: Any) -> Any:
         """
         Initialize the bundle workflow before running.
         """
         self._props_vals = {}
+        self._is_initialized = True
 
     def _get_property(self, name: str, property: dict) -> Any:
         """
@@ -320,6 +325,8 @@ def _get_property(self, name: str, property: dict) -> Any:
             name: the name of target property.
             property: other information for the target property, defined in `TrainProperties` or `InferProperties`.
         """
+        if not self._is_initialized:
+            raise RuntimeError("Please execute 'initialize' before getting any properties.")
         value = None
         if name in self._set_props_vals:
             value = self._set_props_vals[name]
@@ -343,7 +350,7 @@ def _get_property(self, name: str, property: dict) -> Any:
     def _set_property(self, name: str, property: dict, value: Any) -> Any:
         """
         With specified property name and information, set value for the expected property.
-        Stores user-reset initialized objects that should not be re-initialized.
+        Stores user-reset initialized objects that should not be re-initialized and marks the workflow as not initialized.
 
         Args:
             name: the name of target property.
@@ -352,6 +359,7 @@ def _set_property(self, name: str, property: dict, value: Any) -> Any:
 
         """
         self._set_props_vals[name] = value
+        self._is_initialized = False
 
 
 class ConfigWorkflow(BundleWorkflow):

tests/nonconfig_workflow.py

@@ -197,6 +197,8 @@ def __init__(
         self.dataflow: dict = {}
 
     def initialize(self):
+        self._props_vals = {}
+        self._is_initialized = True
         self.net = UNet(
             spatial_dims=3,
             in_channels=1,
@@ -214,7 +216,6 @@ def initialize(self):
         )
         self.dataset = Dataset(data=[self.dataflow], transform=preprocessing)
         self.postprocessing = Compose([Activationsd(keys="pred", softmax=True), AsDiscreted(keys="pred", argmax=True)])
-        self.inferer = SlidingWindowInferer(roi_size=self.parser.roi_size, sw_batch_size=1, overlap=0)
 
     def run(self):
         data = self.dataset[0]
@@ -234,4 +235,4 @@ def get_device(self):
         return torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
     def get_inferer(self):
-        return self.inferer
+        return SlidingWindowInferer(roi_size=self.parser.roi_size, sw_batch_size=1, overlap=0)

tests/test_bundle_workflow.py

@@ -22,7 +22,7 @@
 import torch
 from parameterized import parameterized
 
-from monai.bundle import ConfigWorkflow
+from monai.bundle import ConfigWorkflow, create_workflow
 from monai.data import Dataset
 from monai.inferers import SimpleInferer, SlidingWindowInferer
 from monai.networks.nets import UNet
@@ -190,6 +190,41 @@ def test_pythonic_workflow(self):
         self.assertEqual(pred.meta["filename_or_obj"], self.filename2)
         workflow.finalize()
 
+    def test_create_pythonic_workflow(self):
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        config_file = {"roi_size": (64, 64, 32)}
+        meta_file = os.path.join(os.path.dirname(__file__), "testing_data", "metadata.json")
+        property_path = os.path.join(os.path.dirname(__file__), "testing_data", "python_workflow_properties.json")
+        import sys
+        sys.path.append(os.path.dirname(__file__))
+        workflow = create_workflow("nonconfig_workflow.PythonicWorkflowImpl", workflow_type="infer", config_file=config_file, meta_file=meta_file, properties_path=property_path)
+        # Load input data
+        input_loader = LoadImaged(keys="image")
+        workflow.dataflow.update(input_loader({"image": self.filename}))
+        self.assertEqual(workflow.bundle_root, ".")
+        self.assertEqual(workflow.device, device)
+        self.assertEqual(workflow.version, "0.1.0")
+        # check config override correctly
+        self.assertEqual(workflow.inferer.roi_size, (64, 64, 32))
+        
+        # check set property override correctly
+        workflow.inferer = SlidingWindowInferer(roi_size=config_file["roi_size"], sw_batch_size=1, overlap=0.5)
+        workflow.initialize()
+        self.assertEqual(workflow.inferer.overlap, 0.5)
+
+        workflow.run()
+        # update input data and run again
+        workflow.dataflow.update(input_loader({"image": self.filename2}))
+        workflow.run()
+        pred = workflow.dataflow["pred"]
+        self.assertEqual(pred.shape[2:], self.expected_shape)
+        self.assertEqual(pred.meta["filename_or_obj"], self.filename2)
+        
+        # test add properties
+        workflow.add_property(name="net", required=True, desc="network for the training.")
+        self.assertIn("net", workflow.properties)
+        workflow.finalize()
+
 
 if __name__ == "__main__":
     unittest.main()

tests/testing_data/python_workflow_properties.json

@@ -0,0 +1,26 @@
+{
+    "infer": {
+        "bundle_root": {
+            "description": "root path of the bundle.",
+            "required": true,
+            "id": "bundle_root"
+        },
+        "device": {
+            "description": "target device to execute the bundle workflow.",
+            "required": true,
+            "id": "device"
+        },
+        "inferer": {
+            "description": "MONAI Inferer object to execute the model computation in inference.",
+            "required": true,
+            "id": "inferer"
+        }
+    },
+    "meta": {
+        "version": {
+            "description": "version of the inference configuration.",
+            "required": true,
+            "id": "_meta_::version"
+        }
+    }
+}