



"""simple docstring"""





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    _lowerCAmelCase    :





		"""simple docstring"""






		def __init__(					self							,    _lowercase							,    _lowercase=1_3							,    _lowercase=7							,    _lowercase=True							,    _lowercase=True							,    _lowercase=True							,    _lowercase=True							,    _lowercase=9_9							,    _lowercase=3_2							,    _lowercase=2							,    _lowercase=4							,    _lowercase=3_7							,    _lowercase="gelu"							,    _lowercase=0.1							,    _lowercase=0.1							,    _lowercase=5_1_2							,    _lowercase=1_6							,    _lowercase=2							,    _lowercase=0.02							,    _lowercase=False							,    _lowercase=True							,    _lowercase="None"							,    _lowercase=3							,    _lowercase=4							,    _lowercase=None							,    ) ->						Tuple:







								'''simple docstring'''

								snake_case_   : Union[str, Any]						=			parent
								snake_case_   : Tuple						=			batch_size
								snake_case_   : Tuple						=			seq_length
								snake_case_   : List[str]						=			is_training
								snake_case_   : Tuple						=			use_input_mask
								snake_case_   : Dict						=			use_token_type_ids
								snake_case_   : str						=			use_labels
								snake_case_   : List[str]						=			vocab_size
								snake_case_   : Tuple						=			hidden_size
								snake_case_   : Union[str, Any]						=			num_hidden_layers
								snake_case_   : List[Any]						=			num_attention_heads
								snake_case_   : Tuple						=			intermediate_size
								snake_case_   : Tuple						=			hidden_act
								snake_case_   : List[Any]						=			hidden_dropout_prob
								snake_case_   : Optional[Any]						=			attention_probs_dropout_prob
								snake_case_   : List[Any]						=			max_position_embeddings
								snake_case_   : Any						=			type_vocab_size
								snake_case_   : Any						=			type_sequence_label_size
								snake_case_   : Dict						=			initializer_range
								snake_case_   : str						=			num_labels
								snake_case_   : Tuple						=			num_choices
								snake_case_   : Dict						=			relative_attention
								snake_case_   : List[Any]						=			position_biased_input
								snake_case_   : Tuple						=			pos_att_type
								snake_case_   : Dict						=			scope





		def    UpperCAmelCase__							(					self   ) ->						int:







								'''simple docstring'''

								snake_case_   : str						=			ids_tensor([self.batch_size, self.seq_length]							,    self.vocab_size   )

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

								snake_case_   : Optional[Any]						=			None
								if self.use_token_type_ids:
														snake_case_   : Union[str, Any]						=			ids_tensor([self.batch_size, self.seq_length]							,    self.type_vocab_size   )

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

								snake_case_   : Optional[int]						=			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=_lowercase							,    )

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





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase   ) ->						str:







								'''simple docstring'''

								snake_case_   : int						=			TFDebertaVaModel(config=_lowercase   )
								snake_case_   : Optional[int]						=			{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

								snake_case_   : Any						=			[input_ids, input_mask]
								snake_case_   : str						=			model(_lowercase   )

								snake_case_   : str						=			model(_lowercase   )

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





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase   ) ->						Dict:







								'''simple docstring'''

								snake_case_   : int						=			TFDebertaVaForMaskedLM(config=_lowercase   )
								snake_case_   : Dict						=			{
								    """input_ids""": input_ids,
								    """attention_mask""": input_mask,
								    """token_type_ids""": token_type_ids,
								}
								snake_case_   : Tuple						=			model(_lowercase   )
								self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.seq_length, self.vocab_size)   )





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase   ) ->						str:







								'''simple docstring'''

								snake_case_   : Any						=			self.num_labels
								snake_case_   : Any						=			TFDebertaVaForSequenceClassification(config=_lowercase   )
								snake_case_   : Tuple						=			{
								    """input_ids""": input_ids,
								    """attention_mask""": input_mask,
								    """token_type_ids""": token_type_ids,
								}

								snake_case_   : int						=			model(_lowercase   )
								self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_labels)   )





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase   ) ->						str:







								'''simple docstring'''

								snake_case_   : int						=			self.num_labels
								snake_case_   : Union[str, Any]						=			TFDebertaVaForTokenClassification(config=_lowercase   )
								snake_case_   : Optional[Any]						=			{
								    """input_ids""": input_ids,
								    """attention_mask""": input_mask,
								    """token_type_ids""": token_type_ids,
								}
								snake_case_   : Any						=			model(_lowercase   )
								self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.seq_length, self.num_labels)   )





		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase   ) ->						Any:







								'''simple docstring'''

								snake_case_   : Optional[Any]						=			TFDebertaVaForQuestionAnswering(config=_lowercase   )
								snake_case_   : Optional[int]						=			{
								    """input_ids""": input_ids,
								    """attention_mask""": input_mask,
								    """token_type_ids""": token_type_ids,
								}

								snake_case_   : Optional[Any]						=			model(_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    UpperCAmelCase__							(					self   ) ->						Optional[int]:







								'''simple docstring'''

								snake_case_   : Tuple						=			self.prepare_config_and_inputs()
								(
								    snake_case_		
								)   : str						=			config_and_inputs
								snake_case_   : List[str]						=			{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
								return config, inputs_dict




@require_tf
class    _lowerCAmelCase    (				SCREAMING_SNAKE_CASE__  ,				SCREAMING_SNAKE_CASE__  ,				unittest.TestCase		):





		"""simple docstring"""






		_lowerCamelCase			  =       (
		    (
		        TFDebertaVaModel,
		        TFDebertaVaForMaskedLM,
		        TFDebertaVaForQuestionAnswering,
		        TFDebertaVaForSequenceClassification,
		        TFDebertaVaForTokenClassification,
		    )
		    if is_tf_available()
		    else ()
		)
		_lowerCamelCase			  =       (
		    {
		        '''feature-extraction''': TFDebertaVaModel,
		        '''fill-mask''': TFDebertaVaForMaskedLM,
		        '''question-answering''': TFDebertaVaForQuestionAnswering,
		        '''text-classification''': TFDebertaVaForSequenceClassification,
		        '''token-classification''': TFDebertaVaForTokenClassification,
		        '''zero-shot''': TFDebertaVaForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)

		_lowerCamelCase			  =       False
		_lowerCamelCase			  =       False





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







								'''simple docstring'''

								snake_case_   : int						=			TFDebertaVaModelTester(self   )
								snake_case_   : int						=			ConfigTester(self							,    config_class=_lowercase							,    hidden_size=3_7   )





		def    UpperCAmelCase__							(					self   ) ->						str:







								'''simple docstring'''

								self.config_tester.run_common_tests()





		def    UpperCAmelCase__							(					self   ) ->						Dict:







								'''simple docstring'''

								snake_case_   : Optional[int]						=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowercase   )





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







								'''simple docstring'''

								snake_case_   : str						=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*_lowercase   )





		def    UpperCAmelCase__							(					self   ) ->						Optional[Any]:







								'''simple docstring'''

								snake_case_   : Tuple						=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*_lowercase   )





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







								'''simple docstring'''

								snake_case_   : int						=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*_lowercase   )





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







								'''simple docstring'''

								snake_case_   : Union[str, Any]						=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*_lowercase   )





		@slow
		def    UpperCAmelCase__							(					self   ) ->						List[str]:







								'''simple docstring'''

								snake_case_   : Optional[int]						=			TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge"""   )
								self.assertIsNotNone(_lowercase   )




@require_tf
class    _lowerCAmelCase    (				unittest.TestCase		):





		"""simple docstring"""






		@unittest.skip(reason="""Model not available yet"""   )
		def    UpperCAmelCase__							(					self   ) ->						List[Any]:







								'''simple docstring'''

								pass





		@slow
		def    UpperCAmelCase__							(					self   ) ->						List[str]:







								'''simple docstring'''

								snake_case_   : int						=			TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge"""   )
								snake_case_   : Any						=			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]]   )
								snake_case_   : List[str]						=			tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
								snake_case_   : Optional[int]						=			model(_lowercase							,    attention_mask=_lowercase   )[0]

								snake_case_   : Any						=			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]							,    _lowercase							,    atol=1E-4   )






