






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, 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
]
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, 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  SCREAMING_SNAKE_CASE			(			SCREAMING_SNAKE_CASE__					):
     '''simple docstring'''


     UpperCamelCase_							:		List[str]			=	'''whisper'''
     UpperCamelCase_							:		List[str]			=	['''past_key_values''']
     UpperCamelCase_							:		Union[str, Any]			=	{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}


     def __init__(				self       :	Union[str, Any]					, UpperCAmelCase_       :	Any=5_1865					, UpperCAmelCase_       :	Optional[Any]=80					, UpperCAmelCase_       :	List[Any]=6					, UpperCAmelCase_       :	Union[str, Any]=4					, UpperCAmelCase_       :	List[str]=6					, UpperCAmelCase_       :	Tuple=4					, UpperCAmelCase_       :	List[str]=1536					, UpperCAmelCase_       :	Optional[int]=1536					, UpperCAmelCase_       :	str=0.0					, UpperCAmelCase_       :	Union[str, Any]=0.0					, UpperCAmelCase_       :	int=5_0257					, UpperCAmelCase_       :	str=True					, UpperCAmelCase_       :	Any=True					, UpperCAmelCase_       :	Optional[Any]="gelu"					, UpperCAmelCase_       :	List[Any]=256					, UpperCAmelCase_       :	int=0.0					, UpperCAmelCase_       :	Optional[int]=0.0					, UpperCAmelCase_       :	List[str]=0.0					, UpperCAmelCase_       :	Union[str, Any]=0.02					, UpperCAmelCase_       :	List[str]=False					, UpperCAmelCase_       :	Dict=1500					, UpperCAmelCase_       :	Optional[int]=448					, UpperCAmelCase_       :	Union[str, Any]=5_0256					, UpperCAmelCase_       :	Optional[int]=5_0256					, UpperCAmelCase_       :	Dict=5_0256					, UpperCAmelCase_       :	List[Any]=None					, UpperCAmelCase_       :	str=[220, 5_0256]					, UpperCAmelCase_       :	List[str]=False					, UpperCAmelCase_       :	Union[str, Any]=256					, UpperCAmelCase_       :	str=False					, UpperCAmelCase_       :	Union[str, Any]=0.05					, UpperCAmelCase_       :	List[str]=10					, UpperCAmelCase_       :	Union[str, Any]=2					, UpperCAmelCase_       :	List[str]=0.0					, UpperCAmelCase_       :	Dict=10					, UpperCAmelCase_       :	str=0					, UpperCAmelCase_       :	Any=7					, **UpperCAmelCase_       :	int					, ):
       SCREAMING_SNAKE_CASE       :      Dict							=    vocab_size
       SCREAMING_SNAKE_CASE       :      Dict							=    num_mel_bins
       SCREAMING_SNAKE_CASE       :      Dict							=    d_model
       SCREAMING_SNAKE_CASE       :      List[Any]							=    encoder_layers
       SCREAMING_SNAKE_CASE       :      Dict							=    encoder_attention_heads
       SCREAMING_SNAKE_CASE       :      Any							=    decoder_layers
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    decoder_attention_heads
       SCREAMING_SNAKE_CASE       :      str							=    decoder_ffn_dim
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    encoder_ffn_dim
       SCREAMING_SNAKE_CASE       :      Dict							=    dropout
       SCREAMING_SNAKE_CASE       :      Any							=    attention_dropout
       SCREAMING_SNAKE_CASE       :      Dict							=    activation_dropout
       SCREAMING_SNAKE_CASE       :      str							=    activation_function
       SCREAMING_SNAKE_CASE       :      Tuple							=    init_std
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    encoder_layerdrop
       SCREAMING_SNAKE_CASE       :      Any							=    decoder_layerdrop
       SCREAMING_SNAKE_CASE       :      List[Any]							=    use_cache
       SCREAMING_SNAKE_CASE       :      int							=    encoder_layers
       SCREAMING_SNAKE_CASE       :      str							=    scale_embedding  # scale factor will be sqrt(d_model) if True
       SCREAMING_SNAKE_CASE       :      str							=    max_source_positions
       SCREAMING_SNAKE_CASE       :      int							=    max_target_positions

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

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

       SCREAMING_SNAKE_CASE       :      Dict							=    median_filter_width

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





class  SCREAMING_SNAKE_CASE			(			SCREAMING_SNAKE_CASE__					):
     '''simple docstring'''


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

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

       return common_inputs


     def 				_A       (				self       :	Optional[Any]					, UpperCAmelCase_       :	List[str]					, UpperCAmelCase_       :	Any = -1					, UpperCAmelCase_       :	Union[str, Any] = -1					, UpperCAmelCase_       :	Any = False					, UpperCAmelCase_       :	List[str] = None					, UpperCAmelCase_       :	Union[str, Any] = 2_2050					, UpperCAmelCase_       :	str = 5.0					, UpperCAmelCase_       :	str = 220					, ):
       SCREAMING_SNAKE_CASE       :      Dict							=    OrderedDict()
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    OnnxConfig.generate_dummy_inputs(
           self					, preprocessor=preprocessor.feature_extractor					, batch_size=_lowercase					, framework=_lowercase					, sampling_rate=_lowercase					, time_duration=_lowercase					, frequency=_lowercase					, )
       SCREAMING_SNAKE_CASE       :      Any							=    encoder_inputs["""input_features"""].shape[2]
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    encoder_sequence_length // 2 if self.use_past else seq_length

       SCREAMING_SNAKE_CASE       :      List[str]							=    super().generate_dummy_inputs(
           preprocessor.tokenizer					, _lowercase					, _lowercase					, _lowercase					, _lowercase      )

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

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

       return dummy_inputs






     @property
     def 				_A       (				self       :	Optional[Any]      ):
       return 1E-3














# Copyright 2022 The HuggingFace Team and The OpenBMB Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


snake_case    				=		{
    """configuration_cpmant""": ["""CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CpmAntConfig"""],
    """tokenization_cpmant""": ["""CpmAntTokenizer"""],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   snake_case    				=		[
       """CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """CpmAntForCausalLM""",
       """CpmAntModel""",
       """CpmAntPreTrainedModel""",
   ]


if TYPE_CHECKING:
   from .configuration_cpmant import CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP, CpmAntConfig
   from .tokenization_cpmant import CpmAntTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_cpmant import (
          CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST,
          CpmAntForCausalLM,
          CpmAntModel,
          CpmAntPreTrainedModel,
      )


else:
   import sys

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






