



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




     def __init__(				self ,						a__ ,						a__=1_3 ,						a__=3_2 ,						a__=2 ,						a__=3 ,						a__=1_6 ,						a__=[1, 2, 1] ,						a__=[2, 2, 4] ,						a__=2 ,						a__=2.0 ,						a__=True ,						a__=0.0 ,						a__=0.0 ,						a__=0.1 ,						a__="gelu" ,						a__=False ,						a__=True ,						a__=0.0_2 ,						a__=1e-5 ,						a__=True ,						a__=None ,						a__=True ,						a__=1_0 ,						a__=8 ,						):
         A__		 =					parent
         A__		 =					batch_size
         A__		 =					image_size
         A__		 =					patch_size
         A__		 =					num_channels
         A__		 =					embed_dim
         A__		 =					depths
         A__		 =					num_heads
         A__		 =					window_size
         A__		 =					mlp_ratio
         A__		 =					qkv_bias
         A__		 =					hidden_dropout_prob
         A__		 =					attention_probs_dropout_prob
         A__		 =					drop_path_rate
         A__		 =					hidden_act
         A__		 =					use_absolute_embeddings
         A__		 =					patch_norm
         A__		 =					layer_norm_eps
         A__		 =					initializer_range
         A__		 =					is_training
         A__		 =					scope
         A__		 =					use_labels
         A__		 =					type_sequence_label_size
         A__		 =					encoder_stride




     def 		snake_case_		(				self):
         A__		 =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

         A__		 =					None
         if self.use_labels:
             A__		 =					ids_tensor([self.batch_size] ,						self.type_sequence_label_size)

         A__		 =					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 ,						a__ ,						a__ ,						a__):
         A__		 =					SwinvaModel(config=snake_case__)
         model.to(snake_case__)
         model.eval()
         A__		 =					model(snake_case__)

         A__		 =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1))
         A__		 =					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 ,						a__ ,						a__ ,						a__):
         A__		 =					SwinvaForMaskedImageModeling(config=snake_case__)
         model.to(snake_case__)
         model.eval()
         A__		 =					model(snake_case__)
         self.parent.assertEqual(
             result.logits.shape ,						(self.batch_size, self.num_channels, self.image_size, self.image_size))

         # test greyscale images
         A__		 =					1
         A__		 =					SwinvaForMaskedImageModeling(snake_case__)
         model.to(snake_case__)
         model.eval()

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




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__):
         A__		 =					self.type_sequence_label_size
         A__		 =					SwinvaForImageClassification(snake_case__)
         model.to(snake_case__)
         model.eval()
         A__		 =					model(snake_case__ ,						labels=snake_case__)
         self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.type_sequence_label_size))




     def 		snake_case_		(				self):
         A__		 =					self.prepare_config_and_inputs()
         A__ ,	A__ ,	A__		 =					config_and_inputs
         A__		 =					{'''pixel_values''': pixel_values}
         return config, inputs_dict







