
import unittest

from transformers import YosoConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    YosoForMaskedLM,
		    YosoForMultipleChoice,
		    YosoForQuestionAnswering,
		    YosoForSequenceClassification,
		    YosoForTokenClassification,
		    YosoModel,
		)
		from transformers.models.yoso.modeling_yoso import YOSO_PRETRAINED_MODEL_ARCHIVE_LIST


class 						__magic_name__      :





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





		def 					_A							(							self			:		Optional[int] ):
							lowerCAmelCase						:    Optional[int]     		=   ids_tensor([self.batch_size, self.seq_length]  ,     self.vocab_size )

							lowerCAmelCase						:    Optional[int]     		=   None
							if self.use_input_mask:
												lowerCAmelCase						:    Union[str, Any]     		=   random_attention_mask([self.batch_size, self.seq_length] )

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

							lowerCAmelCase						:    Optional[int]     		=   None
							lowerCAmelCase						:    int     		=   None
							lowerCAmelCase						:    Any     		=   None
							if self.use_labels:
												lowerCAmelCase						:    Tuple     		=   ids_tensor([self.batch_size]  ,     self.type_sequence_label_size )
												lowerCAmelCase						:    Optional[int]     		=   ids_tensor([self.batch_size, self.seq_length]  ,     self.num_labels )
												lowerCAmelCase						:    Optional[int]     		=   ids_tensor([self.batch_size]  ,     self.num_choices )

							lowerCAmelCase						:    Tuple     		=   self.get_config()

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





		def 					_A							(							self			:		Dict ):
							return YosoConfig(
							    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  ,     is_decoder=lowercase__  ,     initializer_range=self.initializer_range  ,     )





		def 					_A							(							self			:		Union[str, Any] ):
							lowerCAmelCase						:    List[str]     		=   self.get_config()
							lowerCAmelCase						:    Optional[int]     		=   3_0_0
							return config





		def 					_A							(							self			:		str ):
							(
							    (
							    lowerCAmelCase					
							)		,							(
							    lowerCAmelCase					
							)		,							(
							    lowerCAmelCase					
							)		,							(
							    lowerCAmelCase					
							)		,							(
							    lowerCAmelCase					
							)		,							(
							    lowerCAmelCase					
							)		,							(
							    lowerCAmelCase					
							)		,												
							)						:    Any     		=   self.prepare_config_and_inputs()

							lowerCAmelCase						:    Tuple     		=   True
							lowerCAmelCase						:    Optional[int]     		=   floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
							lowerCAmelCase						:    List[str]     		=   ids_tensor([self.batch_size, self.seq_length]  ,     vocab_size=2 )

							return (
							    config,
							    input_ids,
							    token_type_ids,
							    input_mask,
							    sequence_labels,
							    token_labels,
							    choice_labels,
							    encoder_hidden_states,
							    encoder_attention_mask,
							)





		def 					_A							(							self			:		int  ,     lowerCamelCase__			:		Tuple  ,     lowerCamelCase__			:		int  ,     lowerCamelCase__			:		Any  ,     lowerCamelCase__			:		Optional[Any]  ,     lowerCamelCase__			:		str  ,     lowerCamelCase__			:		Tuple  ,     lowerCamelCase__			:		List[Any] ):
							lowerCAmelCase						:    int     		=   YosoModel(config=lowercase__ )
							model.to(lowercase__ )
							model.eval()
							lowerCAmelCase						:    int     		=   model(lowercase__  ,     attention_mask=lowercase__  ,     token_type_ids=lowercase__ )
							lowerCAmelCase						:    List[Any]     		=   model(lowercase__  ,     token_type_ids=lowercase__ )
							lowerCAmelCase						:    int     		=   model(lowercase__ )
							self.parent.assertEqual(result.last_hidden_state.shape  ,     (self.batch_size, self.seq_length, self.hidden_size) )





		def 					_A							(							self			:		Tuple  ,     lowerCamelCase__			:		Optional[int]  ,     lowerCamelCase__			:		List[Any]  ,     lowerCamelCase__			:		Any  ,     lowerCamelCase__			:		Optional[Any]  ,     lowerCamelCase__			:		Dict  ,     lowerCamelCase__			:		List[str]  ,     lowerCamelCase__			:		Optional[Any]  ,     lowerCamelCase__			:		Tuple  ,     lowerCamelCase__			:		int  ,     ):
							lowerCAmelCase						:    Any     		=   True
							lowerCAmelCase						:    Optional[Any]     		=   YosoModel(lowercase__ )
							model.to(lowercase__ )
							model.eval()
							lowerCAmelCase						:    Optional[int]     		=   model(
							    lowercase__  ,     attention_mask=lowercase__  ,     token_type_ids=lowercase__  ,     encoder_hidden_states=lowercase__  ,     encoder_attention_mask=lowercase__  ,     )
							lowerCAmelCase						:    Dict     		=   model(
							    lowercase__  ,     attention_mask=lowercase__  ,     token_type_ids=lowercase__  ,     encoder_hidden_states=lowercase__  ,     )
							lowerCAmelCase						:    Optional[Any]     		=   model(lowercase__  ,     attention_mask=lowercase__  ,     token_type_ids=lowercase__ )
							self.parent.assertEqual(result.last_hidden_state.shape  ,     (self.batch_size, self.seq_length, self.hidden_size) )





		def 					_A							(							self			:		Dict  ,     lowerCamelCase__			:		Any  ,     lowerCamelCase__			:		List[Any]  ,     lowerCamelCase__			:		Any  ,     lowerCamelCase__			:		Optional[Any]  ,     lowerCamelCase__			:		Dict  ,     lowerCamelCase__			:		List[Any]  ,     lowerCamelCase__			:		Tuple ):
							lowerCAmelCase						:    Union[str, Any]     		=   YosoForMaskedLM(config=lowercase__ )
							model.to(lowercase__ )
							model.eval()
							lowerCAmelCase						:    Any     		=   model(lowercase__  ,     attention_mask=lowercase__  ,     token_type_ids=lowercase__  ,     labels=lowercase__ )
							self.parent.assertEqual(result.logits.shape  ,     (self.batch_size, self.seq_length, self.vocab_size) )





		def 					_A							(							self			:		Any  ,     lowerCamelCase__			:		Tuple  ,     lowerCamelCase__			:		Optional[Any]  ,     lowerCamelCase__			:		int  ,     lowerCamelCase__			:		List[Any]  ,     lowerCamelCase__			:		List[str]  ,     lowerCamelCase__			:		List[str]  ,     lowerCamelCase__			:		Optional[int] ):
							lowerCAmelCase						:    Optional[int]     		=   YosoForQuestionAnswering(config=lowercase__ )
							model.to(lowercase__ )
							model.eval()
							lowerCAmelCase						:    Union[str, Any]     		=   model(
							    lowercase__  ,     attention_mask=lowercase__  ,     token_type_ids=lowercase__  ,     start_positions=lowercase__  ,     end_positions=lowercase__  ,     )
							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 					_A							(							self			:		Optional[int]  ,     lowerCamelCase__			:		List[Any]  ,     lowerCamelCase__			:		Optional[Any]  ,     lowerCamelCase__			:		Union[str, Any]  ,     lowerCamelCase__			:		Any  ,     lowerCamelCase__			:		Optional[int]  ,     lowerCamelCase__			:		Tuple  ,     lowerCamelCase__			:		Union[str, Any] ):
							lowerCAmelCase						:    Dict     		=   self.num_labels
							lowerCAmelCase						:    Optional[Any]     		=   YosoForSequenceClassification(lowercase__ )
							model.to(lowercase__ )
							model.eval()
							lowerCAmelCase						:    str     		=   model(lowercase__  ,     attention_mask=lowercase__  ,     token_type_ids=lowercase__  ,     labels=lowercase__ )
							self.parent.assertEqual(result.logits.shape  ,     (self.batch_size, self.num_labels) )





		def 					_A							(							self			:		Union[str, Any]  ,     lowerCamelCase__			:		Optional[Any]  ,     lowerCamelCase__			:		Optional[Any]  ,     lowerCamelCase__			:		Union[str, Any]  ,     lowerCamelCase__			:		List[Any]  ,     lowerCamelCase__			:		int  ,     lowerCamelCase__			:		List[str]  ,     lowerCamelCase__			:		Any ):
							lowerCAmelCase						:    str     		=   self.num_labels
							lowerCAmelCase						:    List[str]     		=   YosoForTokenClassification(config=lowercase__ )
							model.to(lowercase__ )
							model.eval()
							lowerCAmelCase						:    List[str]     		=   model(lowercase__  ,     attention_mask=lowercase__  ,     token_type_ids=lowercase__  ,     labels=lowercase__ )
							self.parent.assertEqual(result.logits.shape  ,     (self.batch_size, self.seq_length, self.num_labels) )





		def 					_A							(							self			:		Any  ,     lowerCamelCase__			:		Tuple  ,     lowerCamelCase__			:		int  ,     lowerCamelCase__			:		List[str]  ,     lowerCamelCase__			:		Union[str, Any]  ,     lowerCamelCase__			:		List[str]  ,     lowerCamelCase__			:		Union[str, Any]  ,     lowerCamelCase__			:		int ):
							lowerCAmelCase						:    int     		=   self.num_choices
							lowerCAmelCase						:    Optional[Any]     		=   YosoForMultipleChoice(config=lowercase__ )
							model.to(lowercase__ )
							model.eval()
							lowerCAmelCase						:    Union[str, Any]     		=   input_ids.unsqueeze(1 ).expand(-1  ,     self.num_choices  ,     -1 ).contiguous()
							lowerCAmelCase						:    List[str]     		=   token_type_ids.unsqueeze(1 ).expand(-1  ,     self.num_choices  ,     -1 ).contiguous()
							lowerCAmelCase						:    Any     		=   input_mask.unsqueeze(1 ).expand(-1  ,     self.num_choices  ,     -1 ).contiguous()
							lowerCAmelCase						:    Optional[Any]     		=   model(
							    lowercase__  ,     attention_mask=lowercase__  ,     token_type_ids=lowercase__  ,     labels=lowercase__  ,     )
							self.parent.assertEqual(result.logits.shape  ,     (self.batch_size, self.num_choices) )





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



