


import math
from collections import defaultdict
from typing import List, Optional, Tuple, Union

import numpy as np
import torch

from ..configuration_utils import ConfigMixin, register_to_config
from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_=0.999	,    lowerCAmelCase_="cosine"	,    )    ->List[str]:
   if alpha_transform_type == "cosine":

      def alpha_bar_fn(lowerCAmelCase_ ):
         return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2

   elif alpha_transform_type == "exp":

      def alpha_bar_fn(lowerCAmelCase_ ):
         return math.exp(t * -12.0 )

   else:
      raise ValueError(F"""Unsupported alpha_tranform_type: {alpha_transform_type}""" )

   UpperCAmelCase      					=  []
   for i in range(lowerCAmelCase_ ):
      UpperCAmelCase      					=  i / num_diffusion_timesteps
      UpperCAmelCase      					=  (i + 1) / num_diffusion_timesteps
      betas.append(min(1 - alpha_bar_fn(lowerCAmelCase_ ) / alpha_bar_fn(lowerCAmelCase_ )	,    lowerCAmelCase_ ) )
   return torch.tensor(lowerCAmelCase_	,    dtype=torch.floataa )







class 	__lowercase					(	__snake_case			,       __snake_case	):
      UpperCamelCase										=							[e.name for e in KarrasDiffusionSchedulers]
      UpperCamelCase										=							2





      @register_to_config
      def __init__(		self    :       int       ,							__lowerCamelCase    :       int = 1_0_0_0       ,							__lowerCamelCase    :       float = 0.00_085       ,							__lowerCamelCase    :       float = 0.012       ,							__lowerCamelCase    :       str = "linear"       ,							__lowerCamelCase    :       Optional[Union[np.ndarray, List[float]]] = None       ,							__lowerCamelCase    :       str = "epsilon"       ,							__lowerCamelCase    :       Optional[bool] = False       ,							__lowerCamelCase    :       Optional[bool] = False       ,							__lowerCamelCase    :       float = 1.0       ,							__lowerCamelCase    :       str = "linspace"       ,							__lowerCamelCase    :       int = 0       ,							)     -> Optional[int]:






         """simple docstring"""







         if trained_betas is not None:
            UpperCAmelCase      					=  torch.tensor(__lowerCamelCase       ,							dtype=torch.floataa							)
         elif beta_schedule == "linear":
            UpperCAmelCase      					=  torch.linspace(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase       ,							dtype=torch.floataa							)
         elif beta_schedule == "scaled_linear":
            # this schedule is very specific to the latent diffusion model.
            UpperCAmelCase      					=  (
                torch.linspace(beta_start**0.5       ,							beta_end**0.5       ,							__lowerCamelCase       ,							dtype=torch.floataa							) ** 2
            )
         elif beta_schedule == "squaredcos_cap_v2":
            # Glide cosine schedule
            UpperCAmelCase      					=  betas_for_alpha_bar(__lowerCamelCase       ,							alpha_transform_type="""cosine"""							)
         elif beta_schedule == "exp":
            UpperCAmelCase      					=  betas_for_alpha_bar(__lowerCamelCase       ,							alpha_transform_type="""exp"""							)
         else:
            raise NotImplementedError(F"""{beta_schedule} does is not implemented for {self.__class__}"""							)

         UpperCAmelCase      					=  1.0 - self.betas
         UpperCAmelCase      					=  torch.cumprod(self.alphas       ,							dim=0							)

         #  set all values
         self.set_timesteps(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)
         UpperCAmelCase      					=  use_karras_sigmas





      def 							_lowercase					(		self    :       Optional[int]       ,							__lowerCamelCase    :       List[Any]       ,							__lowerCamelCase    :       str=None							)     -> Optional[int]:






         """simple docstring"""







         if schedule_timesteps is None:
            UpperCAmelCase      					=  self.timesteps

         UpperCAmelCase      					=  (schedule_timesteps == timestep).nonzero()

         # The sigma index that is taken for the **very** first `step`
         # is always the second index (or the last index if there is only 1)
         # This way we can ensure we don't accidentally skip a sigma in
         # case we start in the middle of the denoising schedule (e.g. for image-to-image)
         if len(self._index_counter							) == 0:
            UpperCAmelCase      					=  1 if len(__lowerCamelCase							) > 1 else 0
         else:
            UpperCAmelCase      					=  timestep.cpu().item() if torch.is_tensor(__lowerCamelCase							) else timestep
            UpperCAmelCase      					=  self._index_counter[timestep_int]

         return indices[pos].item()





      @property
      def 							_lowercase					(		self    :       List[str]							)     -> List[str]:






         """simple docstring"""







         if self.config.timestep_spacing in ["linspace", "trailing"]:
            return self.sigmas.max()

         return (self.sigmas.max() ** 2 + 1) ** 0.5





      def 							_lowercase					(		self    :       Optional[int]       ,							__lowerCamelCase    :       torch.FloatTensor       ,							__lowerCamelCase    :       Union[float, torch.FloatTensor]       ,							)     -> torch.FloatTensor:






         """simple docstring"""







         UpperCAmelCase      					=  self.index_for_timestep(__lowerCamelCase							)

         UpperCAmelCase      					=  self.sigmas[step_index]
         UpperCAmelCase      					=  sample / ((sigma**2 + 1) ** 0.5)
         return sample





      def 							_lowercase					(		self    :       Union[str, Any]       ,							__lowerCamelCase    :       int       ,							__lowerCamelCase    :       Union[str, torch.device] = None       ,							__lowerCamelCase    :       Optional[int] = None       ,							)     -> List[Any]:






         """simple docstring"""







         UpperCAmelCase      					=  num_inference_steps

         UpperCAmelCase      					=  num_train_timesteps or self.config.num_train_timesteps

         # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
         if self.config.timestep_spacing == "linspace":
            UpperCAmelCase      					=  np.linspace(0       ,							num_train_timesteps - 1       ,							__lowerCamelCase       ,							dtype=__lowerCamelCase							)[::-1].copy()
         elif self.config.timestep_spacing == "leading":
            UpperCAmelCase      					=  num_train_timesteps // self.num_inference_steps
            # creates integer timesteps by multiplying by ratio
            # casting to int to avoid issues when num_inference_step is power of 3
            UpperCAmelCase      					=  (np.arange(0       ,							__lowerCamelCase							) * step_ratio).round()[::-1].copy().astype(__lowerCamelCase							)
            timesteps += self.config.steps_offset
         elif self.config.timestep_spacing == "trailing":
            UpperCAmelCase      					=  num_train_timesteps / self.num_inference_steps
            # creates integer timesteps by multiplying by ratio
            # casting to int to avoid issues when num_inference_step is power of 3
            UpperCAmelCase      					=  (np.arange(__lowerCamelCase       ,							0       ,							-step_ratio							)).round().copy().astype(__lowerCamelCase							)
            timesteps -= 1
         else:
            raise ValueError(
                F"""{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'."""							)

         UpperCAmelCase      					=  np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5							)
         UpperCAmelCase      					=  np.log(__lowerCamelCase							)
         UpperCAmelCase      					=  np.interp(__lowerCamelCase       ,							np.arange(0       ,							len(__lowerCamelCase							)							)       ,							__lowerCamelCase							)

         if self.config.use_karras_sigmas:
            UpperCAmelCase      					=  self._convert_to_karras(in_sigmas=__lowerCamelCase       ,							num_inference_steps=self.num_inference_steps							)
            UpperCAmelCase      					=  np.array([self._sigma_to_t(__lowerCamelCase       ,							__lowerCamelCase							) for sigma in sigmas]							)

         UpperCAmelCase      					=  np.concatenate([sigmas, [0.0]]							).astype(np.floataa							)
         UpperCAmelCase      					=  torch.from_numpy(__lowerCamelCase							).to(device=__lowerCamelCase							)
         UpperCAmelCase      					=  torch.cat([sigmas[:1], sigmas[1:-1].repeat_interleave(2							), sigmas[-1:]]							)

         UpperCAmelCase      					=  torch.from_numpy(__lowerCamelCase							)
         UpperCAmelCase      					=  torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2							)]							)

         if str(__lowerCamelCase							).startswith("""mps"""							):
            # mps does not support float64
            UpperCAmelCase      					=  timesteps.to(__lowerCamelCase       ,							dtype=torch.floataa							)
         else:
            UpperCAmelCase      					=  timesteps.to(device=__lowerCamelCase							)

         # empty dt and derivative
         UpperCAmelCase      					=  None
         UpperCAmelCase      					=  None

         # for exp beta schedules, such as the one for `pipeline_shap_e.py`
         # we need an index counter
         UpperCAmelCase      					=  defaultdict(__lowerCamelCase							)





      def 							_lowercase					(		self    :       Tuple       ,							__lowerCamelCase    :       str       ,							__lowerCamelCase    :       List[Any]							)     -> int:






         """simple docstring"""







         UpperCAmelCase      					=  np.log(__lowerCamelCase							)

         # get distribution
         UpperCAmelCase      					=  log_sigma - log_sigmas[:, np.newaxis]

         # get sigmas range
         UpperCAmelCase      					=  np.cumsum((dists >= 0)       ,							axis=0							).argmax(axis=0							).clip(max=log_sigmas.shape[0] - 2							)
         UpperCAmelCase      					=  low_idx + 1

         UpperCAmelCase      					=  log_sigmas[low_idx]
         UpperCAmelCase      					=  log_sigmas[high_idx]

         # interpolate sigmas
         UpperCAmelCase      					=  (low - log_sigma) / (low - high)
         UpperCAmelCase      					=  np.clip(__lowerCamelCase       ,							0       ,							1							)

         # transform interpolation to time range
         UpperCAmelCase      					=  (1 - w) * low_idx + w * high_idx
         UpperCAmelCase      					=  t.reshape(sigma.shape							)
         return t





      def 							_lowercase					(		self    :       Optional[int]       ,							__lowerCamelCase    :       torch.FloatTensor       ,							__lowerCamelCase    :       Tuple							)     -> torch.FloatTensor:






         """simple docstring"""







         UpperCAmelCase      					=  in_sigmas[-1].item()
         UpperCAmelCase      					=  in_sigmas[0].item()

         UpperCAmelCase      					=  7.0  # 7.0 is the value used in the paper
         UpperCAmelCase      					=  np.linspace(0       ,							1       ,							__lowerCamelCase							)
         UpperCAmelCase      					=  sigma_min ** (1 / rho)
         UpperCAmelCase      					=  sigma_max ** (1 / rho)
         UpperCAmelCase      					=  (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
         return sigmas





      @property
      def 							_lowercase					(		self    :       Union[str, Any]							)     -> List[Any]:






         """simple docstring"""







         return self.dt is None





      def 							_lowercase					(		self    :       Optional[int]       ,							__lowerCamelCase    :       Union[torch.FloatTensor, np.ndarray]       ,							__lowerCamelCase    :       Union[float, torch.FloatTensor]       ,							__lowerCamelCase    :       Union[torch.FloatTensor, np.ndarray]       ,							__lowerCamelCase    :       bool = True       ,							)     -> Union[SchedulerOutput, Tuple]:






         """simple docstring"""







         UpperCAmelCase      					=  self.index_for_timestep(__lowerCamelCase							)

         # advance index counter by 1
         UpperCAmelCase      					=  timestep.cpu().item() if torch.is_tensor(__lowerCamelCase							) else timestep
         self._index_counter[timestep_int] += 1

         if self.state_in_first_order:
            UpperCAmelCase      					=  self.sigmas[step_index]
            UpperCAmelCase      					=  self.sigmas[step_index + 1]
         else:
            # 2nd order / Heun's method
            UpperCAmelCase      					=  self.sigmas[step_index - 1]
            UpperCAmelCase      					=  self.sigmas[step_index]

         # currently only gamma=0 is supported. This usually works best anyways.
         # We can support gamma in the future but then need to scale the timestep before
         # passing it to the model which requires a change in API
         UpperCAmelCase      					=  0
         UpperCAmelCase      					=  sigma * (gamma + 1)  # Note: sigma_hat == sigma for now

         # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
         if self.config.prediction_type == "epsilon":
            UpperCAmelCase      					=  sigma_hat if self.state_in_first_order else sigma_next
            UpperCAmelCase      					=  sample - sigma_input * model_output
         elif self.config.prediction_type == "v_prediction":
            UpperCAmelCase      					=  sigma_hat if self.state_in_first_order else sigma_next
            UpperCAmelCase      					=  model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + (
                sample / (sigma_input**2 + 1)
            )
         elif self.config.prediction_type == "sample":
            UpperCAmelCase      					=  model_output
         else:
            raise ValueError(
                F"""prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`"""							)

         if self.config.clip_sample:
            UpperCAmelCase      					=  pred_original_sample.clamp(
                -self.config.clip_sample_range       ,							self.config.clip_sample_range							)

         if self.state_in_first_order:
            # 2. Convert to an ODE derivative for 1st order
            UpperCAmelCase      					=  (sample - pred_original_sample) / sigma_hat
            # 3. delta timestep
            UpperCAmelCase      					=  sigma_next - sigma_hat

            # store for 2nd order step
            UpperCAmelCase      					=  derivative
            UpperCAmelCase      					=  dt
            UpperCAmelCase      					=  sample
         else:
            # 2. 2nd order / Heun's method
            UpperCAmelCase      					=  (sample - pred_original_sample) / sigma_next
            UpperCAmelCase      					=  (self.prev_derivative + derivative) / 2

            # 3. take prev timestep & sample
            UpperCAmelCase      					=  self.dt
            UpperCAmelCase      					=  self.sample

            # free dt and derivative
            # Note, this puts the scheduler in "first order mode"
            UpperCAmelCase      					=  None
            UpperCAmelCase      					=  None
            UpperCAmelCase      					=  None

         UpperCAmelCase      					=  sample + derivative * dt

         if not return_dict:
            return (prev_sample,)

         return SchedulerOutput(prev_sample=__lowerCamelCase							)





      def 							_lowercase					(		self    :       Tuple       ,							__lowerCamelCase    :       torch.FloatTensor       ,							__lowerCamelCase    :       torch.FloatTensor       ,							__lowerCamelCase    :       torch.FloatTensor       ,							)     -> torch.FloatTensor:






         """simple docstring"""







         UpperCAmelCase      					=  self.sigmas.to(device=original_samples.device       ,							dtype=original_samples.dtype							)
         if original_samples.device.type == "mps" and torch.is_floating_point(__lowerCamelCase							):
            # mps does not support float64
            UpperCAmelCase      					=  self.timesteps.to(original_samples.device       ,							dtype=torch.floataa							)
            UpperCAmelCase      					=  timesteps.to(original_samples.device       ,							dtype=torch.floataa							)
         else:
            UpperCAmelCase      					=  self.timesteps.to(original_samples.device							)
            UpperCAmelCase      					=  timesteps.to(original_samples.device							)

         UpperCAmelCase      					=  [self.index_for_timestep(__lowerCamelCase       ,							__lowerCamelCase							) for t in timesteps]

         UpperCAmelCase      					=  sigmas[step_indices].flatten()
         while len(sigma.shape							) < len(original_samples.shape							):
            UpperCAmelCase      					=  sigma.unsqueeze(-1							)

         UpperCAmelCase      					=  original_samples + noise * sigma
         return noisy_samples





      def __len__(		self    :       List[Any]							)     -> int:






         """simple docstring"""







         return self.config.num_train_timesteps







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





      def __init__(		self    :       str       ,							__lowerCamelCase    :       Any       ,							__lowerCamelCase    :       Optional[int]=3       ,							__lowerCamelCase    :       Union[str, Any]=3_2       ,							__lowerCamelCase    :       List[str]=3       ,							__lowerCamelCase    :       Dict=1_0       ,							__lowerCamelCase    :       Optional[int]=[1_0, 2_0, 3_0, 4_0]       ,							__lowerCamelCase    :       Optional[int]=[1, 1, 2, 1]       ,							__lowerCamelCase    :       int=True       ,							__lowerCamelCase    :       str=True       ,							__lowerCamelCase    :       str="relu"       ,							__lowerCamelCase    :       str=3       ,							__lowerCamelCase    :       int=None       ,							)     -> Dict:






         """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(__lowerCamelCase							)





      def 							_lowercase					(		self    :       List[str]							)     -> Optional[Any]:






         """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 							_lowercase					(		self    :       List[Any]							)     -> Dict:






         """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 							_lowercase					(		self    :       Tuple       ,							__lowerCamelCase    :       Optional[int]       ,							__lowerCamelCase    :       List[str]       ,							__lowerCamelCase    :       Tuple							)     -> str:






         """simple docstring"""







         UpperCAmelCase      					=  TFResNetModel(config=__lowerCamelCase							)
         UpperCAmelCase      					=  model(__lowerCamelCase							)
         # 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 							_lowercase					(		self    :       Optional[Any]       ,							__lowerCamelCase    :       Any       ,							__lowerCamelCase    :       Optional[Any]       ,							__lowerCamelCase    :       int							)     -> Tuple:






         """simple docstring"""







         UpperCAmelCase      					=  self.num_labels
         UpperCAmelCase      					=  TFResNetForImageClassification(__lowerCamelCase							)
         UpperCAmelCase      					=  model(__lowerCamelCase       ,							labels=__lowerCamelCase							)
         self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.num_labels)							)





      def 							_lowercase					(		self    :       Optional[int]							)     -> Tuple:






         """simple docstring"""







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






@require_tf
class 	__lowercase					(	__snake_case			,       __snake_case			,       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 							_lowercase					(		self    :       str							)     -> List[Any]:






         """simple docstring"""







         UpperCAmelCase      					=  TFResNetModelTester(self							)
         UpperCAmelCase      					=  ConfigTester(self       ,							config_class=__lowerCamelCase       ,							has_text_modality=__lowerCamelCase							)





      def 							_lowercase					(		self    :       str							)     -> 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 							_lowercase					(		self    :       str							)     -> Dict:






         """simple docstring"""







         return





      @unittest.skip(reason="""ResNet does not use inputs_embeds"""							)
      def 							_lowercase					(		self    :       Optional[int]							)     -> Optional[int]:






         """simple docstring"""







         pass





      @unittest.skip(reason="""ResNet does not support input and output embeddings"""							)
      def 							_lowercase					(		self    :       Union[str, Any]							)     -> Tuple:






         """simple docstring"""







         pass





      def 							_lowercase					(		self    :       Optional[Any]							)     -> Optional[int]:






         """simple docstring"""







         UpperCAmelCase					,	UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs_for_common()

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

            UpperCAmelCase      					=  ["""pixel_values"""]
            self.assertListEqual(arg_names[:1]       ,							__lowerCamelCase							)





      def 							_lowercase					(		self    :       str							)     -> List[Any]:






         """simple docstring"""







         UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__lowerCamelCase							)





      def 							_lowercase					(		self    :       List[Any]							)     -> List[str]:






         """simple docstring"""







         def check_hidden_states_output(__lowerCamelCase    :       str       ,							__lowerCamelCase    :       Dict       ,							__lowerCamelCase    :       Union[str, Any]							):
            UpperCAmelCase      					=  model_class(__lowerCamelCase							)
            UpperCAmelCase      					=  model(**self._prepare_for_class(__lowerCamelCase       ,							__lowerCamelCase							)							)

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

            UpperCAmelCase      					=  self.model_tester.num_stages
            self.assertEqual(len(__lowerCamelCase							)       ,							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(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)

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

               check_hidden_states_output(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)





      def 							_lowercase					(		self    :       Union[str, Any]							)     -> int:






         """simple docstring"""







         UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase							)





      @slow
      def 							_lowercase					(		self    :       Tuple							)     -> List[str]:






         """simple docstring"""







         for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCAmelCase      					=  TFResNetModel.from_pretrained(__lowerCamelCase							)
            self.assertIsNotNone(__lowerCamelCase							)

def 	_UpperCamelCase					(    )    ->int:
   UpperCAmelCase      					=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
   return image







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





      @cached_property
      def 							_lowercase					(		self    :       List[Any]							)     -> Dict:






         """simple docstring"""







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





      @slow
      def 							_lowercase					(		self    :       Dict							)     -> str:






         """simple docstring"""







         UpperCAmelCase      					=  TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)

         UpperCAmelCase      					=  self.default_image_processor
         UpperCAmelCase      					=  prepare_img()
         UpperCAmelCase      					=  image_processor(images=__lowerCamelCase       ,							return_tensors="""tf"""							)

         # forward pass
         UpperCAmelCase      					=  model(**__lowerCamelCase							)

         # verify the logits
         UpperCAmelCase      					=  tf.TensorShape((1, 1_0_0_0)							)
         self.assertEqual(outputs.logits.shape       ,							__lowerCamelCase							)

         UpperCAmelCase      					=  tf.constant([-11.1_069, -9.7_877, -8.3_777]							)

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



