


"""simple docstring"""






from math import ceil





def 				A_       ( snake_case__       ,					snake_case__		)					->  Dict:
			_UpperCamelCase					:Union[str, Any]					     =	list(range(0       ,					snake_case__		)		)

			_UpperCamelCase					:Optional[int]					     =	[item for sublist in list(device_map.values()		) for item in sublist]

			# Duplicate check
			_UpperCamelCase					:List[Any]					     =	[]
			for i in device_map_blocks:
						if device_map_blocks.count(snake_case__		) > 1 and i not in duplicate_blocks:
									duplicate_blocks.append(snake_case__		)
    # Missing blocks
			_UpperCamelCase					:Dict					     =	[i for i in blocks if i not in device_map_blocks]
			_UpperCamelCase					:Optional[int]					     =	[i for i in device_map_blocks if i not in blocks]

			if len(snake_case__		) != 0:
						raise ValueError(
						    '''Duplicate attention blocks specified in device_map. Attention blocks must be specified to one device.'''
						    ''' These attention blocks were specified more than once: ''' + str(snake_case__		)		)
			if len(snake_case__		) != 0:
						raise ValueError(
						    '''There are attention blocks for this model that are not specified in the device_map. Add these attention '''
						    '''blocks to a device on the device_map: ''' + str(snake_case__		)		)
			if len(snake_case__		) != 0:
						raise ValueError(
						    '''The device_map contains more attention blocks than this model has. Remove these from the device_map:'''
						    + str(snake_case__		)		)





def 				A_       ( snake_case__       ,					snake_case__		)					->  Optional[Any]:
			_UpperCamelCase					:List[str]					     =	list(range(snake_case__		)		)
			_UpperCamelCase					:Optional[Any]					     =	int(ceil(n_layers / len(snake_case__		)		)		)
			_UpperCamelCase					:Dict					     =	[layers[i : i + n_blocks] for i in range(0       ,					snake_case__       ,					snake_case__		)]

			return dict(zip(snake_case__       ,					snake_case__		)		)





"""simple docstring"""






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

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


UpperCamelCase__				:Dict			   =	logging.get_logger(__name__)

UpperCamelCase__				:int			   =	{
    """facebook/bart-large""": """https://huggingface.co/facebook/bart-large/resolve/main/config.json""",
    # See all BART models at https://huggingface.co/models?filter=bart
}






class      A(  lowerCamelCase__		):

		"""simple docstring"""





		A    =							"bart"
		A    =							["past_key_values"]
		A    =							{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}
		def __init__( self					,				SCREAMING_SNAKE_CASE__=5_02_65					,				SCREAMING_SNAKE_CASE__=10_24					,				SCREAMING_SNAKE_CASE__=12					,				SCREAMING_SNAKE_CASE__=40_96					,				SCREAMING_SNAKE_CASE__=16					,				SCREAMING_SNAKE_CASE__=12					,				SCREAMING_SNAKE_CASE__=40_96					,				SCREAMING_SNAKE_CASE__=16					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__="gelu"					,				SCREAMING_SNAKE_CASE__=10_24					,				SCREAMING_SNAKE_CASE__=0.1					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=0.0_2					,				SCREAMING_SNAKE_CASE__=0.0					,				SCREAMING_SNAKE_CASE__=False					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=3					,				SCREAMING_SNAKE_CASE__=1					,				SCREAMING_SNAKE_CASE__=0					,				SCREAMING_SNAKE_CASE__=2					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=2					,				SCREAMING_SNAKE_CASE__=2					,				**SCREAMING_SNAKE_CASE__					,				)      ->	Optional[Any]:

					"""simple docstring"""



					_UpperCamelCase					:Union[str, Any]					     =	vocab_size
					_UpperCamelCase					:Union[str, Any]					     =	max_position_embeddings
					_UpperCamelCase					:int					     =	d_model
					_UpperCamelCase					:Any					     =	encoder_ffn_dim
					_UpperCamelCase					:str					     =	encoder_layers
					_UpperCamelCase					:str					     =	encoder_attention_heads
					_UpperCamelCase					:Optional[int]					     =	decoder_ffn_dim
					_UpperCamelCase					:Any					     =	decoder_layers
					_UpperCamelCase					:Dict					     =	decoder_attention_heads
					_UpperCamelCase					:str					     =	dropout
					_UpperCamelCase					:Tuple					     =	attention_dropout
					_UpperCamelCase					:Optional[Any]					     =	activation_dropout
					_UpperCamelCase					:Optional[Any]					     =	activation_function
					_UpperCamelCase					:int					     =	init_std
					_UpperCamelCase					:Any					     =	encoder_layerdrop
					_UpperCamelCase					:List[Any]					     =	decoder_layerdrop
					_UpperCamelCase					:Union[str, Any]					     =	classifier_dropout
					_UpperCamelCase					:List[Any]					     =	use_cache
					_UpperCamelCase					:str					     =	encoder_layers
					_UpperCamelCase					:int					     =	scale_embedding  # scale factor will be sqrt(d_model) if True

					super().__init__(
					    num_labels=SCREAMING_SNAKE_CASE__					,				pad_token_id=SCREAMING_SNAKE_CASE__					,				bos_token_id=SCREAMING_SNAKE_CASE__					,				eos_token_id=SCREAMING_SNAKE_CASE__					,				is_encoder_decoder=SCREAMING_SNAKE_CASE__					,				decoder_start_token_id=SCREAMING_SNAKE_CASE__					,				forced_eos_token_id=SCREAMING_SNAKE_CASE__					,				**SCREAMING_SNAKE_CASE__					,				)

					# ensure backward compatibility for BART CNN models
					if self.forced_bos_token_id is None and kwargs.get('''force_bos_token_to_be_generated'''					,				SCREAMING_SNAKE_CASE__   ):
								_UpperCamelCase					:Any					     =	self.bos_token_id
								warnings.warn(
								    f"Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. "
								    '''The config can simply be saved and uploaded again to be fixed.'''   )






