
"""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 					A_			:





							def __init__(						self						:List[str]  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:List[Any]=13  ,							lowerCamelCase_						:Optional[int]=32  ,							lowerCamelCase_						:str=2  ,							lowerCamelCase_						:str=3  ,							lowerCamelCase_						:str=16  ,							lowerCamelCase_						:Dict=[1, 2, 1]  ,							lowerCamelCase_						:str=[2, 2, 4]  ,							lowerCamelCase_						:int=2  ,							lowerCamelCase_						:Any=2.0  ,							lowerCamelCase_						:Optional[int]=True  ,							lowerCamelCase_						:Any=0.0  ,							lowerCamelCase_						:Optional[int]=0.0  ,							lowerCamelCase_						:Dict=0.1  ,							lowerCamelCase_						:List[str]="gelu"  ,							lowerCamelCase_						:Optional[Any]=False  ,							lowerCamelCase_						:int=True  ,							lowerCamelCase_						:List[str]=0.02  ,							lowerCamelCase_						:Optional[Any]=1e-5  ,							lowerCamelCase_						:List[str]=True  ,							lowerCamelCase_						:Any=None  ,							lowerCamelCase_						:Dict=True  ,							lowerCamelCase_						:Union[str, Any]=10  ,							lowerCamelCase_						:List[Any]=8  ,							lowerCamelCase_						:Union[str, Any]=["stage1", "stage2"]  ,							lowerCamelCase_						:Any=[1, 2]  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Any  =parent
										lowerCamelCase__			:  Any  =batch_size
										lowerCamelCase__			:  List[Any]  =image_size
										lowerCamelCase__			:  Any  =patch_size
										lowerCamelCase__			:  Any  =num_channels
										lowerCamelCase__			:  str  =embed_dim
										lowerCamelCase__			:  Dict  =depths
										lowerCamelCase__			:  Any  =num_heads
										lowerCamelCase__			:  Dict  =window_size
										lowerCamelCase__			:  List[Any]  =mlp_ratio
										lowerCamelCase__			:  Tuple  =qkv_bias
										lowerCamelCase__			:  Dict  =hidden_dropout_prob
										lowerCamelCase__			:  str  =attention_probs_dropout_prob
										lowerCamelCase__			:  Union[str, Any]  =drop_path_rate
										lowerCamelCase__			:  Optional[Any]  =hidden_act
										lowerCamelCase__			:  int  =use_absolute_embeddings
										lowerCamelCase__			:  Tuple  =patch_norm
										lowerCamelCase__			:  Union[str, Any]  =layer_norm_eps
										lowerCamelCase__			:  str  =initializer_range
										lowerCamelCase__			:  str  =is_training
										lowerCamelCase__			:  str  =scope
										lowerCamelCase__			:  str  =use_labels
										lowerCamelCase__			:  Tuple  =type_sequence_label_size
										lowerCamelCase__			:  Any  =encoder_stride
										lowerCamelCase__			:  List[str]  =out_features
										lowerCamelCase__			:  int  =out_indices





							def    UpperCAmelCase__							(						self						:Optional[Any] ):





										"""simple docstring"""

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

										lowerCamelCase__			:  Optional[Any]  =None
										if self.use_labels:
													lowerCamelCase__			:  Optional[int]  =ids_tensor([self.batch_size]  ,							self.type_sequence_label_size )

										lowerCamelCase__			:  Tuple  =self.get_config()

										return config, pixel_values, labels





							def    UpperCAmelCase__							(						self						:str ):





										"""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    UpperCAmelCase__							(						self						:int  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:Any ):





										"""simple docstring"""

										lowerCamelCase__			:  Optional[Any]  =SwinModel(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Any  =model(lowerCamelCase_ )

										lowerCamelCase__			:  Optional[int]  =((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
										lowerCamelCase__			:  List[str]  =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						:List[Any]  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  int  =SwinBackbone(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Tuple  =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
										lowerCamelCase__			:  List[str]  =None
										lowerCamelCase__			:  str  =SwinBackbone(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  List[str]  =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    UpperCAmelCase__							(						self						:int  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Dict ):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =SwinForMaskedImageModeling(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  List[str]  =model(lowerCamelCase_ )
										self.parent.assertEqual(
										    result.logits.shape  ,							(self.batch_size, self.num_channels, self.image_size, self.image_size) )

										# test greyscale images
										lowerCamelCase__			:  int  =1
										lowerCamelCase__			:  Union[str, Any]  =SwinForMaskedImageModeling(lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()

										lowerCamelCase__			:  List[Any]  =floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
										lowerCamelCase__			:  str  =model(lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, 1, self.image_size, self.image_size) )





							def    UpperCAmelCase__							(						self						:List[Any]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Union[str, Any] ):





										"""simple docstring"""

										lowerCamelCase__			:  List[str]  =self.type_sequence_label_size
										lowerCamelCase__			:  str  =SwinForImageClassification(lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  List[Any]  =model(lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.type_sequence_label_size) )

										# test greyscale images
										lowerCamelCase__			:  int  =1
										lowerCamelCase__			:  int  =SwinForImageClassification(lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()

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





							def    UpperCAmelCase__							(						self						:int ):





										"""simple docstring"""

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






@require_torch
class 					A_			(  A__   ,      A__   ,      unittest.TestCase     ):
							SCREAMING_SNAKE_CASE_			   =     (
							    (
							        SwinModel,
							        SwinBackbone,
							        SwinForImageClassification,
							        SwinForMaskedImageModeling,
							    )
							    if is_torch_available()
							    else ()
							)
							SCREAMING_SNAKE_CASE_			   =     (
							    {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
							    if is_torch_available()
							    else {}
							)
							SCREAMING_SNAKE_CASE_			   =     True

							SCREAMING_SNAKE_CASE_			   =     False
							SCREAMING_SNAKE_CASE_			   =     False
							SCREAMING_SNAKE_CASE_			   =     False





							def    UpperCAmelCase__							(						self						:Tuple ):





										"""simple docstring"""

										lowerCamelCase__			:  Tuple  =SwinModelTester(self )
										lowerCamelCase__			:  Dict  =ConfigTester(self  ,							config_class=lowerCamelCase_  ,							embed_dim=37 )





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





										"""simple docstring"""

										return





							def    UpperCAmelCase__							(						self						:Optional[int] ):





										"""simple docstring"""

										lowerCamelCase__			:  Union[str, Any]  =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    UpperCAmelCase__							(						self						:List[Any] ):





										"""simple docstring"""

										pass





							def    UpperCAmelCase__							(						self						:Optional[Any] ):





										"""simple docstring"""

										super().test_training_gradient_checkpointing()





							def    UpperCAmelCase__							(						self						:List[Any] ):





										"""simple docstring"""

										lowerCamelCase__			:  Optional[Any]  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*lowerCamelCase_ )





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





										"""simple docstring"""

										lowerCamelCase__			:  List[Any]  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Optional[int] ):





										"""simple docstring"""

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





										"""simple docstring"""

										pass





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





										"""simple docstring"""

										pass





							def    UpperCAmelCase__							(						self						:Any ):





										"""simple docstring"""

										lowerCamelCase__			:  Tuple  =self.model_tester.prepare_config_and_inputs_for_common()

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





							def    UpperCAmelCase__							(						self						:str ):





										"""simple docstring"""

										lowerCamelCase__			:  Union[str, Any]  =self.model_tester.prepare_config_and_inputs_for_common()

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

													lowerCamelCase__			:  Optional[Any]  =['pixel_values']
													self.assertListEqual(arg_names[:1]  ,							lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Optional[Any] ):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =self.model_tester.prepare_config_and_inputs_for_common()
										lowerCamelCase__			:  List[str]  =True

										for model_class in self.all_model_classes:
													lowerCamelCase__			:  Optional[Any]  =True
													lowerCamelCase__			:  Union[str, Any]  =False
													lowerCamelCase__			:  str  =True
													lowerCamelCase__			:  Any  =model_class(lowerCamelCase_ )
													model.to(lowerCamelCase_ )
													model.eval()
													with torch.no_grad():
																lowerCamelCase__			:  int  =model(**self._prepare_for_class(lowerCamelCase_  ,							lowerCamelCase_ ) )
													lowerCamelCase__			:  List[Any]  =outputs.attentions
													lowerCamelCase__			:  Dict  =len(self.model_tester.depths )
													self.assertEqual(len(lowerCamelCase_ )  ,							lowerCamelCase_ )

													# check that output_attentions also work using config
													del inputs_dict["output_attentions"]
													lowerCamelCase__			:  Dict  =True
													lowerCamelCase__			:  Optional[int]  =config.window_size**2
													lowerCamelCase__			:  int  =model_class(lowerCamelCase_ )
													model.to(lowerCamelCase_ )
													model.eval()
													with torch.no_grad():
																lowerCamelCase__			:  List[str]  =model(**self._prepare_for_class(lowerCamelCase_  ,							lowerCamelCase_ ) )
													lowerCamelCase__			:  List[Any]  =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]  ,							)
													lowerCamelCase__			:  List[Any]  =len(lowerCamelCase_ )

													# Check attention is always last and order is fine
													lowerCamelCase__			:  List[Any]  =True
													lowerCamelCase__			:  Dict  =True
													lowerCamelCase__			:  Any  =model_class(lowerCamelCase_ )
													model.to(lowerCamelCase_ )
													model.eval()
													with torch.no_grad():
																lowerCamelCase__			:  int  =model(**self._prepare_for_class(lowerCamelCase_  ,							lowerCamelCase_ ) )

													# also another +1 for reshaped_hidden_states
													lowerCamelCase__			:  Union[str, Any]  =1 if model_class.__name__ == 'SwinBackbone' else 2
													self.assertEqual(out_len + added_hidden_states  ,							len(lowerCamelCase_ ) )

													lowerCamelCase__			:  str  =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    UpperCAmelCase__							(						self						:Optional[int]  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Tuple ):





										"""simple docstring"""

										lowerCamelCase__			:  Tuple  =model_class(lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()

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

										lowerCamelCase__			:  str  =outputs.hidden_states

										lowerCamelCase__			:  str  =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
										lowerCamelCase__			:  List[str]  =(
										    config.patch_size
										    if isinstance(config.patch_size  ,							collections.abc.Iterable )
										    else (config.patch_size, config.patch_size)
										)

										lowerCamelCase__			:  int  =(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":
													lowerCamelCase__			:  Union[str, Any]  =outputs.reshaped_hidden_states
													self.assertEqual(len(lowerCamelCase_ )  ,							lowerCamelCase_ )

													lowerCamelCase__			:  Dict  =reshaped_hidden_states[0].shape
													lowerCamelCase__			:  int  =(
													    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    UpperCAmelCase__							(						self						:Any ):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =self.model_tester.prepare_config_and_inputs_for_common()

										lowerCamelCase__			:  Union[str, Any]  =(
										    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:
													lowerCamelCase__			:  Optional[int]  =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"]
													lowerCamelCase__			:  Optional[int]  =True

													self.check_hidden_states_output(lowerCamelCase_  ,							lowerCamelCase_  ,							lowerCamelCase_  ,							lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Optional[int] ):





										"""simple docstring"""

										lowerCamelCase__			:  Any  =self.model_tester.prepare_config_and_inputs_for_common()
										lowerCamelCase__			:  List[str]  =3

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

										lowerCamelCase__			:  List[Any]  =image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
										lowerCamelCase__			:  Tuple  =image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

										for model_class in self.all_model_classes:
													lowerCamelCase__			:  Any  =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"]
													lowerCamelCase__			:  Optional[int]  =True
													self.check_hidden_states_output(lowerCamelCase_  ,							lowerCamelCase_  ,							lowerCamelCase_  ,							(padded_height, padded_width) )





							@slow
							def    UpperCAmelCase__							(						self						:Optional[Any] ):





										"""simple docstring"""

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





							def    UpperCAmelCase__							(						self						:Tuple ):





										"""simple docstring"""

										lowerCamelCase__			:  Union[str, Any]  =self.model_tester.prepare_config_and_inputs_for_common()

										lowerCamelCase__			:  List[Any]  =_config_zero_init(lowerCamelCase_ )
										for model_class in self.all_model_classes:
													lowerCamelCase__			:  Optional[int]  =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 					A_			(  unittest.TestCase     ):





							@cached_property
							def    UpperCAmelCase__							(						self						:Union[str, Any] ):





										"""simple docstring"""

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





							@slow
							def    UpperCAmelCase__							(						self						:Optional[Any] ):





										"""simple docstring"""

										lowerCamelCase__			:  int  =SwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224' ).to(lowerCamelCase_ )
										lowerCamelCase__			:  Dict  =self.default_image_processor

										lowerCamelCase__			:  Tuple  =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
										lowerCamelCase__			:  Dict  =image_processor(images=lowerCamelCase_  ,							return_tensors='pt' ).to(lowerCamelCase_ )

										# forward pass
										with torch.no_grad():
													lowerCamelCase__			:  List[Any]  =model(**lowerCamelCase_ )

										# verify the logits
										lowerCamelCase__			:  List[str]  =torch.Size((1, 1_000) )
										self.assertEqual(outputs.logits.shape  ,							lowerCamelCase_ )
										lowerCamelCase__			:  Optional[Any]  =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 					A_			(  unittest.TestCase   ,      A__     ):
							SCREAMING_SNAKE_CASE_			   =     (SwinBackbone,) if is_torch_available() else ()
							SCREAMING_SNAKE_CASE_			   =     SwinConfig





							def    UpperCAmelCase__							(						self						:Dict ):





										"""simple docstring"""

										lowerCamelCase__			:  Optional[int]  =SwinModelTester(self )

"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


lowerCAmelCase			=		{
    """configuration_donut_swin""": ["""DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DonutSwinConfig"""],
    """processing_donut""": ["""DonutProcessor"""],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase			=		[
							    """DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """DonutSwinModel""",
							    """DonutSwinPreTrainedModel""",
							]

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase			=		["""DonutFeatureExtractor"""]
							lowerCAmelCase			=		["""DonutImageProcessor"""]


if TYPE_CHECKING:
							from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
							from .processing_donut import DonutProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_donut_swin import (
														    DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
														    DonutSwinModel,
														    DonutSwinPreTrainedModel,
														)

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_donut import DonutFeatureExtractor
														from .image_processing_donut import DonutImageProcessor

else:
							import sys

							lowerCAmelCase			=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)