[WIP] 3482 Develop components for the model package MVP

monai/apps/manifest/export.py

@@ -0,0 +1,59 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import json
+
+import torch
+from monai.apps import ConfigParser
+from ignite.handlers import Checkpoint
+from monai.data import save_net_with_metadata
+from monai.networks import convert_to_torchscript
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--weights', '-w', type=str, help='file path of the trained model weights', required=True)
+    parser.add_argument('--config', '-c', type=str, help='file path of config file that defines network', required=True)
+    parser.add_argument('--meta', '-e', type=str, help='file path of the meta data')
+    args = parser.parse_args()
+
+    # load config file
+    with open(args.config) as f:
+        config_dict = json.load(f)
+    # load meta data
+    with open(args.meta) as f:
+        meta_dict = json.load(f)
+
+    net: torch.nn.Module = None
+    # TODO: parse network definiftion from config file and construct network instance
+    config_parser = ConfigParser(config_dict)
+    net = config_parser.get_instance("network")
+
+    checkpoint = torch.load(args.weights)
+    # here we use ignite Checkpoint to support nested weights and be compatible with MONAI CheckpointSaver
+    Checkpoint.load_objects(to_load={"model": net}, checkpoint=checkpoint)
+
+    # convert to TorchScript model and save with meta data
+    net = convert_to_torchscript(model=net)
+
+    save_net_with_metadata(
+        jit_obj=net,
+        filename_prefix_or_stream="model.ts",
+        include_config_vals=False,
+        append_timestamp=False,
+        meta_values=meta_dict,
+        more_extra_files={args.config: json.dumps(config_dict).encode()},
+    )
+
+
+if __name__ == '__main__':
+    main()

monai/apps/manifest/inference.py

@@ -0,0 +1,68 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import json
+
+import torch
+from monai.apps import ConfigParser
+from monai.data import decollate_batch
+from monai.inferers import Inferer
+from monai.transforms import Transform
+from monai.utils.enums import CommonKeys
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', '-c', type=str, help='config file that defines components', required=True)
+    parser.add_argument('--meta', '-e', type=str, help='file path of the meta data')
+    parser.add_argument('--override', '-o', type=str, help='config file that override components', required=False)
+    args = parser.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    configs = {}
+
+    # load meta data
+    with open(args.meta) as f:
+        configs.update(json.load(f))
+    # load config file, can override meta data in config
+    with open(args.config) as f:
+        configs.update(json.load(f))
+
+    model: torch.nn.Module = None
+    dataloader: torch.utils.data.DataLoader = None
+    inferer: Inferer = None
+    postprocessing: Transform = None
+    # TODO: parse inference config file and construct instances
+    config_parser = ConfigParser(configs)
+
+    # change JSON config content in python code, lazy instantiation
+    model_conf = config_parser.get_config("model")
+    model_conf["disabled"] = False
+    model = config_parser.build(model_conf).to(device)
+
+    # instantialize the components immediately
+    dataloader = config_parser.get_instance("dataloader")
+    inferer = config_parser.get_instance("inferer")
+    postprocessing = config_parser.get_instance("postprocessing")
+
+    model.eval()
+    with torch.no_grad():
+        for d in dataloader:
+            images = d[CommonKeys.IMAGE].to(device)
+            # define sliding window size and batch size for windows inference
+            d[CommonKeys.PRED] = inferer(inputs=images, predictor=model)
+            # decollate the batch data into a list of dictionaries, then execute postprocessing transforms
+            [postprocessing(i) for i in decollate_batch(d)]
+
+
+if __name__ == '__main__':
+    main()

monai/apps/manifest/schema/metadata.json

@@ -0,0 +1,71 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://monai.io/mmar_metadata_schema.json",
+    "title": "metadata",
+    "description": "metadata that defines the context information for MMAR.",
+    "type": "object",
+    "properties": {
+        "version": {
+            "description": "version number of this MMAR.",
+            "type": "string"
+        },
+        "monai_version": {
+            "description": "version number of MONAI used in this MMAR.",
+            "type": "string"
+        },
+        "pytorch_version": {
+            "description": "version number of PyTorch used in this MMAR.",
+            "type": "string"
+        },
+        "numpy_version": {
+            "description": "version number of MONAI used in this MMAR.",
+            "type": "string"
+        },
+        "network_data_format": {
+            "description": "define the input and output data format for network.",
+            "type": "object",
+            "properties": {
+                "inputs": {
+                    "type": "object",
+                    "properties": {
+                        "image": {
+                            "type": "object",
+                            "properties": {
+                                "type": {
+                                    "type": "string",
+                                    "description": "the data format for `image`."
+                                },
+                                "format": {
+                                    "type": "string"
+                                },
+                                "num_channels": {
+                                    "type": "integer",
+                                    "minimum": 1
+                                },
+                                "spatial_shape": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "integer",
+                                        "minumum": 1
+                                    }
+                                },
+                                "dtype": {
+                                    "type": "string"
+                                },
+                                "value_range": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "number",
+                                        "unuqueItems": true
+                                    }
+                                },
+                                "required": ["num_channels", "spatial_shape", "value_range"]
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "required": ["monai_version", "pytorch_version", "network_data_format"]
+    }
+}

monai/apps/manifest/verify_network.py

@@ -0,0 +1,60 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import json
+
+import torch
+from monai.apps import ConfigParser
+from monai.utils.type_conversion import get_equivalent_dtype
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', '-c', type=str, help='config file that defines components', required=True)
+    parser.add_argument('--meta', '-e', type=str, help='file path of the meta data')
+    args = parser.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    configs = {}
+
+    # load meta data
+    with open(args.meta) as f:
+        configs.update(json.load(f))
+    # load config file, can override meta data in config
+    with open(args.config) as f:
+        configs.update(json.load(f))
+
+    model: torch.nn.Module = None
+    # TODO: parse inference config file and construct instances
+    config_parser = ConfigParser(configs)
+
+    model = config_parser.get_instance("model")
+    input_channels = config_parser.get_config("network_data_format#inputs#image#num_channels")
+    input_spatial_shape = tuple(config_parser.get_config("network_data_format#inputs#image#spatial_shape"))
+    dtype = config_parser.get_config("network_data_format#inputs#image#dtype")
+    dtype = get_equivalent_dtype(dtype, data_type=torch.Tensor)
+
+    output_channels = config_parser.get_config("network_data_format#outputs#pred#num_channels")
+    output_spatial_shape = tuple(config_parser.get_config("network_data_format#outputs#pred#spatial_shape"))
+
+    model.eval()
+    with torch.no_grad():
+        test_data = torch.rand(*(input_channels, *input_spatial_shape), dtype=dtype, device=device)
+        output = model(test_data)
+        if output.shape[0] != output_channels:
+            raise ValueError(f"channel number of output data doesn't match expection: {output_channels}.")
+        if output.shape[1:] != output_spatial_shape:
+            raise ValueError(f"spatial shape of output data doesn't match expection: {output_spatial_shape}.")
+
+
+if __name__ == '__main__':
+    main()