



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   __lowerCAmelCase  :
					"""simple docstring"""






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






								"""simple docstring"""


								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(_snake_case       )



					def      _a				(  self       :							List[Any]       ):






								"""simple docstring"""


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

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

								A__	  =     self.get_config()
								return config, pixel_values, labels



					def      _a				(  self       :							Union[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					,       )



					def      _a				(  self       :							int					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							Dict					,       _snake_case       :							List[str]       ):






								"""simple docstring"""


								A__	  =     TFRegNetModel(config=_snake_case       )
								A__	  =     model(_snake_case					,       training=_snake_case       )
								# 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      _a				(  self       :							Optional[int]					,       _snake_case       :							str					,       _snake_case       :							List[Any]					,       _snake_case       :							Dict       ):






								"""simple docstring"""


								A__	  =     self.num_labels
								A__	  =     TFRegNetForImageClassification(_snake_case       )
								A__	  =     model(_snake_case					,       labels=_snake_case					,       training=_snake_case       )
								self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.num_labels)       )



					def      _a				(  self       :							Tuple       ):






								"""simple docstring"""


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







@require_tf
class   __lowerCAmelCase  (		UpperCAmelCase_				,  UpperCAmelCase_				,  unittest.TestCase   ):
					"""simple docstring"""






					A__					:		Optional[int]      							=     (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
					A__					:		Dict      							=     (
					    {"feature-extraction": TFRegNetModel, "image-classification": TFRegNetForImageClassification}
					    if is_tf_available()
					    else {}
					)

					A__					:		List[str]      							=     False
					A__					:		List[Any]      							=     False
					A__					:		List[str]      							=     False
					A__					:		List[Any]      							=     False
					A__					:		int      							=     False



					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								A__	  =     TFRegNetModelTester(self       )
								A__	  =     ConfigTester(self					,       config_class=_snake_case					,       has_text_modality=_snake_case       )



					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								return



					@unittest.skip(reason='RegNet does not use inputs_embeds'       )
					def      _a				(  self       :							List[Any]       ):






								"""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      _a				(  self       :							Optional[int]       ):






								"""simple docstring"""


								super().test_keras_fit()



					@unittest.skip(reason='RegNet does not support input and output embeddings'       )
					def      _a				(  self       :							List[Any]       ):






								"""simple docstring"""


								pass



					def      _a				(  self       :							int       ):






								"""simple docstring"""


								A__  ,			A__	  =     self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											A__	  =     model_class(_snake_case       )
											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]					,       _snake_case       )



					def      _a				(  self       :							Dict       ):






								"""simple docstring"""


								A__	  =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case       )



					def      _a				(  self       :							int       ):






								"""simple docstring"""


								def check_hidden_states_output(_snake_case       :							Optional[Any]					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							int       ):
											A__	  =     model_class(_snake_case       )
											A__	  =     model(**self._prepare_for_class(_snake_case					,       _snake_case       )					,       training=_snake_case       )

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

											A__	  =     self.model_tester.num_stages
											self.assertEqual(len(_snake_case       )					,       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__	  =     self.model_tester.prepare_config_and_inputs_for_common()
								A__	  =     ['basic', 'bottleneck']
								for model_class in self.all_model_classes:
											for layer_type in layers_type:
														A__	  =     layer_type
														A__	  =     True
														check_hidden_states_output(_snake_case					,       _snake_case					,       _snake_case       )

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

														check_hidden_states_output(_snake_case					,       _snake_case					,       _snake_case       )



					def      _a				(  self       :							List[Any]       ):






								"""simple docstring"""


								A__  ,			A__	  =     self.model_tester.prepare_config_and_inputs_for_common()

								def check_equivalence(_snake_case       :							Tuple					,       _snake_case       :							List[Any]					,       _snake_case       :							Optional[int]					,       _snake_case       :							Dict={}       ):
											A__	  =     model(_snake_case					,       return_dict=_snake_case					,       **_snake_case       )
											A__	  =     model(_snake_case					,       return_dict=_snake_case					,       **_snake_case       ).to_tuple()

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

														recursive_check(_snake_case					,       _snake_case       )

								for model_class in self.all_model_classes:
											A__	  =     model_class(_snake_case       )

											A__	  =     self._prepare_for_class(_snake_case					,       _snake_case       )
											A__	  =     self._prepare_for_class(_snake_case					,       _snake_case       )
											check_equivalence(_snake_case					,       _snake_case					,       _snake_case       )

											A__	  =     self._prepare_for_class(_snake_case					,       _snake_case					,       return_labels=_snake_case       )
											A__	  =     self._prepare_for_class(_snake_case					,       _snake_case					,       return_labels=_snake_case       )
											check_equivalence(_snake_case					,       _snake_case					,       _snake_case       )

											A__	  =     self._prepare_for_class(_snake_case					,       _snake_case       )
											A__	  =     self._prepare_for_class(_snake_case					,       _snake_case       )
											check_equivalence(_snake_case					,       _snake_case					,       _snake_case					,       {'output_hidden_states': True}       )

											A__	  =     self._prepare_for_class(_snake_case					,       _snake_case					,       return_labels=_snake_case       )
											A__	  =     self._prepare_for_class(_snake_case					,       _snake_case					,       return_labels=_snake_case       )
											check_equivalence(_snake_case					,       _snake_case					,       _snake_case					,       {'output_hidden_states': True}       )



					def      _a				(  self       :							Union[str, Any]       ):






								"""simple docstring"""


								A__	  =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_snake_case       )



					@slow
					def      _a				(  self       :							List[Any]       ):






								"""simple docstring"""


								for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A__	  =     TFRegNetModel.from_pretrained(_snake_case       )
											self.assertIsNotNone(_snake_case       )







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






@require_tf
@require_vision
class   __lowerCAmelCase  (		unittest.TestCase   ):
					"""simple docstring"""






					@cached_property
					def      _a				(  self       :							Union[str, Any]       ):






								"""simple docstring"""


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



					@slow
					def      _a				(  self       :							int       ):






								"""simple docstring"""


								A__	  =     TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )

								A__	  =     self.default_image_processor
								A__	  =     prepare_img()
								A__	  =     image_processor(images=_snake_case					,       return_tensors='tf'       )

								# forward pass
								A__	  =     model(**_snake_case					,       training=_snake_case       )

								# verify the logits
								A__	  =     tf.TensorShape((1, 10_00)       )
								self.assertEqual(outputs.logits.shape					,       _snake_case       )

								A__	  =     tf.constant([-0.4180, -1.5051, -3.4836]       )

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









"""simple docstring"""







import warnings

from .generation import TFGenerationMixin







class 					A_(SCREAMING_SNAKE_CASE_      ):







			"""simple docstring"""



			warnings.warn(
			    """Importing `TFGenerationMixin` from `src/transformers/generation_tf_utils.py` is deprecated and will """
			    """be removed in Transformers v5. Import as `from transformers import TFGenerationMixin` instead."""   ,   SCREAMING_SNAKE_CASE_   ,   )





