


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


_A									=		logging.get_logger(__name__)

_A									=		{
    '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__			(   A_						):



    """simple docstring"""






    UpperCAmelCase__		:						int    =    "mbart"
    UpperCAmelCase__		:						Dict    =    ["past_key_values"]
    UpperCAmelCase__		:						Union[str, Any]    =    {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}






    def __init__(     self   ,  A_=50265   ,  A_=1024   ,  A_=12   ,  A_=4096   ,  A_=16   ,  A_=12   ,  A_=4096   ,  A_=16   ,  A_=0.0   ,  A_=0.0   ,  A_=True   ,  A_=True   ,  A_="gelu"   ,  A_=1024   ,  A_=0.1   ,  A_=0.0   ,  A_=0.0   ,  A_=0.02   ,  A_=0.0   ,  A_=False   ,  A_=1   ,  A_=0   ,  A_=2   ,  A_=2   ,  **A_   ,  )    ->			Tuple:
         __UpperCamelCase       				=vocab_size
         __UpperCamelCase       				=max_position_embeddings
         __UpperCamelCase       				=d_model
         __UpperCamelCase       				=encoder_ffn_dim
         __UpperCamelCase       				=encoder_layers
         __UpperCamelCase       				=encoder_attention_heads
         __UpperCamelCase       				=decoder_ffn_dim
         __UpperCamelCase       				=decoder_layers
         __UpperCamelCase       				=decoder_attention_heads
         __UpperCamelCase       				=dropout
         __UpperCamelCase       				=attention_dropout
         __UpperCamelCase       				=activation_dropout
         __UpperCamelCase       				=activation_function
         __UpperCamelCase       				=init_std
         __UpperCamelCase       				=encoder_layerdrop
         __UpperCamelCase       				=decoder_layerdrop
         __UpperCamelCase       				=classifier_dropout
         __UpperCamelCase       				=use_cache
         __UpperCamelCase       				=encoder_layers
         __UpperCamelCase       				=scale_embedding  # scale factor will be sqrt(d_model) if True
         super().__init__(
             pad_token_id=A_   ,  bos_token_id=A_   ,  eos_token_id=A_   ,  is_encoder_decoder=A_   ,  forced_eos_token_id=A_   ,  **A_   ,  )






class        UpperCAmelCase__			(   A_						):



    """simple docstring"""






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

              if self.use_past:
                   __UpperCamelCase       				={0: 'batch'}
                   __UpperCamelCase       				={0: 'batch', 1: 'past_decoder_sequence + sequence'}
              else:
                   __UpperCamelCase       				={0: 'batch', 1: 'decoder_sequence'}
                   __UpperCamelCase       				={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.
              __UpperCamelCase       				=OrderedDict(
                  [
                      ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
                      ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
                  ]       )
              if self.use_past:
                   __UpperCamelCase				, __UpperCamelCase       				=self.num_layers
                   for i in range(A_       ):
                        __UpperCamelCase       				={0: 'batch', 2: 'past_sequence + sequence'}
                        __UpperCamelCase       				={0: 'batch', 2: 'past_sequence + sequence'}
         else:
              __UpperCamelCase       				=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 _a   (     self       )    ->			Mapping[str, Mapping[int, str]]:
         if self.task in ["default", "seq2seq-lm"]:
              __UpperCamelCase       				=super().outputs
         else:
              __UpperCamelCase       				=super(A_   ,  self       ).outputs
              if self.use_past:
                   __UpperCamelCase				, __UpperCamelCase       				=self.num_layers
                   for i in range(A_       ):
                        __UpperCamelCase       				={0: 'batch', 2: 'past_sequence + sequence'}
                        __UpperCamelCase       				={0: 'batch', 2: 'past_sequence + sequence'}
         return common_outputs






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

         # Generate decoder inputs
         __UpperCamelCase       				=seq_length if not self.use_past else 1
         __UpperCamelCase       				=self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
             A_   ,  A_   ,  A_   ,  A_   ,  A_       )
         __UpperCamelCase       				={f'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
         __UpperCamelCase       				=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
              __UpperCamelCase				, __UpperCamelCase       				=common_inputs['input_ids'].shape
              __UpperCamelCase       				=common_inputs['decoder_input_ids'].shape[1]
              __UpperCamelCase				, __UpperCamelCase       				=self.num_attention_heads
              __UpperCamelCase       				=(
                  batch,
                  num_encoder_attention_heads,
                  encoder_seq_length,
                  self._config.hidden_size // num_encoder_attention_heads,
              )
              __UpperCamelCase       				=decoder_seq_length + 3
              __UpperCamelCase       				=(
                  batch,
                  num_decoder_attention_heads,
                  decoder_past_length,
                  self._config.hidden_size // num_decoder_attention_heads,
              )

              __UpperCamelCase       				=torch.cat(
                  [common_inputs['decoder_attention_mask'], torch.ones(A_   ,  A_       )]   ,  dim=1       )

              __UpperCamelCase       				=[]
              # If the number of encoder and decoder layers are present in the model configuration, both are considered
              __UpperCamelCase				, __UpperCamelCase       				=self.num_layers
              __UpperCamelCase       				=min(A_   ,  A_       )
              __UpperCamelCase       				=max(A_   ,  A_       ) - min_num_layers
              __UpperCamelCase       				='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.
              __UpperCamelCase       				=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 _a   (     self   ,  A_   ,  A_ = -1   ,  A_ = -1   ,  A_ = False   ,  A_ = None   ,  )    ->			Mapping[str, Any]:
         __UpperCamelCase       				=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
              __UpperCamelCase				, __UpperCamelCase       				=common_inputs['input_ids'].shape
              # Not using the same length for past_key_values
              __UpperCamelCase       				=seqlen + 2
              __UpperCamelCase				, __UpperCamelCase       				=self.num_layers
              __UpperCamelCase				, __UpperCamelCase       				=self.num_attention_heads
              __UpperCamelCase       				=(
                  batch,
                  num_encoder_attention_heads,
                  past_key_values_length,
                  self._config.hidden_size // num_encoder_attention_heads,
              )

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






    def _a   (     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
         __UpperCamelCase       				=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
         __UpperCamelCase       				=tokenizer.num_special_tokens_to_add(A_       )
         __UpperCamelCase       				=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
         __UpperCamelCase       				=[' '.join([tokenizer.unk_token]       ) * seq_length] * batch_size
         __UpperCamelCase       				=dict(tokenizer(A_   ,  return_tensors=A_       )       )
         return common_inputs






    def _a   (     self   ,  A_   ,  A_ = -1   ,  A_ = -1   ,  A_ = False   ,  A_ = None   ,  )    ->			Mapping[str, Any]:
         if self.task in ["default", "seq2seq-lm"]:
              __UpperCamelCase       				=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":
              __UpperCamelCase       				=self._generate_dummy_inputs_for_causal_lm(
                  A_   ,  batch_size=A_   ,  seq_length=A_   ,  is_pair=A_   ,  framework=A_       )
         else:
              __UpperCamelCase       				=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 _a   (     self   ,  A_   ,  A_   ,  A_   ,  A_       )    ->			Optional[Any]:
         if self.task in ["default", "seq2seq-lm"]:
              __UpperCamelCase       				=super()._flatten_past_key_values_(A_   ,  A_   ,  A_   ,  A_       )
         else:
              __UpperCamelCase       				=super(A_   ,  self       )._flatten_past_key_values_(
                  A_   ,  A_   ,  A_   ,  A_       )









import json
import os
import tempfile

import datasets
from utils import generate_example_dataset, get_duration


_A									=		50_0000

_A			,	_A									=		os.path.split(__file__)
_A									=		os.path.join(RESULTS_BASEPATH, 'results', RESULTS_FILENAME.replace('.py', '.json'))

@get_duration
def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   datasets.Dataset							):
     __UpperCamelCase       				=dataset.select(range(0     ,	len(SCREAMING_SNAKE_CASE__							)     ,	2							)							)

@get_duration
def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   datasets.Dataset							):
     __UpperCamelCase       				=dataset.sort('numbers'							)

@get_duration
def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   datasets.Dataset							):
     __UpperCamelCase       				=dataset.shuffle()

