'''simple docstring'''

import types
from typing import List, Optional, Tuple, Union

import torch
from transformers import CLIPTextModelWithProjection, CLIPTokenizer
from transformers.models.clip.modeling_clip import CLIPTextModelOutput

from diffusers.models import PriorTransformer
from diffusers.pipelines import DiffusionPipeline, StableDiffusionImageVariationPipeline
from diffusers.schedulers import UnCLIPScheduler
from diffusers.utils import logging, randn_tensor


_lowerCamelCase :				List[str]														= logging.get_logger(__name__)  # pylint: disable=invalid-name



def  _lowerCAmelCase				(				self			,      __a			,      __a			,      __a			,      __a      )  ->      str:
     '''simple docstring'''







     _UpperCamelCase  :Dict       =image.to(device=__a      )
     _UpperCamelCase  :Union[str, Any]       =image  # take image as image_embeddings
     _UpperCamelCase  :Dict       =image_embeddings.unsqueeze(1      )

     # duplicate image embeddings for each generation per prompt, using mps friendly method
     _UpperCamelCase       ,      _UpperCamelCase       ,      _UpperCamelCase  :str       =image_embeddings.shape
     _UpperCamelCase  :int       =image_embeddings.repeat(1			,      __a			,      1      )
     _UpperCamelCase  :int       =image_embeddings.view(bs_embed * num_images_per_prompt			,      __a			,      -1      )

     if do_classifier_free_guidance:
          _UpperCamelCase  :str       =torch.zeros_like(__a      )

          # For classifier free guidance, we need to do two forward passes.
          # Here we concatenate the unconditional and text embeddings into a single batch
          # to avoid doing two forward passes
          _UpperCamelCase  :List[Any]       =torch.cat([uncond_embeddings, image_embeddings]      )

     return image_embeddings




