

"""simple docstring"""


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

a					:Dict    = logging.get_logger(__name__)

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

# fmt: off
a					:Tuple    = [
    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, 1_058, 1_220, 1_267, 1_279, 1_303, 1_343, 1_377,
    1_391, 1_635, 1_782, 1_875, 2_162, 2_361, 2_488, 3_467, 4_008, 4_211,
    4_600, 4_808, 5_299, 5_855, 6_329, 7_203, 9_609, 9_959, 10_563, 10_786,
    11_420, 11_709, 11_907, 13_163, 13_697, 13_700, 14_808, 15_306, 16_410, 16_791,
    17_992, 19_203, 19_510, 20_724, 22_305, 22_935, 27_007, 30_109, 30_420, 33_409,
    34_949, 40_283, 40_493, 40_549, 47_282, 49_146, 50_257, 50_359, 50_360, 50_361
]
a					:Tuple    = [
    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, 1_350, 1_853, 1_982, 2_460, 2_627,
    3_246, 3_253, 3_268, 3_536, 3_846, 3_961, 4_183, 4_667, 6_585, 6_647,
    7_273, 9_061, 9_383, 10_428, 10_929, 11_938, 12_033, 12_331, 12_562, 13_793,
    14_157, 14_635, 15_265, 15_618, 16_553, 16_604, 18_362, 18_956, 20_075, 21_675,
    22_520, 26_130, 26_161, 26_435, 28_279, 29_464, 31_650, 32_302, 32_470, 36_865,
    42_863, 47_425, 49_870, 50_254, 50_258, 50_360, 50_361, 50_362
]

class      __a							(UpperCamelCase_):






     '''simple docstring'''
     _SCREAMING_SNAKE_CASE						:Any       = """whisper"""
     _SCREAMING_SNAKE_CASE						:Optional[Any]       = ["""past_key_values"""]
     _SCREAMING_SNAKE_CASE						:Union[str, Any]       = {"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}

     def __init__(						self	,    _a=51_865	,    _a=80	,    _a=6	,    _a=4	,    _a=6	,    _a=4	,    _a=1_536	,    _a=1_536	,    _a=0.0	,    _a=0.0	,    _a=50_257	,    _a=True	,    _a=True	,    _a="gelu"	,    _a=256	,    _a=0.0	,    _a=0.0	,    _a=0.0	,    _a=0.02	,    _a=False	,    _a=1_500	,    _a=448	,    _a=50_256	,    _a=50_256	,    _a=50_256	,    _a=None	,    _a=[220, 50_256]	,    _a=False	,    _a=256	,    _a=False	,    _a=0.05	,    _a=10	,    _a=2	,    _a=0.0	,    _a=10	,    _a=0	,    _a=7	,    **_a	,    )  ->      int:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	vocab_size
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	num_mel_bins
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	d_model
           SCREAMING_SNAKE_CASE__   :      int      		=	encoder_layers
           SCREAMING_SNAKE_CASE__   :      Any      		=	encoder_attention_heads
           SCREAMING_SNAKE_CASE__   :      Dict      		=	decoder_layers
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	decoder_attention_heads
           SCREAMING_SNAKE_CASE__   :      str      		=	decoder_ffn_dim
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	encoder_ffn_dim
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	dropout
           SCREAMING_SNAKE_CASE__   :      int      		=	attention_dropout
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	activation_dropout
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	activation_function
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	init_std
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	encoder_layerdrop
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	decoder_layerdrop
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	use_cache
           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	encoder_layers
           SCREAMING_SNAKE_CASE__   :      Any      		=	scale_embedding  # scale factor will be sqrt(d_model) if True
           SCREAMING_SNAKE_CASE__   :      Any      		=	max_source_positions
           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	max_target_positions

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

           # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	apply_spec_augment
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	mask_time_prob
           SCREAMING_SNAKE_CASE__   :      Dict      		=	mask_time_length
           SCREAMING_SNAKE_CASE__   :      Any      		=	mask_time_min_masks
           SCREAMING_SNAKE_CASE__   :      Any      		=	mask_feature_prob
           SCREAMING_SNAKE_CASE__   :      Any      		=	mask_feature_length
           SCREAMING_SNAKE_CASE__   :      Dict      		=	mask_feature_min_masks

           SCREAMING_SNAKE_CASE__   :      str      		=	median_filter_width

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





class      __a							(UpperCamelCase_):






     '''simple docstring'''

     @property
     def 					_a			(						self  )  ->      Mapping[str, Mapping[int, str]]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	OrderedDict(
               [
                   ("""input_features""", {0: """batch""", 1: """feature_size""", 2: """encoder_sequence"""}),
               ]  )
           if self.use_past:
                 SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	{0: """batch"""}
           else:
                 SCREAMING_SNAKE_CASE__   :      str      		=	{0: """batch""", 1: """decoder_sequence"""}

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

           return common_inputs

     def 					_a			(						self	,    _a	,    _a = -1	,    _a = -1	,    _a = False	,    _a = None	,    _a = 22_050	,    _a = 5.0	,    _a = 220	,    )  ->      Mapping[str, Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	OrderedDict()
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	OnnxConfig.generate_dummy_inputs(
               self	,    preprocessor=preprocessor.feature_extractor	,    batch_size=_a	,    framework=_a	,    sampling_rate=_a	,    time_duration=_a	,    frequency=_a	,    )
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	encoder_inputs["""input_features"""].shape[2]
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	encoder_sequence_length // 2 if self.use_past else seq_length

           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	super().generate_dummy_inputs(
               preprocessor.tokenizer	,    _a	,    _a	,    _a	,    _a  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	encoder_inputs.pop("""input_features"""  )
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	decoder_inputs.pop("""decoder_input_ids"""  )

           if "past_key_values" in decoder_inputs:
                 SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	decoder_inputs.pop("""past_key_values"""  )

           return dummy_inputs





     @property
     def 					_a			(						self  )  ->      float:


           """simple docstring"""


           return 1E-3







"""simple docstring"""


from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow


if is_tf_available():
  import numpy as np
  import tensorflow as tf

  from transformers import TFCamembertModel

@require_tf
@require_sentencepiece
@require_tokenizers
class      __a							(unittest.TestCase):






     '''simple docstring'''

     @slow
     def 					_a			(						self  )  ->      Union[str, Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	TFCamembertModel.from_pretrained("""jplu/tf-camembert-base"""  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	tf.convert_to_tensor(
               [[5, 121, 11, 660, 16, 730, 25_543, 110, 83, 6]]	,    dtype=tf.intaa	,    )  # J'aime le camembert !"

           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	model(_a  )["""last_hidden_state"""]
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	tf.TensorShape((1, 10, 768)  )
           self.assertEqual(output.shape	,    _a  )
           # compare the actual values for a slice.
           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	tf.convert_to_tensor(
               [[[-0.0_254, 0.0_235, 0.1_027], [0.0_606, -0.1_811, -0.0_418], [-0.1_561, -0.1_127, 0.2_687]]]	,    dtype=tf.floataa	,    )
           # camembert = torch.hub.load('pytorch/fairseq', 'camembert.v0')
           # camembert.eval()
           # expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach()

           self.assertTrue(np.allclose(output[:, :3, :3].numpy()	,    expected_slice.numpy()	,    atol=1E-4  )  )




