



'''simple docstring'''

import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

# Register SEW's fairseq modules
from sew_asapp import tasks  # noqa: F401

from transformers import (
    SEWDConfig,
    SEWDForCTC,
    SEWDModel,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
UpperCAmelCase			=    logging.get_logger(__name__)

UpperCAmelCase			=    {
    'post_extract_proj': 'feature_projection',
    'encoder.pos_conv.0': 'encoder.pos_conv_embed.conv',
    'attention.self.query_proj': 'encoder.encoder.layer.*.attention.self.query_proj',
    'attention.self.key_proj': 'encoder.encoder.layer.*.attention.self.key_proj',
    'attention.self.value_proj': 'encoder.encoder.layer.*.attention.self.value_proj',
    'attention.output.dense': 'encoder.encoder.layer.*.attention.output.dense',
    'attention.output.LayerNorm': 'encoder.encoder.layer.*.attention.output.LayerNorm',
    'intermediate.dense': 'encoder.encoder.layer.*.intermediate.dense',
    'output.dense': 'encoder.encoder.layer.*.output.dense',
    'output.LayerNorm': 'encoder.encoder.layer.*.output.LayerNorm',
    'encoder.encoder.rel_embeddings': 'encoder.encoder.rel_embeddings',
    'encoder.encoder.LayerNorm': 'encoder.encoder.LayerNorm',
    'encoder.upsample.0': 'encoder.upsample.projection',
    'encoder.layer_norm': 'encoder.layer_norm',
    'w2v_model.layer_norm': 'layer_norm',
    'w2v_encoder.proj': 'lm_head',
    'mask_emb': 'masked_spec_embed',
}






def 		_snake_case		(					_SCREAMING_SNAKE_CASE     :						Dict							,		_SCREAMING_SNAKE_CASE     :						Optional[Any]							,		_SCREAMING_SNAKE_CASE     :						Dict							,		_SCREAMING_SNAKE_CASE     :						Tuple							,		_SCREAMING_SNAKE_CASE     :						List[Any]							)			->						str:







	"""simple docstring"""
	for attribute in key.split("""."""							):
		lowerCAmelCase    =	getattr(_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							)

	if weight_type is not None:
		lowerCAmelCase    =	getattr(_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							).shape
	else:
		lowerCAmelCase    =	hf_pointer.shape

	assert hf_shape == value.shape, (
	    f'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'
	    f' {value.shape} for {full_name}'
	)

	if weight_type == "weight":
		lowerCAmelCase    =	value
	elif weight_type == "weight_g":
		lowerCAmelCase    =	value
	elif weight_type == "weight_v":
		lowerCAmelCase    =	value
	elif weight_type == "bias":
		lowerCAmelCase    =	value
	else:
		lowerCAmelCase    =	value

	logger.info(f'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'							)






def 		_snake_case		(					_SCREAMING_SNAKE_CASE     :						List[str]							,		_SCREAMING_SNAKE_CASE     :						Optional[Any]							,		_SCREAMING_SNAKE_CASE     :						Union[str, Any]							)			->						Any:







	"""simple docstring"""
	lowerCAmelCase    =	[]
	lowerCAmelCase    =	fairseq_model.state_dict()

	lowerCAmelCase    =	hf_model.sew_d.feature_extractor if is_finetuned else hf_model.feature_extractor

	for name, value in fairseq_dict.items():
		lowerCAmelCase    =	False
		if "conv_layers" in name:
			load_conv_layer(
			    _SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							,		hf_model.config.feat_extract_norm == """group"""							,		)
			lowerCAmelCase    =	True
		else:
			for key, mapped_key in MAPPING.items():
				lowerCAmelCase    =	"""sew_d.""" + mapped_key if (is_finetuned and mapped_key != """lm_head""") else mapped_key

				if key in name or key.split("""w2v_model."""							)[-1] == name.split("""."""							)[0]:
					lowerCAmelCase    =	True
					if "*" in mapped_key:
						lowerCAmelCase    =	name.split(_SCREAMING_SNAKE_CASE							)[0].split("""."""							)[-2]
						if not layer_index.isnumeric():
							continue
						lowerCAmelCase    =	mapped_key.replace("""*"""							,		_SCREAMING_SNAKE_CASE							)
					if "weight_g" in name:
						lowerCAmelCase    =	"""weight_g"""
					elif "weight_v" in name:
						lowerCAmelCase    =	"""weight_v"""
					elif "weight" in name:
						lowerCAmelCase    =	"""weight"""
					elif "bias" in name:
						lowerCAmelCase    =	"""bias"""
					else:
						lowerCAmelCase    =	None
					set_recursively(_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							)
				continue
		if not is_used:
			unused_weights.append(_SCREAMING_SNAKE_CASE							)

	logger.warning(f'Unused weights: {unused_weights}'							)






def 		_snake_case		(					_SCREAMING_SNAKE_CASE     :						Dict							,		_SCREAMING_SNAKE_CASE     :						Union[str, Any]							,		_SCREAMING_SNAKE_CASE     :						List[str]							,		_SCREAMING_SNAKE_CASE     :						List[Any]							,		_SCREAMING_SNAKE_CASE     :						Optional[int]							)			->						Dict:







	"""simple docstring"""
	lowerCAmelCase    =	full_name.split("""conv_layers."""							)[-1]
	lowerCAmelCase    =	name.split("""."""							)
	lowerCAmelCase    =	int(items[0]							)
	lowerCAmelCase    =	int(items[1]							)

	if type_id == 0:
		if "bias" in name:
			assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
			    f'{full_name} has size {value.shape}, but'
			    f' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'
			)
			lowerCAmelCase    =	value
			logger.info(f'Feat extract conv layer {layer_id} was initialized from {full_name}.'							)
		elif "weight" in name:
			assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
			    f'{full_name} has size {value.shape}, but'
			    f' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'
			)
			lowerCAmelCase    =	value
			logger.info(f'Feat extract conv layer {layer_id} was initialized from {full_name}.'							)
	elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
		if "bias" in name:
			assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
			    f'{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'
			    " found."
			)
			lowerCAmelCase    =	value
			logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'							)
		elif "weight" in name:
			assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
			    f'{full_name} has size {value.shape}, but'
			    f' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'
			)
			lowerCAmelCase    =	value
			logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'							)
	else:
		unused_weights.append(_SCREAMING_SNAKE_CASE							)






