


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						:






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




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






						def  lowerCamelCase (      self		:  Union[str, Any]				)      ->		Optional[int]:
													"""simple docstring"""




													_lowerCamelCase :	Tuple						=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

													_lowerCamelCase :	Union[str, Any]						=None
													if self.use_labels:
																				_lowerCamelCase :	Union[str, Any]						=ids_tensor([self.batch_size]    ,     self.num_labels				)

													_lowerCamelCase :	Dict						=self.get_config()

													return config, pixel_values, labels






						def  lowerCamelCase (      self		:  int				)      ->		Optional[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  lowerCamelCase (      self		:  Optional[int]    ,     lowercase_		:  Optional[int]    ,     lowercase_		:  List[str]    ,     lowercase_		:  Optional[int]				)      ->		Optional[Any]:
													"""simple docstring"""




													_lowerCamelCase :	Any						=ResNetModel(config=a_				)
													model.to(a_				)
													model.eval()
													_lowerCamelCase :	int						=model(a_				)
													# 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  lowerCamelCase (      self		:  List[str]    ,     lowercase_		:  Dict    ,     lowercase_		:  str    ,     lowercase_		:  Any				)      ->		Any:
													"""simple docstring"""




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






						def  lowerCamelCase (      self		:  List[Any]    ,     lowercase_		:  str    ,     lowercase_		:  List[str]    ,     lowercase_		:  Tuple				)      ->		Any:
													"""simple docstring"""




													_lowerCamelCase :	str						=ResNetBackbone(config=a_				)
													model.to(a_				)
													model.eval()
													_lowerCamelCase :	Tuple						=model(a_				)

													# 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 :	Union[str, Any]						=None
													_lowerCamelCase :	List[str]						=ResNetBackbone(config=a_				)
													model.to(a_				)
													model.eval()
													_lowerCamelCase :	Union[str, Any]						=model(a_				)

													# 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  lowerCamelCase (      self		:  int				)      ->		Tuple:
													"""simple docstring"""




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




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

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






						def  lowerCamelCase (      self		:  str				)      ->		int:
													"""simple docstring"""




													_lowerCamelCase :	Any						=ResNetModelTester(self				)
													_lowerCamelCase :	List[str]						=ConfigTester(self    ,     config_class=a_    ,     has_text_modality=a_				)






						def  lowerCamelCase (      self		:  Optional[int]				)      ->		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  lowerCamelCase (      self		:  Optional[int]				)      ->		Optional[int]:
													"""simple docstring"""




													return






						@unittest.skip(reason='ResNet does not use inputs_embeds'				)
						def  lowerCamelCase (      self		:  Optional[Any]				)      ->		Dict:
													"""simple docstring"""




													pass






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




													pass






						def  lowerCamelCase (      self		:  List[str]				)      ->		Optional[int]:
													"""simple docstring"""




													_lowerCamelCase			,  _lowerCamelCase :	Dict						=self.model_tester.prepare_config_and_inputs_for_common()

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

																				_lowerCamelCase :	Tuple						=['pixel_values']
																				self.assertListEqual(arg_names[:1]    ,     a_				)






						def  lowerCamelCase (      self		:  List[str]				)      ->		List[Any]:
													"""simple docstring"""




													_lowerCamelCase :	List[Any]						=self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*a_				)






						def  lowerCamelCase (      self		:  Union[str, Any]				)      ->		int:
													"""simple docstring"""




													_lowerCamelCase :	Any						=self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_backbone(*a_				)






						def  lowerCamelCase (      self		:  Union[str, Any]				)      ->		List[Any]:
													"""simple docstring"""




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

													for model_class in self.all_model_classes:
																				_lowerCamelCase :	Tuple						=model_class(config=a_				)
																				for name, module in model.named_modules():
																											if isinstance(a_    ,     (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  lowerCamelCase (      self		:  Optional[int]				)      ->		Optional[Any]:
													"""simple docstring"""




													def check_hidden_states_output(lowercase_		:  List[Any]    ,     lowercase_		:  Any    ,     lowercase_		:  Optional[int]				):
																				_lowerCamelCase :	Optional[Any]						=model_class(a_				)
																				model.to(a_				)
																				model.eval()

																				with torch.no_grad():
																											_lowerCamelCase :	str						=model(**self._prepare_for_class(a_    ,     a_				)				)

																				_lowerCamelCase :	Union[str, Any]						=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																				_lowerCamelCase :	List[Any]						=self.model_tester.num_stages
																				self.assertEqual(len(a_				)    ,     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 :	Union[str, Any]						=self.model_tester.prepare_config_and_inputs_for_common()
													_lowerCamelCase :	List[Any]						=['basic', 'bottleneck']
													for model_class in self.all_model_classes:
																				for layer_type in layers_type:
																											_lowerCamelCase :	int						=layer_type
																											_lowerCamelCase :	Optional[int]						=True
																											check_hidden_states_output(a_    ,     a_    ,     a_				)

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

																											check_hidden_states_output(a_    ,     a_    ,     a_				)






						@unittest.skip(reason='ResNet does not use feedforward chunking'				)
						def  lowerCamelCase (      self		:  List[Any]				)      ->		List[str]:
													"""simple docstring"""




													pass






						def  lowerCamelCase (      self		:  List[Any]				)      ->		List[Any]:
													"""simple docstring"""




													_lowerCamelCase :	str						=self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*a_				)






						@slow
						def  lowerCamelCase (      self		:  int				)      ->		int:
													"""simple docstring"""




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




def 			a_   (					):
							'''simple docstring'''





							_lowerCamelCase :	Dict						=Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
							return image




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






						@cached_property
						def  lowerCamelCase (      self		:  Optional[Any]				)      ->		str:
													"""simple docstring"""




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






						@slow
						def  lowerCamelCase (      self		:  List[Any]				)      ->		Tuple:
													"""simple docstring"""




													_lowerCamelCase :	Optional[int]						=ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]				).to(a_				)

													_lowerCamelCase :	Any						=self.default_image_processor
													_lowerCamelCase :	Optional[Any]						=prepare_img()
													_lowerCamelCase :	Any						=image_processor(images=a_    ,     return_tensors='pt'				).to(a_				)

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

													# verify the logits
													_lowerCamelCase :	Dict						=torch.Size((1, 1000)				)
													self.assertEqual(outputs.logits.shape    ,     a_				)

													_lowerCamelCase :	Optional[Any]						=torch.tensor([-11.1069, -9.7877, -8.3777]				).to(a_				)

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




@require_torch
class A						(     UpperCamelCase_					,							unittest.TestCase  ):
						UpperCamelCase__							:						Union[str, Any]   =(ResNetBackbone,) if is_torch_available() else ()
						UpperCamelCase__							:						int   =False
						UpperCamelCase__							:						str   =ResNetConfig






						def  lowerCamelCase (      self		:  Tuple				)      ->		List[Any]:
													"""simple docstring"""




													_lowerCamelCase :	Any						=ResNetModelTester(self				)






from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import is_torch_available, is_transformers_available


if is_transformers_available() and is_torch_available():
 from .image_encoder import PaintByExampleImageEncoder
 from .pipeline_paint_by_example import PaintByExamplePipeline


