o  i(@s>ddlmZddlZddlmZmZddlmZddlZ ddl Z ddl m Z ddl m mZddlmZddlmZddlmZddlmZdd lmZdd lmZmZmZmZGd d d eZGd ddeZ GdddeZ!GdddeZ"GdddeZ#GdddeZ$GdddeZ%eZ&e#Z'e$Z(e!Z)e%Z*e"Z+dS)) annotationsN)CallableSequence)Any)_Loss) FocalLoss) MaskedLoss)compute_tp_fp_fn)one_hot)DiceCEReduction LossReductionWeightlook_up_optionc sJeZdZdZdddddddejdddddf d!fdd Zd"dd ZZS)#DiceLossaS Compute average Dice loss between two tensors. It can support both multi-classes and multi-labels tasks. The data `input` (BNHW[D] where N is number of classes) is compared with ground truth `target` (BNHW[D]). Note that axis N of `input` is expected to be logits or probabilities for each class, if passing logits as input, must set `sigmoid=True` or `softmax=True`, or specifying `other_act`. And the same axis of `target` can be 1 or N (one-hot format). The `smooth_nr` and `smooth_dr` parameters are values added to the intersection and union components of the inter-over-union calculation to smooth results respectively, these values should be small. The original papers: Milletari, F. et. al. (2016) V-Net: Fully Convolutional Neural Networks for Volumetric Medical Image Segmentation. 3DV 2016. Wang, Z. et. al. (2023) Jaccard Metric Losses: Optimizing the Jaccard Index with Soft Labels. NeurIPS 2023. Wang, Z. et. al. (2023) Dice Semimetric Losses: Optimizing the Dice Score with Soft Labels. MICCAI 2023. TFNh㈵>include_backgroundbool to_onehot_ysigmoidsoftmax other_actCallable | None squared_predjaccard reductionLossReduction | str smooth_nrfloat smooth_drbatchweight3Sequence[float] | float | int | torch.Tensor | None soft_labelreturnNonecstjt|jd|durt|stdt|jdt|t|t|dudkr1t d||_ ||_ ||_ ||_ ||_||_||_t| |_t| |_| |_| dur\t| nd} |d| || |_dS)a Args: include_background: if False, channel index 0 (background category) is excluded from the calculation. if the non-background segmentations are small compared to the total image size they can get overwhelmed by the signal from the background so excluding it in such cases helps convergence. to_onehot_y: whether to convert the ``target`` into the one-hot format, using the number of classes inferred from `input` (``input.shape[1]``). 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: callable function to execute other activation layers, Defaults to ``None``. for example: ``other_act = torch.tanh``. squared_pred: use squared versions of targets and predictions in the denominator or not. jaccard: compute Jaccard Index (soft IoU) instead of dice or not. 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. smooth_nr: a small constant added to the numerator to avoid zero. smooth_dr: a small constant added to the denominator to avoid nan. batch: whether to sum the intersection and union areas over the batch dimension before the dividing. Defaults to False, a Dice loss value is computed independently from each item in the batch before any `reduction`. weight: weights to apply to the voxels of each class. If None no weights are applied. The input can be a single value (same weight for all classes), a sequence of values (the length of the sequence should be the same as the number of classes. If not ``include_background``, the number of classes should not include the background category class 0). The value/values should be no less than 0. Defaults to None. soft_label: whether the target contains non-binary values (soft labels) or not. If True a soft label formulation of the loss will be used. 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. rN*other_act must be None or callable but is .XIncompatible values: more than 1 of [sigmoid=True, softmax=True, other_act is not None]. class_weight)super__init__r valuecallable TypeErrortype__name__int ValueErrorrrrrrrrrrrrtorch as_tensorregister_bufferr")selfrrrrrrrrrrrr r" __class__S/home/dell461/cl/sdc2/last_ska_mid/HISourceFinder-master-l/src/monai/losses/dice.pyr,8s&7     zDiceLoss.__init__input torch.TensortargetcCs|jrt|}|jd}|jr |dkrtdnt|d}|jdur*||}|jr=|dkr7tdnt||d}|j s^|dkrJtdn|ddddf}|ddddf}|j|jkrqt d|jd|jd t d t |j }|jrd g|}|jrd nd}t|||||j\}}}|js|d 9}|d 9}d ||j} d ||||j} d| | } |jd} |jdur| dkr|jjd krt|jg| |_n |jjd | krtd |jd krtd| |j| } |jtjjkrt| } | S|jtj jkrt!| } | S|jtj"jkr8t#| jd d dgt |jd } | $| } | Std|jd)a 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"]. Example: >>> from monai.losses.dice import * # NOQA >>> import torch >>> from monai.losses.dice import DiceLoss >>> B, C, H, W = 7, 5, 3, 2 >>> input = torch.rand(B, C, H, W) >>> target_idx = torch.randint(low=0, high=C - 1, size=(B, H, W)).long() >>> target = one_hot(target_idx[:, None, ...], num_classes=C) >>> self = DiceLoss(reduction='none') >>> loss = self(input, target) >>> assert np.broadcast_shapes(loss.shape, input.shape) == input.shape r(2single channel prediction, `softmax=True` ignored.N6single channel prediction, `to_onehot_y=True` ignored. num_classes>single channel prediction, `include_background=False` ignored.z"ground truth has different shape () from input ()r?zthe length of the `weight` sequence should be the same as the number of classes. If `include_background=False`, the weight should not include the background category class 0.z:the value/values of the `weight` should be no less than 0.Unsupported reduction: 0, available options are ["mean", "sum", "none"].)%rr4shaperwarningswarnrrr rAssertionErrorarangelentolistrrr r"rrrr*ndimr5r3mintorr MEANr-meanSUMsumNONElistview)r7r<r> n_pred_ch reduce_axisordtpfpfn numerator denominatorfZnum_of_classesbroadcast_shaper:r:r;forwardsj                  & zDiceLoss.forward)rrrrrrrrrrrrrrrrrrrrrrr r!r"rr#r$r<r=r>r=r#r=) r1 __module__ __qualname____doc__r rTr,re __classcell__r:r:r8r;rs"Krcs.eZdZdZdfdd ZddddZZS)MaskedDiceLossa Add an additional `masking` process before `DiceLoss`, accept a binary mask ([0, 1]) indicating a region, `input` and `target` will be masked by the region: region with mask `1` will keep the original value, region with `0` mask will be converted to `0`. Then feed `input` and `target` to normal `DiceLoss` computation. This has the effect of ensuring only the masked region contributes to the loss computation and hence gradient calculation. argsrkwargsr#r$cs&tj|i|ttjd|_dS)z@ Args follow :py:class:`monai.losses.DiceLoss`. )lossN)r+r,rrespatial_weighted)r7rlrmr8r:r;r,szMaskedDiceLoss.__init__Nr<r=r>masktorch.Tensor | NonecCs|j|||dS)z Args: input: the shape should be BNH[WD]. target: the shape should be BNH[WD]. mask: the shape should B1H[WD] or 11H[WD]. )r<r>rp)ro)r7r<r>rpr:r:r;reszMaskedDiceLoss.forward)rlrrmrr#r$N)r<r=r>r=rprqr#r=r1rgrhrir,rerjr:r:r8r;rks rkc sPeZdZdZdddddejejddddf d!fdd ZddZ d"dd Z Z S)#GeneralizedDiceLossa> Compute the generalised Dice loss defined in: Sudre, C. et. al. (2017) Generalised Dice overlap as a deep learning loss function for highly unbalanced segmentations. DLMIA 2017. Adapted from: https://github.com/NifTK/NiftyNet/blob/v0.6.0/niftynet/layer/loss_segmentation.py#L279 TFNrrrrrrrrw_type Weight | strrrrrrrr"r#r$c stjt|jd|durt|stdt|jdt|t|t|dudkr1t d||_ ||_ ||_ ||_ ||_t|t|_t||_t| |_| |_| |_dS)a Args: include_background: If False channel index 0 (background category) is excluded from the calculation. to_onehot_y: whether to convert the ``target`` into the one-hot format, using the number of classes inferred from `input` (``input.shape[1]``). 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: callable function to execute other activation layers, Defaults to ``None``. for example: ``other_act = torch.tanh``. w_type: {``"square"``, ``"simple"``, ``"uniform"``} Type of function to transform ground truth volume to a weight factor. Defaults to ``"square"``. 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. smooth_nr: a small constant added to the numerator to avoid zero. smooth_dr: a small constant added to the denominator to avoid nan. batch: whether to sum the intersection and union areas over the batch dimension before the dividing. Defaults to False, intersection over union is computed from each item in the batch. If True, the class-weighted intersection and union areas are first summed across the batches. soft_label: whether the target contains non-binary values (soft labels) or not. If True a soft label formulation of the loss will be used. 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. r%Nr&r'r(r))r+r,r r-r.r/r0r1r2r3rrrrrrr rurrrrr") r7rrrrrrurrrrr"r8r:r;r,s-     zGeneralizedDiceLoss.__init__cCsB|jttjkr t|S|jttjkrt||St|Srr)rustrr SIMPLEr4 reciprocalSQUARE ones_like)r7Zgrndr:r:r;w_funcNs   zGeneralizedDiceLoss.w_funcr<r=r>cCs|jrt|}|jd}|jr |dkrtdnt|d}|jdur*||}|jr=|dkr7tdnt||d}|j s^|dkrJtdn|ddddf}|ddddf}|j|jkrqt d|jd|jd t d t |j }|jrd g|}t|||d|j\}}}|d 9}|d 9}d |||}t||} || } t| } |jrd | | <| | t| } nd | | <tj| ddd jdd} | | | } |jrd nd} d|| j| dd|j}|| j| dd|j}d||}|jtjjkrt|}|S|jtjjkrt|}|S|jtjjkrAt |jd d dgt |jd }|!|}|St"d|jd)z Args: input: the shape should be BNH[WD]. target: the shape should be BNH[WD]. Raises: ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"]. r(r?Nr@rArCz"ground truth has differing shape (rDrErFrrGdim@T)keepdim?rHrI)#rr4rJrrKrLrrr rrMrNrOrPrr r"rWr|risinfmax unsqueezerrrr rTr-rUrVrXrYrZr3)r7r<r>r[r\r^r_r`rbZground_owinfsZ max_valuesZfinal_reduce_dimnumerdenomrcrdr:r:r;reUsf                   & zGeneralizedDiceLoss.forward)rrrrrrrrrrrurvrrrrrrrrr"rr#r$rf) r1rgrhrir rzr rTr,r|rerjr:r:r8r;rts  @rtcs`eZdZdZdejddfd"fdd Zd#ddZd$ddZd%ddZ d%ddZ d&d d!Z Z S)'GeneralizedWassersteinDiceLossa{ Compute the generalized Wasserstein Dice Loss defined in: Fidon L. et al. (2017) Generalised Wasserstein Dice Score for Imbalanced Multi-class Segmentation using Holistic Convolutional Networks. BrainLes 2017. Or its variant (use the option weighting_mode="GDL") defined in the Appendix of: Tilborghs, S. et al. (2020) Comparative study of deep learning methods for the automatic segmentation of lung, lesion and lesion type in CT scans of COVID-19 patients. arXiv preprint arXiv:2007.15546 Adapted from: https://github.com/LucasFidon/GeneralizedWassersteinDiceLoss defaultr dist_matrixnp.ndarray | torch.Tensorweighting_moderwrrrrrr#r$cstjt|jd|jd|jdkr%td|jdd|jdd|dvr/td|||_t|jtj r@t |j|_t |jdkrR|jt |j|_||_ |jd|_t||_t||_d S) a Args: dist_matrix: 2d tensor or 2d numpy array; matrix of distances between the classes. It must have dimension C x C where C is the number of classes. weighting_mode: {``"default"``, ``"GDL"``} Specifies how to weight the class-specific sum of errors. Default to ``"default"``. - ``"default"``: (recommended) use the original weighting method as in: Fidon L. et al. (2017) Generalised Wasserstein Dice Score for Imbalanced Multi-class Segmentation using Holistic Convolutional Networks. BrainLes 2017. - ``"GDL"``: use a GDL-like weighting method as in the Appendix of: Tilborghs, S. et al. (2020) Comparative study of deep learning methods for the automatic segmentation of lung, lesion and lesion type in CT scans of COVID-19 patients. arXiv preprint arXiv:2007.15546 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. smooth_nr: a small constant added to the numerator to avoid zero. smooth_dr: a small constant added to the denominator to avoid nan. Raises: ValueError: When ``dist_matrix`` is not a square matrix. Example: .. code-block:: python import torch import numpy as np from monai.losses import GeneralizedWassersteinDiceLoss # Example with 3 classes (including the background: label 0). # The distance between the background class (label 0) and the other classes is the maximum, equal to 1. # The distance between class 1 and class 2 is 0.5. dist_mat = np.array([[0.0, 1.0, 1.0], [1.0, 0.0, 0.5], [1.0, 0.5, 0.0]], dtype=np.float32) wass_loss = GeneralizedWassersteinDiceLoss(dist_matrix=dist_mat) pred_score = torch.tensor([[1000, 0, 0], [0, 1000, 0], [0, 0, 1000]], dtype=torch.float32) grnd = torch.tensor([0, 1, 2], dtype=torch.int64) wass_loss(pred_score, grnd) # 0 r%rr(zdist_matrix must be C x C, got z x r')rGDLz8weighting_mode must be either 'default' or 'GDL, got %s.N)r+r,r r-rJr3m isinstancenpndarrayr4 from_numpyr alpha_modesizerBrrr)r7rrrrrr8r:r;r,s5"  z'GeneralizedWassersteinDiceLoss.__init__r<r=r>cCsJ||d|dd}||dd}tj|dd}|||}||}|jdkr>||||}| |||} n||||}t j |dd} d|| } d||j | |j } d| } |jtjjkrpt | } | S|jtjjkr~t | } | S|jtjjkr|jddd t|jd} | | } | Std |jd ) zy Args: input: the shape should be BNH[WD]. target: the shape should be BNH[WD]. rr(r~rrFrr)r(rHrI)reshaperlongFrwasserstein_distance_map)_compute_alpha_generalized_true_positivesr"_compute_generalized_true_positive_compute_denominatorr4rWrrrr rTr-rUrVrXrJrOrZr3)r7r<r> flat_input flat_targetprobsZ wass_dist_mapalphaZtrue_posrZ all_errorZ wass_diceZwass_dice_lossrdr:r:r;res0          z&GeneralizedWassersteinDiceLoss.forward flat_probarcCstt|j|j}tj|dd}tj|dd}||d|d|d|df}tj|dd}||d|d|df}tj|dd}tj |d|d}tj |dd}||}tj |dd}|S)a( Compute the voxel-wise Wasserstein distance between the flattened prediction and the flattened labels (ground_truth) with respect to the distance matrix on the label space M. This corresponds to eq. 6 in: Fidon L. et al. (2017) Generalised Wasserstein Dice Score for Imbalanced Multi-class Segmentation using Holistic Convolutional Networks. BrainLes 2017. Args: flat_proba: the probabilities of input(predicted) tensor. flat_target: the target tensor. rr~r(rF)rindex) r4cloner5rrSdevicerexpandrgathersqueezerW)r7rrrZ m_extendedflat_target_extendedZwasserstein_mapr:r:r;r0s*z7GeneralizedWassersteinDiceLoss.wasserstein_distance_maprrcCdtj|dd}||d|j|df}tj|dd}tj||dd}tj|d|ddgdS) Args: alpha: generalised number of true positives of target class. flat_target: the target tensor. wasserstein_distance_map: the map obtained from the above function. rFr~rr(rrrr4rrrrBrrWr7rrrZalpha_extendedrr:r:r;rV  zAGeneralizedWassersteinDiceLoss._compute_generalized_true_positivecCr)rrFr~rr(rrrrr:r:r;rgrz3GeneralizedWassersteinDiceLoss._compute_denominatorcCs|t|d|jf|j}|jdkr4tj ||jd ddd}tj |dd}d|d}|Sd|d d df<|S) zC Args: flat_target: the target tensor. rrrArFr(r~rr}N) r4onesrrBrrSrrrr permuterW)r7rrZ one_hot_fZvolumesr:r:r;rxs"  zHGeneralizedWassersteinDiceLoss._compute_alpha_generalized_true_positives) rrrrwrrrrrrr#r$rf)rr=rr=r#r=)rr=rr=rr=r#r=)rr=r#r=) r1rgrhrir rTr,rerrrrrjr:r:r8r;rs G 3 & rcs`eZdZdZ               d*d+fdd Zd,d$d%Zd,d&d'Zd,d(d)ZZS)- DiceCELossa Compute both Dice loss and Cross Entropy Loss, and return the weighted sum of these two losses. The details of Dice loss is shown in ``monai.losses.DiceLoss``. The details of Cross Entropy Loss is shown in ``torch.nn.CrossEntropyLoss`` and ``torch.nn.BCEWithLogitsLoss()``. In this implementation, two deprecated parameters ``size_average`` and ``reduce``, and the parameter ``ignore_index`` are not supported. TFNrUrrr}rrrrrrrrrrrwrrrrr rq lambda_dice lambda_celabel_smoothingr#r$cstt|tj}| dur|s| dd}n| }t||||||||| | | |d |_tj| ||d|_ tj | |d|_ | dkrDt d|dkrLt d| |_ ||_dS) a! Args: ``lambda_ce`` are only used for cross entropy loss. ``reduction`` and ``weight`` is used for both losses and other parameters are only used for dice loss. include_background: if False channel index 0 (background category) is excluded from the calculation. to_onehot_y: whether to convert the ``target`` into the one-hot format, using the number of classes inferred from `input` (``input.shape[1]``). Defaults to False. sigmoid: if True, apply a sigmoid function to the prediction, only used by the `DiceLoss`, don't need to specify activation function for `CrossEntropyLoss` and `BCEWithLogitsLoss`. softmax: if True, apply a softmax function to the prediction, only used by the `DiceLoss`, don't need to specify activation function for `CrossEntropyLoss` and `BCEWithLogitsLoss`. other_act: callable function to execute other activation layers, Defaults to ``None``. for example: ``other_act = torch.tanh``. only used by the `DiceLoss`, not for the `CrossEntropyLoss` and `BCEWithLogitsLoss`. squared_pred: use squared versions of targets and predictions in the denominator or not. jaccard: compute Jaccard Index (soft IoU) instead of dice or not. reduction: {``"mean"``, ``"sum"``} Specifies the reduction to apply to the output. Defaults to ``"mean"``. The dice loss should as least reduce the spatial dimensions, which is different from cross entropy loss, thus here the ``none`` option cannot be used. - ``"mean"``: the sum of the output will be divided by the number of elements in the output. - ``"sum"``: the output will be summed. smooth_nr: a small constant added to the numerator to avoid zero. smooth_dr: a small constant added to the denominator to avoid nan. batch: whether to sum the intersection and union areas over the batch dimension before the dividing. Defaults to False, a Dice loss value is computed independently from each item in the batch before any `reduction`. weight: a rescaling weight given to each class for cross entropy loss for `CrossEntropyLoss`. or a weight of positive examples to be broadcasted with target used as `pos_weight` for `BCEWithLogitsLoss`. See ``torch.nn.CrossEntropyLoss()`` or ``torch.nn.BCEWithLogitsLoss()`` for more information. The weight is also used in `DiceLoss`. lambda_dice: the trade-off weight value for dice loss. The value should be no less than 0.0. Defaults to 1.0. lambda_ce: the trade-off weight value for cross entropy loss. The value should be no less than 0.0. Defaults to 1.0. label_smoothing: a value in [0, 1] range. If > 0, the labels are smoothed by the given factor to reduce overfitting. Defaults to 0.0. Nr( rrrrrrrrrrrr )r rr) pos_weightrr}'lambda_dice should be no less than 0.0.z%lambda_ce should be no less than 0.0.)r+r,rr r-rdicennCrossEntropyLoss cross_entropyBCEWithLogitsLossbinary_cross_entropyr3rr)r7rrrrrrrrrrrr rrrZ dice_weightr8r:r;r,s6 <   zDiceCELoss.__init__r<r=r>cCsb|jd|jd}}||kr|dkrtj|dd}|}n t|s+|j|jd}|||S)a Compute CrossEntropy loss for the input logits and target. Will remove the channel dim according to PyTorch CrossEntropyLoss: https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html?#torch.nn.CrossEntropyLoss. r(r~dtype)rJr4rris_floating_pointrSrr)r7r<r>r[Z n_target_chr:r:r;ces   z DiceCELoss.cecCs$t|s |j|jd}|||S)zh Compute Binary CrossEntropy loss for the input logits and target in one single class. r)r4rrSrr)r7r<r>r:r:r;bces  zDiceCELoss.bcec Cs||kr!td|jdt|jd|jdt|jd |jddkr?|jd|jdkr?td|jd|jd|||}|jddkrR|||n|||}|j||j|}|S) a Args: input: the shape should be BNH[WD]. target: the shape should be BNH[WD] or B1H[WD]. Raises: ValueError: When number of dimensions for input and target are different. ValueError: When number of channels for target is neither 1 (without one-hot encoding) nor the same as input. Returns: torch.Tensor: value of the loss. Lthe number of dimensions for input and target should be the same, got shape (nb dims: ) and P). if target is not one-hot encoded, please provide a tensor with shape B1H[WD].r(gnumber of channels for target is neither 1 (without one-hot encoding) nor the same as input, got shape  and r') rr3rJrOrrrrr)r7r<r> dice_lossce_loss total_lossr:r:r;res0" &zDiceCELoss.forward)TFFFNFFrUrrFNrrr}) rrrrrrrrrrrrrrrrwrrrrrrr rqrrrrrrr#r$rf) r1rgrhrir,rrrerjr:r:r8r;rs*  Z  rcsNeZdZdZ                d(d)fd!d" Zd*d&d'ZZS)+ DiceFocalLossa Compute both Dice loss and Focal Loss, and return the weighted sum of these two losses. The details of Dice loss is shown in ``monai.losses.DiceLoss``. The details of Focal Loss is shown in ``monai.losses.FocalLoss``. ``gamma`` and ``lambda_focal`` are only used for the focal loss. ``include_background``, ``weight``, ``reduction``, and ``alpha`` are used for both losses, and other parameters are only used for dice loss. TFNrUrrrrrrrrrrrrrrwrrrrgammar r!r lambda_focalr float | Noner#r$csxtt|d||||||| | | | d |_t|d| | ||d|_|dkr)td|dkr1td||_||_||_ dS)af Args: include_background: if False channel index 0 (background category) is excluded from the calculation. to_onehot_y: whether to convert the ``target`` into the one-hot format, using the number of classes inferred from `input` (``input.shape[1]``). Defaults to False. sigmoid: if True, apply a sigmoid function to the prediction, only used by the `DiceLoss`, don't need to specify activation function for `FocalLoss`. softmax: if True, apply a softmax function to the prediction, only used by the `DiceLoss`, don't need to specify activation function for `FocalLoss`. other_act: callable function to execute other activation layers, Defaults to ``None``. for example: `other_act = torch.tanh`. only used by the `DiceLoss`, not for `FocalLoss`. squared_pred: use squared versions of targets and predictions in the denominator or not. jaccard: compute Jaccard Index (soft IoU) instead of dice or not. 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. smooth_nr: a small constant added to the numerator to avoid zero. smooth_dr: a small constant added to the denominator to avoid nan. batch: whether to sum the intersection and union areas over the batch dimension before the dividing. Defaults to False, a Dice loss value is computed independently from each item in the batch before any `reduction`. gamma: value of the exponent gamma in the definition of the Focal loss. weight: weights to apply to the voxels of each class. If None no weights are applied. The input can be a single value (same weight for all classes), a sequence of values (the length of the sequence should be the same as the number of classes). lambda_dice: the trade-off weight value for dice loss. The value should be no less than 0.0. Defaults to 1.0. lambda_focal: the trade-off weight value for focal loss. The value should be no less than 0.0. Defaults to 1.0. alpha: value of the alpha in the definition of the alpha-balanced Focal loss. The value should be in [0, 1]. Defaults to None. Fr)rrrr rrr}r(lambda_focal should be no less than 0.0.N) r+r,rrrfocalr3rrr)r7rrrrrrrrrrrrr rrrr8r:r;r,6s< 7 zDiceFocalLoss.__init__r<r=r>c Cs||kr!td|jdt|jd|jdt|jd |jddkr?|jd|jdkr?td|jd|jd|jrW|jd}|dkrQtd nt||d }|||}| ||}|j ||j |}|S) a Args: input: the shape should be BNH[WD]. The input should be the original logits due to the restriction of ``monai.losses.FocalLoss``. target: the shape should be BNH[WD] or B1H[WD]. Raises: ValueError: When number of dimensions for input and target are different. ValueError: When number of channels for target is neither 1 (without one-hot encoding) nor the same as input. Returns: torch.Tensor: value of the loss. rrrrr(rrr'r@rA) rr3rJrOrrKrLr rrrr)r7r<r>r[r focal_lossrr:r:r;res:"     zDiceFocalLoss.forward)TFFFNFFrUrrFrNrrN)"rrrrrrrrrrrrrrrrwrrrrrrrrr r!rrrrrrr#r$rfrsr:r:r8r;r*s( VrcsNeZdZdZdddddejejdddddddfd%fdd Zd&d#d$Z Z S)'GeneralizedDiceFocalLossa Compute both Generalized Dice Loss and Focal Loss, and return their weighted average. The details of Generalized Dice Loss and Focal Loss are available at ``monai.losses.GeneralizedDiceLoss`` and ``monai.losses.FocalLoss``. Args: include_background (bool, optional): if False channel index 0 (background category) is excluded from the calculation. Defaults to True. to_onehot_y: whether to convert the ``target`` into the one-hot format, using the number of classes inferred from `input` (``input.shape[1]``). Defaults to False. sigmoid (bool, optional): if True, apply a sigmoid function to the prediction. Defaults to False. softmax (bool, optional): if True, apply a softmax function to the prediction. Defaults to False. other_act (Optional[Callable], optional): callable function to execute other activation layers, Defaults to ``None``. for example: `other_act = torch.tanh`. only used by the `GeneralizedDiceLoss`, not for the `FocalLoss`. w_type (Union[Weight, str], optional): {``"square"``, ``"simple"``, ``"uniform"``}. Type of function to transform ground-truth volume to a weight factor. Defaults to ``"square"``. reduction (Union[LossReduction, str], optional): {``"none"``, ``"mean"``, ``"sum"``}. Specified 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. smooth_nr (float, optional): a small constant added to the numerator to avoid zero. Defaults to 1e-5. smooth_dr (float, optional): a small constant added to the denominator to avoid nan. Defaults to 1e-5. batch (bool, optional): whether to sum the intersection and union areas over the batch dimension before the dividing. Defaults to False, i.e., the areas are computed for each item in the batch. gamma (float, optional): value of the exponent gamma in the definition of the Focal loss. Defaults to 2.0. weight (Optional[Union[Sequence[float], float, int, torch.Tensor]], optional): weights to apply to the voxels of each class. If None no weights are applied. The input can be a single value (same weight for all classes), a sequence of values (the length of the sequence hould be the same as the number of classes). Defaults to None. lambda_gdl (float, optional): the trade-off weight value for Generalized Dice Loss. The value should be no less than 0.0. Defaults to 1.0. lambda_focal (float, optional): the trade-off weight value for Focal Loss. The value should be no less than 0.0. Defaults to 1.0. Raises: ValueError: if either `lambda_gdl` or `lambda_focal` is less than 0. TFNrrrrrrrrrrrurvrrrrrrrr r! lambda_gdlrr#r$c sltt||||||||| | d |_t||| | |d|_| dkr&td|dkr.td| |_||_dS)N) rrrrrrurrrr)rrrr rr}z&lambda_gdl should be no less than 0.0.r) r+r,rtgeneralized_dicerrr3rr)r7rrrrrrurrrrrr rrr8r:r;r,s4   z!GeneralizedDiceFocalLoss.__init__r<r=r>c Cs||kr!td|jdt|jd|jdt|jd |jddkr?|jd|jdkr?td|jd|jd|||}|||}|j||j|}|S) a/ Args: input (torch.Tensor): the shape should be BNH[WD]. The input should be the original logits due to the restriction of ``monai.losses.FocalLoss``. target (torch.Tensor): the shape should be BNH[WD] or B1H[WD]. Raises: ValueError: When number of dimensions for input and target are different. ValueError: When number of channels for target is neither 1 (without one-hot encoding) nor the same as input. Returns: torch.Tensor: value of the loss. rrrrr(rrr')rr3rJrOrrrr)r7r<r>Zgdl_lossrrr:r:r;res0"  z GeneralizedDiceFocalLoss.forward)rrrrrrrrrrrurvrrrrrrrrrrr r!rrrrr#r$rf) r1rgrhrir rzr rTr,rerjr:r:r8r;rs$(,r), __future__rrKcollections.abcrrtypingrnumpyrr4torch.nnrtorch.nn.functional functionalrtorch.nn.modules.lossrZmonai.losses.focal_lossrZmonai.losses.spatial_maskrZmonai.losses.utilsr monai.networksr monai.utilsr r r rrrkrtrrrrDicedice_ce dice_focalrgeneralized_dice_focalgeneralized_wasserstein_dicer:r:r:r;s@        J#f! t