



import inspect
import unittest

from transformers import MobileNetVaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import MobileNetVaForImageClassification, MobileNetVaModel
		from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import MobileNetVaImageProcessor





class  __magic_name__   (							A__						):






		def SCREAMING_SNAKE_CASE_			(						self      :     Dict      )				->					int:
								'''simple docstring'''







								UpperCAmelCase         =     self.config_class(**self.inputs_dict      )
								self.parent.assertTrue(hasattr(UpperCamelCase__				,		"tf_padding"      )      )
								self.parent.assertTrue(hasattr(UpperCamelCase__				,		"depth_multiplier"      )      )





class  __magic_name__   :






		def __init__(						self      :     List[Any]				,		UpperCamelCase__      :     str				,		UpperCamelCase__      :     int=13				,		UpperCamelCase__      :     Optional[int]=3				,		UpperCamelCase__      :     Dict=32				,		UpperCamelCase__      :     int=0.25				,		UpperCamelCase__      :     Optional[int]=8				,		UpperCamelCase__      :     str=True				,		UpperCamelCase__      :     List[Any]=10_24				,		UpperCamelCase__      :     str=32				,		UpperCamelCase__      :     Tuple="relu6"				,		UpperCamelCase__      :     Dict=0.1				,		UpperCamelCase__      :     int=0.02				,		UpperCamelCase__      :     int=True				,		UpperCamelCase__      :     Any=True				,		UpperCamelCase__      :     int=10				,		UpperCamelCase__      :     Any=None				,		)				->					List[str]:
								'''simple docstring'''







								UpperCAmelCase         =     parent
								UpperCAmelCase         =     batch_size
								UpperCAmelCase         =     num_channels
								UpperCAmelCase         =     image_size
								UpperCAmelCase         =     depth_multiplier
								UpperCAmelCase         =     min_depth
								UpperCAmelCase         =     tf_padding
								UpperCAmelCase         =     int(last_hidden_size * depth_multiplier      )
								UpperCAmelCase         =     output_stride
								UpperCAmelCase         =     hidden_act
								UpperCAmelCase         =     classifier_dropout_prob
								UpperCAmelCase         =     use_labels
								UpperCAmelCase         =     is_training
								UpperCAmelCase         =     num_labels
								UpperCAmelCase         =     initializer_range
								UpperCAmelCase         =     scope






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[int]      )				->					Any:
								'''simple docstring'''







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

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

								UpperCAmelCase         =     self.get_config()

								return config, pixel_values, labels, pixel_labels






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[Any]      )				->					str:
								'''simple docstring'''







								return MobileNetVaConfig(
								    num_channels=self.num_channels				,		image_size=self.image_size				,		depth_multiplier=self.depth_multiplier				,		min_depth=self.min_depth				,		tf_padding=self.tf_padding				,		hidden_act=self.hidden_act				,		classifier_dropout_prob=self.classifier_dropout_prob				,		initializer_range=self.initializer_range				,		)






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[int]				,		UpperCamelCase__      :     str				,		UpperCamelCase__      :     Tuple				,		UpperCamelCase__      :     Tuple				,		UpperCamelCase__      :     int      )				->					List[str]:
								'''simple docstring'''







								UpperCAmelCase         =     MobileNetVaModel(config=UpperCamelCase__      )
								model.to(UpperCamelCase__      )
								model.eval()
								UpperCAmelCase         =     model(UpperCamelCase__      )
								self.parent.assertEqual(
								    result.last_hidden_state.shape				,		(
								        self.batch_size,
								        self.last_hidden_size,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    )				,		)






		def SCREAMING_SNAKE_CASE_			(						self      :     Dict				,		UpperCamelCase__      :     Optional[Any]				,		UpperCamelCase__      :     Tuple				,		UpperCamelCase__      :     Union[str, Any]				,		UpperCamelCase__      :     Union[str, Any]      )				->					int:
								'''simple docstring'''







								UpperCAmelCase         =     self.num_labels
								UpperCAmelCase         =     MobileNetVaForImageClassification(UpperCamelCase__      )
								model.to(UpperCamelCase__      )
								model.eval()
								UpperCAmelCase         =     model(UpperCamelCase__				,		labels=UpperCamelCase__      )
								self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.num_labels)      )







		def SCREAMING_SNAKE_CASE_			(						self      :     int      )				->					Union[str, Any]:
								'''simple docstring'''







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





