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

							"""simple docstring"""






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





													'''simple docstring'''






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



							def       A__						(					self     )->				str:





													'''simple docstring'''






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

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

													__UpperCamelCase       					=     self.get_config()

													return config, pixel_values, labels



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





													'''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       A__						(					self       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )->				int:





													'''simple docstring'''






													__UpperCamelCase       					=     SwinModel(config=SCREAMING_SNAKE_CASE_     )
													model.to(SCREAMING_SNAKE_CASE_     )
													model.eval()
													__UpperCamelCase       					=     model(SCREAMING_SNAKE_CASE_     )

													__UpperCamelCase       					=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths     ) - 1))
													__UpperCamelCase       					=     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       A__						(					self       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )->				Any:





													'''simple docstring'''






													__UpperCamelCase       					=     SwinBackbone(config=SCREAMING_SNAKE_CASE_     )
													model.to(SCREAMING_SNAKE_CASE_     )
													model.eval()
													__UpperCamelCase       					=     model(SCREAMING_SNAKE_CASE_     )

													# 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
													__UpperCamelCase       					=     None
													__UpperCamelCase       					=     SwinBackbone(config=SCREAMING_SNAKE_CASE_     )
													model.to(SCREAMING_SNAKE_CASE_     )
													model.eval()
													__UpperCamelCase       					=     model(SCREAMING_SNAKE_CASE_     )

													# 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       A__						(					self       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )->				Optional[int]:





													'''simple docstring'''






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

													# test greyscale images
													__UpperCamelCase       					=     1
													__UpperCamelCase       					=     SwinForMaskedImageModeling(SCREAMING_SNAKE_CASE_     )
													model.to(SCREAMING_SNAKE_CASE_     )
													model.eval()

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



							def       A__						(					self       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )->				str:





													'''simple docstring'''






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

													# test greyscale images
													__UpperCamelCase       					=     1
													__UpperCamelCase       					=     SwinForImageClassification(SCREAMING_SNAKE_CASE_     )
													model.to(SCREAMING_SNAKE_CASE_     )
													model.eval()

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



							def       A__						(					self     )->				Tuple:





													'''simple docstring'''






													__UpperCamelCase       					=     self.prepare_config_and_inputs()
													(
													    (
													    __UpperCamelCase						
													)					,							(
													    __UpperCamelCase						
													)					,							(
													    __UpperCamelCase						
													)					,													
													)       					=     config_and_inputs
													__UpperCamelCase       					=     {'''pixel_values''': pixel_values}
													return config, inputs_dict






@require_torch
class     SCREAMING_SNAKE_CASE__      (							A__				,						A__				,						unittest.TestCase      ):

							"""simple docstring"""






							_snake_case       						=					(
							    (
							        SwinModel,
							        SwinBackbone,
							        SwinForImageClassification,
							        SwinForMaskedImageModeling,
							    )
							    if is_torch_available()
							    else ()
							)
							_snake_case       						=					(
							    {'feature-extraction': SwinModel, 'image-classification': SwinForImageClassification}
							    if is_torch_available()
							    else {}
							)
							_snake_case       						=					True

							_snake_case       						=					False
							_snake_case       						=					False
							_snake_case       						=					False



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





													'''simple docstring'''






													__UpperCamelCase       					=     SwinModelTester(self     )
													__UpperCamelCase       					=     ConfigTester(self       ,		config_class=SCREAMING_SNAKE_CASE_       ,		embed_dim=37     )



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





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





													'''simple docstring'''






													return



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





													'''simple docstring'''






													__UpperCamelCase       					=     self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_     )



							@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''     )
							def       A__						(					self     )->				str:





													'''simple docstring'''






													pass



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





													'''simple docstring'''






													super().test_training_gradient_checkpointing()



							def       A__						(					self     )->				Any:





													'''simple docstring'''






													__UpperCamelCase       					=     self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE_     )



							def       A__						(					self     )->				Any:





													'''simple docstring'''






													__UpperCamelCase       					=     self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_     )



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





													'''simple docstring'''






													__UpperCamelCase       					=     self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_     )



							@unittest.skip(reason='''Swin does not use inputs_embeds'''     )
							def       A__						(					self     )->				Any:





													'''simple docstring'''






													pass



							@unittest.skip(reason='''Swin Transformer does not use feedforward chunking'''     )
							def       A__						(					self     )->				Tuple:





													'''simple docstring'''






													pass



							def       A__						(					self     )->				Dict:





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.model_tester.prepare_config_and_inputs_for_common()

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



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





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.model_tester.prepare_config_and_inputs_for_common()

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

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



							def       A__						(					self     )->				str:





													'''simple docstring'''






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

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

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

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

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

																			# also another +1 for reshaped_hidden_states
																			__UpperCamelCase       					=     1 if model_class.__name__ == '''SwinBackbone''' else 2
																			self.assertEqual(out_len + added_hidden_states       ,		len(SCREAMING_SNAKE_CASE_     )     )

																			__UpperCamelCase       					=     outputs.attentions

																			self.assertEqual(len(SCREAMING_SNAKE_CASE_     )       ,		SCREAMING_SNAKE_CASE_     )

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



							def       A__						(					self       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )->				Optional[int]:





													'''simple docstring'''






													__UpperCamelCase       					=     model_class(SCREAMING_SNAKE_CASE_     )
													model.to(SCREAMING_SNAKE_CASE_     )
													model.eval()

													with torch.no_grad():
																			__UpperCamelCase       					=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )     )

													__UpperCamelCase       					=     outputs.hidden_states

													__UpperCamelCase       					=     getattr(
													    self.model_tester       ,		'''expected_num_hidden_layers'''       ,		len(self.model_tester.depths     ) + 1     )
													self.assertEqual(len(SCREAMING_SNAKE_CASE_     )       ,		SCREAMING_SNAKE_CASE_     )

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

													__UpperCamelCase       					=     (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":
																			__UpperCamelCase       					=     outputs.reshaped_hidden_states
																			self.assertEqual(len(SCREAMING_SNAKE_CASE_     )       ,		SCREAMING_SNAKE_CASE_     )

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



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





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.model_tester.prepare_config_and_inputs_for_common()

													__UpperCamelCase       					=     (
													    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:
																			__UpperCamelCase       					=     True
																			self.check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )

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

																			self.check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )



							def       A__						(					self     )->				str:





													'''simple docstring'''






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

													__UpperCamelCase       					=     (
													    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)
													)
													__UpperCamelCase       					=     (
													    config.patch_size
													    if isinstance(config.patch_size       ,		collections.abc.Iterable     )
													    else (config.patch_size, config.patch_size)
													)

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

													for model_class in self.all_model_classes:
																			__UpperCamelCase       					=     True
																			self.check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		(padded_height, padded_width)     )

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



							@slow
							def       A__						(					self     )->				Union[str, Any]:





													'''simple docstring'''






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



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





													'''simple docstring'''






													__UpperCamelCase					,							__UpperCamelCase       					=     self.model_tester.prepare_config_and_inputs_for_common()

													__UpperCamelCase       					=     _config_zero_init(SCREAMING_SNAKE_CASE_     )
													for model_class in self.all_model_classes:
																			__UpperCamelCase       					=     model_class(config=SCREAMING_SNAKE_CASE_     )
																			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      ):

							"""simple docstring"""






							@cached_property
							def       A__						(					self     )->				int:





													'''simple docstring'''






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



							@slow
							def       A__						(					self     )->				str:





													'''simple docstring'''






													__UpperCamelCase       					=     SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''     ).to(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     self.default_image_processor

													__UpperCamelCase       					=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
													__UpperCamelCase       					=     image_processor(images=SCREAMING_SNAKE_CASE_       ,		return_tensors='''pt'''     ).to(SCREAMING_SNAKE_CASE_     )

													# forward pass
													with torch.no_grad():
																			__UpperCamelCase       					=     model(**SCREAMING_SNAKE_CASE_     )

													# verify the logits
													__UpperCamelCase       					=     torch.Size((1, 1000)     )
													self.assertEqual(outputs.logits.shape       ,		SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     torch.tensor([-0.0_9_4_8, -0.6_4_5_4, -0.0_9_2_1]     ).to(SCREAMING_SNAKE_CASE_     )
													self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,		SCREAMING_SNAKE_CASE_       ,		atol=1E-4     )     )






@require_torch
class     SCREAMING_SNAKE_CASE__      (							unittest.TestCase				,						A__      ):

							"""simple docstring"""






							_snake_case       						=					(SwinBackbone,) if is_torch_available() else ()
							_snake_case       						=					SwinConfig



							def       A__						(					self     )->				Tuple:





													'''simple docstring'''






													__UpperCamelCase       					=     SwinModelTester(self     )






import torch

from transformers import PreTrainedModel

from .custom_configuration import CustomConfig, NoSuperInitConfig






class     SCREAMING_SNAKE_CASE__      (							SCREAMING_SNAKE_CASE_      ):

							"""simple docstring"""






							_snake_case       						=					CustomConfig



							def __init__(					self       ,		SCREAMING_SNAKE_CASE_     )->				Tuple:





													'''simple docstring'''






													super().__init__(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     torch.nn.Linear(config.hidden_size       ,		config.hidden_size     )



							def       A__						(					self       ,		SCREAMING_SNAKE_CASE_     )->				List[str]:





													'''simple docstring'''






													return self.linear(SCREAMING_SNAKE_CASE_     )



							def       A__						(					self       ,		SCREAMING_SNAKE_CASE_     )->				Any:





													'''simple docstring'''






													pass






class     SCREAMING_SNAKE_CASE__      (							SCREAMING_SNAKE_CASE_      ):

							"""simple docstring"""






							_snake_case       						=					NoSuperInitConfig



							def __init__(					self       ,		SCREAMING_SNAKE_CASE_     )->				Tuple:





													'''simple docstring'''






													super().__init__(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     torch.nn.Linear(config.attribute       ,		config.attribute     )



							def       A__						(					self       ,		SCREAMING_SNAKE_CASE_     )->				List[str]:





													'''simple docstring'''






													return self.linear(SCREAMING_SNAKE_CASE_     )



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





													'''simple docstring'''






													pass




