


'''simple docstring'''





from __future__ import annotations

import unittest

from transformers import DebertaConfig, 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, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFDebertaForMaskedLM,
					    TFDebertaForQuestionAnswering,
					    TFDebertaForSequenceClassification,
					    TFDebertaForTokenClassification,
					    TFDebertaModel,
					)
class 	a__				:





			'''simple docstring'''

			def __init__(     self       : str ,						lowerCAmelCase_       : int ,						lowerCAmelCase_       : List[str]=13 ,						lowerCAmelCase_       : int=7 ,						lowerCAmelCase_       : Dict=True ,						lowerCAmelCase_       : Dict=True ,						lowerCAmelCase_       : str=True ,						lowerCAmelCase_       : List[str]=True ,						lowerCAmelCase_       : Any=99 ,						lowerCAmelCase_       : Tuple=32 ,						lowerCAmelCase_       : Optional[Any]=2 ,						lowerCAmelCase_       : str=4 ,						lowerCAmelCase_       : Optional[Any]=37 ,						lowerCAmelCase_       : List[str]="gelu" ,						lowerCAmelCase_       : int=0.1 ,						lowerCAmelCase_       : int=0.1 ,						lowerCAmelCase_       : Dict=512 ,						lowerCAmelCase_       : List[str]=16 ,						lowerCAmelCase_       : Optional[int]=2 ,						lowerCAmelCase_       : Union[str, Any]=0.02 ,						lowerCAmelCase_       : str=3 ,						lowerCAmelCase_       : List[Any]=4 ,						lowerCAmelCase_       : Optional[int]=None ,						)			->		Tuple:
						__A=  parent
						__A=  13
						__A=  7
						__A=  True
						__A=  True
						__A=  True
						__A=  True
						__A=  99
						__A=  32
						__A=  2
						__A=  4
						__A=  37
						__A=  'gelu'
						__A=  0.1
						__A=  0.1
						__A=  512
						__A=  16
						__A=  False
						__A=  -1
						__A=  True
						__A=  2
						__A=  0.02
						__A=  3
						__A=  4
						__A=  None
			def 				lowerCAmelCase    (     self       : Optional[int]  )			->		Dict:
						__A=  ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size  )

						__A=  None
						if self.use_input_mask:
									__A=  random_attention_mask([self.batch_size, self.seq_length]  )

						__A=  None
						if self.use_token_type_ids:
									__A=  ids_tensor([self.batch_size, self.seq_length] ,						self.type_vocab_size  )

						__A=  None
						__A=  None
						__A=  None
						if self.use_labels:
									__A=  ids_tensor([self.batch_size] ,						self.type_sequence_label_size  )
									__A=  ids_tensor([self.batch_size, self.seq_length] ,						self.num_labels  )

						__A=  DebertaConfig(
						    vocab_size=self.vocab_size ,						hidden_size=self.hidden_size ,						num_hidden_layers=self.num_hidden_layers ,						num_attention_heads=self.num_attention_heads ,						intermediate_size=self.intermediate_size ,						hidden_act=self.hidden_act ,						hidden_dropout_prob=self.hidden_dropout_prob ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob ,						max_position_embeddings=self.max_position_embeddings ,						type_vocab_size=self.type_vocab_size ,						relative_attention=self.relative_attention ,						max_relative_positions=self.max_relative_positions ,						position_biased_input=self.position_biased_input ,						initializer_range=self.initializer_range ,						return_dict=lowerCAmelCase_ ,						)

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
			def 				lowerCAmelCase    (     self       : str ,						lowerCAmelCase_       : List[Any] ,						lowerCAmelCase_       : Union[str, Any] ,						lowerCAmelCase_       : Tuple ,						lowerCAmelCase_       : Optional[int] ,						lowerCAmelCase_       : List[str] ,						lowerCAmelCase_       : Optional[Any] ,						lowerCAmelCase_       : Optional[int]  )			->		Any:
						__A=  TFDebertaModel(config=lowerCAmelCase_  )
						__A=  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

						__A=  [input_ids, input_mask]
						__A=  model(lowerCAmelCase_  )

						__A=  model(lowerCAmelCase_  )

						self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size)  )
			def 				lowerCAmelCase    (     self       : Tuple ,						lowerCAmelCase_       : Union[str, Any] ,						lowerCAmelCase_       : Union[str, Any] ,						lowerCAmelCase_       : List[Any] ,						lowerCAmelCase_       : int ,						lowerCAmelCase_       : Dict ,						lowerCAmelCase_       : Union[str, Any] ,						lowerCAmelCase_       : Union[str, Any]  )			->		Any:
						__A=  TFDebertaForMaskedLM(config=lowerCAmelCase_  )
						__A=  {
						    'input_ids': input_ids,
						    'attention_mask': input_mask,
						    'token_type_ids': token_type_ids,
						}
						__A=  model(lowerCAmelCase_  )
						self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.vocab_size)  )
			def 				lowerCAmelCase    (     self       : Any ,						lowerCAmelCase_       : Any ,						lowerCAmelCase_       : int ,						lowerCAmelCase_       : Tuple ,						lowerCAmelCase_       : Union[str, Any] ,						lowerCAmelCase_       : Union[str, Any] ,						lowerCAmelCase_       : Dict ,						lowerCAmelCase_       : Tuple  )			->		Optional[Any]:
						__A=  self.num_labels
						__A=  TFDebertaForSequenceClassification(config=lowerCAmelCase_  )
						__A=  {
						    'input_ids': input_ids,
						    'attention_mask': input_mask,
						    'token_type_ids': token_type_ids,
						}

						__A=  model(lowerCAmelCase_  )
						self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.num_labels)  )
			def 				lowerCAmelCase    (     self       : Any ,						lowerCAmelCase_       : Tuple ,						lowerCAmelCase_       : List[Any] ,						lowerCAmelCase_       : Optional[Any] ,						lowerCAmelCase_       : Optional[Any] ,						lowerCAmelCase_       : int ,						lowerCAmelCase_       : Tuple ,						lowerCAmelCase_       : List[Any]  )			->		Dict:
						__A=  self.num_labels
						__A=  TFDebertaForTokenClassification(config=lowerCAmelCase_  )
						__A=  {
						    'input_ids': input_ids,
						    'attention_mask': input_mask,
						    'token_type_ids': token_type_ids,
						}
						__A=  model(lowerCAmelCase_  )
						self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.num_labels)  )
			def 				lowerCAmelCase    (     self       : Optional[Any] ,						lowerCAmelCase_       : List[str] ,						lowerCAmelCase_       : Optional[int] ,						lowerCAmelCase_       : str ,						lowerCAmelCase_       : Dict ,						lowerCAmelCase_       : int ,						lowerCAmelCase_       : Union[str, Any] ,						lowerCAmelCase_       : List[Any]  )			->		str:
						__A=  TFDebertaForQuestionAnswering(config=lowerCAmelCase_  )
						__A=  {
						    'input_ids': input_ids,
						    'attention_mask': input_mask,
						    'token_type_ids': token_type_ids,
						}

						__A=  model(lowerCAmelCase_  )
						self.parent.assertEqual(result.start_logits.shape ,						(self.batch_size, self.seq_length)  )
						self.parent.assertEqual(result.end_logits.shape ,						(self.batch_size, self.seq_length)  )

			def 				lowerCAmelCase    (     self       : Union[str, Any]  )			->		List[Any]:
						__A=  self.prepare_config_and_inputs()
						(
						    (
						    __A
						),  (
						    __A
						),  (
						    __A
						),  (
						    __A
						),  (
						    __A
						),  (
						    __A
						),  (
						    __A
						),  
						)=  config_and_inputs
						__A=  {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
						return config, inputs_dict


@require_tf
class 	a__				(				a_			,     a_			,     unittest.TestCase      ):





			'''simple docstring'''

			A	:							List[str]							= (
			    (
			        TFDebertaModel,
			        TFDebertaForMaskedLM,
			        TFDebertaForQuestionAnswering,
			        TFDebertaForSequenceClassification,
			        TFDebertaForTokenClassification,
			    )
			    if is_tf_available()
			    else ()
			)
			A	:							str							= (
			    {
			        '''feature-extraction''': TFDebertaModel,
			        '''fill-mask''': TFDebertaForMaskedLM,
			        '''question-answering''': TFDebertaForQuestionAnswering,
			        '''text-classification''': TFDebertaForSequenceClassification,
			        '''token-classification''': TFDebertaForTokenClassification,
			        '''zero-shot''': TFDebertaForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)

			A	:							Any							= False
			A	:							Optional[int]							= False
			def 				lowerCAmelCase    (     self       : Tuple  )			->		Tuple:
						__A=  TFDebertaModelTester(self  )
						__A=  ConfigTester(self ,						config_class=lowerCAmelCase_ ,						hidden_size=37  )
			def 				lowerCAmelCase    (     self       : Optional[Any]  )			->		Dict:
						self.config_tester.run_common_tests()
			def 				lowerCAmelCase    (     self       : Union[str, Any]  )			->		Optional[Any]:
						__A=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowerCAmelCase_  )
			def 				lowerCAmelCase    (     self       : List[Any]  )			->		Optional[int]:
						__A=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase_  )
			def 				lowerCAmelCase    (     self       : List[Any]  )			->		Tuple:
						__A=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_  )
			def 				lowerCAmelCase    (     self       : str  )			->		List[Any]:
						__A=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_  )
			def 				lowerCAmelCase    (     self       : Dict  )			->		Union[str, Any]:
						__A=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_  )

			@slow
			def 				lowerCAmelCase    (     self       : List[Any]  )			->		Optional[Any]:
						__A=  TFDebertaModel.from_pretrained('kamalkraj/deberta-base'  )
						self.assertIsNotNone(lowerCAmelCase_  )


