o  im?@sxddlmZddlZddlmZddlmZmZddlm Z gdZ Gdd d e Z ddddZ GdddZ dS)) annotationsN)do_metric_reduction)MetricReductiondeprecated_arg)CumulativeIterationMetric) DiceMetric compute_dice DiceHelpercsJeZdZdZdejddddfdfdd ZdddZ ddddZZ S) raQ Computes Dice score for a set of pairs of prediction-groundtruth labels. It supports single-channel label maps or multi-channel images with class segmentations per channel. This allows the computation for both multi-class and multi-label tasks. If either prediction ``y_pred`` or ground truth ``y`` have shape BCHW[D], it is expected that these represent one- hot segmentations for C number of classes. If either shape is B1HW[D], it is expected that these are label maps and the number of classes must be specified by the ``num_classes`` parameter. In either case for either inputs, this metric applies no activations and so non-binary values will produce unexpected results if this metric is used for binary overlap measurement (ie. either was expected to be one-hot formatted). Soft labels are thus permitted by this metric. Typically this implies that raw predictions from a network must first be activated and possibly made into label maps, eg. for a multi-class prediction tensor softmax and then argmax should be applied over the channel dimensions to produce a label map. The ``include_background`` parameter can be set to `False` to exclude the first category (channel index 0) which is by convention assumed to be background. If the non-background segmentations are small compared to the total image size they can get overwhelmed by the signal from the background. This assumes the shape of both prediction and ground truth is BCHW[D]. The typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`. Further information can be found in the official `MONAI Dice Overview `. Example: .. code-block:: python import torch from monai.metrics import DiceMetric from monai.losses import DiceLoss from monai.networks import one_hot batch_size, n_classes, h, w = 7, 5, 128, 128 y_pred = torch.rand(batch_size, n_classes, h, w) # network predictions y_pred = torch.argmax(y_pred, 1, True) # convert to label map # ground truth as label map y = torch.randint(0, n_classes, size=(batch_size, 1, h, w)) dm = DiceMetric( reduction="mean_batch", return_with_label=True, num_classes=n_classes ) raw_scores = dm(y_pred, y) print(dm.aggregate()) # now compute the Dice loss which should be the same as 1 - raw_scores dl = DiceLoss(to_onehot_y=True, reduction="none") loss = dl(one_hot(y_pred, n_classes), y).squeeze() print(1.0 - loss) # same as raw_scores Args: include_background: whether to include Dice computation on the first channel/category of the prediction and ground truth. Defaults to ``True``, use ``False`` to exclude the background class. reduction: defines mode of reduction to the metrics, this will only apply reduction on `not-nan` values. The available reduction modes are enumerated by :py:class:`monai.utils.enums.MetricReduction`. If "none", is selected, the metric will not do reduction. get_not_nans: whether to return the `not_nans` count. If True, aggregate() returns `(metric, not_nans)` where `not_nans` counts the number of valid values in the result, and will have the same shape. ignore_empty: whether to ignore empty ground truth cases during calculation. If `True`, the `NaN` value will be set for an empty ground truth cases, otherwise 1 will be set if the predictions of empty ground truth cases are also empty. num_classes: number of input channels (always including the background). When this is ``None``, ``y_pred.shape[1]`` will be used. This option is useful when both ``y_pred`` and ``y`` are single-channel class indices and the number of classes is not automatically inferred from data. return_with_label: whether to return the metrics with label, only works when reduction is "mean_batch". If `True`, use "label_{index}" as the key corresponding to C channels; if ``include_background`` is True, the index begins at "0", otherwise at "1". It can also take a list of label names. The outcome will then be returned as a dictionary. TFNinclude_backgroundbool reductionMetricReduction | str get_not_nans ignore_empty num_classes int | Nonereturn_with_labelbool | list[str]returnNonecsPt||_||_||_||_||_||_t|jt j dd|j|jd|_ dS)NFr r r apply_argmaxrr) super__init__r r rrrrr rNONE dice_helper)selfr r rrrr __class__X/home/dell461/cl/sdc2/last_ska_mid/HISourceFinder-master-l/src/monai/metrics/meandice.pyres  zDiceMetric.__init__y_pred torch.TensorycCs.|}|dkrtd|d|j||dS)a Compute the dice value using ``DiceHelper``. Args: y_pred: prediction value, see class docstring for format definition. y: ground truth label. Raises: ValueError: when `y_pred` has fewer than three dimensions. zHy_pred should have at least 3 dimensions (batch, channel, spatial), got .r"r$) ndimension ValueErrorr)rr"r$dimsr r r!_compute_tensor~s zDiceMetric._compute_tensorMetricReduction | str | None0torch.Tensor | tuple[torch.Tensor, torch.Tensor]c Cs|}t|tjstdt|dt||p|j\}}|jtj krg|j rgi}t|j t rQt |D]\}}|j sAd|dnd|}t|d||<q3nt|j |D] \} }t|d|| <qW|}|jrn||fS|S)a Execute reduction and aggregation logic for the output of `compute_dice`. Args: reduction: defines mode of reduction as enumerated in :py:class:`monai.utils.enums.MetricReduction`. By default this will do no reduction. z2the data to aggregate must be PyTorch Tensor, got r&label_r) get_buffer isinstancetorchTensorr)typerr r MEAN_BATCHrr enumerater rounditemzipr) rr datafnot_nans_fivZ _label_keykeyr r r! aggregates  zDiceMetric.aggregate)r r r rrr rr rrrrrrr"r#r$r#rr#N)r r,rr-) __name__ __module__ __qualname____doc__rMEANrr+rA __classcell__r r rr!rsN rTr"r#r$r r rrrrcCst|tjdd||d||dS)a Computes Dice score metric for a batch of predictions. This performs the same computation as :py:class:`monai.metrics.DiceMetric`, which is preferrable to use over this function. For input formats, see the documentation for that class . Args: y_pred: input data to compute, typical segmentation model output. y: ground truth to compute mean dice metric. include_background: whether to include Dice computation on the first channel/category of the prediction and ground truth. Defaults to ``True``, use ``False`` to exclude the background class. ignore_empty: whether to ignore empty ground truth cases during calculation. If `True`, the `NaN` value will be set for an empty ground truth cases, otherwise 1 will be set if the predictions of empty ground truth cases are also empty. num_classes: number of input channels (always including the background). When this is ``None``, ``y_pred.shape[1]`` will be used. This option is useful when both ``y_pred`` and ``y`` are single-channel class indices and the number of classes is not automatically inferred from data. Returns: Dice scores per batch and per class, (shape: [batch_size, num_classes]). Frr')r rr)r"r$r rrr r r!r sr c @sjeZdZdZeddddddedddd d dd d d d d ejd d d d f d$ddZd%dd Zd&d"d#Z d S)'r a Compute Dice score between two tensors ``y_pred`` and ``y``. This is used by :py:class:`monai.metrics.DiceMetric`, see the documentation for that class for input formats. Example: .. code-block:: python import torch from monai.metrics import DiceHelper n_classes, batch_size = 5, 16 spatial_shape = (128, 128, 128) y_pred = torch.rand(batch_size, n_classes, *spatial_shape).float() # predictions y = torch.randint(0, n_classes, size=(batch_size, 1, *spatial_shape)).long() # ground truth score, not_nans = DiceHelper(include_background=False, sigmoid=True, softmax=True)(y_pred, y) print(score, not_nans) Args: include_background: whether to include Dice computation on the first channel/category of the prediction and ground truth. Defaults to ``True``, use ``False`` to exclude the background class. threshold: if ``True`, ``y_pred`` will be thresholded at a value of 0.5. Defaults to False. apply_argmax: whether ``y_pred`` are softmax activated outputs. If True, `argmax` will be performed to get the discrete prediction. Defaults to the value of ``not threshold``. activate: if this and ``threshold` are ``True``, sigmoid activation is applied to ``y_pred`` before thresholding. Defaults to False. get_not_nans: whether to return the number of not-nan values. reduction: defines mode of reduction to the metrics, this will only apply reduction on `not-nan` values. The available reduction modes are enumerated by :py:class:`monai.utils.enums.MetricReduction`. If "none", is selected, the metric will not do reduction. ignore_empty: whether to ignore empty ground truth cases during calculation. If `True`, the `NaN` value will be set for an empty ground truth cases, otherwise 1 will be set if the predictions of empty ground truth cases are also empty. num_classes: number of input channels (always including the background). When this is ``None``, ``y_pred.shape[1]`` will be used. This option is useful when both ``y_pred`` and ``y`` are single-channel class indices and the number of classes is not automatically inferred from data. softmaxz1.5z1.7zUse `apply_argmax` instead.r)new_namesigmoidzUse `threshold` instead. thresholdNFTr bool | Noner activaterr rrrrrrc Csf| dur| }| dur | }||_||_||_|dur|n||_|dur%| n||_||_||_||_dSrC)rMr rr rrOrr) rr rMrrOrr rrrLrJr r r!rs zDiceHelper.__init__r"r#r$cCst|}|dkrdtt|||t|S|jr(tjtd|jdS|t|}|dkr;tjd|jdStjd|jdS)a6 Compute the dice metric for binary inputs which have only spatial dimensions. This method is called separately for each batch item and for each channel of those items. Args: y_pred: input predictions with shape HW[D]. y: ground truth with shape HW[D]. rg@nan)deviceg?g)r2sum masked_selectrtensorfloatrQ)rr"r$y_oZdenormr r r!compute_channels $zDiceHelper.compute_channelr-cCsz|j|j}}|jdur|jd}n|j}|jddkr%|jdkr%d}}|r4|dkr4tj|ddd}n|rB|jr>t|}|dk}|jrGdnd}g}t |jdD]P}g} |dkr_t ||ndgD]7} |jddkrs||df| kn||| f } |jddkr||df| kn||| f} | | | | qb| t | qRtj |dd}t||j\} }|jr| |fS| S) a Compute the metric for the given prediction and ground truth. Args: y_pred: input predictions with shape (batch_size, num_classes or 1, spatial_dims...). the number of channels is inferred from ``y_pred.shape[1]`` when ``num_classes is None``. y: ground truth with shape (batch_size, num_classes or 1, spatial_dims...). NrFT)dimkeepdimg?r)rX)rrMrshaper2argmaxrOrLr ranger appendrWstack contiguousrr r)rr"r$Z _apply_argmax _threshold n_pred_chZfirst_chr:bZc_listcZx_predxr;r<r r r!__call__,s0    .*zDiceHelper.__call__)r rNrMr rrNrOr rr r rrr rrrLrNrJrNrrrB)r"r#r$r#rr-) rDrErFrGrrr5rrWrer r r r!r s"( r )TTN) r"r#r$r#r r rr rrrr#) __future__rr2monai.metrics.utilsr monai.utilsrrmetricr__all__rr r r r r r!s    &