monai-weekly 1.7.dev2638__tar.gz → 1.7.dev2640__tar.gz

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/PKG-INFO

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

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/__init__.py

@@ -136,4 +136,4 @@ except Exception:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "f2ec87ae9b536baaeca1d6bcc2b6349369e2af8f"
+__commit_id__ = "b229330ff12ea9a60b52f6ebfed256331aec71e0"

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-09-20T02:14:58+0000",
+ "date": "2026-10-04T02:49:09+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "43b604323beaeca5718d23b2ba4c130da08d84b8",
- "version": "1.7.dev2638"
+ "full-revisionid": "e06f55fca00aba1d14a62c329e1f16d77b871297",
+ "version": "1.7.dev2640"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/apps/auto3dseg/bundle_gen.py

@@ -491,7 +491,7 @@ class BundleGen(AlgoGen):
         mlflow_tracking_uri: a tracking URI for MLflow server which could be local directory or address of
             the remote tracking Server; MLflow runs will be recorded locally in algorithms' model folder if
             the value is None.
-        mlfow_experiment_name: a string to specify the experiment name for MLflow server.
+        mlflow_experiment_name: a string to specify the experiment name for MLflow server.
     .. code-block:: bash
 
         python -m monai.apps.auto3dseg BundleGen generate --data_stats_filename="../algorithms/datastats.yaml"

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/apps/detection/metrics/matching.py

