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

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

# fmt: off
_a								=						[
    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, 1_0563, 1_0786,
    1_1420, 1_1709, 1_1907, 1_3163, 1_3697, 1_3700, 1_4808, 1_5306, 1_6410, 1_6791,
    1_7992, 1_9203, 1_9510, 2_0724, 2_2305, 2_2935, 2_7007, 3_0109, 3_0420, 3_3409,
    3_4949, 4_0283, 4_0493, 4_0549, 4_7282, 4_9146, 5_0257, 5_0359, 5_0360, 5_0361
]
_a								=						[
    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, 1_0428, 1_0929, 1_1938, 1_2033, 1_2331, 1_2562, 1_3793,
    1_4157, 1_4635, 1_5265, 1_5618, 1_6553, 1_6604, 1_8362, 1_8956, 2_0075, 2_1675,
    2_2520, 2_6130, 2_6161, 2_6435, 2_8279, 2_9464, 3_1650, 3_2302, 3_2470, 3_6865,
    4_2863, 4_7425, 4_9870, 5_0254, 5_0258, 5_0360, 5_0361, 5_0362
]






class        _UpperCAmelCase(       lowerCamelCase      ):
		lowercase__         = 'whisper'
		lowercase__         = ['past_key_values']
		lowercase__         = {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}



		def __init__(   self							,						__a=5_18_65							,						__a=80							,						__a=6							,						__a=4							,						__a=6							,						__a=4							,						__a=15_36							,						__a=15_36							,						__a=0.0							,						__a=0.0							,						__a=5_02_57							,						__a=True							,						__a=True							,						__a="gelu"							,						__a=2_56							,						__a=0.0							,						__a=0.0							,						__a=0.0							,						__a=0.02							,						__a=False							,						__a=15_00							,						__a=4_48							,						__a=5_02_56							,						__a=5_02_56							,						__a=5_02_56							,						__a=None							,						__a=[2_20, 5_02_56]							,						__a=False							,						__a=2_56							,						__a=False							,						__a=0.05							,						__a=10							,						__a=2							,						__a=0.0							,						__a=10							,						__a=0							,						__a=7							,						**__a							,						)			->			Optional[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=__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        _UpperCAmelCase(       lowerCamelCase      ):



		@property
		def 		UpperCAmelCase				(   self)			->			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_(__a							,						direction='''inputs''')

							return common_inputs



		def 		UpperCAmelCase				(   self							,						__a							,						__a = -1							,						__a = -1							,						__a = False							,						__a = None							,						__a = 2_20_50							,						__a = 5.0							,						__a = 2_20							,						)			->			Mapping[str, Any]:






							'''simple docstring'''
							_UpperCamelCase									=    OrderedDict()
							_UpperCamelCase									=    OnnxConfig.generate_dummy_inputs(
							    self							,						preprocessor=preprocessor.feature_extractor							,						batch_size=__a							,						framework=__a							,						sampling_rate=__a							,						time_duration=__a							,						frequency=__a							,						)
							_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							,						__a							,						__a							,						__a							,						__a)

							_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 		UpperCAmelCase				(   self)			->			float:






							'''simple docstring'''
							return 1e-3








"""simple docstring"""





from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import numpy
				import tensorflow as tf

				from transformers import (
				    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    BertConfig,
				    DPRConfig,
				    TFDPRContextEncoder,
				    TFDPRQuestionEncoder,
				    TFDPRReader,
				)






