



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




      """simple docstring"""




      def __init__( self							: List[Any]       ,     SCREAMING_SNAKE_CASE_							: Union[str, Any]       ,     SCREAMING_SNAKE_CASE_							: Union[str, Any]=1_3       ,     SCREAMING_SNAKE_CASE_							: int=3_2       ,     SCREAMING_SNAKE_CASE_							: List[str]=2       ,     SCREAMING_SNAKE_CASE_							: Dict=3       ,     SCREAMING_SNAKE_CASE_							: Optional[Any]=1_6       ,     SCREAMING_SNAKE_CASE_							: List[Any]=[1, 2, 1]       ,     SCREAMING_SNAKE_CASE_							: Optional[Any]=[2, 2, 4]       ,     SCREAMING_SNAKE_CASE_							: str=2       ,     SCREAMING_SNAKE_CASE_							: str=2.0       ,     SCREAMING_SNAKE_CASE_							: Optional[int]=True       ,     SCREAMING_SNAKE_CASE_							: Optional[int]=0.0       ,     SCREAMING_SNAKE_CASE_							: List[str]=0.0       ,     SCREAMING_SNAKE_CASE_							: Union[str, Any]=0.1       ,     SCREAMING_SNAKE_CASE_							: Any="gelu"       ,     SCREAMING_SNAKE_CASE_							: Union[str, Any]=False       ,     SCREAMING_SNAKE_CASE_							: List[str]=True       ,     SCREAMING_SNAKE_CASE_							: Optional[int]=0.02       ,     SCREAMING_SNAKE_CASE_							: int=1E-5       ,     SCREAMING_SNAKE_CASE_							: Dict=True       ,     SCREAMING_SNAKE_CASE_							: int=None       ,     SCREAMING_SNAKE_CASE_							: int=True       ,     SCREAMING_SNAKE_CASE_							: str=1_0       ,     SCREAMING_SNAKE_CASE_							: Optional[int]=8       ,     SCREAMING_SNAKE_CASE_							: int=["stage1", "stage2"]       ,     SCREAMING_SNAKE_CASE_							: str=[1, 2]       ,     ):
        lowerCAmelCase_  :							Any								=					parent
        lowerCAmelCase_  :							Tuple								=					batch_size
        lowerCAmelCase_  :							List[Any]								=					image_size
        lowerCAmelCase_  :							int								=					patch_size
        lowerCAmelCase_  :							str								=					num_channels
        lowerCAmelCase_  :							Optional[int]								=					embed_dim
        lowerCAmelCase_  :							List[Any]								=					depths
        lowerCAmelCase_  :							Any								=					num_heads
        lowerCAmelCase_  :							str								=					window_size
        lowerCAmelCase_  :							Union[str, Any]								=					mlp_ratio
        lowerCAmelCase_  :							List[str]								=					qkv_bias
        lowerCAmelCase_  :							Any								=					hidden_dropout_prob
        lowerCAmelCase_  :							List[Any]								=					attention_probs_dropout_prob
        lowerCAmelCase_  :							List[Any]								=					drop_path_rate
        lowerCAmelCase_  :							Optional[int]								=					hidden_act
        lowerCAmelCase_  :							int								=					use_absolute_embeddings
        lowerCAmelCase_  :							Optional[Any]								=					patch_norm
        lowerCAmelCase_  :							Tuple								=					layer_norm_eps
        lowerCAmelCase_  :							Optional[Any]								=					initializer_range
        lowerCAmelCase_  :							Union[str, Any]								=					is_training
        lowerCAmelCase_  :							int								=					scope
        lowerCAmelCase_  :							Tuple								=					use_labels
        lowerCAmelCase_  :							Optional[Any]								=					type_sequence_label_size
        lowerCAmelCase_  :							List[Any]								=					encoder_stride
        lowerCAmelCase_  :							Tuple								=					out_features
        lowerCAmelCase_  :							int								=					out_indices



      def 	SCREAMING_SNAKE_CASE__					( self							: int			):
        lowerCAmelCase_  :							Union[str, Any]								=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

        lowerCAmelCase_  :							Dict								=					None
        if self.use_labels:
          lowerCAmelCase_  :							Any								=					ids_tensor([self.batch_size]       ,     self.type_sequence_label_size			)

        lowerCAmelCase_  :							Optional[int]								=					self.get_config()

        return config, pixel_values, labels



      def 	SCREAMING_SNAKE_CASE__					( self							: Union[str, Any]			):
        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 	SCREAMING_SNAKE_CASE__					( self							: List[str]       ,     SCREAMING_SNAKE_CASE_							: str       ,     SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     SCREAMING_SNAKE_CASE_							: Any			):
        lowerCAmelCase_  :							List[str]								=					SwinModel(config=SCREAMING_SNAKE_CASE_			)
        model.to(SCREAMING_SNAKE_CASE_			)
        model.eval()
        lowerCAmelCase_  :							Tuple								=					model(SCREAMING_SNAKE_CASE_			)

        lowerCAmelCase_  :							Dict								=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
        lowerCAmelCase_  :							Optional[int]								=					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 	SCREAMING_SNAKE_CASE__					( self							: Optional[Any]       ,     SCREAMING_SNAKE_CASE_							: List[Any]       ,     SCREAMING_SNAKE_CASE_							: Dict       ,     SCREAMING_SNAKE_CASE_							: Optional[Any]			):
        lowerCAmelCase_  :							Optional[Any]								=					SwinBackbone(config=SCREAMING_SNAKE_CASE_			)
        model.to(SCREAMING_SNAKE_CASE_			)
        model.eval()
        lowerCAmelCase_  :							Optional[int]								=					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], 1_6, 1_6]			)

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

        # verify backbone works with out_features=None
        lowerCAmelCase_  :							List[Any]								=					None
        lowerCAmelCase_  :							Union[str, Any]								=					SwinBackbone(config=SCREAMING_SNAKE_CASE_			)
        model.to(SCREAMING_SNAKE_CASE_			)
        model.eval()
        lowerCAmelCase_  :							List[str]								=					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 	SCREAMING_SNAKE_CASE__					( self							: Union[str, Any]       ,     SCREAMING_SNAKE_CASE_							: int       ,     SCREAMING_SNAKE_CASE_							: int       ,     SCREAMING_SNAKE_CASE_							: Dict			):
        lowerCAmelCase_  :							List[Any]								=					SwinForMaskedImageModeling(config=SCREAMING_SNAKE_CASE_			)
        model.to(SCREAMING_SNAKE_CASE_			)
        model.eval()
        lowerCAmelCase_  :							Optional[int]								=					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
        lowerCAmelCase_  :							int								=					1
        lowerCAmelCase_  :							Tuple								=					SwinForMaskedImageModeling(SCREAMING_SNAKE_CASE_			)
        model.to(SCREAMING_SNAKE_CASE_			)
        model.eval()

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



      def 	SCREAMING_SNAKE_CASE__					( self							: int       ,     SCREAMING_SNAKE_CASE_							: List[Any]       ,     SCREAMING_SNAKE_CASE_							: Dict       ,     SCREAMING_SNAKE_CASE_							: Union[str, Any]			):
        lowerCAmelCase_  :							List[Any]								=					self.type_sequence_label_size
        lowerCAmelCase_  :							List[str]								=					SwinForImageClassification(SCREAMING_SNAKE_CASE_			)
        model.to(SCREAMING_SNAKE_CASE_			)
        model.eval()
        lowerCAmelCase_  :							int								=					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
        lowerCAmelCase_  :							Union[str, Any]								=					1
        lowerCAmelCase_  :							List[str]								=					SwinForImageClassification(SCREAMING_SNAKE_CASE_			)
        model.to(SCREAMING_SNAKE_CASE_			)
        model.eval()

        lowerCAmelCase_  :							List[Any]								=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
        lowerCAmelCase_  :							int								=					model(SCREAMING_SNAKE_CASE_			)
        self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size)			)





      def 	SCREAMING_SNAKE_CASE__					( self							: Optional[int]			):
        lowerCAmelCase_  :							int								=					self.prepare_config_and_inputs()
        (
            (
            lowerCAmelCase_
        )		,(
            lowerCAmelCase_
        )		,(
            lowerCAmelCase_
        )		,
        )  :							Tuple								=					config_and_inputs
        lowerCAmelCase_  :							str								=					{'pixel_values': pixel_values}
        return config, inputs_dict







