


"""simple docstring"""






import ast
import os
import re
import shutil
import tempfile
import unittest
from unittest import mock

import torch

from accelerate.test_utils.examples import compare_against_test
from accelerate.test_utils.testing import TempDirTestCase, require_trackers, run_command, slow
from accelerate.utils import write_basic_config


# DataLoaders built from `test_samples/MRPC` for quick testing
# Should mock `{script_name}.get_dataloaders` via:
# @mock.patch("{script_name}.get_dataloaders", mocked_dataloaders)

UpperCamelCase__				:Optional[int]			   =	[
    """cross_validation.py""",
    """gradient_accumulation.py""",
    """local_sgd.py""",
    """multi_process_metrics.py""",
    """memory.py""",
    """automatic_gradient_accumulation.py""",
    """fsdp_with_peak_mem_tracking.py""",
    """deepspeed_with_config_support.py""",
    """megatron_lm_gpt_pretraining.py""",
]






class      A(  unittest.TestCase		):

		"""simple docstring"""





		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = None					,				SCREAMING_SNAKE_CASE__ = None   )      ->	List[Any]:

					"""simple docstring"""



					_UpperCamelCase					:Any					     =	None
					_UpperCamelCase					:Optional[int]					     =	os.path.abspath(os.path.join('''examples'''					,				'''by_feature'''   )   )
					_UpperCamelCase					:Union[str, Any]					     =	os.path.abspath('''examples'''   )
					for item in os.listdir(SCREAMING_SNAKE_CASE__   ):
								if item not in EXCLUDE_EXAMPLES:
											_UpperCamelCase					:Optional[Any]					     =	os.path.join(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
											if os.path.isfile(SCREAMING_SNAKE_CASE__   ) and ".py" in item_path:
														with self.subTest(
														    tested_script=SCREAMING_SNAKE_CASE__					,				feature_script=SCREAMING_SNAKE_CASE__					,				tested_section='''main()''' if parser_only else '''training_function()'''					,				):
																	_UpperCamelCase					:List[str]					     =	compare_against_test(
																	    os.path.join(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
																	_UpperCamelCase					:Optional[Any]					     =	'''\n'''.join(SCREAMING_SNAKE_CASE__   )
																	if special_strings is not None:
																				for string in special_strings:
																							_UpperCamelCase					:List[Any]					     =	diff.replace(SCREAMING_SNAKE_CASE__					,				''''''   )
																	self.assertEqual(SCREAMING_SNAKE_CASE__					,				''''''   )
		def   _UpperCamelCase( self   )      ->	Union[str, Any]:

					"""simple docstring"""



					self.one_complete_example('''complete_nlp_example.py'''					,				SCREAMING_SNAKE_CASE__   )
					self.one_complete_example('''complete_nlp_example.py'''					,				SCREAMING_SNAKE_CASE__   )





		def   _UpperCamelCase( self   )      ->	Optional[Any]:

					"""simple docstring"""



					_UpperCamelCase					:int					     =	os.path.abspath(os.path.join('''examples'''					,				'''cv_example.py'''   )   )
					_UpperCamelCase					:List[str]					     =	[
					    ''' ''' * 16 + '''{\n\n''',
					    ''' ''' * 20 + '''"accuracy": eval_metric["accuracy"],\n\n''',
					    ''' ''' * 20 + '''"f1": eval_metric["f1"],\n\n''',
					    ''' ''' * 20 + '''"train_loss": total_loss.item() / len(train_dataloader),\n\n''',
					    ''' ''' * 20 + '''"epoch": epoch,\n\n''',
					    ''' ''' * 16 + '''},\n\n''',
					    ''' ''' * 16 + '''step=epoch,\n''',
					    ''' ''' * 12,
					    ''' ''' * 8 + '''for step, batch in enumerate(active_dataloader):\n''',
					]
					self.one_complete_example('''complete_cv_example.py'''					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )
					self.one_complete_example('''complete_cv_example.py'''					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )






@mock.patch.dict(os.environ				,							{"TESTING_MOCKED_DATALOADERS": "1"}		)
class      A(  lowerCamelCase__		):

		"""simple docstring"""





		A    =							False
		@classmethod
		def   _UpperCamelCase( cls   )      ->	List[Any]:

					"""simple docstring"""



					super().setUpClass()
					_UpperCamelCase					:Optional[Any]					     =	tempfile.mkdtemp()
					_UpperCamelCase					:Optional[Any]					     =	os.path.join(cls._tmpdir					,				'''default_config.yml'''   )

					write_basic_config(save_location=cls.configPath   )
					_UpperCamelCase					:Optional[int]					     =	['''accelerate''', '''launch''', '''--config_file''', cls.configPath]
		@classmethod
		def   _UpperCamelCase( cls   )      ->	Tuple:

					"""simple docstring"""



					super().tearDownClass()
					shutil.rmtree(cls._tmpdir   )
		def   _UpperCamelCase( self   )      ->	Optional[Any]:

					"""simple docstring"""



					_UpperCamelCase					:Any					     =	f"\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps epoch\n        --output_dir {self.tmpdir}\n        ".split()
					run_command(self._launch_args + testargs   )
					self.assertTrue(os.path.exists(os.path.join(self.tmpdir					,				'''epoch_0'''   )   )   )
		def   _UpperCamelCase( self   )      ->	Dict:

					"""simple docstring"""



					_UpperCamelCase					:List[Any]					     =	f"\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps 1\n        --output_dir {self.tmpdir}\n        ".split()
					_UpperCamelCase					:Any					     =	run_command(self._launch_args + testargs   )
					self.assertTrue(os.path.exists(os.path.join(self.tmpdir					,				'''step_2'''   )   )   )
		def   _UpperCamelCase( self   )      ->	str:

					"""simple docstring"""



					_UpperCamelCase					:Any					     =	f"\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir					,				'epoch_0'   )}\n        ".split()
					_UpperCamelCase					:Any					     =	run_command(self._launch_args + testargs					,				return_stdout=SCREAMING_SNAKE_CASE__   )
					self.assertNotIn('''epoch 0:'''					,				SCREAMING_SNAKE_CASE__   )
					self.assertIn('''epoch 1:'''					,				SCREAMING_SNAKE_CASE__   )
		def   _UpperCamelCase( self   )      ->	Optional[Any]:

					"""simple docstring"""



					_UpperCamelCase					:Dict					     =	f"\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir					,				'step_2'   )}\n        ".split()
					_UpperCamelCase					:str					     =	run_command(self._launch_args + testargs					,				return_stdout=SCREAMING_SNAKE_CASE__   )
					if torch.cuda.is_available():
								_UpperCamelCase					:Tuple					     =	torch.cuda.device_count()
					else:
								_UpperCamelCase					:str					     =	1
					if num_processes > 1:
								self.assertNotIn('''epoch 0:'''					,				SCREAMING_SNAKE_CASE__   )
								self.assertIn('''epoch 1:'''					,				SCREAMING_SNAKE_CASE__   )
					else:
								self.assertIn('''epoch 0:'''					,				SCREAMING_SNAKE_CASE__   )
								self.assertIn('''epoch 1:'''					,				SCREAMING_SNAKE_CASE__   )
		@slow
		def   _UpperCamelCase( self   )      ->	Any:

					"""simple docstring"""



					_UpperCamelCase					:Optional[int]					     =	'''
        examples/by_feature/cross_validation.py
        --num_folds 2
        '''.split()
					with mock.patch.dict(os.environ					,				{'''TESTING_MOCKED_DATALOADERS''': '''0'''}   ):
								_UpperCamelCase					:Optional[int]					     =	run_command(self._launch_args + testargs					,				return_stdout=SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					:Dict					     =	re.findall('''({.+})'''					,				SCREAMING_SNAKE_CASE__   )
								_UpperCamelCase					:Optional[Any]					     =	[r for r in results if '''accuracy''' in r][-1]
								_UpperCamelCase					:Tuple					     =	ast.literal_eval(SCREAMING_SNAKE_CASE__   )
								self.assertGreaterEqual(results['''accuracy''']					,				0.7_5   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:List[str]					     =	['''examples/by_feature/multi_process_metrics.py''']
					run_command(self._launch_args + testargs   )
		@require_trackers
		@mock.patch.dict(os.environ					,				{'''WANDB_MODE''': '''offline'''}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					with tempfile.TemporaryDirectory() as tmpdir:
								_UpperCamelCase					:Optional[int]					     =	f"\n            examples/by_feature/tracking.py\n            --with_tracking\n            --project_dir {tmpdir}\n            ".split()
								run_command(self._launch_args + testargs   )
								self.assertTrue(os.path.exists(os.path.join(SCREAMING_SNAKE_CASE__					,				'''tracking'''   )   )   )
		def   _UpperCamelCase( self   )      ->	Any:

					"""simple docstring"""



					_UpperCamelCase					:Optional[Any]					     =	['''examples/by_feature/gradient_accumulation.py''']
					run_command(self._launch_args + testargs   )





		def   _UpperCamelCase( self   )      ->	Optional[int]:

					"""simple docstring"""



					_UpperCamelCase					:Optional[Any]					     =	['''examples/by_feature/local_sgd.py''']
					run_command(self._launch_args + testargs   )





"""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__   )

