





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


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



									"""simple docstring"""



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


							def   _snake_case	(				self     :Optional[int]		) -> Optional[int]:



									"""simple docstring"""



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

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

									SCREAMING_SNAKE_CASE__								=   self.get_config()

									return config, pixel_values, labels


							def   _snake_case	(				self     :List[str]		) -> 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   _snake_case	(				self     :Dict				,					__A     :str				,					__A     :Dict				,					__A     :List[str]		) -> int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   RegNetModel(config=__A		)
									model.to(__A		)
									model.eval()
									SCREAMING_SNAKE_CASE__								=   model(__A		)
									# 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   _snake_case	(				self     :str				,					__A     :Dict				,					__A     :Optional[int]				,					__A     :Any		) -> Optional[int]:



									"""simple docstring"""



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


							def   _snake_case	(				self     :Optional[Any]		) -> Optional[int]:



									"""simple docstring"""



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




@require_torch
class 	UpperCamelCase_							(  SCREAMING_SNAKE_CASE_					,	SCREAMING_SNAKE_CASE_					,	unittest.TestCase     ):
							lowerCamelCase_							     =       (RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
							lowerCamelCase_							     =       (
							    {"""feature-extraction""": RegNetModel, """image-classification""": RegNetForImageClassification}
							    if is_torch_available()
							    else {}
							)

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


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   RegNetModelTester(self		)
									SCREAMING_SNAKE_CASE__								=   ConfigTester(self				,					config_class=__A				,					has_text_modality=__A		)


							def   _snake_case	(				self     :Any		) -> List[str]:



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



									"""simple docstring"""



									return


							@unittest.skip(reason="""RegNet does not use inputs_embeds"""		)
							def   _snake_case	(				self     :List[Any]		) -> Dict:



									"""simple docstring"""



									pass


							@unittest.skip(reason="""RegNet does not support input and output embeddings"""		)
							def   _snake_case	(				self     :List[str]		) -> Tuple:



									"""simple docstring"""



									pass


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs_for_common()

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

											SCREAMING_SNAKE_CASE__								=   ['pixel_values']
											self.assertListEqual(arg_names[:1]				,					__A		)


							def   _snake_case	(				self     :Optional[int]		) -> List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__A		)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
											SCREAMING_SNAKE_CASE__								=   model_class(config=__A		)
											for name, module in model.named_modules():
													if isinstance(__A				,					(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   _snake_case	(				self     :str		) -> int:



									"""simple docstring"""



									def check_hidden_states_output(__A     :Dict				,					__A     :int				,					__A     :Any		):
											SCREAMING_SNAKE_CASE__								=   model_class(__A		)
											model.to(__A		)
											model.eval()

											with torch.no_grad():
													SCREAMING_SNAKE_CASE__								=   model(**self._prepare_for_class(__A				,					__A		)		)

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

											SCREAMING_SNAKE_CASE__								=   self.model_tester.num_stages
											self.assertEqual(len(__A		)				,					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]				,					)

									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs_for_common()
									SCREAMING_SNAKE_CASE__								=   ['basic', 'bottleneck']
									for model_class in self.all_model_classes:
											for layer_type in layers_type:
													SCREAMING_SNAKE_CASE__								=   layer_type
													SCREAMING_SNAKE_CASE__								=   True
													check_hidden_states_output(__A				,					__A				,					__A		)

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

													check_hidden_states_output(__A				,					__A				,					__A		)


							def   _snake_case	(				self     :List[str]		) -> Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*__A		)


							@slow
							def   _snake_case	(				self     :List[Any]		) -> Dict:



									"""simple docstring"""



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






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     )
		return image




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


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



									"""simple docstring"""



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


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(__A		)

									SCREAMING_SNAKE_CASE__								=   self.default_image_processor
									SCREAMING_SNAKE_CASE__								=   prepare_img()
									SCREAMING_SNAKE_CASE__								=   image_processor(images=__A				,					return_tensors="""pt"""		).to(__A		)

									# forward pass
									with torch.no_grad():
											SCREAMING_SNAKE_CASE__								=   model(**__A		)

									# verify the logits
									SCREAMING_SNAKE_CASE__								=   torch.Size((1, 1000)		)
									self.assertEqual(outputs.logits.shape				,					__A		)

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

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




"""simple docstring"""







def     UpperCAmelCase_					(				__a   :			float      ,							__a   :			float						):




			'''simple docstring'''



			if density <= 0:
						raise ValueError('Impossible fluid density'						)
			if bulk_modulus <= 0:
						raise ValueError('Impossible bulk modulus'						)

			return (bulk_modulus / density) ** 0.5


if __name__ == "__main__":
	import doctest

	doctest.testmod()





