

'''simple docstring'''





from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor





class 		__SCREAMING_SNAKE_CASE       :







				def __init__(					self    :		Union[str, Any]		,				UpperCAmelCase__    :		Optional[Any]		,				UpperCAmelCase__    :		List[str]=3		,				UpperCAmelCase__    :		int=32		,				UpperCAmelCase__    :		Dict=3		,				UpperCAmelCase__    :		Union[str, Any]=10		,				UpperCAmelCase__    :		List[str]=[10, 20, 30, 40]		,				UpperCAmelCase__    :		int=[1, 1, 2, 1]		,				UpperCAmelCase__    :		Tuple=True		,				UpperCAmelCase__    :		str=True		,				UpperCAmelCase__    :		Optional[Any]="relu"		,				UpperCAmelCase__    :		Union[str, Any]=3		,				UpperCAmelCase__    :		str=None		,				):
										'''simple docstring'''
										lowercase   :       Dict								=parent
										lowercase   :       Optional[Any]								=batch_size
										lowercase   :       Optional[int]								=image_size
										lowercase   :       str								=num_channels
										lowercase   :       List[Any]								=embeddings_size
										lowercase   :       Tuple								=hidden_sizes
										lowercase   :       List[Any]								=depths
										lowercase   :       Optional[int]								=is_training
										lowercase   :       int								=use_labels
										lowercase   :       str								=hidden_act
										lowercase   :       int								=num_labels
										lowercase   :       Dict								=scope
										lowercase   :       Union[str, Any]								=len(UpperCAmelCase__      )







				def    lowerCamelCase_  (					self    :		Union[str, Any]      ):
										'''simple docstring'''
										lowercase   :       Tuple								=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

										lowercase   :       Optional[Any]								=None
										if self.use_labels:
																lowercase   :       List[str]								=ids_tensor([self.batch_size]		,				self.num_labels      )

										lowercase   :       Optional[Any]								=self.get_config()
										return config, pixel_values, labels







				def    lowerCamelCase_  (					self    :		Dict      ):
										'''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		,				)







				def    lowerCamelCase_  (					self    :		Union[str, Any]		,				UpperCAmelCase__    :		Tuple		,				UpperCAmelCase__    :		List[Any]		,				UpperCAmelCase__    :		str      ):
										'''simple docstring'''
										lowercase   :       Tuple								=TFRegNetModel(config=UpperCAmelCase__      )
										lowercase   :       List[str]								=model(UpperCAmelCase__		,				training=UpperCAmelCase__      )
										# 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    lowerCamelCase_  (					self    :		Optional[int]		,				UpperCAmelCase__    :		List[str]		,				UpperCAmelCase__    :		List[str]		,				UpperCAmelCase__    :		Tuple      ):
										'''simple docstring'''
										lowercase   :       Any								=self.num_labels
										lowercase   :       List[str]								=TFRegNetForImageClassification(UpperCAmelCase__      )
										lowercase   :       List[Any]								=model(UpperCAmelCase__		,				labels=UpperCAmelCase__		,				training=UpperCAmelCase__      )
										self.parent.assertEqual(result.logits.shape		,				(self.batch_size, self.num_labels)      )







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										lowercase   :       int								=self.prepare_config_and_inputs()
										lowercase		,  lowercase		,  lowercase   :       int								=config_and_inputs
										lowercase   :       int								={'''pixel_values''': pixel_values}
										return config, inputs_dict





@require_tf
class 		__SCREAMING_SNAKE_CASE       ( lowercase__	,       lowercase__	,       unittest.TestCase			):
				lowerCamelCase_							=						(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
				lowerCamelCase_							=						(
				    {'feature-extraction': TFRegNetModel, 'image-classification': TFRegNetForImageClassification}
				    if is_tf_available()
				    else {}
				)

				lowerCamelCase_							=						False
				lowerCamelCase_							=						False
				lowerCamelCase_							=						False
				lowerCamelCase_							=						False
				lowerCamelCase_							=						False







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										lowercase   :       Union[str, Any]								=TFRegNetModelTester(self      )
										lowercase   :       Tuple								=ConfigTester(self		,				config_class=UpperCAmelCase__		,				has_text_modality=UpperCAmelCase__      )







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										return







				@unittest.skip(reason='''RegNet does not use inputs_embeds'''      )
				def    lowerCamelCase_  (					self    :		Tuple      ):
										'''simple docstring'''
										pass







				@unittest.skipIf(
				    not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''      )      ) == 0		,				reason='''TF does not support backprop for grouped convolutions on CPU.'''		,				)
				@slow
				def    lowerCamelCase_  (					self    :		Optional[int]      ):
										'''simple docstring'''
										super().test_keras_fit()







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







				def    lowerCamelCase_  (					self    :		Any      ):
										'''simple docstring'''
										lowercase		,  lowercase   :       int								=self.model_tester.prepare_config_and_inputs_for_common()

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

																lowercase   :       Any								=['''pixel_values''']
																self.assertListEqual(arg_names[:1]		,				UpperCAmelCase__      )







				def    lowerCamelCase_  (					self    :		Optional[Any]      ):
										'''simple docstring'''
										lowercase   :       Optional[int]								=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCAmelCase__      )







				def    lowerCamelCase_  (					self    :		Tuple      ):
										'''simple docstring'''
										def check_hidden_states_output(UpperCAmelCase__    :		List[Any]		,				UpperCAmelCase__    :		Optional[int]		,				UpperCAmelCase__    :		str      ):
																lowercase   :       Any								=model_class(UpperCAmelCase__      )
																lowercase   :       Optional[Any]								=model(**self._prepare_for_class(UpperCAmelCase__		,				UpperCAmelCase__      )		,				training=UpperCAmelCase__      )

																lowercase   :       Dict								=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																lowercase   :       str								=self.model_tester.num_stages
																self.assertEqual(len(UpperCAmelCase__      )		,				expected_num_stages + 1      )

																# RegNet'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 // 2, self.model_tester.image_size // 2]		,				)

										lowercase		,  lowercase   :       Optional[Any]								=self.model_tester.prepare_config_and_inputs_for_common()
										lowercase   :       Dict								=['''basic''', '''bottleneck''']
										for model_class in self.all_model_classes:
																for layer_type in layers_type:
																						lowercase   :       str								=layer_type
																						lowercase   :       List[Any]								=True
																						check_hidden_states_output(UpperCAmelCase__		,				UpperCAmelCase__		,				UpperCAmelCase__      )

																						# check that output_hidden_states also work using config
																						del inputs_dict["output_hidden_states"]
																						lowercase   :       Optional[int]								=True

																						check_hidden_states_output(UpperCAmelCase__		,				UpperCAmelCase__		,				UpperCAmelCase__      )







				def    lowerCamelCase_  (					self    :		Optional[Any]      ):
										'''simple docstring'''
										lowercase		,  lowercase   :       int								=self.model_tester.prepare_config_and_inputs_for_common()

										def check_equivalence(UpperCAmelCase__    :		Tuple		,				UpperCAmelCase__    :		str		,				UpperCAmelCase__    :		List[Any]		,				UpperCAmelCase__    :		int={}      ):
																lowercase   :       Optional[Any]								=model(UpperCAmelCase__		,				return_dict=UpperCAmelCase__		,				**UpperCAmelCase__      )
																lowercase   :       List[str]								=model(UpperCAmelCase__		,				return_dict=UpperCAmelCase__		,				**UpperCAmelCase__      ).to_tuple()

																def recursive_check(UpperCAmelCase__    :		Tuple		,				UpperCAmelCase__    :		Dict      ):
																						if isinstance(UpperCAmelCase__		,				(List, Tuple)      ):
																												for tuple_iterable_value, dict_iterable_value in zip(UpperCAmelCase__		,				UpperCAmelCase__      ):
																																		recursive_check(UpperCAmelCase__		,				UpperCAmelCase__      )
																						elif tuple_object is None:
																												return
																						else:
																												self.assertTrue(
																												    all(tf.equal(UpperCAmelCase__		,				UpperCAmelCase__      )      )		,				msg=(
																												        '''Tuple and dict output are not equal. Difference:'''
																												        F''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object      )      )}'''
																												    )		,				)

																						recursive_check(UpperCAmelCase__		,				UpperCAmelCase__      )

										for model_class in self.all_model_classes:
																lowercase   :       Optional[Any]								=model_class(UpperCAmelCase__      )

																lowercase   :       int								=self._prepare_for_class(UpperCAmelCase__		,				UpperCAmelCase__      )
																lowercase   :       Any								=self._prepare_for_class(UpperCAmelCase__		,				UpperCAmelCase__      )
																check_equivalence(UpperCAmelCase__		,				UpperCAmelCase__		,				UpperCAmelCase__      )

																lowercase   :       List[str]								=self._prepare_for_class(UpperCAmelCase__		,				UpperCAmelCase__		,				return_labels=UpperCAmelCase__      )
																lowercase   :       str								=self._prepare_for_class(UpperCAmelCase__		,				UpperCAmelCase__		,				return_labels=UpperCAmelCase__      )
																check_equivalence(UpperCAmelCase__		,				UpperCAmelCase__		,				UpperCAmelCase__      )

																lowercase   :       List[Any]								=self._prepare_for_class(UpperCAmelCase__		,				UpperCAmelCase__      )
																lowercase   :       str								=self._prepare_for_class(UpperCAmelCase__		,				UpperCAmelCase__      )
																check_equivalence(UpperCAmelCase__		,				UpperCAmelCase__		,				UpperCAmelCase__		,				{'''output_hidden_states''': True}      )

																lowercase   :       int								=self._prepare_for_class(UpperCAmelCase__		,				UpperCAmelCase__		,				return_labels=UpperCAmelCase__      )
																lowercase   :       str								=self._prepare_for_class(UpperCAmelCase__		,				UpperCAmelCase__		,				return_labels=UpperCAmelCase__      )
																check_equivalence(UpperCAmelCase__		,				UpperCAmelCase__		,				UpperCAmelCase__		,				{'''output_hidden_states''': True}      )







				def    lowerCamelCase_  (					self    :		Optional[Any]      ):
										'''simple docstring'''
										lowercase   :       Optional[Any]								=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__      )







				@slow
				def    lowerCamelCase_  (					self    :		Dict      ):
										'''simple docstring'''
										for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowercase   :       Any								=TFRegNetModel.from_pretrained(UpperCAmelCase__      )
																self.assertIsNotNone(UpperCAmelCase__      )






