


'''simple docstring'''






from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor
class 						__UpperCamelCase	:





							def __init__(  self		:Dict  ,_UpperCamelCase		:str  ,_UpperCamelCase		:str=3  ,_UpperCamelCase		:Tuple=3_2  ,_UpperCamelCase		:Tuple=3  ,_UpperCamelCase		:Any=1_0  ,_UpperCamelCase		:Any=[1_0, 2_0, 3_0, 4_0]  ,_UpperCamelCase		:Optional[Any]=[1, 1, 2, 1]  ,_UpperCamelCase		:List[Any]=True  ,_UpperCamelCase		:int=True  ,_UpperCamelCase		:Optional[int]="relu"  ,_UpperCamelCase		:List[Any]=3  ,_UpperCamelCase		:List[Any]=None  ,):
									snake_case_		:							List[Any]			       =						parent
									snake_case_		:							Optional[Any]			       =						batch_size
									snake_case_		:							Dict			       =						image_size
									snake_case_		:							str			       =						num_channels
									snake_case_		:							Union[str, Any]			       =						embeddings_size
									snake_case_		:							Optional[Any]			       =						hidden_sizes
									snake_case_		:							Any			       =						depths
									snake_case_		:							List[str]			       =						is_training
									snake_case_		:							int			       =						use_labels
									snake_case_		:							Optional[Any]			       =						hidden_act
									snake_case_		:							List[Any]			       =						num_labels
									snake_case_		:							Optional[int]			       =						scope
									snake_case_		:							int			       =						len(_UpperCamelCase			)





							def 		a__   (  self		:List[Any]			):
									snake_case_		:							List[str]			       =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

									snake_case_		:							Union[str, Any]			       =						None
									if self.use_labels:
											snake_case_		:							Tuple			       =						ids_tensor([self.batch_size]  ,self.num_labels			)

									snake_case_		:							Optional[int]			       =						self.get_config()
									return config, pixel_values, labels





							def 		a__   (  self		:List[str]			):
									return RegNetConfig(
									    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  ,)





							def 		a__   (  self		:Optional[int]  ,_UpperCamelCase		:List[str]  ,_UpperCamelCase		:List[str]  ,_UpperCamelCase		:List[Any]			):
									snake_case_		:							Any			       =						TFRegNetModel(config=_UpperCamelCase			)
									snake_case_		:							Optional[Any]			       =						model(_UpperCamelCase  ,training=_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 // 3_2, self.image_size // 3_2)  ,)





							def 		a__   (  self		:Optional[Any]  ,_UpperCamelCase		:Dict  ,_UpperCamelCase		:int  ,_UpperCamelCase		:List[str]			):
									snake_case_		:							int			       =						self.num_labels
									snake_case_		:							Tuple			       =						TFRegNetForImageClassification(_UpperCamelCase			)
									snake_case_		:							List[str]			       =						model(_UpperCamelCase  ,labels=_UpperCamelCase  ,training=_UpperCamelCase			)
									self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.num_labels)			)





							def 		a__   (  self		:Optional[Any]			):
									snake_case_		:							List[str]			       =						self.prepare_config_and_inputs()
									snake_case_		:							List[Any]			       =						config_and_inputs
									snake_case_		:							Dict			       =						{'pixel_values': pixel_values}
									return config, inputs_dict





