
from sklearn.metrics import accuracy_score

import datasets


lowercase						:      Dict							=							"""
Accuracy is the proportion of correct predictions among the total number of cases processed. It can be computed with:
Accuracy = (TP + TN) / (TP + TN + FP + FN)
 Where:
TP: True positive
TN: True negative
FP: False positive
FN: False negative
"""


lowercase						:      Any							=							"""
Args:
    predictions (`list` of `int`): Predicted labels.
    references (`list` of `int`): Ground truth labels.
    normalize (`boolean`): If set to False, returns the number of correctly classified samples. Otherwise, returns the fraction of correctly classified samples. Defaults to True.
    sample_weight (`list` of `float`): Sample weights Defaults to None.

Returns:
    accuracy (`float` or `int`): Accuracy score. Minimum possible value is 0. Maximum possible value is 1.0, or the number of examples input, if `normalize` is set to `True`.. A higher score means higher accuracy.

Examples:

    Example 1-A simple example
        >>> accuracy_metric = datasets.load_metric(\"accuracy\")
        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])
        >>> print(results)
        {'accuracy': 0.5}

    Example 2-The same as Example 1, except with `normalize` set to `False`.
        >>> accuracy_metric = datasets.load_metric(\"accuracy\")
        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], normalize=False)
        >>> print(results)
        {'accuracy': 3.0}

    Example 3-The same as Example 1, except with `sample_weight` set.
        >>> accuracy_metric = datasets.load_metric(\"accuracy\")
        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], sample_weight=[0.5, 2, 0.7, 0.5, 9, 0.4])
        >>> print(results)
        {'accuracy': 0.8778625954198473}
"""


lowercase						:      Dict							=							"""
@article{scikit-learn,
  title={Scikit-learn: Machine Learning in {P}ython},
  author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
  journal={Journal of Machine Learning Research},
  volume={12},
  pages={2825--2830},
  year={2011}
}
"""

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION      ,			_KWARGS_DESCRIPTION  )
class __snake_case	(   datasets.Metric  ):
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           return datasets.MetricInfo(
               description=_DESCRIPTION	,citation=_CITATION	,inputs_description=_KWARGS_DESCRIPTION	,features=datasets.Features(
                   {
                       """predictions""": datasets.Sequence(datasets.Value("""int32"""   )   ),
                       """references""": datasets.Sequence(datasets.Value("""int32"""   )   ),
                   }
                   if self.config_name == """multilabel"""
                   else {
                       """predictions""": datasets.Value("""int32"""   ),
                       """references""": datasets.Value("""int32"""   ),
                   }   )	,reference_urls=["""https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html"""]	,)
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case	,snake_case	,snake_case=True	,snake_case=None   ):



           '''simple docstring'''







           return {
               "accuracy": float(
                   accuracy_score(snake_case	,snake_case	,normalize=snake_case	,sample_weight=snake_case   )   )
           }


import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
  import torch


lowercase						:      Any							=							logging.get_logger(__name__)

