





'''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

snake_case_     =	logging.get_logger(__name__)

snake_case_     =	{
    '''openai/whisper-base''': '''https://huggingface.co/openai/whisper-base/resolve/main/config.json''',
}

# fmt: off
snake_case_     =	[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 3_57, 3_66, 4_38, 5_32, 6_85,
    7_05, 7_96, 9_30, 10_58, 12_20, 12_67, 12_79, 13_03, 13_43, 13_77,
    13_91, 16_35, 17_82, 18_75, 21_62, 23_61, 24_88, 34_67, 40_08, 42_11,
    46_00, 48_08, 52_99, 58_55, 63_29, 72_03, 96_09, 99_59, 1_05_63, 1_07_86,
    1_14_20, 1_17_09, 1_19_07, 1_31_63, 1_36_97, 1_37_00, 1_48_08, 1_53_06, 1_64_10, 1_67_91,
    1_79_92, 1_92_03, 1_95_10, 2_07_24, 2_23_05, 2_29_35, 2_70_07, 3_01_09, 3_04_20, 3_34_09,
    3_49_49, 4_02_83, 4_04_93, 4_05_49, 4_72_82, 4_91_46, 5_02_57, 5_03_59, 5_03_60, 5_03_61
]
snake_case_     =	[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 3_59, 5_03, 5_22, 5_42, 8_73,
    8_93, 9_02, 9_18, 9_22, 9_31, 13_50, 18_53, 19_82, 24_60, 26_27,
    32_46, 32_53, 32_68, 35_36, 38_46, 39_61, 41_83, 46_67, 65_85, 66_47,
    72_73, 90_61, 93_83, 1_04_28, 1_09_29, 1_19_38, 1_20_33, 1_23_31, 1_25_62, 1_37_93,
    1_41_57, 1_46_35, 1_52_65, 1_56_18, 1_65_53, 1_66_04, 1_83_62, 1_89_56, 2_00_75, 2_16_75,
    2_25_20, 2_61_30, 2_61_61, 2_64_35, 2_82_79, 2_94_64, 3_16_50, 3_23_02, 3_24_70, 3_68_65,
    4_28_63, 4_74_25, 4_98_70, 5_02_54, 5_02_58, 5_03_60, 5_03_61, 5_03_62
]


class   _lowercase						(							_UpperCAmelCase				):
   _UpperCamelCase       		=   'whisper'
   _UpperCamelCase       		=   ['past_key_values']
   _UpperCamelCase       		=   {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}


   def __init__( self    ,   _UpperCAmelCase=51_865    ,   _UpperCAmelCase=80    ,   _UpperCAmelCase=6    ,   _UpperCAmelCase=4    ,   _UpperCAmelCase=6    ,   _UpperCAmelCase=4    ,   _UpperCAmelCase=1_536    ,   _UpperCAmelCase=1_536    ,   _UpperCAmelCase=0.0    ,   _UpperCAmelCase=0.0    ,   _UpperCAmelCase=50_257    ,   _UpperCAmelCase=True    ,   _UpperCAmelCase=True    ,   _UpperCAmelCase="gelu"    ,   _UpperCAmelCase=256    ,   _UpperCAmelCase=0.0    ,   _UpperCAmelCase=0.0    ,   _UpperCAmelCase=0.0    ,   _UpperCAmelCase=0.02    ,   _UpperCAmelCase=False    ,   _UpperCAmelCase=1_500    ,   _UpperCAmelCase=448    ,   _UpperCAmelCase=50_256    ,   _UpperCAmelCase=50_256    ,   _UpperCAmelCase=50_256    ,   _UpperCAmelCase=None    ,   _UpperCAmelCase=[220, 50_256]    ,   _UpperCAmelCase=False    ,   _UpperCAmelCase=256    ,   _UpperCAmelCase=False    ,   _UpperCAmelCase=0.05    ,   _UpperCAmelCase=10    ,   _UpperCAmelCase=2    ,   _UpperCAmelCase=0.0    ,   _UpperCAmelCase=10    ,   _UpperCAmelCase=0    ,   _UpperCAmelCase=7    ,   **_UpperCAmelCase    ,   ):
       A       :       Tuple							=						vocab_size
       A       :       Optional[int]							=						num_mel_bins
       A       :       List[Any]							=						d_model
       A       :       List[Any]							=						encoder_layers
       A       :       str							=						encoder_attention_heads
       A       :       Optional[Any]							=						decoder_layers
       A       :       Optional[Any]							=						decoder_attention_heads
       A       :       Optional[int]							=						decoder_ffn_dim
       A       :       Tuple							=						encoder_ffn_dim
       A       :       Optional[int]							=						dropout
       A       :       Dict							=						attention_dropout
       A       :       Optional[int]							=						activation_dropout
       A       :       List[Any]							=						activation_function
       A       :       Optional[int]							=						init_std
       A       :       List[Any]							=						encoder_layerdrop
       A       :       Optional[Any]							=						decoder_layerdrop
       A       :       Tuple							=						use_cache
       A       :       Union[str, Any]							=						encoder_layers
       A       :       Tuple							=						scale_embedding  # scale factor will be sqrt(d_model) if True
       A       :       Any							=						max_source_positions
       A       :       int							=						max_target_positions

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

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

       A       :       str							=						median_filter_width

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







