



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

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


if is_tf_available():
			import tensorflow as tf

			from transformers import TFResNetForImageClassification, TFResNetModel
			from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import AutoImageProcessor
class 			_lowerCAmelCase   :






			"""simple docstring"""





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







									__lowercase					=				parent
									__lowercase					=				batch_size
									__lowercase					=				image_size
									__lowercase					=				num_channels
									__lowercase					=				embeddings_size
									__lowercase					=				hidden_sizes
									__lowercase					=				depths
									__lowercase					=				is_training
									__lowercase					=				use_labels
									__lowercase					=				hidden_act
									__lowercase					=				num_labels
									__lowercase					=				scope
									__lowercase					=				len(lowercase   )





			def 		snake_case__			(				self	:       Optional[int]   )						->					Optional[int]:
									"""simple docstring"""







									__lowercase					=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

									__lowercase					=				None
									if self.use_labels:
															__lowercase					=				ids_tensor([self.batch_size]			,     self.num_labels   )

									__lowercase					=				self.get_config()

									return config, pixel_values, labels





			def 		snake_case__			(				self	:       str   )						->					Optional[Any]:
									"""simple docstring"""







									return ResNetConfig(
									    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 		snake_case__			(				self	:       int			,     lowercase	:       List[str]			,     lowercase	:       Dict			,     lowercase	:       Tuple   )						->					Optional[Any]:
									"""simple docstring"""







									__lowercase					=				TFResNetModel(config=lowercase   )
									__lowercase					=				model(lowercase   )
									# expected last hidden states: B, C, H // 32, W // 32
									self.parent.assertEqual(
									    result.last_hidden_state.shape			,     (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)			,     )





			def 		snake_case__			(				self	:       List[str]			,     lowercase	:       List[Any]			,     lowercase	:       List[Any]			,     lowercase	:       List[str]   )						->					Any:
									"""simple docstring"""







									__lowercase					=				self.num_labels
									__lowercase					=				TFResNetForImageClassification(lowercase   )
									__lowercase					=				model(lowercase			,     labels=lowercase   )
									self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)   )







			def 		snake_case__			(				self	:       str   )						->					int:
									"""simple docstring"""







									__lowercase					=				self.prepare_config_and_inputs()
									__lowercase	,			__lowercase	,			__lowercase					=				config_and_inputs
									__lowercase					=				{"""pixel_values""": pixel_values}
									return config, inputs_dict





