



'''simple docstring'''





import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
    import tensorflow as tf

if is_tensorflow_text_available():
    from transformers.models.bert import TFBertTokenizer


A__    :   Optional[int]           =					["""bert-base-uncased""", """bert-base-cased"""]
A__    :   Optional[Any]           =					"""hf-internal-testing/tiny-bert-tf-only"""

if is_tf_available():



    class  snake_case__						(    tf.keras.Model				):
     def __init__(   self						:							Dict      ,     __a						:							int  )      ->   List[str]:







           '''simple docstring'''
           super().__init__()
           __snake_case :   int													=    tokenizer
           __snake_case :   int													=    AutoConfig.from_pretrained(_lowerCAmelCase  )
           __snake_case :   Optional[int]													=    TFAutoModel.from_config(_lowerCAmelCase  )





     def A_   (   self						:							Optional[Any]      ,     __a						:							Union[str, Any]  )      ->   int:







           '''simple docstring'''
           __snake_case :   Optional[Any]													=    self.tokenizer(_lowerCAmelCase  )
           __snake_case :   int													=    self.bert(**_lowerCAmelCase  )
           return out["pooler_output"]



@require_tf
@require_tensorflow_text
class  snake_case__						(    unittest.TestCase				):
 def A_   (   self						:							Tuple  )      ->   Optional[int]:







       '''simple docstring'''
       super().setUp()

       __snake_case :   Dict													=    [
           BertTokenizer.from_pretrained(_lowerCAmelCase  ) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
       ]  # repeat for when fast_bert_tokenizer=false
       __snake_case :   List[str]													=    [TFBertTokenizer.from_pretrained(_lowerCAmelCase  ) for checkpoint in TOKENIZER_CHECKPOINTS] + [
           TFBertTokenizer.from_pretrained(_lowerCAmelCase      ,     use_fast_bert_tokenizer=_lowerCAmelCase  )
           for checkpoint in TOKENIZER_CHECKPOINTS
       ]
       assert len(self.tokenizers  ) == len(self.tf_tokenizers  )

       __snake_case :   str													=    [
           '''This is a straightforward English test sentence.''',
           '''This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.''',
           '''Now we\'re going to add some Chinese: 一 二 三 一二三''',
           '''And some much more rare Chinese: 齉 堃 齉堃''',
           '''Je vais aussi écrire en français pour tester les accents''',
           '''Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ''',
       ]
       __snake_case :   Optional[Any]													=    list(zip(self.test_sentences      ,     self.test_sentences[::-1]  )  )
 def A_   (   self						:							int  )      ->   Dict:







       '''simple docstring'''




       for tokenizer, tf_tokenizer in zip(self.tokenizers      ,     self.tf_tokenizers  ):
             for test_inputs in (self.test_sentences, self.paired_sentences):
                   __snake_case :   Union[str, Any]													=    tokenizer(_lowerCAmelCase      ,     return_tensors='tf'      ,     padding='longest'  )
                   __snake_case :   List[Any]													=    tf_tokenizer(_lowerCAmelCase  )

                   for key in python_outputs.keys():
                         self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape  )  )
                         self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key]      ,     tf.intaa  ) == tf_outputs[key]  )  )
 @slow
 def A_   (   self						:							str  )      ->   Dict:







       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
             __snake_case :   Tuple													=    tf_tokenizer(self.paired_sentences  )
             __snake_case :   Optional[Any]													=    tf_tokenizer(
                 text=[sentence[0] for sentence in self.paired_sentences]      ,     text_pair=[sentence[1] for sentence in self.paired_sentences]      ,     )
             for key in merged_outputs.keys():
                   self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key]      ,     tf.intaa  ) == separated_outputs[key]  )  )
 @slow
 def A_   (   self						:							Union[str, Any]  )      ->   List[Any]:







       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
             __snake_case :   Any													=    tf.function(_lowerCAmelCase  )
             for test_inputs in (self.test_sentences, self.paired_sentences):
                   __snake_case :   str													=    tf.constant(_lowerCAmelCase  )
                   __snake_case :   Dict													=    compiled_tokenizer(_lowerCAmelCase  )
                   __snake_case :   Union[str, Any]													=    tf_tokenizer(_lowerCAmelCase  )

                   for key in eager_outputs.keys():
                         self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]  )  )





 @slow
 def A_   (   self						:							Union[str, Any]  )      ->   Optional[Any]:







       '''simple docstring'''




       for tf_tokenizer in self.tf_tokenizers:
             __snake_case :   Optional[int]													=    ModelToSave(tokenizer=_lowerCAmelCase  )
             __snake_case :   str													=    tf.convert_to_tensor(self.test_sentences  )
             __snake_case :   Dict													=    model(_lowerCAmelCase  )  # Build model with some sample inputs
             with TemporaryDirectory() as tempdir:
                   __snake_case :   Optional[int]													=    Path(_lowerCAmelCase  ) / '''saved.model'''
                   model.save(_lowerCAmelCase  )
                   __snake_case :   List[str]													=    tf.keras.models.load_model(_lowerCAmelCase  )
             __snake_case :   Tuple													=    loaded_model(_lowerCAmelCase  )
             # We may see small differences because the loaded model is compiled, so we need an epsilon for the test
             self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output  )  )      ,     1e-5  )










