
import math
from collections import OrderedDict

import torch
from packaging import version
from torch import Tensor, nn

from .utils import logging


_snake_case		  =   logging.get_logger(__name__)


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def __init__( self):
            super().__init__()
            if version.parse(torch.__version__) < version.parse('''1.12.0'''):
                  raise ImportError(
                      f'You are using torch=={torch.__version__}, but torch>=1.12.0 is required to use '
                      '''PytorchGELUTanh. Please upgrade torch.''')







      def lowercase__		( self					,					_UpperCAmelCase):
            return nn.functional.gelu(_UpperCAmelCase					,					approximate='''tanh''')


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def lowercase__		( self					,					_UpperCAmelCase):
            return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (input + 0.044715 * torch.pow(_UpperCAmelCase					,					3.0))))


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def __init__( self					,					_UpperCAmelCase = False):
            super().__init__()
            if use_gelu_python:
                  lowerCAmelCase_						=      self._gelu_python
            else:
                  lowerCAmelCase_						=      nn.functional.gelu







      def lowercase__		( self					,					_UpperCAmelCase):
            return input * 0.5 * (1.0 + torch.erf(input / math.sqrt(2.0)))







      def lowercase__		( self					,					_UpperCAmelCase):
            return self.act(_UpperCAmelCase)


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def lowercase__		( self					,					_UpperCAmelCase):
            return 0.5 * input * (1.0 + torch.tanh(input * 0.7978845608 * (1.0 + 0.044715 * input * input)))


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def lowercase__		( self					,					_UpperCAmelCase):
            return input * torch.sigmoid(1.702 * input)


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def __init__( self					,					_UpperCAmelCase					,					_UpperCAmelCase):
            if min > max:
                  raise ValueError(f'min should be < max (got min: {min}, max: {max})')

            super().__init__()
            lowerCAmelCase_						=      min
            lowerCAmelCase_						=      max







      def lowercase__		( self					,					_UpperCAmelCase):
            return torch.clip(gelu(_UpperCAmelCase)					,					self.min					,					self.max)


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def __init__( self):
            super().__init__()
            lowerCAmelCase_						=      math.sqrt(2 / math.pi)







      def lowercase__		( self					,					_UpperCAmelCase):
            return 0.5 * input * (1 + torch.tanh(self.precomputed_constant * (input + 0.044715 * torch.pow(_UpperCAmelCase					,					3))))


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def lowercase__		( self					,					_UpperCAmelCase):
            return nn.functional.silu(_UpperCAmelCase)


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def __init__( self):
            super().__init__()
            if version.parse(torch.__version__) < version.parse('''1.9.0'''):
                  lowerCAmelCase_						=      self._mish_python
            else:
                  lowerCAmelCase_						=      nn.functional.mish







      def lowercase__		( self					,					_UpperCAmelCase):
            return input * torch.tanh(nn.functional.softplus(_UpperCAmelCase))







      def lowercase__		( self					,					_UpperCAmelCase):
            return self.act(_UpperCAmelCase)


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def lowercase__		( self					,					_UpperCAmelCase):
            return input


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase=0.707107					,					_UpperCAmelCase=0.282095):
            lowerCAmelCase_						=      (input - mu).div(sigma * math.sqrt(2.0))
            return 0.5 * (1.0 + torch.erf(_UpperCAmelCase))


class 			UpperCamelCase_				(  nn.Module     ):




      '''simple docstring'''







      def lowercase__		( self					,					_UpperCAmelCase):
            lowerCAmelCase_						=      nn.functional.relu(_UpperCAmelCase)
            lowerCAmelCase_						=      torch.square(_UpperCAmelCase)
            return squared


class 			UpperCamelCase_				(  A     ):




      '''simple docstring'''







      def __getitem__( self					,					_UpperCAmelCase):
            lowerCAmelCase_						=      super().__getitem__(_UpperCAmelCase)
            lowerCAmelCase_			,		lowerCAmelCase_						=      content if isinstance(_UpperCAmelCase					,					_UpperCAmelCase) else (content, {})
            return cls(**_UpperCAmelCase)
