

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     : str       =						logging.get_logger(__name__)


__lowercase     : Any       =						{
    '''Salesforce/codegen-350M-nl''': '''https://huggingface.co/Salesforce/codegen-350M-nl/resolve/main/config.json''',
    '''Salesforce/codegen-350M-multi''': '''https://huggingface.co/Salesforce/codegen-350M-multi/resolve/main/config.json''',
    '''Salesforce/codegen-350M-mono''': '''https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/config.json''',
    '''Salesforce/codegen-2B-nl''': '''https://huggingface.co/Salesforce/codegen-2B-nl/resolve/main/config.json''',
    '''Salesforce/codegen-2B-multi''': '''https://huggingface.co/Salesforce/codegen-2B-multi/resolve/main/config.json''',
    '''Salesforce/codegen-2B-mono''': '''https://huggingface.co/Salesforce/codegen-2B-mono/resolve/main/config.json''',
    '''Salesforce/codegen-6B-nl''': '''https://huggingface.co/Salesforce/codegen-6B-nl/resolve/main/config.json''',
    '''Salesforce/codegen-6B-multi''': '''https://huggingface.co/Salesforce/codegen-6B-multi/resolve/main/config.json''',
    '''Salesforce/codegen-6B-mono''': '''https://huggingface.co/Salesforce/codegen-6B-mono/resolve/main/config.json''',
    '''Salesforce/codegen-16B-nl''': '''https://huggingface.co/Salesforce/codegen-16B-nl/resolve/main/config.json''',
    '''Salesforce/codegen-16B-multi''': '''https://huggingface.co/Salesforce/codegen-16B-multi/resolve/main/config.json''',
    '''Salesforce/codegen-16B-mono''': '''https://huggingface.co/Salesforce/codegen-16B-mono/resolve/main/config.json''',
}



class 						_A     (				snake_case				):





  '''simple docstring'''



  __lowerCamelCase			:      List[Any]					=   '''codegen'''
  __lowerCamelCase			:      str					=   {
      '''max_position_embeddings''': '''n_positions''',
      '''hidden_size''': '''n_embd''',
      '''num_attention_heads''': '''n_head''',
      '''num_hidden_layers''': '''n_layer''',
  }





  def __init__(  self   ,SCREAMING_SNAKE_CASE_=50400   ,SCREAMING_SNAKE_CASE_=2048   ,SCREAMING_SNAKE_CASE_=2048   ,SCREAMING_SNAKE_CASE_=4096   ,SCREAMING_SNAKE_CASE_=28   ,SCREAMING_SNAKE_CASE_=16   ,SCREAMING_SNAKE_CASE_=64   ,SCREAMING_SNAKE_CASE_=None   ,SCREAMING_SNAKE_CASE_="gelu_new"   ,SCREAMING_SNAKE_CASE_=0.0   ,SCREAMING_SNAKE_CASE_=0.0   ,SCREAMING_SNAKE_CASE_=0.0   ,SCREAMING_SNAKE_CASE_=1E-5   ,SCREAMING_SNAKE_CASE_=0.02   ,SCREAMING_SNAKE_CASE_=True   ,SCREAMING_SNAKE_CASE_=50256   ,SCREAMING_SNAKE_CASE_=50256   ,SCREAMING_SNAKE_CASE_=False   ,**SCREAMING_SNAKE_CASE_   ,):

      '''simple docstring'''
      snake_case							:		Union[str, Any]        =		vocab_size
      snake_case							:		List[str]        =		n_ctx
      snake_case							:		str        =		n_positions
      snake_case							:		Tuple        =		n_embd
      snake_case							:		List[Any]        =		n_layer
      snake_case							:		Tuple        =		n_head
      snake_case							:		Any        =		n_inner
      snake_case							:		Union[str, Any]        =		rotary_dim
      snake_case							:		Union[str, Any]        =		activation_function
      snake_case							:		List[Any]        =		resid_pdrop
      snake_case							:		List[str]        =		embd_pdrop
      snake_case							:		str        =		attn_pdrop
      snake_case							:		Tuple        =		layer_norm_epsilon
      snake_case							:		int        =		initializer_range
      snake_case							:		int        =		use_cache

      snake_case							:		int        =		bos_token_id
      snake_case							:		str        =		eos_token_id

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