def 							_lowerCAmelCase (      )							->     str:
						lowercase   :       Dict								=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
						return image







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







				@cached_property
				def    lowerCamelCase_  (					self    :		List[Any]      ):
										'''simple docstring'''
										return (
										    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )
										    if is_vision_available()
										    else None
										)







				@slow
				def    lowerCamelCase_  (					self    :		Optional[int]      ):
										'''simple docstring'''
										lowercase   :       Optional[int]								=TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )

										lowercase   :       Dict								=self.default_image_processor
										lowercase   :       str								=prepare_img()
										lowercase   :       Dict								=image_processor(images=UpperCAmelCase__		,				return_tensors='''tf'''      )

										# forward pass
										lowercase   :       Optional[int]								=model(**UpperCAmelCase__		,				training=UpperCAmelCase__      )

										# verify the logits
										lowercase   :       Optional[Any]								=tf.TensorShape((1, 1000)      )
										self.assertEqual(outputs.logits.shape		,				UpperCAmelCase__      )

										lowercase   :       Optional[int]								=tf.constant([-0.41_80, -1.50_51, -3.48_36]      )

										tf.debugging.assert_near(outputs.logits[0, :3]		,				UpperCAmelCase__		,				atol=1E-4      )








'''simple docstring'''





from datetime import datetime

