



"""simple docstring"""
from __future__ import annotations

import unittest

from transformers import LEDConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
      import tensorflow as tf

      from transformers import TFLEDForConditionalGeneration, TFLEDModel



@require_tf
class       SCREAMING_SNAKE_CASE__  :
   __lowerCAmelCase  :   Optional[Any]						=						LEDConfig
   __lowerCAmelCase  :   Any						=						{}
   __lowerCAmelCase  :   Optional[Any]						=						'gelu'

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=13      ,     _SCREAMING_SNAKE_CASE=7      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=False      ,     _SCREAMING_SNAKE_CASE=99      ,     _SCREAMING_SNAKE_CASE=32      ,     _SCREAMING_SNAKE_CASE=2      ,     _SCREAMING_SNAKE_CASE=4      ,     _SCREAMING_SNAKE_CASE=37      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=20      ,     _SCREAMING_SNAKE_CASE=2      ,     _SCREAMING_SNAKE_CASE=1      ,     _SCREAMING_SNAKE_CASE=0      ,     _SCREAMING_SNAKE_CASE=4      ,     )  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	parent
    UpperCAmelCase	:					Tuple	=	batch_size
    UpperCAmelCase	:					Optional[Any]	=	seq_length
    UpperCAmelCase	:					List[str]	=	is_training
    UpperCAmelCase	:					Union[str, Any]	=	use_labels
    UpperCAmelCase	:					Union[str, Any]	=	vocab_size
    UpperCAmelCase	:					Any	=	hidden_size
    UpperCAmelCase	:					Dict	=	num_hidden_layers
    UpperCAmelCase	:					str	=	num_attention_heads
    UpperCAmelCase	:					Union[str, Any]	=	intermediate_size

    UpperCAmelCase	:					List[str]	=	hidden_dropout_prob
    UpperCAmelCase	:					List[str]	=	attention_probs_dropout_prob
    UpperCAmelCase	:					List[Any]	=	max_position_embeddings
    UpperCAmelCase	:					Optional[int]	=	eos_token_id
    UpperCAmelCase	:					str	=	pad_token_id
    UpperCAmelCase	:					Tuple	=	bos_token_id
    UpperCAmelCase	:					Optional[Any]	=	attention_window

    # `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
    # [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
    # returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
    # because its local attention only attends to `self.attention_window` and one before and one after
    UpperCAmelCase	:					int	=	self.attention_window + 2

    # because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
    # the `test_attention_outputs` and `test_hidden_states_output` tests
    UpperCAmelCase	:					str	=	(
        self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
    )

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	ids_tensor([self.batch_size, self.seq_length - 1]      ,     self.vocab_size						)
    UpperCAmelCase	:					Optional[Any]	=	tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size						)      ,     1						)
    UpperCAmelCase	:					str	=	tf.concat([input_ids, eos_tensor]      ,     axis=1						)

    UpperCAmelCase	:					Optional[Any]	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.vocab_size						)

    UpperCAmelCase	:					Tuple	=	self.config_cls(
        vocab_size=self.vocab_size      ,     d_model=self.hidden_size      ,     encoder_layers=self.num_hidden_layers      ,     decoder_layers=self.num_hidden_layers      ,     encoder_attention_heads=self.num_attention_heads      ,     decoder_attention_heads=self.num_attention_heads      ,     encoder_ffn_dim=self.intermediate_size      ,     decoder_ffn_dim=self.intermediate_size      ,     dropout=self.hidden_dropout_prob      ,     attention_dropout=self.attention_probs_dropout_prob      ,     max_position_embeddings=self.max_position_embeddings      ,     eos_token_ids=[2]      ,     bos_token_id=self.bos_token_id      ,     pad_token_id=self.pad_token_id      ,     decoder_start_token_id=self.pad_token_id      ,     attention_window=self.attention_window      ,     **self.config_updates      ,     )
    UpperCAmelCase	:					Optional[int]	=	prepare_led_inputs_dict(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Any	=	tf.concat(
        [tf.zeros_like(_SCREAMING_SNAKE_CASE						)[:, :-1], tf.ones_like(_SCREAMING_SNAKE_CASE						)[:, -1:]]      ,     axis=-1      ,     )
    UpperCAmelCase	:					Union[str, Any]	=	global_attention_mask
    return config, inputs_dict




   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	TFLEDModel(config=_SCREAMING_SNAKE_CASE						).get_decoder()
    UpperCAmelCase	:					Optional[Any]	=	inputs_dict["""input_ids"""]

    UpperCAmelCase	:					Any	=	input_ids[:1, :]
    UpperCAmelCase	:					int	=	inputs_dict["""attention_mask"""][:1, :]
    UpperCAmelCase	:					Optional[Any]	=	1

    # first forward pass
    UpperCAmelCase	:					Optional[int]	=	model(_SCREAMING_SNAKE_CASE      ,     attention_mask=_SCREAMING_SNAKE_CASE      ,     use_cache=_SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	,		UpperCAmelCase	:					List[Any]	=	outputs.to_tuple()

    # create hypothetical next token and extent to next_input_ids
    UpperCAmelCase	:					List[str]	=	ids_tensor((self.batch_size, 3)      ,     config.vocab_size						)
    UpperCAmelCase	:					Any	=	tf.cast(ids_tensor((self.batch_size, 3)      ,     2						)      ,     tf.inta						)

    # append to next input_ids and
    UpperCAmelCase	:					List[str]	=	tf.concat([input_ids, next_tokens]      ,     axis=-1						)
    UpperCAmelCase	:					int	=	tf.concat([attention_mask, next_attn_mask]      ,     axis=-1						)

    UpperCAmelCase	:					List[Any]	=	model(_SCREAMING_SNAKE_CASE      ,     attention_mask=_SCREAMING_SNAKE_CASE						)[0]
    UpperCAmelCase	:					Union[str, Any]	=	model(_SCREAMING_SNAKE_CASE      ,     attention_mask=_SCREAMING_SNAKE_CASE      ,     past_key_values=_SCREAMING_SNAKE_CASE						)[0]

    self.parent.assertEqual(next_tokens.shape[1]      ,     output_from_past.shape[1]						)

    # select random slice
    UpperCAmelCase	:					int	=	int(ids_tensor((1,)      ,     output_from_past.shape[-1]						)						)
    UpperCAmelCase	:					int	=	output_from_no_past[:, -3:, random_slice_idx]
    UpperCAmelCase	:					str	=	output_from_past[:, :, random_slice_idx]

    # test that outputs are equal for slice
    tf.debugging.assert_near(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     rtol=1E-3						)

def       _snake_case						(						UpperCamelCase						:		Any			,		UpperCamelCase						:		int			,		UpperCamelCase						:		Union[str, Any]			,		UpperCamelCase						:		List[str]=None			,		UpperCamelCase						:		str=None			,		UpperCamelCase						:		Dict=None			,		UpperCamelCase						:		List[Any]=None			,		):
 if attention_mask is None:
  UpperCAmelCase	:					int	=	tf.cast(tf.math.not_equal(UpperCamelCase			,		config.pad_token_id						)			,		tf.inta						)
 if decoder_attention_mask is None:
  UpperCAmelCase	:					Dict	=	tf.concat(
      [
          tf.ones(decoder_input_ids[:, :1].shape			,		dtype=tf.inta						),
          tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]			,		config.pad_token_id						)			,		tf.inta						),
      ]			,		axis=-1			,		)
 if head_mask is None:
  UpperCAmelCase	:					List[Any]	=	tf.ones((config.encoder_layers, config.encoder_attention_heads)						)
 if decoder_head_mask is None:
  UpperCAmelCase	:					Union[str, Any]	=	tf.ones((config.decoder_layers, config.decoder_attention_heads)						)
 return {
     "input_ids": input_ids,
     "attention_mask": attention_mask,
     "decoder_input_ids": decoder_input_ids,
     "decoder_attention_mask": decoder_attention_mask,
     "head_mask": head_mask,
     "decoder_head_mask": decoder_head_mask,
 }



