fix(losses): register buffers in GlobalMutualInformationLoss

When kernel_type="gaussian", `preterm` and `bin_centers` were stored
as plain tensor attributes via simple assignment. This means they are
not registered in PyTorch's module buffer system, so calling
`loss.to("cuda")` or `loss.cuda()` does not move these tensors to the
target device. Each forward pass had to call `.to(img)` to patch the
device mismatch at runtime, which is both redundant and misleading.

Use `register_buffer(..., persistent=False)` so that both tensors are
properly tracked by the module and automatically move with `.to()` /
`.cuda()` / `.cpu()` calls, consistent with the pattern already used
by `LocalNormalizedCrossCorrelationLoss`.

The `.to(img)` calls in `parzen_windowing_gaussian` are retained for
dtype coercion (e.g. float16 inference).

Adds `TestGlobalMutualInformationLossBuffers` to verify buffer
registration and that b-spline mode does not create gaussian buffers.

Closes #8819

Signed-off-by: Oleksandr Sanin <alexaaander.sanin@gmail.com>

Author: AlexanderSanin

monai/losses/image_dissimilarity.py

@@ -233,9 +233,11 @@ def __init__(
         self.kernel_type = look_up_option(kernel_type, ["gaussian", "b-spline"])
         self.num_bins = num_bins
         self.kernel_type = kernel_type
+        self.preterm: torch.Tensor
+        self.bin_centers: torch.Tensor
         if self.kernel_type == "gaussian":
-            self.preterm = 1 / (2 * sigma**2)
-            self.bin_centers = bin_centers[None, None, ...]
+            self.register_buffer("preterm", 1 / (2 * sigma**2), persistent=False)
+            self.register_buffer("bin_centers", bin_centers[None, None, ...], persistent=False)
         self.smooth_nr = float(smooth_nr)
         self.smooth_dr = float(smooth_dr)
 

tests/losses/image_dissimilarity/test_global_mutual_information_loss.py

@@ -145,5 +145,28 @@ def test_ill_opts(self, num_bins, reduction, expected_exception, expected_messag
             GlobalMutualInformationLoss(num_bins=num_bins, reduction=reduction)(pred, target)
 
 
+class TestGlobalMutualInformationLossBuffers(unittest.TestCase):
+    def test_gaussian_kernel_registers_buffers(self):
+        loss = GlobalMutualInformationLoss(kernel_type="gaussian")
+        # preterm and bin_centers must be registered buffers so .to() moves them
+        self.assertIn("preterm", loss._buffers)
+        self.assertIn("bin_centers", loss._buffers)
+        self.assertFalse(loss.preterm.requires_grad)
+        self.assertFalse(loss.bin_centers.requires_grad)
+        self.assertEqual(loss.bin_centers.ndim, 3)
+
+    def test_bspline_kernel_has_no_gaussian_buffers(self):
+        loss = GlobalMutualInformationLoss(kernel_type="b-spline")
+        self.assertNotIn("preterm", loss._buffers)
+        self.assertNotIn("bin_centers", loss._buffers)
+
+    def test_gaussian_kernel_forward_correct(self):
+        pred = torch.rand(2, 1, 8, 8, dtype=torch.float32)
+        target = torch.rand(2, 1, 8, 8, dtype=torch.float32)
+        loss = GlobalMutualInformationLoss(kernel_type="gaussian")
+        result = loss(pred, target)
+        self.assertEqual(result.shape, torch.Size([]))
+
+
 if __name__ == "__main__":
     unittest.main()