monai-weekly 1.7.dev2643__tar.gz → 1.7.dev2645__tar.gz

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2643
+Version: 1.7.dev2645
 Summary: AI Toolkit for Healthcare Imaging
 Author-email: MONAI Consortium <monai.contact@gmail.com>
 License: Apache License 2.0

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/__init__.py

@@ -137,4 +137,4 @@ except Exception:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "4f150a8f26664d1452a8e420d118f4541597f686"
+__commit_id__ = "c5bddb21ccaaf3654a87c65ede6d2c7bd82e4128"

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-10-25T02:15:18+0000",
+ "date": "2026-11-08T02:09:15+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "08aa7d448a8733b13dadffc2f153f7bcb56f41cf",
- "version": "1.7.dev2643"
+ "full-revisionid": "ed1d0c3cb86b2cfe223a7c845bec698dedbfa614",
+ "version": "1.7.dev2645"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/apps/auto3dseg/auto_runner.py

@@ -23,7 +23,7 @@ import torch
 from monai.apps.auto3dseg.bundle_gen import BundleGen
 from monai.apps.auto3dseg.data_analyzer import DataAnalyzer
 from monai.apps.auto3dseg.ensemble_builder import EnsembleRunner
-from monai.apps.auto3dseg.hpo_gen import NNIGen
+from monai.apps.auto3dseg.hpo_gen import NNIGen, _nni_trial_command
 from monai.apps.auto3dseg.utils import export_bundle_algo_history, import_bundle_algo_history
 from monai.apps.utils import get_logger
 from monai.auto3dseg.utils import algo_to_json
@@ -797,7 +797,7 @@ class AutoRunner:
                     nni_config[key] = self.hpo_params[key]
             nni_config.update({"experimentName": name})
             nni_config.update({"search_space": self.search_space})
-            trial_cmd = "python -m monai.apps.auto3dseg NNIGen run_algo " + obj_filename + " " + self.work_dir
+            trial_cmd = _nni_trial_command(obj_filename, self.work_dir)
             nni_config.update({"trialCommand": trial_cmd})
             nni_config_filename = os.path.abspath(os.path.join(self.work_dir, f"{name}_nni_config.yaml"))
             ConfigParser.export_config_file(nni_config, nni_config_filename, fmt="yaml", default_flow_style=None)

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/apps/auto3dseg/bundle_gen.py

@@ -12,6 +12,7 @@
 from __future__ import annotations
 
 import importlib
+import ntpath
 import os
 import re
 import shutil
@@ -50,6 +51,52 @@ ALGO_HASH = MONAIEnvVars.algo_hash()
 __all__ = ["BundleAlgo", "BundleGen"]
 
 
+def _check_single_path_component(value: Any, what: str) -> None:
+    """
+    Require ``value`` to be one non-empty directory name with no path separators, drive or NUL character.
+
+    Args:
+        value: the name to check.
+        what: a description of the value, used in the error message.
+
+    Raises:
+        ValueError: if ``value`` is not a plain directory name.
+    """
+    name = str(value)
+    separators = {os.sep, "/"} | ({os.altsep} if os.altsep else set())
+    if (
+        not name
+        or name in (".", "..")
+        or "\x00" in name
+        or any(sep in name for sep in separators)
+        or os.path.isabs(name)
+        or ntpath.splitdrive(name)[0]
+    ):
+        raise ValueError(f"Invalid {what} {value!r}: expected a single directory name without path separators.")
+
+
+def _confined_join(root: str, name: str) -> str:
+    """
+    Join ``name`` to ``root`` and check that the resolved result stays inside ``root``.
+
+    Args:
+        root: the parent directory.
+        name: the child directory name.
+
+    Returns:
+        the joined path.
+
+    Raises:
+        ValueError: if the resolved path is not inside ``root``.
+    """
+    path = os.path.join(root, name)
+    real_root = os.path.realpath(root)
+    real_path = os.path.realpath(path)
+    if real_path == real_root or os.path.commonpath([real_root, real_path]) != real_root:
+        raise ValueError(f"Invalid path: {path!r} is not inside {root!r}.")
+    return path
+
+
 class BundleAlgo(Algo):
     """
     An algorithm represented by a set of bundle configurations and scripts.
@@ -176,18 +223,29 @@ class BundleAlgo(Algo):
         Args:
             output_path: Path to export the 'scripts' and 'configs' directories.
             algo_name: the identifier of the algorithm (usually contains the name and extra info like fold ID).
+                It must be a single directory name: path separators, ``.`` and ``..`` are rejected.
             kwargs: other parameters, including: "copy_dirs=True/False" means whether to copy the template as output
                 instead of inplace operation, "fill_template=True/False" means whether to fill the placeholders
                 in the template. other parameters are for `fill_template_config` function.
 
+
+        Raises:
+            ValueError: if ``algo_name`` or the Algo ``name`` is not a single directory name, or the destination
+                does not resolve inside ``output_path``.
         """
         if kwargs.pop("copy_dirs", True):
-            self.output_path = os.path.join(output_path, algo_name)
+            _check_single_path_component(algo_name, "algo_name")
+            if self.name:  # an empty name copies the whole template_path
+                _check_single_path_component(self.name, "the Algo name")
+            source = os.path.join(str(self.template_path), self.name)
+            if not os.path.isdir(source):
+                raise ValueError(f"Algo template folder {source!r} does not exist.")
+            self.output_path = _confined_join(output_path, algo_name)
             os.makedirs(self.output_path, exist_ok=True)
             if os.path.isdir(self.output_path):
                 shutil.rmtree(self.output_path)
             # copy algorithm_templates/<Algo> to the working directory output_path
-            shutil.copytree(os.path.join(str(self.template_path), self.name), self.output_path)
+            shutil.copytree(source, self.output_path)
         else:
             self.output_path = str(self.template_path)
         if kwargs.pop("fill_template", True):

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/apps/auto3dseg/hpo_gen.py

@@ -12,6 +12,8 @@
 from __future__ import annotations
 
 import os
+import shlex
+import sys
 from abc import abstractmethod
 from copy import deepcopy
 from typing import Any, cast
@@ -32,6 +34,84 @@ logger = get_logger(module_name=__name__)
 __all__ = ["HPOGen", "NNIGen", "OptunaGen"]
 
 
