






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


							'''simple docstring'''






							def __init__(		self			,			lowercase_			,			lowercase_=3			,			lowercase_=3_2			,			lowercase_=3			,			lowercase_=1_0			,			lowercase_=[1_0, 2_0, 3_0, 4_0]			,			lowercase_=[1, 1, 2, 1]			,			lowercase_=True			,			lowercase_=True			,			lowercase_="relu"			,			lowercase_=3			,			lowercase_=None			,			lowercase_=["stage2", "stage3", "stage4"]			,			lowercase_=[2, 3, 4]			,			)					->					Optional[int]:
														'''simple docstring'''

														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      _lowercase       (		self   )					->					str:
														'''simple docstring'''

														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      _lowercase       (		self   )					->					Union[str, Any]:
														'''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			,			lowercase_			,			lowercase_			,			lowercase_   )					->					Any:
														'''simple docstring'''

														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 // 3_2, self.image_size // 3_2)			,			)

							def      _lowercase       (		self			,			lowercase_			,			lowercase_			,			lowercase_   )					->					List[Any]:
														'''simple docstring'''

														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      _lowercase       (		self			,			lowercase_			,			lowercase_			,			lowercase_   )					->					int:
														'''simple docstring'''

														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      _lowercase       (		self   )					->					str:
														'''simple docstring'''

														lowerCAmelCase_										=     self.prepare_config_and_inputs()
														lowerCAmelCase_										=     config_and_inputs
														lowerCAmelCase_										=     {"pixel_values": pixel_values}
														return config, inputs_dict




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


							'''simple docstring'''






							__a:	Any     =    (
							    (
							        ResNetModel,
							        ResNetForImageClassification,
							        ResNetBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							__a:	List[str]     =    (
							    {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
							    if is_torch_available()
							    else {}
							)

							__a:	List[str]     =    True
							__a:	List[Any]     =    False
							__a:	Any     =    False
							__a:	Optional[Any]     =    False
							__a:	Optional[int]     =    False

							def      _lowercase       (		self   )					->					Optional[int]:
														'''simple docstring'''

														lowerCAmelCase_										=     ResNetModelTester(self   )
														lowerCAmelCase_										=     ConfigTester(self			,			config_class=lowercase_			,			has_text_modality=lowercase_   )

							def      _lowercase       (		self   )					->					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      _lowercase       (		self   )					->					Union[str, Any]:
														'''simple docstring'''

														return

							@unittest.skip(reason='ResNet does not use inputs_embeds'   )
							def      _lowercase       (		self   )					->					Any:
														'''simple docstring'''

														pass

							@unittest.skip(reason='ResNet does not support input and output embeddings'   )
							def      _lowercase       (		self   )					->					List[Any]:
														'''simple docstring'''

														pass

							def      _lowercase       (		self   )					->					List[str]:
														'''simple docstring'''

														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      _lowercase       (		self   )					->					str:
														'''simple docstring'''

														lowerCAmelCase_										=     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*lowercase_   )

							def      _lowercase       (		self   )					->					Dict:
														'''simple docstring'''

														lowerCAmelCase_										=     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_backbone(*lowercase_   )

							def      _lowercase       (		self   )					->					List[str]:
														'''simple docstring'''

														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      _lowercase       (		self   )					->					Union[str, Any]:
														'''simple docstring'''

														def check_hidden_states_output(lowercase_			,			lowercase_			,			lowercase_   ):
																					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_										=     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      _lowercase       (		self   )					->					Any:
														'''simple docstring'''

														pass

							def      _lowercase       (		self   )					->					str:
														'''simple docstring'''

														lowerCAmelCase_										=     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*lowercase_   )






							@slow
							def      _lowercase       (		self   )					->					Dict:
														'''simple docstring'''

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


def      lowerCamelCase					(						)	->			Tuple:
							lowerCAmelCase_										=     Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
							return image




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


							'''simple docstring'''






							@cached_property
							def      _lowercase       (		self   )					->					Union[str, Any]:
														'''simple docstring'''

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






							@slow
							def      _lowercase       (		self   )					->					int:
														'''simple docstring'''

														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, 1_0_0_0)   )
														self.assertEqual(outputs.logits.shape			,			lowercase_   )

														lowerCAmelCase_										=     torch.tensor([-11.10_69, -9.78_77, -8.37_77]   ).to(lowercase_   )

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




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


							'''simple docstring'''






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

							def      _lowercase       (		self   )					->					Optional[Any]:
														'''simple docstring'''

														lowerCAmelCase_										=     ResNetModelTester(self   )




import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
				import tensorflow as tf

				from transformers.activations_tf import get_tf_activation



@require_tf
class    lowercase_    (     unittest.TestCase		):



							def        UpperCamelCase       (						self				):
													_snake_case						:     int				=    tf.constant([-100, -1.0, -0.1, 0, 0.1, 1.0, 100.0]				)
													_snake_case						:     List[Any]				=    get_tf_activation("gelu"				)
													_snake_case						:     Any				=    get_tf_activation("gelu_10"				)

													_snake_case						:     Dict				=    gelu(lowercase_				)
													_snake_case						:     Optional[int]				=    geluaa(lowercase_				)

													_snake_case						:     Tuple				=    tf.where(y_gelu_aa < 10.0      ,				1.0      ,				0.0				)

													self.assertEqual(tf.math.reduce_max(lowercase_				).numpy().item()      ,				10.0				)
													self.assertTrue(np.allclose(y_gelu * clipped_mask      ,				y_gelu_aa * clipped_mask				)				)



							def        UpperCamelCase       (						self				):
													get_tf_activation("gelu"				)
													get_tf_activation("gelu_10"				)
													get_tf_activation("gelu_fast"				)
													get_tf_activation("gelu_new"				)
													get_tf_activation("glu"				)
													get_tf_activation("mish"				)
													get_tf_activation("quick_gelu"				)
													get_tf_activation("relu"				)
													get_tf_activation("sigmoid"				)
													get_tf_activation("silu"				)
													get_tf_activation("swish"				)
													get_tf_activation("tanh"				)
													with self.assertRaises(lowercase_				):
																			get_tf_activation("bogus"				)
													with self.assertRaises(lowercase_				):
																			get_tf_activation(lowercase_				)