


import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 torch import nn

	from transformers import RegNetForImageClassification, RegNetModel
	from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor
class 						lowerCamelCase_							:



					'''simple docstring'''







					def __init__(					self			,							snake_case_			,							snake_case_=3			,							snake_case_=3_2			,							snake_case_=3			,							snake_case_=1_0			,							snake_case_=[1_0, 2_0, 3_0, 4_0]			,							snake_case_=[1, 1, 2, 1]			,							snake_case_=True			,							snake_case_=True			,							snake_case_="relu"			,							snake_case_=3			,							snake_case_=None			,							) ->      Union[str, 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(snake_case_    )






					def A   (					self    ) ->      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 A   (					self    ) ->      List[str]:







								'''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			,							snake_case_			,							snake_case_			,							snake_case_    ) ->      Any:







								'''simple docstring'''

								__lowercase			       = RegNetModel(config=snake_case_    )
								model.to(snake_case_    )
								model.eval()
								__lowercase			       = model(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 // 3_2, self.image_size // 3_2)			,							)






					def A   (					self			,							snake_case_			,							snake_case_			,							snake_case_    ) ->      Any:







								'''simple docstring'''

								__lowercase			       = self.num_labels
								__lowercase			       = RegNetForImageClassification(snake_case_    )
								model.to(snake_case_    )
								model.eval()
								__lowercase			       = model(snake_case_			,							labels=snake_case_    )
								self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.num_labels)    )






					def A   (					self    ) ->      Optional[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_torch
class 						lowerCamelCase_							(					lowerCAmelCase__  ,  lowerCAmelCase__  ,  unittest.TestCase					):



					'''simple docstring'''







					__UpperCAmelCase							  =					(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
					__UpperCAmelCase							  =					(
					    {"feature-extraction": RegNetModel, "image-classification": RegNetForImageClassification}
					    if is_torch_available()
					    else {}
					)

					__UpperCAmelCase							  =					False
					__UpperCAmelCase							  =					False
					__UpperCAmelCase							  =					False
					__UpperCAmelCase							  =					False






					def A   (					self    ) ->      Union[str, Any]:







								'''simple docstring'''

								__lowercase			       = RegNetModelTester(self    )
								__lowercase			       = ConfigTester(self			,							config_class=snake_case_			,							has_text_modality=snake_case_    )






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







								'''simple docstring'''

								return






					@unittest.skip(reason='''RegNet does not use inputs_embeds'''    )
					def A   (					self    ) ->      Dict:







								'''simple docstring'''

								pass






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







								'''simple docstring'''

								pass






					def A   (					self    ) ->      Any:







								'''simple docstring'''

								__lowercase       ,			__lowercase			       = self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowercase			       = ['''pixel_values''']
											self.assertListEqual(arg_names[:1]			,							snake_case_    )






					def A   (					self    ) ->      List[Any]:







								'''simple docstring'''

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






					def A   (					self    ) ->      List[Any]:







								'''simple docstring'''

								__lowercase       ,			__lowercase			       = self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											__lowercase			       = model_class(config=snake_case_    )
											for name, module in model.named_modules():
														if isinstance(snake_case_			,							(nn.BatchNormad, nn.GroupNorm)    ):
																	self.assertTrue(
																	    torch.all(module.weight == 1    )			,							msg=F'Parameter {name} of model {model_class} seems not properly initialized'			,							)
																	self.assertTrue(
																	    torch.all(module.bias == 0    )			,							msg=F'Parameter {name} of model {model_class} seems not properly initialized'			,							)






					def A   (					self    ) ->      Dict:







								'''simple docstring'''

								def check_hidden_states_output(snake_case_			,							snake_case_			,							snake_case_    ):
											__lowercase			       = model_class(snake_case_    )
											model.to(snake_case_    )
											model.eval()

											with torch.no_grad():
														__lowercase			       = model(**self._prepare_for_class(snake_case_			,							snake_case_    )    )

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

											__lowercase			       = 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]			,							)

								__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(snake_case_			,							snake_case_			,							snake_case_    )

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

														check_hidden_states_output(snake_case_			,							snake_case_			,							snake_case_    )






					def A   (					self    ) ->      Optional[Any]:







								'''simple docstring'''

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






					@slow
					def A   (					self    ) ->      Optional[Any]:







								'''simple docstring'''

								for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase			       = RegNetModel.from_pretrained(snake_case_    )
											self.assertIsNotNone(snake_case_    )




def 		lowercase_	(  ):


			'''simple docstring'''







			__lowercase			       = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
			return image





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



					'''simple docstring'''







					@cached_property
					def A   (					self    ) ->      List[Any]:







								'''simple docstring'''

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






					@slow
					def A   (					self    ) ->      Union[str, Any]:







								'''simple docstring'''

								__lowercase			       = RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(snake_case_    )

								__lowercase			       = self.default_image_processor
								__lowercase			       = prepare_img()
								__lowercase			       = image_processor(images=snake_case_			,							return_tensors='''pt'''    ).to(snake_case_    )

								# forward pass
								with torch.no_grad():
											__lowercase			       = model(**snake_case_    )

								# verify the logits
								__lowercase			       = torch.Size((1, 1_0_0_0)    )
								self.assertEqual(outputs.logits.shape			,							snake_case_    )

								__lowercase			       = torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]    ).to(snake_case_    )

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






def 		lowercase_	(  _UpperCamelCase	):


			'''simple docstring'''







			__lowercase			       = hex_num.strip()
			if not hex_num:
						raise ValueError('''No value was passed to the function'''	)

			__lowercase			       = hex_num[0] == '''-'''
			if is_negative:
						__lowercase			       = hex_num[1:]

			try:
						__lowercase			       = int(_UpperCamelCase							,      16	)
			except ValueError:
						raise ValueError('''Invalid value was passed to the function'''	)

			__lowercase			       = ''''''
			while int_num > 0:
						__lowercase			       = str(int_num % 2	) + bin_str
						int_num >>= 1

			return int(('''-''' + bin_str) if is_negative else bin_str	)


if __name__ == "__main__":
	import doctest

	doctest.testmod()