@require_tf
class 			_lowerCAmelCase   ( _UpperCAmelCase    ,					_UpperCAmelCase    ,					unittest.TestCase			):






			"""simple docstring"""





			lowercase__      :  Union[str, Any]      =			(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
			lowercase__      :  Tuple      =			(
			    {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
			    if is_tf_available()
			    else {}
			)

			lowercase__      :  List[str]      =			False
			lowercase__      :  List[Any]      =			False
			lowercase__      :  List[str]      =			False
			lowercase__      :  Optional[Any]      =			False
			lowercase__      :  Optional[int]      =			False





			def 		snake_case__			(				self	:       Tuple   )						->					int:
									"""simple docstring"""







									__lowercase					=				TFResNetModelTester(self   )
									__lowercase					=				ConfigTester(self			,     config_class=lowercase			,     has_text_modality=lowercase   )





			def 		snake_case__			(				self	:       int   )						->					Optional[int]:
									"""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 		snake_case__			(				self	:       List[Any]   )						->					Any:
									"""simple docstring"""







									return





			@unittest.skip(reason="""ResNet does not use inputs_embeds"""   )
			def 		snake_case__			(				self	:       Union[str, Any]   )						->					List[Any]:
									"""simple docstring"""







									pass





			@unittest.skip(reason="""ResNet does not support input and output embeddings"""   )
			def 		snake_case__			(				self	:       Optional[Any]   )						->					Tuple:
									"""simple docstring"""







									pass





			def 		snake_case__			(				self	:       List[str]   )						->					List[str]:
									"""simple docstring"""







									__lowercase	,			__lowercase					=				self.model_tester.prepare_config_and_inputs_for_common()

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

															__lowercase					=				["""pixel_values"""]
															self.assertListEqual(arg_names[:1]			,     lowercase   )





			def 		snake_case__			(				self	:       Union[str, Any]   )						->					Optional[Any]:
									"""simple docstring"""







									__lowercase					=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowercase   )





			def 		snake_case__			(				self	:       Dict   )						->					Union[str, Any]:
									"""simple docstring"""







									def check_hidden_states_output(lowercase	:       str			,     lowercase	:       List[str]			,     lowercase	:       Any   ):
															__lowercase					=				model_class(lowercase   )
															__lowercase					=				model(**self._prepare_for_class(lowercase			,     lowercase   )   )

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

															__lowercase					=				self.model_tester.num_stages
															self.assertEqual(len(lowercase   )			,     expected_num_stages + 1   )

															# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
															self.assertListEqual(
															    list(hidden_states[0].shape[-2:]   )			,     [self.model_tester.image_size // 4, self.model_tester.image_size // 4]			,     )

									__lowercase	,			__lowercase					=				self.model_tester.prepare_config_and_inputs_for_common()
									__lowercase					=				["""basic""", """bottleneck"""]
									for model_class in self.all_model_classes:
															for layer_type in layers_type:
																					__lowercase					=				layer_type
																					__lowercase					=				True
																					check_hidden_states_output(lowercase			,     lowercase			,     lowercase   )

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

																					check_hidden_states_output(lowercase			,     lowercase			,     lowercase   )





			def 		snake_case__			(				self	:       Tuple   )						->					str:
									"""simple docstring"""







									__lowercase					=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*lowercase   )







			@slow
			def 		snake_case__			(				self	:       Dict   )						->					Dict:
									"""simple docstring"""







									for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															__lowercase					=				TFResNetModel.from_pretrained(lowercase   )
															self.assertIsNotNone(lowercase   )






def  UpperCAmelCase__    (    ) ->      str:
						__lowercase					=				Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
						return image







@require_tf
@require_vision
class 			_lowerCAmelCase   ( unittest.TestCase			):






			"""simple docstring"""





			@cached_property
			def 		snake_case__			(				self	:       Any   )						->					int:
									"""simple docstring"""







									return (
									    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
									    if is_vision_available()
									    else None
									)







			@slow
			def 		snake_case__			(				self	:       List[Any]   )						->					List[str]:
									"""simple docstring"""







									__lowercase					=				TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )

									__lowercase					=				self.default_image_processor
									__lowercase					=				prepare_img()
									__lowercase					=				image_processor(images=lowercase			,     return_tensors="""tf"""   )

									# forward pass
									__lowercase					=				model(**lowercase   )

									# verify the logits
									__lowercase					=				tf.TensorShape((1, 1_000)   )
									self.assertEqual(outputs.logits.shape			,     lowercase   )

									__lowercase					=				tf.constant([-11.1069, -9.7877, -8.3777]   )

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










import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
			from transformers import SpeechaTextFeatureExtractor

UpperCamelCase__ =						random.Random()






def  UpperCAmelCase__    (    lowercase__						,       lowercase__=1.0						,       lowercase__=None						,       lowercase__=None   ) ->      str:
						if rng is None:
												__lowercase					=				global_rng

						__lowercase					=				[]
						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 			_lowerCAmelCase   ( unittest.TestCase			):






			"""simple docstring"""





			def __init__(				self	:       List[Any]			,     lowercase	:       Tuple			,     lowercase	:       Union[str, Any]=7			,     lowercase	:       List[Any]=400			,     lowercase	:       Any=2_000			,     lowercase	:       Optional[int]=24			,     lowercase	:       Any=24			,     lowercase	:       List[str]=0.0			,     lowercase	:       Dict=16_000			,     lowercase	:       Union[str, Any]=True			,     lowercase	:       Dict=True			,     )						->					Any:
									"""simple docstring"""







									__lowercase					=				parent
									__lowercase					=				batch_size
									__lowercase					=				min_seq_length
									__lowercase					=				max_seq_length
									__lowercase					=				(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
									__lowercase					=				feature_size
									__lowercase					=				num_mel_bins
									__lowercase					=				padding_value
									__lowercase					=				sampling_rate
									__lowercase					=				return_attention_mask
									__lowercase					=				do_normalize





			def 		snake_case__			(				self	:       Optional[int]   )						->					Any:
									"""simple docstring"""







									return {
									    "feature_size": self.feature_size,
									    "num_mel_bins": self.num_mel_bins,
									    "padding_value": self.padding_value,
									    "sampling_rate": self.sampling_rate,
									    "return_attention_mask": self.return_attention_mask,
									    "do_normalize": self.do_normalize,
									}







			def 		snake_case__			(				self	:       List[str]			,     lowercase	:       Tuple=False			,     lowercase	:       int=False   )						->					Optional[Any]:
									"""simple docstring"""







									def _flatten(lowercase	:       Optional[Any]   ):
															return list(itertools.chain(*lowercase   )   )

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





@require_torch
@require_torchaudio
class 			_lowerCAmelCase   ( _UpperCAmelCase    ,					unittest.TestCase			):






			"""simple docstring"""





			lowercase__      :  int      =			SpeechaTextFeatureExtractor if is_speech_available() else None





			def 		snake_case__			(				self	:       Dict   )						->					Optional[int]:
									"""simple docstring"""







									__lowercase					=				SpeechaTextFeatureExtractionTester(self   )





			def 		snake_case__			(				self	:       Tuple			,     lowercase	:       Optional[Any]   )						->					Union[str, Any]:
									"""simple docstring"""







									self.assertTrue(np.all(np.mean(lowercase			,     axis=0   ) < 1E-3   )   )
									self.assertTrue(np.all(np.abs(np.var(lowercase			,     axis=0   ) - 1   ) < 1E-3   )   )





			def 		snake_case__			(				self	:       List[Any]   )						->					str:
									"""simple docstring"""







									__lowercase					=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
									# create three inputs of length 800, 1000, and 1200
									__lowercase					=				[floats_list((1, x)   )[0] for x in range(800			,     1_400			,     200   )]
									__lowercase					=				[np.asarray(lowercase   ) for speech_input in speech_inputs]

									# Test feature size
									__lowercase					=				feature_extractor(lowercase			,     padding=lowercase			,     return_tensors="""np"""   ).input_features
									self.assertTrue(input_features.ndim == 3   )
									self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size   )

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

									# Test batched
									__lowercase					=				feature_extractor(lowercase			,     return_tensors="""np"""   ).input_features
									__lowercase					=				feature_extractor(lowercase			,     return_tensors="""np"""   ).input_features
									for enc_seq_a, enc_seq_a in zip(lowercase			,     lowercase   ):
															self.assertTrue(np.allclose(lowercase			,     lowercase			,     atol=1E-3   )   )

									# Test 2-D numpy arrays are batched.
									__lowercase					=				[floats_list((1, x)   )[0] for x in (800, 800, 800)]
									__lowercase					=				np.asarray(lowercase   )
									__lowercase					=				feature_extractor(lowercase			,     return_tensors="""np"""   ).input_features
									__lowercase					=				feature_extractor(lowercase			,     return_tensors="""np"""   ).input_features
									for enc_seq_a, enc_seq_a in zip(lowercase			,     lowercase   ):
															self.assertTrue(np.allclose(lowercase			,     lowercase			,     atol=1E-3   )   )





			def 		snake_case__			(				self	:       List[str]   )						->					Tuple:
									"""simple docstring"""







									__lowercase					=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
									__lowercase					=				[floats_list((1, x)   )[0] for x in range(800			,     1_400			,     200   )]

									__lowercase					=				["""longest""", """max_length""", """do_not_pad"""]
									__lowercase					=				[None, 16, None]
									for max_length, padding in zip(lowercase			,     lowercase   ):
															__lowercase					=				feature_extractor(
															    lowercase			,     padding=lowercase			,     max_length=lowercase			,     return_attention_mask=lowercase   )
															__lowercase					=				inputs.input_features
															__lowercase					=				inputs.attention_mask
															__lowercase					=				[np.sum(lowercase   ) for x in attention_mask]

															self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]   )
															self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]   )
															self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]   )





			def 		snake_case__			(				self	:       Any   )						->					Dict:
									"""simple docstring"""







									__lowercase					=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
									__lowercase					=				[floats_list((1, x)   )[0] for x in range(800			,     1_400			,     200   )]

									__lowercase					=				["""longest""", """max_length""", """do_not_pad"""]
									__lowercase					=				[None, 16, None]
									for max_length, padding in zip(lowercase			,     lowercase   ):
															__lowercase					=				feature_extractor(
															    lowercase			,     max_length=lowercase			,     padding=lowercase			,     return_tensors="""np"""			,     return_attention_mask=lowercase   )
															__lowercase					=				inputs.input_features
															__lowercase					=				inputs.attention_mask
															__lowercase					=				[np.sum(lowercase   ) for x in attention_mask]

															self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]   )
															self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6   )
															self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]   )
															self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6   )
															self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]   )





			def 		snake_case__			(				self	:       str   )						->					List[Any]:
									"""simple docstring"""







									__lowercase					=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
									__lowercase					=				[floats_list((1, x)   )[0] for x in range(800			,     1_400			,     200   )]
									__lowercase					=				feature_extractor(
									    lowercase			,     padding="""max_length"""			,     max_length=4			,     truncation=lowercase			,     return_tensors="""np"""			,     return_attention_mask=lowercase			,     )
									__lowercase					=				inputs.input_features
									__lowercase					=				inputs.attention_mask
									__lowercase					=				np.sum(attention_mask == 1			,     axis=1   )

									self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]   )
									self._check_zero_mean_unit_variance(input_features[1]   )
									self._check_zero_mean_unit_variance(input_features[2]   )





			def 		snake_case__			(				self	:       Tuple   )						->					List[str]:
									"""simple docstring"""







									__lowercase					=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
									__lowercase					=				[floats_list((1, x)   )[0] for x in range(800			,     1_400			,     200   )]
									__lowercase					=				feature_extractor(
									    lowercase			,     padding="""longest"""			,     max_length=4			,     truncation=lowercase			,     return_tensors="""np"""			,     return_attention_mask=lowercase			,     )
									__lowercase					=				inputs.input_features
									__lowercase					=				inputs.attention_mask
									__lowercase					=				np.sum(attention_mask == 1			,     axis=1   )

									self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]   )
									self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]   )
									self._check_zero_mean_unit_variance(input_features[2]   )

									# make sure that if max_length < longest -> then pad to max_length
									self.assertEqual(input_features.shape			,     (3, 4, 24)   )

									__lowercase					=				[floats_list((1, x)   )[0] for x in range(800			,     1_400			,     200   )]
									__lowercase					=				feature_extractor(
									    lowercase			,     padding="""longest"""			,     max_length=16			,     truncation=lowercase			,     return_tensors="""np"""			,     return_attention_mask=lowercase			,     )
									__lowercase					=				inputs.input_features
									__lowercase					=				inputs.attention_mask
									__lowercase					=				np.sum(attention_mask == 1			,     axis=1   )

									self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]   )
									self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]   )
									self._check_zero_mean_unit_variance(input_features[2]   )

									# make sure that if max_length < longest -> then pad to max_length
									self.assertEqual(input_features.shape			,     (3, 6, 24)   )





			def 		snake_case__			(				self	:       Optional[Any]   )						->					Tuple:
									"""simple docstring"""







									import torch

									__lowercase					=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
									__lowercase					=				np.random.rand(100			,     32   ).astype(np.floataa   )
									__lowercase					=				np_speech_inputs.tolist()

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





			def 		snake_case__			(				self	:       Optional[int]			,     lowercase	:       Union[str, Any]   )						->					int:
									"""simple docstring"""







									from datasets import load_dataset

									__lowercase					=				load_dataset("""hf-internal-testing/librispeech_asr_dummy"""			,     """clean"""			,     split="""validation"""   )
									# automatic decoding with librispeech
									__lowercase					=				ds.sort("""id"""   ).select(range(lowercase   )   )[:num_samples]["""audio"""]

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







			def 		snake_case__			(				self	:       str   )						->					Any:
									"""simple docstring"""







									__lowercase					=				np.array([
									    -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
									    -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
									    -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
									]   )
									# fmt: on

									__lowercase					=				self._load_datasamples(1   )
									__lowercase					=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
									__lowercase					=				feature_extractor(lowercase			,     return_tensors="""pt"""   ).input_features
									self.assertEquals(input_features.shape			,     (1, 584, 24)   )
									self.assertTrue(np.allclose(input_features[0, 0, :30]			,     lowercase			,     atol=1E-4   )   )





