





'''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   _lowercase						:


   def __init__( self    ,   _UpperCAmelCase    ,   _UpperCAmelCase=13    ,   _UpperCAmelCase=32    ,   _UpperCAmelCase=2    ,   _UpperCAmelCase=3    ,   _UpperCAmelCase=16    ,   _UpperCAmelCase=[1, 2, 1]    ,   _UpperCAmelCase=[2, 2, 4]    ,   _UpperCAmelCase=2    ,   _UpperCAmelCase=2.0    ,   _UpperCAmelCase=True    ,   _UpperCAmelCase=0.0    ,   _UpperCAmelCase=0.0    ,   _UpperCAmelCase=0.1    ,   _UpperCAmelCase="gelu"    ,   _UpperCAmelCase=False    ,   _UpperCAmelCase=True    ,   _UpperCAmelCase=0.02    ,   _UpperCAmelCase=1E-5    ,   _UpperCAmelCase=True    ,   _UpperCAmelCase=None    ,   _UpperCAmelCase=True    ,   _UpperCAmelCase=10    ,   _UpperCAmelCase=8    ,   ):
       A       :       List[Any]							=						parent
       A       :       List[Any]							=						batch_size
       A       :       Optional[int]							=						image_size
       A       :       List[Any]							=						patch_size
       A       :       Any							=						num_channels
       A       :       Tuple							=						embed_dim
       A       :       Optional[Any]							=						depths
       A       :       Any							=						num_heads
       A       :       List[Any]							=						window_size
       A       :       Union[str, Any]							=						mlp_ratio
       A       :       List[str]							=						qkv_bias
       A       :       Optional[Any]							=						hidden_dropout_prob
       A       :       Union[str, Any]							=						attention_probs_dropout_prob
       A       :       Any							=						drop_path_rate
       A       :       List[str]							=						hidden_act
       A       :       str							=						use_absolute_embeddings
       A       :       List[Any]							=						patch_norm
       A       :       Optional[int]							=						layer_norm_eps
       A       :       List[Any]							=						initializer_range
       A       :       List[Any]							=						is_training
       A       :       int							=						scope
       A       :       Union[str, Any]							=						use_labels
       A       :       Union[str, Any]							=						type_sequence_label_size
       A       :       str							=						encoder_stride


   def 					snake_case				( self					):
       A       :       Optional[int]							=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

       A       :       int							=						self.get_config()

       return config, pixel_values, labels


   def 					snake_case				( self					):
       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    ,   _UpperCAmelCase    ,   _UpperCAmelCase    ,   _UpperCAmelCase					):
       A       :       Optional[int]							=						SwinvaModel(config=lowercase__					)
       model.to(lowercase__					)
       model.eval()
       A       :       Tuple							=						model(lowercase__					)

       A       :       List[str]							=						((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
       A       :       Optional[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 					snake_case				( self    ,   _UpperCAmelCase    ,   _UpperCAmelCase    ,   _UpperCAmelCase					):
       A       :       Optional[Any]							=						SwinvaForMaskedImageModeling(config=lowercase__					)
       model.to(lowercase__					)
       model.eval()
       A       :       int							=						model(lowercase__					)
       self.parent.assertEqual(
           result.logits.shape    ,   (self.batch_size, self.num_channels, self.image_size, self.image_size)					)

       # test greyscale images
       A       :       Union[str, Any]							=						1
       A       :       Any							=						SwinvaForMaskedImageModeling(lowercase__					)
       model.to(lowercase__					)
       model.eval()

       A       :       Tuple							=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
       A       :       str							=						model(lowercase__					)
       self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, 1, self.image_size, self.image_size)					)


   def 					snake_case				( self    ,   _UpperCAmelCase    ,   _UpperCAmelCase    ,   _UpperCAmelCase					):
       A       :       Optional[Any]							=						self.type_sequence_label_size
       A       :       int							=						SwinvaForImageClassification(lowercase__					)
       model.to(lowercase__					)
       model.eval()
       A       :       Optional[int]							=						model(lowercase__    ,   labels=lowercase__					)
       self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.type_sequence_label_size)					)


   def 					snake_case				( self					):
       A       :       Dict							=						self.prepare_config_and_inputs()
       A       :       str							=						config_and_inputs
       A       :       int							=						{"pixel_values": pixel_values}
       return config, inputs_dict







@require_torch
class   _lowercase						(							_UpperCAmelCase		,					_UpperCAmelCase		,					unittest.TestCase				):
   _UpperCamelCase       		=   (
       (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
   )
   _UpperCamelCase       		=   (
       {"""feature-extraction""": SwinvaModel, """image-classification""": SwinvaForImageClassification}
       if is_torch_available()
       else {}
   )

   _UpperCamelCase       		=   False
   _UpperCamelCase       		=   False
   _UpperCamelCase       		=   False
   _UpperCamelCase       		=   False


   def 					snake_case				( self					):
       A       :       Optional[Any]							=						SwinvaModelTester(self					)
       A       :       int							=						ConfigTester(self    ,   config_class=lowercase__    ,   embed_dim=37					)


   def 					snake_case				( self					):
       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					):
       A       :       Any							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowercase__					)


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


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


   def 					snake_case				( self					):
       A       :       int							=						self.model_tester.prepare_config_and_inputs_for_common()

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


   def 					snake_case				( self					):
       A       :       Optional[Any]							=						self.model_tester.prepare_config_and_inputs_for_common()

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

           A       :       Optional[Any]							=						["pixel_values"]
           self.assertListEqual(arg_names[:1]    ,   lowercase__					)


   def 					snake_case				( self					):
       A       :       str							=						self.model_tester.prepare_config_and_inputs_for_common()
       A       :       List[str]							=						True

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

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

           self.assertListEqual(
               list(attentions[0].shape[-3:]					)    ,   [self.model_tester.num_heads[0], window_size_squared, window_size_squared]    ,   )
           A       :       Optional[Any]							=						len(lowercase__					)

           # Check attention is always last and order is fine
           A       :       List[Any]							=						True
           A       :       Any							=						True
           A       :       List[str]							=						model_class(lowercase__					)
           model.to(lowercase__					)
           model.eval()
           with torch.no_grad():
               A       :       Tuple							=						model(**self._prepare_for_class(lowercase__    ,   lowercase__					)					)

           if hasattr(self.model_tester    ,   '''num_hidden_states_types'''					):
               A       :       List[Any]							=						self.model_tester.num_hidden_states_types
           else:
               # also another +1 for reshaped_hidden_states
               A       :       Tuple							=						2
           self.assertEqual(out_len + added_hidden_states    ,   len(lowercase__					)					)

           A       :       Tuple							=						outputs.attentions

           self.assertEqual(len(lowercase__					)    ,   lowercase__					)

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


   def 					snake_case				( self    ,   _UpperCAmelCase    ,   _UpperCAmelCase    ,   _UpperCAmelCase    ,   _UpperCAmelCase					):
       A       :       Optional[Any]							=						model_class(lowercase__					)
       model.to(lowercase__					)
       model.eval()

       with torch.no_grad():
           A       :       Union[str, Any]							=						model(**self._prepare_for_class(lowercase__    ,   lowercase__					)					)

       A       :       Any							=						outputs.hidden_states

       A       :       Dict							=						getattr(
           self.model_tester    ,   '''expected_num_hidden_layers'''    ,   len(self.model_tester.depths					) + 1					)
       self.assertEqual(len(lowercase__					)    ,   lowercase__					)

       # Swinv2 has a different seq_length
       A       :       Any							=						(
           config.patch_size
           if isinstance(config.patch_size    ,   collections.abc.Iterable					)
           else (config.patch_size, config.patch_size)
       )

       A       :       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]    ,   )

       A       :       Tuple							=						outputs.reshaped_hidden_states
       self.assertEqual(len(lowercase__					)    ,   lowercase__					)

       A       :       Optional[Any]							=						reshaped_hidden_states[0].shape
       A       :       List[Any]							=						(
           reshaped_hidden_states[0].view(lowercase__    ,   lowercase__    ,   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					):
       A       :       Dict							=						self.model_tester.prepare_config_and_inputs_for_common()

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

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           A       :       Union[str, Any]							=						True

           self.check_hidden_states_output(lowercase__    ,   lowercase__    ,   lowercase__    ,   lowercase__					)


   def 					snake_case				( self					):
       A       :       str							=						self.model_tester.prepare_config_and_inputs_for_common()
       A       :       Tuple							=						3

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

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

       for model_class in self.all_model_classes:
           A       :       Dict							=						True
           self.check_hidden_states_output(lowercase__    ,   lowercase__    ,   lowercase__    ,   (padded_height, padded_width)					)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           A       :       Optional[Any]							=						True
           self.check_hidden_states_output(lowercase__    ,   lowercase__    ,   lowercase__    ,   (padded_height, padded_width)					)


   def 					snake_case				( self					):
       A       :       Optional[int]							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*lowercase__					)


   def 					snake_case				( self					):
       A       :       str							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*lowercase__					)


   @slow
   def 					snake_case				( self					):






       for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           A       :       List[str]							=						SwinvaModel.from_pretrained(lowercase__					)
           self.assertIsNotNone(lowercase__					)


   def 					snake_case				( self					):
       A       :       List[str]							=						self.model_tester.prepare_config_and_inputs_for_common()

       A       :       Optional[Any]							=						_config_zero_init(lowercase__					)
       for model_class in self.all_model_classes:
           A       :       List[Any]							=						model_class(config=lowercase__					)
           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   _lowercase						(							unittest.TestCase				):


   @cached_property
   def 					snake_case				( self					):
       return (
           AutoImageProcessor.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''					)
           if is_vision_available()
           else None
       )


   @slow
   def 					snake_case				( self					):
       A       :       List[str]							=						SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256'''					).to(
           lowercase__					)
       A       :       List[Any]							=						self.default_image_processor

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

       # forward pass
       with torch.no_grad():
           A       :       Any							=						model(**lowercase__					)

       # verify the logits
       A       :       List[Any]							=						torch.Size((1, 1_000)					)
       self.assertEqual(outputs.logits.shape    ,   lowercase__					)
       A       :       Dict							=						torch.tensor([-0.3947, -0.4306, 0.0026]					).to(lowercase__					)
       self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,   lowercase__    ,   atol=1E-4					)					)







'''simple docstring'''






def 							_lowerCamelCase(  UpperCamelCase__    : Union[str, Any]    ,       UpperCamelCase__    : str		)		->  Optional[Any]:
    A       :       Tuple							=						0
    while b > 0:
        if b & 1:
            res += a

        a += a
        b >>= 1

    return res
def 							_lowerCamelCase(  UpperCamelCase__    : Any    ,       UpperCamelCase__    : Any    ,       UpperCamelCase__    : List[str]		)		->  Any:
    A       :       str							=						0
    while b > 0:
        if b & 1:
            A       :       List[Any]							=						((res % c) + (a % c)) % c

        a += a
        b >>= 1

    return res
