



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


lowercase_													=      {
    '''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			(  SCREAMING_SNAKE_CASE					):
	SCREAMING_SNAKE_CASE  	=							"codegen"
	SCREAMING_SNAKE_CASE  	=							{
	    "max_position_embeddings": "n_positions",
	    "hidden_size": "n_embd",
	    "num_attention_heads": "n_head",
	    "num_hidden_layers": "n_layer",
	}



	def __init__(    self				:     Optional[int]					,						snake_case_				:     Dict=5_04_00					,						snake_case_				:     str=20_48					,						snake_case_				:     Any=20_48					,						snake_case_				:     List[Any]=40_96					,						snake_case_				:     Dict=28					,						snake_case_				:     Optional[int]=16					,						snake_case_				:     Any=64					,						snake_case_				:     Tuple=None					,						snake_case_				:     str="gelu_new"					,						snake_case_				:     Tuple=0.0					,						snake_case_				:     int=0.0					,						snake_case_				:     Tuple=0.0					,						snake_case_				:     Any=1e-5					,						snake_case_				:     Union[str, Any]=0.0_2					,						snake_case_				:     Union[str, Any]=True					,						snake_case_				:     Any=5_02_56					,						snake_case_				:     List[Any]=5_02_56					,						snake_case_				:     Optional[int]=False					,						**snake_case_				:     List[str]					,						)->				str:
						__lowerCAmelCase						 =vocab_size
						__lowerCAmelCase						 =n_ctx
						__lowerCAmelCase						 =n_positions
						__lowerCAmelCase						 =n_embd
						__lowerCAmelCase						 =n_layer
						__lowerCAmelCase						 =n_head
						__lowerCAmelCase						 =n_inner
						__lowerCAmelCase						 =rotary_dim
						__lowerCAmelCase						 =activation_function
						__lowerCAmelCase						 =resid_pdrop
						__lowerCAmelCase						 =embd_pdrop
						__lowerCAmelCase						 =attn_pdrop
						__lowerCAmelCase						 =layer_norm_epsilon
						__lowerCAmelCase						 =initializer_range
						__lowerCAmelCase						 =use_cache

						__lowerCAmelCase						 =bos_token_id
						__lowerCAmelCase						 =eos_token_id

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






class     __a			(  SCREAMING_SNAKE_CASE					):



	def __init__(    self				:     Optional[Any]					,						snake_case_				:     PretrainedConfig					,						snake_case_				:     str = "default"					,						snake_case_				:     List[PatchingSpec] = None					,						snake_case_				:     bool = False					,						)->				Tuple:
						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?
											__lowerCAmelCase						 =0



	@property
	def 		UpperCamelCase				(    self				:     Optional[Any])->				Mapping[str, Mapping[int, str]]:
						__lowerCAmelCase						 =OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}})
						if self.use_past:
											self.fill_with_past_key_values_(snake_case_					,						direction="""inputs""")
											__lowerCAmelCase						 ={0: """batch""", 1: """past_sequence + sequence"""}
						else:
											__lowerCAmelCase						 ={0: """batch""", 1: """sequence"""}

						return common_inputs



	@property
	def 		UpperCamelCase				(    self				:     Optional[int])->				int:
						return self._config.n_layer



	@property
	def 		UpperCamelCase				(    self				:     List[Any])->				int:
						return self._config.n_head



	def 		UpperCamelCase				(    self				:     Optional[Any]					,						snake_case_				:     PreTrainedTokenizer					,						snake_case_				:     int = -1					,						snake_case_				:     int = -1					,						snake_case_				:     bool = False					,						snake_case_				:     Optional[TensorType] = None					,						)->				Mapping[str, Any]:
						__lowerCAmelCase						 =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()
						__lowerCAmelCase						 =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

																__lowerCAmelCase ,						__lowerCAmelCase						 =common_inputs["""input_ids"""].shape
																# Not using the same length for past_key_values
																__lowerCAmelCase						 =seqlen + 2
																__lowerCAmelCase						 =(
																    batch,
																    self.num_attention_heads,
																    past_key_values_length,
																    self._config.hidden_size // self.num_attention_heads,
																)
																__lowerCAmelCase						 =[
																    (torch.zeros(snake_case_), torch.zeros(snake_case_)) for _ in range(self.num_layers)
																]

						__lowerCAmelCase						 =common_inputs["""attention_mask"""]
						if self.use_past:
											__lowerCAmelCase						 =ordered_inputs["""attention_mask"""].dtype
											__lowerCAmelCase						 =torch.cat(
											    [ordered_inputs["""attention_mask"""], torch.ones(snake_case_					,						snake_case_					,						dtype=snake_case_)]					,						dim=1)

						return ordered_inputs



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









from collections import OrderedDict
from typing import Mapping

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


lowercase_													=      logging.get_logger(__name__)

lowercase_													=      {
    '''distilbert-base-uncased''': '''https://huggingface.co/distilbert-base-uncased/resolve/main/config.json''',
    '''distilbert-base-uncased-distilled-squad''': (
        '''https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/config.json'''
    ),
    '''distilbert-base-cased''': '''https://huggingface.co/distilbert-base-cased/resolve/main/config.json''',
    '''distilbert-base-cased-distilled-squad''': (
        '''https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/config.json'''
    ),
    '''distilbert-base-german-cased''': '''https://huggingface.co/distilbert-base-german-cased/resolve/main/config.json''',
    '''distilbert-base-multilingual-cased''': (
        '''https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/config.json'''
    ),
    '''distilbert-base-uncased-finetuned-sst-2-english''': (
        '''https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english/resolve/main/config.json'''
    ),
}






