




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



	"""simple docstring"""






	def __init__(					self	,				lowerCamelCase	,				lowerCamelCase=3	,				lowerCamelCase=32	,				lowerCamelCase=3	,				lowerCamelCase=10	,				lowerCamelCase=[10, 20, 30, 40]	,				lowerCamelCase=[1, 1, 2, 1]	,				lowerCamelCase=True	,				lowerCamelCase=True	,				lowerCamelCase="relu"	,				lowerCamelCase=3	,				lowerCamelCase=None	,				lowerCamelCase=["stage2", "stage3", "stage4"]	,				lowerCamelCase=[2, 3, 4]	,				) ->      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    )
								lowercase__        =							out_features
								lowercase__        =							out_indices

	def    __a     (					self    ) ->      Tuple:





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





								"""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    __a     (					self	,				lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase    ) ->      int:





								"""simple docstring"""


								lowercase__        =							ResNetModel(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 // 32, self.image_size // 32)	,				)

	def    __a     (					self	,				lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase    ) ->      List[str]:





								"""simple docstring"""


								lowercase__        =							self.num_labels
								lowercase__        =							ResNetForImageClassification(_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	,				lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase    ) ->      int:





								"""simple docstring"""


								lowercase__        =							ResNetBackbone(config=_snake_case    )
								model.to(_snake_case    )
								model.eval()
								lowercase__        =							model(_snake_case    )

								# 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
								lowercase__        =							None
								lowercase__        =							ResNetBackbone(config=_snake_case    )
								model.to(_snake_case    )
								model.eval()
								lowercase__        =							model(_snake_case    )

								# 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    __a     (					self    ) ->      Dict:





								"""simple docstring"""


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







@require_torch
class 				UpperCAmelCase(					lowerCAmelCase_   ,     lowerCAmelCase_   ,     unittest.TestCase					):



	"""simple docstring"""






	a     : List[Any]	  =					(
	    (
	        ResNetModel,
	        ResNetForImageClassification,
	        ResNetBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	a     : Tuple	  =					(
	    {"""feature-extraction""": ResNetModel, """image-classification""": ResNetForImageClassification}
	    if is_torch_available()
	    else {}
	)

	a     : Optional[int]	  =					True
	a     : Optional[int]	  =					False
	a     : List[Any]	  =					False
	a     : Any	  =					False
	a     : int	  =					False

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





								"""simple docstring"""


								lowercase__        =							ResNetModelTester(self    )
								lowercase__        =							ConfigTester(self	,				config_class=_snake_case	,				has_text_modality=_snake_case    )

	def    __a     (					self    ) ->      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    __a     (					self    ) ->      Union[str, Any]:





								"""simple docstring"""


								return

	@unittest.skip(reason="ResNet does not use inputs_embeds"    )
	def    __a     (					self    ) ->      Any:





								"""simple docstring"""


								pass

	@unittest.skip(reason="ResNet does not support input and output embeddings"    )
	def    __a     (					self    ) ->      Tuple:





								"""simple docstring"""


								pass

	def    __a     (					self    ) ->      Dict:





								"""simple docstring"""


								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    ) ->      Optional[int]:





								"""simple docstring"""


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

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





								"""simple docstring"""


								lowercase__        =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_backbone(*_snake_case    )

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





								"""simple docstring"""


								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    ) ->      int:





								"""simple docstring"""


								def check_hidden_states_output(lowerCamelCase	,				lowerCamelCase	,				lowerCamelCase    ):
															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    )

															# 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]	,				)

								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    )

	@unittest.skip(reason="ResNet does not use feedforward chunking"    )
	def    __a     (					self    ) ->      Tuple:





								"""simple docstring"""


								pass

	def    __a     (					self    ) ->      int:





								"""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[int]:





								"""simple docstring"""


								for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowercase__        =							ResNetModel.from_pretrained(_snake_case    )
															self.assertIsNotNone(_snake_case    )

def  snake_case_					(		)      ->			List[str]:
							lowercase__        =							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
							return image







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



	"""simple docstring"""






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





								"""simple docstring"""


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







	@slow
	def    __a     (					self    ) ->      List[str]:





								"""simple docstring"""


								lowercase__        =							ResNetForImageClassification.from_pretrained(RESNET_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, 1000)    )
								self.assertEqual(outputs.logits.shape	,				_snake_case    )

								lowercase__        =							torch.tensor([-11.1069, -9.78_77, -8.37_77]    ).to(_snake_case    )

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







@require_torch
class 				UpperCAmelCase(					lowerCAmelCase_   ,     unittest.TestCase					):



	"""simple docstring"""






	a     : Dict	  =					(ResNetBackbone,) if is_torch_available() else ()
	a     : Any	  =					False
	a     : Optional[Any]	  =					ResNetConfig

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





								"""simple docstring"""


								lowercase__        =							ResNetModelTester(self    )





def  snake_case_					(		)      ->			int:

							for a in range(3_00    ):
														for b in range(a + 1    ,4_00    ):
																					for c in range(b + 1    ,5_00    ):
																												if (a + b + c) == 10_00 and (a**2) + (b**2) == (c**2):
																																			return a * b * c

							return -1
def  snake_case_					(		)      ->			int:

							for a in range(3_00    ):
														for b in range(4_00    ):
																					lowercase__  :	Dict        =							10_00 - a - b
																					if a < b < c and (a**2) + (b**2) == (c**2):
																												return a * b * c

							return -1
def  snake_case_					(		)      ->			None:
							import timeit

							print(
							    timeit.timeit("solution()"    ,setup="from __main__ import solution"    ,number=10_00    )    )
							print(
							    timeit.timeit(
							        "solution_fast()"    ,setup="from __main__ import solution_fast"    ,number=10_00    )    )


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