






import inspect
import unittest

from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
			import jax
			import jax.numpy as jnp

			from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel

if is_vision_available():
			from PIL import Image

			from transformers import AutoImageProcessor




class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						def __init__(self:					Dict ,					__UpperCAmelCase:					List[Any] ,					__UpperCAmelCase:					Optional[Any]=3 ,					__UpperCAmelCase:					str=32 ,					__UpperCAmelCase:					Tuple=3 ,					__UpperCAmelCase:					str=10 ,					__UpperCAmelCase:					Optional[Any]=[10, 20, 30, 40] ,					__UpperCAmelCase:					Optional[Any]=[1, 1, 2, 1] ,					__UpperCAmelCase:					int=True ,					__UpperCAmelCase:					Tuple=True ,					__UpperCAmelCase:					int="relu" ,					__UpperCAmelCase:					str=3 ,					__UpperCAmelCase:					Dict=None ,					)    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Dict      =					parent
											__a					:						str      =					batch_size
											__a					:						List[str]      =					image_size
											__a					:						List[str]      =					num_channels
											__a					:						Tuple      =					embeddings_size
											__a					:						List[str]      =					hidden_sizes
											__a					:						str      =					depths
											__a					:						Optional[Any]      =					is_training
											__a					:						Any      =					use_labels
											__a					:						Union[str, Any]      =					hidden_act
											__a					:						Dict      =					num_labels
											__a					:						Dict      =					scope
											__a					:						Optional[int]      =					len(lowerCAmelCase__   )



						def        UpperCAmelCase__					(self:					List[Any]   )    ->     Dict:




											'''simple docstring'''



											__a					:						List[str]      =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

											__a					:						Tuple      =					self.get_config()

											return config, pixel_values



						def        UpperCAmelCase__					(self:					str   )    ->     Any:




											'''simple docstring'''



											return RegNetConfig(
											    num_channels=self.num_channels ,					embeddings_size=self.embeddings_size ,					hidden_sizes=self.hidden_sizes ,					depths=self.depths ,					hidden_act=self.hidden_act ,					num_labels=self.num_labels ,					image_size=self.image_size ,					)



						def        UpperCAmelCase__					(self:					Tuple ,					__UpperCAmelCase:					str ,					__UpperCAmelCase:					Tuple   )    ->     Optional[Any]:




											'''simple docstring'''



											__a					:						Dict      =					FlaxRegNetModel(config=lowerCAmelCase__   )
											__a					:						Optional[Any]      =					model(lowerCAmelCase__   )

											# Output shape (b, c, h, w)
											self.parent.assertEqual(
											    result.last_hidden_state.shape ,					(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) ,					)



						def        UpperCAmelCase__					(self:					int ,					__UpperCAmelCase:					Optional[int] ,					__UpperCAmelCase:					List[str]   )    ->     Tuple:




											'''simple docstring'''



											__a					:						str      =					self.num_labels
											__a					:						List[Any]      =					FlaxRegNetForImageClassification(config=lowerCAmelCase__   )
											__a					:						List[str]      =					model(lowerCAmelCase__   )
											self.parent.assertEqual(result.logits.shape ,					(self.batch_size, self.num_labels)   )



						def        UpperCAmelCase__					(self:					int   )    ->     Any:




											'''simple docstring'''



											__a					:						List[Any]      =					self.prepare_config_and_inputs()
											__a      ,			__a					:						List[str]      =					config_and_inputs
											__a					:						Tuple      =					{"pixel_values": pixel_values}
											return config, inputs_dict




