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




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




	def      _UpperCamelCase       (					self   )						->				Dict:
			lowerCamelCase	:     str            =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

			lowerCamelCase	:     List[Any]            =       self.get_config()

			return config, pixel_values, labels




	def      _UpperCamelCase       (					self   )						->				int:
			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						,					UpperCAmelCase_						,					UpperCAmelCase_						,					UpperCAmelCase_   )						->				Tuple:
			lowerCamelCase	:     int            =       ResNetModel(config=UpperCAmelCase__   )
			model.to(UpperCAmelCase__   )
			model.eval()
			lowerCamelCase	:     List[Any]            =       model(UpperCAmelCase__   )
			# 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						,					UpperCAmelCase_						,					UpperCAmelCase_						,					UpperCAmelCase_   )						->				Dict:
			lowerCamelCase	:     Optional[Any]            =       self.num_labels
			lowerCamelCase	:     List[Any]            =       ResNetForImageClassification(UpperCAmelCase__   )
			model.to(UpperCAmelCase__   )
			model.eval()
			lowerCamelCase	:     Tuple            =       model(UpperCAmelCase__						,					labels=UpperCAmelCase__   )
			self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.num_labels)   )




	def      _UpperCamelCase       (					self						,					UpperCAmelCase_						,					UpperCAmelCase_						,					UpperCAmelCase_   )						->				Union[str, Any]:
			lowerCamelCase	:     int            =       ResNetBackbone(config=UpperCAmelCase__   )
			model.to(UpperCAmelCase__   )
			model.eval()
			lowerCamelCase	:     Optional[Any]            =       model(UpperCAmelCase__   )

			# 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	:     Tuple            =       ResNetBackbone(config=UpperCAmelCase__   )
			model.to(UpperCAmelCase__   )
			model.eval()
			lowerCamelCase	:     Union[str, Any]            =       model(UpperCAmelCase__   )

			# 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   )						->				str:
			lowerCamelCase	:     Dict            =       self.prepare_config_and_inputs()
			lowerCamelCase	:     Union[str, Any]            =       config_and_inputs
			lowerCamelCase	:     int            =       {"""pixel_values""": pixel_values}
			return config, inputs_dict






@require_torch
class 			_lowercase  (							__UpperCAmelCase							,			__UpperCAmelCase							,			unittest.TestCase						):
	lowercase_								=      (
	    (
	        ResNetModel,
	        ResNetForImageClassification,
	        ResNetBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	lowercase_								=      (
	    {"""feature-extraction""": ResNetModel, """image-classification""": ResNetForImageClassification}
	    if is_torch_available()
	    else {}
	)

	lowercase_								=      True
	lowercase_								=      False
	lowercase_								=      False
	lowercase_								=      False
	lowercase_								=      False




	def      _UpperCamelCase       (					self   )						->				Union[str, Any]:
			lowerCamelCase	:     int            =       ResNetModelTester(self   )
			lowerCamelCase	:     Optional[Any]            =       ConfigTester(self						,					config_class=UpperCAmelCase__						,					has_text_modality=UpperCAmelCase__   )




	def      _UpperCamelCase       (					self   )						->				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   )						->				Dict:
			return




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




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




	def      _UpperCamelCase       (					self   )						->				Optional[Any]:
			lowerCamelCase	:     Tuple            =       self.model_tester.prepare_config_and_inputs_for_common()

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

					lowerCamelCase	:     str            =       ["""pixel_values"""]
					self.assertListEqual(arg_names[:1]						,					UpperCAmelCase__   )




	def      _UpperCamelCase       (					self   )						->				List[str]:
			lowerCamelCase	:     Optional[int]            =       self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*UpperCAmelCase__   )




	def      _UpperCamelCase       (					self   )						->				Dict:
			lowerCamelCase	:     int            =       self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_backbone(*UpperCAmelCase__   )




	def      _UpperCamelCase       (					self   )						->				Union[str, Any]:
			lowerCamelCase	:     Tuple            =       self.model_tester.prepare_config_and_inputs_for_common()

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







			def check_hidden_states_output(UpperCAmelCase_						,					UpperCAmelCase_						,					UpperCAmelCase_   ):
					lowerCamelCase	:     str            =       model_class(UpperCAmelCase__   )
					model.to(UpperCAmelCase__   )
					model.eval()

					with torch.no_grad():
							lowerCamelCase	:     int            =       model(**self._prepare_for_class(UpperCAmelCase__						,					UpperCAmelCase__   )   )

					lowerCamelCase	:     Dict            =       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

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

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

							check_hidden_states_output(UpperCAmelCase__						,					UpperCAmelCase__						,					UpperCAmelCase__   )




	@unittest.skip(reason='ResNet does not use feedforward chunking'   )
	def      _UpperCamelCase       (					self   )						->				Dict:
			pass




	def      _UpperCamelCase       (					self   )						->				List[Any]:
			lowerCamelCase	:     Optional[Any]            =       self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__   )




	@slow
	def      _UpperCamelCase       (					self   )						->				str:







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


