



'''simple docstring'''







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






			def __init__(   self  :							List[Any]      ,       SCREAMING_SNAKE_CASE  :							Any      ,       SCREAMING_SNAKE_CASE  :							Union[str, Any]=3      ,       SCREAMING_SNAKE_CASE  :							List[Any]=32      ,       SCREAMING_SNAKE_CASE  :							Dict=3      ,       SCREAMING_SNAKE_CASE  :							Optional[int]=10      ,       SCREAMING_SNAKE_CASE  :							Dict=[10, 20, 30, 40]      ,       SCREAMING_SNAKE_CASE  :							List[Any]=[1, 1, 2, 1]      ,       SCREAMING_SNAKE_CASE  :							Union[str, Any]=True      ,       SCREAMING_SNAKE_CASE  :							Dict=True      ,       SCREAMING_SNAKE_CASE  :							str="relu"      ,       SCREAMING_SNAKE_CASE  :							List[str]=3      ,       SCREAMING_SNAKE_CASE  :							Union[str, Any]=None      ,       SCREAMING_SNAKE_CASE  :							Dict=["stage2", "stage3", "stage4"]      ,       SCREAMING_SNAKE_CASE  :							Optional[int]=[2, 3, 4]      ,       ):




					"""simple docstring"""







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






			def 				_lowercase	(   self  :							List[str]	):




					"""simple docstring"""







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

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

					SCREAMING_SNAKE_CASE_						:Optional[int]										=      self.get_config()

					return config, pixel_values, labels






			def 				_lowercase	(   self  :							List[str]	):




					"""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 				_lowercase	(   self  :							Union[str, Any]      ,       SCREAMING_SNAKE_CASE  :							int      ,       SCREAMING_SNAKE_CASE  :							Optional[int]      ,       SCREAMING_SNAKE_CASE  :							str	):




					"""simple docstring"""







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




					"""simple docstring"""







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






			def 				_lowercase	(   self  :							int      ,       SCREAMING_SNAKE_CASE  :							str      ,       SCREAMING_SNAKE_CASE  :							Optional[Any]      ,       SCREAMING_SNAKE_CASE  :							Union[str, Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:str										=      ResNetBackbone(config=SCREAMING_SNAKE_CASE	)
					model.to(SCREAMING_SNAKE_CASE	)
					model.eval()
					SCREAMING_SNAKE_CASE_						:Dict										=      model(SCREAMING_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
					SCREAMING_SNAKE_CASE_						:Any										=      None
					SCREAMING_SNAKE_CASE_						:List[Any]										=      ResNetBackbone(config=SCREAMING_SNAKE_CASE	)
					model.to(SCREAMING_SNAKE_CASE	)
					model.eval()
					SCREAMING_SNAKE_CASE_						:Dict										=      model(SCREAMING_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 				_lowercase	(   self  :							int	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      self.prepare_config_and_inputs()
					SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						:Optional[Any]										=      config_and_inputs
					SCREAMING_SNAKE_CASE_						:int										=      {'pixel_values': pixel_values}
					return config, inputs_dict




@require_torch
class 				__lowerCAmelCase(							lowerCAmelCase__		,			lowerCAmelCase__		,			unittest.TestCase      ):
			__snake_case  :		Union[str, Any]		=      (
			    (
			        ResNetModel,
			        ResNetForImageClassification,
			        ResNetBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			__snake_case  :		List[str]		=      (
			    {'feature-extraction': ResNetModel, 'image-classification': ResNetForImageClassification}
			    if is_torch_available()
			    else {}
			)

			__snake_case  :		List[str]		=      True
			__snake_case  :		str		=      False
			__snake_case  :		Tuple		=      False
			__snake_case  :		Tuple		=      False
			__snake_case  :		Optional[Any]		=      False






			def 				_lowercase	(   self  :							List[str]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:str										=      ResNetModelTester(self	)
					SCREAMING_SNAKE_CASE_						:List[str]										=      ConfigTester(self      ,       config_class=SCREAMING_SNAKE_CASE      ,       has_text_modality=SCREAMING_SNAKE_CASE	)






			def 				_lowercase	(   self  :							Tuple	):




					"""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 				_lowercase	(   self  :							List[Any]	):




					"""simple docstring"""







					return






			@unittest.skip(reason='ResNet does not use inputs_embeds'	)
			def 				_lowercase	(   self  :							List[str]	):




					"""simple docstring"""







					pass






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




					"""simple docstring"""







					pass






			def 				_lowercase	(   self  :							Tuple	):




					"""simple docstring"""







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

					for model_class in self.all_model_classes:
							SCREAMING_SNAKE_CASE_						:List[str]										=      model_class(SCREAMING_SNAKE_CASE	)
							SCREAMING_SNAKE_CASE_						:Tuple										=      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_						:Union[str, Any]										=      ['pixel_values']
							self.assertListEqual(arg_names[:1]      ,       SCREAMING_SNAKE_CASE	)






			def 				_lowercase	(   self  :							List[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:int										=      self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE	)






			def 				_lowercase	(   self  :							str	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE	)






			def 				_lowercase	(   self  :							Optional[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						:Any										=      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=SCREAMING_SNAKE_CASE	)
							for name, module in model.named_modules():
									if isinstance(SCREAMING_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 				_lowercase	(   self  :							Any	):




					"""simple docstring"""







					def check_hidden_states_output(SCREAMING_SNAKE_CASE  :							Tuple      ,       SCREAMING_SNAKE_CASE  :							int      ,       SCREAMING_SNAKE_CASE  :							Optional[int]	):
							SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      model_class(SCREAMING_SNAKE_CASE	)
							model.to(SCREAMING_SNAKE_CASE	)
							model.eval()

							with torch.no_grad():
									SCREAMING_SNAKE_CASE_						:Optional[int]										=      model(**self._prepare_for_class(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)	)

							SCREAMING_SNAKE_CASE_						:Optional[int]										=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

							SCREAMING_SNAKE_CASE_						:Optional[int]										=      self.model_tester.num_stages
							self.assertEqual(len(SCREAMING_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]      ,       )

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

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      True

									check_hidden_states_output(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)






			@unittest.skip(reason='ResNet does not use feedforward chunking'	)
			def 				_lowercase	(   self  :							List[str]	):




					"""simple docstring"""







					pass






			def 				_lowercase	(   self  :							List[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[str]										=      self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE	)






			@slow
			def 				_lowercase	(   self  :							Tuple	):




					"""simple docstring"""







					for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							SCREAMING_SNAKE_CASE_						:Dict										=      ResNetModel.from_pretrained(SCREAMING_SNAKE_CASE	)
							self.assertIsNotNone(SCREAMING_SNAKE_CASE	)







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




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






			@cached_property
			def 				_lowercase	(   self  :							List[str]	):




					"""simple docstring"""







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






			@slow
			def 				_lowercase	(   self  :							Any	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Tuple										=      ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(SCREAMING_SNAKE_CASE	)

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

					# forward pass
					with torch.no_grad():
							SCREAMING_SNAKE_CASE_						:Tuple										=      model(**SCREAMING_SNAKE_CASE	)

					# verify the logits
					SCREAMING_SNAKE_CASE_						:int										=      torch.Size((1, 1_000)	)
					self.assertEqual(outputs.logits.shape      ,       SCREAMING_SNAKE_CASE	)

					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      torch.tensor([-11.10_69, -9.78_77, -8.37_77]	).to(SCREAMING_SNAKE_CASE	)

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




@require_torch
class 				__lowerCAmelCase(							lowerCAmelCase__		,			unittest.TestCase      ):
			__snake_case  :		str		=      (ResNetBackbone,) if is_torch_available() else ()
			__snake_case  :		List[Any]		=      False
			__snake_case  :		int		=      ResNetConfig






			def 				_lowercase	(   self  :							Tuple	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Any										=      ResNetModelTester(self	)





'''simple docstring'''







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE = 1000     ):
		return sum(i for i in range(SCREAMING_SNAKE_CASE     ) if i % 3 == 0 or i % 5 == 0     )


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