





from sklearn.metrics import accuracy_score

import datasets


__A       : Union[str, Any]						    = "\nAccuracy is the proportion of correct predictions among the total number of cases processed. It can be computed with:\nAccuracy = (TP + TN) / (TP + TN + FP + FN)\n Where:\nTP: True positive\nTN: True negative\nFP: False positive\nFN: False negative\n"


__A       : List[Any]						    = "\nArgs:\n    predictions (`list` of `int`): Predicted labels.\n    references (`list` of `int`): Ground truth labels.\n    normalize (`boolean`): If set to False, returns the number of correctly classified samples. Otherwise, returns the fraction of correctly classified samples. Defaults to True.\n    sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n    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.\n\nExamples:\n\n    Example 1-A simple example\n        >>> accuracy_metric = datasets.load_metric(\"accuracy\")\n        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])\n        >>> print(results)\n        {'accuracy': 0.5}\n\n    Example 2-The same as Example 1, except with `normalize` set to `False`.\n        >>> accuracy_metric = datasets.load_metric(\"accuracy\")\n        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], normalize=False)\n        >>> print(results)\n        {'accuracy': 3.0}\n\n    Example 3-The same as Example 1, except with `sample_weight` set.\n        >>> accuracy_metric = datasets.load_metric(\"accuracy\")\n        >>> 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])\n        >>> print(results)\n        {'accuracy': 0.8778625954198473}\n"


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







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,   _KWARGS_DESCRIPTION  )
class     lowerCamelCase(	datasets.Metric  ):
     '''simple docstring'''


     def 					lowerCAmelCase__		(						self       ):
         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 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_=True							,    snake_case_=None       ):
         return {
             "accuracy": float(
                 accuracy_score(snake_case_							,    snake_case_							,    normalize=snake_case_							,    sample_weight=snake_case_       )       )
         }












import csv
import dataclasses
import json
from dataclasses import dataclass
from typing import List, Optional, Union

from ...utils import is_tf_available, is_torch_available, logging


__A       : Optional[int]						    = logging.get_logger(__name__)







@dataclass
class     lowerCamelCase:
     '''simple docstring'''


     __magic_name__        = 42
     __magic_name__        = 42
     __magic_name__        = None
     __magic_name__        = None




     def 					lowerCAmelCase__		(						self       ):
         return json.dumps(dataclasses.asdict(self       )							,    indent=2       ) + "\n"







@dataclass(frozen=__snake_case  )
class     lowerCamelCase:
     '''simple docstring'''


     __magic_name__        = 42
     __magic_name__        = None
     __magic_name__        = None
     __magic_name__        = None




     def 					lowerCAmelCase__		(						self       ):
         return json.dumps(dataclasses.asdict(self       )       ) + "\n"







class     lowerCamelCase:
     '''simple docstring'''


     def 					lowerCAmelCase__		(						self							,    snake_case_       ):
         raise NotImplementedError()




     def 					lowerCAmelCase__		(						self							,    snake_case_       ):
         raise NotImplementedError()




     def 					lowerCAmelCase__		(						self							,    snake_case_       ):
         raise NotImplementedError()




     def 					lowerCAmelCase__		(						self							,    snake_case_       ):
         raise NotImplementedError()




     def 					lowerCAmelCase__		(						self       ):
         raise NotImplementedError()




     def 					lowerCAmelCase__		(						self							,    snake_case_       ):
         if len(self.get_labels()       ) > 1:
             _A    =       self.get_labels()[int(example.label       )]
         return example




     @classmethod
     def 					lowerCAmelCase__		(						cls							,    snake_case_							,    snake_case_=None       ):
         with open(snake_case_							,    'r'							,    encoding='utf-8-sig'       ) as f:
             return list(csv.reader(snake_case_							,    delimiter='\t'							,    quotechar=snake_case_       )       )







