





'''simple docstring'''




# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from pathlib import Path

from .config_args import default_config_file, load_config_from_file
from .config_utils import SubcommandHelpFormatter


__UpperCAmelCase         =   """Update an existing config file with the latest defaults while maintaining the old configuration."""



def 						__A						(       lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							List[Any]						=	args.config_file
		if config_file is None and Path(lowerCamelCase_					).exists():
				SCREAMING_SNAKE_CASE				:							Dict						=	default_config_file
		elif not Path(lowerCamelCase_					).exists():
				raise ValueError(f'''The passed config file located at {config_file} doesn\'t exist.'''					)
		SCREAMING_SNAKE_CASE				:							List[str]						=	load_config_from_file(lowerCamelCase_					)

		if config_file.endswith(""".json"""					):
				config.to_json_file(lowerCamelCase_					)
		else:
				config.to_yaml_file(lowerCamelCase_					)
		return config_file



def 						__A						(       lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							Optional[int]						=	parser.add_parser("""update"""	,	parents=lowerCamelCase_	,	help=lowerCamelCase_	,	formatter_class=lowerCamelCase_					)
		parser.add_argument(
		    """--config_file"""	,	default=lowerCamelCase_	,	help=(
		        """The path to the config file to update. Will default to a file named default_config.yaml in the cache """
		        """location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have """
		        """such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed """
		        """with 'huggingface'."""
		    )	,	)

		parser.set_defaults(func=lowerCamelCase_					)
		return parser



def 						__A						(       lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							Tuple						=	update_config(lowerCamelCase_					)
		print(f'''Sucessfully updated the configuration file at {config_file}.'''					)










'''simple docstring'''




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

__UpperCAmelCase         =   {
    """facebook/mbart-large-cc25""": """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json""",
    # See all MBART models at https://huggingface.co/models?filter=mbart
}




class       UpperCamelCase__			(			lowercase_	):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__						=					'''mbart'''
					SCREAMING_SNAKE_CASE__						=					['''past_key_values''']
					SCREAMING_SNAKE_CASE__						=					{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}


					def __init__(		self							:	Union[str, Any]     ,		lowerCamelCase_							:	List[str]=5_02_65     ,		lowerCamelCase_							:	Tuple=10_24     ,		lowerCamelCase_							:	Union[str, Any]=12     ,		lowerCamelCase_							:	int=40_96     ,		lowerCamelCase_							:	Dict=16     ,		lowerCamelCase_							:	Any=12     ,		lowerCamelCase_							:	Any=40_96     ,		lowerCamelCase_							:	Tuple=16     ,		lowerCamelCase_							:	List[Any]=0.0     ,		lowerCamelCase_							:	Any=0.0     ,		lowerCamelCase_							:	Any=True     ,		lowerCamelCase_							:	Dict=True     ,		lowerCamelCase_							:	List[str]="gelu"     ,		lowerCamelCase_							:	List[str]=10_24     ,		lowerCamelCase_							:	int=0.1     ,		lowerCamelCase_							:	List[Any]=0.0     ,		lowerCamelCase_							:	Tuple=0.0     ,		lowerCamelCase_							:	Optional[int]=0.02     ,		lowerCamelCase_							:	Any=0.0     ,		lowerCamelCase_							:	Tuple=False     ,		lowerCamelCase_							:	Tuple=1     ,		lowerCamelCase_							:	Tuple=0     ,		lowerCamelCase_							:	List[str]=2     ,		lowerCamelCase_							:	Optional[int]=2     ,		**lowerCamelCase_							:	int     ,		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							List[Any]						=	vocab_size
							SCREAMING_SNAKE_CASE				:							Any						=	max_position_embeddings
							SCREAMING_SNAKE_CASE				:							Optional[int]						=	d_model
							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	encoder_ffn_dim
							SCREAMING_SNAKE_CASE				:							Tuple						=	encoder_layers
							SCREAMING_SNAKE_CASE				:							Dict						=	encoder_attention_heads
							SCREAMING_SNAKE_CASE				:							str						=	decoder_ffn_dim
							SCREAMING_SNAKE_CASE				:							List[Any]						=	decoder_layers
							SCREAMING_SNAKE_CASE				:							List[str]						=	decoder_attention_heads
							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	dropout
							SCREAMING_SNAKE_CASE				:							Dict						=	attention_dropout
							SCREAMING_SNAKE_CASE				:							Any						=	activation_dropout
							SCREAMING_SNAKE_CASE				:							Dict						=	activation_function
							SCREAMING_SNAKE_CASE				:							str						=	init_std
							SCREAMING_SNAKE_CASE				:							Tuple						=	encoder_layerdrop
							SCREAMING_SNAKE_CASE				:							Tuple						=	decoder_layerdrop
							SCREAMING_SNAKE_CASE				:							List[str]						=	classifier_dropout
							SCREAMING_SNAKE_CASE				:							int						=	use_cache
							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	encoder_layers
							SCREAMING_SNAKE_CASE				:							int						=	scale_embedding  # scale factor will be sqrt(d_model) if True
							super().__init__(
							    pad_token_id=lowerCamelCase_     ,		bos_token_id=lowerCamelCase_     ,		eos_token_id=lowerCamelCase_     ,		is_encoder_decoder=lowerCamelCase_     ,		forced_eos_token_id=lowerCamelCase_     ,		**lowerCamelCase_     ,		)







class       UpperCamelCase__			(			lowercase_	):




					"""simple docstring"""


					@property
					def lowerCamelCase_	(		self							:	Optional[int]		):

							'''simple docstring'''



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

									if self.use_past:
											SCREAMING_SNAKE_CASE				:							str						=	{0: """batch"""}
											SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	{0: """batch""", 1: """past_decoder_sequence + sequence"""}
									else:
											SCREAMING_SNAKE_CASE				:							Dict						=	{0: """batch""", 1: """decoder_sequence"""}
											SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	{0: """batch""", 1: """decoder_sequence"""}

									if self.use_past:
											self.fill_with_past_key_values_(lowerCamelCase_     ,		direction="""inputs"""		)
							elif self.task == "causal-lm":
									# TODO: figure this case out.
									SCREAMING_SNAKE_CASE				:							Optional[Any]						=	OrderedDict(
									    [
									        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
									        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
									    ]		)
									if self.use_past:
											SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							Optional[Any]						=	self.num_layers
											for i in range(lowerCamelCase_		):
													SCREAMING_SNAKE_CASE				:							Any						=	{0: """batch""", 2: """past_sequence + sequence"""}
													SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	{0: """batch""", 2: """past_sequence + sequence"""}
							else:
									SCREAMING_SNAKE_CASE				:							List[str]						=	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 lowerCamelCase_	(		self							:	List[str]		):

							'''simple docstring'''



							if self.task in ["default", "seq2seq-lm"]:
									SCREAMING_SNAKE_CASE				:							List[Any]						=	super().outputs
							else:
									SCREAMING_SNAKE_CASE				:							int						=	super(lowerCamelCase_     ,		self		).outputs
									if self.use_past:
											SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							List[str]						=	self.num_layers
											for i in range(lowerCamelCase_		):
													SCREAMING_SNAKE_CASE				:							str						=	{0: """batch""", 2: """past_sequence + sequence"""}
													SCREAMING_SNAKE_CASE				:							Tuple						=	{0: """batch""", 2: """past_sequence + sequence"""}
							return common_outputs


					def lowerCamelCase_	(		self							:	List[Any]     ,		lowerCamelCase_							:	PreTrainedTokenizer     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	bool = False     ,		lowerCamelCase_							:	Optional[TensorType] = None     ,		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							Dict						=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_		)

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

							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				:							Dict						=	common_inputs["""input_ids"""].shape
									SCREAMING_SNAKE_CASE				:							Dict						=	common_inputs["""decoder_input_ids"""].shape[1]
									SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							str						=	self.num_attention_heads
									SCREAMING_SNAKE_CASE				:							Optional[int]						=	(
									    batch,
									    num_encoder_attention_heads,
									    encoder_seq_length,
									    self._config.hidden_size // num_encoder_attention_heads,
									)
									SCREAMING_SNAKE_CASE				:							Any						=	decoder_seq_length + 3
									SCREAMING_SNAKE_CASE				:							Dict						=	(
									    batch,
									    num_decoder_attention_heads,
									    decoder_past_length,
									    self._config.hidden_size // num_decoder_attention_heads,
									)

									SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	torch.cat(
									    [common_inputs["""decoder_attention_mask"""], torch.ones(lowerCamelCase_     ,		lowerCamelCase_		)]     ,		dim=1		)

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

									for _ in range(lowerCamelCase_		):
											common_inputs["past_key_values"].append(
											    (
											        torch.zeros(lowerCamelCase_		),
											        torch.zeros(lowerCamelCase_		),
											        torch.zeros(lowerCamelCase_		),
											        torch.zeros(lowerCamelCase_		),
											    )		)
									# TODO: test this.
									SCREAMING_SNAKE_CASE				:							List[Any]						=	encoder_shape if remaining_side_name == """encoder""" else decoder_shape
									for _ in range(lowerCamelCase_     ,		lowerCamelCase_		):
											common_inputs["past_key_values"].append((torch.zeros(lowerCamelCase_		), torch.zeros(lowerCamelCase_		))		)
							return common_inputs


					def lowerCamelCase_	(		self							:	Optional[int]     ,		lowerCamelCase_							:	PreTrainedTokenizer     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	bool = False     ,		lowerCamelCase_							:	Optional[TensorType] = None     ,		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							Optional[int]						=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_		)

							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				:							Optional[Any]						=	common_inputs["""input_ids"""].shape
									# Not using the same length for past_key_values
									SCREAMING_SNAKE_CASE				:							Optional[int]						=	seqlen + 2
									SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							Optional[int]						=	self.num_layers
									SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							str						=	self.num_attention_heads
									SCREAMING_SNAKE_CASE				:							int						=	(
									    batch,
									    num_encoder_attention_heads,
									    past_key_values_length,
									    self._config.hidden_size // num_encoder_attention_heads,
									)

									SCREAMING_SNAKE_CASE				:							Dict						=	common_inputs["""attention_mask"""].dtype
									SCREAMING_SNAKE_CASE				:							Dict						=	torch.cat(
									    [common_inputs["""attention_mask"""], torch.ones(lowerCamelCase_     ,		lowerCamelCase_     ,		dtype=lowerCamelCase_		)]     ,		dim=1		)
									SCREAMING_SNAKE_CASE				:							Optional[Any]						=	[
									    (torch.zeros(lowerCamelCase_		), torch.zeros(lowerCamelCase_		)) for _ in range(lowerCamelCase_		)
									]
							return common_inputs


					def lowerCamelCase_	(		self							:	str     ,		lowerCamelCase_							:	PreTrainedTokenizer     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	bool = False     ,		lowerCamelCase_							:	Optional[TensorType] = None     ,		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							List[Any]						=	compute_effective_axis_dimension(
							    lowerCamelCase_     ,		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
							SCREAMING_SNAKE_CASE				:							int						=	tokenizer.num_special_tokens_to_add(lowerCamelCase_		)
							SCREAMING_SNAKE_CASE				:							int						=	compute_effective_axis_dimension(
							    lowerCamelCase_     ,		fixed_dimension=OnnxConfig.default_fixed_sequence     ,		num_token_to_add=lowerCamelCase_		)

							# Generate dummy inputs according to compute batch and sequence
							SCREAMING_SNAKE_CASE				:							Any						=	[""" """.join([tokenizer.unk_token]		) * seq_length] * batch_size
							SCREAMING_SNAKE_CASE				:							Optional[Any]						=	dict(tokenizer(lowerCamelCase_     ,		return_tensors=lowerCamelCase_		)		)
							return common_inputs


					def lowerCamelCase_	(		self							:	str     ,		lowerCamelCase_							:	PreTrainedTokenizer     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	int = -1     ,		lowerCamelCase_							:	bool = False     ,		lowerCamelCase_							:	Optional[TensorType] = None     ,		):

							'''simple docstring'''



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

							elif self.task == "causal-lm":
									SCREAMING_SNAKE_CASE				:							str						=	self._generate_dummy_inputs_for_causal_lm(
									    lowerCamelCase_     ,		batch_size=lowerCamelCase_     ,		seq_length=lowerCamelCase_     ,		is_pair=lowerCamelCase_     ,		framework=lowerCamelCase_		)
							else:
									SCREAMING_SNAKE_CASE				:							List[Any]						=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    lowerCamelCase_     ,		batch_size=lowerCamelCase_     ,		seq_length=lowerCamelCase_     ,		is_pair=lowerCamelCase_     ,		framework=lowerCamelCase_		)

							return common_inputs



					def lowerCamelCase_	(		self							:	Union[str, Any]     ,		lowerCamelCase_							:	Union[str, Any]     ,		lowerCamelCase_							:	Tuple     ,		lowerCamelCase_							:	str     ,		lowerCamelCase_							:	List[Any]		):

							'''simple docstring'''



							if self.task in ["default", "seq2seq-lm"]:
									SCREAMING_SNAKE_CASE				:							Tuple						=	super()._flatten_past_key_values_(lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_		)
							else:
									SCREAMING_SNAKE_CASE				:							List[Any]						=	super(lowerCamelCase_     ,		self		)._flatten_past_key_values_(
									    lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_     ,		lowerCamelCase_		)



