a  d0@sddlmZmZmZmZmZmZmZddlZddlm Z ddl m Z ddl m Z ddlmZddlmZddlmZmZdd lmZdd lmZmZesd gZGd d d eZdS))AnyCallableOptionalSequenceTupleUnion no_type_checkN)Tensor)Literal) _dice_compute)_stat_scores_update)Metric) AverageMethodMDMCAverageMethod)_MATPLOTLIB_AVAILABLE)_AX_TYPE_PLOT_OUT_TYPE Dice.plotc seZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <d Z e ed <ed!eeee eedee eeeeeeedd fdd ZeeeddddZeeeeeefdddZeedddZd"eeeeefeeeddd ZZS)#DiceaCompute `Dice`_. .. math:: \text{Dice} = \frac{\text{2 * TP}}{\text{2 * TP} + \text{FP} + \text{FN}} Where :math:`\text{TP}` and :math:`\text{FP}` represent the number of true positives and false positives respecitively. It is recommend set `ignore_index` to index of background class. The reduction method (how the precision scores are aggregated) is controlled by the ``average`` parameter, and additionally by the ``mdmc_average`` parameter in the multi-dimensional multi-class case. As input to ``forward`` and ``update`` the metric accepts the following input: - ``preds`` (:class:`~torch.Tensor`): Predictions from model (probabilities, logits or labels) - ``target`` (:class:`~torch.Tensor`): Ground truth values As output to ``forward`` and ``compute`` the metric returns the following output: - ``dice`` (:class:`~torch.Tensor`): A tensor containing the dice score. - If ``average in ['micro', 'macro', 'weighted', 'samples']``, a one-element tensor will be returned - If ``average in ['none', None]``, the shape will be ``(C,)``, where ``C`` stands for the number of classes Args: num_classes: Number of classes. Necessary for ``'macro'``, and ``None`` average methods. threshold: Threshold for transforming probability or logit predictions to binary (0,1) predictions, in the case of binary or multi-label inputs. Default value of 0.5 corresponds to input being probabilities. zero_division: The value to use for the score if denominator equals zero. average: Defines the reduction that is applied. Should be one of the following: - ``'micro'`` [default]: Calculate the metric globally, across all samples and classes. - ``'macro'``: Calculate the metric for each class separately, and average the metrics across classes (with equal weights for each class). - ``'weighted'``: Calculate the metric for each class separately, and average the metrics across classes, weighting each class by its support (``tp + fn``). - ``'none'`` or ``None``: Calculate the metric for each class separately, and return the metric for every class. - ``'samples'``: Calculate the metric for each sample, and average the metrics across samples (with equal weights for each sample). .. note:: What is considered a sample in the multi-dimensional multi-class case depends on the value of ``mdmc_average``. mdmc_average: Defines how averaging is done for multi-dimensional multi-class inputs (on top of the ``average`` parameter). Should be one of the following: - ``None`` [default]: Should be left unchanged if your data is not multi-dimensional multi-class. - ``'samplewise'``: In this case, the statistics are computed separately for each sample on the ``N`` axis, and then averaged over samples. The computation for each sample is done by treating the flattened extra axes ``...`` as the ``N`` dimension within the sample, and computing the metric for the sample based on that. - ``'global'``: In this case the ``N`` and ``...`` dimensions of the inputs are flattened into a new ``N_X`` sample axis, i.e. the inputs are treated as if they were ``(N_X, C)``. From here on the ``average`` parameter applies as usual. ignore_index: Integer specifying a target class to ignore. If given, this class index does not contribute to the returned score, regardless of reduction method. If an index is ignored, and ``average=None`` or ``'none'``, the score for the ignored class will be returned as ``nan``. top_k: Number of the highest probability or logit score predictions considered finding the correct label, relevant only for (multi-dimensional) multi-class inputs. The default value (``None``) will be interpreted as 1 for these inputs. Should be left at default (``None``) for all other types of inputs. multiclass: Used only in certain special cases, where you want to treat inputs as a different type than what they appear to be. kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ValueError: If ``average`` is none of ``"micro"``, ``"macro"``, ``"samples"``, ``"none"``, ``None``. ValueError: If ``mdmc_average`` is not one of ``None``, ``"samplewise"``, ``"global"``. ValueError: If ``average`` is set but ``num_classes`` is not provided. ValueError: If ``num_classes`` is set and ``ignore_index`` is not in the range ``[0, num_classes)``. Example: >>> from torch import tensor >>> from torchmetrics.classification import Dice >>> preds = tensor([2, 0, 2, 1]) >>> target = tensor([1, 1, 2, 0]) >>> dice = Dice(average='micro') >>> dice(preds, target) tensor(0.2500) Fis_differentiableThigher_is_betterfull_state_updategplot_lower_boundg?plot_upper_boundZClassplot_legend_namerN?microglobal)rmacronone) zero_division num_classes thresholdaverage mdmc_average ignore_indextop_k multiclasskwargsreturnc  stjfi| d} || vr4td| d|dtjtjdf} d| vr`|| vrXtjn|| d<d| vrp|| d<||_||_||_ ||_ ||_ ||_ ||_ |dvrtd|d |d vrtd |d |d kr|r|d krtd|r |dur ||kr |d kr td|d|dt} d} |dkr~|dkr~|dkrLgn"|d kr^|gntd|dfdd} d} dD]}|j|| | dq||_||_dS)N)rrsamplesrNzThe `average` has to be one of z, got .reduce mdmc_reduce)rrr*z The `reduce` z is not valid.)N samplewiserzThe `mdmc_reduce` rzMWhen you set `average` as 'macro', you have to provide the number of classes.zThe `ignore_index` z is not valid for inputs with z classescatr.r*rzWrong reduce=""cstjtjdS)N)Zdtype)torchzeroslongZ zeros_shaper5i/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/classification/dice.pyzDice.__init__..sum)tpfptnfn)defaultZdist_reduce_fx)super__init__ ValueErrorrZWEIGHTEDNONEZMACROr,r-r!r"r'r%r&listZ add_stater#r )selfr r!r"r#r$r%r&r'r(Zallowed_averageZ_reduce_optionsr?Z reduce_fns __class__r6r7rAsL $   z Dice.__init__)predstargetr)c Cst|||j|j|j|j|j|j|jd \}}}}|jtj kr|jt j kr|j |7_ |j |7_ |j|7_|j|7_n0|j ||j ||j||j|dS)z*Update state with predictions and targets.)r,r-r"r!r&r'r%N)r r,r-r"r!r&r'r%rZSAMPLESrZ SAMPLEWISEr;r<r=r>append)rErIrJr;r<r=r>r5r5r7updates(    z Dice.update)r)cCst|jtrt|jn|j}t|jtr6t|jn|j}t|jtrTt|jn|j}t|jtrrt|jn|j}||||fS)zaPerform concatenation on the stat scores if neccesary, before passing them to a compute function.) isinstancer;rDr2r0r<r=r>)rEr;r<r=r>r5r5r7_get_final_statss zDice._get_final_statscCs(|\}}}}t||||j|j|jS)zCompute metric.)rNr r#r-r )rEr;r<_r>r5r5r7computesz Dice.compute)valaxr)cCs |||S)a Plot a single or multiple values from the metric. Args: val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results. If no value is provided, will automatically call `metric.compute` and plot that result. ax: An matplotlib axis object. If provided will add plot to that axis Returns: Figure object and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single value >>> from torch import randint >>> from torchmetrics.classification import Dice >>> metric = Dice() >>> metric.update(randint(2,(10,)), randint(2,(10,))) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> from torch import randint >>> from torchmetrics.classification import Dice >>> metric = Dice() >>> values = [ ] >>> for _ in range(10): ... values.append(metric(randint(2,(10,)), randint(2,(10,)))) >>> fig_, ax_ = metric.plot(values) )Z_plot)rErQrRr5r5r7plots(r)rNrrrNNN)NN)__name__ __module__ __qualname____doc__rbool__annotations__rrrfloatrrstrrintrr rrAr rLrrNrPrrrrrS __classcell__r5r5rGr7rsN i       =r)typingrrrrrrrr2r Ztyping_extensionsr Z+torchmetrics.functional.classification.dicer Z2torchmetrics.functional.classification.stat_scoresr Ztorchmetrics.metricr Ztorchmetrics.utilities.enumsrrZtorchmetrics.utilities.importsrZtorchmetrics.utilities.plotrrZ__doctest_skip__rr5r5r5r7s$