


'''simple docstring'''

import re
from typing import Callable, List, Optional, Union

import tensorflow as tf


try:
     from tensorflow.keras.optimizers.legacy import Adam
except ImportError:
     from tensorflow.keras.optimizers import Adam





class   snake_case					(					tf.keras.optimizers.schedules.LearningRateSchedule    ):





  """simple docstring"""




  def __init__(					self    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase = 1.0    ,						UpperCamelCase = None    ,						):







   """simple docstring"""
   super().__init__()
   lowerCamelCase_  				=						initial_learning_rate
   lowerCamelCase_  				=						warmup_steps
   lowerCamelCase_  				=						power
   lowerCamelCase_  				=						decay_schedule_fn
   lowerCamelCase_  				=						name






  def __call__(					self    ,						UpperCamelCase  ):







   """simple docstring"""
   with tf.name_scope(self.name or "WarmUp"  ) as name:
    # Implements polynomial warmup. i.e., if global_step < warmup_steps, the
    # learning rate will be `global_step/num_warmup_steps * init_lr`.
    lowerCamelCase_  				=						tf.cast(UpperCamelCase    ,						tf.floataa  )
    lowerCamelCase_  				=						tf.cast(self.warmup_steps    ,						tf.floataa  )
    lowerCamelCase_  				=						global_step_float / warmup_steps_float
    lowerCamelCase_  				=						self.initial_learning_rate * tf.math.pow(UpperCamelCase    ,						self.power  )
    return tf.cond(
        global_step_float < warmup_steps_float    ,						lambda: warmup_learning_rate    ,						lambda: self.decay_schedule_fn(step - self.warmup_steps  )    ,						name=UpperCamelCase    ,						)







  def 						snake_case	(					self  ):







   """simple docstring"""
   return {
       "initial_learning_rate": self.initial_learning_rate,
       "decay_schedule_fn": self.decay_schedule_fn,
       "warmup_steps": self.warmup_steps,
       "power": self.power,
       "name": self.name,
   }





def __snake_case      (   UpperCAmelCase_		:		float      ,       UpperCAmelCase_		:		int      ,       UpperCAmelCase_		:		int      ,       UpperCAmelCase_		:		float = 0.0      ,       UpperCAmelCase_		:		float = 0.9      ,       UpperCAmelCase_		:		float = 0.999      ,       UpperCAmelCase_		:		float = 1E-8      ,       UpperCAmelCase_		:		Optional[float] = None      ,       UpperCAmelCase_		:		Optional[float] = None      ,       UpperCAmelCase_		:		float = 0.0      ,       UpperCAmelCase_		:		float = 1.0      ,       UpperCAmelCase_		:		Optional[List[str]] = None      ,       ):
 lowerCamelCase_  				=						tf.keras.optimizers.schedules.PolynomialDecay(
     initial_learning_rate=UpperCAmelCase_      ,       decay_steps=num_train_steps - num_warmup_steps      ,       end_learning_rate=init_lr * min_lr_ratio      ,       power=UpperCAmelCase_      ,       )
 if num_warmup_steps:
  lowerCamelCase_  				=						WarmUp(
      initial_learning_rate=UpperCAmelCase_      ,       decay_schedule_fn=UpperCAmelCase_      ,       warmup_steps=UpperCAmelCase_      ,       )
 if weight_decay_rate > 0.0:
  lowerCamelCase_  				=						AdamWeightDecay(
      learning_rate=UpperCAmelCase_      ,       weight_decay_rate=UpperCAmelCase_      ,       beta_a=UpperCAmelCase_      ,       beta_a=UpperCAmelCase_      ,       epsilon=UpperCAmelCase_      ,       clipnorm=UpperCAmelCase_      ,       global_clipnorm=UpperCAmelCase_      ,       exclude_from_weight_decay=["LayerNorm", "layer_norm", "bias"]      ,       include_in_weight_decay=UpperCAmelCase_      ,       )
 else:
  lowerCamelCase_  				=						tf.keras.optimizers.Adam(
      learning_rate=UpperCAmelCase_      ,       beta_a=UpperCAmelCase_      ,       beta_a=UpperCAmelCase_      ,       epsilon=UpperCAmelCase_      ,       clipnorm=UpperCAmelCase_      ,       global_clipnorm=UpperCAmelCase_      ,       )
 # We return the optimizer and the LR scheduler in order to better track the
 # evolution of the LR independently of the optimizer.
 return optimizer, lr_schedule