def 						UpperCAmelCase   (						):





		'''simple docstring'''


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






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




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




	@slow
	def      _UpperCamelCase       (					self   )						->				Any:
			lowerCamelCase	:     Optional[int]            =       ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(UpperCAmelCase__   )

			lowerCamelCase	:     str            =       self.default_image_processor
			lowerCamelCase	:     Dict            =       prepare_img()
			lowerCamelCase	:     int            =       image_processor(images=UpperCAmelCase__						,					return_tensors='pt'   ).to(UpperCAmelCase__   )

			# forward pass
			with torch.no_grad():
					lowerCamelCase	:     Dict            =       model(**UpperCAmelCase__   )

			# verify the logits
			lowerCamelCase	:     str            =       torch.Size((1, 1000)   )
			self.assertEqual(outputs.logits.shape						,					UpperCAmelCase__   )

			lowerCamelCase	:     Union[str, Any]            =       torch.tensor([-11.1069, -9.7877, -8.3777]   ).to(UpperCAmelCase__   )

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






@require_torch
class 			_lowercase  (							__UpperCAmelCase							,			unittest.TestCase						):
	lowercase_								=      (ResNetBackbone,) if is_torch_available() else ()
	lowercase_								=      False
	lowercase_								=      ResNetConfig




	def      _UpperCamelCase       (					self   )						->				Any:
			lowerCamelCase	:     List[Any]            =       ResNetModelTester(self   )









from typing import List, Optional, Tuple, Union

from . import logging
from .import_utils import is_torch_available, is_torch_version


if is_torch_available():
  import torch

UpperCAmelCase__			:  int					     =     logging.get_logger(__name__)  # pylint: disable=invalid-name

try:
  from torch._dynamo import allow_in_graph as maybe_allow_in_graph
except (ImportError, ModuleNotFoundError):






  def        __lowercase   (  cls      )  ->    Any:
        return cls






def        __lowercase   (  _A    ,     _A = None    ,     _A = None    ,     _A = None    ,     _A = None    ,     )  ->    Tuple:
      SCREAMING_SNAKE_CASE			:   Optional[Any]	  = device
      SCREAMING_SNAKE_CASE			:   Tuple	  = shape[0]

      SCREAMING_SNAKE_CASE			:   Optional[int]	  = layout or torch.strided
      SCREAMING_SNAKE_CASE			:   Dict	  = device or torch.device("""cpu"""      )

      if generator is not None:
            SCREAMING_SNAKE_CASE			:   Optional[Any]	  = generator.device.type if not isinstance(_A    ,     _A      ) else generator[0].device.type
            if gen_device_type != device.type and gen_device_type == "cpu":
                  SCREAMING_SNAKE_CASE			:   Tuple	  = """cpu"""
                  if device != "mps":
                        logger.info(
                            F"The passed generator was created on 'cpu' even though a tensor on {device} was expected."
                            F" Tensors will be created on 'cpu' and then moved to {device}. Note that one can probably"
                            F" slighly speed up this function by passing a generator that was created on the {device} device."      )
            elif gen_device_type != device.type and gen_device_type == "cuda":
                  raise ValueError(F"Cannot generate a {device} tensor from a generator of type {gen_device_type}."      )

      if isinstance(_A    ,     _A      ):
            SCREAMING_SNAKE_CASE			:   int	  = (1,) + shape[1:]
            SCREAMING_SNAKE_CASE			:   Any	  = [
                torch.randn(_A    ,     generator=generator[i]    ,     device=_A    ,     dtype=_A    ,     layout=_A      )
                for i in range(_A      )
            ]
            SCREAMING_SNAKE_CASE			:   Any	  = torch.cat(_A    ,     dim=0      ).to(_A      )
      else:
            SCREAMING_SNAKE_CASE			:   int	  = torch.randn(_A    ,     generator=_A    ,     device=_A    ,     dtype=_A    ,     layout=_A      ).to(_A      )

      return latents







def        __lowercase   (  _A      )  ->    Dict:
      if is_torch_version("""<"""    ,     """2.0.0"""      ) or not hasattr(_A    ,     """_dynamo"""      ):
            return False
      return isinstance(_A    ,     torch._dynamo.eval_frame.OptimizedModule      )