def 		_snake_case		(					_SCREAMING_SNAKE_CASE     :						List[str]							,		_SCREAMING_SNAKE_CASE     :						Tuple							)			->						Dict:







	"""simple docstring"""
	lowerCAmelCase    =	SEWDConfig()
	if is_finetuned:
		lowerCAmelCase    =	model.wav_encoder.wav_model.cfg
	else:
		lowerCAmelCase    =	model.cfg

	lowerCAmelCase    =	fs_config.conv_bias
	lowerCAmelCase    =	eval(fs_config.conv_feature_layers							)
	lowerCAmelCase    =	[x[0] for x in conv_layers]
	lowerCAmelCase    =	[x[1] for x in conv_layers]
	lowerCAmelCase    =	[x[2] for x in conv_layers]
	lowerCAmelCase    =	"""gelu"""
	lowerCAmelCase    =	"""layer""" if fs_config.extractor_mode == """layer_norm""" else """group"""
	lowerCAmelCase    =	0.0
	lowerCAmelCase    =	fs_config.activation_fn.name
	lowerCAmelCase    =	fs_config.encoder_embed_dim
	lowerCAmelCase    =	0.02
	lowerCAmelCase    =	fs_config.encoder_ffn_embed_dim
	lowerCAmelCase    =	1E-5
	lowerCAmelCase    =	fs_config.encoder_layerdrop
	lowerCAmelCase    =	fs_config.encoder_attention_heads
	lowerCAmelCase    =	fs_config.conv_pos_groups
	lowerCAmelCase    =	fs_config.conv_pos
	lowerCAmelCase    =	len(_SCREAMING_SNAKE_CASE							)
	lowerCAmelCase    =	fs_config.encoder_layers
	lowerCAmelCase    =	fs_config.squeeze_factor
	# DeBERTa-specific parameters:
	lowerCAmelCase    =	fs_config.max_position_embeddings
	lowerCAmelCase    =	fs_config.position_buckets
	lowerCAmelCase    =	fs_config.share_att_key
	lowerCAmelCase    =	fs_config.relative_attention
	lowerCAmelCase    =	fs_config.position_biased_input
	lowerCAmelCase    =	tuple(fs_config.pos_att_type.split("""|"""							)							)
	lowerCAmelCase    =	fs_config.norm_rel_ebd

	# take care of any params that are overridden by the Wav2VecCtc model
	if is_finetuned:
		lowerCAmelCase    =	model.cfg
		lowerCAmelCase    =	fs_config.final_dropout
		lowerCAmelCase    =	fs_config.layerdrop
	lowerCAmelCase    =	fs_config.activation_dropout
	lowerCAmelCase    =	fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0
	lowerCAmelCase    =	fs_config.attention_dropout
	lowerCAmelCase    =	fs_config.dropout_input
	lowerCAmelCase    =	fs_config.dropout
	lowerCAmelCase    =	fs_config.mask_channel_length
	lowerCAmelCase    =	fs_config.mask_channel_prob
	lowerCAmelCase    =	fs_config.mask_length
	lowerCAmelCase    =	fs_config.mask_prob

	lowerCAmelCase    =	"""Wav2Vec2FeatureExtractor"""
	lowerCAmelCase    =	"""Wav2Vec2CTCTokenizer"""

	return config