@require_torch
class     _UpperCAmelCase			(       __a			,      __a			,      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__		 =					SwinvaModelTester(self)
         A__		 =					ConfigTester(self ,						config_class=snake_case__ ,						embed_dim=3_7)




     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__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case__)




     @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__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()

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




     def 		snake_case_		(				self):
         A__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()

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

             A__		 =					['''pixel_values''']
             self.assertListEqual(arg_names[:1] ,						snake_case__)




     def 		snake_case_		(				self):
         A__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()
         A__		 =					True

         for model_class in self.all_model_classes:
             A__		 =					True
             A__		 =					False
             A__		 =					True
             A__		 =					model_class(snake_case__)
             model.to(snake_case__)
             model.eval()
             with torch.no_grad():
                 A__		 =					model(**self._prepare_for_class(snake_case__ ,						snake_case__))
             A__		 =					outputs.attentions
             A__		 =					len(self.model_tester.depths)
             self.assertEqual(len(snake_case__) ,						snake_case__)

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

             self.assertListEqual(
                 list(attentions[0].shape[-3:]) ,						[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,						)
             A__		 =					len(snake_case__)

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

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

             A__		 =					outputs.attentions

             self.assertEqual(len(snake_case__) ,						snake_case__)

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




     def 		snake_case_		(				self ,						a__ ,						a__ ,						a__ ,						a__):
         A__		 =					model_class(snake_case__)
         model.to(snake_case__)
         model.eval()

         with torch.no_grad():
             A__		 =					model(**self._prepare_for_class(snake_case__ ,						snake_case__))

         A__		 =					outputs.hidden_states

         A__		 =					getattr(
             self.model_tester ,						'''expected_num_hidden_layers''' ,						len(self.model_tester.depths) + 1)
         self.assertEqual(len(snake_case__) ,						snake_case__)

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

         A__		 =					(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__		 =					outputs.reshaped_hidden_states
         self.assertEqual(len(snake_case__) ,						snake_case__)

         A__ ,	A__ ,	A__ ,	A__		 =					reshaped_hidden_states[0].shape
         A__		 =					(
             reshaped_hidden_states[0].view(snake_case__ ,						snake_case__ ,						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__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()

         A__		 =					(
             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__		 =					True
             self.check_hidden_states_output(snake_case__ ,						snake_case__ ,						snake_case__ ,						snake_case__)

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

             self.check_hidden_states_output(snake_case__ ,						snake_case__ ,						snake_case__ ,						snake_case__)




     def 		snake_case_		(				self):
         A__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()
         A__		 =					3

         A__		 =					(
             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__		 =					(
             config.patch_size
             if isinstance(config.patch_size ,						collections.abc.Iterable)
             else (config.patch_size, config.patch_size)
         )

         A__		 =					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
         A__		 =					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

         for model_class in self.all_model_classes:
             A__		 =					True
             self.check_hidden_states_output(snake_case__ ,						snake_case__ ,						snake_case__ ,						(padded_height, padded_width))

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             A__		 =					True
             self.check_hidden_states_output(snake_case__ ,						snake_case__ ,						snake_case__ ,						(padded_height, padded_width))




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*snake_case__)




     def 		snake_case_		(				self):
         A__		 =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*snake_case__)




     @slow
     def 		snake_case_		(				self):
         for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             A__		 =					SwinvaModel.from_pretrained(snake_case__)
             self.assertIsNotNone(snake_case__)




     def 		snake_case_		(				self):
         A__ ,	A__		 =					self.model_tester.prepare_config_and_inputs_for_common()

         A__		 =					_config_zero_init(snake_case__)
         for model_class in self.all_model_classes:
             A__		 =					model_class(config=snake_case__)
             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     _UpperCAmelCase			(       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__		 =					SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256''').to(
             snake_case__)
         A__		 =					self.default_image_processor

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

         # forward pass
         with torch.no_grad():
             A__		 =					model(**snake_case__)

         # verify the logits
         A__		 =					torch.Size((1, 1_0_0_0))
         self.assertEqual(outputs.logits.shape ,						snake_case__)
         A__		 =					torch.tensor([-0.3_9_4_7, -0.4_3_0_6, 0.0_0_2_6]).to(snake_case__)
         self.assertTrue(torch.allclose(outputs.logits[0, :3] ,						snake_case__ ,						atol=1e-4))





def 		lowerCAmelCase__    (					UpperCamelCase_				:       Optional[int] ,       UpperCamelCase_				:       List[str] ,       UpperCamelCase_				:       List[Any] ,       UpperCamelCase_				:       str	)->  int:
    if height >= 1:
        move_tower(height - 1 ,       UpperCamelCase_ ,       UpperCamelCase_ ,       UpperCamelCase_	)
        move_disk(UpperCamelCase_ ,       UpperCamelCase_	)
        move_tower(height - 1 ,       UpperCamelCase_ ,       UpperCamelCase_ ,       UpperCamelCase_	)



def 		lowerCAmelCase__    (					UpperCamelCase_				:       Optional[int] ,       UpperCamelCase_				:       List[Any]	)->  str:
    print('''moving disk from''' ,       UpperCamelCase_ ,       '''to''' ,       UpperCamelCase_	)



def 		lowerCAmelCase__    (					)->  Tuple:
    A__		 =					int(input('''Height of hanoi: '''	).strip()	)
    move_tower(UpperCamelCase_ ,       '''A''' ,       '''B''' ,       '''C'''	)


if __name__ == "__main__":
   main()
