fix activation order and inheritance

Signed-off-by: ytl0623 <david89062388@gmail.com>

Author: ytl0623

monai/losses/dice.py

@@ -239,27 +239,53 @@ class MaskedDiceLoss(DiceLoss):
 
     """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
+    def __init__(
+        self,
+        include_background: bool = True,
+        to_onehot_y: bool = False,
+        sigmoid: bool = False,
+        softmax: bool = False,
+        other_act: Callable | None = None,
+        squared_pred: bool = False,
+        jaccard: bool = False,
+        reduction: LossReduction | str = LossReduction.MEAN,
+        smooth_nr: float = 1e-5,
+        smooth_dr: float = 1e-5,
+        batch: bool = False,
+        weight: Sequence[float] | float | int | torch.Tensor | None = None,
+        soft_label: bool = False,
+    ) -> None:
         """
         Args follow :py:class:`monai.losses.DiceLoss`.
         """
-        super().__init__(*args, **kwargs)
-        self.dice = DiceLoss(
-            include_background=self.include_background,
-            to_onehot_y=self.to_onehot_y,
+        if other_act is not None and not callable(other_act):
+            raise TypeError(f"other_act must be None or callable but is {type(other_act).__name__}.")
+        if sigmoid and softmax:
+            raise ValueError("Incompatible values: sigmoid=True and softmax=True.")
+        if other_act is not None and (sigmoid or softmax):
+            raise ValueError("Incompatible values: other_act is not None and sigmoid=True or softmax=True.")
+
+        self.pre_sigmoid = sigmoid
+        self.pre_softmax = softmax
+        self.pre_other_act = other_act
+
+        super().__init__(
+            include_background=include_background,
+            to_onehot_y=to_onehot_y,
             sigmoid=False,
             softmax=False,
             other_act=None,
-            squared_pred=self.squared_pred,
-            jaccard=self.jaccard,
-            reduction=self.reduction,
-            smooth_nr=self.smooth_nr,
-            smooth_dr=self.smooth_dr,
-            batch=self.batch,
-            weight=self.class_weight,
-            soft_label=self.soft_label,
+            squared_pred=squared_pred,
+            jaccard=jaccard,
+            reduction=reduction,
+            smooth_nr=smooth_nr,
+            smooth_dr=smooth_dr,
+            batch=batch,
+            weight=weight,
+            soft_label=soft_label,
         )
-        self.spatial_weighted = MaskedLoss(loss=self.dice.forward)
+
+        self.spatial_weighted = MaskedLoss(loss=super().forward)
 
     def forward(self, input: torch.Tensor, target: torch.Tensor, mask: torch.Tensor | None = None) -> torch.Tensor:
         """
@@ -269,19 +295,19 @@ def forward(self, input: torch.Tensor, target: torch.Tensor, mask: torch.Tensor
             mask: the shape should B1H[WD] or 11H[WD].
         """
 
-        if self.sigmoid:
+        if self.pre_sigmoid:
             input = torch.sigmoid(input)
 
         n_pred_ch = input.shape[1]
-        if self.softmax:
+        if self.pre_softmax:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `softmax=True` ignored.")
+                warnings.warn("single channel prediction, `softmax=True` ignored.", stacklevel=2)
             else:
                 input = torch.softmax(input, 1)
 
-        if self.other_act is not None:
-            input = self.other_act(input)
-        return self.spatial_weighted(input=input, target=target, mask=mask)  # type: ignore[no-any-return]
+        if self.pre_other_act is not None:
+            input = self.pre_other_act(input)
+        return self.spatial_weighted(input=input, target=target, mask=mask) # type: ignore[no-any-return]
 
 
 class GeneralizedDiceLoss(_Loss):