@torch.no_grad()
def 		_snake_case		(					_SCREAMING_SNAKE_CASE     :						int							,		_SCREAMING_SNAKE_CASE     :						str							,		_SCREAMING_SNAKE_CASE     :						Dict=None							,		_SCREAMING_SNAKE_CASE     :						Union[str, Any]=None							,		_SCREAMING_SNAKE_CASE     :						Tuple=True							)			->						Optional[Any]:







	"""simple docstring"""

	if is_finetuned:
		lowerCAmelCase,   lowerCAmelCase,   lowerCAmelCase    =	fairseq.checkpoint_utils.load_model_ensemble_and_task(
		    [checkpoint_path]							,		arg_overrides={"""data""": """/""".join(dict_path.split("""/"""							)[:-1]							)}							)
	else:
		lowerCAmelCase,   lowerCAmelCase,   lowerCAmelCase    =	fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]							)

	if config_path is not None:
		lowerCAmelCase    =	SEWDConfig.from_pretrained(_SCREAMING_SNAKE_CASE							)
	else:
		lowerCAmelCase    =	convert_config(model[0]							,		_SCREAMING_SNAKE_CASE							)
	lowerCAmelCase    =	model[0].eval()

	lowerCAmelCase    =	True if config.feat_extract_norm == """layer""" else False
	lowerCAmelCase    =	WavaVecaFeatureExtractor(
	    feature_size=1							,		sampling_rate=16_000							,		padding_value=0							,		do_normalize=_SCREAMING_SNAKE_CASE							,		return_attention_mask=_SCREAMING_SNAKE_CASE							,		)

	if is_finetuned:
		if dict_path:
			lowerCAmelCase    =	Dictionary.load(_SCREAMING_SNAKE_CASE							)

			# important change bos & pad token id since CTC symbol is <pad> and
			# not <s> as in fairseq
			lowerCAmelCase    =	target_dict.pad_index
			lowerCAmelCase    =	target_dict.bos_index
			lowerCAmelCase    =	target_dict.pad_index
			lowerCAmelCase    =	target_dict.bos_index
			lowerCAmelCase    =	target_dict.eos_index
			lowerCAmelCase    =	len(target_dict.symbols							)
			lowerCAmelCase    =	os.path.join(_SCREAMING_SNAKE_CASE							,		"""vocab.json"""							)
			if not os.path.isdir(_SCREAMING_SNAKE_CASE							):
				logger.error("""--pytorch_dump_folder_path ({}) should be a directory""".format(_SCREAMING_SNAKE_CASE							)							)
				return
			os.makedirs(_SCREAMING_SNAKE_CASE							,		exist_ok=_SCREAMING_SNAKE_CASE							)
			with open(_SCREAMING_SNAKE_CASE							,		"""w"""							,		encoding="""utf-8"""							) as vocab_handle:
				json.dump(target_dict.indices							,		_SCREAMING_SNAKE_CASE							)
			lowerCAmelCase    =	WavaVecaCTCTokenizer(
			    _SCREAMING_SNAKE_CASE							,		unk_token=target_dict.unk_word							,		pad_token=target_dict.pad_word							,		bos_token=target_dict.bos_word							,		eos_token=target_dict.eos_word							,		word_delimiter_token="""|"""							,		do_lower_case=_SCREAMING_SNAKE_CASE							,		)
			lowerCAmelCase    =	WavaVecaProcessor(feature_extractor=_SCREAMING_SNAKE_CASE							,		tokenizer=_SCREAMING_SNAKE_CASE							)
			processor.save_pretrained(_SCREAMING_SNAKE_CASE							)

		lowerCAmelCase    =	SEWDForCTC(_SCREAMING_SNAKE_CASE							)
	else:
		lowerCAmelCase    =	SEWDModel(_SCREAMING_SNAKE_CASE							)
		feature_extractor.save_pretrained(_SCREAMING_SNAKE_CASE							)

	recursively_load_weights(_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							,		_SCREAMING_SNAKE_CASE							)

	hf_model.save_pretrained(_SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
				UpperCAmelCase			=    argparse.ArgumentParser()
				parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
				parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to fairseq checkpoint')
				parser.add_argument('--dict_path', default=None, type=str, help='Path to dict of fine-tuned model')
				parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
				parser.add_argument(
				    '--is_finetuned', action='store_true', help='Whether the model to convert is a fine-tuned model or not'
				)
				UpperCAmelCase			=    parser.parse_args()
				convert_sew_checkpoint(
				    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned
				)




'''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			=    {
    'google/bigbird-pegasus-large-arxiv': (
        'https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json'
    ),
    'google/bigbird-pegasus-large-pubmed': (
        'https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json'
    ),
    'google/bigbird-pegasus-large-bigpatent': (
        'https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json'
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}

class __snake_case(      _lowerCAmelCase					):


						'''simple docstring'''



						UpperCAmelCase							:    Union[str, Any]           =		"bigbird_pegasus"
						UpperCAmelCase							:    Optional[Any]           =		["past_key_values"]
						UpperCAmelCase							:    Optional[Any]           =		{
						    "num_attention_heads": "encoder_attention_heads",
						    "hidden_size": "d_model",
						    "attention_probs_dropout_prob": "attention_dropout",
						}


						def __init__(					self	,       A_=9_6103	,       A_=4096	,       A_=16	,       A_=4096	,       A_=16	,       A_=16	,       A_=4096	,       A_=16	,       A_=0.0	,       A_=0.0	,       A_=True	,       A_=True	,       A_="gelu_new"	,       A_=1024	,       A_=0.1	,       A_=0.0	,       A_=0.0	,       A_=0.0_2	,       A_=2	,       A_=0.0	,       A_=True	,       A_=0	,       A_=2	,       A_=1	,       A_="block_sparse"	,       A_=64	,       A_=3	,       A_=False	,       **A_	,       )	->	List[str]:
							lowerCAmelCase    =	vocab_size
							lowerCAmelCase    =	max_position_embeddings
							lowerCAmelCase    =	d_model
							lowerCAmelCase    =	encoder_ffn_dim
							lowerCAmelCase    =	encoder_layers
							lowerCAmelCase    =	encoder_attention_heads
							lowerCAmelCase    =	decoder_ffn_dim
							lowerCAmelCase    =	decoder_layers
							lowerCAmelCase    =	decoder_attention_heads
							lowerCAmelCase    =	dropout
							lowerCAmelCase    =	attention_dropout
							lowerCAmelCase    =	activation_dropout
							lowerCAmelCase    =	activation_function
							lowerCAmelCase    =	init_std
							lowerCAmelCase    =	encoder_layerdrop
							lowerCAmelCase    =	decoder_layerdrop
							lowerCAmelCase    =	classifier_dropout
							lowerCAmelCase    =	use_cache
							lowerCAmelCase    =	encoder_layers
							lowerCAmelCase    =	scale_embedding  # scale factor will be sqrt(d_model) if True

							# extra config
							lowerCAmelCase    =	attention_type
							lowerCAmelCase    =	block_size
							lowerCAmelCase    =	num_random_blocks
							lowerCAmelCase    =	use_bias

							super().__init__(
							    pad_token_id=A_	,       bos_token_id=A_	,       eos_token_id=A_	,       is_encoder_decoder=A_	,       decoder_start_token_id=A_	,       **A_	,       )







class __snake_case(      _lowerCAmelCase					):


						'''simple docstring'''



						@property
						def 				__snake_case    (					self      )	->	Mapping[str, Mapping[int, str]]:
							if self.task in ["default", "seq2seq-lm"]:
								lowerCAmelCase    =	OrderedDict(
								    [
								        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
								        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
								    ]      )

								if self.use_past:
									lowerCAmelCase    =	{0: """batch"""}
									lowerCAmelCase    =	{0: """batch""", 1: """past_decoder_sequence + sequence"""}
								else:
									lowerCAmelCase    =	{0: """batch""", 1: """decoder_sequence"""}
									lowerCAmelCase    =	{0: """batch""", 1: """decoder_sequence"""}

								if self.use_past:
									self.fill_with_past_key_values_(A_	,       direction="""inputs"""      )
							elif self.task == "causal-lm":
								# TODO: figure this case out.
								lowerCAmelCase    =	OrderedDict(
								    [
								        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
								        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
								    ]      )
								if self.use_past:
									lowerCAmelCase,   lowerCAmelCase    =	self.num_layers
									for i in range(A_      ):
										lowerCAmelCase    =	{0: """batch""", 2: """past_sequence + sequence"""}
										lowerCAmelCase    =	{0: """batch""", 2: """past_sequence + sequence"""}
							else:
								lowerCAmelCase    =	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 				__snake_case    (					self      )	->	Mapping[str, Mapping[int, str]]:
							if self.task in ["default", "seq2seq-lm"]:
								lowerCAmelCase    =	super().outputs
							else:
								lowerCAmelCase    =	super(A_	,       self      ).outputs
								if self.use_past:
									lowerCAmelCase,   lowerCAmelCase    =	self.num_layers
									for i in range(A_      ):
										lowerCAmelCase    =	{0: """batch""", 2: """past_sequence + sequence"""}
										lowerCAmelCase    =	{0: """batch""", 2: """past_sequence + sequence"""}
							return common_outputs


						def 				__snake_case    (					self	,       A_	,       A_ = -1	,       A_ = -1	,       A_ = False	,       A_ = None	,       )	->	Mapping[str, Any]:
							lowerCAmelCase    =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    A_	,       A_	,       A_	,       A_	,       A_      )

							# Generate decoder inputs
							lowerCAmelCase    =	seq_length if not self.use_past else 1
							lowerCAmelCase    =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    A_	,       A_	,       A_	,       A_	,       A_      )
							lowerCAmelCase    =	{f'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
							lowerCAmelCase    =	dict(**A_	,       **A_      )

							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
								lowerCAmelCase    =	common_inputs["""decoder_input_ids"""].shape[1]
								lowerCAmelCase,   lowerCAmelCase    =	self.num_attention_heads
								lowerCAmelCase    =	(
								    batch,
								    num_encoder_attention_heads,
								    encoder_seq_length,
								    self._config.hidden_size // num_encoder_attention_heads,
								)
								lowerCAmelCase    =	decoder_seq_length + 3
								lowerCAmelCase    =	(
								    batch,
								    num_decoder_attention_heads,
								    decoder_past_length,
								    self._config.hidden_size // num_decoder_attention_heads,
								)

								lowerCAmelCase    =	torch.cat(
								    [common_inputs["""decoder_attention_mask"""], torch.ones(A_	,       A_      )]	,       dim=1      )

								lowerCAmelCase    =	[]
								# If the number of encoder and decoder layers are present in the model configuration, both are considered
								lowerCAmelCase,   lowerCAmelCase    =	self.num_layers
								lowerCAmelCase    =	min(A_	,       A_      )
								lowerCAmelCase    =	max(A_	,       A_      ) - min_num_layers
								lowerCAmelCase    =	"""encoder""" if num_encoder_layers > num_decoder_layers else """decoder"""

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


						def 				__snake_case    (					self	,       A_	,       A_ = -1	,       A_ = -1	,       A_ = False	,       A_ = None	,       )	->	Mapping[str, Any]:
							lowerCAmelCase    =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    A_	,       A_	,       A_	,       A_	,       A_      )

							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,   lowerCAmelCase    =	self.num_layers
								lowerCAmelCase,   lowerCAmelCase    =	self.num_attention_heads
								lowerCAmelCase    =	(
								    batch,
								    num_encoder_attention_heads,
								    past_key_values_length,
								    self._config.hidden_size // num_encoder_attention_heads,
								)

								lowerCAmelCase    =	common_inputs["""attention_mask"""].dtype
								lowerCAmelCase    =	torch.cat(
								    [common_inputs["""attention_mask"""], torch.ones(A_	,       A_	,       dtype=A_      )]	,       dim=1      )
								lowerCAmelCase    =	[
								    (torch.zeros(A_      ), torch.zeros(A_      )) for _ in range(A_      )
								]
							return common_inputs


						def 				__snake_case    (					self	,       A_	,       A_ = -1	,       A_ = -1	,       A_ = False	,       A_ = None	,       )	->	Mapping[str, Any]:
							# Copied from OnnxConfig.generate_dummy_inputs
							# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
							# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
							lowerCAmelCase    =	compute_effective_axis_dimension(
							    A_	,       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
							lowerCAmelCase    =	tokenizer.num_special_tokens_to_add(A_      )
							lowerCAmelCase    =	compute_effective_axis_dimension(
							    A_	,       fixed_dimension=OnnxConfig.default_fixed_sequence	,       num_token_to_add=A_      )

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


						def 				__snake_case    (					self	,       A_	,       A_ = -1	,       A_ = -1	,       A_ = False	,       A_ = None	,       )	->	Mapping[str, Any]:
							if self.task in ["default", "seq2seq-lm"]:
								lowerCAmelCase    =	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
								    A_	,       batch_size=A_	,       seq_length=A_	,       is_pair=A_	,       framework=A_      )

							elif self.task == "causal-lm":
								lowerCAmelCase    =	self._generate_dummy_inputs_for_causal_lm(
								    A_	,       batch_size=A_	,       seq_length=A_	,       is_pair=A_	,       framework=A_      )
							else:
								lowerCAmelCase    =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
								    A_	,       batch_size=A_	,       seq_length=A_	,       is_pair=A_	,       framework=A_      )

							return common_inputs




						def 				__snake_case    (					self	,       A_	,       A_	,       A_	,       A_      )	->	Tuple:
							if self.task in ["default", "seq2seq-lm"]:
								lowerCAmelCase    =	super()._flatten_past_key_values_(A_	,       A_	,       A_	,       A_      )
							else:
								lowerCAmelCase    =	super(A_	,       self      )._flatten_past_key_values_(
								    A_	,       A_	,       A_	,       A_      )