




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 			__snake_case   :
 def __init__(  self		,   snake_case__		,   snake_case__=13		,   snake_case__=32		,   snake_case__=2		,   snake_case__=3		,   snake_case__=16		,   snake_case__=[1, 2, 1]		,   snake_case__=[2, 2, 4]		,   snake_case__=2		,   snake_case__=2.0		,   snake_case__=True		,   snake_case__=0.0		,   snake_case__=0.0		,   snake_case__=0.1		,   snake_case__="gelu"		,   snake_case__=False		,   snake_case__=True		,   snake_case__=0.02		,   snake_case__=1e-5		,   snake_case__=True		,   snake_case__=None		,   snake_case__=True		,   snake_case__=10		,   snake_case__=8		,   snake_case__=["stage1", "stage2"]		,   snake_case__=[1, 2]		,   )	->							Union[str, Any]:
       '''simple docstring'''





       UpperCAmelCase    : Tuple      =parent
       UpperCAmelCase    : List[Any]      =batch_size
       UpperCAmelCase    : List[Any]      =image_size
       UpperCAmelCase    : List[Any]      =patch_size
       UpperCAmelCase    : Dict      =num_channels
       UpperCAmelCase    : List[Any]      =embed_dim
       UpperCAmelCase    : Dict      =depths
       UpperCAmelCase    : Any      =num_heads
       UpperCAmelCase    : Optional[Any]      =window_size
       UpperCAmelCase    : int      =mlp_ratio
       UpperCAmelCase    : List[str]      =qkv_bias
       UpperCAmelCase    : List[str]      =hidden_dropout_prob
       UpperCAmelCase    : Dict      =attention_probs_dropout_prob
       UpperCAmelCase    : Tuple      =drop_path_rate
       UpperCAmelCase    : Union[str, Any]      =hidden_act
       UpperCAmelCase    : str      =use_absolute_embeddings
       UpperCAmelCase    : Any      =patch_norm
       UpperCAmelCase    : Optional[int]      =layer_norm_eps
       UpperCAmelCase    : Tuple      =initializer_range
       UpperCAmelCase    : Union[str, Any]      =is_training
       UpperCAmelCase    : Optional[Any]      =scope
       UpperCAmelCase    : str      =use_labels
       UpperCAmelCase    : int      =type_sequence_label_size
       UpperCAmelCase    : Union[str, Any]      =encoder_stride
       UpperCAmelCase    : Any      =out_features
       UpperCAmelCase    : List[str]      =out_indices
 def 	UpperCAmelCase__       (  self						)	->							Tuple:
       '''simple docstring'''





       UpperCAmelCase    : Tuple      =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

       UpperCAmelCase    : Tuple      =None
       if self.use_labels:
             UpperCAmelCase    : List[str]      =ids_tensor([self.batch_size]		,   self.type_sequence_label_size						)

       UpperCAmelCase    : List[Any]      =self.get_config()

       return config, pixel_values, labels
 def 	UpperCAmelCase__       (  self						)	->							Union[str, Any]:
       '''simple docstring'''





       return SwinConfig(
           image_size=self.image_size		,   patch_size=self.patch_size		,   num_channels=self.num_channels		,   embed_dim=self.embed_dim		,   depths=self.depths		,   num_heads=self.num_heads		,   window_size=self.window_size		,   mlp_ratio=self.mlp_ratio		,   qkv_bias=self.qkv_bias		,   hidden_dropout_prob=self.hidden_dropout_prob		,   attention_probs_dropout_prob=self.attention_probs_dropout_prob		,   drop_path_rate=self.drop_path_rate		,   hidden_act=self.hidden_act		,   use_absolute_embeddings=self.use_absolute_embeddings		,   path_norm=self.patch_norm		,   layer_norm_eps=self.layer_norm_eps		,   initializer_range=self.initializer_range		,   encoder_stride=self.encoder_stride		,   out_features=self.out_features		,   out_indices=self.out_indices		,   )
 def 	UpperCAmelCase__       (  self		,   snake_case__		,   snake_case__		,   snake_case__						)	->							Optional[int]:
       '''simple docstring'''





       UpperCAmelCase    : Any      =SwinModel(config=__a						)
       model.to(__a						)
       model.eval()
       UpperCAmelCase    : Any      =model(__a						)

       UpperCAmelCase    : Optional[Any]      =((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
       UpperCAmelCase    : Dict      =int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

       self.parent.assertEqual(result.last_hidden_state.shape		,   (self.batch_size, expected_seq_len, expected_dim)						)
 def 	UpperCAmelCase__       (  self		,   snake_case__		,   snake_case__		,   snake_case__						)	->							Union[str, Any]:
       '''simple docstring'''





       UpperCAmelCase    : Dict      =SwinBackbone(config=__a						)
       model.to(__a						)
       model.eval()
       UpperCAmelCase    : Optional[Any]      =model(__a						)

       # 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    : Tuple      =None
       UpperCAmelCase    : List[Any]      =SwinBackbone(config=__a						)
       model.to(__a						)
       model.eval()
       UpperCAmelCase    : List[Any]      =model(__a						)

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps						)		,   1						)
       self.parent.assertListEqual(list(result.feature_maps[0].shape						)		,   [self.batch_size, model.channels[-1], 4, 4]						)

       # verify channels
       self.parent.assertEqual(len(model.channels						)		,   1						)
 def 	UpperCAmelCase__       (  self		,   snake_case__		,   snake_case__		,   snake_case__						)	->							int:
       '''simple docstring'''





       UpperCAmelCase    : int      =SwinForMaskedImageModeling(config=__a						)
       model.to(__a						)
       model.eval()
       UpperCAmelCase    : Dict      =model(__a						)
       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(__a						)
       model.to(__a						)
       model.eval()

       UpperCAmelCase    : str      =floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
       UpperCAmelCase    : List[str]      =model(__a						)
       self.parent.assertEqual(result.logits.shape		,   (self.batch_size, 1, self.image_size, self.image_size)						)
 def 	UpperCAmelCase__       (  self		,   snake_case__		,   snake_case__		,   snake_case__						)	->							Any:
       '''simple docstring'''





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

       # test greyscale images
       UpperCAmelCase    : List[Any]      =1
       UpperCAmelCase    : Optional[Any]      =SwinForImageClassification(__a						)
       model.to(__a						)
       model.eval()

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






 def 	UpperCAmelCase__       (  self						)	->							Any:
       '''simple docstring'''





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