@require_tf
class 						__UpperCamelCase	(						__A						,  __A						,  unittest.TestCase							):
							lowercase			:		str   		=  (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
							lowercase			:		Tuple   		=  (
							    {'feature-extraction': TFRegNetModel, 'image-classification': TFRegNetForImageClassification}
							    if is_tf_available()
							    else {}
							)

							lowercase			:		Optional[Any]   		=  False
							lowercase			:		int   		=  False
							lowercase			:		int   		=  False
							lowercase			:		List[Any]   		=  False
							lowercase			:		Optional[Any]   		=  False





							def 		a__   (  self		:List[Any]			):
									snake_case_		:							str			       =						TFRegNetModelTester(self			)
									snake_case_		:							List[Any]			       =						ConfigTester(self  ,config_class=_UpperCamelCase  ,has_text_modality=_UpperCamelCase			)





							def 		a__   (  self		:List[Any]			):
									return





							@unittest.skip(reason="""RegNet does not use inputs_embeds"""			)
							def 		a__   (  self		:Dict			):
									pass





							@unittest.skipIf(
							    not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""			)			) == 0  ,reason="""TF does not support backprop for grouped convolutions on CPU."""  ,)
							@slow
							def 		a__   (  self		:int			):
									super().test_keras_fit()





							@unittest.skip(reason="""RegNet does not support input and output embeddings"""			)
							def 		a__   (  self		:Optional[Any]			):
									pass





							def 		a__   (  self		:Optional[Any]			):
									snake_case_		:							int			       =						self.model_tester.prepare_config_and_inputs_for_common()

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

											snake_case_		:							Optional[int]			       =						['pixel_values']
											self.assertListEqual(arg_names[:1]  ,_UpperCamelCase			)





							def 		a__   (  self		:int			):
									snake_case_		:							Tuple			       =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_UpperCamelCase			)





							def 		a__   (  self		:str			):





									def check_hidden_states_output(_UpperCamelCase		:List[str]  ,_UpperCamelCase		:Optional[Any]  ,_UpperCamelCase		:List[str]			):
											snake_case_		:							List[Any]			       =						model_class(_UpperCamelCase			)
											snake_case_		:							int			       =						model(**self._prepare_for_class(_UpperCamelCase  ,_UpperCamelCase			)  ,training=_UpperCamelCase			)

											snake_case_		:							List[str]			       =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

											snake_case_		:							Optional[Any]			       =						self.model_tester.num_stages
											self.assertEqual(len(_UpperCamelCase			)  ,expected_num_stages + 1			)

											# RegNet'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 // 2, self.model_tester.image_size // 2]  ,)

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

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

													check_hidden_states_output(_UpperCamelCase  ,_UpperCamelCase  ,_UpperCamelCase			)





							def 		a__   (  self		:Tuple			):
									snake_case_		:							Dict			       =						self.model_tester.prepare_config_and_inputs_for_common()

									def check_equivalence(_UpperCamelCase		:List[str]  ,_UpperCamelCase		:str  ,_UpperCamelCase		:Optional[Any]  ,_UpperCamelCase		:str={}			):
											snake_case_		:							Tuple			       =						model(_UpperCamelCase  ,return_dict=_UpperCamelCase  ,**_UpperCamelCase			)
											snake_case_		:							Optional[Any]			       =						model(_UpperCamelCase  ,return_dict=_UpperCamelCase  ,**_UpperCamelCase			).to_tuple()

											def recursive_check(_UpperCamelCase		:List[Any]  ,_UpperCamelCase		:Tuple			):
													if isinstance(_UpperCamelCase  ,(List, Tuple)			):
															for tuple_iterable_value, dict_iterable_value in zip(_UpperCamelCase  ,_UpperCamelCase			):
																	recursive_check(_UpperCamelCase  ,_UpperCamelCase			)
													elif tuple_object is None:
															return
													else:
															self.assertTrue(
															    all(tf.equal(_UpperCamelCase  ,_UpperCamelCase			)			)  ,msg=(
															        """Tuple and dict output are not equal. Difference:"""
															        F''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object			)			)}'''
															    )  ,)

													recursive_check(_UpperCamelCase  ,_UpperCamelCase			)

									for model_class in self.all_model_classes:
											snake_case_		:							Dict			       =						model_class(_UpperCamelCase			)

											snake_case_		:							Optional[int]			       =						self._prepare_for_class(_UpperCamelCase  ,_UpperCamelCase			)
											snake_case_		:							Union[str, Any]			       =						self._prepare_for_class(_UpperCamelCase  ,_UpperCamelCase			)
											check_equivalence(_UpperCamelCase  ,_UpperCamelCase  ,_UpperCamelCase			)

											snake_case_		:							str			       =						self._prepare_for_class(_UpperCamelCase  ,_UpperCamelCase  ,return_labels=_UpperCamelCase			)
											snake_case_		:							List[str]			       =						self._prepare_for_class(_UpperCamelCase  ,_UpperCamelCase  ,return_labels=_UpperCamelCase			)
											check_equivalence(_UpperCamelCase  ,_UpperCamelCase  ,_UpperCamelCase			)

											snake_case_		:							Any			       =						self._prepare_for_class(_UpperCamelCase  ,_UpperCamelCase			)
											snake_case_		:							int			       =						self._prepare_for_class(_UpperCamelCase  ,_UpperCamelCase			)
											check_equivalence(_UpperCamelCase  ,_UpperCamelCase  ,_UpperCamelCase  ,{"""output_hidden_states""": True}			)

											snake_case_		:							Tuple			       =						self._prepare_for_class(_UpperCamelCase  ,_UpperCamelCase  ,return_labels=_UpperCamelCase			)
											snake_case_		:							int			       =						self._prepare_for_class(_UpperCamelCase  ,_UpperCamelCase  ,return_labels=_UpperCamelCase			)
											check_equivalence(_UpperCamelCase  ,_UpperCamelCase  ,_UpperCamelCase  ,{"""output_hidden_states""": True}			)





							def 		a__   (  self		:Optional[Any]			):
									snake_case_		:							Dict			       =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase			)





							@slow
							def 		a__   (  self		:Optional[int]			):





									for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											snake_case_		:							List[Any]			       =						TFRegNetModel.from_pretrained(_UpperCamelCase			)
											self.assertIsNotNone(_UpperCamelCase			)





def      UpperCAmelCase      (		):







		'''simple docstring'''
		snake_case_		:							Optional[int]			       =						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
		return image






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





							@cached_property
							def 		a__   (  self		:List[Any]			):
									return (
									    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
									    if is_vision_available()
									    else None
									)





							@slow
							def 		a__   (  self		:List[Any]			):
									snake_case_		:							Optional[int]			       =						TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)

									snake_case_		:							int			       =						self.default_image_processor
									snake_case_		:							List[str]			       =						prepare_img()
									snake_case_		:							Any			       =						image_processor(images=_UpperCamelCase  ,return_tensors="""tf"""			)

									# forward pass
									snake_case_		:							Tuple			       =						model(**_UpperCamelCase  ,training=_UpperCamelCase			)

									# verify the logits
									snake_case_		:							int			       =						tf.TensorShape((1, 1_0_0_0)			)
									self.assertEqual(outputs.logits.shape  ,_UpperCamelCase			)

									snake_case_		:							Tuple			       =						tf.constant([-0.41_80, -1.50_51, -3.48_36]			)

									tf.debugging.assert_near(outputs.logits[0, :3]  ,_UpperCamelCase  ,atol=1E-4			)




'''simple docstring'''






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


__A	:	Optional[int]     =     logging.get_logger(__name__)

__A	:	List[Any]     =     {
    'studio-ousia/luke-base': 'https://huggingface.co/studio-ousia/luke-base/resolve/main/config.json',
    'studio-ousia/luke-large': 'https://huggingface.co/studio-ousia/luke-large/resolve/main/config.json',
}
class 						__UpperCamelCase	(						lowercase__							):
							lowercase			:		Union[str, Any]   		=  'luke'





							def __init__(  self		:List[str]  ,_UpperCamelCase		:Tuple=5_0_2_6_7  ,_UpperCamelCase		:Tuple=5_0_0_0_0_0  ,_UpperCamelCase		:str=7_6_8  ,_UpperCamelCase		:List[Any]=2_5_6  ,_UpperCamelCase		:List[str]=1_2  ,_UpperCamelCase		:str=1_2  ,_UpperCamelCase		:Union[str, Any]=3_0_7_2  ,_UpperCamelCase		:int="gelu"  ,_UpperCamelCase		:int=0.1  ,_UpperCamelCase		:Dict=0.1  ,_UpperCamelCase		:Dict=5_1_2  ,_UpperCamelCase		:Optional[Any]=2  ,_UpperCamelCase		:int=0.02  ,_UpperCamelCase		:Any=1E-1_2  ,_UpperCamelCase		:Tuple=True  ,_UpperCamelCase		:Any=None  ,_UpperCamelCase		:Any=1  ,_UpperCamelCase		:int=0  ,_UpperCamelCase		:List[Any]=2  ,**_UpperCamelCase		:str  ,):
									super().__init__(pad_token_id=_UpperCamelCase  ,bos_token_id=_UpperCamelCase  ,eos_token_id=_UpperCamelCase  ,**_UpperCamelCase			)

									snake_case_		:							Any			       =						vocab_size
									snake_case_		:							List[Any]			       =						entity_vocab_size
									snake_case_		:							Optional[Any]			       =						hidden_size
									snake_case_		:							List[Any]			       =						entity_emb_size
									snake_case_		:							Dict			       =						num_hidden_layers
									snake_case_		:							Union[str, Any]			       =						num_attention_heads
									snake_case_		:							Dict			       =						hidden_act
									snake_case_		:							Dict			       =						intermediate_size
									snake_case_		:							Any			       =						hidden_dropout_prob
									snake_case_		:							List[Any]			       =						attention_probs_dropout_prob
									snake_case_		:							Optional[Any]			       =						max_position_embeddings
									snake_case_		:							Any			       =						type_vocab_size
									snake_case_		:							int			       =						initializer_range
									snake_case_		:							Union[str, Any]			       =						layer_norm_eps
									snake_case_		:							Tuple			       =						use_entity_aware_attention
									snake_case_		:							Tuple			       =						classifier_dropout