class __snake_case	:
    def __init__(						self	,snake_case	,snake_case=21	,snake_case=[]	,snake_case=None   ):



           '''simple docstring'''







           lowercase							:  Tuple 			=   model
           lowercase							:  List[Any] 			=   trace_batch_nums
           lowercase							:  Union[str, Any] 			=   abort_after_batch_num

           # keep a LIFO buffer of frames to dump as soon as inf/nan is encountered to give context to the problem emergence
           lowercase							:  List[Any] 			=   collections.deque([]	,snake_case   )
           lowercase							:  List[Any] 			=   []
           lowercase							:  Tuple 			=   0
           lowercase							:  Optional[Any] 			=   0
           lowercase							:  int 			=   False
           lowercase							:  List[str] 			=   """                 """

           self.analyse_model()

           self.register_forward_hook()
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case=None   ):



           '''simple docstring'''







           if frame is not None:
                  self.expand_frame(snake_case   )
           self.frames.append("""\n""".join(self.frame   )   )
           lowercase							:  List[str] 			=   []  # start a new frame
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case   ):



           '''simple docstring'''







           self.frame.append(snake_case   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           print("""\n""".join(self.frames   )   )
           lowercase							:  Any 			=   []
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  List[str] 			=   []
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           print(f"\nDetected inf/nan during batch_number={self.batch_number}"   )
           print(f"Last {len(self.frames   )} forward frames:"   )
           print(f"{'abs min':8} {'abs max':8} metadata"   )
           print("""\n""".join(self.frames   )   )
           print("""\n\n"""   )
           lowercase							:  Dict 			=   []
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  int 			=   {m: name for name, m in self.model.named_modules()}
           # self.longest_module_name = max(len(v) for v in self.module_names.values())
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case	,snake_case   ):



           '''simple docstring'''







           if torch.is_tensor(snake_case   ):
                  self.expand_frame(get_abs_min_max(snake_case	,snake_case   )   )
                  if detect_overflow(snake_case	,snake_case   ):
                         lowercase							:  str 			=   True
           elif var is None:
                  self.expand_frame(f"{'None':>17} {ctx}"   )
           else:
                  self.expand_frame(f"{'not a tensor':>17} {ctx}"   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           self.expand_frame(f"\n\n{self.prefix} *** Starting batch number={self.batch_number} ***"   )
           self.expand_frame(f"{'abs min':8} {'abs max':8} metadata"   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           self.expand_frame(f"{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n"   )
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case	,snake_case	,snake_case   ):



           '''simple docstring'''







           self.expand_frame(f"{self.prefix} {self.module_names[module]} {module.__class__.__name__}"   )

           # params
           for name, p in module.named_parameters(recurse=snake_case   ):
                  self.analyse_variable(snake_case	,snake_case   )

           # inputs
           if isinstance(snake_case	,snake_case   ):
                  for i, x in enumerate(snake_case   ):
                         self.analyse_variable(snake_case	,f"input[{i}]"   )
           else:
                  self.analyse_variable(snake_case	,"""input"""   )

           # outputs
           if isinstance(snake_case	,snake_case   ):
                  for i, x in enumerate(snake_case   ):
                         # possibly a tuple of tuples
                         if isinstance(snake_case	,snake_case   ):
                                for j, y in enumerate(snake_case   ):
                                       self.analyse_variable(snake_case	,f"output[{i}][{j}]"   )
                         else:
                                self.analyse_variable(snake_case	,f"output[{i}]"   )
           else:
                  self.analyse_variable(snake_case	,"""output"""   )

           self.save_frame()
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           self.model.apply(self._register_forward_hook   )
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case   ):



           '''simple docstring'''







           module.register_forward_hook(self.forward_hook   )
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case	,snake_case	,snake_case   ):



           '''simple docstring'''







           lowercase							:  Dict 			=   False

           lowercase							:  str 			=   True if self.batch_number in self.trace_batch_nums else False
           if trace_mode:
                  self.reset_saved_frames()

           if self.total_calls == 0:
                  self.batch_start_frame()
           self.total_calls += 1

           # count batch numbers - the very first forward hook of the batch will be called when the
           # batch completes - i.e. it gets called very last - we know this batch has finished
           if module == self.model:
                  self.batch_number += 1
                  lowercase							:  Tuple 			=   True

           self.create_frame(snake_case	,snake_case	,snake_case   )

           # if last_frame_of_batch:
           #     self.batch_end_frame()

           if trace_mode:
                  self.trace_frames()

           if last_frame_of_batch:
                  self.batch_start_frame()

           if self.detected_overflow and not trace_mode:
                  self.dump_saved_frames()

                  # now we can abort, as it's pointless to continue running
                  raise ValueError(
                      """DebugUnderflowOverflow: inf/nan detected, aborting as there is no point running further. """
                      """Please scroll up above this traceback to see the activation values prior to this event."""   )

           # abort after certain batch if requested to do so
           if self.abort_after_batch_num is not None and self.batch_number > self.abort_after_batch_num:
                  raise ValueError(
                      f"DebugUnderflowOverflow: aborting after {self.batch_number} batches due to"
                      f" `abort_after_batch_num={self.abort_after_batch_num}` arg"   )







def 		_snake_case(						SCREAMING_SNAKE_CASE__      ,			SCREAMING_SNAKE_CASE__       )				->					List[str]:
       lowercase							:  str 			=   var.abs()
       return f"{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}"







def 		_snake_case(						SCREAMING_SNAKE_CASE__      ,			SCREAMING_SNAKE_CASE__       )				->					Optional[int]:
       lowercase							:  Any 			=   False
       if torch.isnan(SCREAMING_SNAKE_CASE__       ).any().item():
              lowercase							:  Tuple 			=   True
              print(f"{ctx} has nans"       )
       if torch.isinf(SCREAMING_SNAKE_CASE__       ).any().item():
              lowercase							:  Union[str, Any] 			=   True
              print(f"{ctx} has infs"       )

       # if needed to monitor large elements can enable the following
       if 0:  # and detected:
              lowercase							:  Optional[int] 			=   var[torch.ge(var.abs()      ,			100       )]
              if naaa.numel() > 0:
                     print(f"{ctx}:  n100={naaa.numel()}"       )
              lowercase							:  Union[str, Any] 			=   var[torch.ge(var.abs()      ,			1_000       )]
              if naaaa.numel() > 0:
                     print(f"{ctx}: n1000={naaaa.numel()}"       )
              lowercase							:  List[str] 			=   var[torch.ge(var.abs()      ,			10_000       )]
              if naaaaa.numel() > 0:
                     print(f"{ctx}: n10000={naaaaa.numel()}"       )

       if 0:
              print(f"min={var.min():9.2e} max={var.max():9.2e}"       )

       if 0:
              print(f"min={var.min():9.2e} max={var.max():9.2e} var={var.var():9.2e} mean={var.mean():9.2e} ({ctx})"       )

       return detected




class __snake_case	(   lowerCAmelCase  ):
    _a	:		Dict=       "underflow_overflow"
    _a	:		Union[str, Any]=       "tpu_metrics_debug"