@get_duration
def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   datasets.Dataset							):
     __UpperCamelCase       				=dataset.train_test_split(0.1							)

@get_duration
def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   datasets.Dataset     ,	SCREAMING_SNAKE_CASE__     :   int=10							):
     for shard_id in range(SCREAMING_SNAKE_CASE__							):
          __UpperCamelCase       				=dataset.shard(SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__							)

def 		_UpperCAmelCase							(     ):
     __UpperCamelCase       				={'num examples': SPEED_TEST_N_EXAMPLES}
     __UpperCamelCase       				=(select, sort, shuffle, train_test_split, shard)
     with tempfile.TemporaryDirectory() as tmp_dir:
          print('generating dataset'							)
          __UpperCamelCase       				=datasets.Features({'text': datasets.Value('string'							), 'numbers': datasets.Value('float32'							)}							)
          __UpperCamelCase       				=generate_example_dataset(
              os.path.join(SCREAMING_SNAKE_CASE__     ,	'dataset.arrow'							)     ,	SCREAMING_SNAKE_CASE__     ,	num_examples=SCREAMING_SNAKE_CASE__							)
          print('Functions'							)
          for func in functions:
               print(func.__name__							)
               __UpperCamelCase       				=func(SCREAMING_SNAKE_CASE__							)

     with open(SCREAMING_SNAKE_CASE__     ,	'wb'							) as f:
          f.write(json.dumps(SCREAMING_SNAKE_CASE__							).encode('utf-8'							)							)


if __name__ == "__main__":  # useful to run the profiler
   benchmark_indices_mapping()