@require_torch
class  UpperCamelCase__  (      lowercase_,   lowercase_,   unittest.TestCase    ):




      """simple docstring"""




      _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 	SCREAMING_SNAKE_CASE__					( self							: Dict			):
        lowerCAmelCase_  :							str								=					SwinModelTester(self			)
        lowerCAmelCase_  :							int								=					ConfigTester(self       ,     config_class=SCREAMING_SNAKE_CASE_       ,     embed_dim=3_7			)



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



      def 	SCREAMING_SNAKE_CASE__					( self							: str			):
        lowerCAmelCase_  :							str								=					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 	SCREAMING_SNAKE_CASE__					( self							: str			):
        pass



      def 	SCREAMING_SNAKE_CASE__					( self							: Optional[Any]			):
        super().test_training_gradient_checkpointing()



      def 	SCREAMING_SNAKE_CASE__					( self							: Any			):
        lowerCAmelCase_  :							Dict								=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE_			)



      def 	SCREAMING_SNAKE_CASE__					( self							: Optional[int]			):
        lowerCAmelCase_  :							Tuple								=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_			)



      def 	SCREAMING_SNAKE_CASE__					( self							: List[str]			):
        lowerCAmelCase_  :							Optional[Any]								=					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 	SCREAMING_SNAKE_CASE__					( self							: List[str]			):
        pass



      @unittest.skip(reason='Swin Transformer does not use feedforward chunking'			)
      def 	SCREAMING_SNAKE_CASE__					( self							: int			):
        pass



      def 	SCREAMING_SNAKE_CASE__					( self							: List[str]			):
        lowerCAmelCase_		,lowerCAmelCase_  :							Tuple								=					self.model_tester.prepare_config_and_inputs_for_common()

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



      def 	SCREAMING_SNAKE_CASE__					( self							: int			):
        lowerCAmelCase_		,lowerCAmelCase_  :							Union[str, Any]								=					self.model_tester.prepare_config_and_inputs_for_common()

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

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



      def 	SCREAMING_SNAKE_CASE__					( self							: int			):
        lowerCAmelCase_		,lowerCAmelCase_  :							Optional[Any]								=					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_  :							Any								=					False
          lowerCAmelCase_  :							Dict								=					True
          lowerCAmelCase_  :							Union[str, Any]								=					model_class(SCREAMING_SNAKE_CASE_			)
          model.to(SCREAMING_SNAKE_CASE_			)
          model.eval()
          with torch.no_grad():
            lowerCAmelCase_  :							Optional[int]								=					model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_			)			)
          lowerCAmelCase_  :							Any								=					outputs.attentions
          lowerCAmelCase_  :							Optional[Any]								=					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"]
          lowerCAmelCase_  :							str								=					True
          lowerCAmelCase_  :							Dict								=					config.window_size**2
          lowerCAmelCase_  :							Union[str, Any]								=					model_class(SCREAMING_SNAKE_CASE_			)
          model.to(SCREAMING_SNAKE_CASE_			)
          model.eval()
          with torch.no_grad():
            lowerCAmelCase_  :							Optional[Any]								=					model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_			)			)
          lowerCAmelCase_  :							Any								=					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]       ,     )
          lowerCAmelCase_  :							Any								=					len(SCREAMING_SNAKE_CASE_			)

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

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

          lowerCAmelCase_  :							Optional[int]								=					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 	SCREAMING_SNAKE_CASE__					( self							: List[str]       ,     SCREAMING_SNAKE_CASE_							: Dict       ,     SCREAMING_SNAKE_CASE_							: str       ,     SCREAMING_SNAKE_CASE_							: Dict       ,     SCREAMING_SNAKE_CASE_							: Any			):
        lowerCAmelCase_  :							Dict								=					model_class(SCREAMING_SNAKE_CASE_			)
        model.to(SCREAMING_SNAKE_CASE_			)
        model.eval()

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

        lowerCAmelCase_  :							Any								=					outputs.hidden_states

        lowerCAmelCase_  :							Union[str, Any]								=					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
        lowerCAmelCase_  :							Optional[Any]								=					(
            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_  :							Tuple								=					outputs.reshaped_hidden_states
          self.assertEqual(len(SCREAMING_SNAKE_CASE_			)       ,     SCREAMING_SNAKE_CASE_			)

          lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_  :							List[str]								=					reshaped_hidden_states[0].shape
          lowerCAmelCase_  :							Any								=					(
              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 	SCREAMING_SNAKE_CASE__					( self							: List[str]			):
        lowerCAmelCase_		,lowerCAmelCase_  :							Tuple								=					self.model_tester.prepare_config_and_inputs_for_common()

        lowerCAmelCase_  :							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:
          lowerCAmelCase_  :							Optional[int]								=					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"]
          lowerCAmelCase_  :							List[Any]								=					True

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



      def 	SCREAMING_SNAKE_CASE__					( self							: Tuple			):
        lowerCAmelCase_		,lowerCAmelCase_  :							str								=					self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase_  :							Union[str, Any]								=					3

        lowerCAmelCase_  :							str								=					(
            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_  :							Any								=					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
        lowerCAmelCase_  :							Union[str, Any]								=					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

        for model_class in self.all_model_classes:
          lowerCAmelCase_  :							List[str]								=					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"]
          lowerCAmelCase_  :							Union[str, Any]								=					True
          self.check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_       ,     (padded_height, padded_width)			)



      @slow
      def 	SCREAMING_SNAKE_CASE__					( self							: Dict			):
        for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowerCAmelCase_  :							Any								=					SwinModel.from_pretrained(SCREAMING_SNAKE_CASE_			)
          self.assertIsNotNone(SCREAMING_SNAKE_CASE_			)





      def 	SCREAMING_SNAKE_CASE__					( self							: Dict			):
        lowerCAmelCase_		,lowerCAmelCase_  :							Tuple								=					self.model_tester.prepare_config_and_inputs_for_common()

        lowerCAmelCase_  :							int								=					_config_zero_init(SCREAMING_SNAKE_CASE_			)
        for model_class in self.all_model_classes:
          lowerCAmelCase_  :							Tuple								=					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  UpperCamelCase__  (      unittest.TestCase    ):




      """simple docstring"""




      @cached_property
      def 	SCREAMING_SNAKE_CASE__					( self							: Optional[Any]			):
        return (
            AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'			)
            if is_vision_available()
            else None
        )





      @slow
      def 	SCREAMING_SNAKE_CASE__					( self							: Any			):
        lowerCAmelCase_  :							List[Any]								=					SwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'			).to(SCREAMING_SNAKE_CASE_			)
        lowerCAmelCase_  :							Optional[Any]								=					self.default_image_processor

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

        # forward pass
        with torch.no_grad():
          lowerCAmelCase_  :							List[str]								=					model(**SCREAMING_SNAKE_CASE_			)

        # verify the logits
        lowerCAmelCase_  :							List[Any]								=					torch.Size((1, 1_0_0_0)			)
        self.assertEqual(outputs.logits.shape       ,     SCREAMING_SNAKE_CASE_			)
        lowerCAmelCase_  :							Union[str, Any]								=					torch.tensor([-0.09_48, -0.64_54, -0.09_21]			).to(SCREAMING_SNAKE_CASE_			)
        self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,     SCREAMING_SNAKE_CASE_       ,     atol=1E-4			)			)







@require_torch
class  UpperCamelCase__  (      unittest.TestCase,   lowercase_    ):




      """simple docstring"""




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



      def 	SCREAMING_SNAKE_CASE__					( self							: int			):
        lowerCAmelCase_  :							int								=					SwinModelTester(self			)










"""simple docstring"""







import pytest

from datasets.utils.version import Version

@pytest.mark.parametrize(
    'other, expected_equality'       ,  [
        (Version('1.0.0'		), True),
        ('1.0.0', True),
        (Version('2.0.0'		), False),
        ('2.0.0', False),
        ('1', False),
        ('a', False),
        (1, False),
        (None, False),
    ]       ,  )
def 							UpperCamelCase_       (       lowerCAmelCase__ :							List[Any]       ,  lowerCAmelCase__ :							List[Any]		)		->  Tuple:

  """simple docstring"""




  lowerCAmelCase_  :							List[str]								=					Version('1.0.0'		)
  assert (version == other) is expected_equality
  assert (version != other) is not expected_equality
  assert (hash(lowerCAmelCase__		) == hash(lowerCAmelCase__		)) is expected_equality





