


import inspect
import unittest

from transformers import ResNetConfig
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_backbone_common import BackboneTesterMixin
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 ResNetBackbone, ResNetForImageClassification, ResNetModel
				from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor







class      __lowercase  :





							"""simple docstring"""







							def __init__(	self       ,		lowerCAmelCase__       ,		lowerCAmelCase__=3       ,		lowerCAmelCase__=3_2       ,		lowerCAmelCase__=3       ,		lowerCAmelCase__=1_0       ,		lowerCAmelCase__=[1_0, 2_0, 3_0, 4_0]       ,		lowerCAmelCase__=[1, 1, 2, 1]       ,		lowerCAmelCase__=True       ,		lowerCAmelCase__=True       ,		lowerCAmelCase__="relu"       ,		lowerCAmelCase__=3       ,		lowerCAmelCase__=None       ,		lowerCAmelCase__=["stage2", "stage3", "stage4"]       ,		lowerCAmelCase__=[2, 3, 4]       ,		):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= parent
										SCREAMING_SNAKE_CASE_						:			str       						= batch_size
										SCREAMING_SNAKE_CASE_						:			Tuple       						= image_size
										SCREAMING_SNAKE_CASE_						:			List[str]       						= num_channels
										SCREAMING_SNAKE_CASE_						:			List[str]       						= embeddings_size
										SCREAMING_SNAKE_CASE_						:			Any       						= hidden_sizes
										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= depths
										SCREAMING_SNAKE_CASE_						:			List[str]       						= is_training
										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= use_labels
										SCREAMING_SNAKE_CASE_						:			Any       						= hidden_act
										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= num_labels
										SCREAMING_SNAKE_CASE_						:			Any       						= scope
										SCREAMING_SNAKE_CASE_						:			int       						= len(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Any       						= out_features
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= out_indices






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Any       						= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

										SCREAMING_SNAKE_CASE_						:			Dict       						= None
										if self.use_labels:
													SCREAMING_SNAKE_CASE_						:			Any       						= ids_tensor([self.batch_size]       ,		self.num_labels    )

										SCREAMING_SNAKE_CASE_						:			List[str]       						= self.get_config()

										return config, pixel_values, labels






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										return ResNetConfig(
										    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       ,		out_features=self.out_features       ,		out_indices=self.out_indices       ,		)






							def  UpperCamelCase__			(	self       ,		lowerCAmelCase__       ,		lowerCAmelCase__       ,		lowerCAmelCase__    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= ResNetModel(config=lowerCAmelCase__    )
										model.to(lowerCAmelCase__    )
										model.eval()
										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= model(lowerCAmelCase__    )
										# 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  UpperCamelCase__			(	self       ,		lowerCAmelCase__       ,		lowerCAmelCase__       ,		lowerCAmelCase__    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Any       						= self.num_labels
										SCREAMING_SNAKE_CASE_						:			str       						= ResNetForImageClassification(lowerCAmelCase__    )
										model.to(lowerCAmelCase__    )
										model.eval()
										SCREAMING_SNAKE_CASE_						:			List[str]       						= model(lowerCAmelCase__       ,		labels=lowerCAmelCase__    )
										self.parent.assertEqual(result.logits.shape       ,		(self.batch_size, self.num_labels)    )






							def  UpperCamelCase__			(	self       ,		lowerCAmelCase__       ,		lowerCAmelCase__       ,		lowerCAmelCase__    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			List[str]       						= ResNetBackbone(config=lowerCAmelCase__    )
										model.to(lowerCAmelCase__    )
										model.eval()
										SCREAMING_SNAKE_CASE_						:			Tuple       						= model(lowerCAmelCase__    )

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps    )       ,		len(config.out_features    )    )
										self.parent.assertListEqual(list(result.feature_maps[0].shape    )       ,		[self.batch_size, self.hidden_sizes[1], 4, 4]    )

										# verify channels
										self.parent.assertEqual(len(model.channels    )       ,		len(config.out_features    )    )
										self.parent.assertListEqual(model.channels       ,		config.hidden_sizes[1:]    )

										# verify backbone works with out_features=None
										SCREAMING_SNAKE_CASE_						:			Dict       						= None
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= ResNetBackbone(config=lowerCAmelCase__    )
										model.to(lowerCAmelCase__    )
										model.eval()
										SCREAMING_SNAKE_CASE_						:			Any       						= model(lowerCAmelCase__    )

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps    )       ,		1    )
										self.parent.assertListEqual(list(result.feature_maps[0].shape    )       ,		[self.batch_size, self.hidden_sizes[-1], 1, 1]    )

										# verify channels
										self.parent.assertEqual(len(model.channels    )       ,		1    )
										self.parent.assertListEqual(model.channels       ,		[config.hidden_sizes[-1]]    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




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







@require_torch
class      __lowercase  (__SCREAMING_SNAKE_CASE     ,    __SCREAMING_SNAKE_CASE     ,    unittest.TestCase   ):





							"""simple docstring"""







							_UpperCAmelCase     =		(
							    (
							        ResNetModel,
							        ResNetForImageClassification,
							        ResNetBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							_UpperCAmelCase     =		(
							    {"""feature-extraction""": ResNetModel, """image-classification""": ResNetForImageClassification}
							    if is_torch_available()
							    else {}
							)

							_UpperCAmelCase     =		True
							_UpperCAmelCase     =		False
							_UpperCAmelCase     =		False
							_UpperCAmelCase     =		False
							_UpperCAmelCase     =		False






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			str       						= ResNetModelTester(self    )
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= ConfigTester(self       ,		config_class=lowerCAmelCase__       ,		has_text_modality=lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""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  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										return






							@unittest.skip(reason='ResNet does not use inputs_embeds'    )
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										pass






							@unittest.skip(reason='ResNet does not support input and output embeddings'    )
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										pass






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			str       						= self.model_tester.prepare_config_and_inputs_for_common()

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

													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= ['pixel_values']
													self.assertListEqual(arg_names[:1]       ,		lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Any       						= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			int       						= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*lowerCAmelCase__    )






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			List[str]       						= self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE_						:			List[str]       						= model_class(config=lowerCAmelCase__    )
													for name, module in model.named_modules():
																if isinstance(lowerCAmelCase__       ,		(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  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										def check_hidden_states_output(lowerCAmelCase__       ,		lowerCAmelCase__       ,		lowerCAmelCase__    ):
													SCREAMING_SNAKE_CASE_						:			Any       						= model_class(lowerCAmelCase__    )
													model.to(lowerCAmelCase__    )
													model.eval()

													with torch.no_grad():
																SCREAMING_SNAKE_CASE_						:			Dict       						= model(**self._prepare_for_class(lowerCAmelCase__       ,		lowerCAmelCase__    )    )

													SCREAMING_SNAKE_CASE_						:			Dict       						= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													SCREAMING_SNAKE_CASE_						:			Any       						= self.model_tester.num_stages
													self.assertEqual(len(lowerCAmelCase__    )       ,		expected_num_stages + 1    )

													# ResNet'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 // 4, self.model_tester.image_size // 4]       ,		)

										SCREAMING_SNAKE_CASE_						,	SCREAMING_SNAKE_CASE_						:			Dict       						= self.model_tester.prepare_config_and_inputs_for_common()
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= ['basic', 'bottleneck']
										for model_class in self.all_model_classes:
													for layer_type in layers_type:
																SCREAMING_SNAKE_CASE_						:			Any       						= layer_type
																SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= True
																check_hidden_states_output(lowerCAmelCase__       ,		lowerCAmelCase__       ,		lowerCAmelCase__    )

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																SCREAMING_SNAKE_CASE_						:			int       						= True

																check_hidden_states_output(lowerCAmelCase__       ,		lowerCAmelCase__       ,		lowerCAmelCase__    )






							@unittest.skip(reason='ResNet does not use feedforward chunking'    )
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										pass






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			int       						= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__    )






							@slow
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													SCREAMING_SNAKE_CASE_						:			List[str]       						= ResNetModel.from_pretrained(lowerCAmelCase__    )
													self.assertIsNotNone(lowerCAmelCase__    )







def 		a__       (							):
			SCREAMING_SNAKE_CASE_						:			Optional[int]       						= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
			return image







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





							"""simple docstring"""







							@cached_property
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




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






							@slow
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			str       						= ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			int       						= self.default_image_processor
										SCREAMING_SNAKE_CASE_						:			Any       						= prepare_img()
										SCREAMING_SNAKE_CASE_						:			List[str]       						= image_processor(images=lowerCAmelCase__       ,		return_tensors='pt'    ).to(lowerCAmelCase__    )

										# forward pass
										with torch.no_grad():
													SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= model(**lowerCAmelCase__    )

										# verify the logits
										SCREAMING_SNAKE_CASE_						:			Any       						= torch.Size((1, 1_0_0_0)    )
										self.assertEqual(outputs.logits.shape       ,		lowerCAmelCase__    )

										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= torch.tensor([-11.1_069, -9.7_877, -8.3_777]    ).to(lowerCAmelCase__    )

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







@require_torch
class      __lowercase  (__SCREAMING_SNAKE_CASE     ,    unittest.TestCase   ):





							"""simple docstring"""







							_UpperCAmelCase     =		(ResNetBackbone,) if is_torch_available() else ()
							_UpperCAmelCase     =		False
							_UpperCAmelCase     =		ResNetConfig






							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			Dict       						= ResNetModelTester(self    )









def 		a__       (							A__ = 2_0							):

			try:
						SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= int(A__							)
			except (TypeError, ValueError):
						raise TypeError('Parameter n must be int or castable to int.'							)
			if n <= 0:
						raise ValueError('Parameter n must be greater than or equal to one.'							)
			SCREAMING_SNAKE_CASE_						:			int       						= 0
			while 1:
						i += n * (n - 1)
						SCREAMING_SNAKE_CASE_						:			List[str]       						= 0
						for j in range(2,	A__							):
									if i % j != 0:
												SCREAMING_SNAKE_CASE_						:			str       						= 1
												break
						if nfound == 0:
									if i == 0:
												SCREAMING_SNAKE_CASE_						:			Tuple       						= 1
									return i
			return None


if __name__ == "__main__":
				print(F"""{solution() = }""")