@require_torch
class 						__magic_name__      (  snake_case, snake_case, unittest.TestCase			):
		_lowerCAmelCase						=		(
		    (
		        YosoModel,
		        YosoForMaskedLM,
		        YosoForMultipleChoice,
		        YosoForQuestionAnswering,
		        YosoForSequenceClassification,
		        YosoForTokenClassification,
		    )
		    if is_torch_available()
		    else ()
		)
		_lowerCAmelCase						=		False
		_lowerCAmelCase						=		False
		_lowerCAmelCase						=		False

		_lowerCAmelCase						=		()
		_lowerCAmelCase						=		(
		    {
		        "feature-extraction": YosoModel,
		        "fill-mask": YosoForMaskedLM,
		        "question-answering": YosoForQuestionAnswering,
		        "text-classification": YosoForSequenceClassification,
		        "token-classification": YosoForTokenClassification,
		        "zero-shot": YosoForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)





		def 					_A							(							self			:		str ):
							lowerCAmelCase						:    Any     		=   YosoModelTester(self )
							lowerCAmelCase						:    int     		=   ConfigTester(self  ,     config_class=lowercase__  ,     hidden_size=3_7 )





		def 					_A							(							self			:		Tuple ):
							self.config_tester.run_common_tests()





		def 					_A							(							self			:		List[str] ):
							lowerCAmelCase						:    Union[str, Any]     		=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase__ )





		def 					_A							(							self			:		List[str] ):
							lowerCAmelCase						:    Dict     		=   self.model_tester.prepare_config_and_inputs()
							for type in ["absolute", "relative_key", "relative_key_query"]:
												lowerCAmelCase						:    Dict     		=   type
												self.model_tester.create_and_check_model(*lowercase__ )





		def 					_A							(							self			:		str ):
							lowerCAmelCase						:    Dict     		=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*lowercase__ )





		def 					_A							(							self			:		int ):
							lowerCAmelCase						:    List[Any]     		=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*lowercase__ )





		def 					_A							(							self			:		int ):
							lowerCAmelCase						:    Optional[int]     		=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*lowercase__ )





		def 					_A							(							self			:		int ):
							lowerCAmelCase						:    Dict     		=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*lowercase__ )





		def 					_A							(							self			:		List[Any] ):
							lowerCAmelCase						:    Optional[Any]     		=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*lowercase__ )





		@slow
		def 					_A							(							self			:		List[str] ):



							for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowerCAmelCase						:    Optional[int]     		=   YosoModel.from_pretrained(lowercase__ )
												self.assertIsNotNone(lowercase__ )





		def 					_A							(							self			:		List[str] ):
							return



