jnddlmZddlmZmZmZmZddlZddlmZddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZmZdd lmZesgd ZGd de ZGddeZGddeZGddeZGddeZGddeZGddeZGddeZ dS))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 fd e 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_updateerrorvaluefn default_value nan_strategyrwarnignoredisable state_namekwargsreturnc tjdi|d}||vr+t|tst d|d|d||_||||||_dS)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 {/home/lighthouse/badge-speaker-benchmark/.benchmark-venv-community/lib/python3.11/site-packages/torchmetrics/aggregation.pyr'zBaseAggregator.__init__:s ""6"""E 3 3 3J|UZ<[<[ 3wI]wwhtwww ) z=LLL$xweightct|ts!tj||j|j}|6t|ts!tj||j|j}|jdkr0tj|}|tj|}n:tj| }tj |}| s| r|jdkrtd|jdvr9|jdkrtdt|||z}|||z}n[t|jtst!d |j|j|||z<d |||z<ntj |}||j||jfS) z3Convert input ``x`` to a tensor and check for Nans.dtypedeviceNrrz"Encountered `nan` values in tensor)rrrz4Encountered `nan` values in tensor. Will be removed.z+`nan_strategy` shall be float but you pass )r(rtorch as_tensorr5r6risnan zeros_likebool ones_likeany RuntimeErrorr UserWarningr)r*to)r,r1r2nans nans_weights r/_cast_and_nan_check_inputz(BaseAggregator._cast_and_nan_check_inputMs!V$$ IDKHHHA  j&@&@ _V4:dkRRRF   ) );q>>D!#k&11 #.t4499;; ++xxzz 3[__.. 3$//&'KLLL$(:::(F22&']_jkkkD;./0A#d[&8$9:FF%d&7??l()jW[Wh)j)jkkk,0,=Ad[()12F4+-._Q''FttDJ4:!6!666r0cdS)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 sr*#t### U\! %% (C- %VT\*%G$HI5PQ %  %  % %%%%%%(QU77uf}%7/7eVm8L/M7 vv~ 7777B(E%-0(T((((.........r0rceZdZUdZdZeed<eed< ddee de fde d d ffd Z d ee efd d fd Z ddeeeeefdeed efdZxZS) 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_valuerrrrrNc tjdtjt dtj |fddi|dS)Nmaxinfr5rr[r&r'r8tensorr)get_default_dtyper,rrr.s r/r'zMaxMetric.__init__sm   \%,,e.E.G.G H H H H   #        r0rc||\}}|r3tj|jtj||_dSdSzUpdate 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.update[11%88q ;;== I"Yt~uy7G7GHHDNNN I Ir0valaxc.|||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 I I I_c&#&#E&(6*:":;<&#IQRZI[&# &#&#&#&#&#&#&#&#r0rZceZdZUdZdZeed<eed< ddee de fde d d ffd Z d ee efd d fd Z ddeeeeefdeed efdZxZS) 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_valuerrrrrNc tjdtjt dtj|fddi|dS)Nminr^r_rrxr`rcs r/r'zMinMetric.__init__sj   LuU-D-F-F G G G   #        r0rc||\}}|r3tj|jtj||_dSdSre)rDrfr8rzrxrgs r/rFzMinMetric.updaterir0rjrkc.|||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 edefdZxZS) 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_valuerrrrrNc tjdtjdtj|fddi|dS)Nsumr_rr)r&r'r8rarbrcs r/r'zSumMetric.__init__qsd   LE$;$=$= > > >   #        r0rc||\}}|r$|xj|z c_dSdSre)rDrfrrrgs r/rFzSumMetric.update~sQ11%88q ;;== * NNeiikk )NNNN * *r0rjrkc.|||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~ceZdZUdZeed< 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.]) rrrrrrNc @tjdg|fi|dS)Ncat)r&r'rcs r/r'zCatMetric.__init__s. L;;F;;;;;r0c||\}}|r|j|dSdSre)rDrfrappendrgs r/rFzCatMetric.updatesQ11%88q ;;== % J  e $ $ $ $ $ % %r0czt|jtr|jrt|jS|jSrH)r(rrUr rJs r/rKzCatMetric.computes7 dj$ ' ' ,DJ , ++ +zr0rr)rMrNrOrPrrSrr r)rr'rFrKrWrXs@r/rrs""H MMMU[<<G$HI5PQ<<  <<<<<< %E%-0 %T % % % %r0rceZdZUdZeed<eed< ddeedefde dd ffd Z dd eeefdeeed fdd fd Z defd Z dde 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_valuer2rrrrrNc tjdtjdtj|fddi||dtjdtjddS)Nrrr_rrr2r")r&r'r8rarbr+rcs r/r'zMeanMetric.__init__s   LE$;$=$= > > >   $       xcAXAZAZ)[)[)[lqrrrrrr0rc4t|ts!tj||j|j}|tj|}n6t|ts!tj||j|j}tj||j}| ||\}}| dkrdS|xj ||z z c_ |xj | z c_ 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 None corresponding to simple harmonic average. r4Nr)r(rr8r9r5r6r= broadcast_toshaperDrfrrr2)r,rr2s r/rFzMeanMetric.update,s%(( QOEDKPPPE >_U++FFFF++ S_V4:dkRRRF#FEK8866ufEE v ;;==A   F EFN//111 vzz||# r0c |j|jz SrH)rr2rJs r/rKzMeanMetric.computeGs,,r0rjrkc.|||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/rrsT##J NNNU[ s sG$HI5PQ s s  s s s s s s$$E%-0$%vt@S:T$`d$$$$6----- _c&#&#E&(6*:":;<&#IQRZI[&# &#&#&#&#&#&#&#&#r0rc VeZdZdZ d dedeedefdedd ffd 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) rwindowrrrrNc fttdd|i||dSNr) base_metricrr%)r&r'rr,rrrr.s r/r'zRunningMean.__init__s< Z%T%T\%TV%T%T]cdddddr0rr rMrNrOrPintrr r)rr'rWrXs@r/rrts--bTZeeeG$HI5PQe e  eeeeeeeeeer0rc VeZdZdZ d dedeedefdedd ffd 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) rrrrrrrNc fttdd|i||dSr)r&r'r~rs r/r'zRunningSum.__init__s< Y%S%SL%SF%S%S\bcccccr0rrrXs@r/rrs..dTZdddG$HI5PQd d  ddddddddddr0r)!collections.abcrtypingrrrrr8rtyping_extensionsr torchmetrics.metricr torchmetrics.utilitiesr torchmetrics.utilities.datar torchmetrics.utilities.importsr torchmetrics.utilities.plotrrtorchmetrics.wrappers.runningr__doctest_skip__rrZrwr~rrrrr%r0r/rs%$$$$$111111111111 %%%%%%&&&&&&111111444444@@@@@@@@@@@@@@111111a```S.S.S.S.S.VS.S.S.lg#g#g#g#g#g#g#g#Tg#g#g#g#g#g#g#g#Tg#g#g#g#g#g#g#g#T>>>>>>>>B|#|#|#|#|#|#|#|#~6e6e6e6e6e'6e6e6er7d7d7d7d7d7d7d7d7d7dr0