class 						_A     (				snake_case				):





  '''simple docstring'''



  def __init__(  self   ,SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_ = "default"   ,SCREAMING_SNAKE_CASE_ = None   ,SCREAMING_SNAKE_CASE_ = False   ,):

      '''simple docstring'''
      super().__init__(SCREAMING_SNAKE_CASE_   ,task=SCREAMING_SNAKE_CASE_   ,patching_specs=SCREAMING_SNAKE_CASE_   ,use_past=SCREAMING_SNAKE_CASE_    )
      if not getattr(self._config   ,"""pad_token_id"""   ,SCREAMING_SNAKE_CASE_    ):
          # TODO: how to do that better?
          snake_case							:		Optional[Any]        =		0





  @property
  def    snake_case_       (  self    ):

      '''simple docstring'''
      snake_case							:		int        =		OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}}    )
      if self.use_past:
          self.fill_with_past_key_values_(SCREAMING_SNAKE_CASE_   ,direction="""inputs"""    )
          snake_case							:		Dict        =		{0: """batch""", 1: """past_sequence + sequence"""}
      else:
          snake_case							:		Optional[Any]        =		{0: """batch""", 1: """sequence"""}

      return common_inputs





  @property
  def    snake_case_       (  self    ):

      '''simple docstring'''
      return self._config.n_layer





  @property
  def    snake_case_       (  self    ):

      '''simple docstring'''
      return self._config.n_head





  def    snake_case_       (  self   ,SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_ = -1   ,SCREAMING_SNAKE_CASE_ = -1   ,SCREAMING_SNAKE_CASE_ = False   ,SCREAMING_SNAKE_CASE_ = None   ,):

      '''simple docstring'''
      snake_case							:		List[str]        =		super(SCREAMING_SNAKE_CASE_   ,self    ).generate_dummy_inputs(
          SCREAMING_SNAKE_CASE_   ,batch_size=SCREAMING_SNAKE_CASE_   ,seq_length=SCREAMING_SNAKE_CASE_   ,is_pair=SCREAMING_SNAKE_CASE_   ,framework=SCREAMING_SNAKE_CASE_    )

      # We need to order the input in the way they appears in the forward()
      snake_case							:		Any        =		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

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

      snake_case							:		Tuple        =		common_inputs["""attention_mask"""]
      if self.use_past:
          snake_case							:		Dict        =		ordered_inputs["""attention_mask"""].dtype
          snake_case							:		Any        =		torch.cat(
              [ordered_inputs["""attention_mask"""], torch.ones(SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_   ,dtype=SCREAMING_SNAKE_CASE_    )]   ,dim=1    )

      return ordered_inputs





  @property
  def    snake_case_       (  self    ):

      '''simple docstring'''
      return 13





'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase     :							Tuple       						=     {
    'configuration_luke': ['LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LukeConfig'],
    'tokenization_luke': ['LukeTokenizer'],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase     :							int       						=     [
          'LUKE_PRETRAINED_MODEL_ARCHIVE_LIST',
          'LukeForEntityClassification',
          'LukeForEntityPairClassification',
          'LukeForEntitySpanClassification',
          'LukeForMultipleChoice',
          'LukeForQuestionAnswering',
          'LukeForSequenceClassification',
          'LukeForTokenClassification',
          'LukeForMaskedLM',
          'LukeModel',
          'LukePreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig
      from .tokenization_luke import LukeTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_luke import (
                LUKE_PRETRAINED_MODEL_ARCHIVE_LIST,
                LukeForEntityClassification,
                LukeForEntityPairClassification,
                LukeForEntitySpanClassification,
                LukeForMaskedLM,
                LukeForMultipleChoice,
                LukeForQuestionAnswering,
                LukeForSequenceClassification,
                LukeForTokenClassification,
                LukeModel,
                LukePreTrainedModel,
            )

else:
      import sys

      lowercase     :							Dict       						=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




