


import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
 import os

 # The slow tests are often failing with OOM error on GPU
 # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
 # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
 SCREAMING_SNAKE_CASE       :      str												= "platform"

 import jax
 import jax.numpy as jnp

 from transformers import BlenderbotTokenizer
 from transformers.models.blenderbot.modeling_flax_blenderbot import (
     FlaxBlenderbotForConditionalGeneration,
     FlaxBlenderbotModel,
     shift_tokens_right,
 )



def 				UpperCamelCase_(      lowerCamelCase_							, lowerCamelCase_							, lowerCamelCase_=None							, lowerCamelCase_=None							, lowerCamelCase_=None							, lowerCamelCase_=None							, lowerCamelCase_=None							, lowerCamelCase_=None							, )    ->						List[str]:
    if attention_mask is None:
        _lowercase       :							int      		=		np.where(input_ids != config.pad_token_id							, 1							, 0 )
    if decoder_attention_mask is None:
        _lowercase       :							Optional[Any]      		=		np.where(decoder_input_ids != config.pad_token_id							, 1							, 0 )
    if head_mask is None:
        _lowercase       :							Dict      		=		np.ones((config.encoder_layers, config.encoder_attention_heads) )
    if decoder_head_mask is None:
        _lowercase       :							Optional[int]      		=		np.ones((config.decoder_layers, config.decoder_attention_heads) )
    if cross_attn_head_mask is None:
        _lowercase       :							List[str]      		=		np.ones((config.decoder_layers, config.decoder_attention_heads) )
    return {
        "input_ids": input_ids,
        "decoder_input_ids": decoder_input_ids,
        "attention_mask": attention_mask,
        "decoder_attention_mask": attention_mask,
    }