@require_torch
class 						__magic_name__      (  unittest.TestCase			):





		@slow
		def 					_A							(							self			:		str ):
							lowerCAmelCase						:    Optional[Any]     		=   YosoModel.from_pretrained('''uw-madison/yoso-4096''' )
							lowerCAmelCase						:    Union[str, Any]     		=   torch.tensor([[0, 1, 2, 3, 4, 5]] )

							with torch.no_grad():
												lowerCAmelCase						:    Optional[int]     		=   model(lowercase__ )[0]

							lowerCAmelCase						:    Dict     		=   torch.Size((1, 6, 7_6_8) )
							self.assertEqual(output.shape  ,     lowercase__ )

							lowerCAmelCase						:    str     		=   torch.tensor(
							    [[[-0.0_6_1_1, 0.1_2_4_2, 0.0_8_4_0], [0.0_2_8_0, -0.0_0_4_8, 0.1_1_2_5], [0.0_1_0_6, 0.0_2_2_6, 0.0_7_5_1]]] )

							self.assertTrue(torch.allclose(output[:, :3, :3]  ,     lowercase__  ,     atol=1E-4 ) )





		@slow
		def 					_A							(							self			:		List[Any] ):
							lowerCAmelCase						:    Optional[int]     		=   YosoForMaskedLM.from_pretrained('''uw-madison/yoso-4096''' )
							lowerCAmelCase						:    int     		=   torch.tensor([[0, 1, 2, 3, 4, 5]] )

							with torch.no_grad():
												lowerCAmelCase						:    Optional[int]     		=   model(lowercase__ )[0]

							lowerCAmelCase						:    Optional[Any]     		=   5_0_2_6_5

							lowerCAmelCase						:    Union[str, Any]     		=   torch.Size((1, 6, vocab_size) )
							self.assertEqual(output.shape  ,     lowercase__ )

							lowerCAmelCase						:    Tuple     		=   torch.tensor(
							    [[[-2.1_3_1_3, -3.7_2_8_5, -2.2_4_0_7], [-2.7_0_4_7, -3.3_3_1_4, -2.6_4_0_8], [0.0_6_2_9, -2.5_1_6_6, -0.3_3_5_6]]] )

							self.assertTrue(torch.allclose(output[:, :3, :3]  ,     lowercase__  ,     atol=1E-4 ) )





		@slow
		def 					_A							(							self			:		Union[str, Any] ):
							lowerCAmelCase						:    Any     		=   YosoForMaskedLM.from_pretrained('''uw-madison/yoso-4096''' )
							lowerCAmelCase						:    Dict     		=   torch.arange(4_0_9_6 ).unsqueeze(0 )

							with torch.no_grad():
												lowerCAmelCase						:    List[str]     		=   model(lowercase__ )[0]

							lowerCAmelCase						:    str     		=   5_0_2_6_5

							lowerCAmelCase						:    Dict     		=   torch.Size((1, 4_0_9_6, vocab_size) )
							self.assertEqual(output.shape  ,     lowercase__ )

							lowerCAmelCase						:    List[Any]     		=   torch.tensor(
							    [[[-2.3_9_1_4, -4.3_7_4_2, -5.0_9_5_6], [-4.0_9_8_8, -4.2_3_8_4, -7.0_4_0_6], [-3.1_4_2_7, -3.7_1_9_2, -6.6_8_0_0]]] )

							self.assertTrue(torch.allclose(output[:, :3, :3]  ,     lowercase__  ,     atol=1E-4 ) )

