ܓ,jnZSSKJr SSKJrJrJrJr SSKrSSKJr SSK J r SSK J r SSK Jr SSKJr SS KJr SS KJrJr SS KJr \(d/S Qr"S S\ 5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r g))Sequence)AnyCallableOptionalUnionN)Tensor)Literal)Metric)rank_zero_warn) dim_zero_cat)_MATPLOTLIB_AVAILABLE)_AX_TYPE_PLOT_OUT_TYPE)Running)zSumMetric.plotzMeanMetric.plotzMaxMetric.plotzMinMetric.plotc ^\rSrSr%SrSrSrSr\\ S'SS\ \ \ 4S\ \ \4S \ \S \4S \ S \S S4 U4SjjjrSS\ \\ 4S\\ \\ 4S \\ \ 44SjjrS\ \\ 4S S4SjrS \ 4SjrSrU=r$)BaseAggregator a)Base 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 >[TU]"S0UD6 SnX6;a'[U[5(d[ SUSUS35eX0lUR XBUS9 X@lg)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 ڦC:\Users\johnn\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\LocalCache\local-packages\Python313\site-packages\torchmetrics/aggregation.pyr(BaseAggregator.__init__:sp "6"E  3J|UZ<[<[HI]H^^ghtguuvw ) zL$xweightc:[U[5(d)[R"XRUR S9nUb>[U[5(d)[R"X RUR S9nUR S:wGa@[R"U5nUb[R"U5nO:[R"U5R5n[R"U5nUR5(dUR5(aUR S:Xa [S5eUR S;a1UR S:Xa[S[5 XU-)nX#U-)nOf[UR [5(d[!SUR 35eUR XU-'S X#U-'O[R"U5nUR#UR5UR#UR54$) z3Convert input ``x`` to a tensor and check for Nans.dtypedevicerrz"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_tensorr7r8risnan zeros_likebool ones_likeany RuntimeErrorr UserWarningr*r+to)r-r3r4nans nans_weights r0_cast_and_nan_check_input(BaseAggregator._cast_and_nan_check_inputMs!V$$DKKHA  j&@&@__V::dkkRF    );;q>D!#kk&1 #..t499; +xxzz[__..$$/&'KLL$$(::((F2&']_jk;./0A#[&8$9:F%d&7&7??(+VW[WhWhVi)jkk,0,=,=A[()12F+-.__Q'FttDJJ4::!666r2cg)zOverwrite in child class.Nr&)r-rs r0updateBaseAggregator.updatensr2c,[XR5$zCompute the aggregated value.)getattrrr-s r0computeBaseAggregator.computeqst__--r2)rr)rrN)__name__ __module__ __qualname____firstlineno____doc__is_differentiablehigher_is_betterrr>__annotations__rrstrrlistr r*rr(rtuplerFrIrO__static_attributes__ __classcell__r/s@r0rr s*#t# U\! % (C- %VT\*%G$HI5PQ %  %  % %%(QU7uf}%7/7eVm8L/M7 vv~ 7B(E%-0(T(...r2rc^\rSrSr%SrSr\\S'\\S'SS\ \ S\ 4S\ S S 4U4S jjjr S \ \ \4S S 4S jrSS\\ \\\4S\\S \4SjjrSrU=r$) MaxMetricvaAggregate 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_valuerrrr Nc >[TU]"S[R"[ S5[R "5S9*U4SS0UD6 g)Nmaxinfr7rrcr'r(r:tensorr*get_default_dtyper-rrr/s r0r(MaxMetric.__init__sJ   \\%,e.E.E.G H H  #    r2rcURU5upUR5(a;[R"UR[R"U55UlggzUpdate state with data. Args: value: Either a float or tensor containing data. Additional tensor dimensions will be flattened N)rFnumelr:rercr-r_s r0rIMaxMetric.updateE11%8 ;;=="YYt~~uyy7GHDN r2valaxc$URX5$)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-rtrus r0plotMaxMetric.plotLzz#""r2)rcrNNrRrSrTrUrVrr>rYrrr r*rr(rIrrrrrzr]r^r_s@r0rarav"H#t"U[  G$HI5PQ         IE%-0 IT I_c&#E&(6*:":;<&#IQRZI[&# &#&#r2rac^\rSrSr%SrSr\\S'\\S'SS\ \ S\ 4S\ S S 4U4S jjjr S \ \ \4S S 4S jrSS\\ \\\4S\\S \4SjjrSrU=r$) MinMetricaAggregate 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_valuerrrr Nc >[TU]"S[R"[ S5[R "5S9U4SS0UD6 g)Nminrfrgrrrhrks r0r(MinMetric.__init__sG   LLuU-D-D-F G  #    r2rcURU5upUR5(a;[R"UR[R"U55Ulggrn)rFror:rrrps r0rIMinMetric.updatersr2rtruc$URX5$)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) rwrys r0rzMinMetric.plot!r|r2)rr}r~rr_s@r0rrrr2rc^\rSrSr%Sr\\S'SS\\S\ 4S\ SS4U4S jjjr S \\ \4SS4S jr SS \ \\\\4S \ \S\4SjjrSrU=r$) SumMetriciJaAggregate 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_valuerrrr Nc |>[TU]"S[R"S[R"5S9U4SS0UD6 g)Nsumrgrr)r'r(r:rirjrks r0r(SumMetric.__init__qsC   LLE$;$;$= >  #    r2rcURU5upUR5(a$U=RUR5- slggrn)rFrorrrps r0rISumMetric.update~s:11%8 ;;== NNeiik )N r2rtruc$URX5$)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) rwrys r0rzSumMetric.plotsNzz#""r2r&r}r~)rRrSrTrUrVrrYrr r*rr(rIrrrrrzr]r^r_s@r0rrJs"HU[  G$HI5PQ         *E%-0 *T *_c'#E&(6*:":;<'#IQRZI['# '#'#r2rc^\rSrSr%Sr\\S'S S\\S\ 4S\ SS4U4S jjjr S\\ \4SS4S jr S\4S jr S rU=r$) CatMetriciaConcatenate 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.]) rrrrr Nc ,>[TU]"S/U40UD6 g)Ncat)r'r(rks r0r(CatMetric.__init__s L;F;r2cURU5upUR5(aURRU5 ggrn)rFrorappendrps r0rICatMetric.updates811%8 ;;== JJ  e $ r2c[UR[5(a&UR(a[UR5$UR$rL)r)rr[r rNs r0rOCatMetric.computes2 djj$ ' 'DJJ + +zzr2r&r})rRrSrTrUrVrrYrr r*rr(rIrOr]r^r_s@r0rrsz"H MU[<G$HI5PQ<<  << %E%-0 %T %r2rc^\rSrSr%Sr\\S'\\S'SS\\S\ 4S\ SS 4U4S jjjr SS \\ \4S\\ \S 4SS 4S jjr S\4S jr SS\\\\\4S\\S\4SjjrSrU=r$) MeanMetriciaAggregate 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_valuer4rrrr Nc >[TU]"S[R"S[R"5S9U4SS0UD6 UR S[R"S[R"5S9SS9 g)Nrrrgrrr4r#)r'r(r:rirjr,rks r0r(MeanMetric.__init__sl   LLE$;$;$= >  $     xcAXAXAZ)[lqrr2rcP[U[5(d)[R"XRUR S9nUc[R "U5nO>[U[5(d)[R"X RUR S9n[R"X!R5nURX5upUR5S:XagU=RX-R5- sl U=RUR5- sl g)azUpdate 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. r6Nr)r)rr:r;r7r8r? broadcast_toshaperFrorrr4)r-rr4s r0rIMeanMetric.update,s%((OOEDKKPE >__U+FFF++__V::dkkRF##FKK866uE  ;;=A   EN//11 vzz|# r2c4URUR- $rL)rr4rNs r0rOMeanMetric.computeGs,,r2rtruc$URX5$)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) rwrys r0rzMeanMetric.plotKr|r2r&r}rQr~)rRrSrTrUrVrrYrr r*rr(rIrOrrrrrzr]r^r_s@r0rrs#J NU[ sG$HI5PQ s s  s s$E%-0$%vt@S:T$`d$6-- _c&#E&(6*:":;<&#IQRZI[&# &#&#r2rc X^\rSrSrSrS S\S\\S\4S\ SS4U4S jjjr S r U=r $) RunningMeanitaAggregate 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) windowrrrr Nc 8>[TU][SSU0UD6US9 gNr) base_metricrr&)r'r(rr-rrrr/s r0r(RunningMean.__init__s% Z%T\%TV%T]cdr2r&r rRrSrTrUrVintrr r*rr(r]r^r_s@r0rrtsW-bTZeeG$HI5PQe e  eer2rc X^\rSrSrSrS S\S\\S\4S\ SS4U4S jjjr S r U=r $) RunningSumiaAggregate 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) rrrrr Nc 8>[TU][SSU0UD6US9 gr)r'r(rrs r0r(RunningSum.__init__s% Y%SL%SF%S\bcr2r&rrr_s@r0rrsW.dTZddG$HI5PQd d  ddr2r)!collections.abcrtypingrrrrr:rtyping_extensionsr torchmetrics.metricr torchmetrics.utilitiesr torchmetrics.utilities.datar torchmetrics.utilities.importsr torchmetrics.utilities.plotrrtorchmetrics.wrappers.runningr__doctest_skip__rrarrrrrrr&r2r0rs%11 %&14@@1`S.VS.lg#g#Tg#g#Tg#g#T>>B|#|#~6e'6er7d7dr2