





'''simple docstring'''


import collections
import inspect
import unittest

from transformers import SwinvaConfig
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_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 SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
    from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor






class     lowerCAmelCase__ :

       '''simple docstring'''

       def __init__( self					:				Optional[int]       ,     a__					:				str       ,     a__					:				Union[str, Any]=13       ,     a__					:				Any=32       ,     a__					:				int=2       ,     a__					:				str=3       ,     a__					:				List[Any]=16       ,     a__					:				Tuple=[1, 2, 1]       ,     a__					:				Union[str, Any]=[2, 2, 4]       ,     a__					:				Optional[int]=2       ,     a__					:				str=2.0       ,     a__					:				int=True       ,     a__					:				Any=0.0       ,     a__					:				Optional[Any]=0.0       ,     a__					:				int=0.1       ,     a__					:				List[str]="gelu"       ,     a__					:				Optional[Any]=False       ,     a__					:				Tuple=True       ,     a__					:				int=0.02       ,     a__					:				Tuple=1e-5       ,     a__					:				str=True       ,     a__					:				Optional[Any]=None       ,     a__					:				List[str]=True       ,     a__					:				Tuple=10       ,     a__					:				int=8       ,     ):
              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

       def 			__snake_case      ( self					:				Any						):
              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 			__snake_case      ( self					:				str						):
              return SwinvaConfig(
                  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       ,     )

       def 			__snake_case      ( self					:				str       ,     a__					:				str       ,     a__					:				List[str]       ,     a__					:				Dict						):
              UpperCAmelCase  =						SwinvaModel(config=a__						)
              model.to(a__						)
              model.eval()
              UpperCAmelCase  =						model(a__						)

              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 			__snake_case      ( self					:				Union[str, Any]       ,     a__					:				Optional[int]       ,     a__					:				Union[str, Any]       ,     a__					:				int						):
              UpperCAmelCase  =						SwinvaForMaskedImageModeling(config=a__						)
              model.to(a__						)
              model.eval()
              UpperCAmelCase  =						model(a__						)
              self.parent.assertEqual(
                  result.logits.shape       ,     (self.batch_size, self.num_channels, self.image_size, self.image_size)						)

              # test greyscale images
              UpperCAmelCase  =						1
              UpperCAmelCase  =						SwinvaForMaskedImageModeling(a__						)
              model.to(a__						)
              model.eval()

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

       def 			__snake_case      ( self					:				Tuple       ,     a__					:				Dict       ,     a__					:				Tuple       ,     a__					:				int						):
              UpperCAmelCase  =						self.type_sequence_label_size
              UpperCAmelCase  =						SwinvaForImageClassification(a__						)
              model.to(a__						)
              model.eval()
              UpperCAmelCase  =						model(a__       ,     labels=a__						)
              self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size)						)



       def 			__snake_case      ( self					:				Optional[int]						):
              UpperCAmelCase  =						self.prepare_config_and_inputs()
              UpperCAmelCase,					UpperCAmelCase,					UpperCAmelCase  =						config_and_inputs
              UpperCAmelCase  =						{'''pixel_values''': pixel_values}
              return config, inputs_dict