@require_tf
class 	a__				(				unittest.TestCase      ):





			'''simple docstring'''

			@unittest.skip(reason='Model not available yet'  )
			def 				lowerCAmelCase    (     self       : str  )			->		Dict:
						pass

			@slow
			def 				lowerCAmelCase    (     self       : List[str]  )			->		Dict:
						__A=  TFDebertaModel.from_pretrained('kamalkraj/deberta-base'  )
						__A=  tf.constant([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]]  )
						__A=  tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
						__A=  model(lowerCAmelCase_ ,						attention_mask=lowerCAmelCase_  )[0]

						__A=  tf.constant(
						    [
						        [
						            [-0.59_85_58_96, -0.80_55_25_66, -0.8_46_21_35],
						            [1.4_48_40_25, -0.93_48_37_94, -0.80_59_30_85],
						            [0.3_12_27_41, 0.00_31_60_59, -1.4_13_13_77],
						        ]
						    ]  )
						tf.debugging.assert_near(output[:, 1:4, 1:4] ,						lowerCAmelCase_ ,						atol=1E-4  )







'''simple docstring'''





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


UpperCAmelCase__      =							logging.get_logger(__name__)

UpperCAmelCase__      =							{
    '''dandelin/vilt-b32-mlm''': '''https://huggingface.co/dandelin/vilt-b32-mlm/blob/main/config.json'''
}
class 	a__				(				a_      ):





			'''simple docstring'''

			A	:							Dict							= '''vilt'''
			def __init__(     self       : str ,						lowerCAmelCase_       : Tuple=30_522 ,						lowerCAmelCase_       : List[Any]=2 ,						lowerCAmelCase_       : Optional[Any]=2 ,						lowerCAmelCase_       : Union[str, Any]=40 ,						lowerCAmelCase_       : str=768 ,						lowerCAmelCase_       : Tuple=12 ,						lowerCAmelCase_       : List[Any]=12 ,						lowerCAmelCase_       : int=3_072 ,						lowerCAmelCase_       : List[Any]="gelu" ,						lowerCAmelCase_       : int=0.0 ,						lowerCAmelCase_       : str=0.0 ,						lowerCAmelCase_       : Optional[Any]=0.02 ,						lowerCAmelCase_       : Union[str, Any]=1E-12 ,						lowerCAmelCase_       : Dict=384 ,						lowerCAmelCase_       : Optional[int]=32 ,						lowerCAmelCase_       : Optional[Any]=3 ,						lowerCAmelCase_       : str=True ,						lowerCAmelCase_       : List[Any]=-1 ,						lowerCAmelCase_       : Union[str, Any]=False ,						lowerCAmelCase_       : str=-1 ,						**lowerCAmelCase_       : Any ,						)			->		Tuple:
						super().__init__(tie_word_embeddings=lowerCAmelCase_ ,						**lowerCAmelCase_  )

						__A=  vocab_size
						__A=  type_vocab_size
						__A=  modality_type_vocab_size
						__A=  max_position_embeddings

						__A=  hidden_size
						__A=  num_hidden_layers
						__A=  num_attention_heads
						__A=  intermediate_size
						__A=  hidden_act
						__A=  hidden_dropout_prob
						__A=  attention_probs_dropout_prob
						__A=  initializer_range
						__A=  layer_norm_eps

						__A=  image_size
						__A=  patch_size
						__A=  num_channels
						__A=  qkv_bias
						__A=  max_image_length
						__A=  num_images



