
from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


lowercase  :					Dict						    =							logging.get_logger(__name__)

lowercase  :					int						    =							{
    """EleutherAI/gpt-j-6B""": """https://huggingface.co/EleutherAI/gpt-j-6B/resolve/main/config.json""",
    # See all GPT-J models at https://huggingface.co/models?filter=gpt_j
}

class __snake_case		(      lowerCAmelCase     ):
    _a		:						Union[str, Any]=				"gptj"
    _a		:						Tuple=				{
        "max_position_embeddings": "n_positions",
        "hidden_size": "n_embd",
        "num_attention_heads": "n_head",
        "num_hidden_layers": "n_layer",
    }
    def __init__(  self		,snake_case=50400		,snake_case=2048		,snake_case=4096		,snake_case=28		,snake_case=16		,snake_case=64		,snake_case=None		,snake_case="gelu_new"		,snake_case=0.0		,snake_case=0.0		,snake_case=0.0		,snake_case=1e-5		,snake_case=0.02		,snake_case=True		,snake_case=50256		,snake_case=50256		,snake_case=False		,**snake_case		,):



           '''simple docstring'''







           lowercase							:     int       	=      vocab_size
           lowercase							:     Optional[Any]       	=      n_positions
           lowercase							:     Any       	=      n_embd
           lowercase							:     Tuple       	=      n_layer
           lowercase							:     Any       	=      n_head
           lowercase							:     List[Any]       	=      n_inner
           lowercase							:     Optional[Any]       	=      rotary_dim
           lowercase							:     List[str]       	=      activation_function
           lowercase							:     List[str]       	=      resid_pdrop
           lowercase							:     List[str]       	=      embd_pdrop
           lowercase							:     Optional[int]       	=      attn_pdrop
           lowercase							:     Optional[Any]       	=      layer_norm_epsilon
           lowercase							:     Tuple       	=      initializer_range
           lowercase							:     List[str]       	=      use_cache

           lowercase							:     Tuple       	=      bos_token_id
           lowercase							:     int       	=      eos_token_id

           super().__init__(
               bos_token_id=snake_case		,eos_token_id=snake_case		,tie_word_embeddings=snake_case		,**snake_case      )






class __snake_case		(      lowerCAmelCase     ):
    def __init__(  self		,snake_case		,snake_case = "default"		,snake_case = None		,snake_case = False		,):



           '''simple docstring'''







           super().__init__(snake_case		,task=snake_case		,patching_specs=snake_case		,use_past=snake_case      )
           if not getattr(self._config		,"""pad_token_id"""		,snake_case      ):
                  # TODO: how to do that better?
                  lowercase							:     List[Any]       	=      0
    @property
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[str]       	=      OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}}      )
           if self.use_past:
                  self.fill_with_past_key_values_(snake_case		,direction="""inputs"""      )
                  lowercase							:     Tuple       	=      {0: """batch""", 1: """past_sequence + sequence"""}
           else:
                  lowercase							:     str       	=      {0: """batch""", 1: """sequence"""}

           return common_inputs
    @property
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           return self._config.n_layer
    @property
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           return self._config.n_head
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case = -1		,snake_case = -1		,snake_case = False		,snake_case = None		,):



           '''simple docstring'''







           lowercase							:     Optional[Any]       	=      super(snake_case		,self      ).generate_dummy_inputs(
               snake_case		,batch_size=snake_case		,seq_length=snake_case		,is_pair=snake_case		,framework=snake_case      )

           # We need to order the input in the way they appears in the forward()
           lowercase							:     Tuple       	=      OrderedDict({"""input_ids""": common_inputs["""input_ids"""]}      )

           # Need to add the past_keys
           if self.use_past:
                  if not is_torch_available():
                         raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""      )
                  else:
                         import torch

                         lowercase	,			lowercase							:     Any       	=      common_inputs["""input_ids"""].shape
                         # Not using the same length for past_key_values
                         lowercase							:     Optional[int]       	=      seqlen + 2
                         lowercase							:     List[Any]       	=      (
                             batch,
                             self.num_attention_heads,
                             past_key_values_length,
                             self._config.hidden_size // self.num_attention_heads,
                         )
                         lowercase							:     Union[str, Any]       	=      [
                             (torch.zeros(snake_case      ), torch.zeros(snake_case      )) for _ in range(self.num_layers      )
                         ]

           lowercase							:     Optional[Any]       	=      common_inputs["""attention_mask"""]
           if self.use_past:
                  lowercase							:     Union[str, Any]       	=      ordered_inputs["""attention_mask"""].dtype
                  lowercase							:     Any       	=      torch.cat(
                      [ordered_inputs["""attention_mask"""], torch.ones(snake_case		,snake_case		,dtype=snake_case      )]		,dim=1      )

           return ordered_inputs
    @property
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           return 13


from typing import TYPE_CHECKING

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


lowercase  :					str						    =							{
    """configuration_funnel""": ["""FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FunnelConfig"""],
    """convert_funnel_original_tf_checkpoint_to_pytorch""": [],
    """tokenization_funnel""": ["""FunnelTokenizer"""],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase  :					Tuple						    =							["""FunnelTokenizerFast"""]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase  :					List[str]						    =							[
      """FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """FunnelBaseModel""",
      """FunnelForMaskedLM""",
      """FunnelForMultipleChoice""",
      """FunnelForPreTraining""",
      """FunnelForQuestionAnswering""",
      """FunnelForSequenceClassification""",
      """FunnelForTokenClassification""",
      """FunnelModel""",
      """FunnelPreTrainedModel""",
      """load_tf_weights_in_funnel""",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase  :					Optional[Any]						    =							[
      """TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFFunnelBaseModel""",
      """TFFunnelForMaskedLM""",
      """TFFunnelForMultipleChoice""",
      """TFFunnelForPreTraining""",
      """TFFunnelForQuestionAnswering""",
      """TFFunnelForSequenceClassification""",
      """TFFunnelForTokenClassification""",
      """TFFunnelModel""",
      """TFFunnelPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig
  from .tokenization_funnel import FunnelTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_funnel_fast import FunnelTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_funnel import (
        FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
        FunnelBaseModel,
        FunnelForMaskedLM,
        FunnelForMultipleChoice,
        FunnelForPreTraining,
        FunnelForQuestionAnswering,
        FunnelForSequenceClassification,
        FunnelForTokenClassification,
        FunnelModel,
        FunnelPreTrainedModel,
        load_tf_weights_in_funnel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_funnel import (
        TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFFunnelBaseModel,
        TFFunnelForMaskedLM,
        TFFunnelForMultipleChoice,
        TFFunnelForPreTraining,
        TFFunnelForQuestionAnswering,
        TFFunnelForSequenceClassification,
        TFFunnelForTokenClassification,
        TFFunnelModel,
        TFFunnelPreTrainedModel,
    )

else:
  import sys

  lowercase  :					Any						    =							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
