o .wi@sJddlZddlZddlZddlmZmZddlmZmZddl m Z ddl m Z ddl mZmZmZmZmZmZddlZddlmZddlmZdd lmZdd lmZmZmZmZmZm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'ddl(m)Z)m*Z*m+Z+ddl,m-Z-de.fddZ/GdddeeZ0dedefddZ1Gddde0Z2dS)N)ABCabstractmethod) GeneratorSequence)contextmanagerdeepcopy)AnyCallableClassVarListOptionalUnion)apply_to_collection)Tensor)Module)_flatten_squeeze_if_scalar dim_zero_cat dim_zero_max dim_zero_mean dim_zero_min dim_zero_sum)gather_all_tensors)TorchMetricsUserError)_TORCH_GREATER_EQUAL_2_1)_AX_TYPE_PLOT_OUT_TYPEplot_single_or_multi_val)rank_zero_warnreturncCstjo tjS)z-Determine if distributed mode is initialized.)torch distributed is_availableis_initializedr%r%P/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/torchmetrics/metric.pyjit_distributed_available/r'cseZdZUdZdgZeeeed<gdZ eeeed<dZ e e ed<dZ e e ed<dZe e ed <dZe eed <dZe eed <dZe eed <d eddffdd Zede fddZede fddZedefddZedeeeeeefffddZ  ddedeeefde eeefde ddf ddZ e!j"j#d ed edefd!d"Z$d ed edefd#d$Z%d ed edefd%d&Z&d'eeeefdfddfd(d)Z'd'eeefddfd*d+Z(e)dfd,ed-e eddfd.d/Z*d0edefd1d2Z+dd3d4Z,   5 dd,e ed-e ed6e d7e eddf d8d9Z-dd:e ddfd;d<Z.e/   5 5 dd,e ed-e ed6e d:e d7e ede0f d=d>Z1d?edefd@dAZ2e3dBedCeddfdDdEZ4e3defdFdGZ5dBedCedefdHdIZ6  ddJe eee7eeeefe7eeeffdKe e8de9fdLdMZ:ddNdOZ;ddPdQZdedWeddffdXdY Z?edd[d\Z@edd^d_ZAd`eee!jAfddfdadbZBddcddZddedfZCddgdhZDd`eee!jAfddffdidj ZEddledme7edeFffdndo ZGddpe ddfdqdrZH  k ddse eeefdtedue deeefffdvdw ZIdeeeeeefffdxdyZJdzedted{ed|e d}eed~eedeeddffdd ZKd edeeeffddZLdefddZMdedeNjefddfddZOdedeNjefddfddZPdedeNjefddfddZQdedeNjefddfddZRdedeNjefddfddZSdedeNjefddfddZTdedeNjefddfddZUdedeNjefddfddZVdedeNjefddfddZWdedeNjefddfddZXdedeNjefddfddZYdedeNjefddfddZZdedeNjefddfddZ[dedeNjefddfddZ\dedeNjefddfddZ]dedeNjefddfddZ^dddZ_dedeNjefddfddZ`dedeNjefddfddZadedeNjefddfddZbdedeNjefddfddZcdedeNjefddfddZddedeNjefddfddZededeNjefddfddZfdedeNjefddfddZgdedeNjefddfddZhdedeNjefddfddZidedeNjefddfddZjdddZkdddÄZldddńZmdddDŽZndddɄZodeddfdd̄Zpdeqfdd΄ZrdZsZtS)MetricaFBase class for all metrics present in the Metrics API. This class is inherited by all metrics and implements the following functionality: 1. Handles the transfer of metric states to the correct device. 2. Handles the synchronization of metric states across processes. 3. Provides properties and methods to control the overall behavior of the metric and its states. The three core methods of the base class are: ``add_state()``, ``forward()`` and ``reset()`` which should almost never be overwritten by child classes. Instead, the following methods should be overwritten ``update()`` and ``compute()``. Args: kwargs: additional keyword arguments, see :ref:`Metric kwargs` for more info. - **compute_on_cpu**: If metric state should be stored on CPU during computations. Only works for list states. - **dist_sync_on_step**: If metric state should synchronize on ``forward()``. Default is ``False``. - **process_group**: The process group on which the synchronization is called. Default is the world. - **dist_sync_fn**: Function that performs the allgather option on the metric state. Default is a custom implementation that calls ``torch.distributed.all_gather`` internally. - **distributed_available_fn**: Function that checks if the distributed backend is available. Defaults to a check of ``torch.distributed.is_available()`` and ``torch.distributed.is_initialized()``. - **sync_on_compute**: If metric state should synchronize when ``compute`` is called. Default is ``True``. - **compute_with_cache**: If results from ``compute`` should be cached. Default is ``True``. device__jit_ignored_attributes__)is_differentiablehigher_is_betterplot_lower_boundplot_upper_boundplot_legend_name metric_state_update_called__jit_unused_properties__Nr,r-full_state_updater.r/r0kwargsr c sttjd|jjtt|_t d|_ t |_ | dd|_t|jts5td|j| dd|_t|jtsJtd|j| dd|_| d d|_|jdurjt|jsjtd |j| d dpqt|_| d d |_t|jtstd|j| dd |_t|jtstd|j|rddt|D}tdd|t|j|_||j|_| |j!|_!d|_"d|_#d|_$|j|_%d |_&d|_'d|_(i|_)i|_*i|_+d|_,d|_-dS)Nztorchmetrics.metric.cpucompute_on_cpuFzCExpected keyword argument `compute_on_cpu` to be an `bool` but got dist_sync_on_stepzFExpected keyword argument `dist_sync_on_step` to be an `bool` but got process_group dist_sync_fnzLExpected keyword argument `dist_sync_fn` to be an callable function but got distributed_available_fnsync_on_computeTzCExpected keyword argument `sync_on_compute` to be a `bool` but got compute_with_cachezFExpected keyword argument `compute_with_cache` to be a `bool` but got cSsg|]}d|dqS)`r%).0ar%r%r& z#Metric.__init__..zUnexpected keyword arguments: z, r).super__init__r!_C_log_api_usage_once __class____name__boolrr*_deviceget_default_dtype_dtypepopr7 isinstance ValueErrorr8r9r:callabler'r;r<r=sortedjoininspect signatureupdate_update_signature _wrap_update _wrap_computecompute _computed_forward_cache _update_count_to_sync_should_unsync _enable_grad_dtype_convert _defaults _persistent _reductions _is_synced_cache)selfr5kwargs_rGr%r&rDisd              zMetric.__init__cCstdtdd|jS)NzLThis property will be removed in 2.0.0. Use `Metric.updated_called` instead.) stacklevel)rDeprecationWarning update_calledrfr%r%r&r2s zMetric._update_calledcCs |jdkS)zWReturns `True` if `update` or `forward` has been called initialization or last `reset`.rr\rmr%r%r&rls zMetric.update_calledcC|jS)zgGet the number of times `update` and/or `forward` has been called since initialization or last `reset`.rnrmr%r%r& update_countzMetric.update_countcsfddjDS)z$Get the current state of the metric.ci|]}|t|qSr%getattrr?attrrmr%r& rBz'Metric.metric_state..)rarmr%rmr&r1szMetric.metric_stateFnamedefaultdist_reduce_fx persistentcCst|ttfrt|tr|rtd|dkrt}n(|dkr t}n!|dkr't}n|dkr.t}n|dkr5t}n |durAt |sAtdt|trJ| }t |||t ||j |<||j|<||j|<dS) aL Add metric state variable. Only used by subclasses. Metric state variables are either `:class:`~torch.Tensor` or an empty list, which can be appended to by the metric. Each state variable must have a unique name associated with it. State variables are accessible as attributes of the metric i.e, if ``name`` is ``"my_state"`` then its value can be accessed from an instance ``metric`` as ``metric.my_state``. Metric states behave like buffers and parameters of :class:`~torch.nn.Module` as they are also updated when ``.to()`` is called. Unlike parameters and buffers, metric states are not by default saved in the modules :attr:`~torch.nn.Module.state_dict`. Args: name: The name of the state variable. The variable will then be accessible at ``self.name``. default: Default value of the state; can either be a :class:`~torch.Tensor` or an empty list. The state will be reset to this value when ``self.reset()`` is called. dist_reduce_fx (Optional): Function to reduce state across multiple processes in distributed mode. If value is ``"sum"``, ``"mean"``, ``"cat"``, ``"min"`` or ``"max"`` we will use ``torch.sum``, ``torch.mean``, ``torch.cat``, ``torch.min`` and ``torch.max``` respectively, each with argument ``dim=0``. Note that the ``"cat"`` reduction only makes sense if the state is a list, and not a tensor. The user can also pass a custom function in this parameter. persistent (Optional): whether the state will be saved as part of the modules ``state_dict``. Default is ``False``. .. note:: Setting ``dist_reduce_fx`` to None will return the metric state synchronized across different processes. However, there won't be any reduction function applied to the synchronized metric state. The metric states would be synced as follows - If the metric state is :class:`~torch.Tensor`, the synced value will be a stacked :class:`~torch.Tensor` across the process dimension if the metric state was a :class:`~torch.Tensor`. The original :class:`~torch.Tensor` metric state retains dimension and hence the synchronized output will be of shape ``(num_process, ...)``. - If the metric state is a ``list``, the synced value will be a ``list`` containing the combined elements from all processes. .. important:: When passing a custom function to ``dist_reduce_fx``, expect the synchronized metric state to follow the format discussed in the above note. .. caution:: The values inserted into a list state are deleted whenever :meth:`~Metric.reset` is called. This allows device memory to be automatically reallocated, but may produce unexpected effects when referencing list states. To retain such values after :meth:`~Metric.reset` is called, you must first copy them to another object. Raises: ValueError: If ``default`` is not a ``tensor`` or an ``empty list``. ValueError: If ``dist_reduce_fx`` is not callable or one of ``"mean"``, ``"sum"``, ``"cat"``, ``"min"``, ``"max"`` or ``None``. zPstate variable must be a tensor or any empty list (where you can append tensors)summeanmaxmincatNzV`dist_reduce_fx` must be callable or one of ['mean', 'sum', 'cat', 'min', 'max', None])rNrlistrOrrrrrrP contiguoussetattrrrarbrc)rfrxryrzr{r%r%r& add_states(<   zMetric.add_stateargscOsT|jrtd|js|jdus|jr|j|i||_|jS|j|i||_|jS)aAggregate and evaluate batch input directly. Serves the dual purpose of both computing the metric on the current batch of inputs but also add the batch statistics to the overall accumulating metric state. Input arguments are the exact same as corresponding ``update`` method. The returned output is the exact same as the output of ``compute``. Args: args: Any arguments as required by the metric ``update`` method. kwargs: Any keyword arguments as required by the metric ``update`` method. Returns: The output of the ``compute`` method evaluated on the current batch. Raises: TorchMetricsUserError: If the metric is already synced and ``forward`` is called again. zfThe Metric shouldn't be synced when performing ``forward``. HINT: Did you forget to call ``unsync`` ?.N)rdrr4r8_forward_full_state_updater[_forward_reduce_state_updaterfrr5r%r%r&forwardszMetric.forwardc Os|j|i||j}|j|_d|_|j}d|_|}d|_||j|i|| }| D] \}}t |||q3||_d|_ d|_|j |_d|_d|_||_|jr[||S)a3Forward computation using two calls to `update`. Doing this secures that metrics that need access to the full metric state during `update` works as expected. This is the most safe method to use for any metric but also the slower version of the two forward implementations. FTN)rUr\r8r]r^r7_copy_state_dictr_resetrYitemsrrdr<rZ_move_list_states_to_cpu) rfrr5r\_temp_compute_on_cpucache batch_valrvvalr%r%r&r?s. z!Metric._forward_full_state_updatecOs|}|j}||j|_d|_|j}d|_d|_|j|i|| }|d|_t | |Wdn1s@wYd|_ d|_|j|_d|_d|_||_|jr_||S)aForward computation using single call to `update`. This can be done when the global metric state is a simple reduction of batch states. This can be unsafe for certain metric cases but is also the fastest way to both accumulate globally and compute locally. FTN)rr\rr8r]r^r7r_rUrYr!no_grad_reduce_statesrdr<rZr)rfrr5 global_stater\rrr%r%r&rls.   z#Metric._forward_reduce_state_updateincoming_statecCst|ttfstdt||js|jdus|jrtdt|tr<|j}t||s9td|j dt||j }| |dS)aMerge incoming metric state to the current state of the metric. Args: incoming_state: either a dict containing a metric state similar to the metric itself or an instance of the metric class. Raises: ValueError: If the incoming state is neither a dict nor an instance of the metric class. RuntimeError: If the metric has ``full_state_update=True`` or ``dist_sync_on_step=True``. In these cases, the metric cannot be merged with another metric state in a simple way. The user should overwrite the method in the metric class to handle the merge operation. ValueError: If the incoming state is a metric instance but the class is different from the current metric class. Example with a metric instance: >>> from torchmetrics.aggregation import SumMetric >>> metric1 = SumMetric() >>> metric2 = SumMetric() >>> metric1.update(1) >>> metric2.update(2) >>> metric1.merge_state(metric2) >>> metric1.compute() tensor(3.) Example with a dict: >>> from torchmetrics.aggregation import SumMetric >>> metric = SumMetric() >>> metric.update(1) >>> # SumMetric has one state variable called `sum_value` >>> metric.merge_state({"sum_value": torch.tensor(2)}) >>> metric.compute() tensor(3.) zFExpected incoming state to be a dict or an instance of Metric but got Nz``merge_state`` is not supported for metrics with ``full_state_update=True`` or ``dist_sync_on_step=True``. Please overwrite the merge_state method in the metric class.z-Expected incoming state to be an instance of z but got ) rNdictr)rOtyper4r8 RuntimeErrorrGrHr1r)rfr this_classr%r%r& merge_states (   zMetric.merge_statecCsT|jD]}t||}||vrtd|d|||}|j|}|tkr*||}nw|tkr=|jd|||j}nd|tkrHt ||}nY|t krSt ||}nN|t krit|trdt ||g}n=||}n8|durzt|trzt ||g}n'|durt|trt||g}n|rt|r|t ||g}ntd|t|||qdS)zAdd an incoming metric state to the current state of the metric. Args: incoming_state: a dict containing a metric state similar metric itself zExpected state variable z! to be present in incoming state rNzUnsupported reduce_fn: )rartrOrcrrr\floatrr!r~rrrrNrrstackrrrP TypeErrorr)rfrrv local_stater reduce_fnreducedr%r%r&rs6       zMetric._reduce_statesr:r9csfddjD}jD]C\}}|tkr/t||tr/t||dkr/t||g||<jrR|tkrRt||trRt||dkrRtjgj j dg||<qt |t ||p[j d}jD]^\}}t||tr}t||dkr}t|gqct||dt rt||||<nt||dtrt||||<t|s|dustd|dur|||n||}t||qcdS)Ncrrr%rsrurmr%r&rwrBz%Metric._sync_dist..rr)r*dtype)groupz%reduction_fn must be callable or None)rcrrrNrlenrr!tensorr*rrrr9rrrrPr)rfr:r9 input_dictrv reduction_fn output_dictrr%rmr& _sync_dists>&  zMetric._sync_distrUcs*tdtdtddffdd }|S)Nrr5r c sd_jd7_tj6z |i|Wn$ty>}zdt|vr8tdjjdjjd||d}~wwWdn1sIwYj rW dSdS)NrzExpected all tensors to be onzEncountered different devices in metric calculation (see stacktrace for details). This could be due to the metric class not being on the same device as input. Instead of `metric=z(...)` try to do `metric=zF(...).to(device)` where device corresponds to the device of the input.) rZr\r!set_grad_enabledr_rstrrGrHr7r)rr5errrfrUr%r& wrapped_funcs0  z)Metric._wrap_update..wrapped_func functoolswrapsr )rfrUrr%rr&rWszMetric._wrap_updatecCs:|jD]}t||}t|trt||dd|DqdS)z+Move list states to cpu to save GPU memory.cSsg|]}|dqS)r6)tor?cur_vr%r%r&rA;sz3Metric._move_list_states_to_cpu..N)rartrNrr)rfkey current_valr%r%r&r6s   zMetric._move_list_states_to_cpuT should_syncdistributed_availablecCsv|jr |r td|dur|jdur|j}t|r|nd}|r"|s$dS|dur*t}||_|j||dd|_dS)aSync function for manually controlling when metrics states should be synced across processes. Args: dist_sync_fn: Function to be used to perform states synchronization process_group: Specify the process group on which synchronization is called. default: `None` (which selects the entire world) should_sync: Whether to apply to state synchronization. This will have an impact only when running in a distributed setting. distributed_available: Function to determine if we are running inside a distributed setting Raises: TorchMetricsUserError: If the metric is already synced and ``sync`` is called again. z#The Metric has already been synced.N)r9T)rdrr;rPrrrer)rfr:r9rris_distributedr%r%r&sync=s   z Metric.sync should_unsynccCsX|sdS|js td|jdurtd|jD] \}}t|||qd|_d|_dS)zUnsync function for manually controlling when metrics states should be reverted back to their local states. Args: should_unsync: Whether to perform unsync Nz&The Metric has already been un-synced.z5The internal cache should exist to unsync the Metric.F)rdrrerr)rfrrvrr%r%r&unsyncis  z Metric.unsyncccs0|j||||ddV|j|jo|ddS)a`Context manager to synchronize states. This context manager is used in distributed setting and makes sure that the local cache states are restored after yielding the synchronized state. Args: dist_sync_fn: Function to be used to perform states synchronization process_group: Specify the process group on which synchronization is called. default: `None` (which selects the entire world) should_sync: Whether to apply to state synchronization. This will have an impact only when running in a distributed setting. should_unsync: Whether to restore the cache state so that the metrics can continue to be accumulated. distributed_available: Function to determine if we are running inside a distributed setting )r:r9rrN)r)rrrd)rfr:r9rrrr%r%r& sync_contextszMetric.sync_contextrYcs*tdtdtdtffdd }|S)Nrr5r csjstdjjdtjdurjSjjjj dt |i|}t |t dd}Wdn1s=wYj rH|_|S)Nz!The ``compute`` method of metric zn was called before the ``update`` method which may lead to errors, as metric states have not yet been updated.)r:rrcS|SN)clonexr%r%r&z.wrapped_func..)rlrrGrH UserWarningrZrr:r]r^rrrr=)rr5valuerYrfr%r&rs$  z*Metric._wrap_compute..wrapped_funcr)rfrYrr%rr&rXszMetric._wrap_compute___cOdS)zHOverride this method to update the state variables of your metric class.Nr%rfrrr%r%r&rUz Metric.updatecCr)zOverride this method to compute the final metric value. This method will automatically synchronize state variables when running in distributed backend. Nr%rmr%r%r&rYrzMetric.computecOst)z+Override this method plot the metric value.)NotImplementedErrorrr%r%r&plotz Metric.plotraxc CsB|dur|n|}t|||j|jj|j|j|jd\}}||fS)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 N)rr-rx lower_bound upper_bound legend_name)rYrr-rGrHr.r/r0)rfrrfigr%r%r&_plots  z Metric._plotcCsvd|_d|_d|_|jD]$\}}t||}t|tr+t||| |j qt|| qd|_d|_dS)z4Reset metric state variables to their default value.rNF)r\r[rZrarrtrNrrdetachrrr*clearrerd)rfrvryrr%r%r&rs   z Metric.resetcCst|S)zMake a copy of the metric.rrmr%r%r&rz Metric.clonecCsdd|jDS)z|Get the current state, including all metric states, for the metric. Used for loading and saving a metric. cSsi|] \}}|dvr||qS))rUrYrVr%r?kvr%r%r&rwsz'Metric.__getstate__..)__dict__rrmr%r%r& __getstate__ szMetric.__getstate__statecCs:|j|t|j|_||j|_||j|_dS)zmSet the state of the metric, based on a input state. Used for loading and saving a metric. N)rrUrSrTrVrWrXrY)rfrr%r%r& __setstate__s zMetric.__setstate__rcs*|dvr td|dt||dS)zOOverwrite default method to prevent specific attributes from being set by user.)r-r,r4r.r/r0zCan't change const `z`.N)rrC __setattr__)rfrxrrhr%r&r szMetric.__setattr__ torch.devicecCro)z Return the device of the metric.)rJrmr%r%r&r*-rqz Metric.device torch.dtypecCro)z'Return the default dtype of the metric.)rLrmr%r%r&r2rqz Metric.dtypedst_typecC|SzkOverride default and prevent dtype casting. Please use :meth:`Metric.set_dtype` instead. r%)rfrr%r%r&r7z Metric.typecCrrr%rmr%r%r&r?rz Metric.floatcCrrr%rmr%r%r&doubleGrz Metric.doublecCrrr%rmr%r%r&halfOrz Metric.halfcsd|_t|}d|_|S)zTransfer all metric state to specific dtype. Special version of standard `type` method. Arguments: dst_type: the desired type as string or dtype object TF)r`rCr)rfroutrhr%r& set_dtypeWs zMetric.set_dtypefn exclude_statec sFt}ttfdddD}|js|r|S|jD]S\}}||vr*q!t|tr7||j|<nt|t rHfdd|D|j|<t ||}t|tr[t |||q!t|t rnt ||fdd|Dq!t d|t jd|jd }|j|_|j|_|jd urt|jt|_|jd urt|jt|_|S) a"Overwrite `_apply` function such that we can also move metric states to the correct device. This method is called by the base ``nn.Module`` class whenever `.to`, `.cuda`, `.float`, `.half` etc. methods are called. Dtype conversion is guarded and will only happen through the special `set_dtype` method. Args: fn: the function to apply exclude_state: list of state variables to exclude from applying the function, that then needs to be handled by the metric class itself. c3s|]}|vVqdSrr%)r?f)fsr%r& qsz Metric._apply..)z Module.typez Module.halfz Module.floatz Module.doublezModule.bfloat16cg|]}|qSr%r%r?rrr%r&rA}z!Metric._apply..crr%r%rrr%r&rArzQExpected metric state to be either a Tensor or a list of Tensor, but encountered r)r*N)rC_applyranyr`rarrNrrrtrrr!zerosr*rJrrLrZrr[) rfrrthiscondrrr _dummy_tensorrh)rrr&rcs8         z Metric._applymodecCs|jD]}||j|<qdS)zDChange post-init if metric states should be saved to its state_dict.N)rb)rfrrr%r%r&r{s  zMetric.persistent destinationprefix keep_varscsxtj|||d}|jD]-}|j|sq t||}|s1t|tr%|}n t|tr1dd|D}t ||||<q |S)aWGet the current state of metric as an dictionary. Args: destination: Optional dictionary, that if provided, the state of module will be updated into the dict and the same object is returned. Otherwise, an ``OrderedDict`` will be created and returned. prefix: optional string, a prefix added to parameter and buffer names to compose the keys in state_dict. keep_vars: by default the :class:`~torch.Tensor` returned in the state dict are detached from autograd. If set to ``True``, detaching will not be performed. )rrrcSs"g|] }t|tr |n|qSr%)rNrrrr%r%r&rAs"z%Metric.state_dict..) rC state_dictrarbrtrNrrrr)rfrrrrrrhr%r&rs       zMetric.state_dictcCsTi}|jD]"}t||}t|tr||j||<qdd|D||<q|S)zCopy the current state values.cSs2g|]}t|tr||jnt|qSr%)rNrrrrr*r)r?rr%r%r&rAs&z+Metric._copy_state_dict..)rartrNrrrrr*)rfrrv current_valuer%r%r&rs    zMetric._copy_state_dictrlocal_metadatastrict missing_keysunexpected_keys error_msgsc sJ|jD]}||} | |vrt|||| qt|||d|||dS)z#Load metric states from state_dict.TN)rarrMrC_load_from_state_dict) rfrrrrrrrrrxrhr%r&rs zMetric._load_from_state_dictc s^tjjtjjf|jjfdd|D}tddD}|s)|s)iS|r-|S|S)zFFilter kwargs such that they match the update signature of the metric.cs,i|]\}}|vr|jvr||qSr%)kindr_params _sign_paramsr%r&rws&z)Metric._filter_kwargs..css|] }|jtjjkVqdSr)rrS Parameter VAR_KEYWORDrr%r%r&rsz(Metric._filter_kwargs..) rSr VAR_POSITIONALr rV parametersrrvalues)rfr5filtered_kwargsexists_var_keywordr%rr&_filter_kwargss zMetric._filter_kwargscCs\|jjt|g}|jD]}t||}t|dr"t|ts"||q | |q t t |S)aReturn an unique hash of the metric. The hash depends on both the class itself but also the current metric state, which therefore enforces that two instances of the same metrics never have the same hash even if they have been updated on the same data. __iter__) rGrHidrarthasattrrNrextendappendhashtuple)rf hash_valsrrr%r%r&__hash__s     zMetric.__hash__otherCompositionalMetriccCttj||Sz;Construct compositional metric using the addition operator.rr!addrfrr%r%r&__add__zMetric.__add__cCrz>Construct compositional metric using the logical and operator.rr! bitwise_andr"r%r%r&__and__r$zMetric.__and__cCr)z8Construct compositional metric using the equal operator.)rr!eqr"r%r%r&__eq__r$z Metric.__eq__cCrzAConstruct compositional metric using the floor division operator.rr! floor_divider"r%r%r& __floordiv__r$zMetric.__floordiv__cCr)zHConstruct compositional metric using the greater than or equal operator.)rr!ger"r%r%r&__ge__r$z Metric.__ge__cCr)z?Construct compositional metric using the greater than operator.)rr!gtr"r%r%r&__gt__"r$z Metric.__gt__cCr)zEConstruct compositional metric using the less than or equal operator.)rr!ler"r%r%r&__le__&r$z Metric.__le__cCr)zr$z Metric.__or__cCrzDConstruct compositional metric using the exponential/power operator.rr!powr"r%r%r&__pow__Br$zMetric.__pow__cCttj||Srr r"r%r%r&__radd__Fr$zMetric.__radd__cCrr%r&r"r%r%r&__rand__JszMetric.__rand__cCrMr+r,r"r%r%r& __rfloordiv__Or$zMetric.__rfloordiv__cCrMr7r8r"r%r%r& __rmatmul__Sr$zMetric.__rmatmul__cCrMr;r<r"r%r%r&__rmod__Wr$zMetric.__rmod__cCrMr?r@r"r%r%r&__rmul__[r$zMetric.__rmul__cCrMrErFr"r%r%r&__ror___r$zMetric.__ror__cCrMrIrJr"r%r%r&__rpow__cr$zMetric.__rpow__cCrMz>Construct compositional metric using the subtraction operator.rr!subr"r%r%r&__rsub__gr$zMetric.__rsub__cCrMz>Construct compositional metric using the true divide operator.rr! true_divider"r%r%r& __rtruediv__kr$zMetric.__rtruediv__cCrMz>Construct compositional metric using the logical xor operator.rr! bitwise_xorr"r%r%r&__rxor__or$zMetric.__rxor__cCrrVrWr"r%r%r&__sub__sr$zMetric.__sub__cCrrZr[r"r%r%r& __truediv__wr$zMetric.__truediv__cCrr^r_r"r%r%r&__xor__{r$zMetric.__xor__cCttj|dS)z;Construct compositional metric using the absolute operator.Nrr!absrmr%r%r&__abs__r$zMetric.__abs__cCre)6Construct compositional metric using the not operator.N)rr! bitwise_notrmr%r%r&__inv__r$zMetric.__inv__cCr)ri)rkrmr%r%r& __invert__rzMetric.__invert__cCs tt|dS)z@Construct compositional metric using absolute negative operator.N)r_negrmr%r%r&__neg__s zMetric.__neg__cCre)z7Construct compositional metric using absolute operator.Nrfrmr%r%r&__pos__r$zMetric.__pos__idxcstfdd|dS)z;Construct compositional metric using the get item operator.cs|Srr%rrpr%r&rrz$Metric.__getitem__..N)r)rfrpr%rqr& __getitem__r(zMetric.__getitem__cCstt|S)z=Needed method for construction of new metrics __new__ method.)rr)__str__rmr%r%r&__getnewargs__szMetric.__getnewargs__)NFr N)NNTN)T)NNTTNNN)r r))r r)r r)rF)NrF)rrr r))r r)urH __module__ __qualname____doc__r+r rr__annotations__r3r,r rIr-r4r.rr/r0r rDpropertyr2rlintrprrr rr1r rr!jitunusedrrrrrrrrWrrrrrrrXrrUrYrrrrrrrrrrr*rrrrrrrr{rrrrrbuiltinsr#r(r*r.r0r2r4r6r:r>rBrDrHrLrNrOrPrQrRrSrTrUrYr]rarbrcrdrhrkrlrnrorrrrtr __classcell__r%r%rhr&r)4sf " H$  U -"(= $)   , $"*          4 ""        r)rcCs t| Sr)r!rgrr%r%r&rms rmc seZdZdZdedeeeefdeeeedfddffdd Z d d e ed e e ddfd d Z d e de ddfddZ de fddZejjd e de de fddZd!ddZd"deddfddZdefddZdedefddZZS)#rz`Composition of two metrics with a specific operator which will be executed upon metrics compute.operatormetric_ametric_bNr csZt||_t|tr|jd|ddn||_t|tr(|jd|dddS||_dS)aQClass for creating compositions of metrics. This metric class is the output of adding, multiplying etc. any other metric. The metric re-implements the standard ``update``, ``forward``, ``reset`` and ``compute`` methods to redirect the arguments to the metrics that formed this composition. Args: operator: The operator taking in one (if metric_b is None) or two arguments. Will be applied to outputs of metric_a.compute() and (optionally if metric_b is not None) metric_b.compute() metric_a: First metric whose compute() result is the first argument of operator metric_b: second metric whose compute() result is the second argument of operator. For operators taking in only one input, this should be None. rF)r{rN)rCrDoprNrregister_bufferrr)rfrrrrhr%r&rDs    zCompositionalMetric.__init__r:r9cCr)z[No syncing required here. syncing will be done in metric_a and metric_b. Nr%)rfr:r9r%r%r&rrzCompositionalMetric._sync_distrr5cOs`t|jtr|jj|i|jjdi|t|jtr.|jj|i|jjdi|dSdS)ERedirect the call to the input which the composition was formed from.Nr%)rNrr)rUrrrr%r%r&rUs   $zCompositionalMetric.updatecCsVt|jtr |jn|j}t|jtr|jn|j}|dur%||S|||SrN)rNrr)rYrr)rfval_aval_br%r%r&rYs   zCompositionalMetric.computecOst|jtr|j|i|jjdi|n|j}t|jtr-|j|i|jjdi|n|j}|dur:d|_|jS|durSt|jtrJd|_|jS|||_|jS||||_|jS)zACalculate metric on current batch and accumulate to global state.Nr%)rNrr)rrr[r)rfrr5rrr%r%r&rs&      zCompositionalMetric.forwardcCs4t|jtr |jt|jtr|jdSdSr)rNrr)rrrmr%r%r&rs   zCompositionalMetric.resetFrcCs<t|jtr |jj|dt|jtr|jj|ddSdS)zChange if metric state is persistent (save as part of state_dict) or not. Args: mode: bool indicating if all states should be persistent or not )rN)rNrr)r{r)rfrr%r%r&r{ s  zCompositionalMetric.persistentcCs,d|jjd|jd|jd}|jj|S)zaReturn a representation of the compositional metric, including the two inputs it was formed from.z( z( z, z ) ))rrHrrrG)rf _op_metricsr%r%r&__repr__s  zCompositionalMetric.__repr__rYcCs|S)z0No wrapping necessary for compositional metrics.r%)rfrYr%r%r&rXrz!CompositionalMetric._wrap_computervrurw)rHrxryrzr rr)rrrDr r rrUrYr!r~rrrrIr{rrrXrr%r%rhr&rs(  $   r)3rrrSabcrrcollections.abcrr contextlibrcopyrtypingr r r r r rr!lightning_utilitiesrrtorch.nnrtorchmetrics.utilities.datarrrrrrr"torchmetrics.utilities.distributedr!torchmetrics.utilities.exceptionsrtorchmetrics.utilities.importsrtorchmetrics.utilities.plotrrrtorchmetrics.utilities.printsrrIr'r)rmrr%r%r%r&s<      $   t