code: 
  
  
  
  
  
  
  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 :
      """simple docstring"""
  
      def __init__(							self			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    int   ,    __SCREAMING_SNAKE_CASE			:    List[Any]=13   ,    __SCREAMING_SNAKE_CASE			:    List[Any]=32   ,    __SCREAMING_SNAKE_CASE			:    int=2   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]=3   ,    __SCREAMING_SNAKE_CASE			:    Tuple=16   ,    __SCREAMING_SNAKE_CASE			:    Union[str, Any]=[1, 2, 1]   ,    __SCREAMING_SNAKE_CASE			:    Dict=[2, 2, 4]   ,    __SCREAMING_SNAKE_CASE			:    Dict=2   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]=2.0   ,    __SCREAMING_SNAKE_CASE			:    Tuple=True   ,    __SCREAMING_SNAKE_CASE			:    Tuple=0.0   ,    __SCREAMING_SNAKE_CASE			:    Tuple=0.0   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]=0.1   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]="gelu"   ,    __SCREAMING_SNAKE_CASE			:    List[str]=False   ,    __SCREAMING_SNAKE_CASE			:    str=True   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]=0.02   ,    __SCREAMING_SNAKE_CASE			:    Dict=1e-5   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]=True   ,    __SCREAMING_SNAKE_CASE			:    Tuple=None   ,    __SCREAMING_SNAKE_CASE			:    Any=True   ,    __SCREAMING_SNAKE_CASE			:    Dict=10   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]=8   ,    __SCREAMING_SNAKE_CASE			:    int=["stage1", "stage2"]   ,    __SCREAMING_SNAKE_CASE			:    Any=[1, 2]   ,    )			->       Union[str, Any]:
             __UpperCAmelCase    							=parent
             __UpperCAmelCase    							=batch_size
             __UpperCAmelCase    							=image_size
             __UpperCAmelCase    							=patch_size
             __UpperCAmelCase    							=num_channels
             __UpperCAmelCase    							=embed_dim
             __UpperCAmelCase    							=depths
             __UpperCAmelCase    							=num_heads
             __UpperCAmelCase    							=window_size
             __UpperCAmelCase    							=mlp_ratio
             __UpperCAmelCase    							=qkv_bias
             __UpperCAmelCase    							=hidden_dropout_prob
             __UpperCAmelCase    							=attention_probs_dropout_prob
             __UpperCAmelCase    							=drop_path_rate
             __UpperCAmelCase    							=hidden_act
             __UpperCAmelCase    							=use_absolute_embeddings
             __UpperCAmelCase    							=patch_norm
             __UpperCAmelCase    							=layer_norm_eps
             __UpperCAmelCase    							=initializer_range
             __UpperCAmelCase    							=is_training
             __UpperCAmelCase    							=scope
             __UpperCAmelCase    							=use_labels
             __UpperCAmelCase    							=type_sequence_label_size
             __UpperCAmelCase    							=encoder_stride
             __UpperCAmelCase    							=out_features
             __UpperCAmelCase    							=out_indices
  
  
  
      def _a       (							self			:    int			)			->       Tuple:
             __UpperCAmelCase    							=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)
  
             __UpperCAmelCase    							=None
             if self.use_labels:
                    __UpperCAmelCase    							=ids_tensor([self.batch_size]   ,    self.type_sequence_label_size			)
  
             __UpperCAmelCase    							=self.get_config()
  
             return config, pixel_values, labels
  
  
  
      def _a       (							self			:    Optional[int]			)			->       Optional[int]:
             return SwinConfig(
                 image_size=self.image_size   ,    patch_size=self.patch_size   ,    num_channels=self.num_channels   ,    embed_dim=self.embed_dim   ,    depths=self.depths   ,    num_heads=self.num_heads   ,    window_size=self.window_size   ,    mlp_ratio=self.mlp_ratio   ,    qkv_bias=self.qkv_bias   ,    hidden_dropout_prob=self.hidden_dropout_prob   ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,    drop_path_rate=self.drop_path_rate   ,    hidden_act=self.hidden_act   ,    use_absolute_embeddings=self.use_absolute_embeddings   ,    path_norm=self.patch_norm   ,    layer_norm_eps=self.layer_norm_eps   ,    initializer_range=self.initializer_range   ,    encoder_stride=self.encoder_stride   ,    out_features=self.out_features   ,    out_indices=self.out_indices   ,    )
  
  
  
      def _a       (							self			:    Any   ,    __SCREAMING_SNAKE_CASE			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    List[str]			)			->       Tuple:
             __UpperCAmelCase    							=SwinModel(config=__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
             __UpperCAmelCase    							=int(config.embed_dim * 2 ** (len(config.depths			) - 1)			)
  
             self.parent.assertEqual(result.last_hidden_state.shape   ,    (self.batch_size, expected_seq_len, expected_dim)			)
  
  
  
      def _a       (							self			:    str   ,    __SCREAMING_SNAKE_CASE			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    int   ,    __SCREAMING_SNAKE_CASE			:    List[Any]			)			->       str:
             __UpperCAmelCase    							=SwinBackbone(config=__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE			)
  
             # verify hidden states
             self.parent.assertEqual(len(result.feature_maps			)   ,    len(config.out_features			)			)
             self.parent.assertListEqual(list(result.feature_maps[0].shape			)   ,    [self.batch_size, model.channels[0], 16, 16]			)
  
             # verify channels
             self.parent.assertEqual(len(model.channels			)   ,    len(config.out_features			)			)
  
             # verify backbone works with out_features=None
             __UpperCAmelCase    							=None
             __UpperCAmelCase    							=SwinBackbone(config=__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE			)
  
             # verify feature maps
             self.parent.assertEqual(len(result.feature_maps			)   ,    1			)
             self.parent.assertListEqual(list(result.feature_maps[0].shape			)   ,    [self.batch_size, model.channels[-1], 4, 4]			)
  
             # verify channels
             self.parent.assertEqual(len(model.channels			)   ,    1			)
  
  
  
      def _a       (							self			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    Any   ,    __SCREAMING_SNAKE_CASE			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    List[Any]			)			->       int:
             __UpperCAmelCase    							=SwinForMaskedImageModeling(config=__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE			)
             self.parent.assertEqual(
                 result.logits.shape   ,    (self.batch_size, self.num_channels, self.image_size, self.image_size)			)
  
             # test greyscale images
             __UpperCAmelCase    							=1
             __UpperCAmelCase    							=SwinForMaskedImageModeling(__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
  
             __UpperCAmelCase    							=floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
             __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE			)
             self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, 1, self.image_size, self.image_size)			)
  
  
  
      def _a       (							self			:    Optional[int]   ,    __SCREAMING_SNAKE_CASE			:    int   ,    __SCREAMING_SNAKE_CASE			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]			)			->       Any:
             __UpperCAmelCase    							=self.type_sequence_label_size
             __UpperCAmelCase    							=SwinForImageClassification(__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE   ,    labels=__SCREAMING_SNAKE_CASE			)
             self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.type_sequence_label_size)			)
  
             # test greyscale images
             __UpperCAmelCase    							=1
             __UpperCAmelCase    							=SwinForImageClassification(__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
  
             __UpperCAmelCase    							=floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
             __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE			)
             self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.type_sequence_label_size)			)
  
  
  
      def _a       (							self			:    str			)			->       Dict:
             __UpperCAmelCase    							=self.prepare_config_and_inputs()
             (
                 (
                 __UpperCAmelCase
             )							,   (
                 __UpperCAmelCase
             )							,   (
                 __UpperCAmelCase
             )							,   
             )    							=config_and_inputs
             __UpperCAmelCase    							={"""pixel_values""": pixel_values}
             return config, inputs_dict
  
  
  
  
  @require_torch
  class 							_A (    UpperCamelCase				,				UpperCamelCase				,				unittest.TestCase							):
      """simple docstring"""
  
      lowerCamelCase  :       Dict   =   (
          (
              SwinModel,
              SwinBackbone,
              SwinForImageClassification,
              SwinForMaskedImageModeling,
          )
          if is_torch_available()
          else ()
      )
      lowerCamelCase  :       Any   =   (
          {'feature-extraction': SwinModel, 'image-classification': SwinForImageClassification}
          if is_torch_available()
          else {}
      )
      lowerCamelCase  :       Tuple   =   True
  
      lowerCamelCase  :       int   =   False
      lowerCamelCase  :       int   =   False
      lowerCamelCase  :       Dict   =   False
  
  
  
      def _a       (							self			:    Optional[Any]			)			->       Optional[int]:
             __UpperCAmelCase    							=SwinModelTester(self			)
             __UpperCAmelCase    							=ConfigTester(self   ,    config_class=__SCREAMING_SNAKE_CASE   ,    embed_dim=37			)
  
  
  
      def _a       (							self			:    List[Any]			)			->       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 _a       (							self			:    List[Any]			)			->       str:
             return
  
  
  
      def _a       (							self			:    Optional[Any]			)			->       Tuple:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE			)
  
  
  
      @unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""			)
      def _a       (							self			:    str			)			->       Union[str, Any]:
             pass
  
  
  
      def _a       (							self			:    Dict			)			->       Any:
             super().test_training_gradient_checkpointing()
  
  
  
      def _a       (							self			:    List[Any]			)			->       str:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Optional[Any]			)			->       str:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Dict			)			->       str:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE			)
  
  
  
      @unittest.skip(reason="""Swin does not use inputs_embeds"""			)
      def _a       (							self			:    int			)			->       Any:
             pass
  
  
  
      @unittest.skip(reason="""Swin Transformer does not use feedforward chunking"""			)
      def _a       (							self			:    Dict			)			->       Tuple:
             pass
  
  
  
      def _a       (							self			:    Tuple			)			->       Dict:
             __UpperCAmelCase							,   __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs_for_common()
  
             for model_class in self.all_model_classes:
                    __UpperCAmelCase    							=model_class(__SCREAMING_SNAKE_CASE			)
                    self.assertIsInstance(model.get_input_embeddings()   ,    (nn.Module)			)
                    __UpperCAmelCase    							=model.get_output_embeddings()
                    self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE   ,    nn.Linear			)			)
  
  
  
      def _a       (							self			:    str			)			->       Union[str, Any]:
             __UpperCAmelCase							,   __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs_for_common()
  
             for model_class in self.all_model_classes:
                    __UpperCAmelCase    							=model_class(__SCREAMING_SNAKE_CASE			)
                    __UpperCAmelCase    							=inspect.signature(model.forward			)
                    # signature.parameters is an OrderedDict => so arg_names order is deterministic
                    __UpperCAmelCase    							=[*signature.parameters.keys()]
  
                    __UpperCAmelCase    							=["""pixel_values"""]
                    self.assertListEqual(arg_names[:1]   ,    __SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Tuple			)			->       int:
             __UpperCAmelCase							,   __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs_for_common()
             __UpperCAmelCase    							=True
  
             for model_class in self.all_model_classes:
                    __UpperCAmelCase    							=True
                    __UpperCAmelCase    							=False
                    __UpperCAmelCase    							=True
                    __UpperCAmelCase    							=model_class(__SCREAMING_SNAKE_CASE			)
                    model.to(__SCREAMING_SNAKE_CASE			)
                    model.eval()
                    with torch.no_grad():
                           __UpperCAmelCase    							=model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)			)
                    __UpperCAmelCase    							=outputs.attentions
                    __UpperCAmelCase    							=len(self.model_tester.depths			)
                    self.assertEqual(len(__SCREAMING_SNAKE_CASE			)   ,    __SCREAMING_SNAKE_CASE			)
  
                    # check that output_attentions also work using config
                    del inputs_dict["output_attentions"]
                    __UpperCAmelCase    							=True
                    __UpperCAmelCase    							=config.window_size**2
                    __UpperCAmelCase    							=model_class(__SCREAMING_SNAKE_CASE			)
                    model.to(__SCREAMING_SNAKE_CASE			)
                    model.eval()
                    with torch.no_grad():
                           __UpperCAmelCase    							=model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)			)
                    __UpperCAmelCase    							=outputs.attentions
                    self.assertEqual(len(__SCREAMING_SNAKE_CASE			)   ,    __SCREAMING_SNAKE_CASE			)
  
                    self.assertListEqual(
                        list(attentions[0].shape[-3:]			)   ,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]   ,    )
                    __UpperCAmelCase    							=len(__SCREAMING_SNAKE_CASE			)
  
                    # Check attention is always last and order is fine
                    __UpperCAmelCase    							=True
                    __UpperCAmelCase    							=True
                    __UpperCAmelCase    							=model_class(__SCREAMING_SNAKE_CASE			)
                    model.to(__SCREAMING_SNAKE_CASE			)
                    model.eval()
                    with torch.no_grad():
                           __UpperCAmelCase    							=model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)			)
  
                    # also another +1 for reshaped_hidden_states
                    __UpperCAmelCase    							=1 if model_class.__name__ == """SwinBackbone""" else 2
                    self.assertEqual(out_len + added_hidden_states   ,    len(__SCREAMING_SNAKE_CASE			)			)
  
                    __UpperCAmelCase    							=outputs.attentions
  
                    self.assertEqual(len(__SCREAMING_SNAKE_CASE			)   ,    __SCREAMING_SNAKE_CASE			)
  
                    self.assertListEqual(
                        list(self_attentions[0].shape[-3:]			)   ,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]   ,    )
  
  
  
      def _a       (							self			:    Optional[Any]   ,    __SCREAMING_SNAKE_CASE			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    str   ,    __SCREAMING_SNAKE_CASE			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    List[str]			)			->       int:
             __UpperCAmelCase    							=model_class(__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
  
             with torch.no_grad():
                    __UpperCAmelCase    							=model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)			)
  
             __UpperCAmelCase    							=outputs.hidden_states
  
             __UpperCAmelCase    							=getattr(
                 self.model_tester   ,    """expected_num_hidden_layers"""   ,    len(self.model_tester.depths			) + 1			)
             self.assertEqual(len(__SCREAMING_SNAKE_CASE			)   ,    __SCREAMING_SNAKE_CASE			)
  
             # Swin has a different seq_length
             __UpperCAmelCase    							=(
                 config.patch_size
                 if isinstance(config.patch_size   ,    collections.abc.Iterable			)
                 else (config.patch_size, config.patch_size)
             )
  
             __UpperCAmelCase    							=(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
  
             self.assertListEqual(
                 list(hidden_states[0].shape[-2:]			)   ,    [num_patches, self.model_tester.embed_dim]   ,    )
  
             if not model_class.__name__ == "SwinBackbone":
                    __UpperCAmelCase    							=outputs.reshaped_hidden_states
                    self.assertEqual(len(__SCREAMING_SNAKE_CASE			)   ,    __SCREAMING_SNAKE_CASE			)
  
                    __UpperCAmelCase							,   __UpperCAmelCase							,   __UpperCAmelCase							,   __UpperCAmelCase    							=reshaped_hidden_states[0].shape
                    __UpperCAmelCase    							=(
                        reshaped_hidden_states[0].view(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    height * width			).permute(0   ,    2   ,    1			)
                    )
                    self.assertListEqual(
                        list(reshaped_hidden_states.shape[-2:]			)   ,    [num_patches, self.model_tester.embed_dim]   ,    )
  
  
  
      def _a       (							self			:    int			)			->       List[Any]:
             __UpperCAmelCase							,   __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs_for_common()
  
             __UpperCAmelCase    							=(
                 self.model_tester.image_size
                 if isinstance(self.model_tester.image_size   ,    collections.abc.Iterable			)
                 else (self.model_tester.image_size, self.model_tester.image_size)
             )
  
             for model_class in self.all_model_classes:
                    __UpperCAmelCase    							=True
                    self.check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)
  
                    # check that output_hidden_states also work using config
                    del inputs_dict["output_hidden_states"]
                    __UpperCAmelCase    							=True
  
                    self.check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    List[str]			)			->       Union[str, Any]:
             __UpperCAmelCase							,   __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs_for_common()
             __UpperCAmelCase    							=3
  
             __UpperCAmelCase    							=(
                 self.model_tester.image_size
                 if isinstance(self.model_tester.image_size   ,    collections.abc.Iterable			)
                 else (self.model_tester.image_size, self.model_tester.image_size)
             )
             __UpperCAmelCase    							=(
                 config.patch_size
                 if isinstance(config.patch_size   ,    collections.abc.Iterable			)
                 else (config.patch_size, config.patch_size)
             )
  
             __UpperCAmelCase    							=image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
             __UpperCAmelCase    							=image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])
  
             for model_class in self.all_model_classes:
                    __UpperCAmelCase    							=True
                    self.check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    (padded_height, padded_width)			)
  
                    # check that output_hidden_states also work using config
                    del inputs_dict["output_hidden_states"]
                    __UpperCAmelCase    							=True
                    self.check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    (padded_height, padded_width)			)
  
  
  
      @slow
      def _a       (							self			:    str			)			->       Optional[int]:
             for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    __UpperCAmelCase    							=SwinModel.from_pretrained(__SCREAMING_SNAKE_CASE			)
                    self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Optional[int]			)			->       List[str]:
             __UpperCAmelCase							,   __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs_for_common()
  
             __UpperCAmelCase    							=_config_zero_init(__SCREAMING_SNAKE_CASE			)
             for model_class in self.all_model_classes:
                    __UpperCAmelCase    							=model_class(config=__SCREAMING_SNAKE_CASE			)
                    for name, param in model.named_parameters():
                           if "embeddings" not in name and param.requires_grad:
                                  self.assertIn(
                                      ((param.data.mean() * 1e9).round() / 1e9).item()   ,    [0.0, 1.0]   ,    msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''   ,    )
  
  
  
  
  @require_vision
  @require_torch
  class 							_A (    unittest.TestCase							):
      """simple docstring"""
  
      @cached_property
      def _a       (							self			:    str			)			->       Dict:
             return (
                 AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""			)
                 if is_vision_available()
                 else None
             )
  
  
  
      @slow
      def _a       (							self			:    str			)			->       Any:
             __UpperCAmelCase    							=SwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""			).to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=self.default_image_processor
  
             __UpperCAmelCase    							=Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
             __UpperCAmelCase    							=image_processor(images=__SCREAMING_SNAKE_CASE   ,    return_tensors="""pt"""			).to(__SCREAMING_SNAKE_CASE			)
  
             # forward pass
             with torch.no_grad():
                    __UpperCAmelCase    							=model(**__SCREAMING_SNAKE_CASE			)
  
             # verify the logits
             __UpperCAmelCase    							=torch.Size((1, 1000)			)
             self.assertEqual(outputs.logits.shape   ,    __SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.tensor([-0.0_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 							_A (    unittest.TestCase				,				UpperCamelCase							):
      """simple docstring"""
  
      lowerCamelCase  :       List[str]   =   (SwinBackbone,) if is_torch_available() else ()
      lowerCamelCase  :       Union[str, Any]   =   SwinConfig
  
  
  
      def _a       (							self			:    List[str]			)			->       Tuple:
             __UpperCAmelCase    							=SwinModelTester(self			)
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from collections import defaultdict
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	int = 5		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase    							=defaultdict(A_		)
         __UpperCAmelCase    							=0
  
         while True:
                __UpperCAmelCase    							=get_digits(A_		)
                freqs[digits].append(A_		)
  
                if len(freqs[digits]		) == max_base:
                       __UpperCAmelCase    							=freqs[digits][0] ** 3
                       return base
  
                num += 1
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	int		)  ->							str:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         return "".join(sorted(str(num**3		)		)		)
  
  
  if __name__ == "__main__":
     print(F"""{solution() = }""")
  
  
  
  
  