


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      :






		def __init__(  self	,     __UpperCamelCase	,     __UpperCamelCase=13	,     __UpperCamelCase=7	,     __UpperCamelCase=True	,     __UpperCamelCase=True	,     __UpperCamelCase=True	,     __UpperCamelCase=True	,     __UpperCamelCase=99	,     __UpperCamelCase=32	,     __UpperCamelCase=2	,     __UpperCamelCase=4	,     __UpperCamelCase=37	,     __UpperCamelCase="gelu"	,     __UpperCamelCase=0.1	,     __UpperCamelCase=0.1	,     __UpperCamelCase=5_12	,     __UpperCamelCase=16	,     __UpperCamelCase=2	,     __UpperCamelCase=0.02	,     __UpperCamelCase=3	,     __UpperCamelCase=4	,     __UpperCamelCase=None	,     )->			Optional[int]:
						'''simple docstring'''


						A__     :							Any   				=parent
						A__     :							Optional[Any]   				=13
						A__     :							Dict   				=7
						A__     :							Any   				=True
						A__     :							Optional[Any]   				=True
						A__     :							str   				=True
						A__     :							Dict   				=True
						A__     :							Dict   				=99
						A__     :							Optional[Any]   				=32
						A__     :							Optional[int]   				=2
						A__     :							Optional[int]   				=4
						A__     :							str   				=37
						A__     :							Dict   				='''gelu'''
						A__     :							Tuple   				=0.1
						A__     :							Optional[int]   				=0.1
						A__     :							Optional[Any]   				=5_12
						A__     :							List[str]   				=16
						A__     :							str   				=False
						A__     :							str   				=-1
						A__     :							Union[str, Any]   				=True
						A__     :							int   				=2
						A__     :							Tuple   				=0.02
						A__     :							Optional[Any]   				=3
						A__     :							Any   				=4
						A__     :							Optional[Any]   				=None






		def       lowerCAmelCase_  (  self							)->			List[str]:
						'''simple docstring'''


						A__     :							Optional[int]   				=ids_tensor([self.batch_size, self.seq_length]	,     self.vocab_size							)

						A__     :							Dict   				=None
						if self.use_input_mask:
										A__     :							Union[str, Any]   				=random_attention_mask([self.batch_size, self.seq_length]							)

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

						A__     :							Optional[int]   				=None
						A__     :							int   				=None
						A__     :							List[str]   				=None
						if self.use_labels:
										A__     :							Any   				=ids_tensor([self.batch_size]	,     self.type_sequence_label_size							)
										A__     :							str   				=ids_tensor([self.batch_size, self.seq_length]	,     self.num_labels							)

						A__     :							List[Any]   				=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=UpperCamelCase__	,     )

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			List[str]:
						'''simple docstring'''


						A__     :							Tuple   				=TFDebertaModel(config=UpperCamelCase__							)
						A__     :							Optional[Any]   				={'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

						A__     :							Dict   				=[input_ids, input_mask]
						A__     :							Optional[Any]   				=model(UpperCamelCase__							)

						A__     :							List[str]   				=model(UpperCamelCase__							)

						self.parent.assertEqual(result.last_hidden_state.shape	,     (self.batch_size, self.seq_length, self.hidden_size)							)






		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			int:
						'''simple docstring'''


						A__     :							Dict   				=TFDebertaForMaskedLM(config=UpperCamelCase__							)
						A__     :							str   				={
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}
						A__     :							Any   				=model(UpperCamelCase__							)
						self.parent.assertEqual(result.logits.shape	,     (self.batch_size, self.seq_length, self.vocab_size)							)






		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			Optional[int]:
						'''simple docstring'''


						A__     :							Optional[int]   				=self.num_labels
						A__     :							Optional[int]   				=TFDebertaForSequenceClassification(config=UpperCamelCase__							)
						A__     :							str   				={
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}

						A__     :							List[Any]   				=model(UpperCamelCase__							)
						self.parent.assertEqual(result.logits.shape	,     (self.batch_size, self.num_labels)							)






		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			Optional[Any]:
						'''simple docstring'''


						A__     :							Dict   				=self.num_labels
						A__     :							int   				=TFDebertaForTokenClassification(config=UpperCamelCase__							)
						A__     :							List[Any]   				={
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}
						A__     :							int   				=model(UpperCamelCase__							)
						self.parent.assertEqual(result.logits.shape	,     (self.batch_size, self.seq_length, self.num_labels)							)






		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			Optional[Any]:
						'''simple docstring'''


						A__     :							List[Any]   				=TFDebertaForQuestionAnswering(config=UpperCamelCase__							)
						A__     :							Optional[Any]   				={
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}

						A__     :							List[Any]   				=model(UpperCamelCase__							)
						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							)->			str:
						'''simple docstring'''


						A__     :							Optional[Any]   				=self.prepare_config_and_inputs()
						(
						    A__
						)     :							Optional[int]   				=config_and_inputs
						A__     :							int   				={'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
						return config, inputs_dict







@require_tf
class 			a      (      __SCREAMING_SNAKE_CASE      ,__SCREAMING_SNAKE_CASE      ,unittest.TestCase   ):
		__lowercase													=		(
		    (
		        TFDebertaModel,
		        TFDebertaForMaskedLM,
		        TFDebertaForQuestionAnswering,
		        TFDebertaForSequenceClassification,
		        TFDebertaForTokenClassification,
		    )
		    if is_tf_available()
		    else ()
		)
		__lowercase													=		(
		    {
		        """feature-extraction""": TFDebertaModel,
		        """fill-mask""": TFDebertaForMaskedLM,
		        """question-answering""": TFDebertaForQuestionAnswering,
		        """text-classification""": TFDebertaForSequenceClassification,
		        """token-classification""": TFDebertaForTokenClassification,
		        """zero-shot""": TFDebertaForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)

		__lowercase													=		False
		__lowercase													=		False






		def       lowerCAmelCase_  (  self							)->			Optional[Any]:
						'''simple docstring'''


						A__     :							Tuple   				=TFDebertaModelTester(self							)
						A__     :							Tuple   				=ConfigTester(self	,     config_class=UpperCamelCase__	,     hidden_size=37							)






		def       lowerCAmelCase_  (  self							)->			Dict:
						'''simple docstring'''


						self.config_tester.run_common_tests()






		def       lowerCAmelCase_  (  self							)->			List[Any]:
						'''simple docstring'''


						A__     :							str   				=self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCamelCase__							)






		def       lowerCAmelCase_  (  self							)->			str:
						'''simple docstring'''


						A__     :							Optional[int]   				=self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase__							)






		def       lowerCAmelCase_  (  self							)->			Optional[int]:
						'''simple docstring'''


						A__     :							List[str]   				=self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__							)






		def       lowerCAmelCase_  (  self							)->			Union[str, Any]:
						'''simple docstring'''


						A__     :							List[Any]   				=self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__							)






		def       lowerCAmelCase_  (  self							)->			Tuple:
						'''simple docstring'''


						A__     :							Dict   				=self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__							)






		@slow
		def       lowerCAmelCase_  (  self							)->			Dict:
						'''simple docstring'''


						A__     :							List[str]   				=TFDebertaModel.from_pretrained('''kamalkraj/deberta-base'''							)
						self.assertIsNotNone(UpperCamelCase__							)