@require_tf
class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   Optional[Any]						=						(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
   __lowerCAmelCase  :   Dict						=						(TFLEDForConditionalGeneration,) if is_tf_available() else ()
   __lowerCAmelCase  :   int						=						(
       {
           'conversational': TFLEDForConditionalGeneration,
           'feature-extraction': TFLEDModel,
           'summarization': TFLEDForConditionalGeneration,
           'text2text-generation': TFLEDForConditionalGeneration,
           'translation': TFLEDForConditionalGeneration,
       }
       if is_tf_available()
       else {}
   )
   __lowerCAmelCase  :   Any						=						True
   __lowerCAmelCase  :   Tuple						=						False
   __lowerCAmelCase  :   Union[str, Any]						=						False
   __lowerCAmelCase  :   Dict						=						False

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      str:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	TFLEDModelTester(self						)
    UpperCAmelCase	:					int	=	ConfigTester(self      ,     config_class=_SCREAMING_SNAKE_CASE						)

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





    '''simple docstring'''




    self.config_tester.run_common_tests()

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					Dict	=	self.model_tester.prepare_config_and_inputs_for_common()
    self.model_tester.check_decoder_model_past_large_inputs(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	,		UpperCAmelCase	:					int	=	self.model_tester.prepare_config_and_inputs_for_common()
    UpperCAmelCase	:					Union[str, Any]	=	tf.zeros_like(inputs_dict["""attention_mask"""]						)
    UpperCAmelCase	:					Tuple	=	2
    UpperCAmelCase	:					Tuple	=	tf.where(
        tf.range(self.model_tester.seq_length						)[None, :] < num_global_attn_indices      ,     1      ,     inputs_dict["""global_attention_mask"""]      ,     )

    UpperCAmelCase	:					List[Any]	=	True
    UpperCAmelCase	:					int	=	self.model_tester.seq_length
    UpperCAmelCase	:					Optional[int]	=	self.model_tester.encoder_seq_length

    def check_decoder_attentions_output(_SCREAMING_SNAKE_CASE						):
     UpperCAmelCase	:					str	=	outputs.decoder_attentions
     self.assertEqual(len(_SCREAMING_SNAKE_CASE						)      ,     self.model_tester.num_hidden_layers						)
     self.assertListEqual(
         list(decoder_attentions[0].shape[-3:]						)      ,     [self.model_tester.num_attention_heads, seq_length, seq_length]      ,     )

    def check_encoder_attentions_output(_SCREAMING_SNAKE_CASE						):
     UpperCAmelCase	:					List[Any]	=	[t.numpy() for t in outputs.encoder_attentions]
     UpperCAmelCase	:					int	=	[t.numpy() for t in outputs.encoder_global_attentions]
     self.assertEqual(len(_SCREAMING_SNAKE_CASE						)      ,     self.model_tester.num_hidden_layers						)
     self.assertEqual(len(_SCREAMING_SNAKE_CASE						)      ,     self.model_tester.num_hidden_layers						)
     self.assertListEqual(
         list(attentions[0].shape[-3:]						)      ,     [self.model_tester.num_attention_heads, seq_length, seq_length]      ,     )
     self.assertListEqual(
         list(global_attentions[0].shape[-3:]						)      ,     [self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]      ,     )

    for model_class in self.all_model_classes:
     UpperCAmelCase	:					Optional[Any]	=	True
     UpperCAmelCase	:					List[str]	=	False
     UpperCAmelCase	:					str	=	False
     UpperCAmelCase	:					Any	=	model_class(_SCREAMING_SNAKE_CASE						)
     UpperCAmelCase	:					Union[str, Any]	=	model(self._prepare_for_class(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)						)
     UpperCAmelCase	:					Tuple	=	len(_SCREAMING_SNAKE_CASE						)
     self.assertEqual(config.output_hidden_states      ,     _SCREAMING_SNAKE_CASE						)
     check_encoder_attentions_output(_SCREAMING_SNAKE_CASE						)

     if self.is_encoder_decoder:
      UpperCAmelCase	:					Optional[int]	=	model_class(_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					List[str]	=	model(self._prepare_for_class(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)						)
      self.assertEqual(config.output_hidden_states      ,     _SCREAMING_SNAKE_CASE						)
      check_decoder_attentions_output(_SCREAMING_SNAKE_CASE						)

     # Check that output attentions can also be changed via the config
     del inputs_dict["output_attentions"]
     UpperCAmelCase	:					List[str]	=	True
     UpperCAmelCase	:					int	=	model_class(_SCREAMING_SNAKE_CASE						)
     UpperCAmelCase	:					Union[str, Any]	=	model(self._prepare_for_class(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)						)
     self.assertEqual(config.output_hidden_states      ,     _SCREAMING_SNAKE_CASE						)
     check_encoder_attentions_output(_SCREAMING_SNAKE_CASE						)

     # Check attention is always last and order is fine
     UpperCAmelCase	:					Optional[Any]	=	True
     UpperCAmelCase	:					Dict	=	True
     UpperCAmelCase	:					List[str]	=	model_class(_SCREAMING_SNAKE_CASE						)
     UpperCAmelCase	:					int	=	model(self._prepare_for_class(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)						)

     self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)      ,     len(_SCREAMING_SNAKE_CASE						)						)
     self.assertEqual(model.config.output_hidden_states      ,     _SCREAMING_SNAKE_CASE						)
     check_encoder_attentions_output(_SCREAMING_SNAKE_CASE						)

   @unittest.skip("""LED keeps using potentially symbolic tensors in conditionals and breaks tracing."""						)
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    pass




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





    '''simple docstring'''




    pass

def       _snake_case						(						UpperCamelCase						:		Optional[Any]						):
 return tf.constant(UpperCamelCase			,		dtype=tf.intaa						)


A:   Tuple								=		1E-4



@slow
@require_tf
class       SCREAMING_SNAKE_CASE__  (					unittest.TestCase ):

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





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	TFLEDForConditionalGeneration.from_pretrained("""allenai/led-base-16384"""						).led

    # change to intended input here
    UpperCAmelCase	:					int	=	_long_tensor([512 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]						)
    UpperCAmelCase	:					List[Any]	=	_long_tensor([128 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]						)
    UpperCAmelCase	:					Union[str, Any]	=	prepare_led_inputs_dict(model.config      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					str	=	model(**_SCREAMING_SNAKE_CASE						)[0]
    UpperCAmelCase	:					List[str]	=	(1, 1024, 768)
    self.assertEqual(output.shape      ,     _SCREAMING_SNAKE_CASE						)
    # change to expected output here
    UpperCAmelCase	:					Dict	=	tf.convert_to_tensor(
        [[2.3050, 2.8279, 0.6531], [-1.8457, -0.1455, -3.5661], [-1.0186, 0.4586, -2.2043]]      ,     )
    tf.debugging.assert_near(output[:, :3, :3]      ,     _SCREAMING_SNAKE_CASE      ,     atol=1E-3						)




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





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	TFLEDForConditionalGeneration.from_pretrained("""allenai/led-base-16384"""						)

    # change to intended input here
    UpperCAmelCase	:					Optional[Any]	=	_long_tensor([512 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]						)
    UpperCAmelCase	:					List[str]	=	_long_tensor([128 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]						)
    UpperCAmelCase	:					Optional[Any]	=	prepare_led_inputs_dict(model.config      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					int	=	model(**_SCREAMING_SNAKE_CASE						)[0]
    UpperCAmelCase	:					List[Any]	=	(1, 1024, model.config.vocab_size)
    self.assertEqual(output.shape      ,     _SCREAMING_SNAKE_CASE						)
    # change to expected output here
    UpperCAmelCase	:					Union[str, Any]	=	tf.convert_to_tensor(
        [[33.6507, 6.4572, 16.8089], [5.8739, -2.4238, 11.2902], [-3.2139, -4.3149, 4.2783]]      ,     )
    tf.debugging.assert_near(output[:, :3, :3]      ,     _SCREAMING_SNAKE_CASE      ,     atol=1E-3      ,     rtol=1E-3						)

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



    """simple docstring"""

    def __init__(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase=3    ,			_UpperCAmelCase=32    ,			_UpperCAmelCase=3    ,			_UpperCAmelCase=10    ,			_UpperCAmelCase=[10, 20, 30, 40]    ,			_UpperCAmelCase=[1, 1, 2, 1]    ,			_UpperCAmelCase=True    ,			_UpperCAmelCase=True    ,			_UpperCAmelCase="relu"    ,			_UpperCAmelCase=3    ,			_UpperCAmelCase=None    ,			):
       lowercase__:   Optional[Any]					=      parent
       lowercase__:   Union[str, Any]					=      batch_size
       lowercase__:   int					=      image_size
       lowercase__:   Optional[Any]					=      num_channels
       lowercase__:   Optional[int]					=      embeddings_size
       lowercase__:   Dict					=      hidden_sizes
       lowercase__:   Union[str, Any]					=      depths
       lowercase__:   str					=      is_training
       lowercase__:   Optional[int]					=      use_labels
       lowercase__:   List[str]					=      hidden_act
       lowercase__:   Dict					=      num_labels
       lowercase__:   Any					=      scope
       lowercase__:   Optional[Any]					=      len(_UpperCAmelCase							)






    def _snake_case			(   self							):
       lowercase__:   Union[str, Any]					=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

       lowercase__:   Optional[int]					=      self.get_config()

       return config, pixel_values, labels






    def _snake_case			(   self							):
       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 _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase							):
       lowercase__:   Optional[Any]					=      TFResNetModel(config=_UpperCAmelCase							)
       lowercase__:   Dict					=      model(_UpperCAmelCase							)
       # expected last hidden states: B, C, H // 32, W // 32
       self.parent.assertEqual(
           result.last_hidden_state.shape    ,			(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)    ,			)






    def _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase							):
       lowercase__:   str					=      self.num_labels
       lowercase__:   int					=      TFResNetForImageClassification(_UpperCAmelCase							)
       lowercase__:   Optional[Any]					=      model(_UpperCAmelCase    ,			labels=_UpperCAmelCase							)
       self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, self.num_labels)							)






    def _snake_case			(   self							):
       lowercase__:   int					=      self.prepare_config_and_inputs()
       lowercase__, lowercase__, lowercase__:   Optional[Any]					=      config_and_inputs
       lowercase__:   Union[str, Any]					=      {'''pixel_values''': pixel_values}
       return config, inputs_dict



