





'''simple docstring'''

from __future__ import annotations

from collections.abc import MutableSequence
class 							__lowerCAmelCase	:






       """simple docstring"""





       def __init__(				self  :						Tuple			,					lowerCAmelCase__  :						int			,					lowerCAmelCase__  :						MutableSequence[float]	)       ->	None:

            '''simple docstring'''




            if len(lowerCAmelCase__	) != degree + 1:
                 raise ValueError(
                     '''The number of coefficients should be equal to the degree + 1.'''	)

            _UpperCamelCase							       =			list(lowerCAmelCase__	)
            _UpperCamelCase							       =			degree





       def __add__(				self  :						int			,					lowerCAmelCase__  :						Polynomial	)       ->	Polynomial:

            '''simple docstring'''




            if self.degree > polynomial_a.degree:
                 _UpperCamelCase							       =			self.coefficients[:]
                 for i in range(polynomial_a.degree + 1	):
                      coefficients[i] += polynomial_a.coefficients[i]
                 return Polynomial(self.degree			,					lowerCAmelCase__	)
            else:
                 _UpperCamelCase							       =			polynomial_a.coefficients[:]
                 for i in range(self.degree + 1	):
                      coefficients[i] += self.coefficients[i]
                 return Polynomial(polynomial_a.degree			,					lowerCAmelCase__	)





       def __sub__(				self  :						Dict			,					lowerCAmelCase__  :						Polynomial	)       ->	Polynomial:

            '''simple docstring'''




            return self + polynomial_a * Polynomial(0			,					[-1]	)





       def __neg__(				self  :						Dict	)       ->	Polynomial:

            '''simple docstring'''




            return Polynomial(self.degree			,					[-c for c in self.coefficients]	)





       def __mul__(				self  :						Dict			,					lowerCAmelCase__  :						Polynomial	)       ->	Polynomial:

            '''simple docstring'''




            _UpperCamelCase							       =			[0] * (self.degree + polynomial_a.degree + 1)
            for i in range(self.degree + 1	):
                 for j in range(polynomial_a.degree + 1	):
                      coefficients[i + j] += (
                          self.coefficients[i] * polynomial_a.coefficients[j]
                      )

            return Polynomial(self.degree + polynomial_a.degree			,					lowerCAmelCase__	)





       def snake_case__		(				self  :						int			,					lowerCAmelCase__  :						int | float	)       ->	int | float:

            '''simple docstring'''




            _UpperCamelCase							       =			0
            for i in range(self.degree + 1	):
                 result += self.coefficients[i] * (substitution**i)
            return result





       def __str__(				self  :						Tuple	)       ->	str:

            '''simple docstring'''




            _UpperCamelCase							       =			''''''
            for i in range(self.degree			,					-1			,					-1	):
                 if self.coefficients[i] == 0:
                      continue
                 elif self.coefficients[i] > 0:
                      if polynomial:
                           polynomial += " + "
                 else:
                      polynomial += " - "

                 if i == 0:
                      polynomial += str(abs(self.coefficients[i]	)	)
                 elif i == 1:
                      polynomial += str(abs(self.coefficients[i]	)	) + "x"
                 else:
                      polynomial += str(abs(self.coefficients[i]	)	) + "x^" + str(lowerCAmelCase__	)

            return polynomial





       def __repr__(				self  :						List[Any]	)       ->	str:

            '''simple docstring'''




            return self.__str__()





       def snake_case__		(				self  :						Any	)       ->	Polynomial:

            '''simple docstring'''




            _UpperCamelCase							       =			[0] * self.degree
            for i in range(self.degree	):
                 _UpperCamelCase							       =			self.coefficients[i + 1] * (i + 1)
            return Polynomial(self.degree - 1			,					lowerCAmelCase__	)





       def snake_case__		(				self  :						Union[str, Any]			,					lowerCAmelCase__  :						int | float = 0	)       ->	Polynomial:

            '''simple docstring'''




            _UpperCamelCase							       =			[0] * (self.degree + 2)
            _UpperCamelCase							       =			constant
            for i in range(self.degree + 1	):
                 _UpperCamelCase							       =			self.coefficients[i] / (i + 1)
            return Polynomial(self.degree + 1			,					lowerCAmelCase__	)





       def __eq__(				self  :						Optional[Any]			,					lowerCAmelCase__  :						object	)       ->	bool:

            '''simple docstring'''




            if not isinstance(lowerCAmelCase__			,					lowerCAmelCase__	):
                 return False

            if self.degree != polynomial_a.degree:
                 return False

            for i in range(self.degree + 1	):
                 if self.coefficients[i] != polynomial_a.coefficients[i]:
                      return False

            return True







       def __ne__(				self  :						Any			,					lowerCAmelCase__  :						object	)       ->	bool:

            '''simple docstring'''




            return not self.__eq__(lowerCAmelCase__	)










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

lowercase__		:     Optional[Any]			=							logging.get_logger(__name__)

lowercase__		:     Union[str, Any]			=							{
    'openai/whisper-base': 'https://huggingface.co/openai/whisper-base/resolve/main/config.json',
}

