

"""simple docstring"""






import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()







class 	__UpperCamelCase    (    lowercase__							,							lowercase__							,							unittest.TestCase						):
  _UpperCAmelCase          =		AutoencoderKL
  _UpperCAmelCase          =		"sample"
  _UpperCAmelCase          =		1E-2

  @property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[int]  =    4
      _lowerCAmelCase       :   List[str]  =    3
      _lowerCAmelCase       :   str  =    (32, 32)

      _lowerCAmelCase       :   List[Any]  =    floats_tensor((batch_size, num_channels) + sizes      ).to(_A      )

      return {"sample": image}

  @property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      return (3, 32, 32)

  @property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      return (3, 32, 32)

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   int  =    {
          "block_out_channels": [32, 64],
          "in_channels": 3,
          "out_channels": 3,
          "down_block_types": ["DownEncoderBlock2D", "DownEncoderBlock2D"],
          "up_block_types": ["UpDecoderBlock2D", "UpDecoderBlock2D"],
          "latent_channels": 4,
      }
      _lowerCAmelCase       :   List[str]  =    self.dummy_input
      return init_dict, inputs_dict

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      pass

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      pass

  @unittest.skipIf(torch_device == 'mps'    ,'Gradient checkpointing skipped on MPS'      )
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   int  =    self.prepare_init_args_and_inputs_for_common()
      _lowerCAmelCase       :   List[Any]  =    self.model_class(**_A      )
      model.to(_A      )

      assert not model.is_gradient_checkpointing and model.training

      _lowerCAmelCase       :   List[str]  =    model(**_A      ).sample
      # run the backwards pass on the model. For backwards pass, for simplicity purpose,
      # we won't calculate the loss and rather backprop on out.sum()
      model.zero_grad()

      _lowerCAmelCase       :   Dict  =    torch.randn_like(_A      )
      _lowerCAmelCase       :   Optional[int]  =    (out - labels).mean()
      loss.backward()

      # re-instantiate the model now enabling gradient checkpointing
      _lowerCAmelCase       :   Optional[int]  =    self.model_class(**_A      )
      # clone model
      model_a.load_state_dict(model.state_dict()      )
      model_a.to(_A      )
      model_a.enable_gradient_checkpointing()

      assert model_a.is_gradient_checkpointing and model_a.training

      _lowerCAmelCase       :   Tuple  =    model_a(**_A      ).sample
      # run the backwards pass on the model. For backwards pass, for simplicity purpose,
      # we won't calculate the loss and rather backprop on out.sum()
      model_a.zero_grad()
      _lowerCAmelCase       :   int  =    (out_a - labels).mean()
      loss_a.backward()

      # compare the output and parameters gradients
      self.assertTrue((loss - loss_a).abs() < 1E-5      )
      _lowerCAmelCase       :   Dict  =    dict(model.named_parameters()      )
      _lowerCAmelCase       :   Union[str, Any]  =    dict(model_a.named_parameters()      )
      for name, param in named_params.items():
          self.assertTrue(torch_all_close(param.grad.data    ,named_params_a[name].grad.data    ,atol=5E-5      )      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Dict  =    AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'    ,output_loading_info=_A      )
      self.assertIsNotNone(_A      )
      self.assertEqual(len(loading_info['missing_keys']      )    ,0      )

      model.to(_A      )
      _lowerCAmelCase       :   Union[str, Any]  =    model(**self.dummy_input      )

      assert image is not None, "Make sure output is not None"







  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[int]  =    AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'      )
      _lowerCAmelCase       :   int  =    model.to(_A      )
      model.eval()

      if torch_device == "mps":
          _lowerCAmelCase       :   List[Any]  =    torch.manual_seed(0      )
      else:
          _lowerCAmelCase       :   Optional[Any]  =    torch.Generator(device=_A      ).manual_seed(0      )

      _lowerCAmelCase       :   Dict  =    torch.randn(
          1    ,model.config.in_channels    ,model.config.sample_size    ,model.config.sample_size    ,generator=torch.manual_seed(0      )    ,)
      _lowerCAmelCase       :   List[str]  =    image.to(_A      )
      with torch.no_grad():
          _lowerCAmelCase       :   Optional[Any]  =    model(_A    ,sample_posterior=_A    ,generator=_A      ).sample

      _lowerCAmelCase       :   Optional[int]  =    output[0, -1, -3:, -3:].flatten().cpu()

      # Since the VAE Gaussian prior's generator is seeded on the appropriate device,
      # the expected output slices are not the same for CPU and GPU.
      if torch_device == "mps":
          _lowerCAmelCase       :   List[Any]  =    torch.tensor(
              [
                  -4.0078E-01,
                  -3.8323E-04,
                  -1.2681E-01,
                  -1.1462E-01,
                  2.0095E-01,
                  1.0893E-01,
                  -8.8247E-02,
                  -3.0361E-01,
                  -9.8644E-03,
              ]      )
      elif torch_device == "cpu":
          _lowerCAmelCase       :   Optional[Any]  =    torch.tensor(
              [-0.1_3_5_2, 0.0_8_7_8, 0.0_4_1_9, -0.0_8_1_8, -0.1_0_6_9, 0.0_6_8_8, -0.1_4_5_8, -0.4_4_4_6, -0.0_0_2_6]      )
      else:
          _lowerCAmelCase       :   Any  =    torch.tensor(
              [-0.2_4_2_1, 0.4_6_4_2, 0.2_5_0_7, -0.0_4_3_8, 0.0_6_8_2, 0.3_1_6_0, -0.2_0_1_8, -0.0_7_2_7, 0.2_4_8_5]      )

      self.assertTrue(torch_all_close(_A    ,_A    ,rtol=1E-2      )      )







@slow
class 	__UpperCamelCase    (    unittest.TestCase						):

  def __lowerCamelCase		(		self    ,_A    ,_A      ):
      '''simple docstring'''

      return F"""gaussian_noise_s={seed}_shape={'_'.join([str(_A      ) for s in shape]      )}.npy"""

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()

  def __lowerCamelCase		(		self    ,_A=0    ,_A=(4, 3, 512, 512)    ,_A=False      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    torch.floataa if fpaa else torch.floataa
      _lowerCAmelCase       :   Any  =    torch.from_numpy(load_hf_numpy(self.get_file_format(_A    ,_A      )      )      ).to(_A      ).to(_A      )
      return image

  def __lowerCamelCase		(		self    ,_A="CompVis/stable-diffusion-v1-4"    ,_A=False      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[Any]  =    "fp16" if fpaa else None
      _lowerCAmelCase       :   str  =    torch.floataa if fpaa else torch.floataa

      _lowerCAmelCase       :   Union[str, Any]  =    AutoencoderKL.from_pretrained(
          _A    ,subfolder='vae'    ,torch_dtype=_A    ,revision=_A    ,)
      model.to(_A      ).eval()

      return model

  def __lowerCamelCase		(		self    ,_A=0      ):
      '''simple docstring'''

      if torch_device == "mps":
          return torch.manual_seed(_A      )
      return torch.Generator(device=_A      ).manual_seed(_A      )

  @parameterized.expand(
      [
          # fmt: off
          [33, [-0.1_6_0_3, 0.9_8_7_8, -0.0_4_9_5, -0.0_7_9_0, -0.2_7_0_9, 0.8_3_7_5, -0.2_0_6_0, -0.0_8_2_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
          [47, [-0.2_3_7_6, 0.1_1_6_8, 0.1_3_3_2, -0.4_8_4_0, -0.2_5_0_8, -0.0_7_9_1, -0.0_4_9_3, -0.4_0_8_9], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
          # fmt: on
      ]      )
  def __lowerCamelCase		(		self    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Dict  =    self.get_sd_vae_model()
      _lowerCAmelCase       :   List[str]  =    self.get_sd_image(_A      )
      _lowerCAmelCase       :   List[Any]  =    self.get_generator(_A      )

      with torch.no_grad():
          _lowerCAmelCase       :   List[str]  =    model(_A    ,generator=_A    ,sample_posterior=_A      ).sample

      assert sample.shape == image.shape

      _lowerCAmelCase       :   Dict  =    sample[-1, -2:, -2:, :2].flatten().float().cpu()
      _lowerCAmelCase       :   Optional[int]  =    torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice      )

      assert torch_all_close(_A    ,_A    ,atol=3E-3      )

  @parameterized.expand(
      [
          # fmt: off
          [33, [-0.0_5_1_3, 0.0_2_8_9, 1.3_7_9_9, 0.2_1_6_6, -0.2_5_7_3, -0.0_8_7_1, 0.5_1_0_3, -0.0_9_9_9]],
          [47, [-0.4_1_2_8, -0.1_3_2_0, -0.3_7_0_4, 0.1_9_6_5, -0.4_1_1_6, -0.2_3_3_2, -0.3_3_4_0, 0.2_2_4_7]],
          # fmt: on
      ]      )
  @require_torch_gpu
  def __lowerCamelCase		(		self    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   int  =    self.get_sd_vae_model(fpaa=_A      )
      _lowerCAmelCase       :   Optional[int]  =    self.get_sd_image(_A    ,fpaa=_A      )
      _lowerCAmelCase       :   Optional[Any]  =    self.get_generator(_A      )

      with torch.no_grad():
          _lowerCAmelCase       :   Optional[Any]  =    model(_A    ,generator=_A    ,sample_posterior=_A      ).sample

      assert sample.shape == image.shape

      _lowerCAmelCase       :   Union[str, Any]  =    sample[-1, -2:, :2, -2:].flatten().float().cpu()
      _lowerCAmelCase       :   int  =    torch.tensor(_A      )

      assert torch_all_close(_A    ,_A    ,atol=1E-2      )

  @parameterized.expand(
      [
          # fmt: off
          [33, [-0.1_6_0_9, 0.9_8_6_6, -0.0_4_8_7, -0.0_7_7_7, -0.2_7_1_6, 0.8_3_6_8, -0.2_0_5_5, -0.0_8_1_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
          [47, [-0.2_3_7_7, 0.1_1_4_7, 0.1_3_3_3, -0.4_8_4_1, -0.2_5_0_6, -0.0_8_0_5, -0.0_4_9_1, -0.4_0_8_5], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
          # fmt: on
      ]      )
  def __lowerCamelCase		(		self    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Tuple  =    self.get_sd_vae_model()
      _lowerCAmelCase       :   Dict  =    self.get_sd_image(_A      )

      with torch.no_grad():
          _lowerCAmelCase       :   Optional[int]  =    model(_A      ).sample

      assert sample.shape == image.shape

      _lowerCAmelCase       :   Optional[Any]  =    sample[-1, -2:, -2:, :2].flatten().float().cpu()
      _lowerCAmelCase       :   List[str]  =    torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice      )

      assert torch_all_close(_A    ,_A    ,atol=3E-3      )

  @parameterized.expand(
      [
          # fmt: off
          [13, [-0.2_0_5_1, -0.1_8_0_3, -0.2_3_1_1, -0.2_1_1_4, -0.3_2_9_2, -0.3_5_7_4, -0.2_9_5_3, -0.3_3_2_3]],
          [37, [-0.2_6_3_2, -0.2_6_2_5, -0.2_1_9_9, -0.2_7_4_1, -0.4_5_3_9, -0.4_9_9_0, -0.3_7_2_0, -0.4_9_2_5]],
          # fmt: on
      ]      )
  @require_torch_gpu
  def __lowerCamelCase		(		self    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    self.get_sd_vae_model()
      _lowerCAmelCase       :   List[Any]  =    self.get_sd_image(_A    ,shape=(3, 4, 64, 64)      )

      with torch.no_grad():
          _lowerCAmelCase       :   str  =    model.decode(_A      ).sample

      assert list(sample.shape      ) == [3, 3, 512, 512]

      _lowerCAmelCase       :   Tuple  =    sample[-1, -2:, :2, -2:].flatten().cpu()
      _lowerCAmelCase       :   Tuple  =    torch.tensor(_A      )

      assert torch_all_close(_A    ,_A    ,atol=1E-3      )

  @parameterized.expand(
      [
          # fmt: off
          [27, [-0.0_3_6_9, 0.0_2_0_7, -0.0_7_7_6, -0.0_6_8_2, -0.1_7_4_7, -0.1_9_3_0, -0.1_4_6_5, -0.2_0_3_9]],
          [16, [-0.1_6_2_8, -0.2_1_3_4, -0.2_7_4_7, -0.2_6_4_2, -0.3_7_7_4, -0.4_4_0_4, -0.3_6_8_7, -0.4_2_7_7]],
          # fmt: on
      ]      )
  @require_torch_gpu
  def __lowerCamelCase		(		self    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Any  =    self.get_sd_vae_model(fpaa=_A      )
      _lowerCAmelCase       :   Optional[int]  =    self.get_sd_image(_A    ,shape=(3, 4, 64, 64)    ,fpaa=_A      )

      with torch.no_grad():
          _lowerCAmelCase       :   Union[str, Any]  =    model.decode(_A      ).sample

      assert list(sample.shape      ) == [3, 3, 512, 512]

      _lowerCAmelCase       :   Any  =    sample[-1, -2:, :2, -2:].flatten().float().cpu()
      _lowerCAmelCase       :   Any  =    torch.tensor(_A      )

      assert torch_all_close(_A    ,_A    ,atol=5E-3      )

  @parameterized.expand([(13,), (16,), (27,)]      )
  @require_torch_gpu
  @unittest.skipIf(not is_xformers_available()    ,reason='xformers is not required when using PyTorch 2.0.'      )
  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[Any]  =    self.get_sd_vae_model(fpaa=_A      )
      _lowerCAmelCase       :   Union[str, Any]  =    self.get_sd_image(_A    ,shape=(3, 4, 64, 64)    ,fpaa=_A      )

      with torch.no_grad():
          _lowerCAmelCase       :   List[str]  =    model.decode(_A      ).sample

      model.enable_xformers_memory_efficient_attention()
      with torch.no_grad():
          _lowerCAmelCase       :   Tuple  =    model.decode(_A      ).sample

      assert list(sample.shape      ) == [3, 3, 512, 512]

      assert torch_all_close(_A    ,_A    ,atol=1E-1      )

  @parameterized.expand([(13,), (16,), (37,)]      )
  @require_torch_gpu
  @unittest.skipIf(not is_xformers_available()    ,reason='xformers is not required when using PyTorch 2.0.'      )
  def __lowerCamelCase		(		self    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    self.get_sd_vae_model()
      _lowerCAmelCase       :   int  =    self.get_sd_image(_A    ,shape=(3, 4, 64, 64)      )

      with torch.no_grad():
          _lowerCAmelCase       :   int  =    model.decode(_A      ).sample

      model.enable_xformers_memory_efficient_attention()
      with torch.no_grad():
          _lowerCAmelCase       :   Tuple  =    model.decode(_A      ).sample

      assert list(sample.shape      ) == [3, 3, 512, 512]

      assert torch_all_close(_A    ,_A    ,atol=1E-2      )







  @parameterized.expand(
      [
          # fmt: off
          [33, [-0.3_0_0_1, 0.0_9_1_8, -2.6_9_8_4, -3.9_7_2_0, -3.2_0_9_9, -5.0_3_5_3, 1.7_3_3_8, -0.2_0_6_5, 3.4_2_6_7]],
          [47, [-1.5_0_3_0, -4.3_8_7_1, -6.0_3_5_5, -9.1_1_5_7, -1.6_6_6_1, -2.7_8_5_3, 2.1_6_0_7, -5.0_8_2_3, 2.5_6_3_3]],
          # fmt: on
      ]      )
  def __lowerCamelCase		(		self    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[int]  =    self.get_sd_vae_model()
      _lowerCAmelCase       :   List[str]  =    self.get_sd_image(_A      )
      _lowerCAmelCase       :   List[str]  =    self.get_generator(_A      )

      with torch.no_grad():
          _lowerCAmelCase       :   Optional[int]  =    model.encode(_A      ).latent_dist
          _lowerCAmelCase       :   Tuple  =    dist.sample(generator=_A      )

      assert list(sample.shape      ) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

      _lowerCAmelCase       :   List[Any]  =    sample[0, -1, -3:, -3:].flatten().cpu()
      _lowerCAmelCase       :   Union[str, Any]  =    torch.tensor(_A      )

      _lowerCAmelCase       :   Optional[Any]  =    3E-3 if torch_device != "mps" else 1E-2
      assert torch_all_close(_A    ,_A    ,atol=_A      )








"""simple docstring"""






from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFResNetForImageClassification, TFResNetModel
 from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor







class 	__UpperCamelCase    :

  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    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    parent
      _lowerCAmelCase       :   int  =    batch_size
      _lowerCAmelCase       :   int  =    image_size
      _lowerCAmelCase       :   List[str]  =    num_channels
      _lowerCAmelCase       :   Optional[int]  =    embeddings_size
      _lowerCAmelCase       :   Optional[int]  =    hidden_sizes
      _lowerCAmelCase       :   str  =    depths
      _lowerCAmelCase       :   str  =    is_training
      _lowerCAmelCase       :   int  =    use_labels
      _lowerCAmelCase       :   Optional[int]  =    hidden_act
      _lowerCAmelCase       :   Optional[int]  =    num_labels
      _lowerCAmelCase       :   Dict  =    scope
      _lowerCAmelCase       :   Union[str, Any]  =    len(_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[int]  =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

      _lowerCAmelCase       :   Union[str, Any]  =    self.get_config()

      return config, pixel_values, labels

  def __lowerCamelCase		(		self      ):
      '''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    ,image_size=self.image_size    ,)

  def __lowerCamelCase		(		self    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[Any]  =    TFResNetModel(config=_A      )
      _lowerCAmelCase       :   List[str]  =    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 __lowerCamelCase		(		self    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Any  =    self.num_labels
      _lowerCAmelCase       :   Dict  =    TFResNetForImageClassification(_A      )
      _lowerCAmelCase       :   int  =    model(_A    ,labels=_A      )
      self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.num_labels)      )







  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    self.prepare_config_and_inputs()
      _lowerCAmelCase,					_lowerCAmelCase,					_lowerCAmelCase       :   Tuple  =    config_and_inputs
      _lowerCAmelCase       :   Any  =    {'pixel_values': pixel_values}
      return config, inputs_dict







@require_tf
class 	__UpperCamelCase    (    a__							,							a__							,							unittest.TestCase						):
  _UpperCAmelCase          =		(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
  _UpperCAmelCase          =		(
      {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
      if is_tf_available()
      else {}
  )

  _UpperCAmelCase          =		False
  _UpperCAmelCase          =		False
  _UpperCAmelCase          =		False
  _UpperCAmelCase          =		False
  _UpperCAmelCase          =		False

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[str]  =    TFResNetModelTester(self      )
      _lowerCAmelCase       :   List[str]  =    ConfigTester(self    ,config_class=_A    ,has_text_modality=_A      )

  def __lowerCamelCase		(		self      ):
      '''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      ):
      '''simple docstring'''

      return

  @unittest.skip(reason='ResNet does not use inputs_embeds'      )
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      pass

  @unittest.skip(reason='ResNet does not support input and output embeddings'      )
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      pass

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase,					_lowerCAmelCase       :   Optional[int]  =    self.model_tester.prepare_config_and_inputs_for_common()

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

          _lowerCAmelCase       :   str  =    ['pixel_values']
          self.assertListEqual(arg_names[:1]    ,_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Dict  =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      def check_hidden_states_output(_A    ,_A    ,_A      ):
          _lowerCAmelCase       :   int  =    model_class(_A      )
          _lowerCAmelCase       :   int  =    model(**self._prepare_for_class(_A    ,_A      )      )

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

          _lowerCAmelCase       :   int  =    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]    ,)

      _lowerCAmelCase,					_lowerCAmelCase       :   List[str]  =    self.model_tester.prepare_config_and_inputs_for_common()
      _lowerCAmelCase       :   Any  =    ['basic', 'bottleneck']
      for model_class in self.all_model_classes:
          for layer_type in layers_type:
              _lowerCAmelCase       :   Optional[int]  =    layer_type
              _lowerCAmelCase       :   Tuple  =    True
              check_hidden_states_output(_A    ,_A    ,_A      )

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

              check_hidden_states_output(_A    ,_A    ,_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_A      )







  @slow
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          _lowerCAmelCase       :   Optional[Any]  =    TFResNetModel.from_pretrained(_A      )
          self.assertIsNotNone(_A      )





def 		lowerCamelCase__		(					):

    '''simple docstring'''



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







@require_tf
@require_vision
class 	__UpperCamelCase    (    unittest.TestCase						):

  @cached_property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

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







  @slow
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )

      _lowerCAmelCase       :   Tuple  =    self.default_image_processor
      _lowerCAmelCase       :   Optional[Any]  =    prepare_img()
      _lowerCAmelCase       :   int  =    image_processor(images=_A    ,return_tensors='tf'      )

      # forward pass
      _lowerCAmelCase       :   int  =    model(**_A      )

      # verify the logits
      _lowerCAmelCase       :   Optional[Any]  =    tf.TensorShape((1, 1000)      )
      self.assertEqual(outputs.logits.shape    ,_A      )

      _lowerCAmelCase       :   Any  =    tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]      )

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





