


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       ,    __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.02       ,    __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]       ,    ):




              """simple docstring"""




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






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase			:		Union[str, Any]      		=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

              UpperCamelCase			:		Dict      		=						self.get_config()

              return config, pixel_values, labels






       def        _lowercase      (   self  ):




              """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        _lowercase      (   self       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE  ):




              """simple docstring"""




              UpperCamelCase			:		Dict      		=						SwinModel(config=__SCREAMING_SNAKE_CASE  )
              model.to(__SCREAMING_SNAKE_CASE  )
              model.eval()
              UpperCamelCase			:		Tuple      		=						model(__SCREAMING_SNAKE_CASE  )

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




              """simple docstring"""




              UpperCamelCase			:		Optional[Any]      		=						SwinBackbone(config=__SCREAMING_SNAKE_CASE  )
              model.to(__SCREAMING_SNAKE_CASE  )
              model.eval()
              UpperCamelCase			:		str      		=						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			:		List[Any]      		=						None
              UpperCamelCase			:		Union[str, Any]      		=						SwinBackbone(config=__SCREAMING_SNAKE_CASE  )
              model.to(__SCREAMING_SNAKE_CASE  )
              model.eval()
              UpperCamelCase			:		Dict      		=						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        _lowercase      (   self       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE  ):




              """simple docstring"""




              UpperCamelCase			:		List[str]      		=						SwinForMaskedImageModeling(config=__SCREAMING_SNAKE_CASE  )
              model.to(__SCREAMING_SNAKE_CASE  )
              model.eval()
              UpperCamelCase			:		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
              UpperCamelCase			:		Optional[int]      		=						1
              UpperCamelCase			:		Optional[Any]      		=						SwinForMaskedImageModeling(__SCREAMING_SNAKE_CASE  )
              model.to(__SCREAMING_SNAKE_CASE  )
              model.eval()

              UpperCamelCase			:		Optional[int]      		=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
              UpperCamelCase			:		Union[str, Any]      		=						model(__SCREAMING_SNAKE_CASE  )
              self.parent.assertEqual(result.logits.shape       ,    (self.batch_size, 1, self.image_size, self.image_size)  )






       def        _lowercase      (   self       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE  ):




              """simple docstring"""




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

              UpperCamelCase			:		Optional[Any]      		=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
              UpperCamelCase			:		str      		=						model(__SCREAMING_SNAKE_CASE  )
              self.parent.assertEqual(result.logits.shape       ,    (self.batch_size, self.type_sequence_label_size)  )






       def        _lowercase      (   self  ):




              """simple docstring"""




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




@require_torch
class       UpperCAmelCase_		(							__snake_case,   __snake_case,   unittest.TestCase):
       '''simple docstring'''
       __UpperCamelCase					:   Union[str, Any]							=    (
           (
               SwinModel,
               SwinBackbone,
               SwinForImageClassification,
               SwinForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       __UpperCamelCase					:   List[Any]							=    (
           {'feature-extraction': SwinModel, 'image-classification': SwinForImageClassification}
           if is_torch_available()
           else {}
       )
       __UpperCamelCase					:   int							=    True

       __UpperCamelCase					:   List[Any]							=    False
       __UpperCamelCase					:   Union[str, Any]							=    False
       __UpperCamelCase					:   List[Any]							=    False






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase			:		Dict      		=						SwinModelTester(self  )
              UpperCamelCase			:		List[str]      		=						ConfigTester(self       ,    config_class=__SCREAMING_SNAKE_CASE       ,    embed_dim=37  )






       def        _lowercase      (   self  ):




              """simple docstring"""




              self.create_and_test_config_common_properties()
              self.config_tester.create_and_test_config_to_json_string()
              self.config_tester.create_and_test_config_to_json_file()
              self.config_tester.create_and_test_config_from_and_save_pretrained()
              self.config_tester.create_and_test_config_with_num_labels()
              self.config_tester.check_config_can_be_init_without_params()
              self.config_tester.check_config_arguments_init()






       def        _lowercase      (   self  ):




              """simple docstring"""




              return






       def        _lowercase      (   self  ):




              """simple docstring"""




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




              """simple docstring"""




              pass






       def        _lowercase      (   self  ):




              """simple docstring"""




              super().test_training_gradient_checkpointing()






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase			:		List[str]      		=						self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE  )






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase			:		Tuple      		=						self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE  )






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase			:		List[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        _lowercase      (   self  ):




              """simple docstring"""




              pass






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




              """simple docstring"""




              pass






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase		,       UpperCamelCase			:		Tuple      		=						self.model_tester.prepare_config_and_inputs_for_common()

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






       def        _lowercase      (   self  ):




              """simple docstring"""




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

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

                     UpperCamelCase			:		Any      		=						['''pixel_values''']
                     self.assertListEqual(arg_names[:1]       ,    __SCREAMING_SNAKE_CASE  )






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase		,       UpperCamelCase			:		List[Any]      		=						self.model_tester.prepare_config_and_inputs_for_common()
              UpperCamelCase			:		List[str]      		=						True

              for model_class in self.all_model_classes:
                     UpperCamelCase			:		Union[str, Any]      		=						True
                     UpperCamelCase			:		Dict      		=						False
                     UpperCamelCase			:		Dict      		=						True
                     UpperCamelCase			:		Dict      		=						model_class(__SCREAMING_SNAKE_CASE  )
                     model.to(__SCREAMING_SNAKE_CASE  )
                     model.eval()
                     with torch.no_grad():
                            UpperCamelCase			:		Any      		=						model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE  )  )
                     UpperCamelCase			:		str      		=						outputs.attentions
                     UpperCamelCase			:		Tuple      		=						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			:		Union[str, Any]      		=						True
                     UpperCamelCase			:		Tuple      		=						config.window_size**2
                     UpperCamelCase			:		List[str]      		=						model_class(__SCREAMING_SNAKE_CASE  )
                     model.to(__SCREAMING_SNAKE_CASE  )
                     model.eval()
                     with torch.no_grad():
                            UpperCamelCase			:		Optional[int]      		=						model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE  )  )
                     UpperCamelCase			:		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]       ,    )
                     UpperCamelCase			:		Tuple      		=						len(__SCREAMING_SNAKE_CASE  )

                     # Check attention is always last and order is fine
                     UpperCamelCase			:		Optional[Any]      		=						True
                     UpperCamelCase			:		Optional[int]      		=						True
                     UpperCamelCase			:		Optional[Any]      		=						model_class(__SCREAMING_SNAKE_CASE  )
                     model.to(__SCREAMING_SNAKE_CASE  )
                     model.eval()
                     with torch.no_grad():
                            UpperCamelCase			:		Union[str, Any]      		=						model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE  )  )

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

                     UpperCamelCase			:		List[Any]      		=						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        _lowercase      (   self       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE  ):




              """simple docstring"""




              UpperCamelCase			:		Tuple      		=						model_class(__SCREAMING_SNAKE_CASE  )
              model.to(__SCREAMING_SNAKE_CASE  )
              model.eval()

              with torch.no_grad():
                     UpperCamelCase			:		int      		=						model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE  )  )

              UpperCamelCase			:		Optional[int]      		=						outputs.hidden_states

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

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

                     UpperCamelCase		,       UpperCamelCase		,       UpperCamelCase		,       UpperCamelCase			:		str      		=						reshaped_hidden_states[0].shape
                     UpperCamelCase			:		str      		=						(
                         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        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase		,       UpperCamelCase			:		int      		=						self.model_tester.prepare_config_and_inputs_for_common()

              UpperCamelCase			:		List[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:
                     UpperCamelCase			:		Any      		=						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			:		Dict      		=						True

                     self.check_hidden_states_output(__SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE       ,    __SCREAMING_SNAKE_CASE  )






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase		,       UpperCamelCase			:		Dict      		=						self.model_tester.prepare_config_and_inputs_for_common()
              UpperCamelCase			:		Union[str, Any]      		=						3

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

              UpperCamelCase			:		Union[str, Any]      		=						image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
              UpperCamelCase			:		int      		=						image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

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






       @slow
       def        _lowercase      (   self  ):




              """simple docstring"""




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






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase		,       UpperCamelCase			:		int      		=						self.model_tester.prepare_config_and_inputs_for_common()

              UpperCamelCase			:		Tuple      		=						_config_zero_init(__SCREAMING_SNAKE_CASE  )
              for model_class in self.all_model_classes:
                     UpperCamelCase			:		List[str]      		=						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        _lowercase      (   self  ):




              """simple docstring"""




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






       @slow
       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase			:		str      		=						SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''  ).to(__SCREAMING_SNAKE_CASE  )
              UpperCamelCase			:		List[str]      		=						self.default_image_processor

              UpperCamelCase			:		Tuple      		=						Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''  )
              UpperCamelCase			:		List[str]      		=						image_processor(images=__SCREAMING_SNAKE_CASE       ,    return_tensors='''pt'''  ).to(__SCREAMING_SNAKE_CASE  )

              # forward pass
              with torch.no_grad():
                     UpperCamelCase			:		Union[str, Any]      		=						model(**__SCREAMING_SNAKE_CASE  )

              # verify the logits
              UpperCamelCase			:		Dict      		=						torch.Size((1, 1_000)  )
              self.assertEqual(outputs.logits.shape       ,    __SCREAMING_SNAKE_CASE  )
              UpperCamelCase			:		int      		=						torch.tensor([-0.0_948, -0.6_454, -0.0_921]  ).to(__SCREAMING_SNAKE_CASE  )
              self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,    __SCREAMING_SNAKE_CASE       ,    atol=1e-4  )  )




@require_torch
class       UpperCAmelCase_		(							unittest.TestCase,   __snake_case):
       '''simple docstring'''
       __UpperCamelCase					:   Union[str, Any]							=    (SwinBackbone,) if is_torch_available() else ()
       __UpperCamelCase					:   List[Any]							=    SwinConfig






       def        _lowercase      (   self  ):




              """simple docstring"""




              UpperCamelCase			:		Any      		=						SwinModelTester(self  )




from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCamelCase_    =					logging.get_logger(__name__)

lowerCamelCase_    =					{
    '''google/rembert''': '''https://huggingface.co/google/rembert/resolve/main/config.json''',
    # See all RemBERT models at https://huggingface.co/models?filter=rembert
}







class  __lowerCamelCase				(	__snake_case	):
      lowerCamelCase_	:      Tuple          =					'rembert'







      def __init__(     self							,  lowerCamelCase=250300							,  lowerCamelCase=1152							,  lowerCamelCase=32							,  lowerCamelCase=18							,  lowerCamelCase=256							,  lowerCamelCase=1664							,  lowerCamelCase=4608							,  lowerCamelCase="gelu"							,  lowerCamelCase=0.0							,  lowerCamelCase=0.0							,  lowerCamelCase=0.1							,  lowerCamelCase=512							,  lowerCamelCase=2							,  lowerCamelCase=0.02							,  lowerCamelCase=1e-12							,  lowerCamelCase=True							,  lowerCamelCase=0							,  lowerCamelCase=312							,  lowerCamelCase=313							,  **lowerCamelCase							,  )						->       Union[str, Any]:
        super().__init__(pad_token_id=lowerCamelCase							,  bos_token_id=lowerCamelCase							,  eos_token_id=lowerCamelCase							,  **lowerCamelCase   )

        snake_case_       						=      vocab_size
        snake_case_       						=      input_embedding_size
        snake_case_       						=      output_embedding_size
        snake_case_       						=      max_position_embeddings
        snake_case_       						=      hidden_size
        snake_case_       						=      num_hidden_layers
        snake_case_       						=      num_attention_heads
        snake_case_       						=      intermediate_size
        snake_case_       						=      hidden_act
        snake_case_       						=      hidden_dropout_prob
        snake_case_       						=      attention_probs_dropout_prob
        snake_case_       						=      classifier_dropout_prob
        snake_case_       						=      initializer_range
        snake_case_       						=      type_vocab_size
        snake_case_       						=      layer_norm_eps
        snake_case_       						=      use_cache
        snake_case_       						=      False







class  __lowerCamelCase				(	__snake_case	):







      @property
      def 	lowerCAmelCase_    (     self   )						->       Mapping[str, Mapping[int, str]]:
        if self.task == "multiple-choice":
          snake_case_       						=      {0: """batch""", 1: """choice""", 2: """sequence"""}
        else:
          snake_case_       						=      {0: """batch""", 1: """sequence"""}
        return OrderedDict(
            [
                ("""input_ids""", dynamic_axis),
                ("""attention_mask""", dynamic_axis),
                ("""token_type_ids""", dynamic_axis),
            ]   )







      @property
      def 	lowerCAmelCase_    (     self   )						->       float:
        return 1e-4