class   _lowercase						(							_UpperCAmelCase				):


   @property
   def 					snake_case				( self					):
       A       :       Tuple							=						OrderedDict(
           [
               ('''input_features''', {0: '''batch''', 1: '''feature_size''', 2: '''encoder_sequence'''}),
           ]					)
       if self.use_past:
           A       :       int							=						{0: '''batch'''}
       else:
           A       :       Any							=						{0: '''batch''', 1: '''decoder_sequence'''}

       if self.use_past:
           self.fill_with_past_key_values_(__UpperCamelCase    ,   direction='''inputs'''					)

       return common_inputs


   def 					snake_case				( self    ,   _UpperCAmelCase    ,   _UpperCAmelCase = -1    ,   _UpperCAmelCase = -1    ,   _UpperCAmelCase = False    ,   _UpperCAmelCase = None    ,   _UpperCAmelCase = 22_050    ,   _UpperCAmelCase = 5.0    ,   _UpperCAmelCase = 220    ,   ):
       A       :       Any							=						OrderedDict()
       A       :       List[str]							=						OnnxConfig.generate_dummy_inputs(
           self    ,   preprocessor=preprocessor.feature_extractor    ,   batch_size=__UpperCamelCase    ,   framework=__UpperCamelCase    ,   sampling_rate=__UpperCamelCase    ,   time_duration=__UpperCamelCase    ,   frequency=__UpperCamelCase    ,   )
       A       :       List[str]							=						encoder_inputs['''input_features'''].shape[2]
       A       :       int							=						encoder_sequence_length // 2 if self.use_past else seq_length

       A       :       int							=						super().generate_dummy_inputs(
           preprocessor.tokenizer    ,   __UpperCamelCase    ,   __UpperCamelCase    ,   __UpperCamelCase    ,   __UpperCamelCase					)

       A       :       Tuple							=						encoder_inputs.pop('''input_features'''					)
       A       :       List[Any]							=						decoder_inputs.pop('''decoder_input_ids'''					)

       if "past_key_values" in decoder_inputs:
           A       :       List[Any]							=						decoder_inputs.pop('''past_key_values'''					)

       return dummy_inputs


   @property
   def 					snake_case				( self					):
       return 1E-3







'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_torch_available,
)


snake_case_     =	{
    """configuration_speecht5""": [
        """SPEECHT5_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """SPEECHT5_PRETRAINED_HIFIGAN_CONFIG_ARCHIVE_MAP""",
        """SpeechT5Config""",
        """SpeechT5HifiGanConfig""",
    ],
    """feature_extraction_speecht5""": ["""SpeechT5FeatureExtractor"""],
    """processing_speecht5""": ["""SpeechT5Processor"""],
}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case_     =	["""SpeechT5Tokenizer"""]

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case_     =	[
         """SPEECHT5_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """SpeechT5ForSpeechToText""",
         """SpeechT5ForSpeechToSpeech""",
         """SpeechT5ForTextToSpeech""",
         """SpeechT5Model""",
         """SpeechT5PreTrainedModel""",
         """SpeechT5HifiGan""",
     ]

if TYPE_CHECKING:
     from .configuration_speechta import (
         SPEECHT5_PRETRAINED_CONFIG_ARCHIVE_MAP,
         SPEECHT5_PRETRAINED_HIFIGAN_CONFIG_ARCHIVE_MAP,
         SpeechTaConfig,
         SpeechTaHifiGanConfig,
     )
     from .feature_extraction_speechta import SpeechTaFeatureExtractor
     from .processing_speechta import SpeechTaProcessor

     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_speechta import SpeechTaTokenizer

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_speechta import (
              SPEECHT5_PRETRAINED_MODEL_ARCHIVE_LIST,
              SpeechTaForSpeechToSpeech,
              SpeechTaForSpeechToText,
              SpeechTaForTextToSpeech,
              SpeechTaHifiGan,
              SpeechTaModel,
              SpeechTaPreTrainedModel,
          )

else:
     import sys

     snake_case_     =	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
