



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        snake_case__    :







						"""simple docstring"""




						def __init__(       self ,       __lowercase ,       __lowercase=3 ,       __lowercase=3_2 ,       __lowercase=3 ,       __lowercase=1_0 ,       __lowercase=[1_0, 2_0, 3_0, 4_0] ,       __lowercase=[1, 1, 2, 1] ,       __lowercase=True ,       __lowercase=True ,       __lowercase="relu" ,       __lowercase=3 ,       __lowercase=None ,       ) ->				Dict:
									"""simple docstring"""




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

						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				str:
									"""simple docstring"""




									a__       :						Dict							=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

									a__       :						str							=  self.get_config()
									return config, pixel_values, labels

						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				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 ,       )

						def 							SCREAMING_SNAKE_CASE__(       self ,       __lowercase ,       __lowercase ,       __lowercase  ) ->				List[str]:
									"""simple docstring"""




									a__       :						int							=  TFRegNetModel(config=__lowercase  )
									a__       :						str							=  model(__lowercase ,       training=__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 // 3_2, self.image_size // 3_2) ,       )

						def 							SCREAMING_SNAKE_CASE__(       self ,       __lowercase ,       __lowercase ,       __lowercase  ) ->				Tuple:
									"""simple docstring"""




									a__       :						List[str]							=  self.num_labels
									a__       :						Any							=  TFRegNetForImageClassification(__lowercase  )
									a__       :						Dict							=  model(__lowercase ,       labels=__lowercase ,       training=__lowercase  )
									self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.num_labels)  )

						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				Dict:
									"""simple docstring"""




									a__       :						str							=  self.prepare_config_and_inputs()
									a__	,						a__	,						a__       :						int							=  config_and_inputs
									a__       :						Tuple							=  {"""pixel_values""": pixel_values}
									return config, inputs_dict




