





"""simple docstring"""




import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
		from transformers import WhisperFeatureExtractor

if is_torch_available():
		import torch

a						: Tuple     	=			random.Random()






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    Optional[Any]    ,       _lowercase						:    List[str]=1.0    ,       _lowercase						:    Dict=None    ,       _lowercase						:    Dict=None					) ->Any:






	'''simple docstring'''






	if rng is None:
		a      :		Dict	=				global_rng

	a      :		Optional[Any]	=				[]
	for batch_idx in range(shape[0]					):
		values.append([]					)
		for _ in range(shape[1]					):
			values[-1].append(rng.random() * scale					)

	return values


@require_torch
@require_torchaudio
class        __UpperCamelCase				(						unittest.TestCase						):






							def __init__(   self      ,					lowerCAmelCase__      ,					lowerCAmelCase__=7      ,					lowerCAmelCase__=400      ,					lowerCAmelCase__=2000      ,					lowerCAmelCase__=10      ,					lowerCAmelCase__=160      ,					lowerCAmelCase__=8      ,					lowerCAmelCase__=0.0      ,					lowerCAmelCase__=4000      ,					lowerCAmelCase__=False      ,					lowerCAmelCase__=True      ,					)	-> str:
								a      :		Union[str, Any]	=				parent
								a      :		Tuple	=				batch_size
								a      :		Optional[int]	=				min_seq_length
								a      :		Optional[Any]	=				max_seq_length
								a      :		Any	=				(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
								a      :		List[Any]	=				padding_value
								a      :		Dict	=				sampling_rate
								a      :		List[str]	=				return_attention_mask
								a      :		Union[str, Any]	=				do_normalize
								a      :		Dict	=				feature_size
								a      :		Tuple	=				chunk_length
								a      :		int	=				hop_length






							def     __a   (   self      )	-> List[Any]:
								return {
								    "feature_size": self.feature_size,
								    "hop_length": self.hop_length,
								    "chunk_length": self.chunk_length,
								    "padding_value": self.padding_value,
								    "sampling_rate": self.sampling_rate,
								    "return_attention_mask": self.return_attention_mask,
								    "do_normalize": self.do_normalize,
								}






							def     __a   (   self      ,					lowerCAmelCase__=False      ,					lowerCAmelCase__=False      )	-> Tuple:
								def _flatten(lowerCAmelCase__      ):
									return list(itertools.chain(*lowerCAmelCase__      )      )

								if equal_length:
									a      :		List[str]	=				[floats_list((self.max_seq_length, self.feature_size)      ) for _ in range(self.batch_size      )]
								else:
									# make sure that inputs increase in size
									a      :		List[Any]	=				[
									    floats_list((x, self.feature_size)      )
									    for x in range(self.min_seq_length      ,					self.max_seq_length      ,					self.seq_length_diff      )
									]
								if numpify:
									a      :		List[Any]	=				[np.asarray(lowerCAmelCase__      ) for x in speech_inputs]
								return speech_inputs


@require_torch
@require_torchaudio
class        __UpperCamelCase				(						a__		,       unittest.TestCase						):
							lowerCamelCase   :					Tuple      					=WhisperFeatureExtractor if is_speech_available() else None






							def     __a   (   self      )	-> Tuple:
								a      :		List[str]	=				WhisperFeatureExtractionTester(self      )






							def     __a   (   self      )	-> Any:
								a      :		List[str]	=				self.feature_extraction_class(**self.feat_extract_dict      )

								with tempfile.TemporaryDirectory() as tmpdirname:
									a      :		str	=				feat_extract_first.save_pretrained(lowerCAmelCase__      )[0]
									check_json_file_has_correct_format(lowerCAmelCase__      )
									a      :		Tuple	=				self.feature_extraction_class.from_pretrained(lowerCAmelCase__      )

								a      :		Union[str, Any]	=				feat_extract_first.to_dict()
								a      :		Tuple	=				feat_extract_second.to_dict()
								a      :		Optional[int]	=				feat_extract_first.mel_filters
								a      :		int	=				feat_extract_second.mel_filters
								self.assertTrue(np.allclose(lowerCAmelCase__      ,					lowerCAmelCase__      )      )
								self.assertEqual(lowerCAmelCase__      ,					lowerCAmelCase__      )






							def     __a   (   self      )	-> Union[str, Any]:
								a      :		Optional[int]	=				self.feature_extraction_class(**self.feat_extract_dict      )

								with tempfile.TemporaryDirectory() as tmpdirname:
									a      :		List[Any]	=				os.path.join(lowerCAmelCase__      ,					"feat_extract.json"      )
									feat_extract_first.to_json_file(lowerCAmelCase__      )
									a      :		str	=				self.feature_extraction_class.from_json_file(lowerCAmelCase__      )

								a      :		int	=				feat_extract_first.to_dict()
								a      :		Tuple	=				feat_extract_second.to_dict()
								a      :		Any	=				feat_extract_first.mel_filters
								a      :		Optional[Any]	=				feat_extract_second.mel_filters
								self.assertTrue(np.allclose(lowerCAmelCase__      ,					lowerCAmelCase__      )      )
								self.assertEqual(lowerCAmelCase__      ,					lowerCAmelCase__      )






							def     __a   (   self      )	-> Dict:
								# Tests that all call wrap to encode_plus and batch_encode_plus
								a      :		Union[str, Any]	=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
								# create three inputs of length 800, 1000, and 1200
								a      :		List[Any]	=				[floats_list((1, x)      )[0] for x in range(800      ,					1400      ,					200      )]
								a      :		Union[str, Any]	=				[np.asarray(lowerCAmelCase__      ) for speech_input in speech_inputs]

								# Test feature size
								a      :		List[str]	=				feature_extractor(lowerCAmelCase__      ,					padding="max_length"      ,					return_tensors="np"      ).input_features
								self.assertTrue(input_features.ndim == 3      )
								self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames      )
								self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size      )

								# Test not batched input
								a      :		Tuple	=				feature_extractor(speech_inputs[0]      ,					return_tensors="np"      ).input_features
								a      :		Dict	=				feature_extractor(np_speech_inputs[0]      ,					return_tensors="np"      ).input_features
								self.assertTrue(np.allclose(lowerCAmelCase__      ,					lowerCAmelCase__      ,					atol=1E-3      )      )

								# Test batched
								a      :		Optional[Any]	=				feature_extractor(lowerCAmelCase__      ,					return_tensors="np"      ).input_features
								a      :		str	=				feature_extractor(lowerCAmelCase__      ,					return_tensors="np"      ).input_features
								for enc_seq_a, enc_seq_a in zip(lowerCAmelCase__      ,					lowerCAmelCase__      ):
									self.assertTrue(np.allclose(lowerCAmelCase__      ,					lowerCAmelCase__      ,					atol=1E-3      )      )

								# Test 2-D numpy arrays are batched.
								a      :		Union[str, Any]	=				[floats_list((1, x)      )[0] for x in (800, 800, 800)]
								a      :		str	=				np.asarray(lowerCAmelCase__      )
								a      :		Optional[int]	=				feature_extractor(lowerCAmelCase__      ,					return_tensors="np"      ).input_features
								a      :		List[Any]	=				feature_extractor(lowerCAmelCase__      ,					return_tensors="np"      ).input_features
								for enc_seq_a, enc_seq_a in zip(lowerCAmelCase__      ,					lowerCAmelCase__      ):
									self.assertTrue(np.allclose(lowerCAmelCase__      ,					lowerCAmelCase__      ,					atol=1E-3      )      )

								# Test truncation required
								a      :		List[Any]	=				[floats_list((1, x)      )[0] for x in range(200      ,					(feature_extractor.n_samples + 500)      ,					200      )]
								a      :		Any	=				[np.asarray(lowerCAmelCase__      ) for speech_input in speech_inputs]

								a      :		Dict	=				[x[: feature_extractor.n_samples] for x in speech_inputs]
								a      :		List[str]	=				[np.asarray(lowerCAmelCase__      ) for speech_input in speech_inputs_truncated]

								a      :		List[str]	=				feature_extractor(lowerCAmelCase__      ,					return_tensors="np"      ).input_features
								a      :		Any	=				feature_extractor(lowerCAmelCase__      ,					return_tensors="np"      ).input_features
								for enc_seq_a, enc_seq_a in zip(lowerCAmelCase__      ,					lowerCAmelCase__      ):
									self.assertTrue(np.allclose(lowerCAmelCase__      ,					lowerCAmelCase__      ,					atol=1E-3      )      )






							def     __a   (   self      )	-> int:
								import torch

								a      :		Dict	=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
								a      :		Dict	=				np.random.rand(100      ,					32      ).astype(np.floataa      )
								a      :		Any	=				np_speech_inputs.tolist()

								for inputs in [py_speech_inputs, np_speech_inputs]:
									a      :		Any	=				feature_extractor.pad([{"input_features": inputs}]      ,					return_tensors="np"      )
									self.assertTrue(np_processed.input_features.dtype == np.floataa      )
									a      :		Dict	=				feature_extractor.pad([{"input_features": inputs}]      ,					return_tensors="pt"      )
									self.assertTrue(pt_processed.input_features.dtype == torch.floataa      )






							def     __a   (   self      ,					lowerCAmelCase__      )	-> Union[str, Any]:
								a      :		str	=				load_dataset("hf-internal-testing/librispeech_asr_dummy"      ,					"clean"      ,					split="validation"      )
								# automatic decoding with librispeech
								a      :		Dict	=				ds.sort("id"      ).select(range(lowerCAmelCase__      )      )[:num_samples]["audio"]

								return [x["array"] for x in speech_samples]






							def     __a   (   self      )	-> List[str]:
								# fmt: off
								a      :		Any	=				torch.tensor(
								    [
								        0.1_193, -0.0_946, -0.1_098, -0.0_196, 0.0_225, -0.0_690, -0.1_736, 0.0_951,
								        0.0_971, -0.0_817, -0.0_702, 0.0_162, 0.0_260, 0.0_017, -0.0_192, -0.1_678,
								        0.0_709, -0.1_867, -0.0_655, -0.0_274, -0.0_234, -0.1_884, -0.0_516, -0.0_554,
								        -0.0_274, -0.1_425, -0.1_423, 0.0_837, 0.0_377, -0.0_854
								    ]      )
								# fmt: on

								a      :		Tuple	=				self._load_datasamples(1      )
								a      :		Any	=				WhisperFeatureExtractor()
								a      :		List[str]	=				feature_extractor(lowerCAmelCase__      ,					return_tensors="pt"      ).input_features
								self.assertEqual(input_features.shape      ,					(1, 80, 3000)      )
								self.assertTrue(torch.allclose(input_features[0, 0, :30]      ,					lowerCAmelCase__      ,					atol=1E-4      )      )






							def     __a   (   self      )	-> str:
								a      :		Tuple	=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
								a      :		int	=				self._load_datasamples(1      )[0]
								a      :		Optional[int]	=				((audio - audio.min()) / (audio.max() - audio.min())) * 6_5535  # Rescale to [0, 65535] to show issue
								a      :		str	=				feat_extract.zero_mean_unit_var_norm([audio]      ,					attention_mask=lowerCAmelCase__      )[0]

								self.assertTrue(np.all(np.mean(lowerCAmelCase__      ) < 1E-3      )      )
								self.assertTrue(np.all(np.abs(np.var(lowerCAmelCase__      ) - 1      ) < 1E-3      )      )









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     SCREAMING_SNAKE_CASE__ (						unittest.TestCase      ):



 def __init__(							self,__lowerCamelCase,__lowerCamelCase=3,__lowerCamelCase=32,__lowerCamelCase=3,__lowerCamelCase=10,__lowerCamelCase=[10, 20, 30, 40],__lowerCamelCase=[1, 1, 2, 1],__lowerCamelCase=True,__lowerCamelCase=True,__lowerCamelCase="relu",__lowerCamelCase=3,__lowerCamelCase=None,):
        A__											=						parent
        A__											=						batch_size
        A__											=						image_size
        A__											=						num_channels
        A__											=						embeddings_size
        A__											=						hidden_sizes
        A__											=						depths
        A__											=						is_training
        A__											=						use_labels
        A__											=						hidden_act
        A__											=						num_labels
        A__											=						scope
        A__											=						len(__lowerCamelCase )



 def 				UpperCamelCase			(							self ):
        A__											=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

        A__											=						self.get_config()

        return config, pixel_values



 def 				UpperCamelCase			(							self ):
        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,__lowerCamelCase,__lowerCamelCase ):
        A__											=						FlaxRegNetModel(config=__lowerCamelCase )
        A__											=						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,__lowerCamelCase,__lowerCamelCase ):
        A__											=						self.num_labels
        A__											=						FlaxRegNetForImageClassification(config=__lowerCamelCase )
        A__											=						model(__lowerCamelCase )
        self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_labels) )




 def 				UpperCamelCase			(							self ):
        A__											=						self.prepare_config_and_inputs()
        A__					,	A__											=						config_and_inputs
        A__											=						{'''pixel_values''': pixel_values}
        return config, inputs_dict




