






import re
import string

import numpy as np

import datasets


a		:       List[Any]			     = "\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n"

a		:       Dict			     = "\nArgs:\n    predictions: List of predicted texts.\n    references: List of reference texts.\n    regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n        ignore when calculating the exact matches. Note: these regexes are removed\n        from the input data before the changes based on the options below (e.g. ignore_case,\n        ignore_punctuation, ignore_numbers) are applied.\n    ignore_case: Boolean, defaults to False. If true, turns everything\n        to lowercase so that capitalization differences are ignored.\n    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\n    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\nReturns:\n    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.\nExamples:\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]\n    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results[\"exact_match\"], 1))\n    25.0\n\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]\n    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results[\"exact_match\"], 1))\n    50.0\n\n\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]\n    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\", \"YELL\"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results[\"exact_match\"], 1))\n    75.0\n\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]\n    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\", \"YELL\"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n    >>> print(round(results[\"exact_match\"], 1))\n    100.0\n\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"The cat sat on the mat.\", \"Theaters are great.\", \"It's like comparing oranges and apples.\"]\n    >>> preds = [\"The cat sat on the mat?\", \"Theaters are great.\", \"It's like comparing apples and oranges.\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results[\"exact_match\"], 1))\n    33.3\n\n"

a		:       Any			     = "\n"
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,       _KWARGS_DESCRIPTION   )
class     a    ( datasets.Metric   ):



      """simple docstring"""


      def 	UpperCAmelCase      (      self					:			Optional[Any]					)							->      Optional[int]:
        return datasets.MetricInfo(
            description=_DESCRIPTION		,      citation=_CITATION		,      inputs_description=_KWARGS_DESCRIPTION		,      features=datasets.Features(
                {
                    """predictions""": datasets.Value("""string"""		,      id="""sequence"""					),
                    """references""": datasets.Value("""string"""		,      id="""sequence"""					),
                }					)		,      reference_urls=[]		,      )




      def 	UpperCAmelCase      (      self					:			str		,      __lowercase					:			int		,      __lowercase					:			List[str]		,      __lowercase					:			Dict=None		,      __lowercase					:			Optional[Any]=False		,      __lowercase					:			List[str]=False		,      __lowercase					:			Any=False		,      )							->      Optional[Any]:
        if regexes_to_ignore is not None:
          for s in regexes_to_ignore:
            __UpperCAmelCase							:	str           =  np.array([re.sub(__lowercase		,      """"""		,      __lowercase					) for x in predictions]					)
            __UpperCAmelCase							:	int           =  np.array([re.sub(__lowercase		,      """"""		,      __lowercase					) for x in references]					)
        else:
          __UpperCAmelCase							:	List[Any]           =  np.asarray(__lowercase					)
          __UpperCAmelCase							:	Dict           =  np.asarray(__lowercase					)

        if ignore_case:
          __UpperCAmelCase							:	Any           =  np.char.lower(__lowercase					)
          __UpperCAmelCase							:	Dict           =  np.char.lower(__lowercase					)

        if ignore_punctuation:
          __UpperCAmelCase							:	Any           =  string.punctuation.maketrans(""""""		,      """"""		,      string.punctuation					)
          __UpperCAmelCase							:	str           =  np.char.translate(__lowercase		,      table=__lowercase					)
          __UpperCAmelCase							:	Optional[int]           =  np.char.translate(__lowercase		,      table=__lowercase					)

        if ignore_numbers:
          __UpperCAmelCase							:	Optional[int]           =  string.digits.maketrans(""""""		,      """"""		,      string.digits					)
          __UpperCAmelCase							:	Optional[Any]           =  np.char.translate(__lowercase		,      table=__lowercase					)
          __UpperCAmelCase							:	str           =  np.char.translate(__lowercase		,      table=__lowercase					)

        __UpperCAmelCase							:	List[str]           =  predictions == references

        return {"exact_match": np.mean(__lowercase					) * 100}










from typing import Mapping

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


a		:       Tuple			     = logging.get_logger(__name__)

