:jnPddlmZddlmZmZmZmZddlZddlmZddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZmZdd lmZesgd ZGd de ZGddeZGddeZGddeZGddeZGddeZGddeZGddeZ y))Sequence)AnyCallableOptionalUnionN)Tensor)Literal)Metric)rank_zero_warn) dim_zero_cat)_MATPLOTLIB_AVAILABLE)_AX_TYPE_PLOT_OUT_TYPE)Running)zSumMetric.plotzMeanMetric.plotzMaxMetric.plotzMinMetric.plotc eZdZUdZdZdZdZeed< dde e e fde e e fde ed efd e d ed df fd Z dde ee fdee ee fd ee e ffdZde ee fd dfdZd e fdZxZS)BaseAggregatoraeBase 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 encountered will give a RuntimeError - ``'warn'``: if any `nan` values are encountered will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - ``'disable'``: disable all `nan` checks - a float: if a float is provided will impute 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``, ``disable`` or a float NFfull_state_updatevaluefn default_value nan_strategyerrorwarnignoredisable state_namekwargsreturnc t|di|d}||vr"t|tst d|d|d||_|j |||||_y)Nrz6Arg `nan_strategy` should either be a float or one of z but got .defaultdist_reduce_fx)super__init__ isinstancefloat ValueErrorr add_stater)selfrrrrrallowed_nan_strategy __class__s m/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/torchmetrics/aggregation.pyr'zBaseAggregator.__init__:sv "6"E 3 3J|UZ<[HI]H^^ghtguuvw ) z=L$xweightct|ts,tj||j|j }|D!#kk&1 #..t499; +xxz[__.$$/&'KLL$$(::((F2&']_jkD;./0A#d[&8$9:F%d&7&7?(+VW[WhWhVi)jkk,0,=,=Ad[()12F4+-.__Q'FttDJJ4::!666r0cy)zOverwrite in child class.Nr%)r,rs r/updatezBaseAggregator.updatensr0c.t||jSzCompute the aggregated value.)getattrrr,s r/computezBaseAggregator.computeqstT__--r0)rrN)__name__ __module__ __qualname____doc__is_differentiablehigher_is_betterrr<__annotations__rrstrrlistr r)rr'rtuplerDrFrK __classcell__r.s@r/rr s*#t# U\! % (C- %VT\*%G$HI5PQ %  %  % %(QU7uf}%7/7eVm8L/M7 vv~ 7B(E%-0(T(..r0rceZdZUdZdZeed<eed< ddee de fde dd ffd Z d ee efdd fd Z dd eeeeefdeedefdZxZS) MaxMetrica}Aggregate 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 arbitrary 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 encountered will give a RuntimeError - ``'warn'``: if any `nan` values are encountered will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - ``'disable'``: disable all `nan` checks - a float: if a float is provided will impute 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``, ``disable`` 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_valuerrrrNc t|dtjt dtj  |fddi|y)Nmaxinfr5rr[r&r'r8tensorr)get_default_dtyper,rrr.s r/r'zMaxMetric.__init__sJ   \\%,e.E.E.G H H  #    r0rc|j|\}}|jr9tj|jtj||_yyzUpdate state with data. Args: value: Either a float or tensor containing data. Additional tensor dimensions will be flattened N)rDnumelr8r]r[r,r_s r/rFzMaxMetric.updateE11%8q ;;="YYt~~uyy7GHDN r0valaxc&|j||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) _plotr,rjrks r/plotzMaxMetric.plotLzz#r""r0rNNrMrNrOrPrr<rSrrr r)rr'rFrrrrrprWrXs@r/rZrZv"H#t"U[  G$HI5PQ        IE%-0 IT I_c&#E&(6*:":;<&#IQRZI[&# &#r0rZceZdZUdZdZeed<eed< ddee de fde dd ffd Z d ee efdd fd Z dd eeeeefdeedefdZxZS) MinMetrica}Aggregate 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 arbitrary 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 encountered will give a RuntimeError - ``'warn'``: if any `nan` values are encountered will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - ``'disable'``: disable all `nan` checks - a float: if a float is provided will impute 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``, ``disable`` 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_valuerrrrNc t|dtjt dtj |fddi|y)Nminr^r_rrxr`rcs r/r'zMinMetric.__init__sG   LLuU-D-D-F G  #    r0rc|j|\}}|jr9tj|jtj||_yyre)rDrfr8rzrxrgs r/rFzMinMetric.updaterir0rjrkc&|j||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) rmros r/rpzMinMetric.plot!rqr0rrrsrtrXs@r/rwrwrur0rwceZdZUdZeed< ddeedefde ddffd Z d eeefddfd Z dd e eee efd e edefd ZxZS) SumMetricaiAggregate 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 arbitrary 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 encountered will give a RuntimeError - ``'warn'``: if any `nan` values are encountered will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - ``'disable'``: disable all `nan` checks - a float: if a float is provided will impute 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``, ``disable`` 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_valuerrrrNc |t|dtjdtj|fddi|y)Nsumr_rr)r&r'r8rarbrcs r/r'zSumMetric.__init__qsC   LLE$;$;$= >  #    r0rc|j|\}}|jr$|xj|jz c_yyre)rDrfrrrgs r/rFzSumMetric.update~s:11%8q ;;= NNeiik )N r0rjrkc&|j||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) rmros r/rpzSumMetric.plotsNzz#r""r0rrrs)rMrNrOrPrrSrr r)rr'rFrrrrrprWrXs@r/r~r~Js"HU[  G$HI5PQ        *E%-0 *T *_c'#E&(6*:":;<'#IQRZI['# '#r0r~cveZdZUdZeed< d deedefde ddffd Z deeefddfd Z defd Z xZ S) CatMetricakConcatenate 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 arbitrary 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 encountered will give a RuntimeError - ``'warn'``: if any `nan` values are encountered will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - ``'disable'``: disable all `nan` checks - a float: if a float is provided will impute 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``, ``disable`` 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.]) rrrrrNc *t|dg|fi|y)Ncat)r&r'rcs r/r'zCatMetric.__init__s L;F;r0c|j|\}}|jr|jj|yyre)rDrfrappendrgs r/rFzCatMetric.updates811%8q ;;= JJ  e $ r0ct|jtr!|jrt|jS|jSrH)r(rrUr rJs r/rKzCatMetric.computes/ djj$ 'DJJ + +zzr0rr)rMrNrOrPrrSrr r)rr'rFrKrWrXs@r/rrsp"H MU[<G$HI5PQ<<  < %E%-0 %T %r0rceZdZUdZeed<eed< ddeedefde ddffd Z dd eeefdeeedfddfd Z defd Z dd e eeeefde edefdZxZS) MeanMetrica-Aggregate 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 arbitrary shape ``(...,)``. - ``weight`` (:class:`~float` or :class:`~torch.Tensor`): a single float or an tensor of float value with arbitrary 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 encountered will give a RuntimeError - ``'warn'``: if any `nan` values are encountered will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - ``'disable'``: disable all `nan` checks - a float: if a float is provided will impute 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``, ``disable`` 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_valuer2rrrrNc t|dtjdtj|fddi||j dtjdtjdy)Nrrr_rrr2r")r&r'r8rarbr+rcs r/r'zMeanMetric.__init__sl   LLE$;$;$= >  $     xcAXAXAZ)[lqrr0rcHt|ts,tj||j|j }|tj |}n__U+FFF+__V4::dkkRF##FEKK866ufE v ;;=A   EFN//11 vzz|# r0c4|j|jz SrH)rr2rJs r/rKzMeanMetric.computeGs,,r0rjrkc&|j||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) rmros r/rpzMeanMetric.plotKrqr0rrrLrs)rMrNrOrPrrSrr r)rr'rFrKrrrrrprWrXs@r/rrs#J NU[ sG$HI5PQ s s  s$E%-0$%vt@S:T$`d$6-- _c&#E&(6*:":;<&#IQRZI[&# &#r0rc JeZdZdZ d dedeedefdeddffd Z xZ S) RunningMeanai 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 arbitrary 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 encountered will give a RuntimeError - ``'warn'``: if any `nan` values are encountered will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - ``'disable'``: disable all `nan` checks - a float: if a float is provided will impute 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``, ``disable`` 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) windowrrrrNc >t|tdd|i||yNr) base_metricrr%)r&r'rr,rrrr.s r/r'zRunningMean.__init__s% Z%T\%TV%T]cdr0r rMrNrOrPintrr r)rr'rWrXs@r/rrtsW-bTZeeG$HI5PQe e  eer0rc JeZdZdZ d dedeedefdeddffd Z xZ S) RunningSumay 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 arbitrary 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 encountered will give a RuntimeError - ``'warn'``: if any `nan` values are encountered will give a warning and continue - ``'ignore'``: all `nan` values are silently removed - ``'disable'``: disable all `nan` checks - a float: if a float is provided will impute 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``, ``disable`` 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) rrrrrNc >t|tdd|i||yr)r&r'r~rs r/r'zRunningSum.__init__s% Y%SL%SF%S\bcr0rrrXs@r/rrsW.dTZddG$HI5PQd d  ddr0r)!collections.abcrtypingrrrrr8rtyping_extensionsr torchmetrics.metricr torchmetrics.utilitiesr torchmetrics.utilities.datar torchmetrics.utilities.importsr torchmetrics.utilities.plotrrtorchmetrics.wrappers.runningr__doctest_skip__rrZrwr~rrrrr%r0r/rs%11 %&14@@1`S.VS.lg#g#Tg#g#Tg#g#T>>B|#|#~6e'6er7d7dr0