

"""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					:Dict    = logging.get_logger(__name__)

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

# fmt: off
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, 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
]
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, 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      __a							(UpperCamelCase_):






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

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


           """simple docstring"""


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

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

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

           SCREAMING_SNAKE_CASE__   :      str      		=	median_filter_width

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





class      __a							(UpperCamelCase_):






     '''simple docstring'''

     @property
     def 					_a			(						self  )  ->      Mapping[str, Mapping[int, str]]:


           """simple docstring"""


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

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

           return common_inputs

     def 					_a			(						self	,    _a	,    _a = -1	,    _a = -1	,    _a = False	,    _a = None	,    _a = 22_050	,    _a = 5.0	,    _a = 220	,    )  ->      Mapping[str, Any]:


           """simple docstring"""


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

           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	super().generate_dummy_inputs(
               preprocessor.tokenizer	,    _a	,    _a	,    _a	,    _a  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	encoder_inputs.pop("""input_features"""  )
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	decoder_inputs.pop("""decoder_input_ids"""  )

           if "past_key_values" in decoder_inputs:
                 SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	decoder_inputs.pop("""past_key_values"""  )

           return dummy_inputs





     @property
     def 					_a			(						self  )  ->      float:


           """simple docstring"""


           return 1E-3







"""simple docstring"""


import torch

from diffusers import DDPMScheduler

from .test_schedulers import SchedulerCommonTest

class      __a							(UpperCamelCase_):






     '''simple docstring'''
     _SCREAMING_SNAKE_CASE						:Tuple       = (DDPMScheduler,)

     def 					_a			(						self	,    **_a  )  ->      List[str]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      int      		=	{
               """num_train_timesteps""": 1_000,
               """beta_start""": 0.0_001,
               """beta_end""": 0.02,
               """beta_schedule""": """linear""",
               """variance_type""": """fixed_small""",
               """clip_sample""": True,
           }

           config.update(**_a  )
           return config

     def 					_a			(						self  )  ->      str:


           """simple docstring"""


           for timesteps in [1, 5, 100, 1_000]:
                 self.check_over_configs(num_train_timesteps=_a  )

     def 					_a			(						self  )  ->      str:


           """simple docstring"""


           for beta_start, beta_end in zip([0.0_001, 0.001, 0.01, 0.1]	,    [0.002, 0.02, 0.2, 2]  ):
                 self.check_over_configs(beta_start=_a	,    beta_end=_a  )

     def 					_a			(						self  )  ->      Union[str, Any]:


           """simple docstring"""


           for schedule in ["linear", "squaredcos_cap_v2"]:
                 self.check_over_configs(beta_schedule=_a  )

     def 					_a			(						self  )  ->      Any:


           """simple docstring"""


           for variance in ["fixed_small", "fixed_large", "other"]:
                 self.check_over_configs(variance_type=_a  )

     def 					_a			(						self  )  ->      Optional[int]:


           """simple docstring"""


           for clip_sample in [True, False]:
                 self.check_over_configs(clip_sample=_a  )

     def 					_a			(						self  )  ->      int:


           """simple docstring"""


           self.check_over_configs(thresholding=_a  )
           for threshold in [0.5, 1.0, 2.0]:
                 for prediction_type in ["epsilon", "sample", "v_prediction"]:
                       self.check_over_configs(
                           thresholding=_a	,    prediction_type=_a	,    sample_max_value=_a	,    )

     def 					_a			(						self  )  ->      str:


           """simple docstring"""


           for prediction_type in ["epsilon", "sample", "v_prediction"]:
                 self.check_over_configs(prediction_type=_a  )

     def 					_a			(						self  )  ->      str:


           """simple docstring"""


           for t in [0, 500, 999]:
                 self.check_over_forward(time_step=_a  )

     def 					_a			(						self  )  ->      str:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Tuple      		=	self.scheduler_classes[0]
           SCREAMING_SNAKE_CASE__   :      int      		=	self.get_scheduler_config()
           SCREAMING_SNAKE_CASE__   :      Dict      		=	scheduler_class(**_a  )

           assert torch.sum(torch.abs(scheduler._get_variance(0  ) - 0.0  )  ) < 1E-5
           assert torch.sum(torch.abs(scheduler._get_variance(487  ) - 0.00_979  )  ) < 1E-5
           assert torch.sum(torch.abs(scheduler._get_variance(999  ) - 0.02  )  ) < 1E-5

     def 					_a			(						self  )  ->      List[Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	self.scheduler_classes[0]
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	self.get_scheduler_config()
           SCREAMING_SNAKE_CASE__   :      int      		=	scheduler_class(**_a  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	len(_a  )

           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	self.dummy_model()
           SCREAMING_SNAKE_CASE__   :      str      		=	self.dummy_sample_deter
           SCREAMING_SNAKE_CASE__   :      str      		=	torch.manual_seed(0  )

           for t in reversed(range(_a  )  ):
                 # 1. predict noise residual
                 SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	model(_a	,    _a  )

                 # 2. predict previous mean of sample x_t-1
                 SCREAMING_SNAKE_CASE__   :      int      		=	scheduler.step(_a	,    _a	,    _a	,    generator=_a  ).prev_sample

                 # if t > 0:
                 #     noise = self.dummy_sample_deter
                 #     variance = scheduler.get_variance(t) ** (0.5) * noise
                 #
                 # sample = pred_prev_sample + variance
                 SCREAMING_SNAKE_CASE__   :      str      		=	pred_prev_sample

           SCREAMING_SNAKE_CASE__   :      str      		=	torch.sum(torch.abs(_a  )  )
           SCREAMING_SNAKE_CASE__   :      Any      		=	torch.mean(torch.abs(_a  )  )

           assert abs(result_sum.item() - 258.9_606  ) < 1E-2
           assert abs(result_mean.item() - 0.3_372  ) < 1E-3

     def 					_a			(						self  )  ->      Optional[Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	self.scheduler_classes[0]
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	self.get_scheduler_config(prediction_type="""v_prediction"""  )
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	scheduler_class(**_a  )

           SCREAMING_SNAKE_CASE__   :      Dict      		=	len(_a  )

           SCREAMING_SNAKE_CASE__   :      List[str]      		=	self.dummy_model()
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	self.dummy_sample_deter
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	torch.manual_seed(0  )

           for t in reversed(range(_a  )  ):
                 # 1. predict noise residual
                 SCREAMING_SNAKE_CASE__   :      int      		=	model(_a	,    _a  )

                 # 2. predict previous mean of sample x_t-1
                 SCREAMING_SNAKE_CASE__   :      List[str]      		=	scheduler.step(_a	,    _a	,    _a	,    generator=_a  ).prev_sample

                 # if t > 0:
                 #     noise = self.dummy_sample_deter
                 #     variance = scheduler.get_variance(t) ** (0.5) * noise
                 #
                 # sample = pred_prev_sample + variance
                 SCREAMING_SNAKE_CASE__   :      Tuple      		=	pred_prev_sample

           SCREAMING_SNAKE_CASE__   :      Any      		=	torch.sum(torch.abs(_a  )  )
           SCREAMING_SNAKE_CASE__   :      int      		=	torch.mean(torch.abs(_a  )  )

           assert abs(result_sum.item() - 202.0_296  ) < 1E-2
           assert abs(result_mean.item() - 0.2_631  ) < 1E-3

     def 					_a			(						self  )  ->      Union[str, Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	self.scheduler_classes[0]
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	self.get_scheduler_config()
           SCREAMING_SNAKE_CASE__   :      Dict      		=	scheduler_class(**_a  )

           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	[100, 87, 50, 1, 0]

           scheduler.set_timesteps(timesteps=_a  )

           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	scheduler.timesteps

           for i, timestep in enumerate(_a  ):
                 if i == len(_a  ) - 1:
                       SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	-1
                 else:
                       SCREAMING_SNAKE_CASE__   :      Tuple      		=	timesteps[i + 1]

                 SCREAMING_SNAKE_CASE__   :      int      		=	scheduler.previous_timestep(_a  )
                 SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	prev_t.item()

                 self.assertEqual(_a	,    _a  )

     def 					_a			(						self  )  ->      Union[str, Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Tuple      		=	self.scheduler_classes[0]
           SCREAMING_SNAKE_CASE__   :      int      		=	self.get_scheduler_config()
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	scheduler_class(**_a  )

           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	[100, 87, 50, 51, 0]

           with self.assertRaises(_a	,    msg="""`custom_timesteps` must be in descending order."""  ):
                 scheduler.set_timesteps(timesteps=_a  )

     def 					_a			(						self  )  ->      List[Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	self.scheduler_classes[0]
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	self.get_scheduler_config()
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	scheduler_class(**_a  )

           SCREAMING_SNAKE_CASE__   :      int      		=	[100, 87, 50, 1, 0]
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	len(_a  )

           with self.assertRaises(_a	,    msg="""Can only pass one of `num_inference_steps` or `custom_timesteps`."""  ):
                 scheduler.set_timesteps(num_inference_steps=_a	,    timesteps=_a  )





     def 					_a			(						self  )  ->      Tuple:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	self.scheduler_classes[0]
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	self.get_scheduler_config()
           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	scheduler_class(**_a  )

           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	[scheduler.config.num_train_timesteps]

           with self.assertRaises(
               _a	,    msg="""`timesteps` must start before `self.config.train_timesteps`: {scheduler.config.num_train_timesteps}}"""	,    ):
                 scheduler.set_timesteps(timesteps=_a  )