class    lowerCamelCase__  (   __snake_case     ):



   def __init__(    self					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__ = None					,      )				->     Union[str, Any]:
        """simple docstring"""





        super().__init__()

        _UpperCamelCase  :Any       ={"""image_encoder""": None} if decoder_pipe_kwargs is None else decoder_pipe_kwargs

        _UpperCamelCase  :List[Any]       =decoder_pipe_kwargs.get("""torch_dtype"""					,      lowerCAmelCase__     ) or prior.dtype

        _UpperCamelCase  :Union[str, Any]       =StableDiffusionImageVariationPipeline.from_pretrained(
            """lambdalabs/sd-image-variations-diffusers"""					,      **lowerCAmelCase__     )

        # replace `_encode_image` method
        _UpperCamelCase  :Tuple       =types.MethodType(_encode_image					,      self.decoder_pipe     )

        self.register_modules(
            prior=lowerCAmelCase__					,      tokenizer=lowerCAmelCase__					,      text_encoder=lowerCAmelCase__					,      prior_scheduler=lowerCAmelCase__					,      )



   def  _UpperCamelCase		(    self					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__ = None					,      lowerCAmelCase__ = None					,      )				->     str:
        """simple docstring"""





        if text_model_output is None:
             _UpperCamelCase  :Optional[int]       =len(lowerCAmelCase__     ) if isinstance(lowerCAmelCase__					,      lowerCAmelCase__     ) else 1
             # get prompt text embeddings
             _UpperCamelCase  :Any       =self.tokenizer(
                 lowerCAmelCase__					,      padding="""max_length"""					,      max_length=self.tokenizer.model_max_length					,      return_tensors="""pt"""					,      )
             _UpperCamelCase  :List[str]       =text_inputs.input_ids
             _UpperCamelCase  :Tuple       =text_inputs.attention_mask.bool().to(lowerCAmelCase__     )

             if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
                  _UpperCamelCase  :Any       =self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]     )
                  logger.warning(
                      """The following part of your input was truncated because CLIP can only handle sequences up to"""
                      f''' {self.tokenizer.model_max_length} tokens: {removed_text}'''     )
                  _UpperCamelCase  :Tuple       =text_input_ids[:, : self.tokenizer.model_max_length]

             _UpperCamelCase  :str       =self.text_encoder(text_input_ids.to(lowerCAmelCase__     )     )

             _UpperCamelCase  :str       =text_encoder_output.text_embeds
             _UpperCamelCase  :Any       =text_encoder_output.last_hidden_state

        else:
             _UpperCamelCase  :Dict       =text_model_output[0].shape[0]
             _UpperCamelCase       ,      _UpperCamelCase  :Dict       =text_model_output[0], text_model_output[1]
             _UpperCamelCase  :Tuple       =text_attention_mask

        _UpperCamelCase  :Optional[Any]       =text_embeddings.repeat_interleave(lowerCAmelCase__					,      dim=0     )
        _UpperCamelCase  :Optional[int]       =text_encoder_hidden_states.repeat_interleave(lowerCAmelCase__					,      dim=0     )
        _UpperCamelCase  :List[Any]       =text_mask.repeat_interleave(lowerCAmelCase__					,      dim=0     )

        if do_classifier_free_guidance:
             _UpperCamelCase  :Optional[int]       =[""""""] * batch_size

             _UpperCamelCase  :Dict       =self.tokenizer(
                 lowerCAmelCase__					,      padding="""max_length"""					,      max_length=self.tokenizer.model_max_length					,      truncation=lowerCAmelCase__					,      return_tensors="""pt"""					,      )
             _UpperCamelCase  :Any       =uncond_input.attention_mask.bool().to(lowerCAmelCase__     )
             _UpperCamelCase  :Union[str, Any]       =self.text_encoder(uncond_input.input_ids.to(lowerCAmelCase__     )     )

             _UpperCamelCase  :Optional[int]       =uncond_embeddings_text_encoder_output.text_embeds
             _UpperCamelCase  :Optional[Any]       =uncond_embeddings_text_encoder_output.last_hidden_state

             # duplicate unconditional embeddings for each generation per prompt, using mps friendly method

             _UpperCamelCase  :List[Any]       =uncond_embeddings.shape[1]
             _UpperCamelCase  :Dict       =uncond_embeddings.repeat(1					,      lowerCAmelCase__     )
             _UpperCamelCase  :Optional[int]       =uncond_embeddings.view(batch_size * num_images_per_prompt					,      lowerCAmelCase__     )

             _UpperCamelCase  :Optional[Any]       =uncond_text_encoder_hidden_states.shape[1]
             _UpperCamelCase  :List[Any]       =uncond_text_encoder_hidden_states.repeat(1					,      lowerCAmelCase__					,      1     )
             _UpperCamelCase  :Optional[Any]       =uncond_text_encoder_hidden_states.view(
                 batch_size * num_images_per_prompt					,      lowerCAmelCase__					,      -1     )
             _UpperCamelCase  :Tuple       =uncond_text_mask.repeat_interleave(lowerCAmelCase__					,      dim=0     )

             # done duplicates

             # For classifier free guidance, we need to do two forward passes.
             # Here we concatenate the unconditional and text embeddings into a single batch
             # to avoid doing two forward passes
             _UpperCamelCase  :Any       =torch.cat([uncond_embeddings, text_embeddings]     )
             _UpperCamelCase  :Any       =torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states]     )

             _UpperCamelCase  :Dict       =torch.cat([uncond_text_mask, text_mask]     )

        return text_embeddings, text_encoder_hidden_states, text_mask



   @property
   def  _UpperCamelCase		(    self     )				->     Optional[Any]:
        """simple docstring"""





        if self.device != torch.device("""meta"""     ) or not hasattr(self.prior					,      """_hf_hook"""     ):
             return self.device
        for module in self.prior.modules():
             if (
                 hasattr(lowerCAmelCase__					,      """_hf_hook"""     )
                 and hasattr(module._hf_hook					,      """execution_device"""     )
                 and module._hf_hook.execution_device is not None
             ):
                  return torch.device(module._hf_hook.execution_device     )
        return self.device



   def  _UpperCamelCase		(    self					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__     )				->     List[Any]:
        """simple docstring"""





        if latents is None:
             _UpperCamelCase  :Optional[int]       =randn_tensor(lowerCAmelCase__					,      generator=lowerCAmelCase__					,      device=lowerCAmelCase__					,      dtype=lowerCAmelCase__     )
        else:
             if latents.shape != shape:
                  raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {shape}'''     )
             _UpperCamelCase  :List[str]       =latents.to(lowerCAmelCase__     )

        _UpperCamelCase  :Any       =latents * scheduler.init_noise_sigma
        return latents



   def  _UpperCamelCase		(    self					,      lowerCAmelCase__ = None     )				->     int:
        """simple docstring"""





        self.decoder_pipe.to(lowerCAmelCase__     )
        super().to(lowerCAmelCase__     )




   @torch.no_grad()
   def __call__(    self					,      lowerCAmelCase__ = None					,      lowerCAmelCase__ = None					,      lowerCAmelCase__ = None					,      lowerCAmelCase__ = 1					,      lowerCAmelCase__ = 25					,      lowerCAmelCase__ = None					,      lowerCAmelCase__ = None					,      lowerCAmelCase__ = None					,      lowerCAmelCase__ = None					,      lowerCAmelCase__ = 4.0					,      lowerCAmelCase__ = 8.0					,      lowerCAmelCase__ = 50					,      lowerCAmelCase__ = 1					,      lowerCAmelCase__ = 0.0					,      lowerCAmelCase__ = "pil"					,      lowerCAmelCase__ = True					,      )				->     Dict:
        """simple docstring"""





        if prompt is not None:
             if isinstance(lowerCAmelCase__					,      lowerCAmelCase__     ):
                  _UpperCamelCase  :List[Any]       =1
             elif isinstance(lowerCAmelCase__					,      lowerCAmelCase__     ):
                  _UpperCamelCase  :List[Any]       =len(lowerCAmelCase__     )
             else:
                  raise ValueError(f'''`prompt` has to be of type `str` or `list` but is {type(lowerCAmelCase__     )}'''     )
        else:
             _UpperCamelCase  :int       =text_model_output[0].shape[0]

        _UpperCamelCase  :List[str]       =self._execution_device

        _UpperCamelCase  :List[str]       =batch_size * num_images_per_prompt

        _UpperCamelCase  :Optional[Any]       =prior_guidance_scale > 1.0 or decoder_guidance_scale > 1.0

        _UpperCamelCase       ,      _UpperCamelCase       ,      _UpperCamelCase  :Optional[Any]       =self._encode_prompt(
            lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__     )

        # prior

        self.prior_scheduler.set_timesteps(lowerCAmelCase__					,      device=lowerCAmelCase__     )
        _UpperCamelCase  :Optional[Any]       =self.prior_scheduler.timesteps

        _UpperCamelCase  :int       =self.prior.config.embedding_dim

        _UpperCamelCase  :Union[str, Any]       =self.prepare_latents(
            (batch_size, embedding_dim)					,      text_embeddings.dtype					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__					,      self.prior_scheduler					,      )

        for i, t in enumerate(self.progress_bar(lowerCAmelCase__     )     ):
             # expand the latents if we are doing classifier free guidance
             _UpperCamelCase  :Optional[int]       =torch.cat([prior_latents] * 2     ) if do_classifier_free_guidance else prior_latents

             _UpperCamelCase  :Dict       =self.prior(
                 lowerCAmelCase__					,      timestep=lowerCAmelCase__					,      proj_embedding=lowerCAmelCase__					,      encoder_hidden_states=lowerCAmelCase__					,      attention_mask=lowerCAmelCase__					,      ).predicted_image_embedding

             if do_classifier_free_guidance:
                  _UpperCamelCase       ,      _UpperCamelCase  :Tuple       =predicted_image_embedding.chunk(2     )
                  _UpperCamelCase  :Dict       =predicted_image_embedding_uncond + prior_guidance_scale * (
                      predicted_image_embedding_text - predicted_image_embedding_uncond
                  )

             if i + 1 == prior_timesteps_tensor.shape[0]:
                  _UpperCamelCase  :Tuple       =None
             else:
                  _UpperCamelCase  :Optional[int]       =prior_timesteps_tensor[i + 1]

             _UpperCamelCase  :Tuple       =self.prior_scheduler.step(
                 lowerCAmelCase__					,      timestep=lowerCAmelCase__					,      sample=lowerCAmelCase__					,      generator=lowerCAmelCase__					,      prev_timestep=lowerCAmelCase__					,      ).prev_sample

        _UpperCamelCase  :Any       =self.prior.post_process_latents(lowerCAmelCase__     )

        _UpperCamelCase  :Tuple       =prior_latents

        _UpperCamelCase  :Tuple       =self.decoder_pipe(
            image=lowerCAmelCase__					,      height=lowerCAmelCase__					,      width=lowerCAmelCase__					,      num_inference_steps=lowerCAmelCase__					,      guidance_scale=lowerCAmelCase__					,      generator=lowerCAmelCase__					,      output_type=lowerCAmelCase__					,      return_dict=lowerCAmelCase__					,      num_images_per_prompt=lowerCAmelCase__					,      eta=lowerCAmelCase__					,      )
        return output







"""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     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE=3     ,    _SCREAMING_SNAKE_CASE=32     ,    _SCREAMING_SNAKE_CASE=3     ,    _SCREAMING_SNAKE_CASE=10     ,    _SCREAMING_SNAKE_CASE=[10, 20, 30, 40]     ,    _SCREAMING_SNAKE_CASE=[1, 1, 2, 1]     ,    _SCREAMING_SNAKE_CASE=True     ,    _SCREAMING_SNAKE_CASE=True     ,    _SCREAMING_SNAKE_CASE="relu"     ,    _SCREAMING_SNAKE_CASE=3     ,    _SCREAMING_SNAKE_CASE=None     ,    _SCREAMING_SNAKE_CASE=["stage2", "stage3", "stage4"]     ,    _SCREAMING_SNAKE_CASE=[2, 3, 4]     ,    )      ->	Union[str, Any]:




											"""simple docstring"""





											lowerCamelCase__					=parent
											lowerCamelCase__					=batch_size
											lowerCamelCase__					=image_size
											lowerCamelCase__					=num_channels
											lowerCamelCase__					=embeddings_size
											lowerCamelCase__					=hidden_sizes
											lowerCamelCase__					=depths
											lowerCamelCase__					=is_training
											lowerCamelCase__					=use_labels
											lowerCamelCase__					=hidden_act
											lowerCamelCase__					=num_labels
											lowerCamelCase__					=scope
											lowerCamelCase__					=len(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__					=out_features
											lowerCamelCase__					=out_indices






						def 		lowerCAmelCase (       self)      ->	Tuple:




											"""simple docstring"""





											lowerCamelCase__					=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

											lowerCamelCase__					=self.get_config()

											return config, pixel_values, labels






						def 		lowerCAmelCase (       self)      ->	int:




											"""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     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE)      ->	Union[str, Any]:




											"""simple docstring"""





											lowerCamelCase__					=ResNetModel(config=_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()
											lowerCamelCase__					=model(_SCREAMING_SNAKE_CASE)
											# 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     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE)      ->	List[Any]:




											"""simple docstring"""





											lowerCamelCase__					=self.num_labels
											lowerCamelCase__					=ResNetForImageClassification(_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()
											lowerCamelCase__					=model(_SCREAMING_SNAKE_CASE     ,    labels=_SCREAMING_SNAKE_CASE)
											self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.num_labels))






						def 		lowerCAmelCase (       self     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE)      ->	Union[str, Any]:




											"""simple docstring"""





											lowerCamelCase__					=ResNetBackbone(config=_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()
											lowerCamelCase__					=model(_SCREAMING_SNAKE_CASE)

											# 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__					=None
											lowerCamelCase__					=ResNetBackbone(config=_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()
											lowerCamelCase__					=model(_SCREAMING_SNAKE_CASE)

											# 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)      ->	Tuple:




											"""simple docstring"""





											lowerCamelCase__					=self.prepare_config_and_inputs()
											lowerCamelCase__					,  lowerCamelCase__					,  lowerCamelCase__					=config_and_inputs
											lowerCamelCase__					={'pixel_values': pixel_values}
											return config, inputs_dict




@require_torch
class 							__lowercase(							_UpperCamelCase    ,				_UpperCamelCase    ,				unittest.TestCase	):
						lowerCAmelCase_		:				List[Any]=							(
						    (
						        ResNetModel,
						        ResNetForImageClassification,
						        ResNetBackbone,
						    )
						    if is_torch_available()
						    else ()
						)
						lowerCAmelCase_		:				Optional[Any]=							(
						    {"""feature-extraction""": ResNetModel, """image-classification""": ResNetForImageClassification}
						    if is_torch_available()
						    else {}
						)

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






						def 		lowerCAmelCase (       self)      ->	List[str]:




											"""simple docstring"""





											lowerCamelCase__					=ResNetModelTester(self)
											lowerCamelCase__					=ConfigTester(self     ,    config_class=_SCREAMING_SNAKE_CASE     ,    has_text_modality=_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase (       self)      ->	Any:




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




											"""simple docstring"""





											return






						@unittest.skip(reason='ResNet does not use inputs_embeds')
						def 		lowerCAmelCase (       self)      ->	int:




											"""simple docstring"""





											pass






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




											"""simple docstring"""





											pass






						def 		lowerCAmelCase (       self)      ->	str:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.model_tester.prepare_config_and_inputs_for_common()

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

																lowerCamelCase__					=['pixel_values']
																self.assertListEqual(arg_names[:1]     ,    _SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase (       self)      ->	Any:




											"""simple docstring"""





											lowerCamelCase__					=self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase (       self)      ->	List[Any]:




											"""simple docstring"""





											lowerCamelCase__					=self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_backbone(*_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase (       self)      ->	List[str]:




											"""simple docstring"""





											lowerCamelCase__					,  lowerCamelCase__					=self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																lowerCamelCase__					=model_class(config=_SCREAMING_SNAKE_CASE)
																for name, module in model.named_modules():
																					if isinstance(_SCREAMING_SNAKE_CASE     ,    (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)      ->	List[str]:




											"""simple docstring"""





											def check_hidden_states_output(_SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE):
																lowerCamelCase__					=model_class(_SCREAMING_SNAKE_CASE)
																model.to(_SCREAMING_SNAKE_CASE)
																model.eval()

																with torch.no_grad():
																					lowerCamelCase__					=model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE))

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

																lowerCamelCase__					=self.model_tester.num_stages
																self.assertEqual(len(_SCREAMING_SNAKE_CASE)     ,    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__					=self.model_tester.prepare_config_and_inputs_for_common()
											lowerCamelCase__					=['basic', 'bottleneck']
											for model_class in self.all_model_classes:
																for layer_type in layers_type:
																					lowerCamelCase__					=layer_type
																					lowerCamelCase__					=True
																					check_hidden_states_output(_SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE)

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

																					check_hidden_states_output(_SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE     ,    _SCREAMING_SNAKE_CASE)






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




											"""simple docstring"""





											pass






						def 		lowerCAmelCase (       self)      ->	Dict:




											"""simple docstring"""





											lowerCamelCase__					=self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE)






						@slow
						def 		lowerCAmelCase (       self)      ->	int:




											"""simple docstring"""





											for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowerCamelCase__					=ResNetModel.from_pretrained(_SCREAMING_SNAKE_CASE)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE)




def     lowerCamelCase_					(	):
					lowerCamelCase__					=Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
					return image




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






						@cached_property
						def 		lowerCAmelCase (       self)      ->	Union[str, Any]:




											"""simple docstring"""





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






						@slow
						def 		lowerCAmelCase (       self)      ->	Any:




											"""simple docstring"""





											lowerCamelCase__					=ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(_SCREAMING_SNAKE_CASE)

											lowerCamelCase__					=self.default_image_processor
											lowerCamelCase__					=prepare_img()
											lowerCamelCase__					=image_processor(images=_SCREAMING_SNAKE_CASE     ,    return_tensors='pt').to(_SCREAMING_SNAKE_CASE)

											# forward pass
											with torch.no_grad():
																lowerCamelCase__					=model(**_SCREAMING_SNAKE_CASE)

											# verify the logits
											lowerCamelCase__					=torch.Size((1, 10_00))
											self.assertEqual(outputs.logits.shape     ,    _SCREAMING_SNAKE_CASE)

											lowerCamelCase__					=torch.tensor([-11.1069, -9.7877, -8.3777]).to(_SCREAMING_SNAKE_CASE)

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




@require_torch
class 							__lowercase(							_UpperCamelCase    ,				unittest.TestCase	):
						lowerCAmelCase_		:				Optional[Any]=							(ResNetBackbone,) if is_torch_available() else ()
						lowerCAmelCase_		:				Dict=							False
						lowerCAmelCase_		:				int=							ResNetConfig






						def 		lowerCAmelCase (       self)      ->	Optional[Any]:




											"""simple docstring"""





											lowerCamelCase__					=ResNetModelTester(self)