class      A(  lowerCamelCase__		):

		"""simple docstring"""





		@property
		def   _UpperCamelCase( self   )      ->	Mapping[str, Mapping[int, str]]:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:List[Any]					     =	OrderedDict(
								    [
								        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
								        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
								    ]   )

								if self.use_past:
											_UpperCamelCase					:Optional[Any]					     =	{0: '''batch'''}
											_UpperCamelCase					:int					     =	{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
								else:
											_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 1: '''decoder_sequence'''}
											_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 1: '''decoder_sequence'''}

								if self.use_past:
											self.fill_with_past_key_values_(SCREAMING_SNAKE_CASE__					,				direction='''inputs'''   )
					elif self.task == "causal-lm":
								# TODO: figure this case out.
								_UpperCamelCase					:Tuple					     =	OrderedDict(
								    [
								        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
								        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
								    ]   )
								if self.use_past:
											_UpperCamelCase     ,      _UpperCamelCase					:List[str]					     =	self.num_layers
											for i in range(SCREAMING_SNAKE_CASE__   ):
														_UpperCamelCase					:int					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
														_UpperCamelCase					:List[Any]					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
					else:
								_UpperCamelCase					:List[Any]					     =	OrderedDict(
								    [
								        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
								        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
								        ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
								        ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
								    ]   )

					return common_inputs
		@property
		def   _UpperCamelCase( self   )      ->	Mapping[str, Mapping[int, str]]:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:Optional[int]					     =	super().outputs
					else:
								_UpperCamelCase					:List[str]					     =	super(SCREAMING_SNAKE_CASE__					,				self   ).outputs
								if self.use_past:
											_UpperCamelCase     ,      _UpperCamelCase					:int					     =	self.num_layers
											for i in range(SCREAMING_SNAKE_CASE__   ):
														_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
														_UpperCamelCase					:Optional[Any]					     =	{0: '''batch''', 2: '''past_sequence + sequence'''}
					return common_outputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )

					# Generate decoder inputs
					_UpperCamelCase					:List[Any]					     =	seq_length if not self.use_past else 1
					_UpperCamelCase					:Tuple					     =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
					_UpperCamelCase					:Union[str, Any]					     =	{f"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
					_UpperCamelCase					:str					     =	dict(**SCREAMING_SNAKE_CASE__					,				**SCREAMING_SNAKE_CASE__   )

					if self.use_past:
								if not is_torch_available():
											raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''   )
								else:
											import torch
								_UpperCamelCase     ,      _UpperCamelCase					:Any					     =	common_inputs['''input_ids'''].shape
								_UpperCamelCase					:Dict					     =	common_inputs['''decoder_input_ids'''].shape[1]
								_UpperCamelCase     ,      _UpperCamelCase					:Any					     =	self.num_attention_heads
								_UpperCamelCase					:Dict					     =	(
								    batch,
								    num_encoder_attention_heads,
								    encoder_seq_length,
								    self._config.hidden_size // num_encoder_attention_heads,
								)
								_UpperCamelCase					:Tuple					     =	decoder_seq_length + 3
								_UpperCamelCase					:Optional[int]					     =	(
								    batch,
								    num_decoder_attention_heads,
								    decoder_past_length,
								    self._config.hidden_size // num_decoder_attention_heads,
								)

								_UpperCamelCase					:Optional[int]					     =	torch.cat(
								    [common_inputs['''decoder_attention_mask'''], torch.ones(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )]					,				dim=1   )

								_UpperCamelCase					:Union[str, Any]					     =	[]
								# If the number of encoder and decoder layers are present in the model configuration, both are considered
								_UpperCamelCase     ,      _UpperCamelCase					:int					     =	self.num_layers
								_UpperCamelCase					:Any					     =	min(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					:Optional[int]					     =	max(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   ) - min_num_layers
								_UpperCamelCase					:int					     =	'''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

								for _ in range(SCREAMING_SNAKE_CASE__   ):
											common_inputs["past_key_values"].append(
											    (
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											        torch.zeros(SCREAMING_SNAKE_CASE__   ),
											    )   )
								# TODO: test this.
								_UpperCamelCase					:Optional[int]					     =	encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
								for _ in range(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   ):
											common_inputs["past_key_values"].append((torch.zeros(SCREAMING_SNAKE_CASE__   ), torch.zeros(SCREAMING_SNAKE_CASE__   ))   )
					return common_inputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:Dict					     =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )

					if self.use_past:
								if not is_torch_available():
											raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''   )
								else:
											import torch
								_UpperCamelCase     ,      _UpperCamelCase					:List[Any]					     =	common_inputs['''input_ids'''].shape
								# Not using the same length for past_key_values
								_UpperCamelCase					:str					     =	seqlen + 2
								_UpperCamelCase     ,      _UpperCamelCase					:Dict					     =	self.num_layers
								_UpperCamelCase     ,      _UpperCamelCase					:Union[str, Any]					     =	self.num_attention_heads
								_UpperCamelCase					:List[Any]					     =	(
								    batch,
								    num_encoder_attention_heads,
								    past_key_values_length,
								    self._config.hidden_size // num_encoder_attention_heads,
								)

								_UpperCamelCase					:Tuple					     =	common_inputs['''attention_mask'''].dtype
								_UpperCamelCase					:List[Any]					     =	torch.cat(
								    [common_inputs['''attention_mask'''], torch.ones(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				dtype=SCREAMING_SNAKE_CASE__   )]					,				dim=1   )
								_UpperCamelCase					:int					     =	[
								    (torch.zeros(SCREAMING_SNAKE_CASE__   ), torch.zeros(SCREAMING_SNAKE_CASE__   )) for _ in range(SCREAMING_SNAKE_CASE__   )
								]
					return common_inputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:List[str]					     =	compute_effective_axis_dimension(
					    SCREAMING_SNAKE_CASE__					,				fixed_dimension=OnnxConfig.default_fixed_batch					,				num_token_to_add=0   )

					# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
					_UpperCamelCase					:str					     =	tokenizer.num_special_tokens_to_add(SCREAMING_SNAKE_CASE__   )
					_UpperCamelCase					:str					     =	compute_effective_axis_dimension(
					    SCREAMING_SNAKE_CASE__					,				fixed_dimension=OnnxConfig.default_fixed_sequence					,				num_token_to_add=SCREAMING_SNAKE_CASE__   )

					# Generate dummy inputs according to compute batch and sequence
					_UpperCamelCase					:List[Any]					     =	[''' '''.join([tokenizer.unk_token]   ) * seq_length] * batch_size
					_UpperCamelCase					:Optional[Any]					     =	dict(tokenizer(SCREAMING_SNAKE_CASE__					,				return_tensors=SCREAMING_SNAKE_CASE__   )   )
					return common_inputs
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = -1					,				SCREAMING_SNAKE_CASE__ = False					,				SCREAMING_SNAKE_CASE__ = None					,				)      ->	Mapping[str, Any]:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:str					     =	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
								    SCREAMING_SNAKE_CASE__					,				batch_size=SCREAMING_SNAKE_CASE__					,				seq_length=SCREAMING_SNAKE_CASE__					,				is_pair=SCREAMING_SNAKE_CASE__					,				framework=SCREAMING_SNAKE_CASE__   )

					elif self.task == "causal-lm":
								_UpperCamelCase					:Optional[Any]					     =	self._generate_dummy_inputs_for_causal_lm(
								    SCREAMING_SNAKE_CASE__					,				batch_size=SCREAMING_SNAKE_CASE__					,				seq_length=SCREAMING_SNAKE_CASE__					,				is_pair=SCREAMING_SNAKE_CASE__					,				framework=SCREAMING_SNAKE_CASE__   )
					else:
								_UpperCamelCase					:Any					     =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
								    SCREAMING_SNAKE_CASE__					,				batch_size=SCREAMING_SNAKE_CASE__					,				seq_length=SCREAMING_SNAKE_CASE__					,				is_pair=SCREAMING_SNAKE_CASE__					,				framework=SCREAMING_SNAKE_CASE__   )

					return common_inputs





		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )      ->	Dict:

					"""simple docstring"""



					if self.task in ["default", "seq2seq-lm"]:
								_UpperCamelCase					:Union[str, Any]					     =	super()._flatten_past_key_values_(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
					else:
								_UpperCamelCase					:Tuple					     =	super(SCREAMING_SNAKE_CASE__					,				self   )._flatten_past_key_values_(
								    SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )

