o .win@s ddlmZddlmZmZmZmZddlZddlmZddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZmZdd lmZesNgd ZGd dde ZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZ dS))Sequence)AnyCallableOptionalUnionN)Tensor)Literal)Metric)rank_zero_warn) dim_zero_cat)_MATPLOTLIB_AVAILABLE)_AX_TYPE_PLOT_OUT_TYPE)Running)SumMetric.plotMeanMetric.plotMaxMetric.plotMinMetric.plotc seZdZUdZdZdZdZeed<  dde e e fde e e fd e ed efd e d ed df fdd Z dde ee fdee ee fd ee e ffddZde ee fd dfddZd e fddZZS)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 s^tjdi|d}||vrt|tstd|d|d||_|j|||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)selfrrrrr allowed_nan_strategy __class__r&U/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/torchmetrics/aggregation.pyr(:s zBaseAggregator.__init__xweightcCs<t|tstj||j|jd}|dur"t|ts"tj||j|jd}|jdkrt|}|dur6t|}n t| }t |}| sJ| r|jdkrSt d|jdvrq|jdkrbt dt|||B}|||B}n!t|jtstd |j|j|||B<d |||B<nt |}||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-r2r3nans nans_weightr&r&r1_cast_and_nan_check_inputMs2            z(BaseAggregator._cast_and_nan_check_inputcCsdS)zOverwrite in child class.Nr&)r-rr&r&r1updatenszBaseAggregator.updatecCs t||jSzCompute the aggregated value.)getattrrr-r&r&r1computeq zBaseAggregator.compute)rrN)__name__ __module__ __qualname____doc__is_differentiablehigher_is_betterrr<__annotations__rrstrrlistrr*rr(rtuplerDrErI __classcell__r&r&r/r1r s<       !rceZdZUdZdZeed<eed< ddee de fde d d ffd d Z d ee efd d fddZ ddeeeeefdeed efddZZS) 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_valuerrrr r!Nc s4tjdtjtdtd |fddi|dS)Nmaxinfr5rrYr'r(r8tensorr*get_default_dtyper-rr r/r&r1r(s zMaxMetric.__init__rcC4||\}}|rt|jt||_dSdSzUpdate state with data. Args: value: Either a float or tensor containing data. Additional tensor dimensions will be flattened N)rDnumelr8rZrYr-r_r&r&r1rEzMaxMetric.updatevalaxcC |||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-rgrhr&r&r1plot &rrNNrLrMrNrOrr<rRrrrr*rr(rErrr rrmrVr&r&r/r1rXv*  $  rXcrW) 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_valuerrrr r!Nc s2tjdtjtdtd|fddi|dS)Nminr[r\rrtr]r`r/r&r1r(s zMinMetric.__init__rcCrarb)rDrcr8rurtrdr&r&r1rErfzMinMetric.updatergrhcCri)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) rjrlr&r&r1rm!rnrrorprqr&r&r/r1rsrrrscseZdZUdZeed< ddeedefde ddffd d Z d eeefddfd d Z dde eee efde edefddZZS) 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_valuerrrr r!Nc s.tjdtjdtd|fddi|dS)Nsumr\rrw)r'r(r8r^r_r`r/r&r1r(qs zSumMetric.__init__rcCs0||\}}|r|j|7_dSdSrb)rDrcrwrxrdr&r&r1rE~szSumMetric.updatergrhcCri)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) rjrlr&r&r1rms 'rrorp)rLrMrNrOrrRrrr*rr(rErrr rrmrVr&r&r/r1rvJs( $  rvcspeZdZUdZeed< ddeedefde ddffd d Z deeefddfd d Z defd dZ Z 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.]) rrrrr r!Nc stjdg|fi|dS)Ncat)r'r(r`r/r&r1r(szCatMetric.__init__cCs*||\}}|r|j|dSdSrb)rDrcrappendrdr&r&r1rEszCatMetric.updatecCs"t|jtr|jrt|jS|jSrF)r)rrTr rHr&r&r1rIs zCatMetric.computero)rLrMrNrOrrRrrr*rr(rErIrVr&r&r/r1rzs $ rzcseZdZUdZeed<eed< ddeedefde dd ffd d Z dd eeefdeeed fdd fd dZ defddZ dde eeeefde edefddZZS) 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_valuer3rrrr r!Nc sLtjdtjdtd|fddi||jdtjdtddddS)Nrxryr\rr~r3r#)r'r(r8r^r_r,r`r/r&r1r(s"zMeanMetric.__init__rcCst|tstj||j|jd}|durt|}nt|ts(tj||j|jd}t||j}| ||\}}| dkr?dS|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 None corresponding to simple harmonic average. r4Nr)r)rr8r9r5r6r= broadcast_toshaperDrcr~rxr3)r-rr3r&r&r1rE,s    zMeanMetric.updatecCs |j|jSrF)r~r3rHr&r&r1rIGrJzMeanMetric.computergrhcCri)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) rjrlr&r&r1rmKrnrrorKrp)rLrMrNrOrrRrrr*rr(rErIrrr rrmrVr&r&r/r1r}s, %*r}c DeZdZdZ  d dedeedefdedd ffd d Z Z 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) rwindowrrr r!Nc "tjtdd|i||ddSNr) base_metricrr&)r'r(r}r-rrr r/r&r1r("zRunningMean.__init__rr rLrMrNrOintrrr*rr(rVr&r&r/r1rts1rc r) 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) rrrrrr r!Nc rr)r'r(rvrr/r&r1r(rzRunningSum.__init__rrr&r&r/r1rs2r)!collections.abcrtypingrrrrr8rtyping_extensionsrtorchmetrics.metricr torchmetrics.utilitiesr torchmetrics.utilities.datar torchmetrics.utilities.importsr torchmetrics.utilities.plotr rtorchmetrics.wrappers.runningr__doctest_skip__rrXrsrvrzr}rrr&r&r&r1s*        VjjjA9