



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


 """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]						,)	->     Any:
        _UpperCAmelCase						:		List[str]      =				parent
        _UpperCAmelCase						:		Union[str, Any]      =				batch_size
        _UpperCAmelCase						:		int      =				image_size
        _UpperCAmelCase						:		Any      =				num_channels
        _UpperCAmelCase						:		Any      =				embeddings_size
        _UpperCAmelCase						:		List[str]      =				hidden_sizes
        _UpperCAmelCase						:		Any      =				depths
        _UpperCAmelCase						:		List[Any]      =				is_training
        _UpperCAmelCase						:		str      =				use_labels
        _UpperCAmelCase						:		List[Any]      =				hidden_act
        _UpperCAmelCase						:		List[str]      =				num_labels
        _UpperCAmelCase						:		int      =				scope
        _UpperCAmelCase						:		Any      =				len(a_							)
        _UpperCAmelCase						:		Union[str, Any]      =				out_features
        _UpperCAmelCase						:		Tuple      =				out_indices







 def _snake_case				(							self							)	->     Any:
        _UpperCAmelCase						:		str      =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

        _UpperCAmelCase						:		int      =				None
        if self.use_labels:
               _UpperCAmelCase						:		Optional[int]      =				ids_tensor([self.batch_size]						,self.num_labels							)

        _UpperCAmelCase						:		Dict      =				self.get_config()

        return config, pixel_values, labels







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







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







@require_torch
class 							lowercase (						_lowerCamelCase      ,      _lowerCamelCase      ,      unittest.TestCase       ):


 """simple docstring"""


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

 UpperCAmelCase					=						True
 UpperCAmelCase					=						False
 UpperCAmelCase					=						False
 UpperCAmelCase					=						False
 UpperCAmelCase					=						False







 def _snake_case				(							self							)	->     Dict:
        _UpperCAmelCase						:		Optional[Any]      =				ResNetModelTester(self							)
        _UpperCAmelCase						:		int      =				ConfigTester(self						,config_class=a_						,has_text_modality=a_							)







 def _snake_case				(							self							)	->     Tuple:
        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							)	->     int:
        return







 @unittest.skip(reason="""ResNet does not use inputs_embeds"""							)
 def _snake_case				(							self							)	->     Dict:
        pass







 @unittest.skip(reason="""ResNet does not support input and output embeddings"""							)
 def _snake_case				(							self							)	->     Tuple:
        pass







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

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

               _UpperCAmelCase						:		List[Any]      =				["""pixel_values"""]
               self.assertListEqual(arg_names[:1]						,a_							)







 def _snake_case				(							self							)	->     Dict:
        _UpperCAmelCase						:		Optional[Any]      =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*a_							)







 def _snake_case				(							self							)	->     Dict:
        _UpperCAmelCase						:		str      =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*a_							)







 def _snake_case				(							self							)	->     Union[str, Any]:
        _UpperCAmelCase  ,_UpperCAmelCase						:		Dict      =				self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
               _UpperCAmelCase						:		int      =				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 _snake_case				(							self							)	->     str:
        def check_hidden_states_output(a_						,a_						,a_							):
               _UpperCAmelCase						:		Union[str, Any]      =				model_class(a_							)
               model.to(a_							)
               model.eval()

               with torch.no_grad():
                      _UpperCAmelCase						:		Union[str, Any]      =				model(**self._prepare_for_class(a_						,a_							)							)

               _UpperCAmelCase						:		Optional[Any]      =				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

               _UpperCAmelCase						:		str      =				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]						,)

        _UpperCAmelCase  ,_UpperCAmelCase						:		int      =				self.model_tester.prepare_config_and_inputs_for_common()
        _UpperCAmelCase						:		List[str]      =				["""basic""", """bottleneck"""]
        for model_class in self.all_model_classes:
               for layer_type in layers_type:
                      _UpperCAmelCase						:		int      =				layer_type
                      _UpperCAmelCase						:		str      =				True
                      check_hidden_states_output(a_						,a_						,a_							)

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

                      check_hidden_states_output(a_						,a_						,a_							)







 @unittest.skip(reason="""ResNet does not use feedforward chunking"""							)
 def _snake_case				(							self							)	->     Any:
        pass







 def _snake_case				(							self							)	->     Union[str, Any]:
        _UpperCAmelCase						:		Optional[Any]      =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*a_							)







 @slow
 def _snake_case				(							self							)	->     Union[str, Any]:
        for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _UpperCAmelCase						:		Any      =				ResNetModel.from_pretrained(a_							)
               self.assertIsNotNone(a_							)







def 					snake_case_      (  )->	int:





       '''simple docstring'''


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



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


 """simple docstring"""


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







 @slow
 def _snake_case				(							self							)	->     List[str]:
        _UpperCAmelCase						:		List[str]      =				ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(a_							)

        _UpperCAmelCase						:		Optional[int]      =				self.default_image_processor
        _UpperCAmelCase						:		Tuple      =				prepare_img()
        _UpperCAmelCase						:		Any      =				image_processor(images=a_						,return_tensors="""pt"""							).to(a_							)

        # forward pass
        with torch.no_grad():
               _UpperCAmelCase						:		int      =				model(**a_							)

        # verify the logits
        _UpperCAmelCase						:		List[str]      =				torch.Size((1, 1_000)							)
        self.assertEqual(outputs.logits.shape						,a_							)

        _UpperCAmelCase						:		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 							lowercase (						_lowerCamelCase      ,      unittest.TestCase       ):


 """simple docstring"""


 UpperCAmelCase					=						(ResNetBackbone,) if is_torch_available() else ()
 UpperCAmelCase					=						False
 UpperCAmelCase					=						ResNetConfig







 def _snake_case				(							self							)	->     Dict:
        _UpperCAmelCase						:		Union[str, Any]      =				ResNetModelTester(self							)








'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


A_							:				List[Any]						=			{
    """configuration_deta""": ["""DETA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DetaConfig"""],
}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							:				Optional[int]						=			["""DetaImageProcessor"""]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							:				Optional[Any]						=			[
       """DETA_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """DetaForObjectDetection""",
       """DetaModel""",
       """DetaPreTrainedModel""",
   ]


if TYPE_CHECKING:
   from .configuration_deta import DETA_PRETRAINED_CONFIG_ARCHIVE_MAP, DetaConfig

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .image_processing_deta import DetaImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_deta import (
          DETA_PRETRAINED_MODEL_ARCHIVE_LIST,
          DetaForObjectDetection,
          DetaModel,
          DetaPreTrainedModel,
      )

else:
   import sys

   A_							:				List[Any]						=			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