class     __a			(  SCREAMING_SNAKE_CASE					):
	SCREAMING_SNAKE_CASE  	=							"distilbert"
	SCREAMING_SNAKE_CASE  	=							{
	    "hidden_size": "dim",
	    "num_attention_heads": "n_heads",
	    "num_hidden_layers": "n_layers",
	}



	def __init__(    self				:     Optional[Any]					,						snake_case_				:     Tuple=3_05_22					,						snake_case_				:     Any=5_12					,						snake_case_				:     Dict=False					,						snake_case_				:     Tuple=6					,						snake_case_				:     Union[str, Any]=12					,						snake_case_				:     List[str]=7_68					,						snake_case_				:     Optional[Any]=4 * 7_68					,						snake_case_				:     Optional[Any]=0.1					,						snake_case_				:     Dict=0.1					,						snake_case_				:     Union[str, Any]="gelu"					,						snake_case_				:     Any=0.0_2					,						snake_case_				:     Optional[Any]=0.1					,						snake_case_				:     List[Any]=0.2					,						snake_case_				:     Optional[Any]=0					,						**snake_case_				:     List[Any]					,						)->				Tuple:
						__lowerCAmelCase						 =vocab_size
						__lowerCAmelCase						 =max_position_embeddings
						__lowerCAmelCase						 =sinusoidal_pos_embds
						__lowerCAmelCase						 =n_layers
						__lowerCAmelCase						 =n_heads
						__lowerCAmelCase						 =dim
						__lowerCAmelCase						 =hidden_dim
						__lowerCAmelCase						 =dropout
						__lowerCAmelCase						 =attention_dropout
						__lowerCAmelCase						 =activation
						__lowerCAmelCase						 =initializer_range
						__lowerCAmelCase						 =qa_dropout
						__lowerCAmelCase						 =seq_classif_dropout
						super().__init__(**snake_case_					,						pad_token_id=snake_case_)






class     __a			(  SCREAMING_SNAKE_CASE					):



	@property
	def 		UpperCamelCase				(    self				:     Union[str, Any])->				Mapping[str, Mapping[int, str]]:
						if self.task == "multiple-choice":
											__lowerCAmelCase						 ={0: """batch""", 1: """choice""", 2: """sequence"""}
						else:
											__lowerCAmelCase						 ={0: """batch""", 1: """sequence"""}
						return OrderedDict(
						    [
						        ("""input_ids""", dynamic_axis),
						        ("""attention_mask""", dynamic_axis),
						    ])




