Merge branch 'dev' into merging-into-metatensor

Signed-off-by: Wenqi Li <[email protected]>

Author: wyli

docs/source/config_syntax.md

@@ -12,10 +12,10 @@ Content:
 
 - [A basic example](#a-basic-example)
 - [Syntax examples explained](#syntax-examples-explained)
-  - [`@` to interpolate with Python objects](#1--to-interpolate-with-python-objects)
-  - [`$` to evaluate as Python expressions](#2--to-evaluate-as-python-expressions)
-  - [`%` to textually replace configuration elements](#3--to-textually-replace-configuration-elements)
-  - [`_target_` (`_disabled_` and `_requires_`) to instantiate a Python object](#4-instantiate-a-python-object)
+  - [`@` to reference Python objects in configurations](#to-reference-python-objects-in-configurations)
+  - [`$` to evaluate as Python expressions](#to-evaluate-as-python-expressions)
+  - [`%` to textually replace configuration elements](#to-textually-replace-configuration-elements)
+  - [`_target_` (`_disabled_` and `_requires_`) to instantiate a Python object](#instantiate-a-python-object)
 - [The command line interface](#the-command-line-interface)
 - [Recommendations](#recommendations)
 
@@ -73,22 +73,22 @@ For more details on the `ConfigParser` API, please see https://docs.monai.io/en/
 
 A few characters and keywords are interpreted beyond the plain texts, here are examples of the syntax:
 
-### 1. `@` to interpolate with Python objects
+### To reference Python objects in configurations
 
 ```json
 "@preprocessing#transforms#keys"
 ```
 
-_Description:_ A reference to another configuration value defined at `preprocessing#transforms#keys`.
+_Description:_ `@` character indicates a reference to another configuration value defined at `preprocessing#transforms#keys`.
 where `#` indicates a sub-structure of this configuration file.
 
 ```json
 "@preprocessing#1"
 ```
 
-_Description:_ `1` is interpreted as an integer, which is used to index (zero-based indexing) the `preprocessing` sub-structure.
+_Description:_ `1` is referencing as an integer, which is used to index (zero-based indexing) the `preprocessing` sub-structure.
 
-### 2. `$` to evaluate as Python expressions
+### To evaluate as Python expressions
 
 ```json
 "$print(42)"
@@ -110,16 +110,16 @@ _Description:_ `$` followed by an import statement is handled slightly different
 Python expressions. The imported module `resnet18` will be available as a global variable
 to the other configuration sections. This is to simplify the use of external modules in the configuration.
 
-### 3. `%` to textually replace configuration elements
+### To textually replace configuration elements
 
 ```json
 "%demo_config.json#demo_net#in_channels"
 ```
 
-_Description:_ A macro to replace the current configuration element with the texts at `demo_net#in_channels` in the
+_Description:_ `%` character indicates a macro to replace the current configuration element with the texts at `demo_net#in_channels` in the
 `demo_config.json` file. The replacement is done before instantiating or evaluating the components.
 
-### 4. instantiate a Python object
+### Instantiate a Python object
 
 ```json
 {
@@ -164,6 +164,7 @@ python -m monai.bundle COMMANDS
 where `COMMANDS` is one of the following: `run`, `verify_metadata`, `ckpt_export`, ...
 (please see `python -m monai.bundle --help` for a list of available options).
 
+The CLI supports flexible use cases, such as overriding configs at runtime and predefining arguments in a file.
 To display a usage page for a command, for example `run`:
 ```bash
 python -m monai.bundle run -- --help
@@ -182,3 +183,5 @@ Details on the CLI argument parsing is provided in the
   simple structures with sparse uses of expressions or references are preferred.
 - For `$import <module>` in the configuration, please make sure there are instructions for the users to install
   the `<module>` if it is not a (optional) dependency of MONAI.
+- As "#" and "$" might be interpreted differently by the `shell` or `CLI` tools, may need to add escape characters
+  or quotes for them in the command line, like: `"\$torch.device('cuda:1')"`, `"'train_part#trainer'"`.

monai/apps/detection/transforms/array.py

@@ -535,7 +535,9 @@ class RotateBox90(Rotate90):
     def __init__(self, k: int = 1, spatial_axes: Tuple[int, int] = (0, 1)) -> None:
         super().__init__(k, spatial_axes)
 
-    def __call__(self, boxes: NdarrayOrTensor, spatial_size: Union[Sequence[int], int]) -> NdarrayOrTensor:  # type: ignore
+    def __call__(  # type: ignore
+        self, boxes: NdarrayOrTensor, spatial_size: Union[Sequence[int], int]
+    ) -> NdarrayOrTensor:
         """
         Args:
             img: channel first array, must have shape: (num_channels, H[, W, ..., ]),

monai/apps/detection/transforms/dictionary.py

@@ -248,7 +248,7 @@ def __init__(
         self.converter_to_image_coordinate = AffineBox()
         self.affine_lps_to_ras = affine_lps_to_ras
 
-    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Dict[Hashable, NdarrayOrTensor]:
+    def extract_affine(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Tuple[NdarrayOrTensor, NdarrayOrTensor]:
         d = dict(data)
 
         meta_key = self.image_meta_key
@@ -269,6 +269,12 @@ def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Dict[Hashable, N
         affine_t, *_ = convert_data_type(affine, torch.Tensor)
         # torch.inverse should not run in half precision
         inv_affine_t = torch.inverse(affine_t.to(COMPUTE_DTYPE))
+        return affine, inv_affine_t
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+
+        affine, inv_affine_t = self.extract_affine(data)
 
         for key in self.key_iterator(d):
             self.push_transform(d, key, extra_info={"affine": affine})
@@ -285,6 +291,54 @@ def inverse(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Dict[Hashable, Nd
         return d
 
 
+class AffineBoxToWorldCoordinated(AffineBoxToImageCoordinated):
+    """
+    Dictionary-based transform that converts box in image coordinate to world coordinate.
+
+    Args:
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_ref_image_keys: The single key that represents the reference image to which ``box_keys`` are attached.
+        remove_empty: whether to remove the boxes that are actually empty
+        allow_missing_keys: don't raise exception if key is missing.
+        image_meta_key: explicitly indicate the key of the corresponding metadata dictionary.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, affine, original_shape, etc.
+            it is a string, map to the `box_ref_image_key`.
+            if None, will try to construct meta_keys by `box_ref_image_key_{meta_key_postfix}`.
+        image_meta_key_postfix: if image_meta_keys=None, use `box_ref_image_key_{postfix}` to fetch the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+        affine_lps_to_ras: default ``False``. Yet if 1) the image is read by ITKReader,
+            and 2) the ITKReader has affine_lps_to_ras=True, and 3) the box is in world coordinate,
+            then set ``affine_lps_to_ras=True``.
+    """
+
+    def __init__(
+        self,
+        box_keys: KeysCollection,
+        box_ref_image_keys: str,
+        allow_missing_keys: bool = False,
+        image_meta_key: Union[str, None] = None,
+        image_meta_key_postfix: Union[str, None] = DEFAULT_POST_FIX,
+        affine_lps_to_ras=False,
+    ) -> None:
+        super().__init__(
+            box_keys, box_ref_image_keys, allow_missing_keys, image_meta_key, image_meta_key_postfix, affine_lps_to_ras
+        )
+        self.converter_to_world_coordinate = AffineBox()
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+
+        affine, inv_affine_t = self.extract_affine(data)
+
+        for key in self.key_iterator(d):
+            self.push_transform(d, key, extra_info={"affine": inv_affine_t})
+            d[key] = self.converter_to_world_coordinate(d[key], affine=affine)
+        return d
+
+
 class ZoomBoxd(MapTransform, InvertibleTransform):
     """
     Dictionary-based transform that zooms input boxes and images with the given zoom scale.

monai/data/grid_dataset.py

@@ -187,23 +187,19 @@ def __init__(
     ) -> None:
         super().__init__(data=data, transform=None)
         self.patch_iter = patch_iter
-        self.transform = transform
+        self.patch_transform = transform
         self.with_coordinates = with_coordinates
 
     def __iter__(self):
         for image in super().__iter__():
-            if not self.with_coordinates:
-                for patch, *_ in self.patch_iter(image):  # patch_iter to yield at least 1 item: patch
-                    out_patch = (
-                        patch if self.transform is None else apply_transform(self.transform, patch, map_items=False)
-                    )
+            for patch, *others in self.patch_iter(image):
+                out_patch = patch
+                if self.patch_transform is not None:
+                    out_patch = apply_transform(self.patch_transform, patch, map_items=False)
+                if self.with_coordinates and len(others) > 0:  # patch_iter to yield at least 2 items: patch, coords
+                    yield out_patch, others[0]
+                else:
                     yield out_patch
-            else:
-                for patch, slices, *_ in self.patch_iter(image):  # patch_iter to yield at least 2 items: patch, coords
-                    out_patch = (
-                        patch if self.transform is None else apply_transform(self.transform, patch, map_items=False)
-                    )
-                    yield out_patch, slices
 
 
 class PatchDataset(Dataset):

monai/data/iterable_dataset.py

@@ -11,7 +11,6 @@
 
 from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Union
 
-import numpy as np
 from torch.utils.data import IterableDataset as _TorchIterableDataset
 from torch.utils.data import get_worker_info
 
@@ -115,9 +114,6 @@ def _get_item():
     def randomize(self, size: int) -> None:
         self._idx = self.R.randint(size)
 
-    def set_random_state(self, seed: Optional[int] = None, state: Optional[np.random.RandomState] = None):
-        raise NotImplementedError(f"`set_random_state` is not available in {self.__class__.__name__}.")
-
 
 class CSVIterableDataset(IterableDataset):
     """

monai/inferers/inferer.py

@@ -278,6 +278,7 @@ class SliceInferer(SlidingWindowInferer):
     def __init__(self, spatial_dim: int = 0, *args, **kwargs) -> None:
         self.spatial_dim = spatial_dim
         super().__init__(*args, **kwargs)
+        self.orig_roi_size = ensure_tuple(self.roi_size)
 
     def __call__(
         self,
@@ -298,11 +299,13 @@ def __call__(
 
         # Check if ``roi_size`` tuple is 2D and ``inputs`` tensor is 3D
         self.roi_size = ensure_tuple(self.roi_size)
-        if len(self.roi_size) == 2 and len(inputs.shape[2:]) == 3:
-            self.roi_size = list(self.roi_size)
+        if len(self.orig_roi_size) == 2 and len(inputs.shape[2:]) == 3:
+            self.roi_size = list(self.orig_roi_size)
             self.roi_size.insert(self.spatial_dim, 1)
         else:
-            raise RuntimeError("Currently, only 2D `roi_size` with 3D `inputs` tensor is supported.")
+            raise RuntimeError(
+                f"Currently, only 2D `roi_size` ({self.orig_roi_size}) with 3D `inputs` tensor (shape={inputs.shape}) is supported."
+            )
 
         return super().__call__(inputs=inputs, network=lambda x: self.network_wrapper(network, x, *args, **kwargs))
 

monai/losses/giou_loss.py

@@ -50,7 +50,9 @@ def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
             raise ValueError(f"ground truth has different shape ({target.shape}) from input ({input.shape})")
 
         box_dtype = input.dtype
-        giou: torch.Tensor = box_pair_giou(target.to(dtype=COMPUTE_DTYPE), input.to(dtype=COMPUTE_DTYPE))  # type: ignore
+        giou: torch.Tensor = box_pair_giou(  # type: ignore
+            target.to(dtype=COMPUTE_DTYPE), input.to(dtype=COMPUTE_DTYPE)
+        )
         loss: torch.Tensor = 1.0 - giou
         if self.reduction == LossReduction.MEAN.value:
             loss = loss.mean()

monai/networks/nets/swin_unetr.py

@@ -474,7 +474,7 @@ def forward(self, x, mask):
         q = q * self.scale
         attn = q @ k.transpose(-2, -1)
         relative_position_bias = self.relative_position_bias_table[
-            self.relative_position_index[:n, :n].reshape(-1)
+            self.relative_position_index.clone()[:n, :n].reshape(-1)
         ].reshape(n, n, -1)
         relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()
         attn = attn + relative_position_bias.unsqueeze(0)