




import collections
import inspect
import unittest

from transformers import DinatConfig
from transformers.testing_utils import require_natten, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch
				from torch import nn

				from transformers import DinatBackbone, DinatForImageClassification, DinatModel
				from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor





class 		A__				:






	def __init__(	self				,     lowerCamelCase				,     lowerCamelCase=13				,     lowerCamelCase=64				,     lowerCamelCase=4				,     lowerCamelCase=3				,     lowerCamelCase=16				,     lowerCamelCase=[1, 2, 1]				,     lowerCamelCase=[2, 4, 8]				,     lowerCamelCase=3				,     lowerCamelCase=[[3], [1, 2], [1]]				,     lowerCamelCase=2.0				,     lowerCamelCase=True				,     lowerCamelCase=0.0				,     lowerCamelCase=0.0				,     lowerCamelCase=0.1				,     lowerCamelCase="gelu"				,     lowerCamelCase=True				,     lowerCamelCase=0.0_2				,     lowerCamelCase=1e-5				,     lowerCamelCase=True				,     lowerCamelCase=None				,     lowerCamelCase=True				,     lowerCamelCase=10				,     lowerCamelCase=["stage1", "stage2"]				,     lowerCamelCase=[1, 2]				,     )      ->   List[str]:




						"""simple docstring"""






						__magic_name__					:							Dict		   =							parent
						__magic_name__					:							Optional[int]		   =							batch_size
						__magic_name__					:							Optional[Any]		   =							image_size
						__magic_name__					:							Union[str, Any]		   =							patch_size
						__magic_name__					:							List[str]		   =							num_channels
						__magic_name__					:							Dict		   =							embed_dim
						__magic_name__					:							Tuple		   =							depths
						__magic_name__					:							int		   =							num_heads
						__magic_name__					:							Union[str, Any]		   =							kernel_size
						__magic_name__					:							Tuple		   =							dilations
						__magic_name__					:							Optional[int]		   =							mlp_ratio
						__magic_name__					:							Union[str, Any]		   =							qkv_bias
						__magic_name__					:							Optional[Any]		   =							hidden_dropout_prob
						__magic_name__					:							Dict		   =							attention_probs_dropout_prob
						__magic_name__					:							List[Any]		   =							drop_path_rate
						__magic_name__					:							List[Any]		   =							hidden_act
						__magic_name__					:							Optional[Any]		   =							patch_norm
						__magic_name__					:							Optional[Any]		   =							layer_norm_eps
						__magic_name__					:							List[str]		   =							initializer_range
						__magic_name__					:							List[str]		   =							is_training
						__magic_name__					:							List[str]		   =							scope
						__magic_name__					:							List[str]		   =							use_labels
						__magic_name__					:							List[str]		   =							num_labels
						__magic_name__					:							int		   =							out_features
						__magic_name__					:							int		   =							out_indices






	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						__magic_name__					:							str		   =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

						__magic_name__					:							Tuple		   =							None
						if self.use_labels:
											__magic_name__					:							Union[str, Any]		   =							ids_tensor([self.batch_size]				,     self.num_labels						)

						__magic_name__					:							List[str]		   =							self.get_config()

						return config, pixel_values, labels






	def  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






						return DinatConfig(
						    num_labels=self.num_labels				,     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				,     kernel_size=self.kernel_size				,     dilations=self.dilations				,     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				,     patch_norm=self.patch_norm				,     layer_norm_eps=self.layer_norm_eps				,     initializer_range=self.initializer_range				,     out_features=self.out_features				,     out_indices=self.out_indices				,     )






	def  lowercase      (	self				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase						)      ->   int:




						"""simple docstring"""






						__magic_name__					:							Optional[int]		   =							DinatModel(config=lowerCamelCase__						)
						model.to(lowerCamelCase__						)
						model.eval()
						__magic_name__					:							Optional[int]		   =							model(lowerCamelCase__						)

						__magic_name__					:							Optional[int]		   =							(config.image_size // config.patch_size) // (2 ** (len(config.depths						) - 1))
						__magic_name__					:							str		   =							int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

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






	def  lowercase      (	self				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							Any		   =							DinatForImageClassification(lowerCamelCase__						)
						model.to(lowerCamelCase__						)
						model.eval()
						__magic_name__					:							Optional[Any]		   =							model(lowerCamelCase__				,     labels=lowerCamelCase__						)
						self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)						)

						# test greyscale images
						__magic_name__					:							List[Any]		   =							1
						__magic_name__					:							List[str]		   =							DinatForImageClassification(lowerCamelCase__						)
						model.to(lowerCamelCase__						)
						model.eval()

						__magic_name__					:							str		   =							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
						__magic_name__					:							Tuple		   =							model(lowerCamelCase__						)
						self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)						)






	def  lowercase      (	self				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase						)      ->   Optional[Any]:




						"""simple docstring"""






						__magic_name__					:							Optional[int]		   =							DinatBackbone(config=lowerCamelCase__						)
						model.to(lowerCamelCase__						)
						model.eval()
						__magic_name__					:							Dict		   =							model(lowerCamelCase__						)

						# verify hidden states
						self.parent.assertEqual(len(result.feature_maps						)				,     len(config.out_features						)						)
						self.parent.assertListEqual(list(result.feature_maps[0].shape						)				,     [self.batch_size, model.channels[0], 16, 16]						)

						# verify channels
						self.parent.assertEqual(len(model.channels						)				,     len(config.out_features						)						)

						# verify backbone works with out_features=None
						__magic_name__					:							Tuple		   =							None
						__magic_name__					:							List[str]		   =							DinatBackbone(config=lowerCamelCase__						)
						model.to(lowerCamelCase__						)
						model.eval()
						__magic_name__					:							Optional[Any]		   =							model(lowerCamelCase__						)

						# verify feature maps
						self.parent.assertEqual(len(result.feature_maps						)				,     1						)
						self.parent.assertListEqual(list(result.feature_maps[0].shape						)				,     [self.batch_size, model.channels[-1], 4, 4]						)

						# verify channels
						self.parent.assertEqual(len(model.channels						)				,     1						)






	def  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






						__magic_name__					:							Dict		   =							self.prepare_config_and_inputs()
						__magic_name__   , __magic_name__   , __magic_name__					:							str		   =							config_and_inputs
						__magic_name__					:							List[Any]		   =							{'''pixel_values''': pixel_values}
						return config, inputs_dict