@require_torch
class  __magic_name__   (							A__,  A__,  unittest.TestCase						):
		lowercase      :       List[str]          =(MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
		lowercase      :       List[Any]          =(
		    {'''feature-extraction''': MobileNetVaModel, '''image-classification''': MobileNetVaForImageClassification}
		    if is_torch_available()
		    else {}
		)

		lowercase      :       Optional[int]          =False
		lowercase      :       Optional[int]          =False
		lowercase      :       Union[str, Any]          =False
		lowercase      :       Any          =False






		def SCREAMING_SNAKE_CASE_			(						self      :     Union[str, Any]      )				->					List[Any]:
								'''simple docstring'''







								UpperCAmelCase         =     MobileNetVaModelTester(self      )
								UpperCAmelCase         =     MobileNetVaConfigTester(self				,		config_class=UpperCamelCase__				,		has_text_modality=UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     List[Any]      )				->					Tuple:
								'''simple docstring'''







								self.config_tester.run_common_tests()






		@unittest.skip(reason="MobileNetV1 does not use inputs_embeds"      )
		def SCREAMING_SNAKE_CASE_			(						self      :     Tuple      )				->					Optional[int]:
								'''simple docstring'''







								pass






		@unittest.skip(reason="MobileNetV1 does not support input and output embeddings"      )
		def SCREAMING_SNAKE_CASE_			(						self      :     List[Any]      )				->					str:
								'''simple docstring'''







								pass






		@unittest.skip(reason="MobileNetV1 does not output attentions"      )
		def SCREAMING_SNAKE_CASE_			(						self      :     Tuple      )				->					Union[str, Any]:
								'''simple docstring'''







								pass






		def SCREAMING_SNAKE_CASE_			(						self      :     str      )				->					Dict:
								'''simple docstring'''







								UpperCAmelCase       ,		UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs_for_common()

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

														UpperCAmelCase         =     ["pixel_values"]
														self.assertListEqual(arg_names[:1]				,		UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]      )				->					List[str]:
								'''simple docstring'''







								UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[int]      )				->					Union[str, Any]:
								'''simple docstring'''







								def check_hidden_states_output(UpperCamelCase__      :     Optional[Any]				,		UpperCamelCase__      :     Tuple				,		UpperCamelCase__      :     Optional[int]      ):
														UpperCAmelCase         =     model_class(UpperCamelCase__      )
														model.to(UpperCamelCase__      )
														model.eval()

														with torch.no_grad():
																				UpperCAmelCase         =     model(**self._prepare_for_class(UpperCamelCase__				,		UpperCamelCase__      )      )

														UpperCAmelCase         =     outputs.hidden_states

														UpperCAmelCase         =     26
														self.assertEqual(len(UpperCamelCase__      )				,		UpperCamelCase__      )

								UpperCAmelCase       ,		UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														UpperCAmelCase         =     True
														check_hidden_states_output(UpperCamelCase__				,		UpperCamelCase__				,		UpperCamelCase__      )

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

														check_hidden_states_output(UpperCamelCase__				,		UpperCamelCase__				,		UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[int]      )				->					Optional[int]:
								'''simple docstring'''







								UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__      )







		@slow
		def SCREAMING_SNAKE_CASE_			(						self      :     str      )				->					Dict:
								'''simple docstring'''







								for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														UpperCAmelCase         =     MobileNetVaModel.from_pretrained(UpperCamelCase__      )
														self.assertIsNotNone(UpperCamelCase__      )

def    lowerCamelCase_() ->       Any:
						UpperCAmelCase         =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
						return image