class   snake_case					(					lowercase    ):





  """simple docstring"""




  def __init__(					self    ,						UpperCamelCase = 0.001    ,						UpperCamelCase = 0.9    ,						UpperCamelCase = 0.999    ,						UpperCamelCase = 1e-7    ,						UpperCamelCase = False    ,						UpperCamelCase = 0.0    ,						UpperCamelCase = None    ,						UpperCamelCase = None    ,						UpperCamelCase = "AdamWeightDecay"    ,						**UpperCamelCase    ,						):







   """simple docstring"""
   super().__init__(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						**UpperCamelCase  )
   lowerCamelCase_  				=						weight_decay_rate
   lowerCamelCase_  				=						include_in_weight_decay
   lowerCamelCase_  				=						exclude_from_weight_decay






  @classmethod
  def 						snake_case	(					cls    ,						UpperCamelCase  ):







   """simple docstring"""
   lowerCamelCase_  				=						{"WarmUp": WarmUp}
   return super(UpperCamelCase    ,						cls  ).from_config(UpperCamelCase    ,						custom_objects=UpperCamelCase  )






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  ):







   """simple docstring"""
   super(UpperCamelCase    ,						self  )._prepare_local(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  )
   lowerCamelCase_  				=						tf.constant(
       self.weight_decay_rate    ,						name="adam_weight_decay_rate"  )






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  ):







   """simple docstring"""
   lowerCamelCase_  				=						self._do_use_weight_decay(var.name  )
   if do_decay:
    return var.assign_sub(
        learning_rate * var * apply_state[(var.device, var.dtype.base_dtype)]["weight_decay_rate"]    ,						use_locking=self._use_locking    ,						)
   return tf.no_op()






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase=None    ,						**UpperCamelCase  ):







   """simple docstring"""
   lowerCamelCase_				,lowerCamelCase_  				=						list(zip(*UpperCamelCase  )  )
   return super(UpperCamelCase    ,						self  ).apply_gradients(zip(UpperCamelCase    ,						UpperCamelCase  )    ,						name=UpperCamelCase    ,						**UpperCamelCase  )






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  ):







   """simple docstring"""
   if apply_state is None:
    return self._decayed_lr_t[var_dtype], {}

   lowerCamelCase_  				=						apply_state or {}
   lowerCamelCase_  				=						apply_state.get((var_device, var_dtype)  )
   if coefficients is None:
    lowerCamelCase_  				=						self._fallback_apply_state(UpperCamelCase    ,						UpperCamelCase  )
    lowerCamelCase_  				=						coefficients

   return coefficients["lr_t"], {"apply_state": apply_state}






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase=None  ):







   """simple docstring"""
   lowerCamelCase_				,lowerCamelCase_  				=						self._get_lr(var.device    ,						var.dtype.base_dtype    ,						UpperCamelCase  )
   lowerCamelCase_  				=						self._decay_weights_op(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  )
   with tf.control_dependencies([decay]  ):
    return super(UpperCamelCase    ,						self  )._resource_apply_dense(UpperCamelCase    ,						UpperCamelCase    ,						**UpperCamelCase  )






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase=None  ):







   """simple docstring"""
   lowerCamelCase_				,lowerCamelCase_  				=						self._get_lr(var.device    ,						var.dtype.base_dtype    ,						UpperCamelCase  )
   lowerCamelCase_  				=						self._decay_weights_op(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  )
   with tf.control_dependencies([decay]  ):
    return super(UpperCamelCase    ,						self  )._resource_apply_sparse(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						**UpperCamelCase  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						super().get_config()
   config.update({"weight_decay_rate": self.weight_decay_rate}  )
   return config







  def 						snake_case	(					self    ,						UpperCamelCase  ):







   """simple docstring"""
   if self.weight_decay_rate == 0:
    return False

   if self._include_in_weight_decay:
    for r in self._include_in_weight_decay:
     if re.search(UpperCamelCase    ,						UpperCamelCase  ) is not None:
      return True

   if self._exclude_from_weight_decay:
    for r in self._exclude_from_weight_decay:
     if re.search(UpperCamelCase    ,						UpperCamelCase  ) is not None:
      return False
   return True





class   snake_case					(					lowercase    ):





  """simple docstring"""




  def __init__(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						[]
   lowerCamelCase_  				=						None






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   if self._accum_steps is None:
    lowerCamelCase_  				=						tf.Variable(
        tf.constant(0    ,						dtype=tf.intaa  )    ,						trainable=UpperCamelCase    ,						synchronization=tf.VariableSynchronization.ON_READ    ,						aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA    ,						)

   return self._accum_steps.value()






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   if not self._gradients:
    raise ValueError("The accumulator should be called first to initialize the gradients"  )
   return [gradient.value() if gradient is not None else gradient for gradient in self._gradients]






  def __call__(					self    ,						UpperCamelCase  ):







   """simple docstring"""
   if not self._gradients:
    lowerCamelCase_  				=						self.step  # Create the step variable.
    self._gradients.extend(
        [
            tf.Variable(
                tf.zeros_like(UpperCamelCase  )    ,						trainable=UpperCamelCase    ,						synchronization=tf.VariableSynchronization.ON_READ    ,						aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA    ,						)
            if gradient is not None
            else gradient
            for gradient in gradients
        ]  )
   if len(UpperCamelCase  ) != len(self._gradients  ):
    raise ValueError(f'''Expected {len(self._gradients  )} gradients, but got {len(UpperCamelCase  )}'''  )

   for accum_gradient, gradient in zip(self._gradients    ,						UpperCamelCase  ):
    if accum_gradient is not None and gradient is not None:
     accum_gradient.assign_add(UpperCamelCase  )

   self._accum_steps.assign_add(1  )







  def 						snake_case	(					self  ):







   """simple docstring"""
   if not self._gradients:
    return
   self._accum_steps.assign(0  )
   for gradient in self._gradients:
    if gradient is not None:
     gradient.assign(tf.zeros_like(UpperCamelCase  )  )







'''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_						:       Optional[int]      			=				logging.get_logger(__name__)

a_						:       Optional[int]      			=				{
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
a_						:       List[str]      			=				[
    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
]
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, 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   snake_case					(					lowercase    ):





  """simple docstring"""




  _lowerCamelCase						=						"whisper"
  _lowerCamelCase						=						["past_key_values"]
  _lowerCamelCase						=						{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}






  def __init__(					self    ,						UpperCamelCase=5_1865    ,						UpperCamelCase=80    ,						UpperCamelCase=6    ,						UpperCamelCase=4    ,						UpperCamelCase=6    ,						UpperCamelCase=4    ,						UpperCamelCase=1536    ,						UpperCamelCase=1536    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=5_0257    ,						UpperCamelCase=True    ,						UpperCamelCase=True    ,						UpperCamelCase="gelu"    ,						UpperCamelCase=256    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.02    ,						UpperCamelCase=False    ,						UpperCamelCase=1500    ,						UpperCamelCase=448    ,						UpperCamelCase=5_0256    ,						UpperCamelCase=5_0256    ,						UpperCamelCase=5_0256    ,						UpperCamelCase=None    ,						UpperCamelCase=[220, 5_0256]    ,						UpperCamelCase=False    ,						UpperCamelCase=256    ,						UpperCamelCase=False    ,						UpperCamelCase=0.05    ,						UpperCamelCase=10    ,						UpperCamelCase=2    ,						UpperCamelCase=0.0    ,						UpperCamelCase=10    ,						UpperCamelCase=0    ,						UpperCamelCase=7    ,						**UpperCamelCase    ,						):







   """simple docstring"""
   lowerCamelCase_  				=						vocab_size
   lowerCamelCase_  				=						num_mel_bins
   lowerCamelCase_  				=						d_model
   lowerCamelCase_  				=						encoder_layers
   lowerCamelCase_  				=						encoder_attention_heads
   lowerCamelCase_  				=						decoder_layers
   lowerCamelCase_  				=						decoder_attention_heads
   lowerCamelCase_  				=						decoder_ffn_dim
   lowerCamelCase_  				=						encoder_ffn_dim
   lowerCamelCase_  				=						dropout
   lowerCamelCase_  				=						attention_dropout
   lowerCamelCase_  				=						activation_dropout
   lowerCamelCase_  				=						activation_function
   lowerCamelCase_  				=						init_std
   lowerCamelCase_  				=						encoder_layerdrop
   lowerCamelCase_  				=						decoder_layerdrop
   lowerCamelCase_  				=						use_cache
   lowerCamelCase_  				=						encoder_layers
   lowerCamelCase_  				=						scale_embedding  # scale factor will be sqrt(d_model) if True
   lowerCamelCase_  				=						max_source_positions
   lowerCamelCase_  				=						max_target_positions

   # Audio Classification-specific parameters. Feel free to ignore for other classes.
   lowerCamelCase_  				=						classifier_proj_size
   lowerCamelCase_  				=						use_weighted_layer_sum

   # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
   lowerCamelCase_  				=						apply_spec_augment
   lowerCamelCase_  				=						mask_time_prob
   lowerCamelCase_  				=						mask_time_length
   lowerCamelCase_  				=						mask_time_min_masks
   lowerCamelCase_  				=						mask_feature_prob
   lowerCamelCase_  				=						mask_feature_length
   lowerCamelCase_  				=						mask_feature_min_masks

   lowerCamelCase_  				=						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   snake_case					(					lowercase    ):





  """simple docstring"""




  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						OrderedDict(
       [
           ("input_features", {0: "batch", 1: "feature_size", 2: "encoder_sequence"}),
       ]  )
   if self.use_past:
    lowerCamelCase_  				=						{0: "batch"}
   else:
    lowerCamelCase_  				=						{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 = 2_2050    ,						UpperCamelCase = 5.0    ,						UpperCamelCase = 220    ,						):







   """simple docstring"""
   lowerCamelCase_  				=						OrderedDict()
   lowerCamelCase_  				=						OnnxConfig.generate_dummy_inputs(
       self    ,						preprocessor=preprocessor.feature_extractor    ,						batch_size=UpperCamelCase    ,						framework=UpperCamelCase    ,						sampling_rate=UpperCamelCase    ,						time_duration=UpperCamelCase    ,						frequency=UpperCamelCase    ,						)
   lowerCamelCase_  				=						encoder_inputs["input_features"].shape[2]
   lowerCamelCase_  				=						encoder_sequence_length // 2 if self.use_past else seq_length

   lowerCamelCase_  				=						super().generate_dummy_inputs(
       preprocessor.tokenizer    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase  )

   lowerCamelCase_  				=						encoder_inputs.pop("input_features"  )
   lowerCamelCase_  				=						decoder_inputs.pop("decoder_input_ids"  )

   if "past_key_values" in decoder_inputs:
    lowerCamelCase_  				=						decoder_inputs.pop("past_key_values"  )

   return dummy_inputs







  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return 1e-3



