






from typing import Mapping

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


A_	:	Dict				=				logging.get_logger(__name__)




class        _lowerCAmelCase( UpperCAmelCase_      ):





       """simple docstring"""







       a       :	Any								='''mt5'''
       a       :	Union[str, Any]								=['''past_key_values''']





       def __init__(      self						,    _lowerCamelCase=2_5_0_1_1_2						,    _lowerCamelCase=5_1_2						,    _lowerCamelCase=6_4						,    _lowerCamelCase=1_0_2_4						,    _lowerCamelCase=8						,    _lowerCamelCase=None						,    _lowerCamelCase=6						,    _lowerCamelCase=3_2						,    _lowerCamelCase=1_2_8						,    _lowerCamelCase=0.1						,    _lowerCamelCase=1e-6						,    _lowerCamelCase=1.0						,    _lowerCamelCase="gated-gelu"						,    _lowerCamelCase=True						,    _lowerCamelCase=True						,    _lowerCamelCase="T5Tokenizer"						,    _lowerCamelCase=False						,    _lowerCamelCase=0						,    _lowerCamelCase=1						,    _lowerCamelCase=0						,    **_lowerCamelCase						,    ):
         super().__init__(
             is_encoder_decoder=_lowerCamelCase						,    tokenizer_class=_lowerCamelCase						,    tie_word_embeddings=_lowerCamelCase						,    pad_token_id=_lowerCamelCase						,    eos_token_id=_lowerCamelCase						,    decoder_start_token_id=_lowerCamelCase						,    **_lowerCamelCase						,    )
         UpperCamelCase_:      Optional[Any]					   =       vocab_size
         UpperCamelCase_:      Union[str, Any]					   =       d_model
         UpperCamelCase_:      Tuple					   =       d_kv
         UpperCamelCase_:      int					   =       d_ff
         UpperCamelCase_:      Dict					   =       num_layers
         UpperCamelCase_:      Any					   =       (
             num_decoder_layers if num_decoder_layers is not None else self.num_layers
         )  # default = symmetry
         UpperCamelCase_:      Tuple					   =       num_heads
         UpperCamelCase_:      List[Any]					   =       relative_attention_num_buckets
         UpperCamelCase_:      int					   =       relative_attention_max_distance
         UpperCamelCase_:      Any					   =       dropout_rate
         UpperCamelCase_:      Tuple					   =       layer_norm_epsilon
         UpperCamelCase_:      str					   =       initializer_factor
         UpperCamelCase_:      Dict					   =       feed_forward_proj
         UpperCamelCase_:      str					   =       use_cache

         UpperCamelCase_:      Optional[Any]					   =       self.feed_forward_proj.split('-'							)
         UpperCamelCase_:      Optional[Any]					   =       act_info[-1]
         UpperCamelCase_:      Dict					   =       act_info[0] == 'gated'

         if len(_lowerCamelCase							) > 1 and act_info[0] != "gated" or len(_lowerCamelCase							) > 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_:      List[str]					   =       'gelu_new'





       @property
       def     _a					(      self							):
         return self.d_model





       @property
       def     _a					(      self							):
         return self.num_heads





       @property
       def     _a					(      self							):
         return self.num_layers







class        _lowerCAmelCase( UpperCAmelCase_      ):





       """simple docstring"""







       @property
       # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.inputs
       def     _a					(      self							):
         UpperCamelCase_:      Dict					   =       {
             'input_ids': {0: 'batch', 1: 'encoder_sequence'},
             'attention_mask': {0: 'batch', 1: 'encoder_sequence'},
         }
         if self.use_past:
           UpperCamelCase_:      Tuple					   =       'past_encoder_sequence + sequence'
           UpperCamelCase_:      List[Any]					   =       {0: 'batch'}
           UpperCamelCase_:      List[Any]					   =       {0: 'batch', 1: 'past_decoder_sequence + sequence'}
         else:
           UpperCamelCase_:      int					   =       {0: 'batch', 1: 'decoder_sequence'}
           UpperCamelCase_:      List[Any]					   =       {0: 'batch', 1: 'decoder_sequence'}

         if self.use_past:
           self.fill_with_past_key_values_(_lowerCamelCase						,    direction='inputs'							)

         return common_inputs





       @property
       # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.default_onnx_opset
       def     _a					(      self							):
         return 1_3





       @property
       def     _a					(      self							):
         return 5e-4







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


A_	:	List[Any]				=				{
    'configuration_openai': ['OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'OpenAIGPTConfig'],
    'tokenization_openai': ['OpenAIGPTTokenizer'],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_	:	List[str]				=				['OpenAIGPTTokenizerFast']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_	:	Any				=				[
       'OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'OpenAIGPTDoubleHeadsModel',
       'OpenAIGPTForSequenceClassification',
       'OpenAIGPTLMHeadModel',
       'OpenAIGPTModel',
       'OpenAIGPTPreTrainedModel',
       'load_tf_weights_in_openai_gpt',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_	:	str				=				[
       'TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFOpenAIGPTDoubleHeadsModel',
       'TFOpenAIGPTForSequenceClassification',
       'TFOpenAIGPTLMHeadModel',
       'TFOpenAIGPTMainLayer',
       'TFOpenAIGPTModel',
       'TFOpenAIGPTPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_openai import OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenAIGPTConfig
   from .tokenization_openai import OpenAIGPTTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_openai_fast import OpenAIGPTTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_openai import (
          OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
          OpenAIGPTDoubleHeadsModel,
          OpenAIGPTForSequenceClassification,
          OpenAIGPTLMHeadModel,
          OpenAIGPTModel,
          OpenAIGPTPreTrainedModel,
          load_tf_weights_in_openai_gpt,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_openai import (
          TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFOpenAIGPTDoubleHeadsModel,
          TFOpenAIGPTForSequenceClassification,
          TFOpenAIGPTLMHeadModel,
          TFOpenAIGPTMainLayer,
          TFOpenAIGPTModel,
          TFOpenAIGPTPreTrainedModel,
      )

else:
   import sys

   A_	:	str				=				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)