import matplotlib.pyplot as plt
import torch






def 							_lowerCAmelCase (      __magic_name__	:    Dict	)							->     Dict:
						for param in module.parameters():
												lowercase   :       List[str]								=False






def 							_lowerCAmelCase (      )							->     List[str]:
						lowercase   :       Dict								='''cuda''' if torch.cuda.is_available() else '''cpu'''
						if torch.backends.mps.is_available() and torch.backends.mps.is_built():
												lowercase   :       Optional[int]								='''mps'''
						if device == "mps":
												print(
												    '''WARNING: MPS currently doesn\'t seem to work, and messes up backpropagation without any visible torch'''
												    ''' errors. I recommend using CUDA on a colab notebook or CPU instead if you\'re facing inexplicable issues'''
												    ''' with generations.'''	)
						return device






def 							_lowerCAmelCase (      __magic_name__	:    Union[str, Any]	)							->     str:
						lowercase   :       Optional[int]								=plt.imshow(__magic_name__	)
						fig.axes.get_xaxis().set_visible(__magic_name__	)
						fig.axes.get_yaxis().set_visible(__magic_name__	)
						plt.show()







def 							_lowerCAmelCase (      )							->     List[Any]:
						lowercase   :       Any								=datetime.now()
						lowercase   :       Dict								=current_time.strftime('''%H:%M:%S'''	)
						return timestamp





