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






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






   def  __UpperCamelCase	( self							:	List[str]    )   ->		str:
       lowercase__					:  Optional[Any]          =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

       lowercase__					:  Any          =							None
       if self.use_labels:
           lowercase__					:  List[Any]          =							ids_tensor([self.batch_size]      ,		self.num_labels    )

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

       return config, pixel_values, labels






   def  __UpperCamelCase	( self							:	str    )   ->		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  __UpperCamelCase	( self							:	Optional[int]      ,		lowercase_							:	Optional[Any]      ,		lowercase_							:	Tuple      ,		lowercase_							:	Optional[Any]    )   ->		int:
       lowercase__					:  Union[str, Any]          =							ResNetModel(config=lowercase_    )
       model.to(lowercase_    )
       model.eval()
       lowercase__					:  List[str]          =							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  __UpperCamelCase	( self							:	Tuple      ,		lowercase_							:	List[Any]      ,		lowercase_							:	Optional[int]      ,		lowercase_							:	Optional[Any]    )   ->		int:
       lowercase__					:  Optional[int]          =							self.num_labels
       lowercase__					:  Optional[Any]          =							ResNetForImageClassification(lowercase_    )
       model.to(lowercase_    )
       model.eval()
       lowercase__					:  Any          =							model(lowercase_      ,		labels=lowercase_    )
       self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.num_labels)    )






   def  __UpperCamelCase	( self							:	Tuple      ,		lowercase_							:	Any      ,		lowercase_							:	Any      ,		lowercase_							:	Tuple    )   ->		Tuple:
       lowercase__					:  int          =							ResNetBackbone(config=lowercase_    )
       model.to(lowercase_    )
       model.eval()
       lowercase__					:  int          =							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
       lowercase__					:  List[Any]          =							None
       lowercase__					:  str          =							ResNetBackbone(config=lowercase_    )
       model.to(lowercase_    )
       model.eval()
       lowercase__					:  int          =							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  __UpperCamelCase	( self							:	Union[str, Any]    )   ->		List[Any]:
       lowercase__					:  Union[str, Any]          =							self.prepare_config_and_inputs()
       lowercase__   ,  lowercase__   ,  lowercase__					:  int          =							config_and_inputs
       lowercase__					:  Tuple          =							{"pixel_values": pixel_values}
       return config, inputs_dict



@require_torch
class     snake_case_			(						__A    ,__A    ,unittest.TestCase			):
   __A      :						Union[str, Any]   =							(
       (
           ResNetModel,
           ResNetForImageClassification,
           ResNetBackbone,
       )
       if is_torch_available()
       else ()
   )
   __A      :						Dict   =							(
       {"feature-extraction": ResNetModel, "image-classification": ResNetForImageClassification}
       if is_torch_available()
       else {}
   )

   __A      :						Optional[Any]   =							True
   __A      :						Optional[int]   =							False
   __A      :						Union[str, Any]   =							False
   __A      :						Tuple   =							False
   __A      :						Any   =							False






   def  __UpperCamelCase	( self							:	List[str]    )   ->		Optional[int]:
       lowercase__					:  Tuple          =							ResNetModelTester(self    )
       lowercase__					:  Tuple          =							ConfigTester(self      ,		config_class=lowercase_      ,		has_text_modality=lowercase_    )






   def  __UpperCamelCase	( self							:	Optional[Any]    )   ->		List[str]:
       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  __UpperCamelCase	( self							:	Union[str, Any]    )   ->		int:
       return






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






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






   def  __UpperCamelCase	( self							:	List[Any]    )   ->		str:
       lowercase__   ,  lowercase__					:  str          =							self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           lowercase__					:  Union[str, Any]          =							model_class(lowercase_    )
           lowercase__					:  Tuple          =							inspect.signature(model.forward    )
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           lowercase__					:  int          =							[*signature.parameters.keys()]

           lowercase__					:  Optional[Any]          =							["pixel_values"]
           self.assertListEqual(arg_names[:1]      ,		lowercase_    )






   def  __UpperCamelCase	( self							:	List[Any]    )   ->		str:
       lowercase__					:  str          =							self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowercase_    )






   def  __UpperCamelCase	( self							:	Union[str, Any]    )   ->		int:
       lowercase__					:  Dict          =							self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*lowercase_    )






   def  __UpperCamelCase	( self							:	Dict    )   ->		Any:
       lowercase__   ,  lowercase__					:  Tuple          =							self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           lowercase__					:  Optional[Any]          =							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  __UpperCamelCase	( self							:	List[Any]    )   ->		Dict:
       def check_hidden_states_output(lowercase_							:	List[str]      ,		lowercase_							:	Union[str, Any]      ,		lowercase_							:	Optional[Any]    ):
           lowercase__					:  Optional[Any]          =							model_class(lowercase_    )
           model.to(lowercase_    )
           model.eval()

           with torch.no_grad():
               lowercase__					:  Optional[Any]          =							model(**self._prepare_for_class(lowercase_      ,		lowercase_    )    )

           lowercase__					:  Tuple          =							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

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

       lowercase__   ,  lowercase__					:  Optional[Any]          =							self.model_tester.prepare_config_and_inputs_for_common()
       lowercase__					:  Union[str, Any]          =							["basic", "bottleneck"]
       for model_class in self.all_model_classes:
           for layer_type in layers_type:
               lowercase__					:  List[Any]          =							layer_type
               lowercase__					:  Dict          =							True
               check_hidden_states_output(lowercase_      ,		lowercase_      ,		lowercase_    )

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               lowercase__					:  Optional[int]          =							True

               check_hidden_states_output(lowercase_      ,		lowercase_      ,		lowercase_    )






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






   def  __UpperCamelCase	( self							:	List[Any]    )   ->		int:
       lowercase__					:  Union[str, Any]          =							self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*lowercase_    )







   @slow
   def  __UpperCamelCase	( self							:	List[Any]    )   ->		Optional[int]:
       for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           lowercase__					:  Optional[int]          =							ResNetModel.from_pretrained(lowercase_    )
           self.assertIsNotNone(lowercase_    )