@require_torch
@require_vision
class  __magic_name__   (							unittest.TestCase						):






		@cached_property
		def SCREAMING_SNAKE_CASE_			(						self      :     Tuple      )				->					List[Any]:
								'''simple docstring'''







								return (
								    MobileNetVaImageProcessor.from_pretrained("google/mobilenet_v1_1.0_224"      ) if is_vision_available() else None
								)







		@slow
		def SCREAMING_SNAKE_CASE_			(						self      :     Union[str, Any]      )				->					List[Any]:
								'''simple docstring'''







								UpperCAmelCase         =     MobileNetVaForImageClassification.from_pretrained("google/mobilenet_v1_1.0_224"      ).to(UpperCamelCase__      )

								UpperCAmelCase         =     self.default_image_processor
								UpperCAmelCase         =     prepare_img()
								UpperCAmelCase         =     image_processor(images=UpperCamelCase__				,		return_tensors="pt"      ).to(UpperCamelCase__      )

								# forward pass
								with torch.no_grad():
														UpperCAmelCase         =     model(**UpperCamelCase__      )

								# verify the logits
								UpperCAmelCase         =     torch.Size((1, 10_01)      )
								self.assertEqual(outputs.logits.shape				,		UpperCamelCase__      )

								UpperCAmelCase         =     torch.tensor([-4.17_39, -1.12_33, 3.12_05]      ).to(UpperCamelCase__      )

								self.assertTrue(torch.allclose(outputs.logits[0, :3]				,		UpperCamelCase__				,		atol=1e-4      )      )








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






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







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






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[Any]      )				->					Optional[Any]:
								'''simple docstring'''







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

								UpperCAmelCase         =     self.get_config()

								return config, pixel_values






		def SCREAMING_SNAKE_CASE_			(						self      :     Any      )				->					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				,		image_size=self.image_size				,		)






		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[Any]				,		UpperCamelCase__      :     Union[str, Any]				,		UpperCamelCase__      :     List[str]      )				->					Any:
								'''simple docstring'''







								UpperCAmelCase         =     FlaxRegNetModel(config=UpperCamelCase__      )
								UpperCAmelCase         =     model(UpperCamelCase__      )

								# 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 SCREAMING_SNAKE_CASE_			(						self      :     Union[str, Any]				,		UpperCamelCase__      :     Any				,		UpperCamelCase__      :     str      )				->					Union[str, Any]:
								'''simple docstring'''







								UpperCAmelCase         =     self.num_labels
								UpperCAmelCase         =     FlaxRegNetForImageClassification(config=UpperCamelCase__      )
								UpperCAmelCase         =     model(UpperCamelCase__      )
								self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.num_labels)      )







		def SCREAMING_SNAKE_CASE_			(						self      :     str      )				->					List[Any]:
								'''simple docstring'''







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