from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
							from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


lowerCAmelCase							:       Tuple					 =	logging.get_logger(__name__)

lowerCAmelCase							:       List[Any]					 =	{
    """microsoft/deberta-v2-xlarge""": """https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json""",
    """microsoft/deberta-v2-xxlarge""": """https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json""",
    """microsoft/deberta-v2-xlarge-mnli""": (
        """https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json"""
    ),
    """microsoft/deberta-v2-xxlarge-mnli""": (
        """https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json"""
    ),
}





class 				a			(      __lowercase			):
				SCREAMING_SNAKE_CASE__     :   str		      =     '''deberta-v2'''






				def __init__(  self			, _lowerCAmelCase=128100			, _lowerCAmelCase=1536			, _lowerCAmelCase=24			, _lowerCAmelCase=24			, _lowerCAmelCase=6144			, _lowerCAmelCase="gelu"			, _lowerCAmelCase=0.1			, _lowerCAmelCase=0.1			, _lowerCAmelCase=512			, _lowerCAmelCase=0			, _lowerCAmelCase=0.02			, _lowerCAmelCase=1e-7			, _lowerCAmelCase=False			, _lowerCAmelCase=-1			, _lowerCAmelCase=0			, _lowerCAmelCase=True			, _lowerCAmelCase=None			, _lowerCAmelCase=0			, _lowerCAmelCase="gelu"			, **_lowerCAmelCase			, ):

										"""simple docstring"""




										super().__init__(**_lowerCAmelCase					)

										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   hidden_size
										__SCREAMING_SNAKE_CASE:				Tuple           =   num_hidden_layers
										__SCREAMING_SNAKE_CASE:				str           =   num_attention_heads
										__SCREAMING_SNAKE_CASE:				List[Any]           =   intermediate_size
										__SCREAMING_SNAKE_CASE:				str           =   hidden_act
										__SCREAMING_SNAKE_CASE:				Dict           =   hidden_dropout_prob
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   attention_probs_dropout_prob
										__SCREAMING_SNAKE_CASE:				Dict           =   max_position_embeddings
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   type_vocab_size
										__SCREAMING_SNAKE_CASE:				str           =   initializer_range
										__SCREAMING_SNAKE_CASE:				Any           =   relative_attention
										__SCREAMING_SNAKE_CASE:				Tuple           =   max_relative_positions
										__SCREAMING_SNAKE_CASE:				List[str]           =   pad_token_id
										__SCREAMING_SNAKE_CASE:				List[str]           =   position_biased_input

										# Backwards compatibility
										if type(_lowerCAmelCase					) == str:
																__SCREAMING_SNAKE_CASE:				str           =   [x.strip() for x in pos_att_type.lower().split('''|'''					)]

										__SCREAMING_SNAKE_CASE:				int           =   pos_att_type
										__SCREAMING_SNAKE_CASE:				List[Any]           =   vocab_size
										__SCREAMING_SNAKE_CASE:				List[str]           =   layer_norm_eps

										__SCREAMING_SNAKE_CASE:				Optional[int]           =   kwargs.get('''pooler_hidden_size'''			, _lowerCAmelCase					)
										__SCREAMING_SNAKE_CASE:				Dict           =   pooler_dropout
										__SCREAMING_SNAKE_CASE:				int           =   pooler_hidden_act





class 				a			(      __lowercase			):






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										if self.task == "multiple-choice":
																__SCREAMING_SNAKE_CASE:				Any           =   {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
										else:
																__SCREAMING_SNAKE_CASE:				Any           =   {0: '''batch''', 1: '''sequence'''}
										if self._config.type_vocab_size > 0:
																return OrderedDict(
																    [('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ('''token_type_ids''', dynamic_axis)]					)
										else:
																return OrderedDict([('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis)]					)






				@property
				def 			snake_case_    (  self					):

										"""simple docstring"""




										return 12






				def 			snake_case_    (  self			, _lowerCAmelCase			, _lowerCAmelCase = -1			, _lowerCAmelCase = -1			, _lowerCAmelCase = -1			, _lowerCAmelCase = False			, _lowerCAmelCase = None			, _lowerCAmelCase = 3			, _lowerCAmelCase = 40			, _lowerCAmelCase = 40			, _lowerCAmelCase = None			, ):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				str           =   super().generate_dummy_inputs(preprocessor=_lowerCAmelCase			, framework=_lowerCAmelCase					)
										if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
																del dummy_inputs["token_type_ids"]
										return dummy_inputs