@require_flax
class 							snake_case_       (    __UpperCamelCase		,							unittest.TestCase      ):

						"""simple docstring"""



						snake_case__        =      (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

						snake_case__        =      False
						snake_case__        =      False
						snake_case__        =      False



						def        UpperCAmelCase__					(self:					str   )    ->     None:




											'''simple docstring'''



											__a					:						Any      =					FlaxRegNetModelTester(self   )
											__a					:						Dict      =					ConfigTester(self ,					config_class=lowerCAmelCase__ ,					has_text_modality=lowerCAmelCase__   )



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




											'''simple docstring'''



											self.create_and_test_config_common_properties()
											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()



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




											'''simple docstring'''



											return



						def        UpperCAmelCase__					(self:					Dict   )    ->     Optional[Any]:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*lowerCAmelCase__   )



						def        UpperCAmelCase__					(self:					Any   )    ->     Tuple:




											'''simple docstring'''



											__a					:						Dict      =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__   )



						@unittest.skip(reason="RegNet does not use inputs_embeds"   )
						def        UpperCAmelCase__					(self:					Dict   )    ->     Dict:




											'''simple docstring'''



											pass



						@unittest.skip(reason="RegNet does not support input and output embeddings"   )
						def        UpperCAmelCase__					(self:					Union[str, Any]   )    ->     Dict:




											'''simple docstring'''



											pass



						def        UpperCAmelCase__					(self:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											__a      ,			__a					:						Optional[int]      =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__a					:						Tuple      =					model_class(lowerCAmelCase__   )
																__a					:						Dict      =					inspect.signature(model.__call__   )
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																__a					:						Tuple      =					[*signature.parameters.keys()]

																__a					:						Dict      =					["pixel_values"]
																self.assertListEqual(arg_names[:1] ,					lowerCAmelCase__   )



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




											'''simple docstring'''



											def check_hidden_states_output(__UpperCAmelCase:					Dict ,					__UpperCAmelCase:					Tuple ,					__UpperCAmelCase:					Optional[Any]   ):
																__a					:						Any      =					model_class(lowerCAmelCase__   )

																__a					:						List[str]      =					model(**self._prepare_for_class(lowerCAmelCase__ ,					lowerCAmelCase__   )   )

																__a					:						Any      =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																__a					:						List[str]      =					self.model_tester.num_stages
																self.assertEqual(len(lowerCAmelCase__   ) ,					expected_num_stages + 1   )

											__a      ,			__a					:						Union[str, Any]      =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__a					:						Any      =					True
																check_hidden_states_output(lowerCAmelCase__ ,					lowerCAmelCase__ ,					lowerCAmelCase__   )

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																__a					:						str      =					True

																check_hidden_states_output(lowerCAmelCase__ ,					lowerCAmelCase__ ,					lowerCAmelCase__   )



						def        UpperCAmelCase__					(self:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											__a      ,			__a					:						Union[str, Any]      =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																with self.subTest(model_class.__name__   ):
																					__a					:						Tuple      =					self._prepare_for_class(lowerCAmelCase__ ,					lowerCAmelCase__   )
																					__a					:						Tuple      =					model_class(lowerCAmelCase__   )

																					@jax.jit
																					def model_jitted(__UpperCAmelCase:					List[str] ,					**__UpperCAmelCase:					Optional[int]   ):
																										return model(pixel_values=lowerCAmelCase__ ,					**lowerCAmelCase__   )

																					with self.subTest("JIT Enabled"   ):
																										__a					:						List[Any]      =					model_jitted(**lowerCAmelCase__   ).to_tuple()

																					with self.subTest("JIT Disabled"   ):
																										with jax.disable_jit():
																															__a					:						List[Any]      =					model_jitted(**lowerCAmelCase__   ).to_tuple()

																					self.assertEqual(len(lowerCAmelCase__   ) ,					len(lowerCAmelCase__   )   )
																					for jitted_output, output in zip(lowerCAmelCase__ ,					lowerCAmelCase__   ):
																										self.assertEqual(jitted_output.shape ,					output.shape   )







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



					"""simple docstring"""
					__a					:						Optional[Any]      =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
					return image




@require_flax
class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						@cached_property
						def        UpperCAmelCase__					(self:					Tuple   )    ->     Dict:




											'''simple docstring'''



											return AutoImageProcessor.from_pretrained("facebook/regnet-y-040"   ) if is_vision_available() else None



						@slow
						def        UpperCAmelCase__					(self:					Tuple   )    ->     Any:




											'''simple docstring'''



											__a					:						Dict      =					FlaxRegNetForImageClassification.from_pretrained("facebook/regnet-y-040"   )

											__a					:						int      =					self.default_image_processor
											__a					:						Optional[int]      =					prepare_img()
											__a					:						Dict      =					image_processor(images=lowerCAmelCase__ ,					return_tensors="np"   )

											__a					:						Any      =					model(**lowerCAmelCase__   )

											# verify the logits
											__a					:						Any      =					(1, 1000)
											self.assertEqual(outputs.logits.shape ,					lowerCAmelCase__   )

											__a					:						str      =					jnp.array([-0.41_80, -1.50_51, -3.48_36]   )

											self.assertTrue(jnp.allclose(outputs.logits[0, :3] ,					lowerCAmelCase__ ,					atol=1E-4   )   )












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