# fmt: off
lowercase__		:     Any			=							[
    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
]
lowercase__		:     str			=							[
    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 							__lowerCAmelCase	(       __magic_name__					):






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





       def __init__(				self  :						Tuple			,					lowerCAmelCase__  :						List[str]=51865			,					lowerCAmelCase__  :						Optional[Any]=80			,					lowerCAmelCase__  :						Optional[int]=6			,					lowerCAmelCase__  :						List[Any]=4			,					lowerCAmelCase__  :						Any=6			,					lowerCAmelCase__  :						List[Any]=4			,					lowerCAmelCase__  :						List[Any]=1536			,					lowerCAmelCase__  :						Dict=1536			,					lowerCAmelCase__  :						int=0.0			,					lowerCAmelCase__  :						Optional[Any]=0.0			,					lowerCAmelCase__  :						int=50257			,					lowerCAmelCase__  :						Tuple=True			,					lowerCAmelCase__  :						Optional[Any]=True			,					lowerCAmelCase__  :						Optional[int]="gelu"			,					lowerCAmelCase__  :						Optional[int]=256			,					lowerCAmelCase__  :						Any=0.0			,					lowerCAmelCase__  :						Tuple=0.0			,					lowerCAmelCase__  :						Optional[Any]=0.0			,					lowerCAmelCase__  :						str=0.02			,					lowerCAmelCase__  :						Dict=False			,					lowerCAmelCase__  :						int=1500			,					lowerCAmelCase__  :						int=448			,					lowerCAmelCase__  :						Union[str, Any]=50256			,					lowerCAmelCase__  :						str=50256			,					lowerCAmelCase__  :						Optional[int]=50256			,					lowerCAmelCase__  :						List[str]=None			,					lowerCAmelCase__  :						Optional[int]=[220, 50256]			,					lowerCAmelCase__  :						List[Any]=False			,					lowerCAmelCase__  :						str=256			,					lowerCAmelCase__  :						Optional[Any]=False			,					lowerCAmelCase__  :						Any=0.05			,					lowerCAmelCase__  :						Optional[int]=10			,					lowerCAmelCase__  :						Dict=2			,					lowerCAmelCase__  :						int=0.0			,					lowerCAmelCase__  :						Dict=10			,					lowerCAmelCase__  :						List[str]=0			,					lowerCAmelCase__  :						List[Any]=7			,					**lowerCAmelCase__  :						List[str]			,					)       ->	Any:

            '''simple docstring'''




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

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

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

            _UpperCamelCase							       =			median_filter_width

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

class 							__lowerCAmelCase	(       __magic_name__					):






       """simple docstring"""





       @property
       def snake_case__		(				self  :						Optional[Any]	)       ->	Mapping[str, Mapping[int, str]]:

            '''simple docstring'''




            _UpperCamelCase							       =			OrderedDict(
                [
                    ('''input_features''', {0: '''batch''', 1: '''feature_size''', 2: '''encoder_sequence'''}),
                ]	)
            if self.use_past:
                 _UpperCamelCase							       =			{0: '''batch'''}
            else:
                 _UpperCamelCase							       =			{0: '''batch''', 1: '''decoder_sequence'''}

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

            return common_inputs





       def snake_case__		(				self  :						Dict			,					lowerCAmelCase__  :						Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]			,					lowerCAmelCase__  :						int = -1			,					lowerCAmelCase__  :						int = -1			,					lowerCAmelCase__  :						bool = False			,					lowerCAmelCase__  :						Optional["TensorType"] = None			,					lowerCAmelCase__  :						int = 22050			,					lowerCAmelCase__  :						float = 5.0			,					lowerCAmelCase__  :						int = 220			,					)       ->	Mapping[str, Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			OrderedDict()
            _UpperCamelCase							       =			OnnxConfig.generate_dummy_inputs(
                self			,					preprocessor=preprocessor.feature_extractor			,					batch_size=lowerCAmelCase__			,					framework=lowerCAmelCase__			,					sampling_rate=lowerCAmelCase__			,					time_duration=lowerCAmelCase__			,					frequency=lowerCAmelCase__			,					)
            _UpperCamelCase							       =			encoder_inputs['''input_features'''].shape[2]
            _UpperCamelCase							       =			encoder_sequence_length // 2 if self.use_past else seq_length

            _UpperCamelCase							       =			super().generate_dummy_inputs(
                preprocessor.tokenizer			,					lowerCAmelCase__			,					lowerCAmelCase__			,					lowerCAmelCase__			,					lowerCAmelCase__	)

            _UpperCamelCase							       =			encoder_inputs.pop('''input_features'''	)
            _UpperCamelCase							       =			decoder_inputs.pop('''decoder_input_ids'''	)

            if "past_key_values" in decoder_inputs:
                 _UpperCamelCase							       =			decoder_inputs.pop('''past_key_values'''	)

            return dummy_inputs







       @property
       def snake_case__		(				self  :						List[Any]	)       ->	float:

            '''simple docstring'''




            return 1e-3