"""simple docstring"""





from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__lowerCAmelCase       :					Tuple      					=					logging.get_logger(__name__)

__lowerCAmelCase       :					Dict      					=					{
    '''microsoft/swin-tiny-patch4-window7-224''': (
        '''https://huggingface.co/microsoft/swin-tiny-patch4-window7-224/resolve/main/config.json'''
    ),
    # See all Swin models at https://huggingface.co/models?filter=swin
}



class    _lowerCAmelCase    (				SCREAMING_SNAKE_CASE__  ,				SCREAMING_SNAKE_CASE__		):





		"""simple docstring"""






		_lowerCamelCase			  =       '''swin'''

		_lowerCamelCase			  =       {
		    '''num_attention_heads''': '''num_heads''',
		    '''num_hidden_layers''': '''num_layers''',
		}





		def __init__(					self							,    _lowercase=2_2_4							,    _lowercase=4							,    _lowercase=3							,    _lowercase=9_6							,    _lowercase=[2, 2, 6, 2]							,    _lowercase=[3, 6, 1_2, 2_4]							,    _lowercase=7							,    _lowercase=4.0							,    _lowercase=True							,    _lowercase=0.0							,    _lowercase=0.0							,    _lowercase=0.1							,    _lowercase="gelu"							,    _lowercase=False							,    _lowercase=0.02							,    _lowercase=1E-5							,    _lowercase=3_2							,    _lowercase=None							,    _lowercase=None							,    **_lowercase							,    ) ->						Union[str, Any]:







								'''simple docstring'''

								super().__init__(**_lowercase   )

								snake_case_   : str						=			image_size
								snake_case_   : int						=			patch_size
								snake_case_   : Optional[int]						=			num_channels
								snake_case_   : Union[str, Any]						=			embed_dim
								snake_case_   : Optional[int]						=			depths
								snake_case_   : Optional[int]						=			len(_lowercase   )
								snake_case_   : Optional[Any]						=			num_heads
								snake_case_   : Optional[Any]						=			window_size
								snake_case_   : Optional[Any]						=			mlp_ratio
								snake_case_   : Optional[Any]						=			qkv_bias
								snake_case_   : Optional[Any]						=			hidden_dropout_prob
								snake_case_   : Tuple						=			attention_probs_dropout_prob
								snake_case_   : Union[str, Any]						=			drop_path_rate
								snake_case_   : List[Any]						=			hidden_act
								snake_case_   : str						=			use_absolute_embeddings
								snake_case_   : str						=			layer_norm_eps
								snake_case_   : Optional[Any]						=			initializer_range
								snake_case_   : Any						=			encoder_stride
								# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
								# this indicates the channel dimension after the last stage of the model
								snake_case_   : Tuple						=			int(embed_dim * 2 ** (len(_lowercase   ) - 1)   )
								snake_case_   : Tuple						=			["""stem"""] + [f'stage{idx}' for idx in range(1							,    len(_lowercase   ) + 1   )]
								snake_case_			,		snake_case_   : Any						=			get_aligned_output_features_output_indices(
								    out_features=_lowercase							,    out_indices=_lowercase							,    stage_names=self.stage_names   )




class    _lowerCAmelCase    (				SCREAMING_SNAKE_CASE__		):





		"""simple docstring"""






		_lowerCamelCase			  =       version.parse('''1.11'''		)





		@property
		def    UpperCAmelCase__							(					self   ) ->						Mapping[str, Mapping[int, str]]:







								'''simple docstring'''

								return OrderedDict(
								    [
								        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
								    ]   )





		@property
		def    UpperCAmelCase__							(					self   ) ->						float:







								'''simple docstring'''

								return 1E-4