class     lowerCamelCase(	__snake_case  ):
     '''simple docstring'''


     def __init__(						self							,    snake_case_=None							,    snake_case_=None							,    snake_case_="classification"							,    snake_case_=False       ):
         _A    =       [] if labels is None else labels
         _A    =       [] if examples is None else examples
         _A    =       mode
         _A    =       verbose




     def __len__(						self       ):
         return len(self.examples       )




     def __getitem__(						self							,    snake_case_       ):
         if isinstance(snake_case_							,    snake_case_       ):
             return SingleSentenceClassificationProcessor(labels=self.labels							,    examples=self.examples[idx]       )
         return self.examples[idx]




     @classmethod
     def 					lowerCAmelCase__		(						cls							,    snake_case_							,    snake_case_=""							,    snake_case_=0							,    snake_case_=1							,    snake_case_=None							,    snake_case_=False							,    **snake_case_       ):
         _A    =       cls(**snake_case_       )
         processor.add_examples_from_csv(
             snake_case_							,    split_name=snake_case_							,    column_label=snake_case_							,    column_text=snake_case_							,    column_id=snake_case_							,    skip_first_row=snake_case_							,    overwrite_labels=snake_case_							,    overwrite_examples=snake_case_							,    )
         return processor




     @classmethod
     def 					lowerCAmelCase__		(						cls							,    snake_case_							,    snake_case_=None							,    **snake_case_       ):
         _A    =       cls(**snake_case_       )
         processor.add_examples(snake_case_							,    labels=snake_case_       )
         return processor




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_=""							,    snake_case_=0							,    snake_case_=1							,    snake_case_=None							,    snake_case_=False							,    snake_case_=False							,    snake_case_=False							,    ):
         _A    =       self._read_tsv(snake_case_       )
         if skip_first_row:
             _A    =       lines[1:]
         _A    =       []
         _A    =       []
         _A    =       []
         for i, line in enumerate(snake_case_       ):
             texts.append(line[column_text]       )
             labels.append(line[column_label]       )
             if column_id is not None:
                 ids.append(line[column_id]       )
             else:
                 _A    =       F"{split_name}-{i}" if split_name else str(snake_case_       )
                 ids.append(snake_case_       )

         return self.add_examples(
             snake_case_							,    snake_case_							,    snake_case_							,    overwrite_labels=snake_case_							,    overwrite_examples=snake_case_       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_=None							,    snake_case_=None							,    snake_case_=False							,    snake_case_=False       ):
         if labels is not None and len(snake_case_       ) != len(snake_case_       ):
             raise ValueError(
                 F"Text and labels have mismatched lengths {len(snake_case_       )} and {len(snake_case_       )}"       )
         if ids is not None and len(snake_case_       ) != len(snake_case_       ):
             raise ValueError(F"Text and ids have mismatched lengths {len(snake_case_       )} and {len(snake_case_       )}"       )
         if ids is None:
             _A    =       [None] * len(snake_case_       )
         if labels is None:
             _A    =       [None] * len(snake_case_       )
         _A    =       []
         _A    =       set()
         for text_or_text_and_label, label, guid in zip(snake_case_							,    snake_case_							,    snake_case_       ):
             if isinstance(snake_case_							,    (tuple, list)       ) and label is None:
                 _A, _A    =       text_or_text_and_label
             else:
                 _A    =       text_or_text_and_label
             added_labels.add(snake_case_       )
             examples.append(InputExample(guid=snake_case_							,    text_a=snake_case_							,    text_b=snake_case_							,    label=snake_case_       )       )

         # Update examples
         if overwrite_examples:
             _A    =       examples
         else:
             self.examples.extend(snake_case_       )

         # Update labels
         if overwrite_labels:
             _A    =       list(snake_case_       )
         else:
             _A    =       list(set(self.labels       ).union(snake_case_       )       )

         return self.examples




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_=None							,    snake_case_=False							,    snake_case_=0							,    snake_case_=True							,    snake_case_=None							,    ):
         if max_length is None:
             _A    =       tokenizer.max_len

         _A    =       {label: i for i, label in enumerate(self.labels       )}

         _A    =       []
         for ex_index, example in enumerate(self.examples       ):
             if ex_index % 1_0000 == 0:
                 logger.info(F"Tokenizing example {ex_index}"       )

             _A    =       tokenizer.encode(
                 example.text_a							,    add_special_tokens=snake_case_							,    max_length=min(snake_case_							,    tokenizer.max_len       )							,    )
             all_input_ids.append(snake_case_       )

         _A    =       max(len(snake_case_       ) for input_ids in all_input_ids       )

         _A    =       []
         for ex_index, (input_ids, example) in enumerate(zip(snake_case_							,    self.examples       )       ):
             if ex_index % 1_0000 == 0:
                 logger.info(F"Writing example {ex_index}/{len(self.examples       )}"       )
             # The mask has 1 for real tokens and 0 for padding tokens. Only real
             # tokens are attended to.
             _A    =       [1 if mask_padding_with_zero else 0] * len(snake_case_       )

             # Zero-pad up to the sequence length.
             _A    =       batch_length - len(snake_case_       )
             if pad_on_left:
                 _A    =       ([pad_token] * padding_length) + input_ids
                 _A    =       ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask
             else:
                 _A    =       input_ids + ([pad_token] * padding_length)
                 _A    =       attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)

             if len(snake_case_       ) != batch_length:
                 raise ValueError(F"Error with input length {len(snake_case_       )} vs {batch_length}"       )
             if len(snake_case_       ) != batch_length:
                 raise ValueError(F"Error with input length {len(snake_case_       )} vs {batch_length}"       )

             if self.mode == "classification":
                 _A    =       label_map[example.label]
             elif self.mode == "regression":
                 _A    =       float(example.label       )
             else:
                 raise ValueError(self.mode       )

             if ex_index < 5 and self.verbose:
                 logger.info('*** Example ***'       )
                 logger.info(F"guid: {example.guid}"       )
                 logger.info(F"input_ids: {' '.join([str(snake_case_       ) for x in input_ids]       )}"       )
                 logger.info(F"attention_mask: {' '.join([str(snake_case_       ) for x in attention_mask]       )}"       )
                 logger.info(F"label: {example.label} (id = {label})"       )

             features.append(InputFeatures(input_ids=snake_case_							,    attention_mask=snake_case_							,    label=snake_case_       )       )

         if return_tensors is None:
             return features
         elif return_tensors == "tf":
             if not is_tf_available():
                 raise RuntimeError('return_tensors set to \'tf\' but TensorFlow 2.0 can\'t be imported'       )
             import tensorflow as tf

             def gen():
                 for ex in features:
                     yield ({"input_ids": ex.input_ids, "attention_mask": ex.attention_mask}, ex.label)

             _A    =       tf.data.Dataset.from_generator(
                 snake_case_							,    ({'input_ids': tf.intaa, 'attention_mask': tf.intaa}, tf.intaa)							,    ({'input_ids': tf.TensorShape([None]       ), 'attention_mask': tf.TensorShape([None]       )}, tf.TensorShape([]       ))							,    )
             return dataset
         elif return_tensors == "pt":
             if not is_torch_available():
                 raise RuntimeError('return_tensors set to \'pt\' but PyTorch can\'t be imported'       )
             import torch
             from torch.utils.data import TensorDataset

             _A    =       torch.tensor([f.input_ids for f in features]							,    dtype=torch.long       )
             _A    =       torch.tensor([f.attention_mask for f in features]							,    dtype=torch.long       )
             if self.mode == "classification":
                 _A    =       torch.tensor([f.label for f in features]							,    dtype=torch.long       )
             elif self.mode == "regression":
                 _A    =       torch.tensor([f.label for f in features]							,    dtype=torch.float       )

             _A    =       TensorDataset(snake_case_							,    snake_case_							,    snake_case_       )
             return dataset
         else:
             raise ValueError('return_tensors should be one of \'tf\' or \'pt\''       )





