'''simple docstring'''

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


lowercase_  		=			logging.get_logger(__name__)

lowercase_  		=			{
    '''microsoft/deberta-base''': '''https://huggingface.co/microsoft/deberta-base/resolve/main/config.json''',
    '''microsoft/deberta-large''': '''https://huggingface.co/microsoft/deberta-large/resolve/main/config.json''',
    '''microsoft/deberta-xlarge''': '''https://huggingface.co/microsoft/deberta-xlarge/resolve/main/config.json''',
    '''microsoft/deberta-base-mnli''': '''https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/config.json''',
    '''microsoft/deberta-large-mnli''': '''https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/config.json''',
    '''microsoft/deberta-xlarge-mnli''': '''https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/config.json''',
}
class 	SCREAMING_SNAKE_CASE      (    __lowercase):







		"""simple docstring"""
		lowercase :   Dict							=				'deberta'






		def __init__( self		,    __A=5_0265		,    __A=768		,    __A=12		,    __A=12		,    __A=3072		,    __A="gelu"		,    __A=0.1		,    __A=0.1		,    __A=512		,    __A=0		,    __A=0.02		,    __A=1E-7		,    __A=False		,    __A=-1		,    __A=0		,    __A=True		,    __A=None		,    __A=0		,    __A="gelu"		,    **__A		,    )			->  str:
								super().__init__(**__A					)

								_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					    =initializer_range
								_lowerCAmelCase					    =relative_attention
								_lowerCAmelCase					    =max_relative_positions
								_lowerCAmelCase					    =pad_token_id
								_lowerCAmelCase					    =position_biased_input

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

								_lowerCAmelCase					    =pos_att_type
								_lowerCAmelCase					    =vocab_size
								_lowerCAmelCase					    =layer_norm_eps

								_lowerCAmelCase					    =kwargs.get('pooler_hidden_size'		,    __A					)
								_lowerCAmelCase					    =pooler_dropout
								_lowerCAmelCase					    =pooler_hidden_act