class _lowerCamelCase:
       def __init__(					self,      lowerCamelCase,      lowerCamelCase=13,      lowerCamelCase=7,      lowerCamelCase=True,      lowerCamelCase=False,      lowerCamelCase=99,      lowerCamelCase=16,      lowerCamelCase=2,      lowerCamelCase=4,      lowerCamelCase=4,      lowerCamelCase="gelu",      lowerCamelCase=0.1,      lowerCamelCase=0.1,      lowerCamelCase=32,      lowerCamelCase=2,      lowerCamelCase=1,      lowerCamelCase=0,      lowerCamelCase=0.0_2,      )       ->   Optional[Any]:




           """simple docstring"""

           _lowercase       :							List[Any]      		=		parent
           _lowercase       :							Any      		=		batch_size
           _lowercase       :							List[str]      		=		seq_length
           _lowercase       :							Union[str, Any]      		=		is_training
           _lowercase       :							Optional[Any]      		=		use_labels
           _lowercase       :							Tuple      		=		vocab_size
           _lowercase       :							Tuple      		=		hidden_size
           _lowercase       :							List[str]      		=		num_hidden_layers
           _lowercase       :							Union[str, Any]      		=		num_attention_heads
           _lowercase       :							Optional[int]      		=		intermediate_size
           _lowercase       :							List[Any]      		=		hidden_act
           _lowercase       :							Dict      		=		hidden_dropout_prob
           _lowercase       :							Any      		=		attention_probs_dropout_prob
           _lowercase       :							Union[str, Any]      		=		max_position_embeddings
           _lowercase       :							Tuple      		=		eos_token_id
           _lowercase       :							List[Any]      		=		pad_token_id
           _lowercase       :							Dict      		=		bos_token_id
           _lowercase       :							List[Any]      		=		initializer_range
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase       :							str      		=		np.clip(ids_tensor([self.batch_size, self.seq_length - 1],      self.vocab_size),      3,      self.vocab_size)
           _lowercase       :							str      		=		np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1),      dtype=np.intaa)),      -1)

           _lowercase       :							Union[str, Any]      		=		shift_tokens_right(lowerCamelCase,      1,      2)

           _lowercase       :							Optional[Any]      		=		BlenderbotConfig(
               vocab_size=self.vocab_size,      d_model=self.hidden_size,      encoder_layers=self.num_hidden_layers,      decoder_layers=self.num_hidden_layers,      encoder_attention_heads=self.num_attention_heads,      decoder_attention_heads=self.num_attention_heads,      encoder_ffn_dim=self.intermediate_size,      decoder_ffn_dim=self.intermediate_size,      dropout=self.hidden_dropout_prob,      attention_dropout=self.attention_probs_dropout_prob,      max_position_embeddings=self.max_position_embeddings,      eos_token_id=self.eos_token_id,      bos_token_id=self.bos_token_id,      pad_token_id=self.pad_token_id,      initializer_range=self.initializer_range,      use_cache=lowerCamelCase,      )
           _lowercase       :							List[Any]      		=		prepare_blenderbot_inputs_dict(lowerCamelCase,      lowerCamelCase,      lowerCamelCase)
           return config, inputs_dict
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           _lowercase		,				_lowercase       :							Optional[Any]      		=		self.prepare_config_and_inputs()
           return config, inputs_dict
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Optional[Any]:




           """simple docstring"""

           _lowercase       :							int      		=		20
           _lowercase       :							Any      		=		model_class_name(lowerCamelCase)

           _lowercase       :							Any      		=		model.encode(inputs_dict['input_ids'])

           _lowercase		,				_lowercase       :							Optional[int]      		=		(
               inputs_dict['decoder_input_ids'],
               inputs_dict['decoder_attention_mask'],
           )

           _lowercase       :							str      		=		model.init_cache(decoder_input_ids.shape[0],      lowerCamelCase,      lowerCamelCase)
           _lowercase       :							Tuple      		=		jnp.ones((decoder_input_ids.shape[0], max_decoder_length),      dtype='i4')

           _lowercase       :							Optional[int]      		=		jnp.broadcast_to(
               jnp.arange(decoder_input_ids.shape[-1] - 1)[None, :],      (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1),      )
           _lowercase       :							Optional[Any]      		=		model.decode(
               decoder_input_ids[:, :-1],      lowerCamelCase,      decoder_attention_mask=lowerCamelCase,      past_key_values=lowerCamelCase,      decoder_position_ids=lowerCamelCase,      )

           _lowercase       :							Union[str, Any]      		=		jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]],      dtype='i4')
           _lowercase       :							List[str]      		=		model.decode(
               decoder_input_ids[:, -1:],      lowerCamelCase,      decoder_attention_mask=lowerCamelCase,      past_key_values=outputs_cache.past_key_values,      decoder_position_ids=lowerCamelCase,      )

           _lowercase       :							Tuple      		=		model.decode(lowerCamelCase,      lowerCamelCase)

           _lowercase       :							Union[str, Any]      		=		np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])))
           self.parent.assertTrue(diff < 1E-3,      msg=F'''Max diff is {diff}''')




       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Tuple:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		20
           _lowercase       :							List[str]      		=		model_class_name(lowerCamelCase)

           _lowercase       :							int      		=		model.encode(inputs_dict['input_ids'])

           _lowercase		,				_lowercase       :							Any      		=		(
               inputs_dict['decoder_input_ids'],
               inputs_dict['decoder_attention_mask'],
           )

           _lowercase       :							str      		=		jnp.concatenate(
               [
                   decoder_attention_mask,
                   jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])),
               ],      axis=-1,      )

           _lowercase       :							Any      		=		model.init_cache(decoder_input_ids.shape[0],      lowerCamelCase,      lowerCamelCase)
           _lowercase       :							str      		=		jnp.broadcast_to(
               jnp.arange(decoder_input_ids.shape[-1] - 1)[None, :],      (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1),      )

           _lowercase       :							Optional[Any]      		=		model.decode(
               decoder_input_ids[:, :-1],      lowerCamelCase,      decoder_attention_mask=lowerCamelCase,      past_key_values=lowerCamelCase,      decoder_position_ids=lowerCamelCase,      )
           _lowercase       :							str      		=		jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]],      dtype='i4')
           _lowercase       :							List[str]      		=		model.decode(
               decoder_input_ids[:, -1:],      lowerCamelCase,      past_key_values=outputs_cache.past_key_values,      decoder_attention_mask=lowerCamelCase,      decoder_position_ids=lowerCamelCase,      )

           _lowercase       :							List[Any]      		=		model.decode(lowerCamelCase,      lowerCamelCase,      decoder_attention_mask=lowerCamelCase)

           _lowercase       :							List[str]      		=		np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])))
           self.parent.assertTrue(diff < 1E-3,      msg=F'''Max diff is {diff}''')