@require_flax
class     SCREAMING_SNAKE_CASE__ (						UpperCamelCase__				,					unittest.TestCase      ):
 __SCREAMING_SNAKE_CASE							       =	(FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

 __SCREAMING_SNAKE_CASE							       =	False
 __SCREAMING_SNAKE_CASE							       =	False
 __SCREAMING_SNAKE_CASE							       =	False



 def 				UpperCamelCase			(							self ):
        A__											=						FlaxRegNetModelTester(self )
        A__											=						ConfigTester(self,config_class=__lowerCamelCase,has_text_modality=__lowerCamelCase )



 def 				UpperCamelCase			(							self ):
        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 ):
        return



 def 				UpperCamelCase			(							self ):
        A__											=						self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__lowerCamelCase )



 def 				UpperCamelCase			(							self ):
        A__											=						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 ):
        pass



 @unittest.skip(reason='''RegNet does not support input and output embeddings''' )
 def 				UpperCamelCase			(							self ):
        pass



 def 				UpperCamelCase			(							self ):
        A__					,	A__											=						self.model_tester.prepare_config_and_inputs_for_common()

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

               A__											=						['''pixel_values''']
               self.assertListEqual(arg_names[:1],__lowerCamelCase )



 def 				UpperCamelCase			(							self ):
        def check_hidden_states_output(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase ):
               A__											=						model_class(__lowerCamelCase )

               A__											=						model(**self._prepare_for_class(__lowerCamelCase,__lowerCamelCase ) )

               A__											=						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

               A__											=						self.model_tester.num_stages
               self.assertEqual(len(__lowerCamelCase ),expected_num_stages + 1 )

        A__					,	A__											=						self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
               A__											=						True
               check_hidden_states_output(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase )

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               A__											=						True

               check_hidden_states_output(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase )




 def 				UpperCamelCase			(							self ):
        A__					,	A__											=						self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
               with self.subTest(model_class.__name__ ):
                      A__											=						self._prepare_for_class(__lowerCamelCase,__lowerCamelCase )
                      A__											=						model_class(__lowerCamelCase )

                      @jax.jit
                      def model_jitted(__lowerCamelCase,**__lowerCamelCase ):
                             return model(pixel_values=__lowerCamelCase,**__lowerCamelCase )

                      with self.subTest('''JIT Enabled''' ):
                             A__											=						model_jitted(**__lowerCamelCase ).to_tuple()

                      with self.subTest('''JIT Disabled''' ):
                             with jax.disable_jit():
                                    A__											=						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 	UpperCamelCase__(       )->Optional[int]:
       A__											=						Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''  )
       return image




@require_flax
class     SCREAMING_SNAKE_CASE__ (						unittest.TestCase      ):



 @cached_property
 def 				UpperCamelCase			(							self ):
        return AutoImageProcessor.from_pretrained('''facebook/regnet-y-040''' ) if is_vision_available() else None




 @slow
 def 				UpperCamelCase			(							self ):
        A__											=						FlaxRegNetForImageClassification.from_pretrained('''facebook/regnet-y-040''' )

        A__											=						self.default_image_processor
        A__											=						prepare_img()
        A__											=						image_processor(images=__lowerCamelCase,return_tensors='''np''' )

        A__											=						model(**__lowerCamelCase )

        # verify the logits
        A__											=						(1, 1000)
        self.assertEqual(outputs.logits.shape,__lowerCamelCase )

        A__											=						jnp.array([-0.4180, -1.5051, -3.4836] )

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





