from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


_lowerCAmelCase       =		logging.get_logger(__name__)
def 					_snake_case	(  __snake_case						):
					if isinstance(__snake_case  ,     np.ndarray						):
										return list(tensor.shape						)

					_UpperCamelCase			     =     tf.shape(__snake_case						)

					if tensor.shape == tf.TensorShape(__snake_case						):
										return dynamic

					_UpperCamelCase			     =     tensor.shape.as_list()

					return [dynamic[i] if s is None else s for i, s in enumerate(__snake_case						)]
def 					_snake_case	(  __snake_case  ,     __snake_case = None  ,     __snake_case = None						):
					return tf.nn.softmax(logits=logits + 1E-9  ,     axis=__snake_case  ,     name=__snake_case						)
def 					_snake_case	(  __snake_case  ,     __snake_case  ,     __snake_case  ,     __snake_case=1E-5  ,     __snake_case=-1						):
					# This is a very simplified functional layernorm, designed to duplicate
					# the functionality of PyTorch nn.functional.layer_norm when this is needed to port
					# models in Transformers.

					if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(__snake_case  ,     __snake_case						):
										raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.'''						)

					# Get mean and variance on the axis to be normalized
					_UpperCamelCase     ,    _UpperCamelCase			     =     tf.nn.moments(__snake_case  ,     axes=[axis]  ,     keepdims=__snake_case						)

					if axis != -1:
										# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
										# on every dimension except axis
										_UpperCamelCase			     =     [1] * inputs.shape.rank
										_UpperCamelCase			     =     shape_list(__snake_case						)[axis]
										_UpperCamelCase			     =     tf.reshape(__snake_case  ,     __snake_case						)
										_UpperCamelCase			     =     tf.reshape(__snake_case  ,     __snake_case						)

					# Compute layer normalization using the batch_normalization
					# function.
					_UpperCamelCase			     =     tf.nn.batch_normalization(
					    __snake_case  ,     __snake_case  ,     __snake_case  ,     offset=__snake_case  ,     scale=__snake_case  ,     variance_epsilon=__snake_case  ,     )
					return outputs
def 					_snake_case	(  __snake_case  ,     __snake_case=0  ,     __snake_case=-1						):
					# Replicates the behavior of torch.flatten in TF

					# If end_dim or start_dim is negative, count them from the end
					if end_dim < 0:
										end_dim += input.shape.rank
					if start_dim < 0:
										start_dim += input.shape.rank

					if start_dim == end_dim:
										return input

					_UpperCamelCase			     =     tf.shape(__snake_case						)
					_UpperCamelCase			     =     tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]						)
					_UpperCamelCase			     =     tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]  ,     axis=0						)
					return tf.reshape(__snake_case  ,     __snake_case						)
def 					_snake_case	(  __snake_case						):
					if not isinstance(__snake_case  ,     tf.Tensor						):
										_UpperCamelCase			     =     tf.convert_to_tensor(__snake_case						)  # Catches stray NumPy inputs
					if encoder_attention_mask.shape.rank == 3:
										_UpperCamelCase			     =     encoder_attention_mask[:, None, :, :]
					if encoder_attention_mask.shape.rank == 2:
										_UpperCamelCase			     =     encoder_attention_mask[:, None, None, :]
					# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
					# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
					# /transformer/transformer_layers.py#L270
					# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
					# encoder_extended_attention_mask.transpose(-1, -2))
					_UpperCamelCase			     =     (
					    tf.cast(1  ,     encoder_attention_mask.dtype						) - encoder_extended_attention_mask
					) * encoder_extended_attention_mask.dtype.min

					return encoder_extended_attention_mask
def 					_snake_case	(  __snake_case  ,     __snake_case  ,     __snake_case = "input_ids"						):
					tf.debugging.assert_less(
					    __snake_case  ,     tf.cast(__snake_case  ,     dtype=tensor.dtype						)  ,     message=(
					        f"""The maximum value of {tensor_name} ({tf.math.reduce_max(__snake_case						)}) must be smaller than the embedding """
					        f"""layer's input dimension ({embed_dim}). The likely cause is some problem at tokenization time."""
					    )  ,     )
def 					_snake_case	(  __snake_case  ,     __snake_case  ,     __snake_case						):
					_UpperCamelCase			     =     64512
					# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
					# because in that case even chunking the array would not make the saving
					# possible.
					_UpperCamelCase			     =     [x for x in data if len(__snake_case						) > HDF5_OBJECT_HEADER_LIMIT]

					# Expecting this to never be true.
					if bad_attributes:
										raise RuntimeError(
										    '''The following attributes cannot be saved to HDF5 file because '''
										    f"""they are larger than {HDF5_OBJECT_HEADER_LIMIT} """
										    f"""bytes: {bad_attributes}"""						)

					_UpperCamelCase			     =     np.asarray(__snake_case						)

					_UpperCamelCase			     =     1
					_UpperCamelCase			     =     np.array_split(__snake_case  ,     __snake_case						)

					# This will never loop forever thanks to the test above.
					while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data						):
										num_chunks += 1
										_UpperCamelCase			     =     np.array_split(__snake_case  ,     __snake_case						)

					if num_chunks > 1:
										for chunk_id, chunk_data in enumerate(__snake_case						):
															_UpperCamelCase			     =     chunk_data
					else:
										_UpperCamelCase			     =     data
def 					_snake_case	(  __snake_case  ,     __snake_case						):
					if name in group.attrs:
										_UpperCamelCase			     =     [n.decode('''utf8'''						) if hasattr(__snake_case  ,     '''decode'''						) else n for n in group.attrs[name]]
					else:
										_UpperCamelCase			     =     []
										_UpperCamelCase			     =     0
										while "%s%d" % (name, chunk_id) in group.attrs:
															data.extend(
															    [n.decode('''utf8'''						) if hasattr(__snake_case  ,     '''decode'''						) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]]						)
															chunk_id += 1
					return data







def 					_snake_case	(  __snake_case						):

					def _expand_single_ad_tensor(__snake_case						):
										if isinstance(__snake_case  ,     tf.Tensor						) and t.shape.rank == 1:
															return tf.expand_dims(__snake_case  ,     axis=-1						)
										return t

					return tf.nest.map_structure(_expand_single_ad_tensor  ,     __snake_case						)







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

SCREAMING_SNAKE_CASE__							:      List[str]         =    logging.get_logger(__name__)

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

# fmt: off
SCREAMING_SNAKE_CASE__							:      int         =    [
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_7, 3_6_6, 4_3_8, 5_3_2, 6_8_5,
    7_0_5, 7_9_6, 9_3_0, 1_0_5_8, 1_2_2_0, 1_2_6_7, 1_2_7_9, 1_3_0_3, 1_3_4_3, 1_3_7_7,
    1_3_9_1, 1_6_3_5, 1_7_8_2, 1_8_7_5, 2_1_6_2, 2_3_6_1, 2_4_8_8, 3_4_6_7, 4_0_0_8, 4_2_1_1,
    4_6_0_0, 4_8_0_8, 5_2_9_9, 5_8_5_5, 6_3_2_9, 7_2_0_3, 9_6_0_9, 9_9_5_9, 1_0_5_6_3, 1_0_7_8_6,
    1_1_4_2_0, 1_1_7_0_9, 1_1_9_0_7, 1_3_1_6_3, 1_3_6_9_7, 1_3_7_0_0, 1_4_8_0_8, 1_5_3_0_6, 1_6_4_1_0, 1_6_7_9_1,
    1_7_9_9_2, 1_9_2_0_3, 1_9_5_1_0, 2_0_7_2_4, 2_2_3_0_5, 2_2_9_3_5, 2_7_0_0_7, 3_0_1_0_9, 3_0_4_2_0, 3_3_4_0_9,
    3_4_9_4_9, 4_0_2_8_3, 4_0_4_9_3, 4_0_5_4_9, 4_7_2_8_2, 4_9_1_4_6, 5_0_2_5_7, 5_0_3_5_9, 5_0_3_6_0, 5_0_3_6_1
]
SCREAMING_SNAKE_CASE__							:      List[str]         =    [
    1, 2, 7, 8, 9, 1_0, 1_4, 2_5,
    2_6, 2_7, 2_8, 2_9, 3_1, 5_8, 5_9, 6_0, 6_1, 6_2,
    6_3, 9_0, 9_1, 9_2, 9_3, 3_5_9, 5_0_3, 5_2_2, 5_4_2, 8_7_3,
    8_9_3, 9_0_2, 9_1_8, 9_2_2, 9_3_1, 1_3_5_0, 1_8_5_3, 1_9_8_2, 2_4_6_0, 2_6_2_7,
    3_2_4_6, 3_2_5_3, 3_2_6_8, 3_5_3_6, 3_8_4_6, 3_9_6_1, 4_1_8_3, 4_6_6_7, 6_5_8_5, 6_6_4_7,
    7_2_7_3, 9_0_6_1, 9_3_8_3, 1_0_4_2_8, 1_0_9_2_9, 1_1_9_3_8, 1_2_0_3_3, 1_2_3_3_1, 1_2_5_6_2, 1_3_7_9_3,
    1_4_1_5_7, 1_4_6_3_5, 1_5_2_6_5, 1_5_6_1_8, 1_6_5_5_3, 1_6_6_0_4, 1_8_3_6_2, 1_8_9_5_6, 2_0_0_7_5, 2_1_6_7_5,
    2_2_5_2_0, 2_6_1_3_0, 2_6_1_6_1, 2_6_4_3_5, 2_8_2_7_9, 2_9_4_6_4, 3_1_6_5_0, 3_2_3_0_2, 3_2_4_7_0, 3_6_8_6_5,
    4_2_8_6_3, 4_7_4_2_5, 4_9_8_7_0, 5_0_2_5_4, 5_0_2_5_8, 5_0_3_6_0, 5_0_3_6_1, 5_0_3_6_2
]







class 	__lowerCAmelCase      (       _UpperCamelCase	):
   _UpperCamelCase			:    Any  		=					"""whisper"""
   _UpperCamelCase			:    Union[str, Any]  		=					["""past_key_values"""]
   _UpperCamelCase			:    Union[str, Any]  		=					{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}





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





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

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

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

      a__						:    List[str]   		=	median_filter_width

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







class 	__lowerCAmelCase      (       _UpperCamelCase	):





   @property
   def 						_snake_case			(			self   )					->	Mapping[str, Mapping[int, str]]:
      """simple docstring"""





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

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

      return common_inputs





   def 						_snake_case			(			self       ,      snake_case       ,      snake_case = -1       ,      snake_case = -1       ,      snake_case = False       ,      snake_case = None       ,      snake_case = 22_050       ,      snake_case = 5.0       ,      snake_case = 220       ,      )					->	Mapping[str, Any]:
      """simple docstring"""





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

      a__						:    Optional[int]   		=	super().generate_dummy_inputs(
          preprocessor.tokenizer       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case   )

      a__						:    Any   		=	encoder_inputs.pop("input_features"   )
      a__						:    Dict   		=	decoder_inputs.pop("decoder_input_ids"   )

      if "past_key_values" in decoder_inputs:
         a__						:    Tuple   		=	decoder_inputs.pop("past_key_values"   )

      return dummy_inputs





   @property
   def 						_snake_case			(			self   )					->	float:
      """simple docstring"""





      return 1E-3