from typing import TYPE_CHECKING

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


lowerCAmelCase__							= {
    'configuration_deberta_v2': ['DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DebertaV2Config', 'DebertaV2OnnxConfig'],
    'tokenization_deberta_v2': ['DebertaV2Tokenizer'],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCAmelCase__							= ['DebertaV2TokenizerFast']

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCAmelCase__							= [
        'TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST',
        'TFDebertaV2ForMaskedLM',
        'TFDebertaV2ForQuestionAnswering',
        'TFDebertaV2ForSequenceClassification',
        'TFDebertaV2ForTokenClassification',
        'TFDebertaV2Model',
        'TFDebertaV2PreTrainedModel',
    ]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCAmelCase__							= [
        'DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST',
        'DebertaV2ForMaskedLM',
        'DebertaV2ForMultipleChoice',
        'DebertaV2ForQuestionAnswering',
        'DebertaV2ForSequenceClassification',
        'DebertaV2ForTokenClassification',
        'DebertaV2Model',
        'DebertaV2PreTrainedModel',
    ]


if TYPE_CHECKING:
    from .configuration_deberta_va import (
        DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP,
        DebertaVaConfig,
        DebertaVaOnnxConfig,
    )
    from .tokenization_deberta_va import DebertaVaTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_deberta_va_fast import DebertaVaTokenizerFast

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_deberta_va import (
            TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFDebertaVaForMaskedLM,
            TFDebertaVaForQuestionAnswering,
            TFDebertaVaForSequenceClassification,
            TFDebertaVaForTokenClassification,
            TFDebertaVaModel,
            TFDebertaVaPreTrainedModel,
        )

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_deberta_va import (
            DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
            DebertaVaForMaskedLM,
            DebertaVaForMultipleChoice,
            DebertaVaForQuestionAnswering,
            DebertaVaForSequenceClassification,
            DebertaVaForTokenClassification,
            DebertaVaModel,
            DebertaVaPreTrainedModel,
        )

else:
    import sys

    lowerCAmelCase__							= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