_snake_case		  =   {
    "gelu": GELUActivation,
    "gelu_10": (ClippedGELUActivation, {"min": -10, "max": 10}),
    "gelu_fast": FastGELUActivation,
    "gelu_new": NewGELUActivation,
    "gelu_python": (GELUActivation, {"use_gelu_python": True}),
    "gelu_pytorch_tanh": PytorchGELUTanh,
    "gelu_accurate": AccurateGELUActivation,
    "laplace": LaplaceActivation,
    "linear": LinearActivation,
    "mish": MishActivation,
    "quick_gelu": QuickGELUActivation,
    "relu": nn.ReLU,
    "relu2": ReLUSquaredActivation,
    "relu6": nn.ReLUa,
    "sigmoid": nn.Sigmoid,
    "silu": SiLUActivation,
    "swish": SiLUActivation,
    "tanh": nn.Tanh,
}
_snake_case		  =   ClassInstantier(ACTaCLS)
def lowerCamelCase_       (			A			:      Union[str, Any]						):




      """simple docstring"""
      if activation_string in ACTaFN:
            return ACTaFN[activation_string]
      else:
            raise KeyError(F'function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()						)}'						)


# For backwards compatibility with: from activations import gelu_python
_snake_case		  =   get_activation("gelu_python")
_snake_case		  =   get_activation("gelu_new")
_snake_case		  =   get_activation("gelu")
_snake_case		  =   get_activation("gelu_fast")
_snake_case		  =   get_activation("quick_gelu")
_snake_case		  =   get_activation("silu")
_snake_case		  =   get_activation("mish")