a		:       Dict			     = {
    "t5-small": "https://huggingface.co/t5-small/resolve/main/config.json",
    "t5-base": "https://huggingface.co/t5-base/resolve/main/config.json",
    "t5-large": "https://huggingface.co/t5-large/resolve/main/config.json",
    "t5-3b": "https://huggingface.co/t5-3b/resolve/main/config.json",
    "t5-11b": "https://huggingface.co/t5-11b/resolve/main/config.json",
}
class     a    ( lowercase__   ):



      """simple docstring"""


      a  : int							       =	't5'
      a  : Dict							       =	['past_key_values']
      a  : Tuple							       =	{'hidden_size': 'd_model', 'num_attention_heads': 'num_heads', 'num_hidden_layers': 'num_layers'}
      def __init__(      self					:			str		,      __lowercase					:			Optional[int]=32128		,      __lowercase					:			Optional[int]=512		,      __lowercase					:			int=64		,      __lowercase					:			Any=2048		,      __lowercase					:			Tuple=6		,      __lowercase					:			Tuple=None		,      __lowercase					:			int=8		,      __lowercase					:			List[Any]=32		,      __lowercase					:			Dict=128		,      __lowercase					:			Optional[int]=0.1		,      __lowercase					:			int=1e-6		,      __lowercase					:			List[str]=1.0		,      __lowercase					:			List[str]="relu"		,      __lowercase					:			Dict=True		,      __lowercase					:			Optional[Any]=True		,      __lowercase					:			Tuple=0		,      __lowercase					:			List[str]=1		,      **__lowercase					:			Any		,      )							->      str:
        __UpperCAmelCase							:	Tuple           =  vocab_size
        __UpperCAmelCase							:	Optional[int]           =  d_model
        __UpperCAmelCase							:	Union[str, Any]           =  d_kv
        __UpperCAmelCase							:	Union[str, Any]           =  d_ff
        __UpperCAmelCase							:	int           =  num_layers
        __UpperCAmelCase							:	Any           =  (
            num_decoder_layers if num_decoder_layers is not None else self.num_layers
        )  # default = symmetry
        __UpperCAmelCase							:	Dict           =  num_heads
        __UpperCAmelCase							:	List[Any]           =  relative_attention_num_buckets
        __UpperCAmelCase							:	List[str]           =  relative_attention_max_distance
        __UpperCAmelCase							:	Union[str, Any]           =  dropout_rate
        __UpperCAmelCase							:	List[str]           =  layer_norm_epsilon
        __UpperCAmelCase							:	str           =  initializer_factor
        __UpperCAmelCase							:	Dict           =  feed_forward_proj
        __UpperCAmelCase							:	Optional[int]           =  use_cache

        __UpperCAmelCase							:	List[Any]           =  self.feed_forward_proj.split("""-"""					)
        __UpperCAmelCase							:	Tuple           =  act_info[-1]
        __UpperCAmelCase							:	int           =  act_info[0] == """gated"""

        if len(__lowercase					) > 1 and act_info[0] != "gated" or len(__lowercase					) > 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":
          __UpperCAmelCase							:	Dict           =  """gelu_new"""

        super().__init__(
            pad_token_id=__lowercase		,      eos_token_id=__lowercase		,      is_encoder_decoder=__lowercase		,      **__lowercase		,      )


class     a    ( lowercase__   ):



      """simple docstring"""


      @property
      def 	UpperCAmelCase      (      self					:			str					)							->      Mapping[str, Mapping[int, str]]:
        __UpperCAmelCase							:	Union[str, Any]           =  {
            """input_ids""": {0: """batch""", 1: """encoder_sequence"""},
            """attention_mask""": {0: """batch""", 1: """encoder_sequence"""},
        }
        if self.use_past:
          __UpperCAmelCase							:	List[Any]           =  """past_encoder_sequence + sequence"""
          __UpperCAmelCase							:	Optional[int]           =  {0: """batch"""}
          __UpperCAmelCase							:	Union[str, Any]           =  {0: """batch""", 1: """past_decoder_sequence + sequence"""}
        else:
          __UpperCAmelCase							:	str           =  {0: """batch""", 1: """decoder_sequence"""}
          __UpperCAmelCase							:	str           =  {0: """batch""", 1: """decoder_sequence"""}

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

        return common_inputs




      @property
      def 	UpperCAmelCase      (      self					:			int					)							->      int:
        return 13