@require_flax
class _lowerCamelCase(						unittest.TestCase   ):
       lowercase_ :	str     =			99
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase       :							Optional[Any]      		=		np.array(
               [
                   [71, 82, 18, 33, 46, 91, 2],
                   [68, 34, 26, 58, 30, 82, 2],
                   [5, 97, 17, 39, 94, 40, 2],
                   [76, 83, 94, 25, 70, 78, 2],
                   [87, 59, 41, 35, 48, 66, 2],
                   [55, 13, 16, 58, 5, 2, 1],  # note padding
                   [64, 27, 31, 51, 12, 75, 2],
                   [52, 64, 86, 17, 83, 39, 2],
                   [48, 61, 9, 24, 71, 82, 2],
                   [26, 1, 60, 48, 22, 13, 2],
                   [21, 5, 62, 28, 14, 76, 2],
                   [45, 98, 37, 86, 59, 48, 2],
                   [70, 70, 50, 9, 28, 0, 2],
               ],      dtype=np.intaa,      )

           _lowercase       :							Optional[int]      		=		input_ids.shape[0]
           _lowercase       :							int      		=		BlenderbotConfig(
               vocab_size=self.vocab_size,      d_model=24,      encoder_layers=2,      decoder_layers=2,      encoder_attention_heads=2,      decoder_attention_heads=2,      encoder_ffn_dim=32,      decoder_ffn_dim=32,      max_position_embeddings=48,      eos_token_id=2,      pad_token_id=1,      bos_token_id=0,      )
           return config, input_ids, batch_size
       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

           _lowercase		,				_lowercase		,				_lowercase       :							Dict      		=		self._get_config_and_data()
           _lowercase       :							Dict      		=		FlaxBlenderbotForConditionalGeneration(lowerCamelCase)
           _lowercase       :							Union[str, Any]      		=		lm_model(input_ids=lowerCamelCase)
           _lowercase       :							Tuple      		=		(batch_size, input_ids.shape[1], config.vocab_size)
           self.assertEqual(outputs['logits'].shape,      lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		BlenderbotConfig(
               vocab_size=self.vocab_size,      d_model=14,      encoder_layers=2,      decoder_layers=2,      encoder_attention_heads=2,      decoder_attention_heads=2,      encoder_ffn_dim=8,      decoder_ffn_dim=8,      max_position_embeddings=48,      )
           _lowercase       :							str      		=		FlaxBlenderbotForConditionalGeneration(lowerCamelCase)
           _lowercase       :							Optional[Any]      		=		np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]],      dtype=np.intaa)
           _lowercase       :							Optional[Any]      		=		np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]],      dtype=np.intaa)
           _lowercase       :							Dict      		=		lm_model(input_ids=lowerCamelCase,      decoder_input_ids=lowerCamelCase)
           _lowercase       :							Any      		=		(*summary.shape, config.vocab_size)
           self.assertEqual(outputs['logits'].shape,      lowerCamelCase)




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




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]],      dtype=np.intaa)
           _lowercase       :							List[Any]      		=		shift_tokens_right(lowerCamelCase,      1,      2)
           _lowercase       :							List[Any]      		=		np.equal(lowerCamelCase,      1).astype(np.floataa).sum()
           _lowercase       :							List[Any]      		=		np.equal(lowerCamelCase,      1).astype(np.floataa).sum()
           self.assertEqual(shifted.shape,      input_ids.shape)
           self.assertEqual(lowerCamelCase,      n_pad_before - 1)
           self.assertTrue(np.equal(shifted[:, 0],      2).all())