@require_flax
class  __magic_name__   (							A__,  unittest.TestCase						):
		lowercase      :       List[str]          =(FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

		lowercase      :       Tuple          =False
		lowercase      :       Union[str, Any]          =False
		lowercase      :       Dict          =False






		def SCREAMING_SNAKE_CASE_			(						self      :     List[Any]      )				->					None:
								'''simple docstring'''







								UpperCAmelCase         =     FlaxRegNetModelTester(self      )
								UpperCAmelCase         =     ConfigTester(self				,		config_class=UpperCamelCase__				,		has_text_modality=UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]      )				->					Optional[Any]:
								'''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 SCREAMING_SNAKE_CASE_			(						self      :     int      )				->					Dict:
								'''simple docstring'''







								return






		def SCREAMING_SNAKE_CASE_			(						self      :     List[Any]      )				->					List[str]:
								'''simple docstring'''







								UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     str      )				->					Tuple:
								'''simple docstring'''







								UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__      )






		@unittest.skip(reason="RegNet does not use inputs_embeds"      )
		def SCREAMING_SNAKE_CASE_			(						self      :     str      )				->					Optional[int]:
								'''simple docstring'''







								pass






		@unittest.skip(reason="RegNet does not support input and output embeddings"      )
		def SCREAMING_SNAKE_CASE_			(						self      :     int      )				->					Optional[Any]:
								'''simple docstring'''







								pass






		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]      )				->					Optional[Any]:
								'''simple docstring'''







								UpperCAmelCase       ,		UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs_for_common()

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

														UpperCAmelCase         =     ["pixel_values"]
														self.assertListEqual(arg_names[:1]				,		UpperCamelCase__      )






		def SCREAMING_SNAKE_CASE_			(						self      :     Tuple      )				->					Dict:
								'''simple docstring'''







								def check_hidden_states_output(UpperCamelCase__      :     List[str]				,		UpperCamelCase__      :     Any				,		UpperCamelCase__      :     Any      ):
														UpperCAmelCase         =     model_class(UpperCamelCase__      )

														UpperCAmelCase         =     model(**self._prepare_for_class(UpperCamelCase__				,		UpperCamelCase__      )      )

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

														UpperCAmelCase         =     self.model_tester.num_stages
														self.assertEqual(len(UpperCamelCase__      )				,		expected_num_stages + 1      )

								UpperCAmelCase       ,		UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														UpperCAmelCase         =     True
														check_hidden_states_output(UpperCamelCase__				,		UpperCamelCase__				,		UpperCamelCase__      )

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

														check_hidden_states_output(UpperCamelCase__				,		UpperCamelCase__				,		UpperCamelCase__      )







		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]      )				->					Optional[int]:
								'''simple docstring'''







								UpperCAmelCase       ,		UpperCAmelCase         =     self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														with self.subTest(model_class.__name__      ):
																				UpperCAmelCase         =     self._prepare_for_class(UpperCamelCase__				,		UpperCamelCase__      )
																				UpperCAmelCase         =     model_class(UpperCamelCase__      )

																				@jax.jit
																				def model_jitted(UpperCamelCase__      :     Optional[int]				,		**UpperCamelCase__      :     Union[str, Any]      ):
																										return model(pixel_values=UpperCamelCase__				,		**UpperCamelCase__      )

																				with self.subTest("JIT Enabled"      ):
																										UpperCAmelCase         =     model_jitted(**UpperCamelCase__      ).to_tuple()

																				with self.subTest("JIT Disabled"      ):
																										with jax.disable_jit():
																																UpperCAmelCase         =     model_jitted(**UpperCamelCase__      ).to_tuple()

																				self.assertEqual(len(UpperCamelCase__      )				,		len(UpperCamelCase__      )      )
																				for jitted_output, output in zip(UpperCamelCase__				,		UpperCamelCase__      ):
																										self.assertEqual(jitted_output.shape				,		output.shape      )

def    lowerCamelCase_() ->       Union[str, Any]:
						UpperCAmelCase         =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
						return image





@require_flax
class  __magic_name__   (							unittest.TestCase						):






		@cached_property
		def SCREAMING_SNAKE_CASE_			(						self      :     Union[str, Any]      )				->					Optional[Any]:
								'''simple docstring'''







								return AutoImageProcessor.from_pretrained("facebook/regnet-y-040"      ) if is_vision_available() else None







		@slow
		def SCREAMING_SNAKE_CASE_			(						self      :     Optional[int]      )				->					Tuple:
								'''simple docstring'''







								UpperCAmelCase         =     FlaxRegNetForImageClassification.from_pretrained("facebook/regnet-y-040"      )

								UpperCAmelCase         =     self.default_image_processor
								UpperCAmelCase         =     prepare_img()
								UpperCAmelCase         =     image_processor(images=UpperCamelCase__				,		return_tensors="np"      )

								UpperCAmelCase         =     model(**UpperCamelCase__      )

								# verify the logits
								UpperCAmelCase         =     (1, 10_00)
								self.assertEqual(outputs.logits.shape				,		UpperCamelCase__      )

								UpperCAmelCase         =     jnp.array([-0.41_80, -1.50_51, -3.48_36]      )

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