@@ -193,7 +193,7 @@ def _matching_no_gt(
 
     Args:
         iou_thresholds: defined which IoU thresholds should be evaluated
-        dt_scores: predicted scores
+        pred_scores: predicted scores
         max_detections: maximum number of allowed detections per image.
             This functions uses this parameter to stay consistent with
             the actual matching function which needs this limit.

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/apps/detection/transforms/dictionary.py

@@ -37,7 +37,6 @@ from monai.apps.detection.transforms.array import (
     StandardizeEmptyBox,
     ZoomBox,
 )
-from monai.apps.detection.transforms.box_ops import convert_box_to_mask
 from monai.config import KeysCollection, SequenceStr
 from monai.config.type_definitions import DtypeLike, NdarrayOrTensor
 from monai.data.box_utils import COMPUTE_DTYPE, BoxMode, clip_boxes_to_image
@@ -1154,10 +1153,13 @@ class RandCropBoxByPosNegLabeld(Randomizable, MapTransform):
             # As along as the cropped patch contains a box, it is considered as a foreground patch.
             # Positions within extended_boxes are crop centers for foreground patches
             extended_boxes_np = self.generate_fg_center_boxes_np(boxes, image_size)
-            mask_img = convert_box_to_mask(
-                extended_boxes_np, np.ones(extended_boxes_np.shape[0]), image_size, bg_label=0, ellipse_mask=False
-            )
-            mask_img = np.amax(mask_img, axis=0, keepdims=True)[0:1, ...]
+            spatial_dims = len(image_size)
+            mask_img = np.zeros((1,) + tuple(image_size), dtype=np.int16)
+            for b in range(extended_boxes_np.shape[0]):
+                slicing = (0,) + tuple(
+                    slice(extended_boxes_np[b, d], extended_boxes_np[b, d + spatial_dims]) for d in range(spatial_dims)
+                )
+                mask_img[slicing] = 1
             fg_indices_, bg_indices_ = map_binary_to_indices(mask_img, thresh_image, self.image_threshold)
         else:
             fg_indices_ = fg_indices

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/apps/pathology/transforms/post/dictionary.py

@@ -536,7 +536,7 @@ class HoVerNetInstanceMapPostProcessingd(Transform):
 
         for k in [self.instance_info_key, self.instance_map_key]:
             if k in d:
-                raise ValueError("The output key ['{k}'] already exists in the input dictionary!")
+                raise ValueError(f"The output key ['{k}'] already exists in the input dictionary!")
 
         d[self.instance_info_key], d[self.instance_map_key] = self.instance_map_post_process(
             d[self.nuclear_prediction_key], d[self.hover_map_key]
@@ -590,7 +590,7 @@ class HoVerNetNuclearTypePostProcessingd(Transform):
         )
         if self.return_type_map:
             if self.type_map_key in d:
-                raise ValueError("The output key ['{self.type_map_key}'] already exists in the input dictionary!")
+                raise ValueError(f"The output key ['{self.type_map_key}'] already exists in the input dictionary!")
             d[self.type_map_key] = type_map
 
         return d

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/data/dataset_summary.py

@@ -159,6 +159,8 @@ class DatasetSummary:
             label, *_ = convert_data_type(data=label, output_type=torch.Tensor)
 
             image_foreground = image[torch.where(label > foreground_threshold)]
+            if image_foreground.numel() == 0:
+                continue
 
             voxel_max.append(image_foreground.max().item())
             voxel_min.append(image_foreground.min().item())
@@ -166,6 +168,11 @@ class DatasetSummary:
             voxel_sum += image_foreground.sum()
             voxel_square_sum += torch.square(image_foreground).sum()
 
+        if voxel_ct == 0:
+            raise ValueError(
+                f"No foreground voxels found in any sample with {foreground_threshold=}; "
+                "set foreground_threshold=-1 to compute statistics over whole images."
+            )
         self.data_max, self.data_min = max(voxel_max), min(voxel_min)
         self.data_mean = (voxel_sum / voxel_ct).item()
         self.data_std = (torch.sqrt(voxel_square_sum / voxel_ct - self.data_mean**2)).item()
@@ -204,11 +211,17 @@ class DatasetSummary:
             label, *_ = convert_data_type(data=label, output_type=torch.Tensor)
 
             intensities = image[torch.where(label > foreground_threshold)].tolist()
-            if sampling_flag:
-                intensities = intensities[::interval]
-            all_intensities.append(intensities)
+            if intensities:
+                if sampling_flag:
+                    intensities = intensities[::interval]
+                all_intensities.append(intensities)
 
         all_intensities = list(chain(*all_intensities))
+        if not all_intensities:
+            raise ValueError(
+                f"No foreground voxels found in any sample with {foreground_threshold=}; "
+                "set foreground_threshold=-1 to compute statistics over whole images."
+            )
         self.data_min_percentile, self.data_max_percentile = np.percentile(
             all_intensities, [min_percentile, max_percentile]
         )

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/data/image_writer.py

@@ -266,12 +266,13 @@ class ImageWriter:
                 The output data type of this method is always ``np.float32``.
         """
         orig_type = type(data_array)
-        data_array = convert_to_tensor(data_array, track_meta=True)
+        # Add the channel dimension before setting the affine so spatial_ndim is inferred correctly.
+        data_array = convert_to_tensor(data_array, track_meta=True)[None]
         if affine is not None:
             data_array.affine = convert_to_tensor(affine, track_meta=False)  # type: ignore
         resampler = SpatialResample(mode=mode, padding_mode=padding_mode, align_corners=align_corners, dtype=dtype)
         output_array = resampler(
-            data_array[None], dst_affine=target_affine, spatial_size=output_spatial_shape  # type: ignore
+            data_array, dst_affine=target_affine, spatial_size=output_spatial_shape  # type: ignore
         )
         # convert back at the end
         if isinstance(output_array, MetaTensor):

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/data/synthetic.py

@@ -133,7 +133,7 @@ def create_test_image_3d(
     if rad_max <= rad_min:
         raise ValueError(f"`rad_min` {rad_min} should be less than `rad_max` {rad_max}.")
     if rad_min < 1:
-        raise ValueError("f`rad_min` {rad_min} should be no less than 1.")
+        raise ValueError(f"`rad_min` {rad_min} should be no less than 1.")
     min_size = min(height, width, depth)
     if min_size <= 2 * rad_max:
         raise ValueError(f"the minimal size {min_size} of the image should be larger than `2 * rad_max` 2x{rad_max}.")

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/inferers/inferer.py

@@ -11,6 +11,7 @@
 
 from __future__ import annotations
 
+import inspect
 import math
 import warnings
 from abc import ABC, abstractmethod
@@ -862,6 +863,96 @@ class DiffusionInferer(Inferer):
 
         self.scheduler = scheduler
 
+    @staticmethod
+    def _scheduler_step_supports_kwarg(scheduler: Scheduler, kwarg: str) -> bool:
+        try:
+            return kwarg in inspect.signature(scheduler.step).parameters
+        except (TypeError, ValueError):
+            return False
+
+    @staticmethod
+    def _get_previous_sample_from_step_output(step_output: Any) -> torch.Tensor:
+        if isinstance(step_output, tuple):
+            return step_output[0]
+        if isinstance(step_output, Mapping):
+            return step_output["prev_sample"]
+        if hasattr(step_output, "prev_sample"):
+            return step_output.prev_sample
+        raise TypeError("Unsupported scheduler.step output. Expected a tuple or an object with `prev_sample`.")
+
+    @staticmethod
+    def _get_scheduler_name(scheduler: Scheduler) -> str:
+        if hasattr(scheduler, "_get_name"):
+            return scheduler._get_name()
+        return scheduler.__class__.__name__
+
+    @staticmethod
+    def _get_scheduler_config_value(scheduler: Scheduler, name: str, default: Any = None) -> Any:
+        config = getattr(scheduler, "config", None)
+        if isinstance(config, Mapping):
+            if name in config:
+                return config[name]
+        elif config is not None and hasattr(config, name):
+            return getattr(config, name)
+
+        if hasattr(scheduler, name):
+            return getattr(scheduler, name)
+        return default
+
+    @staticmethod
+    def _get_posterior_mean(
+        scheduler: Scheduler, timestep: int | torch.Tensor, x_0: torch.Tensor, x_t: torch.Tensor
+    ) -> torch.Tensor:
+        alpha_t = scheduler.alphas[timestep]
+        alpha_prod_t = scheduler.alphas_cumprod[timestep]
+        alpha_prod_t_prev = scheduler.alphas_cumprod[timestep - 1] if timestep > 0 else scheduler.one
+
+        x_0_coefficient = alpha_prod_t_prev.sqrt() * scheduler.betas[timestep] / (1 - alpha_prod_t)
+        x_t_coefficient = alpha_t.sqrt() * (1 - alpha_prod_t_prev) / (1 - alpha_prod_t)
+
+        return x_0_coefficient * x_0 + x_t_coefficient * x_t
+
+    def _get_posterior_variance(
+        self, scheduler: Scheduler, timestep: int | torch.Tensor, predicted_variance: torch.Tensor | None = None
+    ) -> torch.Tensor:
+        alpha_prod_t = scheduler.alphas_cumprod[timestep]
+        alpha_prod_t_prev = scheduler.alphas_cumprod[timestep - 1] if timestep > 0 else scheduler.one
+        variance = (1 - alpha_prod_t_prev) / (1 - alpha_prod_t) * scheduler.betas[timestep]
+        variance_type = self._get_scheduler_config_value(scheduler, "variance_type")
+
+        if variance_type == "fixed_small":
+            variance = torch.clamp(variance, min=1e-20)
+        elif variance_type == "fixed_large":
+            variance = scheduler.betas[timestep]
+        elif variance_type == "learned" and predicted_variance is not None:
+            return predicted_variance
+        elif variance_type == "learned_range" and predicted_variance is not None:
+            min_log = variance
+            max_log = scheduler.betas[timestep]
+            frac = (predicted_variance + 1) / 2
+            variance = frac * max_log + (1 - frac) * min_log
+
+        return variance
+
+    def _scheduler_step(
+        self,
+        scheduler: Scheduler,
+        model_output: torch.Tensor,
+        timestep: int | torch.Tensor,
+        sample: torch.Tensor,
+        next_timestep: int | torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        step_kwargs = {}
+        if self._scheduler_step_supports_kwarg(scheduler, "return_dict"):
+            step_kwargs["return_dict"] = False
+
+        if isinstance(scheduler, RFlowScheduler):
+            step_output = scheduler.step(model_output, timestep, sample, next_timestep, **step_kwargs)  # type: ignore
+        else:
+            step_output = scheduler.step(model_output, timestep, sample, **step_kwargs)  # type: ignore
+
+        return self._get_previous_sample_from_step_output(step_output)
+
     def __call__(  # type: ignore[override]
         self,
         inputs: torch.Tensor,
@@ -941,7 +1032,12 @@ class DiffusionInferer(Inferer):
             scheduler = self.scheduler
         image = input_noise
 
-        all_next_timesteps = torch.cat((scheduler.timesteps[1:], torch.tensor([0], dtype=scheduler.timesteps.dtype)))
+        all_next_timesteps = torch.cat(
+            (
+                scheduler.timesteps[1:],
+                torch.tensor([0], dtype=scheduler.timesteps.dtype, device=scheduler.timesteps.device),
+            )
+        )
         if verbose and has_tqdm:
             progress_bar = tqdm(
                 zip(scheduler.timesteps, all_next_timesteps),
@@ -985,10 +1081,9 @@ class DiffusionInferer(Inferer):
                 model_output = model_output_uncond + cfg * (model_output_cond - model_output_uncond)
 
             # 2. compute previous image: x_t -> x_t-1
-            if not isinstance(scheduler, RFlowScheduler):
-                image, _ = scheduler.step(model_output, t, image)  # type: ignore
-            else:
-                image, _ = scheduler.step(model_output, t, image, next_t)  # type: ignore
+            image = self._scheduler_step(
+                scheduler=scheduler, model_output=model_output, timestep=t, sample=image, next_timestep=next_t
+            )
             if save_intermediates and t % intermediate_steps == 0:
                 intermediates.append(image)
 
@@ -1029,10 +1124,10 @@ class DiffusionInferer(Inferer):
 
         if not scheduler:
             scheduler = self.scheduler
-        if scheduler._get_name() != "DDPMScheduler":
+        scheduler_name = self._get_scheduler_name(scheduler)
+        if scheduler_name != "DDPMScheduler":
             raise NotImplementedError(
-                f"Likelihood computation is only compatible with DDPMScheduler,"
-                f" you are using {scheduler._get_name()}"
+                f"Likelihood computation is only compatible with DDPMScheduler, you are using {scheduler_name},"
             )
         if mode not in ["crossattn", "concat"]:
             raise NotImplementedError(f"{mode} condition is not supported")
@@ -1047,7 +1142,7 @@ class DiffusionInferer(Inferer):
         total_kl = torch.zeros(inputs.shape[0]).to(inputs.device)
         for t in progress_bar:
             timesteps = torch.full(inputs.shape[:1], t, device=inputs.device).long()
-            noisy_image = self.scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
+            noisy_image = scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
             diffusion_model = (
                 partial(diffusion_model, seg=seg)
                 if isinstance(diffusion_model, SPADEDiffusionModelUNet)
@@ -1060,7 +1155,8 @@ class DiffusionInferer(Inferer):
                 model_output = diffusion_model(x=noisy_image, timesteps=timesteps, context=conditioning)
 
             # get the model's predicted mean,  and variance if it is predicted
-            if model_output.shape[1] == inputs.shape[1] * 2 and scheduler.variance_type in ["learned", "learned_range"]:
+            variance_type = self._get_scheduler_config_value(scheduler, "variance_type")
+            if model_output.shape[1] == inputs.shape[1] * 2 and variance_type in ["learned", "learned_range"]:
                 model_output, predicted_variance = torch.split(model_output, inputs.shape[1], dim=1)
             else:
                 predicted_variance = None
@@ -1073,15 +1169,17 @@ class DiffusionInferer(Inferer):
 
             # 2. compute predicted original sample from predicted noise also called
             # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf
-            if scheduler.prediction_type == "epsilon":
+            prediction_type = self._get_scheduler_config_value(scheduler, "prediction_type")
+            if prediction_type == "epsilon":
                 pred_original_sample = (noisy_image - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
-            elif scheduler.prediction_type == "sample":
+            elif prediction_type == "sample":
                 pred_original_sample = model_output
-            elif scheduler.prediction_type == "v_prediction":
+            elif prediction_type == "v_prediction":
                 pred_original_sample = (alpha_prod_t**0.5) * noisy_image - (beta_prod_t**0.5) * model_output
             # 3. Clip "predicted x_0"
-            if scheduler.clip_sample:
-                pred_original_sample = torch.clamp(pred_original_sample, -1, 1)
+            if self._get_scheduler_config_value(scheduler, "clip_sample"):
+                clip_sample_range = self._get_scheduler_config_value(scheduler, "clip_sample_range", 1.0)
+                pred_original_sample = torch.clamp(pred_original_sample, -clip_sample_range, clip_sample_range)
 
             # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t
             # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
@@ -1093,11 +1191,15 @@ class DiffusionInferer(Inferer):
             predicted_mean = pred_original_sample_coeff * pred_original_sample + current_sample_coeff * noisy_image
 
             # get the posterior mean and variance
-            posterior_mean = scheduler._get_mean(timestep=t, x_0=inputs, x_t=noisy_image)  # type: ignore[operator]
-            posterior_variance = scheduler._get_variance(timestep=t, predicted_variance=predicted_variance)  # type: ignore[operator]
+            posterior_mean = self._get_posterior_mean(scheduler=scheduler, timestep=t, x_0=inputs, x_t=noisy_image)
+            posterior_variance = self._get_posterior_variance(
+                scheduler=scheduler, timestep=t, predicted_variance=predicted_variance
+            )
 
             log_posterior_variance = torch.log(posterior_variance)
-            log_predicted_variance = torch.log(predicted_variance) if predicted_variance else log_posterior_variance
+            log_predicted_variance = (
+                torch.log(predicted_variance) if predicted_variance is not None else log_posterior_variance
+            )
 
             if t == 0:
                 # compute -log p(x_0|x_1)
@@ -1149,7 +1251,7 @@ class DiffusionInferer(Inferer):
         given image. Code adapted from https://github.com/openai/improved-diffusion.
 
         Args:
-            input: the target images. It is assumed that this was uint8 values,
+            inputs: the target images. It is assumed that this was uint8 values,
                       rescaled to the range [-1, 1].
             means: the Gaussian mean Tensor.
             log_scales: the Gaussian log stddev Tensor.
@@ -1510,7 +1612,12 @@ class ControlNetDiffusionInferer(DiffusionInferer):
             scheduler = self.scheduler
         image = input_noise
 
-        all_next_timesteps = torch.cat((scheduler.timesteps[1:], torch.tensor([0], dtype=scheduler.timesteps.dtype)))
+        all_next_timesteps = torch.cat(
+            (
+                scheduler.timesteps[1:],
+                torch.tensor([0], dtype=scheduler.timesteps.dtype, device=scheduler.timesteps.device),
+            )
+        )
         if verbose and has_tqdm:
             progress_bar = tqdm(
                 zip(scheduler.timesteps, all_next_timesteps),
@@ -1584,10 +1691,9 @@ class ControlNetDiffusionInferer(DiffusionInferer):
                 model_output = model_output_uncond + cfg * (model_output_cond - model_output_uncond)
 
             # 3. compute previous image: x_t -> x_t-1
-            if not isinstance(scheduler, RFlowScheduler):
-                image, _ = scheduler.step(model_output, t, image)  # type: ignore
-            else:
-                image, _ = scheduler.step(model_output, t, image, next_t)  # type: ignore
+            image = self._scheduler_step(
+                scheduler=scheduler, model_output=model_output, timestep=t, sample=image, next_timestep=next_t
+            )
 
             if save_intermediates and t % intermediate_steps == 0:
                 intermediates.append(image)
@@ -1632,10 +1738,10 @@ class ControlNetDiffusionInferer(DiffusionInferer):
 
         if not scheduler:
             scheduler = self.scheduler
-        if scheduler._get_name() != "DDPMScheduler":
+        scheduler_name = self._get_scheduler_name(scheduler)
+        if scheduler_name != "DDPMScheduler":
             raise NotImplementedError(
-                f"Likelihood computation is only compatible with DDPMScheduler,"
-                f" you are using {scheduler._get_name()}"
+                f"Likelihood computation is only compatible with DDPMScheduler, you are using {scheduler_name}."
             )
         if mode not in ["crossattn", "concat"]:
             raise NotImplementedError(f"{mode} condition is not supported")
@@ -1648,7 +1754,7 @@ class ControlNetDiffusionInferer(DiffusionInferer):
         total_kl = torch.zeros(inputs.shape[0]).to(inputs.device)
         for t in progress_bar:
             timesteps = torch.full(inputs.shape[:1], t, device=inputs.device).long()
-            noisy_image = self.scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
+            noisy_image = scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
 
             diffuse = diffusion_model
             if isinstance(diffusion_model, SPADEDiffusionModelUNet):
@@ -1681,7 +1787,8 @@ class ControlNetDiffusionInferer(DiffusionInferer):
                     mid_block_additional_residual=mid_block_res_sample,
                 )
             # get the model's predicted mean,  and variance if it is predicted
-            if model_output.shape[1] == inputs.shape[1] * 2 and scheduler.variance_type in ["learned", "learned_range"]:
+            variance_type = self._get_scheduler_config_value(scheduler, "variance_type")
+            if model_output.shape[1] == inputs.shape[1] * 2 and variance_type in ["learned", "learned_range"]:
                 model_output, predicted_variance = torch.split(model_output, inputs.shape[1], dim=1)
             else:
                 predicted_variance = None
@@ -1694,15 +1801,17 @@ class ControlNetDiffusionInferer(DiffusionInferer):
 
             # 2. compute predicted original sample from predicted noise also called
             # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf
-            if scheduler.prediction_type == "epsilon":
+            prediction_type = self._get_scheduler_config_value(scheduler, "prediction_type")
+            if prediction_type == "epsilon":
                 pred_original_sample = (noisy_image - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
-            elif scheduler.prediction_type == "sample":
+            elif prediction_type == "sample":
                 pred_original_sample = model_output
-            elif scheduler.prediction_type == "v_prediction":
+            elif prediction_type == "v_prediction":
                 pred_original_sample = (alpha_prod_t**0.5) * noisy_image - (beta_prod_t**0.5) * model_output
             # 3. Clip "predicted x_0"
-            if scheduler.clip_sample:
-                pred_original_sample = torch.clamp(pred_original_sample, -1, 1)
+            if self._get_scheduler_config_value(scheduler, "clip_sample"):
+                clip_sample_range = self._get_scheduler_config_value(scheduler, "clip_sample_range", 1.0)
+                pred_original_sample = torch.clamp(pred_original_sample, -clip_sample_range, clip_sample_range)
 
             # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t
             # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
@@ -1714,11 +1823,15 @@ class ControlNetDiffusionInferer(DiffusionInferer):
             predicted_mean = pred_original_sample_coeff * pred_original_sample + current_sample_coeff * noisy_image
 
             # get the posterior mean and variance
-            posterior_mean = scheduler._get_mean(timestep=t, x_0=inputs, x_t=noisy_image)  # type: ignore[operator]
-            posterior_variance = scheduler._get_variance(timestep=t, predicted_variance=predicted_variance)  # type: ignore[operator]
+            posterior_mean = self._get_posterior_mean(scheduler=scheduler, timestep=t, x_0=inputs, x_t=noisy_image)
+            posterior_variance = self._get_posterior_variance(
+                scheduler=scheduler, timestep=t, predicted_variance=predicted_variance
+            )
 
             log_posterior_variance = torch.log(posterior_variance)
-            log_predicted_variance = torch.log(predicted_variance) if predicted_variance else log_posterior_variance
+            log_predicted_variance = (
+                torch.log(predicted_variance) if predicted_variance is not None else log_posterior_variance
+            )
 
             if t == 0:
                 # compute -log p(x_0|x_1)
@@ -1874,8 +1987,8 @@ class ControlNetLatentDiffusionInferer(ControlNetDiffusionInferer):
             and autoencoder_model.decoder.label_nc != diffusion_model.label_nc
         ):
             raise ValueError(
-                "If both autoencoder_model and diffusion_model implement SPADE, the number of semantic"
-                "labels for each must be compatible. Got {autoencoder_model.decoder.label_nc} and {diffusion_model.label_nc}"
+                "If both autoencoder_model and diffusion_model implement SPADE, the number of semantic "
+                f"labels for each must be compatible. Got {autoencoder_model.decoder.label_nc} and {diffusion_model.label_nc}"
             )
 
         if cn_cond.shape[2:] != input_noise.shape[2:]:

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/losses/barlow_twins.py

@@ -78,7 +78,7 @@ class BarlowTwinsLoss(_Loss):
         c = torch.mm(input_norm.t(), target_norm) / batch_size  # input_norm.t() is FxB, target_norm is BxF so c is FxF
 
         # loss
-        c_diff = (c - torch.eye(c.size(0), device=c.device)).pow_(2)  # FxF
+        c_diff = (c - torch.eye(c.size(0), dtype=c.dtype, device=c.device)).pow_(2)  # FxF
         c_diff[~torch.eye(c.size(0), device=c.device).bool()] *= lambd_tensor
 
         return c_diff.sum()

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/metrics/utils.py

@@ -12,7 +12,7 @@
 from __future__ import annotations
 
 import warnings
-from collections.abc import Iterable, Sequence
+from collections.abc import Sequence
 from functools import cache, partial
 from types import ModuleType
 from typing import Any, overload
@@ -515,23 +515,22 @@ def remap_instance_id(pred: torch.Tensor, by_size: bool = False) -> torch.Tensor
             value of the tensor should be an integer, and represents the prediction of its corresponding instance id.
         by_size: if True, largest instance will be assigned a smaller id.
 
+    Returns:
+        tensor of the same shape as ``pred`` with ids remapped to ``1..K`` (``torch.int`` dtype),
+        or ``pred`` unchanged (original dtype) when it contains no foreground ids.
     """
-    pred_id: Iterable[Any] = list(pred.unique())
-    # the original implementation has the limitation that if there is no 0 in pred, error will happen
-    pred_id = [i for i in pred_id if i != 0]
-
-    if not pred_id:
+    uniq, inverse = torch.unique(pred, return_inverse=True)
+    order = torch.nonzero(uniq != 0).flatten()
+    if order.numel() == 0:
         return pred
     if by_size:
-        instance_size = [(pred == instance_id).sum() for instance_id in pred_id]
-        pair_data = zip(pred_id, instance_size)
-        pair_list = sorted(pair_data, key=lambda x: x[1], reverse=True)
-        pred_id, _ = zip(*pair_list)
-
-    new_pred = torch.zeros_like(pred, dtype=torch.int)
-    for idx, instance_id in enumerate(pred_id):
-        new_pred[pred == instance_id] = idx + 1
-    return new_pred
+        counts = torch.bincount(inverse.flatten(), minlength=uniq.numel())[order]
+        # stable sort keeps ascending-id order for equal-size instances, matching the
+        # original python `sorted` tie-breaking
+        order = order[torch.argsort(counts, descending=True, stable=True)]
+    lut = torch.zeros(uniq.numel(), dtype=torch.int, device=pred.device)
+    lut[order] = torch.arange(1, order.numel() + 1, dtype=torch.int, device=pred.device)
+    return lut[inverse]
 
 
 def prepare_spacing(

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/networks/blocks/pos_embed_utils.py

@@ -150,7 +150,7 @@ def build_sincos_position_embedding(
             dim=1,
         )[None, :, :]
     else:
-        raise NotImplementedError("Spatial Dimension Size {spatial_dims} Not Implemented!")
+        raise NotImplementedError(f"Spatial Dimension Size {spatial_dims} Not Implemented!")
 
     pos_embed = nn.Parameter(pos_emb)
     pos_embed.requires_grad = False

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/networks/nets/patchgan_discriminator.py

@@ -126,7 +126,7 @@ class PatchDiscriminator(nn.Sequential):
         out_channels: number of output channels
         num_layers_d: number of Convolution layers (Conv + activation + normalisation + [dropout]) in the discriminator.
         kernel_size: kernel size of the convolution layers
-        act: activation type and arguments. Defaults to LeakyReLU.
+        activation: activation type and arguments. Defaults to LeakyReLU.
         norm: feature normalization type and arguments. Defaults to batch norm.
         bias: whether to have a bias term in convolution blocks. Defaults to False.
         padding: padding to be applied to the convolutional layers

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2640}/monai/networks/schedulers/ddpm.py

@@ -131,7 +131,7 @@ class DDPMScheduler(Scheduler):
 
         Args:
             timestep: current timestep.
-            x0: the noise-free input.
+            x_0: the noise-free input.
             x_t: the input noised to timestep t.
 
         Returns: