


import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
     import torch

     from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin






class     _lowerCamelCase					:




       """simple docstring"""



       def __init__( self							,			_SCREAMING_SNAKE_CASE							,			_SCREAMING_SNAKE_CASE=None							,			_SCREAMING_SNAKE_CASE=None							,			_SCREAMING_SNAKE_CASE=None							,			_SCREAMING_SNAKE_CASE="resnet50"							,			_SCREAMING_SNAKE_CASE=3							,			_SCREAMING_SNAKE_CASE=32							,			_SCREAMING_SNAKE_CASE=3							,			_SCREAMING_SNAKE_CASE=True							,			_SCREAMING_SNAKE_CASE=True							,			)->List[str]:




         '''simple docstring'''





         A_ :							Optional[int]							=   parent
         A_ :							List[Any]							=   out_indices if out_indices is not None else [4]
         A_ :							Optional[Any]							=   stage_names
         A_ :							Dict							=   out_features
         A_ :							Optional[Any]							=   backbone
         A_ :							Optional[Any]							=   batch_size
         A_ :							Union[str, Any]							=   image_size
         A_ :							Optional[Any]							=   num_channels
         A_ :							Optional[int]							=   use_pretrained_backbone
         A_ :							Dict							=   is_training



       def 			_snake_case			( self						)->Optional[int]:




         '''simple docstring'''





         A_ :							Tuple							=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)
         A_ :							str							=   self.get_config()

         return config, pixel_values



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




         '''simple docstring'''





         return TimmBackboneConfig(
             image_size=self.image_size							,			num_channels=self.num_channels							,			out_features=self.out_features							,			out_indices=self.out_indices							,			stage_names=self.stage_names							,			use_pretrained_backbone=self.use_pretrained_backbone							,			backbone=self.backbone							,			)



       def 			_snake_case			( self							,			_SCREAMING_SNAKE_CASE							,			_SCREAMING_SNAKE_CASE						)->List[Any]:




         '''simple docstring'''





         A_ :							str							=   TimmBackbone(config=__UpperCamelCase						)
         model.to(__UpperCamelCase						)
         model.eval()
         with torch.no_grad():
           A_ :							Dict							=   model(__UpperCamelCase						)
         self.parent.assertEqual(
             result.feature_map[-1].shape							,			(self.batch_size, model.channels[-1], 14, 14)							,			)







       def 			_snake_case			( self						)->Optional[int]:




         '''simple docstring'''





         A_ :							Optional[int]							=   self.prepare_config_and_inputs()
         A_	,			A_ :							Optional[Any]							=   config_and_inputs
         A_ :							Union[str, Any]							=   {'''pixel_values''': pixel_values}
         return config, inputs_dict






@require_torch
@require_timm
class     _lowerCamelCase					(   UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   ,				unittest.TestCase     ):




       """simple docstring"""
       snake_case    =       (TimmBackbone,) if is_torch_available() else ()
       snake_case    =       {"feature-extraction": TimmBackbone} if is_torch_available() else {}
       snake_case    =       False
       snake_case    =       False
       snake_case    =       False
       snake_case    =       False



       def 			_snake_case			( self						)->Union[str, Any]:




         '''simple docstring'''





         A_ :							List[str]							=   TimmBackboneModelTester(self						)
         A_ :							Union[str, Any]							=   ConfigTester(self							,			config_class=__UpperCamelCase							,			has_text_modality=__UpperCamelCase						)



       def 			_snake_case			( self						)->Any:




         '''simple docstring'''





         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 			_snake_case			( self						)->List[Any]:




         '''simple docstring'''





         A_ :							Dict							=   '''resnet18'''
         A_ :							str							=   '''microsoft/resnet-18'''

         A_ :							str							=   AutoBackbone.from_pretrained(__UpperCamelCase							,			use_timm_backbone=__UpperCamelCase						)
         A_ :							str							=   AutoBackbone.from_pretrained(__UpperCamelCase						)

         self.assertEqual(len(timm_model.out_features						)							,			len(transformers_model.out_features						)						)
         self.assertEqual(len(timm_model.stage_names						)							,			len(transformers_model.stage_names						)						)
         self.assertEqual(timm_model.channels							,			transformers_model.channels						)
         # Out indices are set to the last layer by default. For timm models, we don't know
         # the number of layers in advance, so we set it to (-1,), whereas for transformers
         # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
         self.assertEqual(timm_model.out_indices							,			(-1,)						)
         self.assertEqual(transformers_model.out_indices							,			[len(timm_model.stage_names						) - 1]						)

         A_ :							Union[str, Any]							=   AutoBackbone.from_pretrained(__UpperCamelCase							,			use_timm_backbone=__UpperCamelCase							,			out_indices=[1, 2, 3]						)
         A_ :							List[str]							=   AutoBackbone.from_pretrained(__UpperCamelCase							,			out_indices=[1, 2, 3]						)

         self.assertEqual(timm_model.out_indices							,			transformers_model.out_indices						)
         self.assertEqual(len(timm_model.out_features						)							,			len(transformers_model.out_features						)						)
         self.assertEqual(timm_model.channels							,			transformers_model.channels						)



       @unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''						)
       def 			_snake_case			( self						)->Optional[Any]:




         '''simple docstring'''





         pass



       @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''						)
       def 			_snake_case			( self						)->Union[str, Any]:




         '''simple docstring'''





         pass



       @unittest.skip('''TimmBackbone initialization is managed on the timm side'''						)
       def 			_snake_case			( self						)->int:




         '''simple docstring'''





         pass



       @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''						)
       def 			_snake_case			( self						)->Any:




         '''simple docstring'''





         pass



       @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''						)
       def 			_snake_case			( self						)->Dict:




         '''simple docstring'''





         pass



       @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''						)
       def 			_snake_case			( self						)->Tuple:




         '''simple docstring'''





         pass



       @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''						)
       def 			_snake_case			( self						)->Any:




         '''simple docstring'''





         pass



       @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''						)
       def 			_snake_case			( self						)->Dict:




         '''simple docstring'''





         pass



       @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''						)
       def 			_snake_case			( self						)->int:




         '''simple docstring'''





         pass



       @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''						)
       def 			_snake_case			( self						)->Union[str, Any]:




         '''simple docstring'''





         pass



       @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''						)
       def 			_snake_case			( self						)->int:




         '''simple docstring'''





         pass



       @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''						)
       def 			_snake_case			( self						)->str:




         '''simple docstring'''





         pass



       @unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''						)
       def 			_snake_case			( self						)->Tuple:




         '''simple docstring'''





         pass



       @unittest.skip('''Safetensors is not supported by timm.'''						)
       def 			_snake_case			( self						)->Any:




         '''simple docstring'''





         pass



       @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''						)
       def 			_snake_case			( self						)->Any:




         '''simple docstring'''





         pass



       def 			_snake_case			( self						)->Dict:




         '''simple docstring'''





         A_	,			A_ :							int							=   self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           A_ :							int							=   model_class(__UpperCamelCase						)
           A_ :							Optional[Any]							=   inspect.signature(model.forward						)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           A_ :							Any							=   [*signature.parameters.keys()]

           A_ :							str							=   ['''pixel_values''']
           self.assertListEqual(arg_names[:1]							,			__UpperCamelCase						)



       def 			_snake_case			( self						)->Union[str, Any]:




         '''simple docstring'''





         A_	,			A_ :							Optional[int]							=   self.model_tester.prepare_config_and_inputs_for_common()
         A_ :							Optional[Any]							=   True
         A_ :							Tuple							=   self.has_attentions

         # no need to test all models as different heads yield the same functionality
         A_ :							Dict							=   self.all_model_classes[0]
         A_ :							str							=   model_class(__UpperCamelCase						)
         model.to(__UpperCamelCase						)

         A_ :							str							=   self._prepare_for_class(__UpperCamelCase							,			__UpperCamelCase						)
         A_ :							Union[str, Any]							=   model(**__UpperCamelCase						)
         A_ :							Any							=   outputs[0][-1]

         # Encoder-/Decoder-only models
         A_ :							Optional[Any]							=   outputs.hidden_states[0]
         hidden_states.retain_grad()

         if self.has_attentions:
           A_ :							Any							=   outputs.attentions[0]
           attentions.retain_grad()

         output.flatten()[0].backward(retain_graph=__UpperCamelCase						)

         self.assertIsNotNone(hidden_states.grad						)

         if self.has_attentions:
           self.assertIsNotNone(attentions.grad						)







       def 			_snake_case			( self						)->List[Any]:




         '''simple docstring'''





         A_	,			A_ :							Tuple							=   self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           A_ :							Optional[Any]							=   model_class(__UpperCamelCase						)
           model.to(__UpperCamelCase						)
           model.eval()
           A_ :							int							=   model(**__UpperCamelCase						)

           self.assertEqual(len(result.feature_maps						)							,			len(config.out_indices						)						)
           self.assertEqual(len(model.channels						)							,			len(config.out_indices						)						)

           # Check output of last stage is taken if out_features=None, out_indices=None
           A_ :							List[Any]							=   copy.deepcopy(__UpperCamelCase						)
           A_ :							str							=   None
           A_ :							Optional[int]							=   model_class(__UpperCamelCase						)
           model.to(__UpperCamelCase						)
           model.eval()
           A_ :							List[Any]							=   model(**__UpperCamelCase						)

           self.assertEqual(len(result.feature_maps						)							,			1						)
           self.assertEqual(len(model.channels						)							,			1						)

           # Check backbone can be initialized with fresh weights
           A_ :							List[str]							=   copy.deepcopy(__UpperCamelCase						)
           A_ :							str							=   False
           A_ :							List[str]							=   model_class(__UpperCamelCase						)
           model.to(__UpperCamelCase						)
           model.eval()
           A_ :							Optional[Any]							=   model(**__UpperCamelCase						)






from __future__ import annotations

import unittest

from transformers import DebertaVaConfig, 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 (
		    TFDebertaVaForMaskedLM,
		    TFDebertaVaForQuestionAnswering,
		    TFDebertaVaForSequenceClassification,
		    TFDebertaVaForTokenClassification,
		    TFDebertaVaModel,
		)





class    __A:

					def __init__(						self       :  List[Any] ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  Any=1_3 ,       __UpperCamelCase       :  Optional[int]=7 ,       __UpperCamelCase       :  Any=True ,       __UpperCamelCase       :  Dict=True ,       __UpperCamelCase       :  Optional[Any]=True ,       __UpperCamelCase       :  Dict=True ,       __UpperCamelCase       :  Union[str, Any]=9_9 ,       __UpperCamelCase       :  List[str]=3_2 ,       __UpperCamelCase       :  int=2 ,       __UpperCamelCase       :  Optional[Any]=4 ,       __UpperCamelCase       :  Optional[int]=3_7 ,       __UpperCamelCase       :  Optional[Any]="gelu" ,       __UpperCamelCase       :  int=0.1 ,       __UpperCamelCase       :  str=0.1 ,       __UpperCamelCase       :  Tuple=5_1_2 ,       __UpperCamelCase       :  Any=1_6 ,       __UpperCamelCase       :  Dict=2 ,       __UpperCamelCase       :  Optional[Any]=0.02 ,       __UpperCamelCase       :  Optional[Any]=False ,       __UpperCamelCase       :  Dict=True ,       __UpperCamelCase       :  Any="None" ,       __UpperCamelCase       :  List[Any]=3 ,       __UpperCamelCase       :  Optional[int]=4 ,       __UpperCamelCase       :  Dict=None ,       ):
												lowerCamelCase_					=       parent
												lowerCamelCase_					=       batch_size
												lowerCamelCase_					=       seq_length
												lowerCamelCase_					=       is_training
												lowerCamelCase_					=       use_input_mask
												lowerCamelCase_					=       use_token_type_ids
												lowerCamelCase_					=       use_labels
												lowerCamelCase_					=       vocab_size
												lowerCamelCase_					=       hidden_size
												lowerCamelCase_					=       num_hidden_layers
												lowerCamelCase_					=       num_attention_heads
												lowerCamelCase_					=       intermediate_size
												lowerCamelCase_					=       hidden_act
												lowerCamelCase_					=       hidden_dropout_prob
												lowerCamelCase_					=       attention_probs_dropout_prob
												lowerCamelCase_					=       max_position_embeddings
												lowerCamelCase_					=       type_vocab_size
												lowerCamelCase_					=       type_sequence_label_size
												lowerCamelCase_					=       initializer_range
												lowerCamelCase_					=       num_labels
												lowerCamelCase_					=       num_choices
												lowerCamelCase_					=       relative_attention
												lowerCamelCase_					=       position_biased_input
												lowerCamelCase_					=       pos_att_type
												lowerCamelCase_					=       scope

					def  lowercase__   (						self       :  Optional[Any] ):
												lowerCamelCase_					=       ids_tensor([self.batch_size, self.seq_length] ,       self.vocab_size )

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

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

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

												lowerCamelCase_					=       DebertaVaConfig(
												    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 ,       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  lowercase__   (						self       :  str ,       __UpperCamelCase       :  Union[str, Any] ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  Optional[Any] ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  Any ,       __UpperCamelCase       :  int ,       __UpperCamelCase       :  List[str] ):
												lowerCamelCase_					=       TFDebertaVaModel(config=__UpperCamelCase )
												lowerCamelCase_					=       {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

												lowerCamelCase_					=       [input_ids, input_mask]
												lowerCamelCase_					=       model(__UpperCamelCase )

												lowerCamelCase_					=       model(__UpperCamelCase )

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

					def  lowercase__   (						self       :  Optional[int] ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Dict ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  int ):
												lowerCamelCase_					=       TFDebertaVaForMaskedLM(config=__UpperCamelCase )
												lowerCamelCase_					=       {
												    """input_ids""": input_ids,
												    """attention_mask""": input_mask,
												    """token_type_ids""": token_type_ids,
												}
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.vocab_size) )

					def  lowercase__   (						self       :  List[Any] ,       __UpperCamelCase       :  Union[str, Any] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  int ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  List[Any] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  List[Any] ):
												lowerCamelCase_					=       self.num_labels
												lowerCamelCase_					=       TFDebertaVaForSequenceClassification(config=__UpperCamelCase )
												lowerCamelCase_					=       {
												    """input_ids""": input_ids,
												    """attention_mask""": input_mask,
												    """token_type_ids""": token_type_ids,
												}

												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.num_labels) )

					def  lowercase__   (						self       :  int ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  Any ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  List[Any] ,       __UpperCamelCase       :  List[Any] ):
												lowerCamelCase_					=       self.num_labels
												lowerCamelCase_					=       TFDebertaVaForTokenClassification(config=__UpperCamelCase )
												lowerCamelCase_					=       {
												    """input_ids""": input_ids,
												    """attention_mask""": input_mask,
												    """token_type_ids""": token_type_ids,
												}
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.seq_length, self.num_labels) )

					def  lowercase__   (						self       :  List[Any] ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  Optional[Any] ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Optional[Any] ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  int ):
												lowerCamelCase_					=       TFDebertaVaForQuestionAnswering(config=__UpperCamelCase )
												lowerCamelCase_					=       {
												    """input_ids""": input_ids,
												    """attention_mask""": input_mask,
												    """token_type_ids""": token_type_ids,
												}

												lowerCamelCase_					=       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  lowercase__   (						self       :  Dict ):
												lowerCamelCase_					=       self.prepare_config_and_inputs()
												(
												    (
												    lowerCamelCase_
												)	, (
												    lowerCamelCase_
												)	, (
												    lowerCamelCase_
												)	, (
												    lowerCamelCase_
												)	, (
												    lowerCamelCase_
												)	, (
												    lowerCamelCase_
												)	, (
												    lowerCamelCase_
												)	, 
												)					=       config_and_inputs
												lowerCamelCase_					=       {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
												return config, inputs_dict





@require_tf
class    __A(					UpperCAmelCase  ,		UpperCAmelCase  ,		unittest.TestCase							):
					SCREAMING_SNAKE_CASE           =     (
					    (
					        TFDebertaVaModel,
					        TFDebertaVaForMaskedLM,
					        TFDebertaVaForQuestionAnswering,
					        TFDebertaVaForSequenceClassification,
					        TFDebertaVaForTokenClassification,
					    )
					    if is_tf_available()
					    else ()
					)
					SCREAMING_SNAKE_CASE           =     (
					    {
					        '''feature-extraction''': TFDebertaVaModel,
					        '''fill-mask''': TFDebertaVaForMaskedLM,
					        '''question-answering''': TFDebertaVaForQuestionAnswering,
					        '''text-classification''': TFDebertaVaForSequenceClassification,
					        '''token-classification''': TFDebertaVaForTokenClassification,
					        '''zero-shot''': TFDebertaVaForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)

					SCREAMING_SNAKE_CASE           =     False
					SCREAMING_SNAKE_CASE           =     False

					def  lowercase__   (						self       :  Dict ):
												lowerCamelCase_					=       TFDebertaVaModelTester(self )
												lowerCamelCase_					=       ConfigTester(self ,       config_class=__UpperCamelCase ,       hidden_size=3_7 )

					def  lowercase__   (						self       :  Dict ):
												self.config_tester.run_common_tests()

					def  lowercase__   (						self       :  Optional[Any] ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__UpperCamelCase )

					def  lowercase__   (						self       :  Dict ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase )

					def  lowercase__   (						self       :  List[Any] ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase )

					def  lowercase__   (						self       :  Tuple ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase )

					def  lowercase__   (						self       :  Any ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase )



					@slow
					def  lowercase__   (						self       :  int ):
												lowerCamelCase_					=       TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge""" )
												self.assertIsNotNone(__UpperCamelCase )





@require_tf
class    __A(					unittest.TestCase							):

					@unittest.skip(reason="""Model not available yet""" )
					def  lowercase__   (						self       :  Optional[int] ):
												pass



					@slow
					def  lowercase__   (						self       :  Any ):
												lowerCamelCase_					=       TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge""" )
												lowerCamelCase_					=       tf.constant([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]] )
												lowerCamelCase_					=       tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
												lowerCamelCase_					=       model(__UpperCamelCase ,       attention_mask=__UpperCamelCase )[0]

												lowerCamelCase_					=       tf.constant(
												    [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]] )
												tf.debugging.assert_near(output[:, 1:4, 1:4] ,       __UpperCamelCase ,       atol=1E-4 )