@require_torch
class 			__snake_case   (     lowerCAmelCase_					,   lowerCAmelCase_					,   unittest.TestCase   ):
 __lowerCamelCase    :   List[str]     =      (
     (
         SwinModel,
         SwinBackbone,
         SwinForImageClassification,
         SwinForMaskedImageModeling,
     )
     if is_torch_available()
     else ()
 )
 __lowerCamelCase    :   Optional[Any]     =      (
     {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
     if is_torch_available()
     else {}
 )
 __lowerCamelCase    :   Optional[int]     =      True

 __lowerCamelCase    :   Dict     =      False
 __lowerCamelCase    :   Optional[Any]     =      False
 __lowerCamelCase    :   str     =      False
 def 	UpperCAmelCase__       (  self						)	->							Optional[Any]:
       '''simple docstring'''





       UpperCAmelCase    : List[str]      =SwinModelTester(self						)
       UpperCAmelCase    : Dict      =ConfigTester(self		,   config_class=__a		,   embed_dim=37						)
 def 	UpperCAmelCase__       (  self						)	->							Optional[Any]:
       '''simple docstring'''





       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()
 def 	UpperCAmelCase__       (  self						)	->							List[Any]:
       '''simple docstring'''





       return
 def 	UpperCAmelCase__       (  self						)	->							Any:
       '''simple docstring'''





       UpperCAmelCase    : Dict      =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__a						)
 @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''						)
 def 	UpperCAmelCase__       (  self						)	->							Tuple:
       '''simple docstring'''





       pass
 def 	UpperCAmelCase__       (  self						)	->							Optional[int]:
       '''simple docstring'''





       super().test_training_gradient_checkpointing()
 def 	UpperCAmelCase__       (  self						)	->							Any:
       '''simple docstring'''





       UpperCAmelCase    : int      =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*__a						)
 def 	UpperCAmelCase__       (  self						)	->							int:
       '''simple docstring'''





       UpperCAmelCase    : str      =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*__a						)
 def 	UpperCAmelCase__       (  self						)	->							Union[str, Any]:
       '''simple docstring'''





       UpperCAmelCase    : Optional[Any]      =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*__a						)
 @unittest.skip(reason='''Swin does not use inputs_embeds'''						)
 def 	UpperCAmelCase__       (  self						)	->							Optional[int]:
       '''simple docstring'''





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





       pass
 def 	UpperCAmelCase__       (  self						)	->							Union[str, Any]:
       '''simple docstring'''





       UpperCAmelCase    : Optional[int]      =self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             UpperCAmelCase    : Optional[int]      =model_class(__a						)
             self.assertIsInstance(model.get_input_embeddings()		,   (nn.Module)						)
             UpperCAmelCase    : Dict      =model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(__a		,   nn.Linear						)						)
 def 	UpperCAmelCase__       (  self						)	->							str:
       '''simple docstring'''





       UpperCAmelCase    : Optional[int]      =self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             UpperCAmelCase    : Optional[Any]      =model_class(__a						)
             UpperCAmelCase    : List[str]      =inspect.signature(model.forward						)
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             UpperCAmelCase    : Tuple      =[*signature.parameters.keys()]

             UpperCAmelCase    : List[Any]      =['pixel_values']
             self.assertListEqual(arg_names[:1]		,   __a						)
 def 	UpperCAmelCase__       (  self						)	->							List[Any]:
       '''simple docstring'''





       UpperCAmelCase    : Tuple      =self.model_tester.prepare_config_and_inputs_for_common()
       UpperCAmelCase    : Dict      =True

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

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

             self.assertListEqual(
                 list(attentions[0].shape[-3:]						)		,   [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,   )
             UpperCAmelCase    : List[str]      =len(__a						)

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

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

             UpperCAmelCase    : Tuple      =outputs.attentions

             self.assertEqual(len(__a						)		,   __a						)

             self.assertListEqual(
                 list(self_attentions[0].shape[-3:]						)		,   [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,   )
 def 	UpperCAmelCase__       (  self		,   snake_case__		,   snake_case__		,   snake_case__		,   snake_case__						)	->							Union[str, Any]:
       '''simple docstring'''





       UpperCAmelCase    : str      =model_class(__a						)
       model.to(__a						)
       model.eval()

       with torch.no_grad():
             UpperCAmelCase    : int      =model(**self._prepare_for_class(__a		,   __a						)						)

       UpperCAmelCase    : Any      =outputs.hidden_states

       UpperCAmelCase    : Any      =getattr(
           self.model_tester		,   '''expected_num_hidden_layers'''		,   len(self.model_tester.depths						) + 1						)
       self.assertEqual(len(__a						)		,   __a						)

       # Swin has a different seq_length
       UpperCAmelCase    : List[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    : List[str]      =outputs.reshaped_hidden_states
             self.assertEqual(len(__a						)		,   __a						)

             UpperCAmelCase    : List[str]      =reshaped_hidden_states[0].shape
             UpperCAmelCase    : int      =(
                 reshaped_hidden_states[0].view(__a		,   __a		,   height * width						).permute(0		,   2		,   1						)
             )
             self.assertListEqual(
                 list(reshaped_hidden_states.shape[-2:]						)		,   [num_patches, self.model_tester.embed_dim]		,   )
 def 	UpperCAmelCase__       (  self						)	->							List[Any]:
       '''simple docstring'''





       UpperCAmelCase    : Optional[Any]      =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    : Union[str, Any]      =True
             self.check_hidden_states_output(__a		,   __a		,   __a		,   __a						)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             UpperCAmelCase    : int      =True

             self.check_hidden_states_output(__a		,   __a		,   __a		,   __a						)
 def 	UpperCAmelCase__       (  self						)	->							Any:
       '''simple docstring'''





       UpperCAmelCase    : Optional[int]      =self.model_tester.prepare_config_and_inputs_for_common()
       UpperCAmelCase    : Dict      =3

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

       UpperCAmelCase    : Dict      =image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       UpperCAmelCase    : List[str]      =image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

       for model_class in self.all_model_classes:
             UpperCAmelCase    : str      =True
             self.check_hidden_states_output(__a		,   __a		,   __a		,   (padded_height, padded_width)						)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             UpperCAmelCase    : str      =True
             self.check_hidden_states_output(__a		,   __a		,   __a		,   (padded_height, padded_width)						)
 @slow
 def 	UpperCAmelCase__       (  self						)	->							Any:
       '''simple docstring'''





       for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCAmelCase    : List[str]      =SwinModel.from_pretrained(__a						)
             self.assertIsNotNone(__a						)






 def 	UpperCAmelCase__       (  self						)	->							int:
       '''simple docstring'''





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

       UpperCAmelCase    : Any      =_config_zero_init(__a						)
       for model_class in self.all_model_classes:
             UpperCAmelCase    : Optional[Any]      =model_class(config=__a						)
             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 			__snake_case   (     unittest.TestCase   ):
 @cached_property
 def 	UpperCAmelCase__       (  self						)	->							List[str]:
       '''simple docstring'''





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






 @slow
 def 	UpperCAmelCase__       (  self						)	->							Optional[Any]:
       '''simple docstring'''





       UpperCAmelCase    : Union[str, Any]      =SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''						).to(__a						)
       UpperCAmelCase    : List[str]      =self.default_image_processor

       UpperCAmelCase    : Optional[Any]      =Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
       UpperCAmelCase    : List[str]      =image_processor(images=__a		,   return_tensors='''pt'''						).to(__a						)

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

       # verify the logits
       UpperCAmelCase    : Union[str, Any]      =torch.Size((1, 1000)						)
       self.assertEqual(outputs.logits.shape		,   __a						)
       UpperCAmelCase    : Any      =torch.tensor([-0.0948, -0.6454, -0.0921]						).to(__a						)
       self.assertTrue(torch.allclose(outputs.logits[0, :3]		,   __a		,   atol=1e-4						)						)







@require_torch
class 			__snake_case   (     unittest.TestCase					,   lowerCAmelCase_   ):
 __lowerCamelCase    :   Optional[int]     =      (SwinBackbone,) if is_torch_available() else ()
 __lowerCamelCase    :   str     =      SwinConfig
 def 	UpperCAmelCase__       (  self						)	->							Dict:
       '''simple docstring'''





       UpperCAmelCase    : Optional[int]      =SwinModelTester(self						)

from collections import defaultdict





def   lowerCAmelCase_ (				__lowerCAmelCase = 5						)->  int:






      '''simple docstring'''





      UpperCAmelCase    : List[str]      =defaultdict(__lowerCAmelCase						)
      UpperCAmelCase    : Tuple      =0

      while True:
            UpperCAmelCase    : Any      =get_digits(__lowerCAmelCase						)
            freqs[digits].append(__lowerCAmelCase						)

            if len(freqs[digits]						) == max_base:
                  UpperCAmelCase    : Optional[int]      =freqs[digits][0] ** 3
                  return base

            num += 1





def   lowerCAmelCase_ (				__lowerCAmelCase						)->  str:






      '''simple docstring'''





      return "".join(sorted(str(num**3						)						)						)


if __name__ == "__main__":
     print(f'{solution() = }')