@require_torch
class     lowerCAmelCase__ (				UpperCAmelCase_      , UpperCAmelCase_      , unittest.TestCase    ):

       '''simple docstring'''
       _lowerCamelCase								=(
           (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
       )
       _lowerCamelCase								=(
           {"feature-extraction": SwinvaModel, "image-classification": SwinvaForImageClassification}
           if is_torch_available()
           else {}
       )

       _lowerCamelCase								=False
       _lowerCamelCase								=False
       _lowerCamelCase								=False
       _lowerCamelCase								=False

       def 			__snake_case      ( self					:				Dict						):
              UpperCAmelCase  =						SwinvaModelTester(self						)
              UpperCAmelCase  =						ConfigTester(self       ,     config_class=a__       ,     embed_dim=37						)

       def 			__snake_case      ( self					:				Union[str, Any]						):
              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 			__snake_case      ( self					:				Tuple						):
              UpperCAmelCase  =						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 			__snake_case      ( self					:				Dict						):
              pass

       @unittest.skip(reason='''Swinv2 does not use inputs_embeds'''						)
       def 			__snake_case      ( self					:				int						):
              pass

       def 			__snake_case      ( self					:				Optional[Any]						):
              UpperCAmelCase,					UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs_for_common()

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

       def 			__snake_case      ( self					:				Any						):
              UpperCAmelCase,					UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     UpperCAmelCase  =						model_class(a__						)
                     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]       ,     a__						)

       def 			__snake_case      ( self					:				Optional[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(a__						)
                     model.to(a__						)
                     model.eval()
                     with torch.no_grad():
                            UpperCAmelCase  =						model(**self._prepare_for_class(a__       ,     a__						)						)
                     UpperCAmelCase  =						outputs.attentions
                     UpperCAmelCase  =						len(self.model_tester.depths						)
                     self.assertEqual(len(a__						)       ,     a__						)

                     # check that output_attentions also work using config
                     del inputs_dict["output_attentions"]
                     UpperCAmelCase  =						True
                     UpperCAmelCase  =						config.window_size**2
                     UpperCAmelCase  =						model_class(a__						)
                     model.to(a__						)
                     model.eval()
                     with torch.no_grad():
                            UpperCAmelCase  =						model(**self._prepare_for_class(a__       ,     a__						)						)
                     UpperCAmelCase  =						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  =						len(a__						)

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

                     if hasattr(self.model_tester       ,     '''num_hidden_states_types'''						):
                            UpperCAmelCase  =						self.model_tester.num_hidden_states_types
                     else:
                            # also another +1 for reshaped_hidden_states
                            UpperCAmelCase  =						2
                     self.assertEqual(out_len + added_hidden_states       ,     len(a__						)						)

                     UpperCAmelCase  =						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 			__snake_case      ( self					:				Tuple       ,     a__					:				Optional[Any]       ,     a__					:				List[str]       ,     a__					:				Any       ,     a__					:				Tuple						):
              UpperCAmelCase  =						model_class(a__						)
              model.to(a__						)
              model.eval()

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

              UpperCAmelCase  =						outputs.hidden_states

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

              # Swinv2 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]       ,     )

              UpperCAmelCase  =						outputs.reshaped_hidden_states
              self.assertEqual(len(a__						)       ,     a__						)

              UpperCAmelCase,					UpperCAmelCase,					UpperCAmelCase,					UpperCAmelCase  =						reshaped_hidden_states[0].shape
              UpperCAmelCase  =						(
                  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 			__snake_case      ( self					:				Union[str, 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(a__       ,     a__       ,     a__       ,     a__						)

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

                     self.check_hidden_states_output(a__       ,     a__       ,     a__       ,     a__						)

       def 			__snake_case      ( self					:				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(a__       ,     a__       ,     a__       ,     (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(a__       ,     a__       ,     a__       ,     (padded_height, padded_width)						)

       def 			__snake_case      ( self					:				Union[str, Any]						):
              UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_masked_image_modeling(*a__						)

       def 			__snake_case      ( self					:				Any						):
              UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_image_classification(*a__						)

       @slow
       def 			__snake_case      ( self					:				Optional[Any]						):
              for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     UpperCAmelCase  =						SwinvaModel.from_pretrained(a__						)
                     self.assertIsNotNone(a__						)



       def 			__snake_case      ( self					:				str						):
              UpperCAmelCase,					UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs_for_common()

              UpperCAmelCase  =						_config_zero_init(a__						)
              for model_class in self.all_model_classes:
                     UpperCAmelCase  =						model_class(config=a__						)
                     for name, param in model.named_parameters():
                            if "embeddings" not in name and "logit_scale" 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     lowerCAmelCase__ (				unittest.TestCase    ):

       '''simple docstring'''

       @cached_property
       def 			__snake_case      ( self					:				Union[str, Any]						):
              return (
                  AutoImageProcessor.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''						)
                  if is_vision_available()
                  else None
              )



       @slow
       def 			__snake_case      ( self					:				List[str]						):
              UpperCAmelCase  =						SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''						).to(
                  a__						)
              UpperCAmelCase  =						self.default_image_processor

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

              # forward pass
              with torch.no_grad():
                     UpperCAmelCase  =						model(**a__						)

              # verify the logits
              UpperCAmelCase  =						torch.Size((1, 1000)						)
              self.assertEqual(outputs.logits.shape       ,     a__						)
              UpperCAmelCase  =						torch.tensor([-0.3_947, -0.4_306, 0.0_026]						).to(a__						)
              self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,     a__       ,     atol=1e-4						)						)







'''simple docstring'''





from __future__ import annotations




def lowerCAmelCase    (__A):



     """simple docstring"""



     return len(set(__A)) == len(__A)


if __name__ == "__main__":
  import doctest

  doctest.testmod()