@require_natten
@require_torch
class 		A__				(   __A		,     __A		,     unittest.TestCase ):
	lowerCamelCase__		: int				    =(
	    (
	        DinatModel,
	        DinatForImageClassification,
	        DinatBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	lowerCamelCase__		: Dict				    =(
	    {"""feature-extraction""": DinatModel, """image-classification""": DinatForImageClassification}
	    if is_torch_available()
	    else {}
	)
	lowerCamelCase__		: Optional[Any]				    =False

	lowerCamelCase__		: int				    =False
	lowerCamelCase__		: Union[str, Any]				    =False
	lowerCamelCase__		: Dict				    =False
	lowerCamelCase__		: Dict				    =False






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




						"""simple docstring"""






						__magic_name__					:							List[Any]		   =							DinatModelTester(self						)
						__magic_name__					:							Optional[int]		   =							ConfigTester(self				,     config_class=lowerCamelCase__				,     embed_dim=37						)






	def  lowercase      (	self						)      ->   int:




						"""simple docstring"""






						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  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






						return






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




						"""simple docstring"""






						__magic_name__					:							Union[str, Any]		   =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowerCamelCase__						)






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




						"""simple docstring"""






						__magic_name__					:							Union[str, Any]		   =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__						)






	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							Union[str, Any]		   =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_backbone(*lowerCamelCase__						)






	@unittest.skip(reason='''Dinat does not use inputs_embeds'''						)
	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						pass






	@unittest.skip(reason='''Dinat does not use feedforward chunking'''						)
	def  lowercase      (	self						)      ->   List[str]:




						"""simple docstring"""






						pass






	def  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






						__magic_name__   , __magic_name__					:							Dict		   =							self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__magic_name__					:							int		   =							model_class(lowerCamelCase__						)
											self.assertIsInstance(model.get_input_embeddings()				,     (nn.Module)						)
											__magic_name__					:							Union[str, Any]		   =							model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(lowerCamelCase__				,     nn.Linear						)						)






	def  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






						__magic_name__   , __magic_name__					:							Optional[int]		   =							self.model_tester.prepare_config_and_inputs_for_common()

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

											__magic_name__					:							str		   =							['''pixel_values''']
											self.assertListEqual(arg_names[:1]				,     lowerCamelCase__						)






	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						self.skipTest('''Dinat\'s attention operation is handled entirely by NATTEN.'''						)






	def  lowercase      (	self				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							Any		   =							model_class(lowerCamelCase__						)
						model.to(lowerCamelCase__						)
						model.eval()

						with torch.no_grad():
											__magic_name__					:							Union[str, Any]		   =							model(**self._prepare_for_class(lowerCamelCase__				,     lowerCamelCase__						)						)

						__magic_name__					:							Tuple		   =							outputs.hidden_states

						__magic_name__					:							List[Any]		   =							getattr(
						    self.model_tester				,     '''expected_num_hidden_layers'''				,     len(self.model_tester.depths						) + 1						)
						self.assertEqual(len(lowerCamelCase__						)				,     lowerCamelCase__						)

						# Dinat has a different seq_length
						__magic_name__					:							List[Any]		   =							(
						    config.patch_size
						    if isinstance(config.patch_size				,     collections.abc.Iterable						)
						    else (config.patch_size, config.patch_size)
						)

						__magic_name__					:							int		   =							image_size[0] // patch_size[0]
						__magic_name__					:							Any		   =							image_size[1] // patch_size[1]

						self.assertListEqual(
						    list(hidden_states[0].shape[-3:]						)				,     [height, width, self.model_tester.embed_dim]				,     )

						if model_class.__name__ != "DinatBackbone":
											__magic_name__					:							str		   =							outputs.reshaped_hidden_states
											self.assertEqual(len(lowerCamelCase__						)				,     lowerCamelCase__						)

											__magic_name__   , __magic_name__   , __magic_name__   , __magic_name__					:							List[Any]		   =							reshaped_hidden_states[0].shape
											__magic_name__					:							Dict		   =							(
											    reshaped_hidden_states[0].view(lowerCamelCase__				,     lowerCamelCase__				,     lowerCamelCase__				,     lowerCamelCase__						).permute(0				,     2				,     3				,     1						)
											)
											self.assertListEqual(
											    list(reshaped_hidden_states.shape[-3:]						)				,     [height, width, self.model_tester.embed_dim]				,     )






	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						__magic_name__   , __magic_name__					:							List[Any]		   =							self.model_tester.prepare_config_and_inputs_for_common()

						__magic_name__					:							Optional[int]		   =							(
						    self.model_tester.image_size
						    if isinstance(self.model_tester.image_size				,     collections.abc.Iterable						)
						    else (self.model_tester.image_size, self.model_tester.image_size)
						)

						for model_class in self.all_model_classes:
											__magic_name__					:							List[Any]		   =							True
											self.check_hidden_states_output(lowerCamelCase__				,     lowerCamelCase__				,     lowerCamelCase__				,     lowerCamelCase__						)

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											__magic_name__					:							Any		   =							True

											self.check_hidden_states_output(lowerCamelCase__				,     lowerCamelCase__				,     lowerCamelCase__				,     lowerCamelCase__						)






	@slow
	def  lowercase      (	self						)      ->   List[Any]:




						"""simple docstring"""






						for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__magic_name__					:							Union[str, Any]		   =							DinatModel.from_pretrained(lowerCamelCase__						)
											self.assertIsNotNone(lowerCamelCase__						)






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




						"""simple docstring"""






						__magic_name__   , __magic_name__					:							Dict		   =							self.model_tester.prepare_config_and_inputs_for_common()

						__magic_name__					:							Optional[int]		   =							_config_zero_init(lowerCamelCase__						)
						for model_class in self.all_model_classes:
											__magic_name__					:							List[str]		   =							model_class(config=lowerCamelCase__						)
											for name, param in model.named_parameters():
																if "embeddings" not in name and param.requires_grad:
																					self.assertIn(
																					    ((param.data.mean() * 1e9).round() / 1e9).item()				,     [0.0, 1.0]				,     msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''				,     )





@require_natten
@require_vision
@require_torch
class 		A__				(   unittest.TestCase ):






	@cached_property
	def  lowercase      (	self						)      ->   List[Any]:




						"""simple docstring"""






						return AutoImageProcessor.from_pretrained('''shi-labs/dinat-mini-in1k-224'''						) if is_vision_available() else None






	@slow
	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							Optional[Any]		   =							DinatForImageClassification.from_pretrained('''shi-labs/dinat-mini-in1k-224'''						).to(lowerCamelCase__						)
						__magic_name__					:							Optional[int]		   =							self.default_image_processor

						__magic_name__					:							Optional[Any]		   =							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
						__magic_name__					:							Tuple		   =							image_processor(images=lowerCamelCase__				,     return_tensors='''pt'''						).to(lowerCamelCase__						)

						# forward pass
						with torch.no_grad():
											__magic_name__					:							Tuple		   =							model(**lowerCamelCase__						)

						# verify the logits
						__magic_name__					:							Tuple		   =							torch.Size((1, 1000)						)
						self.assertEqual(outputs.logits.shape				,     lowerCamelCase__						)
						__magic_name__					:							Optional[int]		   =							torch.tensor([-0.1_5_4_5, -0.7_6_6_7, 0.4_6_4_2]						).to(lowerCamelCase__						)
						self.assertTrue(torch.allclose(outputs.logits[0, :3]				,     lowerCamelCase__				,     atol=1e-4						)						)





@require_torch
@require_natten
class 		A__				(   unittest.TestCase		,     __A ):
	lowerCamelCase__		: str				    =(DinatBackbone,) if is_torch_available() else ()
	lowerCamelCase__		: Union[str, Any]				    =DinatConfig






	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						__magic_name__					:							Any		   =							DinatModelTester(self						)









'''simple docstring'''
import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch
  from torch import nn

  from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
  from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor






class        SCREAMING_SNAKE_CASE:

       def __init__(    self					,		lowerCamelCase__					,		lowerCamelCase__=13					,		lowerCamelCase__=32					,		lowerCamelCase__=2					,		lowerCamelCase__=3					,		lowerCamelCase__=16					,		lowerCamelCase__=[1, 2, 1]					,		lowerCamelCase__=[2, 2, 4]					,		lowerCamelCase__=2					,		lowerCamelCase__=2.0					,		lowerCamelCase__=True					,		lowerCamelCase__=0.0					,		lowerCamelCase__=0.0					,		lowerCamelCase__=0.1					,		lowerCamelCase__="gelu"					,		lowerCamelCase__=False					,		lowerCamelCase__=True					,		lowerCamelCase__=0.02					,		lowerCamelCase__=1E-5					,		lowerCamelCase__=True					,		lowerCamelCase__=None					,		lowerCamelCase__=True					,		lowerCamelCase__=10					,		lowerCamelCase__=8					,		lowerCamelCase__=["stage1", "stage2"]					,		lowerCamelCase__=[1, 2]					,		)    ->					Optional[int]:

           """simple docstring"""



           __lowercase							=						parent
           __lowercase							=						batch_size
           __lowercase							=						image_size
           __lowercase							=						patch_size
           __lowercase							=						num_channels
           __lowercase							=						embed_dim
           __lowercase							=						depths
           __lowercase							=						num_heads
           __lowercase							=						window_size
           __lowercase							=						mlp_ratio
           __lowercase							=						qkv_bias
           __lowercase							=						hidden_dropout_prob
           __lowercase							=						attention_probs_dropout_prob
           __lowercase							=						drop_path_rate
           __lowercase							=						hidden_act
           __lowercase							=						use_absolute_embeddings
           __lowercase							=						patch_norm
           __lowercase							=						layer_norm_eps
           __lowercase							=						initializer_range
           __lowercase							=						is_training
           __lowercase							=						scope
           __lowercase							=						use_labels
           __lowercase							=						type_sequence_label_size
           __lowercase							=						encoder_stride
           __lowercase							=						out_features
           __lowercase							=						out_indices

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

           """simple docstring"""



           __lowercase							=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

           __lowercase							=						self.get_config()

           return config, pixel_values, labels

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

           """simple docstring"""



           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					,		out_features=self.out_features					,		out_indices=self.out_indices					,		)

       def     snake_case__			(    self					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )    ->					str:

           """simple docstring"""



           __lowercase							=						SwinModel(config=lowerCamelCase__     )
           model.to(lowerCamelCase__     )
           model.eval()
           __lowercase							=						model(lowerCamelCase__     )

           __lowercase							=						((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths     ) - 1))
           __lowercase							=						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     snake_case__			(    self					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )    ->					Union[str, Any]:

           """simple docstring"""



           __lowercase							=						SwinBackbone(config=lowerCamelCase__     )
           model.to(lowerCamelCase__     )
           model.eval()
           __lowercase							=						model(lowerCamelCase__     )

           # verify hidden states
           self.parent.assertEqual(len(result.feature_maps     )					,		len(config.out_features     )     )
           self.parent.assertListEqual(list(result.feature_maps[0].shape     )					,		[self.batch_size, model.channels[0], 16, 16]     )

           # verify channels
           self.parent.assertEqual(len(model.channels     )					,		len(config.out_features     )     )

           # verify backbone works with out_features=None
           __lowercase							=						None
           __lowercase							=						SwinBackbone(config=lowerCamelCase__     )
           model.to(lowerCamelCase__     )
           model.eval()
           __lowercase							=						model(lowerCamelCase__     )

           # verify feature maps
           self.parent.assertEqual(len(result.feature_maps     )					,		1     )
           self.parent.assertListEqual(list(result.feature_maps[0].shape     )					,		[self.batch_size, model.channels[-1], 4, 4]     )

           # verify channels
           self.parent.assertEqual(len(model.channels     )					,		1     )

       def     snake_case__			(    self					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )    ->					List[str]:

           """simple docstring"""



           __lowercase							=						SwinForMaskedImageModeling(config=lowerCamelCase__     )
           model.to(lowerCamelCase__     )
           model.eval()
           __lowercase							=						model(lowerCamelCase__     )
           self.parent.assertEqual(
               result.logits.shape					,		(self.batch_size, self.num_channels, self.image_size, self.image_size)     )

           # test greyscale images
           __lowercase							=						1
           __lowercase							=						SwinForMaskedImageModeling(lowerCamelCase__     )
           model.to(lowerCamelCase__     )
           model.eval()

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

       def     snake_case__			(    self					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )    ->					int:

           """simple docstring"""



           __lowercase							=						self.type_sequence_label_size
           __lowercase							=						SwinForImageClassification(lowerCamelCase__     )
           model.to(lowerCamelCase__     )
           model.eval()
           __lowercase							=						model(lowerCamelCase__					,		labels=lowerCamelCase__     )
           self.parent.assertEqual(result.logits.shape					,		(self.batch_size, self.type_sequence_label_size)     )

           # test greyscale images
           __lowercase							=						1
           __lowercase							=						SwinForImageClassification(lowerCamelCase__     )
           model.to(lowerCamelCase__     )
           model.eval()

           __lowercase							=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]     )
           __lowercase							=						model(lowerCamelCase__     )
           self.parent.assertEqual(result.logits.shape					,		(self.batch_size, self.type_sequence_label_size)     )




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

           """simple docstring"""



           __lowercase							=						self.prepare_config_and_inputs()
           (
               (
               __lowercase
           )				,(
               __lowercase
           )				,(
               __lowercase
           )				,
           )							=						config_and_inputs
           __lowercase							=						{"""pixel_values""": pixel_values}
           return config, inputs_dict