+# cmd.exe expands or ends a quoted argument at these characters even inside double quotes
+_CMD_UNSAFE_CHARS = frozenset('"%!\r\n\x00')
+
+
+def _quote_trial_arg(arg: Any, windows: bool | None = None) -> str:
+    """
+    Quote one argument of an NNI ``trialCommand`` as a literal for the shell NNI uses.
+
+    NNI's local training service runs ``trialCommand`` with bash on Linux and macOS and with ``cmd.exe`` on
+    Windows. For ``cmd.exe`` the argument is wrapped in double quotes, which make ``&``, ``|``, ``<``, ``>``,
+    ``^`` and parentheses literal, and backslashes before the closing quote are doubled so the program receives
+    the argument unchanged. Characters that ``cmd.exe`` interprets even inside double quotes are rejected.
+
+    Args:
+        arg: the argument value.
+        windows: quote for ``cmd.exe`` instead of a POSIX shell. Defaults to ``sys.platform == "win32"``.
+
+    Returns:
+        the quoted argument.
+
+    Raises:
+        ValueError: on Windows, if the argument contains ``"``, ``%``, ``!`` or a line break or NUL character.
+    """
+    text = str(arg)
+    if sys.platform == "win32" if windows is None else windows:
+        unsafe = sorted(_CMD_UNSAFE_CHARS.intersection(text))
+        if unsafe:
+            raise ValueError(f"Cannot pass {text!r} to an NNI trial on Windows: it contains {unsafe}.")
+        trailing = len(text) - len(text.rstrip("\\"))
+        return '"' + text + "\\" * trailing + '"'
+    return shlex.quote(text)
+
+
+def _nni_trial_command(obj_filename: Any, work_dir: Any, windows: bool | None = None) -> str:
+    """
+    Build the NNI ``trialCommand`` that runs one algo trial.
+
+    The fixed part of the command is plain text; the two paths are quoted with ``_quote_trial_arg`` so they
+    are passed to ``NNIGen run_algo`` unchanged. On a POSIX shell any path is accepted; ``cmd.exe`` cannot
+    carry a few characters even inside double quotes, see ``_quote_trial_arg``.
+
+    Args:
+        obj_filename: the serialized algo object file.
+        work_dir: the Auto3DSeg working directory.
+        windows: quote for ``cmd.exe`` instead of a POSIX shell. Defaults to ``sys.platform == "win32"``.
+
+    Returns:
+        the command string to store as ``trialCommand``.
+
+    Raises:
+        ValueError: on Windows, if ``obj_filename`` or ``work_dir`` contains ``"``, ``%``, ``!``, a line
+            break or a NUL character.
+    """
+    paths = " ".join(_quote_trial_arg(p, windows) for p in (obj_filename, work_dir))
+    return f"python -m monai.apps.auto3dseg NNIGen run_algo {paths}"
+
+
+def _quote_or_raw(arg: Any, windows: bool | None = None) -> str:
+    """
+    Quote one argument of the printed trialCommand instruction, falling back to the unquoted text.
+
+    ``print_bundle_algo_instruction`` only reports how to write the command, so a path its shell cannot
+    quote must not stop the instructions from printing: warn and print the path as it is.
+
+    Args:
+        arg: the argument value.
+        windows: quote for ``cmd.exe`` instead of a POSIX shell. Defaults to ``sys.platform == "win32"``.
+
+    Returns:
+        the quoted argument, or ``str(arg)`` if the shell cannot quote it.
+    """
+    try:
+        return _quote_trial_arg(arg, windows)
+    except ValueError as error:
+        logger.warning(f"Leaving {str(arg)!r} unquoted in the printed trialCommand: {error}")
+        return str(arg)
+
+
 class HPOGen(AlgoGen):
     """
     The base class for hyperparameter optimization (HPO) interfaces to generate algos in the Auto3Dseg pipeline.
@@ -143,7 +223,7 @@ class NNIGen(HPOGen):
         logger.info("=" * 140)
         logger.info("If NNI will run in your local env: ")
         logger.info("1. Add the following line to the trialCommand in your NNI config: ")
-        logger.info(f"{hint} {self.obj_filename} {{result_dir}}")
+        logger.info(f"{hint} {_quote_or_raw(self.obj_filename)} {{result_dir}}")
         logger.info("-" * 140)
         logger.info("If NNI will run in a remote env: ")
         logger.info(

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/apps/nnunet/__init__.py

@@ -12,6 +12,7 @@
 from __future__ import annotations
 
 from .nnunet_bundle import (
+    DEFAULT_NNUNET_NETWORK_MODULES,
     ModelnnUNetWrapper,
     convert_monai_bundle_to_nnunet,
     convert_nnunet_to_monai_bundle,

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/apps/nnunet/nnunet_bundle.py

@@ -12,7 +12,9 @@ from __future__ import annotations
 
 import os
 import shutil
+from collections.abc import Sequence
 from pathlib import Path
+from pydoc import locate
 from typing import Any
 
 import numpy as np
@@ -32,8 +34,60 @@ __all__ = [
     "convert_nnunet_to_monai_bundle",
     "convert_monai_bundle_to_nnunet",
     "ModelnnUNetWrapper",
+    "DEFAULT_NNUNET_NETWORK_MODULES",
 ]
 
+#: Modules that nnUNet plans may reference for the network class and its imported keyword arguments.
+DEFAULT_NNUNET_NETWORK_MODULES: tuple[str, ...] = ("dynamic_network_architectures", "torch.nn")
+
+
+def _in_allowed_modules(dotted_name: str, allowed_modules: Sequence[str]) -> bool:
+    return any(dotted_name == m or dotted_name.startswith(m + ".") for m in allowed_modules)
+
+
+def _check_nnunet_network_spec(
+    class_name: Any, init_kwargs: Any, kwargs_requiring_import: Any, allowed_modules: Sequence[str] | None = None
+) -> None:
+    """
+    Check the network specification read from an nnUNet ``plans.json`` before nnUNet resolves and builds it.
+
+    nnUNet imports ``network_class_name`` and every keyword argument listed in ``_kw_requires_import`` by dotted
+    name and calls them, so each of these names must be under one of ``allowed_modules`` and, if it can be
+    imported, must refer to a ``torch.nn.Module`` subclass. The module prefix is checked before anything is
+    imported.
+
+    Args:
+        class_name: the ``network_class_name`` from the plans.
+        init_kwargs: the ``arch_kwargs`` from the plans.
+        kwargs_requiring_import: the ``_kw_requires_import`` names from the plans.
+        allowed_modules: dotted module prefixes that may be referenced. Defaults to
+            ``DEFAULT_NNUNET_NETWORK_MODULES``. Add the module of a custom architecture here to load it.
+
+    Raises:
+        ValueError: if a name is outside ``allowed_modules`` or does not resolve to a ``torch.nn.Module`` subclass.
+    """
+    allowed = tuple(DEFAULT_NNUNET_NETWORK_MODULES if allowed_modules is None else allowed_modules)
+    hint = "Pass the module in `allowed_network_modules` if this architecture is trusted."
+
+    def _check(name: Any, what: str) -> None:
+        if not isinstance(name, str) or not _in_allowed_modules(name, allowed):
+            raise ValueError(f"Refusing to load {what} {name!r} from nnUNet plans: not in {list(allowed)}. {hint}")
+        resolved = locate(name)
+        # an unresolved name is left to nnUNet, which only searches inside dynamic_network_architectures for it
+        if resolved is not None and not (isinstance(resolved, type) and issubclass(resolved, torch.nn.Module)):
+            raise ValueError(f"Refusing to load {what} {name!r} from nnUNet plans: not a torch.nn.Module subclass.")
+
+    _check(class_name, "network class")
+    init_kwargs = init_kwargs or {}
+    if not isinstance(init_kwargs, dict):
+        raise ValueError(
+            f"Invalid network arguments in nnUNet plans: expected a dict, got {type(init_kwargs).__name__}."
+        )
+    for key in kwargs_requiring_import or ():
+        value = init_kwargs.get(key)
+        if value is not None:
+            _check(value, f"network argument {key!r}")
+
 
 def get_nnunet_trainer(
     dataset_name_or_id: str | int,
@@ -152,6 +206,9 @@ class ModelnnUNetWrapper(torch.nn.Module):
         The folder path where the model and related files are stored.
     model_name : str, optional
         The name of the model file, by default "model.pt".
+    allowed_network_modules : Sequence[str], optional
+        Module prefixes that the plans may reference for the network class and imported network arguments,
+        by default ``DEFAULT_NNUNET_NETWORK_MODULES``.
 
     Attributes
     ----------
@@ -166,7 +223,13 @@ class ModelnnUNetWrapper(torch.nn.Module):
     restoring network architecture, and setting up the predictor for inference.
     """
 