_snake_case		  =   get_activation("linear")





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					,					_UpperCAmelCase					,					_UpperCAmelCase=13					,					_UpperCAmelCase=32					,					_UpperCAmelCase=2					,					_UpperCAmelCase=3					,					_UpperCAmelCase=16					,					_UpperCAmelCase=[1, 2, 1]					,					_UpperCAmelCase=[2, 2, 4]					,					_UpperCAmelCase=2					,					_UpperCAmelCase=2.0					,					_UpperCAmelCase=True					,					_UpperCAmelCase=0.0					,					_UpperCAmelCase=0.0					,					_UpperCAmelCase=0.1					,					_UpperCAmelCase="gelu"					,					_UpperCAmelCase=False					,					_UpperCAmelCase=True					,					_UpperCAmelCase=0.02					,					_UpperCAmelCase=1E-5					,					_UpperCAmelCase=True					,					_UpperCAmelCase=None					,					_UpperCAmelCase=True					,					_UpperCAmelCase=10					,					_UpperCAmelCase=8					,					_UpperCAmelCase=["stage1", "stage2"]					,					_UpperCAmelCase=[1, 2]					,					):
            lowerCAmelCase_						=      parent
            lowerCAmelCase_						=      batch_size
            lowerCAmelCase_						=      image_size
            lowerCAmelCase_						=      patch_size
            lowerCAmelCase_						=      num_channels
            lowerCAmelCase_						=      embed_dim
            lowerCAmelCase_						=      depths
            lowerCAmelCase_						=      num_heads
            lowerCAmelCase_						=      window_size
            lowerCAmelCase_						=      mlp_ratio
            lowerCAmelCase_						=      qkv_bias
            lowerCAmelCase_						=      hidden_dropout_prob
            lowerCAmelCase_						=      attention_probs_dropout_prob
            lowerCAmelCase_						=      drop_path_rate
            lowerCAmelCase_						=      hidden_act
            lowerCAmelCase_						=      use_absolute_embeddings
            lowerCAmelCase_						=      patch_norm
            lowerCAmelCase_						=      layer_norm_eps
            lowerCAmelCase_						=      initializer_range
            lowerCAmelCase_						=      is_training
            lowerCAmelCase_						=      scope
            lowerCAmelCase_						=      use_labels
            lowerCAmelCase_						=      type_sequence_label_size
            lowerCAmelCase_						=      encoder_stride
            lowerCAmelCase_						=      out_features
            lowerCAmelCase_						=      out_indices







      def lowercase__		( self):
            lowerCAmelCase_						=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

            lowerCAmelCase_						=      self.get_config()

            return config, pixel_values, labels







      def lowercase__		( self):
            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 lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      SwinModel(config=_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()
            lowerCAmelCase_						=      model(_UpperCAmelCase)

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

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







      def lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      SwinBackbone(config=_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()
            lowerCAmelCase_						=      model(_UpperCAmelCase)

            # 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_						=      None
            lowerCAmelCase_						=      SwinBackbone(config=_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()
            lowerCAmelCase_						=      model(_UpperCAmelCase)

            # 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					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      SwinForMaskedImageModeling(config=_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()
            lowerCAmelCase_						=      model(_UpperCAmelCase)
            self.parent.assertEqual(
                result.logits.shape					,					(self.batch_size, self.num_channels, self.image_size, self.image_size))

            # test greyscale images
            lowerCAmelCase_						=      1
            lowerCAmelCase_						=      SwinForMaskedImageModeling(_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()

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







      def lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      self.type_sequence_label_size
            lowerCAmelCase_						=      SwinForImageClassification(_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()
            lowerCAmelCase_						=      model(_UpperCAmelCase					,					labels=_UpperCAmelCase)
            self.parent.assertEqual(result.logits.shape					,					(self.batch_size, self.type_sequence_label_size))

            # test greyscale images
            lowerCAmelCase_						=      1
            lowerCAmelCase_						=      SwinForImageClassification(_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()

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







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


@require_torch
class 			UpperCamelCase_				(  A					,       A					,       unittest.TestCase     ):




      '''simple docstring'''







      a		:str						 =      (
          (
              SwinModel,
              SwinBackbone,
              SwinForImageClassification,
              SwinForMaskedImageModeling,
          )
          if is_torch_available()
          else ()
      )
      a		:Optional[Any]						 =      (
          {'feature-extraction': SwinModel, 'image-classification': SwinForImageClassification}
          if is_torch_available()
          else {}
      )
      a		:Optional[int]						 =      True

      a		:Dict						 =      False
      a		:Dict						 =      False
      a		:int						 =      False







      def lowercase__		( self):
            lowerCAmelCase_						=      SwinModelTester(self)
            lowerCAmelCase_						=      ConfigTester(self					,					config_class=_UpperCAmelCase					,					embed_dim=37)







      def lowercase__		( self):
            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):
            return







      def lowercase__		( self):
            lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*_UpperCAmelCase)







      @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.''')
      def lowercase__		( self):
            pass







      def lowercase__		( self):
            super().test_training_gradient_checkpointing()







      def lowercase__		( self):
            lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_backbone(*_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase)







      @unittest.skip(reason='''Swin does not use inputs_embeds''')
      def lowercase__		( self):
            pass







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







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()

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







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()

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

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







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()
            lowerCAmelCase_						=      True

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

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

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

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

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

                  lowerCAmelCase_						=      outputs.attentions

                  self.assertEqual(len(_UpperCAmelCase)					,					_UpperCAmelCase)

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







      def lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      model_class(_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()

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

            lowerCAmelCase_						=      outputs.hidden_states

            lowerCAmelCase_						=      getattr(
                self.model_tester					,					'''expected_num_hidden_layers'''					,					len(self.model_tester.depths) + 1)
            self.assertEqual(len(_UpperCAmelCase)					,					_UpperCAmelCase)

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

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

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

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

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







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()

            lowerCAmelCase_						=      (
                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_						=      True
                  self.check_hidden_states_output(_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase)

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

                  self.check_hidden_states_output(_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()
            lowerCAmelCase_						=      3

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

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

            for model_class in self.all_model_classes:
                  lowerCAmelCase_						=      True
                  self.check_hidden_states_output(_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					(padded_height, padded_width))

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







      @slow
      def lowercase__		( self):
            for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowerCAmelCase_						=      SwinModel.from_pretrained(_UpperCAmelCase)
                  self.assertIsNotNone(_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()

            lowerCAmelCase_						=      _config_zero_init(_UpperCAmelCase)
            for model_class in self.all_model_classes:
                  lowerCAmelCase_						=      model_class(config=_UpperCAmelCase)
                  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 lowercase__		( self):
            return (
                AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224''')
                if is_vision_available()
                else None
            )







      @slow
      def lowercase__		( self):
            lowerCAmelCase_						=      SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224''').to(_UpperCAmelCase)
            lowerCAmelCase_						=      self.default_image_processor

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

            # forward pass
            with torch.no_grad():
                  lowerCAmelCase_						=      model(**_UpperCAmelCase)

            # verify the logits
            lowerCAmelCase_						=      torch.Size((1, 1_000))
            self.assertEqual(outputs.logits.shape					,					_UpperCAmelCase)
            lowerCAmelCase_						=      torch.tensor([-0.0948, -0.6454, -0.0921]).to(_UpperCAmelCase)
            self.assertTrue(torch.allclose(outputs.logits[0, :3]					,					_UpperCAmelCase					,					atol=1E-4))


@require_torch
class 			UpperCamelCase_				(  unittest.TestCase					,       A     ):




      '''simple docstring'''







      a		:Optional[Any]						 =      (SwinBackbone,) if is_torch_available() else ()
      a		:List[str]						 =      SwinConfig







      def lowercase__		( self):
            lowerCAmelCase_						=      SwinModelTester(self)