def      lowercase_							(     ):
    lowercase__					:  Any          =							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
    return image



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






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







   @slow
   def  __UpperCamelCase	( self							:	Optional[int]    )   ->		List[Any]:
       lowercase__					:  Optional[Any]          =							ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(lowercase_    )

       lowercase__					:  Any          =							self.default_image_processor
       lowercase__					:  Tuple          =							prepare_img()
       lowercase__					:  Tuple          =							image_processor(images=lowercase_      ,		return_tensors="pt"    ).to(lowercase_    )

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

       # verify the logits
       lowercase__					:  List[str]          =							torch.Size((1, 10_00)    )
       self.assertEqual(outputs.logits.shape      ,		lowercase_    )

       lowercase__					:  List[str]          =							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     snake_case_			(						__A    ,unittest.TestCase			):
   __A      :						List[Any]   =							(ResNetBackbone,) if is_torch_available() else ()
   __A      :						Optional[Any]   =							False
   __A      :						Tuple   =							ResNetConfig






   def  __UpperCamelCase	( self							:	Optional[Any]    )   ->		Union[str, Any]:
       lowercase__					:  Union[str, Any]          =							ResNetModelTester(self    )




import unittest
from pathlib import Path

from transformers import is_vision_available, load_tool
from transformers.testing_utils import get_tests_dir

from .test_tools_common import ToolTesterMixin


if is_vision_available():
      from PIL import Image



class     snake_case_			(						unittest.TestCase    ,__A			):






   def  __UpperCamelCase	( self							:	int    )   ->		Union[str, Any]:
       lowercase__					:  Any          =							load_tool("image-segmentation"    )
       self.tool.setup()
       lowercase__					:  Optional[int]          =							load_tool("image-segmentation"      ,		remote=lowercase_    )






   def  __UpperCamelCase	( self							:	Any    )   ->		Tuple:
       lowercase__					:  Any          =							Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"    )    ) / "000000039769.png"    )
       lowercase__					:  Tuple          =							self.tool(lowercase_      ,		"cat"    )
       self.assertTrue(isinstance(lowercase_      ,		Image.Image    )    )






   def  __UpperCamelCase	( self							:	Optional[int]    )   ->		Dict:
       lowercase__					:  List[Any]          =							Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"    )    ) / "000000039769.png"    )
       lowercase__					:  Optional[int]          =							self.remote_tool(lowercase_      ,		"cat"    )
       self.assertTrue(isinstance(lowercase_      ,		Image.Image    )    )






   def  __UpperCamelCase	( self							:	List[Any]    )   ->		Dict:
       lowercase__					:  Optional[Any]          =							Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"    )    ) / "000000039769.png"    )
       lowercase__					:  int          =							self.tool(image=lowercase_      ,		label="cat"    )
       self.assertTrue(isinstance(lowercase_      ,		Image.Image    )    )







   def  __UpperCamelCase	( self							:	Dict    )   ->		List[Any]:
       lowercase__					:  Tuple          =							Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"    )    ) / "000000039769.png"    )
       lowercase__					:  Union[str, Any]          =							self.remote_tool(image=lowercase_      ,		label="cat"    )
       self.assertTrue(isinstance(lowercase_      ,		Image.Image    )    )



