



"""simple docstring"""






from sklearn.metrics import accuracy_score

import datasets


_lowercase					:					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"


_lowercase					:					str 		=		"\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"


_lowercase					:					Optional[Any] 		=		"\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 			__SCREAMING_SNAKE_CASE      ( datasets.Metric  ):


					'''simple docstring'''





					def 						snake_case			(			self				:    Dict	)->   int:
								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 						snake_case			(			self				:    str,    lowerCamelCase				:    List[str],    lowerCamelCase				:    str,    lowerCamelCase				:    List[Any]=True,    lowerCamelCase				:    int=None	)->   Union[str, Any]:
								return {
								    "accuracy": float(
								        accuracy_score(lowerCamelCase,    lowerCamelCase,    normalize=lowerCamelCase,    sample_weight=lowerCamelCase	)	)
								}






'''simple docstring'''
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...file_utils import TensorType, is_torch_available
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


a_           =    logging.get_logger(__name__)

a_           =    {
    "facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/config.json",
    # See all Blenderbot models at https://huggingface.co/models?filter=blenderbot
}






class  UpperCAmelCase_					(						snake_case__       ):
 UpperCAmelCase_		     =    """blenderbot"""
 UpperCAmelCase_		     =    ["""past_key_values"""]
 UpperCAmelCase_		     =    {"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}





 def __init__(     self			,							lowercase_=80_08			,							lowercase_=1_28			,							lowercase_=2			,							lowercase_=1_02_40			,							lowercase_=32			,							lowercase_=24			,							lowercase_=1_02_40			,							lowercase_=32			,							lowercase_=0.0			,							lowercase_=0.0			,							lowercase_=True			,							lowercase_=True			,							lowercase_="gelu"			,							lowercase_=25_60			,							lowercase_=0.1			,							lowercase_=0.0			,							lowercase_=0.0			,							lowercase_=0.02			,							lowercase_=1			,							lowercase_=False			,							lowercase_=0			,							lowercase_=1			,							lowercase_=2			,							lowercase_=3			,							lowercase_=2			,							**lowercase_			,							):
     snake_case_			:     str        =    vocab_size
     snake_case_			:     str        =    max_position_embeddings
     snake_case_			:     Optional[Any]        =    d_model
     snake_case_			:     Any        =    encoder_ffn_dim
     snake_case_			:     Optional[Any]        =    encoder_layers
     snake_case_			:     List[Any]        =    encoder_attention_heads
     snake_case_			:     List[Any]        =    decoder_ffn_dim
     snake_case_			:     Optional[int]        =    decoder_layers
     snake_case_			:     Optional[int]        =    decoder_attention_heads
     snake_case_			:     Any        =    dropout
     snake_case_			:     List[str]        =    attention_dropout
     snake_case_			:     int        =    activation_dropout
     snake_case_			:     Dict        =    activation_function
     snake_case_			:     Any        =    init_std
     snake_case_			:     Union[str, Any]        =    encoder_layerdrop
     snake_case_			:     Optional[int]        =    decoder_layerdrop
     snake_case_			:     Any        =    use_cache
     snake_case_			:     List[str]        =    encoder_layers
     snake_case_			:     str        =    scale_embedding  # scale factor will be sqrt(d_model) if True

     super().__init__(
         pad_token_id=lowercase_			,							bos_token_id=lowercase_			,							eos_token_id=lowercase_			,							is_encoder_decoder=lowercase_			,							decoder_start_token_id=lowercase_			,							encoder_no_repeat_ngram_size=lowercase_			,							forced_eos_token_id=lowercase_			,							**lowercase_			,							)






class  UpperCAmelCase_					(						snake_case__       ):





 @property
 def 							snake_case__		(     self):
     if self.task in ["default", "seq2seq-lm"]:
         snake_case_			:     int        =    OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ])
         if self.use_past:
             snake_case_			:     Any        =    {0: "batch"}
             snake_case_			:     Optional[int]        =    {0: "batch", 1: "past_decoder_sequence + sequence"}
         else:
             snake_case_			:     int        =    {0: "batch", 1: "decoder_sequence"}
             snake_case_			:     int        =    {0: "batch", 1: "decoder_sequence"}
         if self.use_past:
             self.fill_with_past_key_values_(lowercase_			,							direction="inputs")
     elif self.task == "causal-lm":
         snake_case_			:     Tuple        =    OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
             ])
         if self.use_past:
             snake_case_      ,			snake_case_			:     Any        =    self.num_layers
             for i in range(lowercase_):
                 snake_case_			:     Dict        =    {0: "batch", 2: "past_sequence + sequence"}
                 snake_case_			:     Dict        =    {0: "batch", 2: "past_sequence + sequence"}
     else:
         snake_case_			:     str        =    OrderedDict(
             [
                 ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                 ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                 ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
                 ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
             ])

     return common_inputs





 @property
 # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
 def 							snake_case__		(     self):
     if self.task in ["default", "seq2seq-lm"]:
         snake_case_			:     Optional[int]        =    super().outputs
     else:
         snake_case_			:     Dict        =    super(lowercase_			,							self).outputs
         if self.use_past:
             snake_case_      ,			snake_case_			:     Any        =    self.num_layers
             for i in range(lowercase_):
                 snake_case_			:     str        =    {0: "batch", 2: "past_sequence + sequence"}
                 snake_case_			:     int        =    {0: "batch", 2: "past_sequence + sequence"}
     return common_outputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_ = -1			,							lowercase_ = -1			,							lowercase_ = False			,							lowercase_ = None			,							):
     snake_case_			:     List[Any]        =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)
     # Generate decoder inputs
     snake_case_			:     int        =    seq_length if not self.use_past else 1
     snake_case_			:     List[str]        =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)
     snake_case_			:     str        =    {F'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
     snake_case_			:     Any        =    dict(**lowercase_			,							**lowercase_)

     if self.use_past:
         if not is_torch_available():
             raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
         else:
             import torch
         snake_case_      ,			snake_case_			:     int        =    common_inputs["input_ids"].shape
         snake_case_			:     str        =    common_inputs["decoder_input_ids"].shape[1]
         snake_case_      ,			snake_case_			:     Tuple        =    self.num_attention_heads
         snake_case_			:     str        =    (
             batch,
             num_encoder_attention_heads,
             encoder_seq_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )
         snake_case_			:     Dict        =    decoder_seq_length
         snake_case_			:     List[Any]        =    (
             batch,
             num_decoder_attention_heads,
             decoder_past_length,
             self._config.hidden_size // num_decoder_attention_heads,
         )
         snake_case_			:     Optional[Any]        =    torch.cat(
             [common_inputs["decoder_attention_mask"], torch.ones(lowercase_			,							lowercase_)]			,							dim=1)
         snake_case_			:     Tuple        =    []
         snake_case_      ,			snake_case_			:     Tuple        =    self.num_layers

         for _ in range(lowercase_):
             common_inputs["past_key_values"].append(
                 (
                     torch.zeros(lowercase_),
                     torch.zeros(lowercase_),
                     torch.zeros(lowercase_),
                     torch.zeros(lowercase_),
                 ))
     return common_inputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_ = -1			,							lowercase_ = -1			,							lowercase_ = False			,							lowercase_ = None			,							):
     snake_case_			:     str        =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)

     if self.use_past:
         if not is_torch_available():
             raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
         else:
             import torch
         snake_case_      ,			snake_case_			:     Optional[Any]        =    common_inputs["input_ids"].shape
         snake_case_			:     List[str]        =    seqlen
         snake_case_      ,			snake_case_			:     Optional[int]        =    self.num_layers
         snake_case_      ,			snake_case_			:     Union[str, Any]        =    self.num_attention_heads
         snake_case_			:     Optional[int]        =    (
             batch,
             num_encoder_attention_heads,
             past_key_values_length,
             self._config.hidden_size // num_encoder_attention_heads,
         )
         snake_case_			:     Dict        =    common_inputs["attention_mask"].dtype
         snake_case_			:     Optional[Any]        =    torch.cat(
             [common_inputs["attention_mask"], torch.ones(lowercase_			,							lowercase_			,							dtype=lowercase_)]			,							dim=1)
         snake_case_			:     Tuple        =    [
             (torch.zeros(lowercase_), torch.zeros(lowercase_)) for _ in range(lowercase_)
         ]
     return common_inputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_ = -1			,							lowercase_ = -1			,							lowercase_ = False			,							lowercase_ = None			,							):
     # Copied from OnnxConfig.generate_dummy_inputs
     # Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
     # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
     snake_case_			:     Any        =    compute_effective_axis_dimension(
         lowercase_			,							fixed_dimension=OnnxConfig.default_fixed_batch			,							num_token_to_add=0)

     # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
     snake_case_			:     Tuple        =    tokenizer.num_special_tokens_to_add(lowercase_)
     snake_case_			:     Tuple        =    compute_effective_axis_dimension(
         lowercase_			,							fixed_dimension=OnnxConfig.default_fixed_sequence			,							num_token_to_add=lowercase_)

     # Generate dummy inputs according to compute batch and sequence
     snake_case_			:     Optional[int]        =    [" ".join([tokenizer.unk_token]) * seq_length] * batch_size
     snake_case_			:     Tuple        =    dict(tokenizer(lowercase_			,							return_tensors=lowercase_))
     return common_inputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_ = -1			,							lowercase_ = -1			,							lowercase_ = False			,							lowercase_ = None			,							):
     if self.task in ["default", "seq2seq-lm"]:
         snake_case_			:     Optional[Any]        =    self._generate_dummy_inputs_for_default_and_seqaseq_lm(
             lowercase_			,							batch_size=lowercase_			,							seq_length=lowercase_			,							is_pair=lowercase_			,							framework=lowercase_)

     elif self.task == "causal-lm":
         snake_case_			:     Dict        =    self._generate_dummy_inputs_for_causal_lm(
             lowercase_			,							batch_size=lowercase_			,							seq_length=lowercase_			,							is_pair=lowercase_			,							framework=lowercase_)
     else:
         snake_case_			:     Dict        =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             lowercase_			,							batch_size=lowercase_			,							seq_length=lowercase_			,							is_pair=lowercase_			,							framework=lowercase_)

     return common_inputs





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_			,							lowercase_			,							lowercase_):
     if self.task in ["default", "seq2seq-lm"]:
         snake_case_			:     int        =    super()._flatten_past_key_values_(lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)
     else:
         snake_case_			:     List[Any]        =    super(lowercase_			,							self)._flatten_past_key_values_(
             lowercase_			,							lowercase_			,							lowercase_			,							lowercase_)





 def 							snake_case__		(     self			,							lowercase_			,							lowercase_):
     if direction not in ["inputs", "outputs"]:
         raise ValueError(F'direction must either be "inputs" or "outputs", but {direction} was given')

     snake_case_			:     Union[str, Any]        =    "past_key_values" if direction == "inputs" else "present"
     snake_case_      ,			snake_case_			:     Union[str, Any]        =    self.num_layers

     snake_case_			:     List[Any]        =    "past_encoder_sequence"
     snake_case_			:     str        =    "past_decoder_sequence" if direction == "inputs" else "past_decoder_sequence + sequence"

     for i in range(lowercase_):
         snake_case_			:     Union[str, Any]        =    {0: "batch", 2: decoder_sequence}
         snake_case_			:     str        =    {0: "batch", 2: decoder_sequence}
         snake_case_			:     Any        =    {0: "batch", 2: encoder_sequence}
         snake_case_			:     Dict        =    {0: "batch", 2: encoder_sequence}