class        _UpperCAmelCase:



		def __init__(   self							,						__a							,						__a=13							,						__a=7							,						__a=True							,						__a=True							,						__a=True							,						__a=True							,						__a=99							,						__a=32							,						__a=2							,						__a=4							,						__a=37							,						__a="gelu"							,						__a=0.1							,						__a=0.1							,						__a=5_12							,						__a=16							,						__a=2							,						__a=0.02							,						__a=3							,						__a=4							,						__a=None							,						__a=0							,						)			->			Any:






							'''simple docstring'''
							_UpperCamelCase									=    parent
							_UpperCamelCase									=    batch_size
							_UpperCamelCase									=    seq_length
							_UpperCamelCase									=    is_training
							_UpperCamelCase									=    use_input_mask
							_UpperCamelCase									=    use_token_type_ids
							_UpperCamelCase									=    use_labels
							_UpperCamelCase									=    vocab_size
							_UpperCamelCase									=    hidden_size
							_UpperCamelCase									=    num_hidden_layers
							_UpperCamelCase									=    num_attention_heads
							_UpperCamelCase									=    intermediate_size
							_UpperCamelCase									=    hidden_act
							_UpperCamelCase									=    hidden_dropout_prob
							_UpperCamelCase									=    attention_probs_dropout_prob
							_UpperCamelCase									=    max_position_embeddings
							_UpperCamelCase									=    type_vocab_size
							_UpperCamelCase									=    type_sequence_label_size
							_UpperCamelCase									=    initializer_range
							_UpperCamelCase									=    num_labels
							_UpperCamelCase									=    num_choices
							_UpperCamelCase									=    scope
							_UpperCamelCase									=    projection_dim



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






							'''simple docstring'''
							_UpperCamelCase									=    ids_tensor([self.batch_size, self.seq_length]							,						self.vocab_size)

							_UpperCamelCase									=    None
							if self.use_input_mask:
												# follow test_modeling_tf_ctrl.py
												_UpperCamelCase									=    random_attention_mask([self.batch_size, self.seq_length])

							_UpperCamelCase									=    None
							if self.use_token_type_ids:
												_UpperCamelCase									=    ids_tensor([self.batch_size, self.seq_length]							,						self.type_vocab_size)

							_UpperCamelCase									=    None
							_UpperCamelCase									=    None
							_UpperCamelCase									=    None
							if self.use_labels:
												_UpperCamelCase									=    ids_tensor([self.batch_size]							,						self.type_sequence_label_size)
												_UpperCamelCase									=    ids_tensor([self.batch_size, self.seq_length]							,						self.num_labels)
												_UpperCamelCase									=    ids_tensor([self.batch_size]							,						self.num_choices)

							_UpperCamelCase									=    BertConfig(
							    vocab_size=self.vocab_size							,						hidden_size=self.hidden_size							,						num_hidden_layers=self.num_hidden_layers							,						num_attention_heads=self.num_attention_heads							,						intermediate_size=self.intermediate_size							,						hidden_act=self.hidden_act							,						hidden_dropout_prob=self.hidden_dropout_prob							,						attention_probs_dropout_prob=self.attention_probs_dropout_prob							,						max_position_embeddings=self.max_position_embeddings							,						type_vocab_size=self.type_vocab_size							,						is_decoder=__a							,						initializer_range=self.initializer_range							,						)
							_UpperCamelCase									=    DPRConfig(projection_dim=self.projection_dim							,						**config.to_dict())

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



		def 		UpperCAmelCase				(   self							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a)			->			Optional[int]:






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRContextEncoder(config=__a)
							_UpperCamelCase									=    model(__a							,						attention_mask=__a							,						token_type_ids=__a)
							_UpperCamelCase									=    model(__a							,						token_type_ids=__a)
							_UpperCamelCase									=    model(__a)
							self.parent.assertEqual(result.pooler_output.shape							,						(self.batch_size, self.projection_dim or self.hidden_size))



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






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRQuestionEncoder(config=__a)
							_UpperCamelCase									=    model(__a							,						attention_mask=__a							,						token_type_ids=__a)
							_UpperCamelCase									=    model(__a							,						token_type_ids=__a)
							_UpperCamelCase									=    model(__a)
							self.parent.assertEqual(result.pooler_output.shape							,						(self.batch_size, self.projection_dim or self.hidden_size))



		def 		UpperCAmelCase				(   self							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a)			->			Dict:






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRReader(config=__a)
							_UpperCamelCase									=    model(__a							,						attention_mask=__a)

							self.parent.assertEqual(result.start_logits.shape							,						(self.batch_size, self.seq_length))
							self.parent.assertEqual(result.end_logits.shape							,						(self.batch_size, self.seq_length))
							self.parent.assertEqual(result.relevance_logits.shape							,						(self.batch_size,))




		def 		UpperCAmelCase				(   self)			->			Any:






							'''simple docstring'''
							_UpperCamelCase									=    self.prepare_config_and_inputs()
							(
							    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    
							)									=    config_and_inputs
							_UpperCamelCase									=    {'''input_ids''': input_ids}
							return config, inputs_dict






@require_tf
class        _UpperCAmelCase(       lowerCamelCase ,	lowerCamelCase ,	unittest.TestCase      ):
		lowercase__         = (
		    (
		        TFDPRContextEncoder,
		        TFDPRQuestionEncoder,
		        TFDPRReader,
		    )
		    if is_tf_available()
		    else ()
		)
		lowercase__         = {'feature-extraction': TFDPRQuestionEncoder} if is_tf_available() else {}

		lowercase__         = False
		lowercase__         = False
		lowercase__         = False
		lowercase__         = False
		lowercase__         = False



		def 		UpperCAmelCase				(   self)			->			Tuple:






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRModelTester(self)
							_UpperCamelCase									=    ConfigTester(self							,						config_class=__a							,						hidden_size=37)



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






							'''simple docstring'''
							self.config_tester.run_common_tests()



		def 		UpperCAmelCase				(   self)			->			Tuple:






							'''simple docstring'''
							_UpperCamelCase									=    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_context_encoder(*__a)



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






							'''simple docstring'''
							_UpperCamelCase									=    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_question_encoder(*__a)



		def 		UpperCAmelCase				(   self)			->			Dict:






							'''simple docstring'''
							_UpperCamelCase									=    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_reader(*__a)




		@slow
		def 		UpperCAmelCase				(   self)			->			str:






							'''simple docstring'''
							for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase									=    TFDPRContextEncoder.from_pretrained(__a)
												self.assertIsNotNone(__a)

							for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase									=    TFDPRContextEncoder.from_pretrained(__a)
												self.assertIsNotNone(__a)

							for model_name in TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase									=    TFDPRQuestionEncoder.from_pretrained(__a)
												self.assertIsNotNone(__a)

							for model_name in TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase									=    TFDPRReader.from_pretrained(__a)
												self.assertIsNotNone(__a)






@require_tf
class        _UpperCAmelCase(       unittest.TestCase      ):



		@slow
		def 		UpperCAmelCase				(   self)			->			Tuple:






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRQuestionEncoder.from_pretrained('''facebook/dpr-question_encoder-single-nq-base''')

							_UpperCamelCase									=    tf.constant(
							    [[1_01, 75_92, 10_10, 20_03, 20_26, 38_99, 1_01_40, 10_29, 1_02]])  # [CLS] hello, is my dog cute? [SEP]
							_UpperCamelCase									=    model(__a)[0]  # embedding shape = (1, 768)
							# compare the actual values for a slice.
							_UpperCamelCase									=    tf.constant(
							    [
							        [
							            0.0323_6253,
							            0.1275_3335,
							            0.1681_8509,
							            0.0027_9786,
							            0.389_6933,
							            0.2426_4945,
							            0.217_8971,
							            -0.0233_5227,
							            -0.0848_1959,
							            -0.1432_4117,
							        ]
							    ])
							self.assertTrue(numpy.allclose(output[:, :10].numpy()							,						expected_slice.numpy()							,						atol=1e-4))






