

'''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_=3_2   , a_=3   , a_=1_0   , a_=[1_0, 2_0, 3_0, 4_0]   , a_=[1, 1, 2, 1]   , a_=True   , a_=True   , a_="relu"   , a_=3   , a_=None   , a_=["stage2", "stage3", "stage4"]   , a_=[2, 3, 4]   , )							->				str:


    """simple docstring"""
    UpperCAmelCase													=	parent
    UpperCAmelCase													=	batch_size
    UpperCAmelCase													=	image_size
    UpperCAmelCase													=	num_channels
    UpperCAmelCase													=	embeddings_size
    UpperCAmelCase													=	hidden_sizes
    UpperCAmelCase													=	depths
    UpperCAmelCase													=	is_training
    UpperCAmelCase													=	use_labels
    UpperCAmelCase													=	hidden_act
    UpperCAmelCase													=	num_labels
    UpperCAmelCase													=	scope
    UpperCAmelCase													=	len(a_     )
    UpperCAmelCase													=	out_features
    UpperCAmelCase													=	out_indices
  def 						snake_case_			(     self     )							->				str:


    """simple docstring"""
    UpperCAmelCase													=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

    UpperCAmelCase													=	self.get_config()

    return config, pixel_values, labels
  def 						snake_case_			(     self     )							->				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 						snake_case_			(     self   , a_   , a_   , a_     )							->				int:


    """simple docstring"""
    UpperCAmelCase													=	ResNetModel(config=a_     )
    model.to(a_     )
    model.eval()
    UpperCAmelCase													=	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 // 3_2, self.image_size // 3_2)   , )
  def 						snake_case_			(     self   , a_   , a_   , a_     )							->				List[str]:


    """simple docstring"""
    UpperCAmelCase													=	self.num_labels
    UpperCAmelCase													=	ResNetForImageClassification(a_     )
    model.to(a_     )
    model.eval()
    UpperCAmelCase													=	model(a_   , labels=a_     )
    self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.num_labels)     )
  def 						snake_case_			(     self   , a_   , a_   , a_     )							->				Optional[Any]:


    """simple docstring"""
    UpperCAmelCase													=	ResNetBackbone(config=a_     )
    model.to(a_     )
    model.eval()
    UpperCAmelCase													=	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													=	None
    UpperCAmelCase													=	ResNetBackbone(config=a_     )
    model.to(a_     )
    model.eval()
    UpperCAmelCase													=	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     )							->				Dict:


    """simple docstring"""
    UpperCAmelCase													=	self.prepare_config_and_inputs()
    UpperCAmelCase							,      UpperCAmelCase							,      UpperCAmelCase													=	config_and_inputs
    UpperCAmelCase													=	{'pixel_values': pixel_values}
    return config, inputs_dict




@require_torch
class        lowercase_	(		a ,       a ,       unittest.TestCase ):

  '''simple docstring'''





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

  __lowerCAmelCase					: Any      =   True
  __lowerCAmelCase					: Union[str, Any]      =   False
  __lowerCAmelCase					: str      =   False
  __lowerCAmelCase					: List[Any]      =   False
  __lowerCAmelCase					: str      =   False
  def 						snake_case_			(     self     )							->				Any:


    """simple docstring"""
    UpperCAmelCase													=	ResNetModelTester(self     )
    UpperCAmelCase													=	ConfigTester(self   , config_class=a_   , has_text_modality=a_     )
  def 						snake_case_			(     self     )							->				Dict:


    """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 						snake_case_			(     self     )							->				str:


    """simple docstring"""
    return
  @unittest.skip(reason='ResNet does not use inputs_embeds'     )
  def 						snake_case_			(     self     )							->				int:


    """simple docstring"""
    pass
  @unittest.skip(reason='ResNet does not support input and output embeddings'     )
  def 						snake_case_			(     self     )							->				Any:


    """simple docstring"""
    pass
  def 						snake_case_			(     self     )							->				Any:


    """simple docstring"""
    UpperCAmelCase							,      UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs_for_common()

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

      UpperCAmelCase													=	['pixel_values']
      self.assertListEqual(arg_names[:1]   , a_     )
  def 						snake_case_			(     self     )							->				str:


    """simple docstring"""
    UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*a_     )
  def 						snake_case_			(     self     )							->				str:


    """simple docstring"""
    UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_backbone(*a_     )
  def 						snake_case_			(     self     )							->				str:


    """simple docstring"""
    UpperCAmelCase							,      UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
      UpperCAmelCase													=	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     )							->				Any:


    """simple docstring"""
    def check_hidden_states_output(a_   , a_   , a_     ):
      UpperCAmelCase													=	model_class(a_     )
      model.to(a_     )
      model.eval()

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

      UpperCAmelCase													=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

      UpperCAmelCase													=	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													=	self.model_tester.prepare_config_and_inputs_for_common()
    UpperCAmelCase													=	['basic', 'bottleneck']
    for model_class in self.all_model_classes:
      for layer_type in layers_type:
        UpperCAmelCase													=	layer_type
        UpperCAmelCase													=	True
        check_hidden_states_output(a_   , a_   , a_     )

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        UpperCAmelCase													=	True

        check_hidden_states_output(a_   , a_   , a_     )
  @unittest.skip(reason='ResNet does not use feedforward chunking'     )
  def 						snake_case_			(     self     )							->				Tuple:


    """simple docstring"""
    pass
  def 						snake_case_			(     self     )							->				Tuple:


    """simple docstring"""
    UpperCAmelCase													=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*a_     )





  @slow
  def 						snake_case_			(     self     )							->				Dict:


    """simple docstring"""
    for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      UpperCAmelCase													=	ResNetModel.from_pretrained(a_     )
      self.assertIsNotNone(a_     )




def       lowerCamelCase__		(						):
  UpperCAmelCase													=	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     )							->				Dict:


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





  @slow
  def 						snake_case_			(     self     )							->				Optional[int]:


    """simple docstring"""
    UpperCAmelCase													=	ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     ).to(a_     )

    UpperCAmelCase													=	self.default_image_processor
    UpperCAmelCase													=	prepare_img()
    UpperCAmelCase													=	image_processor(images=a_   , return_tensors='pt'     ).to(a_     )

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

    # verify the logits
    UpperCAmelCase													=	torch.Size((1, 1_0_0_0)     )
    self.assertEqual(outputs.logits.shape   , a_     )

    UpperCAmelCase													=	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_	(		a ,       unittest.TestCase ):

  '''simple docstring'''





  __lowerCAmelCase					: int      =   (ResNetBackbone,) if is_torch_available() else ()
  __lowerCAmelCase					: Optional[Any]      =   False
  __lowerCAmelCase					: Any      =   ResNetConfig
  def 						snake_case_			(     self     )							->				List[Any]:


    """simple docstring"""
    UpperCAmelCase													=	ResNetModelTester(self     )





'''simple docstring'''




_a				: Tuple 							=						'\n# Diffusers installation\n! pip install diffusers transformers datasets accelerate\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/diffusers.git\n'

_a				: Tuple 							=						[{'type': 'code', 'content': INSTALL_CONTENT}]


