



'''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 __snake_case:


						'''simple docstring'''



						def __init__(					self	,       A_	,       A_=3	,       A_=32	,       A_=3	,       A_=10	,       A_=[10, 20, 30, 40]	,       A_=[1, 1, 2, 1]	,       A_=True	,       A_=True	,       A_="relu"	,       A_=3	,       A_=None	,       A_=["stage2", "stage3", "stage4"]	,       A_=[2, 3, 4]	,       )	->	int:
							lowerCAmelCase    =	parent
							lowerCAmelCase    =	batch_size
							lowerCAmelCase    =	image_size
							lowerCAmelCase    =	num_channels
							lowerCAmelCase    =	embeddings_size
							lowerCAmelCase    =	hidden_sizes
							lowerCAmelCase    =	depths
							lowerCAmelCase    =	is_training
							lowerCAmelCase    =	use_labels
							lowerCAmelCase    =	hidden_act
							lowerCAmelCase    =	num_labels
							lowerCAmelCase    =	scope
							lowerCAmelCase    =	len(lowercase_      )
							lowerCAmelCase    =	out_features
							lowerCAmelCase    =	out_indices


						def 				__snake_case    (					self      )	->	Any:
							lowerCAmelCase    =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

							lowerCAmelCase    =	self.get_config()

							return config, pixel_values, labels


						def 				__snake_case    (					self      )	->	List[Any]:
							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 				__snake_case    (					self	,       A_	,       A_	,       A_      )	->	Optional[Any]:
							lowerCAmelCase    =	ResNetModel(config=lowercase_      )
							model.to(lowercase_      )
							model.eval()
							lowerCAmelCase    =	model(lowercase_      )
							# 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	,       A_	,       A_	,       A_      )	->	List[Any]:
							lowerCAmelCase    =	self.num_labels
							lowerCAmelCase    =	ResNetForImageClassification(lowercase_      )
							model.to(lowercase_      )
							model.eval()
							lowerCAmelCase    =	model(lowercase_	,       labels=lowercase_      )
							self.parent.assertEqual(result.logits.shape	,       (self.batch_size, self.num_labels)      )


						def 				__snake_case    (					self	,       A_	,       A_	,       A_      )	->	Tuple:
							lowerCAmelCase    =	ResNetBackbone(config=lowercase_      )
							model.to(lowercase_      )
							model.eval()
							lowerCAmelCase    =	model(lowercase_      )

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

							# 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 				__snake_case    (					self      )	->	List[str]:
							lowerCAmelCase    =	self.prepare_config_and_inputs()
							lowerCAmelCase,   lowerCAmelCase,   lowerCAmelCase    =	config_and_inputs
							lowerCAmelCase    =	{"""pixel_values""": pixel_values}
							return config, inputs_dict







@require_torch
class __snake_case(      _lowerCAmelCase		,							_lowerCAmelCase		,							unittest.TestCase					):


						'''simple docstring'''



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

						UpperCAmelCase							:    List[Any]           =		True
						UpperCAmelCase							:    Optional[Any]           =		False
						UpperCAmelCase							:    Union[str, Any]           =		False
						UpperCAmelCase							:    str           =		False
						UpperCAmelCase							:    Union[str, Any]           =		False


						def 				__snake_case    (					self      )	->	str:
							lowerCAmelCase    =	ResNetModelTester(self      )
							lowerCAmelCase    =	ConfigTester(self	,       config_class=lowercase_	,       has_text_modality=lowercase_      )


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


						@unittest.skip(reason="""ResNet does not use inputs_embeds"""      )
						def 				__snake_case    (					self      )	->	List[str]:
							pass


						@unittest.skip(reason="""ResNet does not support input and output embeddings"""      )
						def 				__snake_case    (					self      )	->	Union[str, Any]:
							pass


						def 				__snake_case    (					self      )	->	Union[str, Any]:
							lowerCAmelCase,   lowerCAmelCase    =	self.model_tester.prepare_config_and_inputs_for_common()

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

								lowerCAmelCase    =	["""pixel_values"""]
								self.assertListEqual(arg_names[:1]	,       lowercase_      )


						def 				__snake_case    (					self      )	->	List[Any]:
							lowerCAmelCase    =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase_      )


						def 				__snake_case    (					self      )	->	Dict:
							lowerCAmelCase    =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*lowercase_      )


						def 				__snake_case    (					self      )	->	Optional[Any]:
							lowerCAmelCase,   lowerCAmelCase    =	self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								lowerCAmelCase    =	model_class(config=lowercase_      )
								for name, module in model.named_modules():
									if isinstance(lowercase_	,       (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:







							def check_hidden_states_output(A_	,       A_	,       A_      ):
								lowerCAmelCase    =	model_class(lowercase_      )
								model.to(lowercase_      )
								model.eval()

								with torch.no_grad():
									lowerCAmelCase    =	model(**self._prepare_for_class(lowercase_	,       lowercase_      )      )

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

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

							lowerCAmelCase,   lowerCAmelCase    =	self.model_tester.prepare_config_and_inputs_for_common()
							lowerCAmelCase    =	["""basic""", """bottleneck"""]
							for model_class in self.all_model_classes:
								for layer_type in layers_type:
									lowerCAmelCase    =	layer_type
									lowerCAmelCase    =	True
									check_hidden_states_output(lowercase_	,       lowercase_	,       lowercase_      )

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

									check_hidden_states_output(lowercase_	,       lowercase_	,       lowercase_      )


						@unittest.skip(reason="""ResNet does not use feedforward chunking"""      )
						def 				__snake_case    (					self      )	->	Optional[int]:
							pass


						def 				__snake_case    (					self      )	->	int:
							lowerCAmelCase    =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowercase_      )




						@slow
						def 				__snake_case    (					self      )	->	Any:







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







def 		_snake_case		(					)			->						Optional[Any]:







	"""simple docstring"""
	lowerCAmelCase    =	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
	return image

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


						'''simple docstring'''



						@cached_property
						def 				__snake_case    (					self      )	->	str:
							return (
							    AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )
							    if is_vision_available()
							    else None
							)




						@slow
						def 				__snake_case    (					self      )	->	str:
							lowerCAmelCase    =	ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      ).to(lowercase_      )

							lowerCAmelCase    =	self.default_image_processor
							lowerCAmelCase    =	prepare_img()
							lowerCAmelCase    =	image_processor(images=lowercase_	,       return_tensors="""pt"""      ).to(lowercase_      )

							# forward pass
							with torch.no_grad():
								lowerCAmelCase    =	model(**lowercase_      )

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

							lowerCAmelCase    =	torch.tensor([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]      ).to(lowercase_      )

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







@require_torch
class __snake_case(      _lowerCAmelCase		,							unittest.TestCase					):


						'''simple docstring'''



						UpperCAmelCase							:    Union[str, Any]           =		(ResNetBackbone,) if is_torch_available() else ()
						UpperCAmelCase							:    List[str]           =		False
						UpperCAmelCase							:    List[str]           =		ResNetConfig


						def 				__snake_case    (					self      )	->	Dict:
							lowerCAmelCase    =	ResNetModelTester(self      )
lowerCamelCase__   = '''
# Transformers installation
! pip install transformers datasets
# To install from source instead of the last release, comment the command above and uncomment the following one.
# ! pip install git+https://github.com/huggingface/transformers.git
'''

lowerCamelCase__   = [{'''type''': '''code''', '''content''': INSTALL_CONTENT}]
lowerCamelCase__   = {
    '''{processor_class}''': '''FakeProcessorClass''',
    '''{model_class}''': '''FakeModelClass''',
    '''{object_class}''': '''FakeObjectClass''',
}