-    def __init__(self, predictor: object, model_folder: str | Path, model_name: str = "model.pt"):  # type: ignore
+    def __init__(
+        self,
+        predictor: object,
+        model_folder: str | Path,
+        model_name: str = "model.pt",
+        allowed_network_modules: Sequence[str] | None = None,
+    ):  # type: ignore
         super().__init__()
         self.predictor = predictor
 
@@ -216,6 +279,12 @@ class ModelnnUNetWrapper(torch.nn.Module):
                 f"Unable to locate trainer class {trainer_name} in nnunetv2.training.nnUNetTrainer. "
                 f"Please place it there (in any .py file)!"
             )
+        _check_nnunet_network_spec(
+            configuration_manager.network_arch_class_name,
+            configuration_manager.network_arch_init_kwargs,
+            configuration_manager.network_arch_init_kwargs_req_import,
+            allowed_network_modules,
+        )
         network = trainer_class.build_network_architecture(
             configuration_manager.network_arch_class_name,
             configuration_manager.network_arch_init_kwargs,
@@ -294,7 +363,9 @@ class ModelnnUNetWrapper(torch.nn.Module):
         return MetaTensor(out_tensor, meta=x.meta)
 
 
-def get_nnunet_monai_predictor(model_folder: str | Path, model_name: str = "model.pt") -> ModelnnUNetWrapper:
+def get_nnunet_monai_predictor(
+    model_folder: str | Path, model_name: str = "model.pt", allowed_network_modules: Sequence[str] | None = None
+) -> ModelnnUNetWrapper:
     """
     Initializes and returns a `nnUNetMONAIModelWrapper` containing the corresponding `nnUNetPredictor`.
     The model folder should contain the following files, created during training:
@@ -325,6 +396,9 @@ def get_nnunet_monai_predictor(model_folder: str | Path, model_name: str = "mode
         The folder where the model is stored.
     model_name : str, optional
         The name of the model file, by default "model.pt".
+    allowed_network_modules : Sequence[str], optional
+        Module prefixes that ``plans.json`` may reference for the network class and imported network arguments,
+        by default ``DEFAULT_NNUNET_NETWORK_MODULES``. Extend it to load a trusted custom architecture.
 
     Returns
     -------
@@ -344,7 +418,7 @@ def get_nnunet_monai_predictor(model_folder: str | Path, model_name: str = "mode
         allow_tqdm=True,
     )
     # initializes the network architecture, loads the checkpoint
-    wrapper = ModelnnUNetWrapper(predictor, model_folder, model_name)
+    wrapper = ModelnnUNetWrapper(predictor, model_folder, model_name, allowed_network_modules)
     return wrapper
 
 
@@ -428,6 +502,7 @@ def get_network_from_nnunet_plans(
     configuration: str,
     model_ckpt: str | None = None,
     model_key_in_ckpt: str = "model",
+    allowed_network_modules: Sequence[str] | None = None,
 ) -> torch.nn.Module | Any:
     """
     Load and initialize a nnUNet network based on nnUNet plans and configuration.
@@ -444,6 +519,9 @@ def get_network_from_nnunet_plans(
         Path to the model checkpoint file. If None, the network is returned without loading weights (default is None).
     model_key_in_ckpt : str, optional
         The key in the checkpoint file that contains the model state dictionary (default is "model").
+    allowed_network_modules : Sequence[str], optional
+        Module prefixes that ``plans_file`` may reference for the network class and imported network arguments,
+        by default ``DEFAULT_NNUNET_NETWORK_MODULES``. Extend it to load a trusted custom architecture.
 
     Returns
     -------
@@ -465,6 +543,12 @@ def get_network_from_nnunet_plans(
 
     enable_deep_supervision = True
 
+    _check_nnunet_network_spec(
+        configuration_manager.network_arch_class_name,
+        configuration_manager.network_arch_init_kwargs,
+        configuration_manager.network_arch_init_kwargs_req_import,
+        allowed_network_modules,
+    )
     network = get_network_from_plans(
         configuration_manager.network_arch_class_name,
         configuration_manager.network_arch_init_kwargs,

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/auto3dseg/utils.py

@@ -63,13 +63,13 @@ def _require_pickle_allowed() -> None:
         raise RuntimeError(_PICKLE_DISABLED_MSG)
 
 
-def _reject_non_algo_target(target: Any, filename: str) -> None:
+def _reject_non_algo_target(target: Any, filename: str) -> type[Algo]:
     """
     Require that ``target`` names an ``Algo`` subclass before it is instantiated.
 
-    ``algo_from_json`` resolves ``_target_`` through ``ConfigParser``, which imports the dotted path
-    and calls it. ``algo_object.json`` has exactly one legitimate target type -- an ``Algo``
-    subclass -- so resolving the name and checking it here rejects payloads such as
+    ``algo_from_json`` resolves ``_target_`` by importing the dotted path and then calls it.
+    ``algo_object.json`` has exactly one legitimate target type -- an ``Algo`` subclass -- so
+    resolving the name and checking it here rejects payloads such as
     ``subprocess.call`` or ``os.system`` before they are ever invoked.
 
     Importing the named module still runs that module's top-level code, so this narrows the sink
@@ -80,6 +80,9 @@ def _reject_non_algo_target(target: Any, filename: str) -> None:
         target: the ``_target_`` value read from the file.
         filename: the file the value came from, used in the error message.
 
+    Returns:
+        the resolved ``Algo`` subclass.
+
     Raises:
         ValueError: if ``target`` is not a string, or does not resolve to a concrete ``Algo`` subclass.
         ModuleNotFoundError: if the module cannot be imported, so callers can try the next
@@ -97,6 +100,7 @@ def _reject_non_algo_target(target: Any, filename: str) -> None:
             "may be named in a configuration "
             "(see https://github.com/Project-MONAI/MONAI/security/advisories/GHSA-2wx3-8x3w-r8qv)."
         )
+    return resolved
 
 
 measure_np, has_measure = optional_import("skimage.measure", "0.14.2", min_version)
@@ -525,15 +529,12 @@ def algo_from_json(filename: str, template_path: PathLike | None = None, **kwarg
                 sys.path.insert(0, path)
                 path_added = True
 
-            algo_config: dict[str, Any] = {"_target_": target}
-            state_template_path = state.get("template_path")
-            if state_template_path:
-                algo_config["template_path"] = state_template_path
+            algo_cls: Any = _reject_non_algo_target(target, filename)  # subclasses may accept template_path
 
-            _reject_non_algo_target(target, filename)
-
-            parser = ConfigParser(algo_config)
-            algo = parser.get_parsed_content()
+            # Values read from the file are plain data: pass them to the constructor as literals
+            # rather than through ConfigParser, which would evaluate "$"/"@"/"%" prefixed strings.
+            state_template_path = state.get("template_path")
+            algo = algo_cls(template_path=state_template_path) if state_template_path else algo_cls()
             if not isinstance(algo, Algo):
                 raise ValueError(
                     f"refusing to return the object built from '{target}' in {filename}: it is a "

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/metrics/meandice.py

@@ -331,16 +331,23 @@ class DiceHelper:
         self.per_component = per_component
         self.ignore_index = ignore_index
 
-    def compute_cc_dice(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+    def compute_cc_dice(self, y_pred: torch.Tensor, y: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
         """
         Compute per-component Dice for a single batch item.
 
         Args:
             y_pred (torch.Tensor): Predictions with shape (1, 2, D, H, W) or (1, 2, H, W).
             y (torch.Tensor): Ground truth with shape (1, 2, D, H, W) or (1, 2, H, W).
+            mask (torch.Tensor, optional): spatial mask (1, D, H, W) or (1, H, W) from
+                ``create_ignore_mask``, 1=valid, 0=ignore. Ignored voxels are forced to
+                agree as background in both `y` and `y_pred`, so they never contribute to
+                a component's TP/FP/FN, matching how `ignore_index` is handled elsewhere.
 
         Returns:
             torch.Tensor: Mean Dice over connected components.
+        Raises:
+            OptionalImportError: If the ground truth contains foreground voxels
+                after masking, is on the CPU, and SciPy is unavailable.
         """
         if y_pred.ndim == y.ndim:
             y_pred_idx = torch.argmax(y_pred, dim=1)
@@ -348,6 +355,10 @@ class DiceHelper:
         else:
             y_pred_idx = y_pred
             y_idx = y
+        if mask is not None:
+            ignore = mask == 0
+            y_idx = y_idx.masked_fill(ignore, 0)
+            y_pred_idx = y_pred_idx.masked_fill(ignore, 0)
         if y_idx[0].sum() == 0:
             if self.ignore_empty:
                 data = torch.tensor(float("nan"), device=y_idx.device)
@@ -445,7 +456,10 @@ class DiceHelper:
         data = []
         for b in range(y_pred.shape[0]):
             if self.per_component:
-                data.append(self.compute_cc_dice(y_pred=y_pred[b].unsqueeze(0), y=y[b].unsqueeze(0)).reshape(-1))
+                b_mask = mask[b, 0] if mask is not None else None
+                data.append(
+                    self.compute_cc_dice(y_pred=y_pred[b].unsqueeze(0), y=y[b].unsqueeze(0), mask=b_mask).reshape(-1)
+                )
                 continue
             c_list = []
             for c in range(first_ch, n_pred_ch) if n_pred_ch > 1 else [1]:

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/networks/layers/__init__.py

@@ -17,6 +17,7 @@ from .drop_path import DropPath
 from .factories import Act, Conv, Dropout, LayerFactory, Norm, Pad, Pool, RelPosEmbedding, split_args
 from .filtering import BilateralFilter, PHLFilter, TrainableBilateralFilter, TrainableJointBilateralFilter
 from .gmm import GaussianMixtureModel
+from .layer_norm_nd import LayerNormNd
 from .simplelayers import (
     LLTM,
     ApplyFilter,

monai_weekly-1.7.dev2645/monai/networks/layers/layer_norm_nd.py

@@ -0,0 +1,58 @@
+# 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.
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+
+class LayerNormNd(nn.Module):
+    """
+    Layer normalization over the channel dimension of a channels-first tensor.
+
+    `torch.nn.LayerNorm` normalizes over the trailing dimensions, so it expects a channels-last layout
+    such as ``(batch, *spatial, channel)``. Convolutional feature maps in MONAI are channels-first,
+    ``(batch, channel, *spatial)``, and this module normalizes those over the channel dimension only,
+    for any number of spatial dimensions.
+
+    Args:
+        num_channels: number of channels of the input, i.e. the size of dimension 1.
+        spatial_dims: number of spatial dimensions of the input image.
+        eps: value added to the denominator for numerical stability.
+
+    Raises:
+        ValueError: if ``num_channels`` is not positive, or ``spatial_dims`` is negative.
+    """
+
+    def __init__(self, num_channels: int, spatial_dims: int, eps: float = 1e-6) -> None:
+        super().__init__()
+        if num_channels <= 0:
+            raise ValueError(f"num_channels must be positive, got {num_channels}.")
+        if spatial_dims < 0:
+            raise ValueError(f"spatial_dims must be non-negative, got {spatial_dims}.")
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(num_channels))
+        self.bias = nn.Parameter(torch.zeros(num_channels))
+        # broadcast the affine parameters against (batch, channel, *spatial); precomputed so that the
+        # module is scriptable without inspecting the rank of the input at runtime.
+        self.param_shape = [1, num_channels] + [1] * spatial_dims
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        mean = x.mean(dim=1, keepdim=True)
+        xmean = x - mean
+        var = xmean.pow(2).mean(dim=1, keepdim=True)
+        # `var` and the sqrt result are intermediates used nowhere else, so mutating them in place is
+        # safe; `xmean` must stay untouched since its pre-division value is what `pow(2)`'s backward
+        # needs, so the final division is deliberately out-of-place.
+        denom = var.add_(self.eps).sqrt_()
+        x = xmean / denom
+        return self.weight.view(self.param_shape).mul(x).add_(self.bias.view(self.param_shape))

{monai_weekly-1.7.dev2643 → monai_weekly-1.7.dev2645}/monai/networks/nets/__init__.py

@@ -19,6 +19,25 @@ from .basic_unet import BasicUNet, BasicUnet, Basicunet, basicunet
 from .basic_unetplusplus import BasicUNetPlusPlus, BasicUnetPlusPlus, BasicunetPlusPlus, basicunetplusplus
 from .classifier import Classifier, Critic, Discriminator
 from .controlnet import ControlNet
+from .convnext import (
+    ConvNeXt,
+    Convnext,
+    Convnext_base,
+    Convnext_large,
+    Convnext_small,
+    Convnext_tiny,
+    Convnext_xlarge,
+    ConvNeXtBase,
+    ConvNeXtLarge,
+    ConvNeXtSmall,
+    ConvNeXtTiny,
+    ConvNeXtXLarge,
+    convnext_base,
+    convnext_large,
+    convnext_small,
+    convnext_tiny,
+    convnext_xlarge,
+)
 from .daf3d import DAF3D
 from .densenet import (
     DenseNet,