a  di@sddlmZmZmZmZmZmZmZddlZddlm Z ddl m Z ddl m Z ddlmZddlmZddlmZmZdd lmZesgd ZGd d d e ZGd ddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZdS))AnyCallableListOptionalSequenceTupleUnionN)Tensor)Metric)rank_zero_warn) dim_zero_cat)_MATPLOTLIB_AVAILABLE)_AX_TYPE_PLOT_OUT_TYPE)Running)SumMetric.plotMeanMetric.plotMaxMetric.plotMinMetric.plotcseZdZUdZdZdZdZeed<de e e fe e e fe e efe eddfdd Zde ee fee ee fee e fd d d Ze ee fdd ddZe dddZZS)BaseAggregatoraBase class for aggregation metrics. Args: fn: string specifying the reduction function default_value: default tensor value to use for the metric state nan_strategy: options: - ``'error'``: if any `nan` values are encounted will give a RuntimeError - ``'warn'``: if any `nan` values are encounted will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - a float: if a float is provided will impude any `nan` values with this value state_name: name of the metric state kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ValueError: If ``nan_strategy`` is not one of ``error``, ``warn``, ``ignore`` or a float NFfull_state_updateerrorvalue)fn default_value nan_strategy state_namekwargsreturnc s^tjfi|d}||vr>t|ts>td|d|d||_|j|||d||_dS)N)rwarnignorez6Arg `nan_strategy` should either be a float or one of z but got .defaultZdist_reduce_fx)super__init__ isinstancefloat ValueErrorr add_stater)selfrrrrrZallowed_nan_strategy __class__a/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/aggregation.pyr%7szBaseAggregator.__init__)xweightrcCs"t|tstj|tj|jd}|durDt|tsDtj|tj|jd}t|}|durbt|}nt|}t |}| s| r|j dkrt d|j dvr|j dkrt dt|||B}|||B}n8t|j tstd|j |j |||B<|j |||B<||fS) z3Convert input ``x`` to a tensor and check for Nans.ZdtypedeviceNrz Encounted `nan` values in tensor)r rrz2Encounted `nan` values in tensor. Will be removed.z+`nan_strategy` shall be float but you pass )r&r torch as_tensorfloat32r2isnanZ zeros_likeboolZ ones_likeanyr RuntimeErrorr UserWarningr'r()r*r/r0ZnansZ nans_weightr-r-r._cast_and_nan_check_inputKs,         z(BaseAggregator._cast_and_nan_check_inputrrcCsdS)zOverwrite in child class.Nr-)r*rr-r-r.updatejszBaseAggregator.updatercCs t||jSzCompute the aggregated value.)getattrrr*r-r-r.computemszBaseAggregator.compute)rr)N)__name__ __module__ __qualname____doc__Zis_differentiableZhigher_is_betterrr7__annotations__rrstrr rr'rr%rrr;r=rB __classcell__r-r-r+r.rs*      rcseZdZUdZdZeed<eed<dee e fe ddfdd Z ee efdd d d Z deeeeefeeed ddZZS) MaxMetrica5Aggregate a stream of value into their maximum value. As input to ``forward`` and ``update`` the metric accepts the following input - ``value`` (:class:`~float` or :class:`~torch.Tensor`): a single float or an tensor of float values with arbitary shape ``(...,)``. As output of `forward` and `compute` the metric returns the following output - ``agg`` (:class:`~torch.Tensor`): scalar float tensor with aggregated maximum value over all inputs received Args: nan_strategy: options: - ``'error'``: if any `nan` values are encounted will give a RuntimeError - ``'warn'``: if any `nan` values are encounted will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - a float: if a float is provided will impude any `nan` values with this value kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ValueError: If ``nan_strategy`` is not one of ``error``, ``warn``, ``ignore`` or a float Example: >>> from torch import tensor >>> from torchmetrics.aggregation import MaxMetric >>> metric = MaxMetric() >>> metric.update(1) >>> metric.update(tensor([2, 3])) >>> metric.compute() tensor(3.) Tr max_valuerNrrrc s,tjdttd |fddi|dS)NmaxinfrrKr$r%r3tensorr'r*rrr+r-r.r%szMaxMetric.__init__r<cCs0||\}}|r,t|jt||_dSzUpdate state with data. Args: value: Either a float or tensor containing data. Additional tensor dimensions will be flattened N)r;numelr3rMrKr*r_r-r-r.r=szMaxMetric.updatevalaxrcCs |||S)aPlot 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 and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single value >>> from torchmetrics.aggregation import MaxMetric >>> metric = MaxMetric() >>> metric.update([1, 2, 3]) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> from torchmetrics.aggregation import MaxMetric >>> metric = MaxMetric() >>> values = [ ] >>> for i in range(10): ... values.append(metric(i)) >>> fig_, ax_ = metric.plot(values) Z_plotr*rWrXr-r-r.plots&r)r)NNrCrDrErFrr7rGr rrHr'rr%r=rrrrr[rIr-r-r+r.rJrs #    rJcseZdZUdZdZeed<eed<dee e fe ddfdd Z ee efdd d d Z deeeeefeeed ddZZS) MinMetrica5Aggregate a stream of value into their minimum value. As input to ``forward`` and ``update`` the metric accepts the following input - ``value`` (:class:`~float` or :class:`~torch.Tensor`): a single float or an tensor of float values with arbitary shape ``(...,)``. As output of `forward` and `compute` the metric returns the following output - ``agg`` (:class:`~torch.Tensor`): scalar float tensor with aggregated minimum value over all inputs received Args: nan_strategy: options: - ``'error'``: if any `nan` values are encounted will give a RuntimeError - ``'warn'``: if any `nan` values are encounted will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - a float: if a float is provided will impude any `nan` values with this value kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ValueError: If ``nan_strategy`` is not one of ``error``, ``warn``, ``ignore`` or a float Example: >>> from torch import tensor >>> from torchmetrics.aggregation import MinMetric >>> metric = MinMetric() >>> metric.update(1) >>> metric.update(tensor([2, 3])) >>> metric.compute() tensor(1.) Tr min_valuerNrLc s*tjdttd|fddi|dS)NminrNrr^rOrQr+r-r.r%s zMinMetric.__init__r<cCs0||\}}|r,t|jt||_dSrR)r;rSr3r_r^rTr-r-r.r=szMinMetric.updaterVcCs |||S)aPlot 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 and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single value >>> from torchmetrics.aggregation import MinMetric >>> metric = MinMetric() >>> metric.update([1, 2, 3]) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> from torchmetrics.aggregation import MinMetric >>> metric = MinMetric() >>> values = [ ] >>> for i in range(10): ... values.append(metric(i)) >>> fig_, ax_ = metric.plot(values) rYrZr-r-r.r[s&r)r)NNr\r-r-r+r.r]s #    r]cs~eZdZUdZeed<deeefe ddfdd Z eeefddd d Z de eee efe eed d d ZZS) SumMetrica!Aggregate a stream of value into their sum. As input to ``forward`` and ``update`` the metric accepts the following input - ``value`` (:class:`~float` or :class:`~torch.Tensor`): a single float or an tensor of float values with arbitary shape ``(...,)``. As output of `forward` and `compute` the metric returns the following output - ``agg`` (:class:`~torch.Tensor`): scalar float tensor with aggregated sum over all inputs received Args: nan_strategy: options: - ``'error'``: if any `nan` values are encounted will give a RuntimeError - ``'warn'``: if any `nan` values are encounted will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - a float: if a float is provided will impude any `nan` values with this value kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ValueError: If ``nan_strategy`` is not one of ``error``, ``warn``, ``ignore`` or a float Example: >>> from torch import tensor >>> from torchmetrics.aggregation import SumMetric >>> metric = SumMetric() >>> metric.update(1) >>> metric.update(tensor([2, 3])) >>> metric.compute() tensor(6.) sum_valuerNrLc s&tjdtd|fddi|dS)Nsumrra)r$r%r3rPrQr+r-r.r%jszSumMetric.__init__r<cCs,||\}}|r(|j|7_dSrR)r;rSrarbrTr-r-r.r=wszSumMetric.updaterVcCs |||S)aPlot 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 and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single value >>> from torchmetrics.aggregation import SumMetric >>> metric = SumMetric() >>> metric.update([1, 2, 3]) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> from torch import rand, randint >>> from torchmetrics.aggregation import SumMetric >>> metric = SumMetric() >>> values = [ ] >>> for i in range(10): ... values.append(metric([i, i+1])) >>> fig_, ax_ = metric.plot(values) rYrZr-r-r.r[s'r)r)NN)rCrDrErFr rGrrHr'rr%r=rrrrr[rIr-r-r+r.r`Ds #   r`csdeZdZUdZeed<deeefe ddfdd Z eeefddd d Z ed d d Z Z S) CatMetrica#Concatenate a stream of values. As input to ``forward`` and ``update`` the metric accepts the following input - ``value`` (:class:`~float` or :class:`~torch.Tensor`): a single float or an tensor of float values with arbitary shape ``(...,)``. As output of `forward` and `compute` the metric returns the following output - ``agg`` (:class:`~torch.Tensor`): scalar float tensor with concatenated values over all input received Args: nan_strategy: options: - ``'error'``: if any `nan` values are encounted will give a RuntimeError - ``'warn'``: if any `nan` values are encounted will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - a float: if a float is provided will impude any `nan` values with this value kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ValueError: If ``nan_strategy`` is not one of ``error``, ``warn``, ``ignore`` or a float Example: >>> from torch import tensor >>> from torchmetrics.aggregation import CatMetric >>> metric = CatMetric() >>> metric.update(1) >>> metric.update(tensor([2, 3])) >>> metric.compute() tensor([1., 2., 3.]) rrNrLc stjdg|fi|dS)Ncat)r$r%rQr+r-r.r%szCatMetric.__init__r<cCs&||\}}|r"|j|dSrR)r;rSrappendrTr-r-r.r=szCatMetric.updater>cCs"t|jtr|jrt|jS|jSr?)r&rlistr rAr-r-r.rBs zCatMetric.compute)r)rCrDrErFr rGrrHr'rr%r=rBrIr-r-r+r.rds #  rdcseZdZUdZeed<deeefe ddfdd Z deeefeeefdd d d Z ed d dZ de eeeefe eedddZZS) MeanMetricaAggregate a stream of value into their mean value. As input to ``forward`` and ``update`` the metric accepts the following input - ``value`` (:class:`~float` or :class:`~torch.Tensor`): a single float or an tensor of float values with arbitary shape ``(...,)``. - ``weight`` (:class:`~float` or :class:`~torch.Tensor`): a single float or an tensor of float value with arbitary shape ``(...,)``. Needs to be broadcastable with the shape of ``value`` tensor. As output of `forward` and `compute` the metric returns the following output - ``agg`` (:class:`~torch.Tensor`): scalar float tensor with aggregated (weighted) mean over all inputs received Args: nan_strategy: options: - ``'error'``: if any `nan` values are encounted will give a RuntimeError - ``'warn'``: if any `nan` values are encounted will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - a float: if a float is provided will impude any `nan` values with this value kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ValueError: If ``nan_strategy`` is not one of ``error``, ``warn``, ``ignore`` or a float Example: >>> from torchmetrics.aggregation import MeanMetric >>> metric = MeanMetric() >>> metric.update(1) >>> metric.update(torch.tensor([2, 3])) >>> metric.compute() tensor(2.) mean_valuerNrLc s<tjdtd|fddi||jdtddddS)Nrbrcrrir0r")r$r%r3rPr)rQr+r-r.r%szMeanMetric.__init__?)rr0rcCst|tstj|tj|jd}|durDt|tsDtj|tj|jd}t||j}|||\}}| dkrrdS|j || 7_ |j | 7_ dS)aUpdate state with data. Args: value: Either a float or tensor containing data. Additional tensor dimensions will be flattened weight: Either a float or tensor containing weights for calculating the average. Shape of weight should be able to broadcast with the shape of `value`. Default to `1.0` corresponding to simple harmonic average. r1Nr) r&r r3r4r5r2Z broadcast_toshaper;rSrirbr0)r*rr0r-r-r.r="s  zMeanMetric.updater>cCs |j|jSr?)rir0rAr-r-r.rB;szMeanMetric.computerVcCs |||S)aPlot 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 and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single value >>> from torchmetrics.aggregation import MeanMetric >>> metric = MeanMetric() >>> metric.update([1, 2, 3]) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> from torchmetrics.aggregation import MeanMetric >>> metric = MeanMetric() >>> values = [ ] >>> for i in range(10): ... values.append(metric([i, i+1])) >>> fig_, ax_ = metric.plot(values) rYrZr-r-r.r[?s&r)r)rj)NN)rCrDrErFr rGrrHr'rr%r=rBrrrrr[rIr-r-r+r.rhs $ $rhcs6eZdZdZdeeeefeddfdd Z Z S) RunningMeanaQ Aggregate a stream of value into their mean over a running window. Using this metric compared to `MeanMetric` allows for calculating metrics over a running window of values, instead of the whole history of values. This is beneficial when you want to get a better estimate of the metric during training and don't want to wait for the whole training to finish to get epoch level estimates. As input to ``forward`` and ``update`` the metric accepts the following input - ``value`` (:class:`~float` or :class:`~torch.Tensor`): a single float or an tensor of float values with arbitary shape ``(...,)``. As output of `forward` and `compute` the metric returns the following output - ``agg`` (:class:`~torch.Tensor`): scalar float tensor with aggregated sum over all inputs received Args: window: The size of the running window. nan_strategy: options: - ``'error'``: if any `nan` values are encounted will give a RuntimeError - ``'warn'``: if any `nan` values are encounted will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - a float: if a float is provided will impude any `nan` values with this value kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ValueError: If ``nan_strategy`` is not one of ``error``, ``warn``, ``ignore`` or a float Example: >>> from torch import tensor >>> from torchmetrics.aggregation import RunningMean >>> metric = RunningMean(window=3) >>> for i in range(6): ... current_val = metric(tensor([i])) ... running_val = metric.compute() ... total_val = tensor(sum(list(range(i+1)))) / (i+1) # total mean over all samples ... print(f"{current_val=}, {running_val=}, {total_val=}") current_val=tensor(0.), running_val=tensor(0.), total_val=tensor(0.) current_val=tensor(1.), running_val=tensor(0.5000), total_val=tensor(0.5000) current_val=tensor(2.), running_val=tensor(1.), total_val=tensor(1.) current_val=tensor(3.), running_val=tensor(2.), total_val=tensor(1.5000) current_val=tensor(4.), running_val=tensor(3.), total_val=tensor(2.) current_val=tensor(5.), running_val=tensor(4.), total_val=tensor(2.5000) rNwindowrrrc s"tjtfd|i||ddSNr)Z base_metricro)r$r%rhr*rorrr+r-r.r%szRunningMean.__init__)rmr rCrDrErFintrrHr'rr%rIr-r-r+r.rlhs1 rlcs6eZdZdZdeeeefeddfdd Z Z S) RunningSuma1 Aggregate a stream of value into their sum over a running window. Using this metric compared to `SumMetric` allows for calculating metrics over a running window of values, instead of the whole history of values. This is beneficial when you want to get a better estimate of the metric during training and don't want to wait for the whole training to finish to get epoch level estimates. As input to ``forward`` and ``update`` the metric accepts the following input - ``value`` (:class:`~float` or :class:`~torch.Tensor`): a single float or an tensor of float values with arbitary shape ``(...,)``. As output of `forward` and `compute` the metric returns the following output - ``agg`` (:class:`~torch.Tensor`): scalar float tensor with aggregated sum over all inputs received Args: window: The size of the running window. nan_strategy: options: - ``'error'``: if any `nan` values are encounted will give a RuntimeError - ``'warn'``: if any `nan` values are encounted will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - a float: if a float is provided will impude any `nan` values with this value kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ValueError: If ``nan_strategy`` is not one of ``error``, ``warn``, ``ignore`` or a float Example: >>> from torch import tensor >>> from torchmetrics.aggregation import RunningSum >>> metric = RunningSum(window=3) >>> for i in range(6): ... current_val = metric(tensor([i])) ... running_val = metric.compute() ... total_val = tensor(sum(list(range(i+1)))) # total sum over all samples ... print(f"{current_val=}, {running_val=}, {total_val=}") current_val=tensor(0.), running_val=tensor(0.), total_val=tensor(0) current_val=tensor(1.), running_val=tensor(1.), total_val=tensor(1) current_val=tensor(2.), running_val=tensor(3.), total_val=tensor(3) current_val=tensor(3.), running_val=tensor(6.), total_val=tensor(6) current_val=tensor(4.), running_val=tensor(9.), total_val=tensor(10) current_val=tensor(5.), running_val=tensor(12.), total_val=tensor(15) rmrNrnc s"tjtfd|i||ddSrp)r$r%r`rqr+r-r.r%szRunningSum.__init__)rmrrrr-r-r+r.rts1 rt) typingrrrrrrrr3r Ztorchmetrics.metricr Ztorchmetrics.utilitiesr Ztorchmetrics.utilities.datar Ztorchmetrics.utilities.importsr Ztorchmetrics.utilities.plotrrZtorchmetrics.wrappers.runningrZ__doctest_skip__rrJr]r`rdrhrlrtr-r-r-r.s$$      Tiii@{9