class 	SCREAMING_SNAKE_CASE      (    __lowercase):







		"""simple docstring"""






		@property
		def 		UpperCamelCase__							( self					)			->  Mapping[str, Mapping[int, str]]:
								if self.task == "multiple-choice":
														_lowerCAmelCase					    ={0: 'batch', 1: 'choice', 2: 'sequence'}
								else:
														_lowerCAmelCase					    ={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 		UpperCamelCase__							( self					)			->  int:
								return 12






		def 		UpperCamelCase__							( self		,    __A		,    __A = -1		,    __A = -1		,    __A = -1		,    __A = False		,    __A = None		,    __A = 3		,    __A = 40		,    __A = 40		,    __A = None		,    )			->  Mapping[str, Any]:
								_lowerCAmelCase					    =super().generate_dummy_inputs(preprocessor=__A		,    framework=__A					)
								if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
														del dummy_inputs["token_type_ids"]
								return dummy_inputs






'''simple docstring'''

from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers.models.swin.modeling_tf_swin import (
							    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TFSwinForImageClassification,
							    TFSwinForMaskedImageModeling,
							    TFSwinModel,
							)


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor
class 	SCREAMING_SNAKE_CASE      :







		"""simple docstring"""






		def __init__( self		,    __A		,    __A=13		,    __A=32		,    __A=2		,    __A=3		,    __A=16		,    __A=[1, 2, 1]		,    __A=[2, 2, 4]		,    __A=2		,    __A=2.0		,    __A=True		,    __A=0.0		,    __A=0.0		,    __A=0.1		,    __A="gelu"		,    __A=False		,    __A=True		,    __A=0.02		,    __A=1E-5		,    __A=True		,    __A=None		,    __A=True		,    __A=10		,    __A=8		,    )			->  None:
								_lowerCAmelCase					    =parent
								_lowerCAmelCase					    =batch_size
								_lowerCAmelCase					    =image_size
								_lowerCAmelCase					    =patch_size
								_lowerCAmelCase					    =num_channels
								_lowerCAmelCase					    =embed_dim
								_lowerCAmelCase					    =depths
								_lowerCAmelCase					    =num_heads
								_lowerCAmelCase					    =window_size
								_lowerCAmelCase					    =mlp_ratio
								_lowerCAmelCase					    =qkv_bias
								_lowerCAmelCase					    =hidden_dropout_prob
								_lowerCAmelCase					    =attention_probs_dropout_prob
								_lowerCAmelCase					    =drop_path_rate
								_lowerCAmelCase					    =hidden_act
								_lowerCAmelCase					    =use_absolute_embeddings
								_lowerCAmelCase					    =patch_norm
								_lowerCAmelCase					    =layer_norm_eps
								_lowerCAmelCase					    =initializer_range
								_lowerCAmelCase					    =is_training
								_lowerCAmelCase					    =scope
								_lowerCAmelCase					    =use_labels
								_lowerCAmelCase					    =type_sequence_label_size
								_lowerCAmelCase					    =encoder_stride






		def 		UpperCamelCase__							( self					)			->  Any:
								_lowerCAmelCase					    =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

								_lowerCAmelCase					    =None
								if self.use_labels:
														_lowerCAmelCase					    =ids_tensor([self.batch_size]		,    self.type_sequence_label_size					)

								_lowerCAmelCase					    =self.get_config()

								return config, pixel_values, labels






		def 		UpperCamelCase__							( self					)			->  List[str]:
								return SwinConfig(
								    image_size=self.image_size		,    patch_size=self.patch_size		,    num_channels=self.num_channels		,    embed_dim=self.embed_dim		,    depths=self.depths		,    num_heads=self.num_heads		,    window_size=self.window_size		,    mlp_ratio=self.mlp_ratio		,    qkv_bias=self.qkv_bias		,    hidden_dropout_prob=self.hidden_dropout_prob		,    attention_probs_dropout_prob=self.attention_probs_dropout_prob		,    drop_path_rate=self.drop_path_rate		,    hidden_act=self.hidden_act		,    use_absolute_embeddings=self.use_absolute_embeddings		,    path_norm=self.patch_norm		,    layer_norm_eps=self.layer_norm_eps		,    initializer_range=self.initializer_range		,    encoder_stride=self.encoder_stride		,    )






		def 		UpperCamelCase__							( self		,    __A		,    __A		,    __A					)			->  str:
								_lowerCAmelCase					    =TFSwinModel(config=__A					)
								_lowerCAmelCase					    =model(__A					)

								_lowerCAmelCase					    =((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
								_lowerCAmelCase					    =int(config.embed_dim * 2 ** (len(config.depths					) - 1)					)

								self.parent.assertEqual(result.last_hidden_state.shape		,    (self.batch_size, expected_seq_len, expected_dim)					)






		def 		UpperCamelCase__							( self		,    __A		,    __A		,    __A					)			->  List[Any]:
								_lowerCAmelCase					    =TFSwinForMaskedImageModeling(config=__A					)
								_lowerCAmelCase					    =model(__A					)
								self.parent.assertEqual(
								    result.logits.shape		,    (self.batch_size, self.num_channels, self.image_size, self.image_size)					)

								# test greyscale images
								_lowerCAmelCase					    =1
								_lowerCAmelCase					    =TFSwinForMaskedImageModeling(__A					)

								_lowerCAmelCase					    =floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
								_lowerCAmelCase					    =model(__A					)
								self.parent.assertEqual(result.logits.shape		,    (self.batch_size, 1, self.image_size, self.image_size)					)






		def 		UpperCamelCase__							( self		,    __A		,    __A		,    __A					)			->  int:
								_lowerCAmelCase					    =self.type_sequence_label_size
								_lowerCAmelCase					    =TFSwinForImageClassification(__A					)
								_lowerCAmelCase					    =model(__A		,    labels=__A					)
								self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.type_sequence_label_size)					)

								# test greyscale images
								_lowerCAmelCase					    =1
								_lowerCAmelCase					    =TFSwinForImageClassification(__A					)
								_lowerCAmelCase					    =floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
								_lowerCAmelCase					    =model(__A					)
								self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.type_sequence_label_size)					)






		def 		UpperCamelCase__							( self					)			->  int:
								_lowerCAmelCase					    =self.prepare_config_and_inputs()
								_lowerCAmelCase    ,					_lowerCAmelCase    ,					_lowerCAmelCase					    =config_and_inputs
								_lowerCAmelCase					    ={'pixel_values': pixel_values}
								return config, inputs_dict