@require_tf
class        snake_case__    (A__ ,     A__ ,     unittest.TestCase		):







						"""simple docstring"""




						__lowerCAmelCase					:str      =					(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
						__lowerCAmelCase					:Dict      =					(
						    {"feature-extraction": TFRegNetModel, "image-classification": TFRegNetForImageClassification}
						    if is_tf_available()
						    else {}
						)

						__lowerCAmelCase					:List[Any]      =					False
						__lowerCAmelCase					:Optional[Any]      =					False
						__lowerCAmelCase					:Tuple      =					False
						__lowerCAmelCase					:Tuple      =					False
						__lowerCAmelCase					:Any      =					False

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




									a__       :						List[Any]							=  TFRegNetModelTester(self  )
									a__       :						List[str]							=  ConfigTester(self ,       config_class=__lowercase ,       has_text_modality=__lowercase  )

						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				Dict:
									"""simple docstring"""




									return

						@unittest.skip(reason="""RegNet does not use inputs_embeds"""  )
						def 							SCREAMING_SNAKE_CASE__(       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 							SCREAMING_SNAKE_CASE__(       self  ) ->				Optional[int]:
									"""simple docstring"""




									super().test_keras_fit()

						@unittest.skip(reason="""RegNet does not support input and output embeddings"""  )
						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				str:
									"""simple docstring"""




									pass

						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				Tuple:
									"""simple docstring"""




									a__	,						a__       :						Optional[Any]							=  self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
												a__       :						List[str]							=  model_class(__lowercase  )
												a__       :						Dict							=  inspect.signature(model.call  )
												# signature.parameters is an OrderedDict => so arg_names order is deterministic
												a__       :						Union[str, Any]							=  [*signature.parameters.keys()]

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

						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				Tuple:
									"""simple docstring"""




									a__       :						List[Any]							=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__lowercase  )

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




									def check_hidden_states_output(__lowercase ,       __lowercase ,       __lowercase  ):
												a__       :						Union[str, Any]							=  model_class(__lowercase  )
												a__       :						str							=  model(**self._prepare_for_class(__lowercase ,       __lowercase  ) ,       training=__lowercase  )

												a__       :						Optional[Any]							=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

												a__       :						Any							=  self.model_tester.num_stages
												self.assertEqual(len(__lowercase  ) ,       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] ,       )

									a__	,						a__       :						Tuple							=  self.model_tester.prepare_config_and_inputs_for_common()
									a__       :						Dict							=  ["""basic""", """bottleneck"""]
									for model_class in self.all_model_classes:
												for layer_type in layers_type:
															a__       :						Optional[Any]							=  layer_type
															a__       :						List[str]							=  True
															check_hidden_states_output(__lowercase ,       __lowercase ,       __lowercase  )

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															a__       :						Union[str, Any]							=  True

															check_hidden_states_output(__lowercase ,       __lowercase ,       __lowercase  )

						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				Dict:
									"""simple docstring"""




									a__	,						a__       :						List[Any]							=  self.model_tester.prepare_config_and_inputs_for_common()

									def check_equivalence(__lowercase ,       __lowercase ,       __lowercase ,       __lowercase={}  ):
												a__       :						List[Any]							=  model(__lowercase ,       return_dict=__lowercase ,       **__lowercase  )
												a__       :						Tuple							=  model(__lowercase ,       return_dict=__lowercase ,       **__lowercase  ).to_tuple()

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

															recursive_check(__lowercase ,       __lowercase  )

									for model_class in self.all_model_classes:
												a__       :						Any							=  model_class(__lowercase  )

												a__       :						Any							=  self._prepare_for_class(__lowercase ,       __lowercase  )
												a__       :						Union[str, Any]							=  self._prepare_for_class(__lowercase ,       __lowercase  )
												check_equivalence(__lowercase ,       __lowercase ,       __lowercase  )

												a__       :						Tuple							=  self._prepare_for_class(__lowercase ,       __lowercase ,       return_labels=__lowercase  )
												a__       :						Tuple							=  self._prepare_for_class(__lowercase ,       __lowercase ,       return_labels=__lowercase  )
												check_equivalence(__lowercase ,       __lowercase ,       __lowercase  )

												a__       :						Tuple							=  self._prepare_for_class(__lowercase ,       __lowercase  )
												a__       :						Optional[Any]							=  self._prepare_for_class(__lowercase ,       __lowercase  )
												check_equivalence(__lowercase ,       __lowercase ,       __lowercase ,       {"""output_hidden_states""": True}  )

												a__       :						Optional[Any]							=  self._prepare_for_class(__lowercase ,       __lowercase ,       return_labels=__lowercase  )
												a__       :						Any							=  self._prepare_for_class(__lowercase ,       __lowercase ,       return_labels=__lowercase  )
												check_equivalence(__lowercase ,       __lowercase ,       __lowercase ,       {"""output_hidden_states""": True}  )

						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				Any:
									"""simple docstring"""




									a__       :						List[Any]							=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*__lowercase  )

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




									for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												a__       :						Tuple							=  TFRegNetModel.from_pretrained(__lowercase  )
												self.assertIsNotNone(__lowercase  )




def      lowerCAmelCase_					(  )							->	str:







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





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







						"""simple docstring"""




						@cached_property
						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				Dict:
									"""simple docstring"""




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

						@slow
						def 							SCREAMING_SNAKE_CASE__(       self  ) ->				Optional[Any]:
									"""simple docstring"""




									a__       :						Optional[int]							=  TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )

									a__       :						int							=  self.default_image_processor
									a__       :						List[Any]							=  prepare_img()
									a__       :						Optional[Any]							=  image_processor(images=__lowercase ,       return_tensors="""tf"""  )

									# forward pass
									a__       :						Optional[Any]							=  model(**__lowercase ,       training=__lowercase  )

									# verify the logits
									a__       :						Any							=  tf.TensorShape((1, 1_0_0_0)  )
									self.assertEqual(outputs.logits.shape ,       __lowercase  )

									a__       :						int							=  tf.constant([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]  )

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









def      lowerCAmelCase_					(  _lowercase    :       int)							->	int:







			"""simple docstring"""

			if not isinstance(_lowercase						,       _lowercase):
						raise TypeError("""only integers accepted as input""")
			else:
						a__       :						Any							=  str(abs(_lowercase))
						a__       :						str							=  [list(_lowercase) for char in range(len(_lowercase))]
						for index in range(len(_lowercase)):
									num_transpositions[index].pop(_lowercase)
						return max(
						    int("""""".join(list(_lowercase))) for transposition in num_transpositions)


if __name__ == "__main__":
		__import__("doctest").testmod()




