code: 
  '''simple docstring'''
  
  import inspect
  import os
  from argparse import ArgumentParser, Namespace
  from importlib import import_module
  
  import huggingface_hub
  import numpy as np
  from packaging import version
  
  from .. import (
      FEATURE_EXTRACTOR_MAPPING,
      IMAGE_PROCESSOR_MAPPING,
      PROCESSOR_MAPPING,
      TOKENIZER_MAPPING,
      AutoConfig,
      AutoFeatureExtractor,
      AutoImageProcessor,
      AutoProcessor,
      AutoTokenizer,
      is_datasets_available,
      is_tf_available,
      is_torch_available,
  )
  from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
  from . import BaseTransformersCLICommand
  
  
  if is_tf_available():
  	import tensorflow as tf
  
  	tf.config.experimental.enable_tensor_float_aa_execution(False)
  
  if is_torch_available():
  	import torch
  
  if is_datasets_available():
  	from datasets import load_dataset
  
  
  _UpperCAmelCase   :      int 						=  5E-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase	) ->      List[str]:
  		return PTtoTFCommand(
  		    args.model_name			,args.local_dir			,args.max_error			,args.new_weights			,args.no_pr			,args.push			,args.extra_commit_description			,args.override_model_class			,)
  
  
  class 			UpperCAmelCase				(					a_ ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		@staticmethod
  		def _lowercase  (    _snake_case     )				->    Any:
  				_UpperCamelCase       : Any    =      parser.add_parser(
  				    '''pt-to-tf'''  ,					help=(
  				        '''CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint.'''
  				        ''' Can also be used to validate existing weights without opening PRs, with --no-pr.'''
  				    )  ,					)
  				train_parser.add_argument(
  				    '''--model-name'''  ,					type=_snake_case  ,					required=_snake_case  ,					help='''The model name, including owner/organization, as seen on the hub.'''  ,					)
  				train_parser.add_argument(
  				    '''--local-dir'''  ,					type=_snake_case  ,					default=''''''  ,					help='''Optional local directory of the model repository. Defaults to /tmp/{model_name}'''  ,					)
  				train_parser.add_argument(
  				    '''--max-error'''  ,					type=_snake_case  ,					default=_snake_case  ,					help=(
  				        F'''Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk.'''
  				    )  ,					)
  				train_parser.add_argument(
  				    '''--new-weights'''  ,					action='''store_true'''  ,					help='''Optional flag to create new TensorFlow weights, even if they already exist.'''  ,					)
  				train_parser.add_argument(
  				    '''--no-pr'''  ,					action='''store_true'''  ,					help='''Optional flag to NOT open a PR with converted weights.'''     )
  				train_parser.add_argument(
  				    '''--push'''  ,					action='''store_true'''  ,					help='''Optional flag to push the weights directly to `main` (requires permissions)'''  ,					)
  				train_parser.add_argument(
  				    '''--extra-commit-description'''  ,					type=_snake_case  ,					default=''''''  ,					help='''Optional additional commit description to use when opening a PR (e.g. to tag the owner).'''  ,					)
  				train_parser.add_argument(
  				    '''--override-model-class'''  ,					type=_snake_case  ,					default=_snake_case  ,					help='''If you think you know better than the auto-detector, you can specify the model class here. '''
  				    '''Can be either an AutoModel class or a specific model class like BertForSequenceClassification.'''  ,					)
  				train_parser.set_defaults(func=_snake_case     )
  		@staticmethod
  		def _lowercase  (    _snake_case  ,					_snake_case     )				->    List[str]:
  				_UpperCamelCase       : Any    =      set(pt_outputs.keys()     )
  				_UpperCamelCase       : Dict    =      set(tf_outputs.keys()     )
  				if pt_out_attrs != tf_out_attrs:
  						raise ValueError(
  						    F'''The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:'''
  						    F''' {tf_out_attrs})'''     )
  
  				# 2. For each output attribute, computes the difference
  				def _find_pt_tf_differences(_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case=""     ):
  						# If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
  						# recursivelly, keeping the name of the attribute.
  						if isinstance(_snake_case  ,					torch.Tensor     ):
  								_UpperCamelCase       : Optional[int]    =      np.max(np.abs(pt_out.numpy() - tf_out.numpy()     )     )
  								_UpperCamelCase       : str    =      tensor_difference
  						else:
  								_UpperCamelCase       : List[Any]    =      attr_name
  								for i, pt_item in enumerate(_snake_case     ):
  										# If it is a named attribute, we keep the name. Otherwise, just its index.
  										if isinstance(_snake_case  ,					_snake_case     ):
  												_UpperCamelCase       : Dict    =      root_name + pt_item
  												_UpperCamelCase       : str    =      tf_out[pt_item]
  												_UpperCamelCase       : List[str]    =      pt_out[pt_item]
  										else:
  												_UpperCamelCase       : List[str]    =      root_name + F'''[{i}]'''
  												_UpperCamelCase       : List[str]    =      tf_out[i]
  										_UpperCamelCase       : List[Any]    =      _find_pt_tf_differences(_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case     )
  
  						return differences
  
  				return _find_pt_tf_differences(_snake_case  ,					_snake_case  ,					{}     )
  		def __init__(    self  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					*_snake_case  ,					)				->    Tuple:
  				_UpperCamelCase       : int    =      logging.get_logger('''transformers-cli/pt_to_tf'''     )
  				_UpperCamelCase       : List[Any]    =      model_name
  				_UpperCamelCase       : Any    =      local_dir if local_dir else os.path.join('''/tmp'''  ,					_snake_case     )
  				_UpperCamelCase       : Optional[int]    =      max_error
  				_UpperCamelCase       : Optional[int]    =      new_weights
  				_UpperCamelCase       : Dict    =      no_pr
  				_UpperCamelCase       : Tuple    =      push
  				_UpperCamelCase       : Tuple    =      extra_commit_description
  				_UpperCamelCase       : List[Any]    =      override_model_class
  		def _lowercase  (    self  ,					_snake_case  ,					_snake_case  ,					_snake_case     )				->    Tuple:
  
  				def _get_audio_input():
  						_UpperCamelCase       : Dict    =      load_dataset('''hf-internal-testing/librispeech_asr_dummy'''  ,					'''clean'''  ,					split='''validation'''     )
  						_UpperCamelCase       : Union[str, Any]    =      ds.sort('''id'''     ).select(range(2     )     )[:2]['''audio''']
  						_UpperCamelCase       : Dict    =      [x['''array'''] for x in speech_samples]
  						return raw_samples
  
  				_UpperCamelCase       : Optional[int]    =      type(pt_model.config     )
  				if model_config_class in PROCESSOR_MAPPING:
  						_UpperCamelCase       : Optional[Any]    =      AutoProcessor.from_pretrained(self._local_dir     )
  						if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
  								_UpperCamelCase       : List[Any]    =      processor.tokenizer.eos_token
  				elif model_config_class in IMAGE_PROCESSOR_MAPPING:
  						_UpperCamelCase       : Optional[Any]    =      AutoImageProcessor.from_pretrained(self._local_dir     )
  				elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
  						_UpperCamelCase       : Any    =      AutoFeatureExtractor.from_pretrained(self._local_dir     )
  				elif model_config_class in TOKENIZER_MAPPING:
  						_UpperCamelCase       : Any    =      AutoTokenizer.from_pretrained(self._local_dir     )
  						if processor.pad_token is None:
  								_UpperCamelCase       : Optional[Any]    =      processor.eos_token
  				else:
  						raise ValueError(F'''Unknown data processing type (model config type: {model_config_class})'''     )
  
  				_UpperCamelCase       : Optional[int]    =      set(inspect.signature(pt_model.forward     ).parameters.keys()     )
  				_UpperCamelCase       : Optional[int]    =      {}
  				if "input_ids" in model_forward_signature:
  						processor_inputs.update(
  						    {
  						        '''text''': ['''Hi there!''', '''I am a batch with more than one row and different input lengths.'''],
  						        '''padding''': True,
  						        '''truncation''': True,
  						    }     )
  				if "pixel_values" in model_forward_signature:
  						_UpperCamelCase       : Optional[int]    =      load_dataset('''cifar10'''  ,					'''plain_text'''  ,					split='''test'''     )[:2]['''img''']
  						processor_inputs.update({'''images''': sample_images}     )
  				if "input_features" in model_forward_signature:
  						_UpperCamelCase       : Optional[Any]    =      inspect.signature(processor.feature_extractor     ).parameters
  						# Pad to the largest input length by default but take feature extractor default
  						# padding value if it exists e.g. "max_length" and is not False or None
  						if "padding" in feature_extractor_signature:
  								_UpperCamelCase       : Any    =      feature_extractor_signature['''padding'''].default
  								if default_strategy is not False and default_strategy is not None:
  										_UpperCamelCase       : int    =      default_strategy
  								else:
  										_UpperCamelCase       : Any    =      True
  						else:
  								_UpperCamelCase       : int    =      True
  						processor_inputs.update({'''audio''': _get_audio_input(), '''padding''': padding_strategy}     )
  				if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
  						processor_inputs.update({'''audio''': _get_audio_input(), '''padding''': True}     )
  				_UpperCamelCase       : Optional[int]    =      processor(**_snake_case  ,					return_tensors='''pt'''     )
  				_UpperCamelCase       : List[str]    =      processor(**_snake_case  ,					return_tensors='''tf'''     )
  
  				# Extra input requirements, in addition to the input modality
  				if (
  				    config.is_encoder_decoder
  				    or (hasattr(_snake_case  ,					'''encoder'''     ) and hasattr(_snake_case  ,					'''decoder'''     ))
  				    or "decoder_input_ids" in tf_dummy_inputs
  				):
  						_UpperCamelCase       : Dict    =      np.asarray([[1], [1]]  ,					dtype=_snake_case     ) * (pt_model.config.decoder_start_token_id or 0)
  						pt_input.update({'''decoder_input_ids''': torch.tensor(_snake_case     )}     )
  						tf_input.update({'''decoder_input_ids''': tf.convert_to_tensor(_snake_case     )}     )
  
  				return pt_input, tf_input
  
  
  
  
  		def _lowercase  (    self     )				->    Optional[int]:
  				# hub version 0.9.0 introduced the possibility of programmatically opening PRs with normal write tokens.
  				if version.parse(huggingface_hub.__version__     ) < version.parse('''0.9.0'''     ):
  						raise ImportError(
  						    '''The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub'''
  						    ''' installation.'''     )
  				else:
  						from huggingface_hub import Repository, create_commit
  						from huggingface_hub._commit_api import CommitOperationAdd
  
  				# Fetch remote data
  				_UpperCamelCase       : Dict    =      Repository(local_dir=self._local_dir  ,					clone_from=self._model_name     )
  
  				# Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
  				_UpperCamelCase       : int    =      AutoConfig.from_pretrained(self._local_dir     )
  				_UpperCamelCase       : int    =      config.architectures
  				if self._override_model_class is not None:
  						if self._override_model_class.startswith('''TF'''     ):
  								_UpperCamelCase       : str    =      [self._override_model_class[2:]]
  						else:
  								_UpperCamelCase       : int    =      [self._override_model_class]
  						try:
  								_UpperCamelCase       : Any    =      getattr(import_module('''transformers'''     )  ,					architectures[0]     )
  						except AttributeError:
  								raise ValueError(F'''Model class {self._override_model_class} not found in transformers.'''     )
  						try:
  								_UpperCamelCase       : Union[str, Any]    =      getattr(import_module('''transformers'''     )  ,					'''TF''' + architectures[0]     )
  						except AttributeError:
  								raise ValueError(F'''TF model class TF{self._override_model_class} not found in transformers.'''     )
  				elif architectures is None:  # No architecture defined -- use auto classes
  						_UpperCamelCase       : List[str]    =      getattr(import_module('''transformers'''     )  ,					'''AutoModel'''     )
  						_UpperCamelCase       : Tuple    =      getattr(import_module('''transformers'''     )  ,					'''TFAutoModel'''     )
  						self._logger.warning('''No detected architecture, using AutoModel/TFAutoModel'''     )
  				else:  # Architecture defined -- use it
  						if len(_snake_case     ) > 1:
  								raise ValueError(F'''More than one architecture was found, aborting. (architectures = {architectures})'''     )
  						self._logger.warning(F'''Detected architecture: {architectures[0]}'''     )
  						_UpperCamelCase       : Tuple    =      getattr(import_module('''transformers'''     )  ,					architectures[0]     )
  						try:
  								_UpperCamelCase       : List[str]    =      getattr(import_module('''transformers'''     )  ,					'''TF''' + architectures[0]     )
  						except AttributeError:
  								raise AttributeError(F'''The TensorFlow equivalent of {architectures[0]} doesn\'t exist in transformers.'''     )
  
          # Check the TF dummy inputs to see what keys we need in the forward pass
  				_UpperCamelCase       : Tuple    =      tf_class.from_config(_snake_case     )
  				_UpperCamelCase       : List[Any]    =      tf_from_pt_model.dummy_inputs
  
  				del tf_from_pt_model  # Try to keep only one model in memory at a time
  
  				# Load the model and get some basic inputs
  				_UpperCamelCase       : Any    =      pt_class.from_pretrained(self._local_dir     )
  				pt_model.eval()
  
  				_UpperCamelCase,							_UpperCamelCase       : List[Any]    =      self.get_inputs(_snake_case  ,					_snake_case  ,					_snake_case     )
  
  				with torch.no_grad():
  						_UpperCamelCase       : List[Any]    =      pt_model(**_snake_case  ,					output_hidden_states=_snake_case     )
  				del pt_model  # will no longer be used, and may have a large memory footprint
  
  				_UpperCamelCase       : Union[str, Any]    =      tf_class.from_pretrained(self._local_dir  ,					from_pt=_snake_case     )
  				_UpperCamelCase       : Tuple    =      tf_from_pt_model(**_snake_case  ,					output_hidden_states=_snake_case  ,					training=_snake_case     )
  
  				# Confirms that cross loading PT weights into TF worked.
  				_UpperCamelCase       : Any    =      self.find_pt_tf_differences(_snake_case  ,					_snake_case     )
  				_UpperCamelCase       : List[str]    =      {k: v for k, v in crossload_differences.items() if '''hidden''' not in k}
  				_UpperCamelCase       : Optional[int]    =      {k: v for k, v in crossload_differences.items() if '''hidden''' in k}
  				if len(_snake_case     ) == 0 and architectures is not None:
  						raise ValueError(
  						    F'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
  						    ''' output was found. All outputs start with \'hidden\''''     )
  				_UpperCamelCase       : Union[str, Any]    =      max(output_differences.values()     ) if output_differences else 0.0
  				_UpperCamelCase       : int    =      max(hidden_differences.values()     )
  				if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
  						raise ValueError(
  						    '''The cross-loaded TensorFlow model has different outputs, something went wrong!\n'''
  						    + F'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
  						    + '''\n'''.join([F'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]     )
  						    + F'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
  						    + '''\n'''.join([F'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]     )     )
  
  				# Save the weights in a TF format (if needed) and confirms that the results are still good
  				_UpperCamelCase       : Dict    =      os.path.join(self._local_dir  ,					_snake_case     )
  				_UpperCamelCase       : Union[str, Any]    =      os.path.join(self._local_dir  ,					_snake_case     )
  				if (not os.path.exists(_snake_case     ) and not os.path.exists(_snake_case     )) or self._new_weights:
  						tf_from_pt_model.save_pretrained(self._local_dir     )
  				del tf_from_pt_model  # will no longer be used, and may have a large memory footprint
  
  				_UpperCamelCase       : Optional[int]    =      tf_class.from_pretrained(self._local_dir     )
  				_UpperCamelCase       : Any    =      tf_model(**_snake_case  ,					output_hidden_states=_snake_case     )
  
  				_UpperCamelCase       : int    =      self.find_pt_tf_differences(_snake_case  ,					_snake_case     )
  				_UpperCamelCase       : str    =      {k: v for k, v in conversion_differences.items() if '''hidden''' not in k}
  				_UpperCamelCase       : List[str]    =      {k: v for k, v in conversion_differences.items() if '''hidden''' in k}
  				if len(_snake_case     ) == 0 and architectures is not None:
  						raise ValueError(
  						    F'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
  						    ''' output was found. All outputs start with \'hidden\''''     )
  				_UpperCamelCase       : Any    =      max(output_differences.values()     ) if output_differences else 0.0
  				_UpperCamelCase       : Union[str, Any]    =      max(hidden_differences.values()     )
  				if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
  						raise ValueError(
  						    '''The converted TensorFlow model has different outputs, something went wrong!\n'''
  						    + F'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
  						    + '''\n'''.join([F'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]     )
  						    + F'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
  						    + '''\n'''.join([F'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]     )     )
  
  				_UpperCamelCase       : Dict    =      '''Update TF weights''' if self._new_weights else '''Add TF weights'''
  				if self._push:
  						repo.git_add(auto_lfs_track=_snake_case     )
  						repo.git_commit(_snake_case     )
  						repo.git_push(blocking=_snake_case     )  # this prints a progress bar with the upload
  						self._logger.warning(F'''TF weights pushed into {self._model_name}'''     )
  				elif not self._no_pr:
  						self._logger.warning('''Uploading the weights into a new PR...'''     )
  						_UpperCamelCase       : int    =      (
  						    '''Model converted by the [`transformers`\' `pt_to_tf`'''
  						    ''' CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). '''
  						    '''All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n'''
  						    F'''Maximum crossload output difference={max_crossload_output_diff:.3e}; '''
  						    F'''Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n'''
  						    F'''Maximum conversion output difference={max_conversion_output_diff:.3e}; '''
  						    F'''Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n'''
  						)
  						if self._max_error > MAX_ERROR:
  								commit_descrition += (
  								    F'''\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!'''
  								)
  						if self._extra_commit_description:
  								commit_descrition += "\n\n" + self._extra_commit_description
  
  						# sharded model -> adds all related files (index and .h5 shards)
  						if os.path.exists(_snake_case     ):
  								_UpperCamelCase       : int    =      [
  								    CommitOperationAdd(path_in_repo=_snake_case  ,					path_or_fileobj=_snake_case     )
  								]
  								for shard_path in tf.io.gfile.glob(self._local_dir + '''/tf_model-*.h5'''     ):
  										operations += [
  										    CommitOperationAdd(path_in_repo=os.path.basename(_snake_case     )  ,					path_or_fileobj=_snake_case     )
  										]
  						else:
  								_UpperCamelCase       : str    =      [CommitOperationAdd(path_in_repo=_snake_case  ,					path_or_fileobj=_snake_case     )]
  
  						_UpperCamelCase       : List[Any]    =      create_commit(
  						    repo_id=self._model_name  ,					operations=_snake_case  ,					commit_message=_snake_case  ,					commit_description=_snake_case  ,					repo_type='''model'''  ,					create_pr=_snake_case  ,					).pr_url
  						self._logger.warning(F'''PR open in {hub_pr_url}'''     )
  
  
  
  
  
  
style_context: 
  '''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   :      Optional[int] 						=  logging.get_logger(__name__)
  
  _UpperCAmelCase   :      Any 						=  {
      """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 			UpperCAmelCase				(					a_ ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		A__  :   List[str]          =    'bigbird_pegasus'
  		A__  :   Union[str, Any]          =    ['past_key_values']
  		A__  :   Optional[int]          =    {
  		    'num_attention_heads': 'encoder_attention_heads',
  		    'hidden_size': 'd_model',
  		    'attention_probs_dropout_prob': 'attention_dropout',
  		}
  		def __init__(    self  ,					_snake_case=96103  ,					_snake_case=4096  ,					_snake_case=16  ,					_snake_case=4096  ,					_snake_case=16  ,					_snake_case=16  ,					_snake_case=4096  ,					_snake_case=16  ,					_snake_case=0.0  ,					_snake_case=0.0  ,					_snake_case=True  ,					_snake_case=True  ,					_snake_case="gelu_new"  ,					_snake_case=1024  ,					_snake_case=0.1  ,					_snake_case=0.0  ,					_snake_case=0.0  ,					_snake_case=0.02  ,					_snake_case=2  ,					_snake_case=0.0  ,					_snake_case=True  ,					_snake_case=0  ,					_snake_case=2  ,					_snake_case=1  ,					_snake_case="block_sparse"  ,					_snake_case=64  ,					_snake_case=3  ,					_snake_case=False  ,					**_snake_case  ,					)				->    Optional[Any]:
  				_UpperCamelCase       : str    =      vocab_size
  				_UpperCamelCase       : Tuple    =      max_position_embeddings
  				_UpperCamelCase       : int    =      d_model
  				_UpperCamelCase       : List[str]    =      encoder_ffn_dim
  				_UpperCamelCase       : str    =      encoder_layers
  				_UpperCamelCase       : Dict    =      encoder_attention_heads
  				_UpperCamelCase       : str    =      decoder_ffn_dim
  				_UpperCamelCase       : List[str]    =      decoder_layers
  				_UpperCamelCase       : Any    =      decoder_attention_heads
  				_UpperCamelCase       : str    =      dropout
  				_UpperCamelCase       : int    =      attention_dropout
  				_UpperCamelCase       : Optional[int]    =      activation_dropout
  				_UpperCamelCase       : Optional[Any]    =      activation_function
  				_UpperCamelCase       : Tuple    =      init_std
  				_UpperCamelCase       : Any    =      encoder_layerdrop
  				_UpperCamelCase       : List[str]    =      decoder_layerdrop
  				_UpperCamelCase       : Any    =      classifier_dropout
  				_UpperCamelCase       : int    =      use_cache
  				_UpperCamelCase       : Union[str, Any]    =      encoder_layers
  				_UpperCamelCase       : str    =      scale_embedding  # scale factor will be sqrt(d_model) if True
  
  				# extra config
  				_UpperCamelCase       : str    =      attention_type
  				_UpperCamelCase       : Tuple    =      block_size
  				_UpperCamelCase       : Optional[Any]    =      num_random_blocks
  				_UpperCamelCase       : Dict    =      use_bias
  
  				super().__init__(
  				    pad_token_id=_snake_case  ,					bos_token_id=_snake_case  ,					eos_token_id=_snake_case  ,					is_encoder_decoder=_snake_case  ,					decoder_start_token_id=_snake_case  ,					**_snake_case  ,					)
  
  
  
  
  
  
  
  class 			UpperCAmelCase				(					a_ ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		@property
  		def _lowercase  (    self     )				->    Mapping[str, Mapping[int, str]]:
  				if self.task in ["default", "seq2seq-lm"]:
  						_UpperCamelCase       : str    =      OrderedDict(
  						    [
  						        ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
  						        ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
  						    ]     )
  
  						if self.use_past:
  								_UpperCamelCase       : List[Any]    =      {0: '''batch'''}
  								_UpperCamelCase       : Tuple    =      {0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
  						else:
  								_UpperCamelCase       : Union[str, Any]    =      {0: '''batch''', 1: '''decoder_sequence'''}
  								_UpperCamelCase       : Union[str, Any]    =      {0: '''batch''', 1: '''decoder_sequence'''}
  
  						if self.use_past:
  								self.fill_with_past_key_values_(_snake_case  ,					direction='''inputs'''     )
  				elif self.task == "causal-lm":
  						# TODO: figure this case out.
  						_UpperCamelCase       : Optional[int]    =      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(_snake_case     ):
  										_UpperCamelCase       : Optional[int]    =      {0: '''batch''', 2: '''past_sequence + sequence'''}
  										_UpperCamelCase       : Dict    =      {0: '''batch''', 2: '''past_sequence + sequence'''}
  				else:
  						_UpperCamelCase       : Optional[int]    =      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 _lowercase  (    self     )				->    Mapping[str, Mapping[int, str]]:
  				if self.task in ["default", "seq2seq-lm"]:
  						_UpperCamelCase       : int    =      super().outputs
  				else:
  						_UpperCamelCase       : Optional[int]    =      super(_snake_case  ,					self     ).outputs
  						if self.use_past:
  								_UpperCamelCase,							_UpperCamelCase       : Tuple    =      self.num_layers
  								for i in range(_snake_case     ):
  										_UpperCamelCase       : int    =      {0: '''batch''', 2: '''past_sequence + sequence'''}
  										_UpperCamelCase       : Optional[int]    =      {0: '''batch''', 2: '''past_sequence + sequence'''}
  				return common_outputs
  		def _lowercase  (    self  ,					_snake_case  ,					_snake_case = -1  ,					_snake_case = -1  ,					_snake_case = False  ,					_snake_case = None  ,					)				->    Mapping[str, Any]:
  				_UpperCamelCase       : List[str]    =      self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
  				    _snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case     )
  
  				# Generate decoder inputs
  				_UpperCamelCase       : Optional[int]    =      seq_length if not self.use_past else 1
  				_UpperCamelCase       : Optional[int]    =      self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
  				    _snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case     )
  				_UpperCamelCase       : Optional[int]    =      {F'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
  				_UpperCamelCase       : Any    =      dict(**_snake_case  ,					**_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       : Dict    =      common_inputs['''input_ids'''].shape
  						_UpperCamelCase       : Dict    =      common_inputs['''decoder_input_ids'''].shape[1]
  						_UpperCamelCase,							_UpperCamelCase       : List[Any]    =      self.num_attention_heads
  						_UpperCamelCase       : List[Any]    =      (
  						    batch,
  						    num_encoder_attention_heads,
  						    encoder_seq_length,
  						    self._config.hidden_size // num_encoder_attention_heads,
  						)
  						_UpperCamelCase       : int    =      decoder_seq_length + 3
  						_UpperCamelCase       : Union[str, Any]    =      (
  						    batch,
  						    num_decoder_attention_heads,
  						    decoder_past_length,
  						    self._config.hidden_size // num_decoder_attention_heads,
  						)
  
  						_UpperCamelCase       : Any    =      torch.cat(
  						    [common_inputs['''decoder_attention_mask'''], torch.ones(_snake_case  ,					_snake_case     )]  ,					dim=1     )
  
  						_UpperCamelCase       : 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       : Union[str, Any]    =      min(_snake_case  ,					_snake_case     )
  						_UpperCamelCase       : Union[str, Any]    =      max(_snake_case  ,					_snake_case     ) - min_num_layers
  						_UpperCamelCase       : Optional[int]    =      '''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''
  
  						for _ in range(_snake_case     ):
  								common_inputs["past_key_values"].append(
  								    (
  								        torch.zeros(_snake_case     ),
  								        torch.zeros(_snake_case     ),
  								        torch.zeros(_snake_case     ),
  								        torch.zeros(_snake_case     ),
  								    )     )
  						# TODO: test this.
  						_UpperCamelCase       : Optional[Any]    =      encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
  						for _ in range(_snake_case  ,					_snake_case     ):
  								common_inputs["past_key_values"].append((torch.zeros(_snake_case     ), torch.zeros(_snake_case     ))     )
  				return common_inputs
  		def _lowercase  (    self  ,					_snake_case  ,					_snake_case = -1  ,					_snake_case = -1  ,					_snake_case = False  ,					_snake_case = None  ,					)				->    Mapping[str, Any]:
  				_UpperCamelCase       : Dict    =      self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
  				    _snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					_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       : Union[str, Any]    =      common_inputs['''input_ids'''].shape
  						# Not using the same length for past_key_values
  						_UpperCamelCase       : str    =      seqlen + 2
  						_UpperCamelCase,							_UpperCamelCase       : str    =      self.num_layers
  						_UpperCamelCase,							_UpperCamelCase       : str    =      self.num_attention_heads
  						_UpperCamelCase       : List[str]    =      (
  						    batch,
  						    num_encoder_attention_heads,
  						    past_key_values_length,
  						    self._config.hidden_size // num_encoder_attention_heads,
  						)
  
  						_UpperCamelCase       : Optional[int]    =      common_inputs['''attention_mask'''].dtype
  						_UpperCamelCase       : Union[str, Any]    =      torch.cat(
  						    [common_inputs['''attention_mask'''], torch.ones(_snake_case  ,					_snake_case  ,					dtype=_snake_case     )]  ,					dim=1     )
  						_UpperCamelCase       : int    =      [
  						    (torch.zeros(_snake_case     ), torch.zeros(_snake_case     )) for _ in range(_snake_case     )
  						]
  				return common_inputs
  		def _lowercase  (    self  ,					_snake_case  ,					_snake_case = -1  ,					_snake_case = -1  ,					_snake_case = False  ,					_snake_case = 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
  				_UpperCamelCase       : Union[str, Any]    =      compute_effective_axis_dimension(
  				    _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       : List[Any]    =      tokenizer.num_special_tokens_to_add(_snake_case     )
  				_UpperCamelCase       : List[str]    =      compute_effective_axis_dimension(
  				    _snake_case  ,					fixed_dimension=OnnxConfig.default_fixed_sequence  ,					num_token_to_add=_snake_case     )
  
  				# Generate dummy inputs according to compute batch and sequence
  				_UpperCamelCase       : Optional[Any]    =      [''' '''.join([tokenizer.unk_token]     ) * seq_length] * batch_size
  				_UpperCamelCase       : Any    =      dict(tokenizer(_snake_case  ,					return_tensors=_snake_case     )     )
  				return common_inputs
  		def _lowercase  (    self  ,					_snake_case  ,					_snake_case = -1  ,					_snake_case = -1  ,					_snake_case = False  ,					_snake_case = None  ,					)				->    Mapping[str, Any]:
  				if self.task in ["default", "seq2seq-lm"]:
  						_UpperCamelCase       : List[Any]    =      self._generate_dummy_inputs_for_default_and_seqaseq_lm(
  						    _snake_case  ,					batch_size=_snake_case  ,					seq_length=_snake_case  ,					is_pair=_snake_case  ,					framework=_snake_case     )
  
  				elif self.task == "causal-lm":
  						_UpperCamelCase       : List[Any]    =      self._generate_dummy_inputs_for_causal_lm(
  						    _snake_case  ,					batch_size=_snake_case  ,					seq_length=_snake_case  ,					is_pair=_snake_case  ,					framework=_snake_case     )
  				else:
  						_UpperCamelCase       : List[Any]    =      self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
  						    _snake_case  ,					batch_size=_snake_case  ,					seq_length=_snake_case  ,					is_pair=_snake_case  ,					framework=_snake_case     )
  
  				return common_inputs
  
  
  
  
  		def _lowercase  (    self  ,					_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case     )				->    Tuple:
  				if self.task in ["default", "seq2seq-lm"]:
  						_UpperCamelCase       : List[Any]    =      super()._flatten_past_key_values_(_snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case     )
  				else:
  						_UpperCamelCase       : int    =      super(_snake_case  ,					self     )._flatten_past_key_values_(
  						    _snake_case  ,					_snake_case  ,					_snake_case  ,					_snake_case     )
  
  
  
  
  
  