@require_tf
class 	SCREAMING_SNAKE_CASE      (    __lowercase     ,      __lowercase     ,      unittest.TestCase):







		"""simple docstring"""
		lowercase :   Tuple							=				(
		    (
		        TFSwinModel,
		        TFSwinForImageClassification,
		        TFSwinForMaskedImageModeling,
		    )
		    if is_tf_available()
		    else ()
		)
		lowercase :   int							=				(
		    {'feature-extraction': TFSwinModel, 'image-classification': TFSwinForImageClassification}
		    if is_tf_available()
		    else {}
		)

		lowercase :   Union[str, Any]							=				False
		lowercase :   Dict							=				False
		lowercase :   Optional[Any]							=				False
		lowercase :   Optional[Any]							=				False






		def 		UpperCamelCase__							( self					)			->  Dict:
								_lowerCAmelCase					    =TFSwinModelTester(self					)
								_lowerCAmelCase					    =ConfigTester(self		,    config_class=__A		,    embed_dim=37					)






		def 		UpperCamelCase__							( self					)			->  int:
								self.create_and_test_config_common_properties()
								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 		UpperCamelCase__							( self					)			->  Tuple:
								return






		def 		UpperCamelCase__							( self					)			->  int:
								_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__A					)






		def 		UpperCamelCase__							( self					)			->  Dict:
								_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*__A					)






		def 		UpperCamelCase__							( self					)			->  int:
								_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*__A					)






		@unittest.skip(reason='Swin does not use inputs_embeds'					)
		def 		UpperCamelCase__							( self					)			->  List[str]:
								pass






		def 		UpperCamelCase__							( self					)			->  Dict:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														_lowerCAmelCase					    =model_class(__A					)
														self.assertIsInstance(model.get_input_embeddings()		,    tf.keras.layers.Layer					)
														_lowerCAmelCase					    =model.get_output_embeddings()
														self.assertTrue(x is None or isinstance(__A		,    tf.keras.layers.Dense					)					)






		def 		UpperCamelCase__							( self					)			->  Tuple:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														_lowerCAmelCase					    =model_class(__A					)
														_lowerCAmelCase					    =inspect.signature(model.call					)
														# signature.parameters is an OrderedDict => so arg_names order is deterministic
														_lowerCAmelCase					    =[*signature.parameters.keys()]

														_lowerCAmelCase					    =['pixel_values']
														self.assertListEqual(arg_names[:1]		,    __A					)






		def 		UpperCamelCase__							( self					)			->  str:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()
								_lowerCAmelCase					    =True

								for model_class in self.all_model_classes:
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =False
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =model_class(__A					)
														_lowerCAmelCase					    =model(**self._prepare_for_class(__A		,    __A					)					)
														_lowerCAmelCase					    =outputs.attentions
														_lowerCAmelCase					    =len(self.model_tester.depths					)
														self.assertEqual(len(__A					)		,    __A					)

														# check that output_attentions also work using config
														del inputs_dict["output_attentions"]
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =config.window_size**2
														_lowerCAmelCase					    =model_class(__A					)
														_lowerCAmelCase					    =model(**self._prepare_for_class(__A		,    __A					)					)
														_lowerCAmelCase					    =outputs.attentions
														self.assertEqual(len(__A					)		,    __A					)

														self.assertListEqual(
														    list(attentions[0].shape[-3:]					)		,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,    )
														_lowerCAmelCase					    =len(__A					)

														# Check attention is always last and order is fine
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =True
														_lowerCAmelCase					    =model_class(__A					)
														_lowerCAmelCase					    =model(**self._prepare_for_class(__A		,    __A					)					)

														if hasattr(self.model_tester		,    'num_hidden_states_types'					):
																				_lowerCAmelCase					    =self.model_tester.num_hidden_states_types
														else:
																				# also another +1 for reshaped_hidden_states
																				_lowerCAmelCase					    =2
														self.assertEqual(out_len + added_hidden_states		,    len(__A					)					)

														_lowerCAmelCase					    =outputs.attentions

														self.assertEqual(len(__A					)		,    __A					)

														self.assertListEqual(
														    list(self_attentions[0].shape[-3:]					)		,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,    )






		def 		UpperCamelCase__							( self		,    __A		,    __A		,    __A		,    __A					)			->  Union[str, Any]:
								_lowerCAmelCase					    =model_class(__A					)
								_lowerCAmelCase					    =model(**self._prepare_for_class(__A		,    __A					)					)
								_lowerCAmelCase					    =outputs.hidden_states

								_lowerCAmelCase					    =getattr(
								    self.model_tester		,    'expected_num_hidden_layers'		,    len(self.model_tester.depths					) + 1					)
								self.assertEqual(len(__A					)		,    __A					)

								# Swin has a different seq_length
								_lowerCAmelCase					    =to_atuple(config.patch_size					)

								_lowerCAmelCase					    =(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

								self.assertListEqual(
								    list(hidden_states[0].shape[-2:]					)		,    [num_patches, self.model_tester.embed_dim]		,    )

								_lowerCAmelCase					    =outputs.reshaped_hidden_states
								self.assertEqual(len(__A					)		,    __A					)

								_lowerCAmelCase    ,					_lowerCAmelCase    ,					_lowerCAmelCase    ,					_lowerCAmelCase					    =reshaped_hidden_states[0].shape

								_lowerCAmelCase					    =tf.reshape(reshaped_hidden_states[0]		,    (batch_size, num_channels, height * width)					)
								_lowerCAmelCase					    =tf.transpose(__A		,    (0, 2, 1)					)

								self.assertListEqual(
								    list(reshaped_hidden_states.shape[-2:]					)		,    [num_patches, self.model_tester.embed_dim]		,    )






		def 		UpperCamelCase__							( self					)			->  Optional[Any]:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()

								_lowerCAmelCase					    =to_atuple(self.model_tester.image_size					)

								for model_class in self.all_model_classes:
														_lowerCAmelCase					    =True
														self.check_hidden_states_output(__A		,    __A		,    __A		,    __A					)

														# check that output_hidden_states also work using config
														del inputs_dict["output_hidden_states"]
														_lowerCAmelCase					    =True

														self.check_hidden_states_output(__A		,    __A		,    __A		,    __A					)






		def 		UpperCamelCase__							( self					)			->  Optional[Any]:
								_lowerCAmelCase    ,					_lowerCAmelCase					    =self.model_tester.prepare_config_and_inputs_for_common()
								_lowerCAmelCase					    =3

								_lowerCAmelCase					    =to_atuple(self.model_tester.image_size					)
								_lowerCAmelCase					    =to_atuple(config.patch_size					)

								_lowerCAmelCase					    =image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
								_lowerCAmelCase					    =image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

								for model_class in self.all_model_classes:
														_lowerCAmelCase					    =True
														self.check_hidden_states_output(__A		,    __A		,    __A		,    (padded_height, padded_width)					)

														# check that output_hidden_states also work using config
														del inputs_dict["output_hidden_states"]
														_lowerCAmelCase					    =True
														self.check_hidden_states_output(__A		,    __A		,    __A		,    (padded_height, padded_width)					)






		@slow
		def 		UpperCamelCase__							( self					)			->  str:
								for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_lowerCAmelCase					    =TFSwinModel.from_pretrained(__A					)
														self.assertIsNotNone(__A					)

@require_vision
@require_tf
class 	SCREAMING_SNAKE_CASE      (    unittest.TestCase):







		"""simple docstring"""






		@cached_property
		def 		UpperCamelCase__							( self					)			->  List[str]:
								return (
								    AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'					)
								    if is_vision_available()
								    else None
								)






		@slow
		def 		UpperCamelCase__							( self					)			->  List[str]:
								_lowerCAmelCase					    =TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'					)
								_lowerCAmelCase					    =self.default_image_processor

								_lowerCAmelCase					    =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
								_lowerCAmelCase					    =image_processor(images=__A		,    return_tensors='tf'					)

								# forward pass
								_lowerCAmelCase					    =model(__A					)

								# verify the logits
								_lowerCAmelCase					    =tf.TensorShape((1, 1000)					)
								self.assertEqual(outputs.logits.shape		,    __A					)
								_lowerCAmelCase					    =tf.constant([-0.0_948, -0.6_454, -0.0_921]					)
								self.assertTrue(np.allclose(outputs.logits[0, :3]		,    __A		,    atol=1E-4					)					)





