Introduce new loss functions

[talhaanwarch]

I am reading loss functions and found some easy-to-implement loss functions which I believe should be in monai.
For example combo loss and unified focal loss

I tried to implement combo loss if any one can check the implementation

from monai.networks import one_hot
from typing import  Optional,Callable,List, Union
from monai.utils import LossReduction
from torch.nn.modules.loss import _Loss

class ComboLoss(_Loss):
    """
    https://arxiv.org/pdf/1805.02798.pdf
    https://github.com/asgsaeid/ComboLoss/blob/master/combo_loss.py
    Combo Loss is weightage average of dice loss and modified
    crossenropy loss to handle the  class-imbalance problem, i.e., 
    segmenting a small foreground from a large context/background, 
    while at the same time controlling the trade-off between F P and F N.
          
    """
    def __init__(self,
        include_background: bool = True,
        to_onehot_y: bool = False,
        sigmoid: bool = False,
        softmax: bool = False,
        other_act: Optional[Callable] = None,
        reduction: Union[LossReduction, str] = LossReduction.MEAN,
        batch: bool = False,
        epsilon=1e-7, smooth=1e-5, alpha=0.5,beta=0.5
        ) -> None:
        """
          Args:
              include_background: if False, channel index 0 (background category) is excluded from the calculation.
              to_onehot_y: whether to convert `y` into the one-hot format. Defaults to False.
              sigmoid: if True, apply a sigmoid function to the prediction.
              softmax: if True, apply a softmax function to the prediction.
              other_act: if don't want to use `sigmoid` or `softmax`, use other callable function to execute
                  other activation layers, Defaults to ``None``. for example:
                  `other_act = torch.tanh`.
              reduction: {``"none"``, ``"mean"``, ``"sum"``}
                Specifies the reduction to apply to the output. Defaults to ``"mean"``.

                - ``"none"``: no reduction will be applied.
                - ``"mean"``: the sum of the output will be divided by the number of elements in the output.
                - ``"sum"``: the output will be summed.
              epsilon: constant term used to bound input between 0 and 1
              smooth: a small constant added to the numerator and denominator of dice to avoid zero
              alpha: controls the amount of Dice term contribution in the loss function
              beta: controls the level of model penalization for false positives/negatives: when β is set to
              a value smaller than 0.5, F P are penalized more.
          Raises:
            TypeError: When ``other_act`` is not an ``Optional[Callable]``.
            ValueError: When more than 1 of [``sigmoid=True``, ``softmax=True``, ``other_act is not None``].
                Incompatible values.
        """
        super().__init__(reduction=LossReduction(reduction).value)
        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 int(sigmoid) + int(softmax) + int(other_act is not None) > 1:
            raise ValueError("Incompatible values: more than 1 of [sigmoid=True, softmax=True, other_act is not None].")

        self.include_background = include_background
        self.to_onehot_y = to_onehot_y
        self.sigmoid = sigmoid
        self.softmax = softmax
        self.other_act = other_act
        self.batch=batch
        self.epsilon=epsilon
        self.smooth=smooth
        self.alpha=alpha
        self.beta=beta
    
    def forward(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
        """
        Args:
            input: the shape should be BNH[WD], where N is the number of classes.
            target: the shape should be BNH[WD] or B1H[WD], where N is the number of classes.

        Raises:
            AssertionError: When input and target (after one hot transform if set)
                have different shapes.
            ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
        """

        if self.sigmoid:
            input = torch.sigmoid(input)
        n_pred_ch = input.shape[1]
        if self.softmax:
            if n_pred_ch == 1:
                warnings.warn("single channel prediction, `softmax=True` ignored.")
            else:
                input = torch.softmax(input, 1)
        if self.other_act is not None:
            input = self.other_act(input)

        if self.to_onehot_y:
            if n_pred_ch == 1:
                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
            else:
                target = one_hot(target, num_classes=n_pred_ch)
        if not self.include_background:
            if n_pred_ch == 1:
                warnings.warn("single channel prediction, `include_background=False` ignored.")
            else:
                # if skipping background, removing first channel
                target = target[:, 1:]
                input = input[:, 1:]

        if target.shape != input.shape:
            raise AssertionError(f"ground truth has different shape ({target.shape}) from input ({input.shape})")
        # reducing only spatial dimensions (not batch nor channels)
        reduce_axis: List[int] = torch.arange(2, len(input.shape)).tolist()
        if self.batch:
            # reducing spatial dimensions and batch
            reduce_axis = [0] + reduce_axis
       
        #calculate dice loss
        intersection = torch.sum(input * target,dim=reduce_axis)
        dice = (2. * intersection + self.smooth) / (torch.sum(input,dim=reduce_axis) +\
                                                    torch.sum(target,dim=reduce_axis) + self.smooth)
        #calculate crossentropy
        input = torch.clamp(input, self.epsilon, 1.0 - self.epsilon)       
        out = - (self.beta * ((target * torch.log(input)) + ((1 - self.beta) * (1.0 - target) * torch.log(1.0 - input))))
        weighted_ce = torch.mean(out,dim=reduce_axis)

        #sum or average on batch and channels
        if self.reduction == LossReduction.MEAN.value:
            dice = torch.mean(dice)  # the batch and channel average of dice
            weighted_ce = torch.mean(weighted_ce)  # the batch and channel average of ce
        elif self.reduction == LossReduction.SUM.value:
            dice = torch.sum(dice)  # sum over the batch and channel dims of dice loss
            weighted_ce = torch.sum(weighted_ce)  # sum over the batch and channel dims of ce loss
        elif self.reduction != LossReduction.NONE.value:
            raise ValueError(f'Unsupported reduction: {self.reduction}, available options are ["mean", "sum", "none"].')

        combo = (self.alpha * weighted_ce) - ((1 - self.alpha) * dice)
        return combo

[talhaanwarch]

i am getting a negative loss. actually

[Nic-Ma]

Hi @talhaanwarch ,

Thanks for your interest and contribution!

Hi @rijobro ,

What do you think about this new loss function? I think you are more familiar with medical losses.

Thanks in advance.

[rijobro]

Thanks for the contribution, but is this not the same as DiceCELoss, which is also a mix of Dice and weighted cross entropy?