



"""simple docstring"""
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


_UpperCAmelCase     =			logging.get_logger(__name__)


_UpperCAmelCase     =			{
    """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	(  UpperCAmelCase__       ):
  UpperCamelCase	:				Optional[int]     						=					'codegen'
  UpperCamelCase	:				List[str]     						=					{
      'max_position_embeddings': 'n_positions',
      'hidden_size': 'n_embd',
      'num_attention_heads': 'n_head',
      'num_hidden_layers': 'n_layer',
  }



  def __init__(						self :					List[Any]       ,		lowerCAmelCase :					Union[str, Any]=5_0400       ,		lowerCAmelCase :					Tuple=2048       ,		lowerCAmelCase :					Dict=2048       ,		lowerCAmelCase :					List[Any]=4096       ,		lowerCAmelCase :					str=28       ,		lowerCAmelCase :					Union[str, Any]=16       ,		lowerCAmelCase :					Tuple=64       ,		lowerCAmelCase :					Optional[int]=None       ,		lowerCAmelCase :					List[str]="gelu_new"       ,		lowerCAmelCase :					int=0.0       ,		lowerCAmelCase :					Optional[int]=0.0       ,		lowerCAmelCase :					int=0.0       ,		lowerCAmelCase :					int=1E-5       ,		lowerCAmelCase :					Dict=0.0_2       ,		lowerCAmelCase :					Optional[Any]=True       ,		lowerCAmelCase :					List[str]=5_0256       ,		lowerCAmelCase :					Dict=5_0256       ,		lowerCAmelCase :					int=False       ,		**lowerCAmelCase :					str       ,		)     ->					str:


     '''simple docstring'''




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

     SCREAMING_SNAKE_CASE_: Any     			=bos_token_id
     SCREAMING_SNAKE_CASE_: str     			=eos_token_id

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







class 					a	(  UpperCAmelCase__       ):



  def __init__(						self :					Union[str, Any]       ,		lowerCAmelCase :					PretrainedConfig       ,		lowerCAmelCase :					str = "default"       ,		lowerCAmelCase :					List[PatchingSpec] = None       ,		lowerCAmelCase :					bool = False       ,		)     ->					Optional[Any]:


     '''simple docstring'''




     super().__init__(lowerCAmelCase       ,		task=lowerCAmelCase       ,		patching_specs=lowerCAmelCase       ,		use_past=lowerCAmelCase		)
     if not getattr(self._config       ,		"""pad_token_id"""       ,		lowerCAmelCase		):
        # TODO: how to do that better?
        SCREAMING_SNAKE_CASE_: Dict     			=0



  @property
  def 	lowerCamelCase__       (						self :					List[Any]		)     ->					Mapping[str, Mapping[int, str]]:


     '''simple docstring'''




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

     return common_inputs



  @property
  def 	lowerCamelCase__       (						self :					int		)     ->					int:


     '''simple docstring'''




     return self._config.n_layer



  @property
  def 	lowerCamelCase__       (						self :					Union[str, Any]		)     ->					int:


     '''simple docstring'''




     return self._config.n_head



  def 	lowerCamelCase__       (						self :					List[str]       ,		lowerCAmelCase :					PreTrainedTokenizer       ,		lowerCAmelCase :					int = -1       ,		lowerCAmelCase :					int = -1       ,		lowerCAmelCase :					bool = False       ,		lowerCAmelCase :					Optional[TensorType] = None       ,		)     ->					Mapping[str, Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_: Union[str, Any]     			=super(lowerCAmelCase       ,		self		).generate_dummy_inputs(
         lowerCAmelCase       ,		batch_size=lowerCAmelCase       ,		seq_length=lowerCAmelCase       ,		is_pair=lowerCAmelCase       ,		framework=lowerCAmelCase		)

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

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

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

     return ordered_inputs





  @property
  def 	lowerCamelCase__       (						self :					Dict		)     ->					int:


     '''simple docstring'''




     return 13








"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_UpperCAmelCase     =			{
    """configuration_xlm""": ["""XLM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """XLMConfig""", """XLMOnnxConfig"""],
    """tokenization_xlm""": ["""XLMTokenizer"""],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCAmelCase     =			[
       """XLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """XLMForMultipleChoice""",
       """XLMForQuestionAnswering""",
       """XLMForQuestionAnsweringSimple""",
       """XLMForSequenceClassification""",
       """XLMForTokenClassification""",
       """XLMModel""",
       """XLMPreTrainedModel""",
       """XLMWithLMHeadModel""",
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCAmelCase     =			[
       """TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """TFXLMForMultipleChoice""",
       """TFXLMForQuestionAnsweringSimple""",
       """TFXLMForSequenceClassification""",
       """TFXLMForTokenClassification""",
       """TFXLMMainLayer""",
       """TFXLMModel""",
       """TFXLMPreTrainedModel""",
       """TFXLMWithLMHeadModel""",
   ]


if TYPE_CHECKING:
   from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
   from .tokenization_xlm import XLMTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_xlm import (
          XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          XLMForMultipleChoice,
          XLMForQuestionAnswering,
          XLMForQuestionAnsweringSimple,
          XLMForSequenceClassification,
          XLMForTokenClassification,
          XLMModel,
          XLMPreTrainedModel,
          XLMWithLMHeadModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_xlm import (
          TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFXLMForMultipleChoice,
          TFXLMForQuestionAnsweringSimple,
          TFXLMForSequenceClassification,
          TFXLMForTokenClassification,
          TFXLMMainLayer,
          TFXLMModel,
          TFXLMPreTrainedModel,
          TFXLMWithLMHeadModel,
      )

else:
   import sys

   _UpperCAmelCase     =			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