@require_tf
class 			a      (      unittest.TestCase   ):






		@unittest.skip(reason='''Model not available yet'''							)
		def       lowerCAmelCase_  (  self							)->			List[str]:
						'''simple docstring'''


						pass






		@slow
		def       lowerCAmelCase_  (  self							)->			List[Any]:
						'''simple docstring'''


						A__     :							Union[str, Any]   				=TFDebertaModel.from_pretrained('''kamalkraj/deberta-base'''							)
						A__     :							List[Any]   				=tf.constant([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]]							)
						A__     :							str   				=tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]							)
						A__     :							Tuple   				=model(UpperCamelCase__	,     attention_mask=UpperCamelCase__							)[0]

						A__     :							Optional[int]   				=tf.constant(
						    [
						        [
						            [-0.5985_5896, -0.8055_2566, -0.846_2135],
						            [1.448_4025, -0.9348_3794, -0.8059_3085],
						            [0.312_2741, 0.0031_6059, -1.413_1377],
						        ]
						    ]							)
						tf.debugging.assert_near(output[:, 1:4, 1:4]	,     UpperCamelCase__	,     atol=1E-4							)







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__lowerCamelCase       :       str				   =			{
    "configuration_align": [
        "ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "AlignConfig",
        "AlignTextConfig",
        "AlignVisionConfig",
    ],
    "processing_align": ["AlignProcessor"],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowerCamelCase       :       Dict				   =			[
						    "ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "AlignModel",
						    "AlignPreTrainedModel",
						    "AlignTextModel",
						    "AlignVisionModel",
						]

if TYPE_CHECKING:
						from .configuration_align import (
						    ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    AlignConfig,
						    AlignTextConfig,
						    AlignVisionConfig,
						)
						from .processing_align import AlignProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_align import (
												    ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST,
												    AlignModel,
												    AlignPreTrainedModel,
												    AlignTextModel,
												    AlignVisionModel,
												)

else:
						import sys

						__lowerCamelCase       :       List[str]				   =			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