@require_tf
class     UpperCAmelCase						(_UpperCAmelCase    ,_UpperCAmelCase    ,unittest.TestCase  ):



    """simple docstring"""

    _UpperCAmelCase	:Any						    = (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
    _UpperCAmelCase	:List[str]						    = (
        {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
        if is_tf_available()
        else {}
    )

    _UpperCAmelCase	:Any						    = False
    _UpperCAmelCase	:List[str]						    = False
    _UpperCAmelCase	:Optional[Any]						    = False
    _UpperCAmelCase	:Tuple						    = False
    _UpperCAmelCase	:List[Any]						    = False






    def _snake_case			(   self							):
       lowercase__:   Union[str, Any]					=      TFResNetModelTester(self							)
       lowercase__:   Optional[int]					=      ConfigTester(self    ,			config_class=_UpperCAmelCase    ,			has_text_modality=_UpperCAmelCase							)






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






    @unittest.skip(reason='''ResNet does not use inputs_embeds'''							)
    def _snake_case			(   self							):
       pass






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






    def _snake_case			(   self							):
       lowercase__, lowercase__:   int					=      self.model_tester.prepare_config_and_inputs_for_common()

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

          lowercase__:   Optional[Any]					=      ['''pixel_values''']
          self.assertListEqual(arg_names[:1]    ,			_UpperCAmelCase							)






    def _snake_case			(   self							):
       lowercase__:   Any					=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_UpperCAmelCase							)






    def _snake_case			(   self							):
       def check_hidden_states_output(_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase							):
          lowercase__:   Union[str, Any]					=      model_class(_UpperCAmelCase							)
          lowercase__:   List[Any]					=      model(**self._prepare_for_class(_UpperCAmelCase    ,			_UpperCAmelCase							)							)

          lowercase__:   Union[str, Any]					=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

          lowercase__:   Tuple					=      self.model_tester.num_stages
          self.assertEqual(len(_UpperCAmelCase							)    ,			expected_num_stages + 1							)

          # ResNet's feature maps are of shape (batch_size, num_channels, height, width)
          self.assertListEqual(
              list(hidden_states[0].shape[-2:]							)    ,			[self.model_tester.image_size // 4, self.model_tester.image_size // 4]    ,			)

       lowercase__, lowercase__:   Optional[Any]					=      self.model_tester.prepare_config_and_inputs_for_common()
       lowercase__:   Union[str, Any]					=      ['''basic''', '''bottleneck''']
       for model_class in self.all_model_classes:
          for layer_type in layers_type:
             lowercase__:   Tuple					=      layer_type
             lowercase__:   Any					=      True
             check_hidden_states_output(_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase							)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             lowercase__:   List[str]					=      True

             check_hidden_states_output(_UpperCAmelCase    ,			_UpperCAmelCase    ,			_UpperCAmelCase							)






    def _snake_case			(   self							):
       lowercase__:   Optional[int]					=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase							)






    @slow
    def _snake_case			(   self							):
       for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowercase__:   Dict					=      TFResNetModel.from_pretrained(_UpperCAmelCase							)
          self.assertIsNotNone(_UpperCAmelCase							)



def SCREAMING_SNAKE_CASE__			(   )  ->  List[Any]:
   lowercase__:   List[Any]					=      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
   return image




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



    """simple docstring"""

    @cached_property
    def _snake_case			(   self							):
       return (
           AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)
           if is_vision_available()
           else None
       )






    @slow
    def _snake_case			(   self							):
       lowercase__:   Tuple					=      TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)

       lowercase__:   Any					=      self.default_image_processor
       lowercase__:   List[Any]					=      prepare_img()
       lowercase__:   List[Any]					=      image_processor(images=_UpperCAmelCase    ,			return_tensors='''tf'''							)

       # forward pass
       lowercase__:   Dict					=      model(**_UpperCAmelCase							)

       # verify the logits
       lowercase__:   int					=      tf.TensorShape((1, 1000)							)
       self.assertEqual(outputs.logits.shape    ,			_UpperCAmelCase							)

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

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