


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




						def __init__(       self					:      int				,    _a					:      int				,    _a					:      Any=3				,    _a					:      List[Any]=32				,    _a					:      Tuple=3				,    _a					:      Any=10				,    _a					:      str=[10, 20, 30, 40]				,    _a					:      Dict=[1, 1, 2, 1]				,    _a					:      List[Any]=True				,    _a					:      Union[str, Any]=True				,    _a					:      Any="relu"				,    _a					:      Union[str, Any]=3				,    _a					:      Optional[int]=None				,    )							->     Tuple:


										"""simple docstring"""





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




						def 							__UpperCamelCase				(       self					:      List[str]  )							->     int:


										"""simple docstring"""





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

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

										_SCREAMING_SNAKE_CASE			  =self.get_config()

										return config, pixel_values, labels




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


										"""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 							__UpperCamelCase				(       self					:      Any				,    _a					:      List[str]				,    _a					:      List[str]				,    _a					:      List[str]  )							->     int:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =TFResNetModel(config=_snake_case  )
										_SCREAMING_SNAKE_CASE			  =model(_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 							__UpperCamelCase				(       self					:      Any				,    _a					:      Optional[int]				,    _a					:      Tuple				,    _a					:      List[Any]  )							->     Optional[int]:


										"""simple docstring"""





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




						def 							__UpperCamelCase				(       self					:      Dict  )							->     Any:


										"""simple docstring"""





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

@require_tf
class 						A__							(		UpperCAmelCase_   ,     UpperCAmelCase_   ,     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 							__UpperCamelCase				(       self					:      Optional[int]  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =TFResNetModelTester(self  )
										_SCREAMING_SNAKE_CASE			  =ConfigTester(self				,    config_class=_snake_case				,    has_text_modality=_snake_case  )




						def 							__UpperCamelCase				(       self					:      Dict  )							->     List[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 							__UpperCamelCase				(       self					:      Any  )							->     Union[str, Any]:


										"""simple docstring"""





										return




						@unittest.skip(reason='''ResNet does not use inputs_embeds'''  )
						def 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     int:


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




						def 							__UpperCamelCase				(       self					:      str  )							->     Any:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs_for_common()

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

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




						def 							__UpperCamelCase				(       self					:      Dict  )							->     Optional[int]:


										"""simple docstring"""





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




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


										"""simple docstring"""





										def check_hidden_states_output(_a					:      Tuple				,    _a					:      int				,    _a					:      Optional[Any]  ):
														_SCREAMING_SNAKE_CASE			  =model_class(_snake_case  )
														_SCREAMING_SNAKE_CASE			  =model(**self._prepare_for_class(_snake_case				,    _snake_case  )  )

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

														_SCREAMING_SNAKE_CASE			  =self.model_tester.num_stages
														self.assertEqual(len(_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]				,    )

										_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs_for_common()
										_SCREAMING_SNAKE_CASE			  =['''basic''', '''bottleneck''']
										for model_class in self.all_model_classes:
														for layer_type in layers_type:
																		_SCREAMING_SNAKE_CASE			  =layer_type
																		_SCREAMING_SNAKE_CASE			  =True
																		check_hidden_states_output(_snake_case				,    _snake_case				,    _snake_case  )

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

																		check_hidden_states_output(_snake_case				,    _snake_case				,    _snake_case  )




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


										"""simple docstring"""





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




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


										"""simple docstring"""





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







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


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




						@cached_property
						def 							__UpperCamelCase				(       self					:      Dict  )							->     int:


										"""simple docstring"""





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




						@slow
						def 							__UpperCamelCase				(       self					:      int  )							->     int:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )

										_SCREAMING_SNAKE_CASE			  =self.default_image_processor
										_SCREAMING_SNAKE_CASE			  =prepare_img()
										_SCREAMING_SNAKE_CASE			  =image_processor(images=_snake_case				,    return_tensors='''tf'''  )

										# forward pass
										_SCREAMING_SNAKE_CASE			  =model(**_snake_case  )

										# verify the logits
										_SCREAMING_SNAKE_CASE			  =tf.TensorShape((1, 1000)  )
										self.assertEqual(outputs.logits.shape				,    _snake_case  )

										_SCREAMING_SNAKE_CASE			  =tf.constant([-11.10_69, -9.78_77, -8.37_77]  )

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



from ...configuration_utils import PretrainedConfig
from ...utils import logging


snake_case_						:			int													=							logging.get_logger(__name__)

snake_case_						:			Optional[Any]													=							{
    '''SCUT-DLVCLab/lilt-roberta-en-base''': (
        '''https://huggingface.co/SCUT-DLVCLab/lilt-roberta-en-base/resolve/main/config.json'''
    ),
}

class 						A__							(		UpperCamelCase__  ):
						UpperCAmelCase             =						"lilt"




						def __init__(       self					:      int				,    _a					:      Dict=3_0522				,    _a					:      str=768				,    _a					:      Optional[int]=12				,    _a					:      str=12				,    _a					:      List[str]=3072				,    _a					:      Any="gelu"				,    _a					:      int=0.1				,    _a					:      Any=0.1				,    _a					:      Union[str, Any]=512				,    _a					:      str=2				,    _a					:      List[Any]=0.02				,    _a					:      str=1E-12				,    _a					:      str=0				,    _a					:      str="absolute"				,    _a					:      Any=None				,    _a					:      Dict=4				,    _a					:      int=1024				,    **_a					:      List[Any]				,    )							->     Any:


										"""simple docstring"""





										super().__init__(pad_token_id=_a				,    **_a  )

										_SCREAMING_SNAKE_CASE			  =vocab_size
										_SCREAMING_SNAKE_CASE			  =hidden_size
										_SCREAMING_SNAKE_CASE			  =num_hidden_layers
										_SCREAMING_SNAKE_CASE			  =num_attention_heads
										_SCREAMING_SNAKE_CASE			  =hidden_act
										_SCREAMING_SNAKE_CASE			  =intermediate_size
										_SCREAMING_SNAKE_CASE			  =hidden_dropout_prob
										_SCREAMING_SNAKE_CASE			  =attention_probs_dropout_prob
										_SCREAMING_SNAKE_CASE			  =max_position_embeddings
										_SCREAMING_SNAKE_CASE			  =type_vocab_size
										_SCREAMING_SNAKE_CASE			  =initializer_range
										_SCREAMING_SNAKE_CASE			  =layer_norm_eps
										_SCREAMING_SNAKE_CASE			  =position_embedding_type
										_SCREAMING_SNAKE_CASE			  =classifier_dropout
										_SCREAMING_SNAKE_CASE			  =channel_shrink_ratio
										_SCREAMING_SNAKE_CASE			  =max_ad_position_embeddings