@require_flax
class _lowerCamelCase(						_a, unittest.TestCase, _a   ):
       lowercase_ :	int     =			True
       lowercase_ :	Optional[Any]     =			(
           (
               FlaxBlenderbotModel,
               FlaxBlenderbotForConditionalGeneration,
           )
           if is_flax_available()
           else ()
       )
       lowercase_ :	List[Any]     =			(FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()
       def 			UpperCamelCase     (					self)       ->   int:




           """simple docstring"""

           _lowercase       :							int      		=		FlaxBlenderbotModelTester(self)
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           _lowercase		,				_lowercase       :							Tuple      		=		self.model_tester.prepare_config_and_inputs()
           for model_class in self.all_model_classes:
               self.model_tester.check_use_cache_forward(lowerCamelCase,      lowerCamelCase,      lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Optional[int]:




           """simple docstring"""

           _lowercase		,				_lowercase       :							Dict      		=		self.model_tester.prepare_config_and_inputs()
           for model_class in self.all_model_classes:
               self.model_tester.check_use_cache_forward_with_attn_mask(lowerCamelCase,      lowerCamelCase,      lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   str:




           """simple docstring"""

           _lowercase		,				_lowercase       :							Tuple      		=		self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               with self.subTest(model_class.__name__):
                   _lowercase       :							Any      		=		self._prepare_for_class(lowerCamelCase,      lowerCamelCase)
                   _lowercase       :							str      		=		model_class(lowerCamelCase)

                   @jax.jit
                   def encode_jitted(lowerCamelCase,      lowerCamelCase=None,      **lowerCamelCase):
                       return model.encode(input_ids=lowerCamelCase,      attention_mask=lowerCamelCase)

                   with self.subTest('JIT Enabled'):
                       _lowercase       :							Any      		=		encode_jitted(**lowerCamelCase).to_tuple()

                   with self.subTest('JIT Disabled'):
                       with jax.disable_jit():
                           _lowercase       :							List[Any]      		=		encode_jitted(**lowerCamelCase).to_tuple()

                   self.assertEqual(len(lowerCamelCase),      len(lowerCamelCase))
                   for jitted_output, output in zip(lowerCamelCase,      lowerCamelCase):
                       self.assertEqual(jitted_output.shape,      output.shape)
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase		,				_lowercase       :							Union[str, Any]      		=		self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               with self.subTest(model_class.__name__):
                   _lowercase       :							List[str]      		=		model_class(lowerCamelCase)
                   _lowercase       :							Optional[Any]      		=		model.encode(inputs_dict['input_ids'],      inputs_dict['attention_mask'])

                   _lowercase       :							str      		=		{
                       'decoder_input_ids': inputs_dict['decoder_input_ids'],
                       'decoder_attention_mask': inputs_dict['decoder_attention_mask'],
                       'encoder_outputs': encoder_outputs,
                   }

                   @jax.jit
                   def decode_jitted(lowerCamelCase,      lowerCamelCase,      lowerCamelCase):
                       return model.decode(
                           decoder_input_ids=lowerCamelCase,      decoder_attention_mask=lowerCamelCase,      encoder_outputs=lowerCamelCase,      )

                   with self.subTest('JIT Enabled'):
                       _lowercase       :							List[Any]      		=		decode_jitted(**lowerCamelCase).to_tuple()

                   with self.subTest('JIT Disabled'):
                       with jax.disable_jit():
                           _lowercase       :							List[Any]      		=		decode_jitted(**lowerCamelCase).to_tuple()

                   self.assertEqual(len(lowerCamelCase),      len(lowerCamelCase))
                   for jitted_output, output in zip(lowerCamelCase,      lowerCamelCase):
                       self.assertEqual(jitted_output.shape,      output.shape)
       @slow
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           for model_class_name in self.all_model_classes:
               _lowercase       :							Optional[int]      		=		model_class_name.from_pretrained('facebook/blenderbot-400M-distill')
               # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
               _lowercase       :							Optional[Any]      		=		np.ones((1, 1)) * model.config.eos_token_id
               _lowercase       :							int      		=		model(lowerCamelCase)
               self.assertIsNotNone(lowerCamelCase)




       @unittest.skipUnless(jax_device != 'cpu',      '3B test too slow on CPU.')
       @slow
       def 			UpperCamelCase     (					self)       ->   List[Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		{'num_beams': 1, 'early_stopping': True, 'min_length': 15, 'max_length': 25}
           _lowercase       :							List[Any]      		=		{'skip_special_tokens': True, 'clean_up_tokenization_spaces': True}

           _lowercase       :							List[str]      		=		FlaxBlenderbotForConditionalGeneration.from_pretrained('facebook/blenderbot-3B',      from_pt=lowerCamelCase)
           _lowercase       :							Dict      		=		BlenderbotTokenizer.from_pretrained('facebook/blenderbot-3B')

           _lowercase       :							Any      		=		['Sam']
           _lowercase       :							List[str]      		=		tokenizer(lowerCamelCase,      return_tensors='jax')

           _lowercase       :							Any      		=		model.generate(**lowerCamelCase,      **lowerCamelCase)
           _lowercase       :							str      		=		'Sam is a great name. It means "sun" in Gaelic.'

           _lowercase       :							List[str]      		=		tokenizer.batch_decode(lowerCamelCase,      **lowerCamelCase)
           assert generated_txt[0].strip() == tgt_text








from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
     from ...feature_extraction_utils import FeatureExtractionMixin
     from ...tokenization_utils_base import PreTrainedTokenizerBase
     from ...utils import TensorType

_UpperCAmelCase		:  Tuple	=   logging.get_logger(__name__)

_UpperCAmelCase		:  Dict	=   {
    "openai/whisper-base": "https://huggingface.co/openai/whisper-base/resolve/main/config.json",
}

# fmt: off
_UpperCAmelCase		:  Union[str, Any]	=   [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 357, 366, 438, 532, 685,
    705, 796, 930, 1058, 1220, 1267, 1279, 1303, 1343, 1377,
    1391, 1635, 1782, 1875, 2162, 2361, 2488, 3467, 4008, 4211,
    4600, 4808, 5299, 5855, 6329, 7203, 9609, 9959, 10563, 10786,
    11420, 11709, 11907, 13163, 13697, 13700, 14808, 15306, 16410, 16791,
    17992, 19203, 19510, 20724, 22305, 22935, 27007, 30109, 30420, 33409,
    34949, 40283, 40493, 40549, 47282, 49146, 50257, 50359, 50360, 50361
]
_UpperCAmelCase		:  List[Any]	=   [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1350, 1853, 1982, 2460, 2627,
    3246, 3253, 3268, 3536, 3846, 3961, 4183, 4667, 6585, 6647,
    7273, 9061, 9383, 10428, 10929, 11938, 12033, 12331, 12562, 13793,
    14157, 14635, 15265, 15618, 16553, 16604, 18362, 18956, 20075, 21675,
    22520, 26130, 26161, 26435, 28279, 29464, 31650, 32302, 32470, 36865,
    42863, 47425, 49870, 50254, 50258, 50360, 50361, 50362
]




class       __lowerCAmelCase				(							lowerCAmelCase):
       _a           =  '''whisper'''
       _a           =  ['''past_key_values''']
       _a           =  {'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}






       def __init__(      self:    int				,    _lowerCAmelCase:    str=5_18_65				,    _lowerCAmelCase:    str=80				,    _lowerCAmelCase:    int=6				,    _lowerCAmelCase:    Tuple=4				,    _lowerCAmelCase:    Union[str, Any]=6				,    _lowerCAmelCase:    List[Any]=4				,    _lowerCAmelCase:    Any=15_36				,    _lowerCAmelCase:    Union[str, Any]=15_36				,    _lowerCAmelCase:    str=0.0				,    _lowerCAmelCase:    str=0.0				,    _lowerCAmelCase:    List[Any]=5_02_57				,    _lowerCAmelCase:    Optional[Any]=True				,    _lowerCAmelCase:    Tuple=True				,    _lowerCAmelCase:    str="gelu"				,    _lowerCAmelCase:    Dict=2_56				,    _lowerCAmelCase:    Union[str, Any]=0.0				,    _lowerCAmelCase:    Any=0.0				,    _lowerCAmelCase:    Dict=0.0				,    _lowerCAmelCase:    Union[str, Any]=0.02				,    _lowerCAmelCase:    Any=False				,    _lowerCAmelCase:    List[str]=15_00				,    _lowerCAmelCase:    Tuple=4_48				,    _lowerCAmelCase:    Optional[Any]=5_02_56				,    _lowerCAmelCase:    Dict=5_02_56				,    _lowerCAmelCase:    List[Any]=5_02_56				,    _lowerCAmelCase:    Union[str, Any]=None				,    _lowerCAmelCase:    str=[2_20, 5_02_56]				,    _lowerCAmelCase:    Optional[int]=False				,    _lowerCAmelCase:    Optional[int]=2_56				,    _lowerCAmelCase:    int=False				,    _lowerCAmelCase:    Dict=0.05				,    _lowerCAmelCase:    Optional[Any]=10				,    _lowerCAmelCase:    List[str]=2				,    _lowerCAmelCase:    Tuple=0.0				,    _lowerCAmelCase:    str=10				,    _lowerCAmelCase:    Union[str, Any]=0				,    _lowerCAmelCase:    List[Any]=7				,    **_lowerCAmelCase:    Union[str, Any]				,    ):
         lowercase			:Optional[Any]							=  vocab_size
         lowercase			:Optional[int]							=  num_mel_bins
         lowercase			:Union[str, Any]							=  d_model
         lowercase			:List[Any]							=  encoder_layers
         lowercase			:Optional[Any]							=  encoder_attention_heads
         lowercase			:Union[str, Any]							=  decoder_layers
         lowercase			:List[str]							=  decoder_attention_heads
         lowercase			:Optional[int]							=  decoder_ffn_dim
         lowercase			:List[Any]							=  encoder_ffn_dim
         lowercase			:Optional[Any]							=  dropout
         lowercase			:Tuple							=  attention_dropout
         lowercase			:Tuple							=  activation_dropout
         lowercase			:Optional[Any]							=  activation_function
         lowercase			:Any							=  init_std
         lowercase			:Optional[int]							=  encoder_layerdrop
         lowercase			:Optional[int]							=  decoder_layerdrop
         lowercase			:str							=  use_cache
         lowercase			:Optional[Any]							=  encoder_layers
         lowercase			:List[Any]							=  scale_embedding  # scale factor will be sqrt(d_model) if True
         lowercase			:Any							=  max_source_positions
         lowercase			:Optional[Any]							=  max_target_positions

         # Audio Classification-specific parameters. Feel free to ignore for other classes.
         lowercase			:int							=  classifier_proj_size
         lowercase			:List[str]							=  use_weighted_layer_sum

         # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
         lowercase			:Tuple							=  apply_spec_augment
         lowercase			:int							=  mask_time_prob
         lowercase			:Union[str, Any]							=  mask_time_length
         lowercase			:Dict							=  mask_time_min_masks
         lowercase			:Tuple							=  mask_feature_prob
         lowercase			:List[Any]							=  mask_feature_length
         lowercase			:List[Any]							=  mask_feature_min_masks

         lowercase			:Any							=  median_filter_width

         super().__init__(
             pad_token_id=_lowerCAmelCase				,    bos_token_id=_lowerCAmelCase				,    eos_token_id=_lowerCAmelCase				,    is_encoder_decoder=_lowerCAmelCase				,    decoder_start_token_id=_lowerCAmelCase				,    suppress_tokens=_lowerCAmelCase				,    begin_suppress_tokens=_lowerCAmelCase				,    **_lowerCAmelCase				,    )







class       __lowerCAmelCase				(							lowerCAmelCase):






       @property
       def     SCREAMING_SNAKE_CASE			(      self:    str ):
         lowercase			:Tuple							=  OrderedDict(
             [
                 ("input_features", {0: "batch", 1: "feature_size", 2: "encoder_sequence"}),
             ] )
         if self.use_past:
           lowercase			:List[Any]							=  {0: "batch"}
         else:
           lowercase			:str							=  {0: "batch", 1: "decoder_sequence"}

         if self.use_past:
           self.fill_with_past_key_values_(_lowerCAmelCase				,    direction="inputs" )

         return common_inputs






       def     SCREAMING_SNAKE_CASE			(      self:    Dict				,    _lowerCAmelCase:    Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]				,    _lowerCAmelCase:    int = -1				,    _lowerCAmelCase:    int = -1				,    _lowerCAmelCase:    bool = False				,    _lowerCAmelCase:    Optional["TensorType"] = None				,    _lowerCAmelCase:    int = 2_20_50				,    _lowerCAmelCase:    float = 5.0				,    _lowerCAmelCase:    int = 2_20				,    ):
         lowercase			:List[str]							=  OrderedDict()
         lowercase			:str							=  OnnxConfig.generate_dummy_inputs(
             self				,    preprocessor=preprocessor.feature_extractor				,    batch_size=_lowerCAmelCase				,    framework=_lowerCAmelCase				,    sampling_rate=_lowerCAmelCase				,    time_duration=_lowerCAmelCase				,    frequency=_lowerCAmelCase				,    )
         lowercase			:Optional[Any]							=  encoder_inputs["input_features"].shape[2]
         lowercase			:List[str]							=  encoder_sequence_length // 2 if self.use_past else seq_length

         lowercase			:Dict							=  super().generate_dummy_inputs(
             preprocessor.tokenizer				,    _lowerCAmelCase				,    _lowerCAmelCase				,    _lowerCAmelCase				,    _lowerCAmelCase )

         lowercase			:str							=  encoder_inputs.pop("input_features" )
         lowercase			:Optional[int]							=  decoder_inputs.pop("decoder_input_ids" )

         if "past_key_values" in decoder_inputs:
           lowercase			:List[str]							=  decoder_inputs.pop("past_key_values" )

         return dummy_inputs






       @property
       def     SCREAMING_SNAKE_CASE			(      self:    str ):
         return 1e-3



