

from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxSeqaSeqConfigWithPast
from ...utils import logging


A__										=      logging.get_logger(__name__)







class  UpperCamelCase_      (	_snake_case      ):


  """simple docstring"""
  SCREAMING_SNAKE_CASE__					:			List[Any]					    =   """mt5"""
  SCREAMING_SNAKE_CASE__					:			Dict					    =   ["""past_key_values"""]



  def __init__(						self     :					Optional[int]  ,	A_     :					Optional[int]=25_0112  ,	A_     :					Optional[int]=512  ,	A_     :					Union[str, Any]=64  ,	A_     :					Optional[int]=1024  ,	A_     :					Dict=8  ,	A_     :					str=None  ,	A_     :					Tuple=6  ,	A_     :					Union[str, Any]=32  ,	A_     :					List[Any]=128  ,	A_     :					Optional[Any]=0.1  ,	A_     :					Optional[int]=1E-6  ,	A_     :					str=1.0  ,	A_     :					Optional[int]="gated-gelu"  ,	A_     :					Union[str, Any]=True  ,	A_     :					Dict=True  ,	A_     :					List[Any]="T5Tokenizer"  ,	A_     :					List[Any]=False  ,	A_     :					List[str]=0  ,	A_     :					List[str]=1  ,	A_     :					Optional[Any]=0  ,	**A_     :					List[str]  ,	)       ->			List[str]:
      super().__init__(
          is_encoder_decoder=A_  ,	tokenizer_class=A_  ,	tie_word_embeddings=A_  ,	pad_token_id=A_  ,	eos_token_id=A_  ,	decoder_start_token_id=A_  ,	**A_  ,	)
      SCREAMING_SNAKE_CASE__         =    vocab_size
      SCREAMING_SNAKE_CASE__         =    d_model
      SCREAMING_SNAKE_CASE__         =    d_kv
      SCREAMING_SNAKE_CASE__         =    d_ff
      SCREAMING_SNAKE_CASE__         =    num_layers
      SCREAMING_SNAKE_CASE__         =    (
          num_decoder_layers if num_decoder_layers is not None else self.num_layers
      )  # default = symmetry
      SCREAMING_SNAKE_CASE__         =    num_heads
      SCREAMING_SNAKE_CASE__         =    relative_attention_num_buckets
      SCREAMING_SNAKE_CASE__         =    relative_attention_max_distance
      SCREAMING_SNAKE_CASE__         =    dropout_rate
      SCREAMING_SNAKE_CASE__         =    layer_norm_epsilon
      SCREAMING_SNAKE_CASE__         =    initializer_factor
      SCREAMING_SNAKE_CASE__         =    feed_forward_proj
      SCREAMING_SNAKE_CASE__         =    use_cache

      SCREAMING_SNAKE_CASE__         =    self.feed_forward_proj.split("-"						)
      SCREAMING_SNAKE_CASE__         =    act_info[-1]
      SCREAMING_SNAKE_CASE__         =    act_info[0] == "gated"

      if len(A_						) > 1 and act_info[0] != "gated" or len(A_						) > 2:
          raise ValueError(
              f"`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer."
              "Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. "
              "'gated-gelu' or 'relu'"						)

      # for backwards compatibility
      if feed_forward_proj == "gated-gelu":
          SCREAMING_SNAKE_CASE__         =    "gelu_new"



  @property
  def   _UpperCamelCase     (						self     :					Optional[int]						)       ->			int:
      return self.d_model



  @property
  def   _UpperCamelCase     (						self     :					int						)       ->			Any:
      return self.num_heads







  @property
  def   _UpperCamelCase     (						self     :					Optional[int]						)       ->			List[Any]:
      return self.num_layers







class  UpperCamelCase_      (	_snake_case      ):


  """simple docstring"""



  @property
  # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.inputs
  def   _UpperCamelCase     (						self     :					int						)       ->			Mapping[str, Mapping[int, str]]:
      SCREAMING_SNAKE_CASE__         =    {
          "input_ids": {0: "batch", 1: "encoder_sequence"},
          "attention_mask": {0: "batch", 1: "encoder_sequence"},
      }
      if self.use_past:
          SCREAMING_SNAKE_CASE__         =    "past_encoder_sequence + sequence"
          SCREAMING_SNAKE_CASE__         =    {0: "batch"}
          SCREAMING_SNAKE_CASE__         =    {0: "batch", 1: "past_decoder_sequence + sequence"}
      else:
          SCREAMING_SNAKE_CASE__         =    {0: "batch", 1: "decoder_sequence"}
          SCREAMING_SNAKE_CASE__         =    {0: "batch", 1: "decoder_sequence"}

      if self.use_past:
          self.fill_with_past_key_values_(A_  ,	direction="inputs"						)

      return common_inputs



  @property
  # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.default_onnx_opset
  def   _UpperCamelCase     (						self     :					List[Any]						)       ->			int:
      return 13







  @property
  def   _UpperCamelCase     (						self     :					Any						)       ->			float:
      return 5E-4





from sklearn.metrics import accuracy_score

import datasets


A__										=      "\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__										=      "\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__										=      "\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  UpperCamelCase_      (	datasets.Metric      ):


  """simple docstring"""



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