@require_torch
class        SCREAMING_SNAKE_CASE(				__A   ,      __A   ,      unittest.TestCase     ):
       snake_case_ :     Optional[Any]    =					(
           (
               SwinModel,
               SwinBackbone,
               SwinForImageClassification,
               SwinForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       snake_case_ :     Any    =					(
           {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
           if is_torch_available()
           else {}
       )
       snake_case_ :     Any    =					True

       snake_case_ :     int    =					False
       snake_case_ :     Tuple    =					False
       snake_case_ :     Optional[int]    =					False

       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           __lowercase							=						SwinModelTester(self     )
           __lowercase							=						ConfigTester(self					,		config_class=lowerCamelCase__					,		embed_dim=37     )

       def     snake_case__			(    self     )    ->					int:

           """simple docstring"""



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

           """simple docstring"""



           return

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

           """simple docstring"""



           __lowercase							=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase__     )

       @unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""     )
       def     snake_case__			(    self     )    ->					Union[str, Any]:

           """simple docstring"""



           pass

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

           """simple docstring"""



           super().test_training_gradient_checkpointing()

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

           """simple docstring"""



           __lowercase							=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_backbone(*lowerCamelCase__     )

       def     snake_case__			(    self     )    ->					str:

           """simple docstring"""



           __lowercase							=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase__     )

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

           """simple docstring"""



           __lowercase							=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__     )

       @unittest.skip(reason="""Swin does not use inputs_embeds"""     )
       def     snake_case__			(    self     )    ->					Tuple:

           """simple docstring"""



           pass

       @unittest.skip(reason="""Swin Transformer does not use feedforward chunking"""     )
       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           pass

       def     snake_case__			(    self     )    ->					int:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               __lowercase							=						model_class(lowerCamelCase__     )
               self.assertIsInstance(model.get_input_embeddings()					,		(nn.Module)     )
               __lowercase							=						model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(lowerCamelCase__					,		nn.Linear     )     )

       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.model_tester.prepare_config_and_inputs_for_common()

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

               __lowercase							=						["""pixel_values"""]
               self.assertListEqual(arg_names[:1]					,		lowerCamelCase__     )

       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.model_tester.prepare_config_and_inputs_for_common()
           __lowercase							=						True

           for model_class in self.all_model_classes:
               __lowercase							=						True
               __lowercase							=						False
               __lowercase							=						True
               __lowercase							=						model_class(lowerCamelCase__     )
               model.to(lowerCamelCase__     )
               model.eval()
               with torch.no_grad():
                   __lowercase							=						model(**self._prepare_for_class(lowerCamelCase__					,		lowerCamelCase__     )     )
               __lowercase							=						outputs.attentions
               __lowercase							=						len(self.model_tester.depths     )
               self.assertEqual(len(lowerCamelCase__     )					,		lowerCamelCase__     )

               # check that output_attentions also work using config
               del inputs_dict["output_attentions"]
               __lowercase							=						True
               __lowercase							=						config.window_size**2
               __lowercase							=						model_class(lowerCamelCase__     )
               model.to(lowerCamelCase__     )
               model.eval()
               with torch.no_grad():
                   __lowercase							=						model(**self._prepare_for_class(lowerCamelCase__					,		lowerCamelCase__     )     )
               __lowercase							=						outputs.attentions
               self.assertEqual(len(lowerCamelCase__     )					,		lowerCamelCase__     )

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

               # Check attention is always last and order is fine
               __lowercase							=						True
               __lowercase							=						True
               __lowercase							=						model_class(lowerCamelCase__     )
               model.to(lowerCamelCase__     )
               model.eval()
               with torch.no_grad():
                   __lowercase							=						model(**self._prepare_for_class(lowerCamelCase__					,		lowerCamelCase__     )     )

               # also another +1 for reshaped_hidden_states
               __lowercase							=						1 if model_class.__name__ == """SwinBackbone""" else 2
               self.assertEqual(out_len + added_hidden_states					,		len(lowerCamelCase__     )     )

               __lowercase							=						outputs.attentions

               self.assertEqual(len(lowerCamelCase__     )					,		lowerCamelCase__     )

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

       def     snake_case__			(    self					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )    ->					Optional[int]:

           """simple docstring"""



           __lowercase							=						model_class(lowerCamelCase__     )
           model.to(lowerCamelCase__     )
           model.eval()

           with torch.no_grad():
               __lowercase							=						model(**self._prepare_for_class(lowerCamelCase__					,		lowerCamelCase__     )     )

           __lowercase							=						outputs.hidden_states

           __lowercase							=						getattr(
               self.model_tester					,		"""expected_num_hidden_layers"""					,		len(self.model_tester.depths     ) + 1     )
           self.assertEqual(len(lowerCamelCase__     )					,		lowerCamelCase__     )

           # Swin has a different seq_length
           __lowercase							=						(
               config.patch_size
               if isinstance(config.patch_size					,		collections.abc.Iterable     )
               else (config.patch_size, config.patch_size)
           )

           __lowercase							=						(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]					,		)

           if not model_class.__name__ == "SwinBackbone":
               __lowercase							=						outputs.reshaped_hidden_states
               self.assertEqual(len(lowerCamelCase__     )					,		lowerCamelCase__     )

               __lowercase				,__lowercase				,__lowercase				,__lowercase							=						reshaped_hidden_states[0].shape
               __lowercase							=						(
                   reshaped_hidden_states[0].view(lowerCamelCase__					,		lowerCamelCase__					,		height * width     ).permute(0					,		2					,		1     )
               )
               self.assertListEqual(
                   list(reshaped_hidden_states.shape[-2:]     )					,		[num_patches, self.model_tester.embed_dim]					,		)

       def     snake_case__			(    self     )    ->					int:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.model_tester.prepare_config_and_inputs_for_common()

           __lowercase							=						(
               self.model_tester.image_size
               if isinstance(self.model_tester.image_size					,		collections.abc.Iterable     )
               else (self.model_tester.image_size, self.model_tester.image_size)
           )

           for model_class in self.all_model_classes:
               __lowercase							=						True
               self.check_hidden_states_output(lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )

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

               self.check_hidden_states_output(lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )

       def     snake_case__			(    self     )    ->					Dict:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.model_tester.prepare_config_and_inputs_for_common()
           __lowercase							=						3

           __lowercase							=						(
               self.model_tester.image_size
               if isinstance(self.model_tester.image_size					,		collections.abc.Iterable     )
               else (self.model_tester.image_size, self.model_tester.image_size)
           )
           __lowercase							=						(
               config.patch_size
               if isinstance(config.patch_size					,		collections.abc.Iterable     )
               else (config.patch_size, config.patch_size)
           )

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

           for model_class in self.all_model_classes:
               __lowercase							=						True
               self.check_hidden_states_output(lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__					,		(padded_height, padded_width)     )

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

       @slow
       def     snake_case__			(    self     )    ->					Optional[Any]:

           """simple docstring"""



           for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __lowercase							=						SwinModel.from_pretrained(lowerCamelCase__     )
               self.assertIsNotNone(lowerCamelCase__     )




       def     snake_case__			(    self     )    ->					Dict:

           """simple docstring"""



           __lowercase				,__lowercase							=						self.model_tester.prepare_config_and_inputs_for_common()

           __lowercase							=						_config_zero_init(lowerCamelCase__     )
           for model_class in self.all_model_classes:
               __lowercase							=						model_class(config=lowerCamelCase__     )
               for name, param in model.named_parameters():
                   if "embeddings" not in name and param.requires_grad:
                       self.assertIn(
                           ((param.data.mean() * 1E9).round() / 1E9).item()					,		[0.0, 1.0]					,		msg=F'Parameter {name} of model {model_class} seems not properly initialized'					,		)






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

       @cached_property
       def     snake_case__			(    self     )    ->					List[Any]:

           """simple docstring"""



           return (
               AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""     )
               if is_vision_available()
               else None
           )




       @slow
       def     snake_case__			(    self     )    ->					List[Any]:

           """simple docstring"""



           __lowercase							=						SwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""     ).to(lowerCamelCase__     )
           __lowercase							=						self.default_image_processor

           __lowercase							=						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     )
           __lowercase							=						image_processor(images=lowerCamelCase__					,		return_tensors="""pt"""     ).to(lowerCamelCase__     )

           # forward pass
           with torch.no_grad():
               __lowercase							=						model(**lowerCamelCase__     )

           # verify the logits
           __lowercase							=						torch.Size((1, 1000)     )
           self.assertEqual(outputs.logits.shape					,		lowerCamelCase__     )
           __lowercase							=						torch.tensor([-0.09_48, -0.64_54, -0.09_21]     ).to(lowerCamelCase__     )
           self.assertTrue(torch.allclose(outputs.logits[0, :3]					,		lowerCamelCase__					,		atol=1E-4     )     )






@require_torch
class        SCREAMING_SNAKE_CASE(				unittest.TestCase   ,      __A     ):
       snake_case_ :     List[Any]    =					(SwinBackbone,) if is_torch_available() else ()
       snake_case_ :     Optional[Any]    =					SwinConfig

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

           """simple docstring"""



           __lowercase							=						SwinModelTester(self     )




