





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 						UpperCamelCase__					:



     '''simple docstring'''

     def __init__(				self		:       List[Any]		,lowerCamelCase__		:       Tuple		,lowerCamelCase__		:       Dict=13		,lowerCamelCase__		:       int=32		,lowerCamelCase__		:       Any=2		,lowerCamelCase__		:       Optional[int]=3		,lowerCamelCase__		:       List[str]=16		,lowerCamelCase__		:       Tuple=[1, 2, 1]		,lowerCamelCase__		:       Any=[2, 2, 4]		,lowerCamelCase__		:       Dict=2		,lowerCamelCase__		:       List[Any]=2.0		,lowerCamelCase__		:       Dict=True		,lowerCamelCase__		:       Any=0.0		,lowerCamelCase__		:       str=0.0		,lowerCamelCase__		:       int=0.1		,lowerCamelCase__		:       Optional[int]="gelu"		,lowerCamelCase__		:       Optional[Any]=False		,lowerCamelCase__		:       Union[str, Any]=True		,lowerCamelCase__		:       str=0.02		,lowerCamelCase__		:       Optional[int]=1e-5		,lowerCamelCase__		:       Optional[int]=True		,lowerCamelCase__		:       Optional[int]=None		,lowerCamelCase__		:       Any=True		,lowerCamelCase__		:       Union[str, Any]=10		,lowerCamelCase__		:       Optional[int]=8		,lowerCamelCase__		:       List[Any]=["stage1", "stage2"]		,lowerCamelCase__		:       Tuple=[1, 2]		,)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		parent
           SCREAMING_SNAKE_CASE						=		batch_size
           SCREAMING_SNAKE_CASE						=		image_size
           SCREAMING_SNAKE_CASE						=		patch_size
           SCREAMING_SNAKE_CASE						=		num_channels
           SCREAMING_SNAKE_CASE						=		embed_dim
           SCREAMING_SNAKE_CASE						=		depths
           SCREAMING_SNAKE_CASE						=		num_heads
           SCREAMING_SNAKE_CASE						=		window_size
           SCREAMING_SNAKE_CASE						=		mlp_ratio
           SCREAMING_SNAKE_CASE						=		qkv_bias
           SCREAMING_SNAKE_CASE						=		hidden_dropout_prob
           SCREAMING_SNAKE_CASE						=		attention_probs_dropout_prob
           SCREAMING_SNAKE_CASE						=		drop_path_rate
           SCREAMING_SNAKE_CASE						=		hidden_act
           SCREAMING_SNAKE_CASE						=		use_absolute_embeddings
           SCREAMING_SNAKE_CASE						=		patch_norm
           SCREAMING_SNAKE_CASE						=		layer_norm_eps
           SCREAMING_SNAKE_CASE						=		initializer_range
           SCREAMING_SNAKE_CASE						=		is_training
           SCREAMING_SNAKE_CASE						=		scope
           SCREAMING_SNAKE_CASE						=		use_labels
           SCREAMING_SNAKE_CASE						=		type_sequence_label_size
           SCREAMING_SNAKE_CASE						=		encoder_stride
           SCREAMING_SNAKE_CASE						=		out_features
           SCREAMING_SNAKE_CASE						=		out_indices






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

           SCREAMING_SNAKE_CASE						=		self.get_config()

           return config, pixel_values, labels






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Dict			)	->						str:




           '''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 							SCREAMING_SNAKE_CASE__    (				self		:       str		,lowerCamelCase__		:       str		,lowerCamelCase__		:       Any		,lowerCamelCase__		:       List[str]			)	->						List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		SwinModel(config=lowerCamelCase__			)
           model.to(lowerCamelCase__			)
           model.eval()
           SCREAMING_SNAKE_CASE						=		model(lowerCamelCase__			)

           SCREAMING_SNAKE_CASE						=		((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
           SCREAMING_SNAKE_CASE						=		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 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]		,lowerCamelCase__		:       Tuple		,lowerCamelCase__		:       str		,lowerCamelCase__		:       Tuple			)	->						Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		SwinBackbone(config=lowerCamelCase__			)
           model.to(lowerCamelCase__			)
           model.eval()
           SCREAMING_SNAKE_CASE						=		model(lowerCamelCase__			)

           # 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
           SCREAMING_SNAKE_CASE						=		None
           SCREAMING_SNAKE_CASE						=		SwinBackbone(config=lowerCamelCase__			)
           model.to(lowerCamelCase__			)
           model.eval()
           SCREAMING_SNAKE_CASE						=		model(lowerCamelCase__			)

           # 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 							SCREAMING_SNAKE_CASE__    (				self		:       Union[str, Any]		,lowerCamelCase__		:       Optional[int]		,lowerCamelCase__		:       str		,lowerCamelCase__		:       List[Any]			)	->						Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		SwinForMaskedImageModeling(config=lowerCamelCase__			)
           model.to(lowerCamelCase__			)
           model.eval()
           SCREAMING_SNAKE_CASE						=		model(lowerCamelCase__			)
           self.parent.assertEqual(
               result.logits.shape		,(self.batch_size, self.num_channels, self.image_size, self.image_size)			)

           # test greyscale images
           SCREAMING_SNAKE_CASE						=		1
           SCREAMING_SNAKE_CASE						=		SwinForMaskedImageModeling(lowerCamelCase__			)
           model.to(lowerCamelCase__			)
           model.eval()

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






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Dict		,lowerCamelCase__		:       Any		,lowerCamelCase__		:       int		,lowerCamelCase__		:       Any			)	->						Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.type_sequence_label_size
           SCREAMING_SNAKE_CASE						=		SwinForImageClassification(lowerCamelCase__			)
           model.to(lowerCamelCase__			)
           model.eval()
           SCREAMING_SNAKE_CASE						=		model(lowerCamelCase__		,labels=lowerCamelCase__			)
           self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.type_sequence_label_size)			)

           # test greyscale images
           SCREAMING_SNAKE_CASE						=		1
           SCREAMING_SNAKE_CASE						=		SwinForImageClassification(lowerCamelCase__			)
           model.to(lowerCamelCase__			)
           model.eval()

           SCREAMING_SNAKE_CASE						=		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
           SCREAMING_SNAKE_CASE						=		model(lowerCamelCase__			)
           self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.type_sequence_label_size)			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Union[str, Any]			)	->						Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.prepare_config_and_inputs()
           (
               (
               SCREAMING_SNAKE_CASE
           ),   (
               SCREAMING_SNAKE_CASE
           ),   (
               SCREAMING_SNAKE_CASE
           ),   
           )						=		config_and_inputs
           SCREAMING_SNAKE_CASE						=		{"""pixel_values""": pixel_values}
           return config, inputs_dict

@require_torch
class 						UpperCamelCase__					( lowerCAmelCase_				, lowerCAmelCase_				, unittest.TestCase  ):



     '''simple docstring'''

     __snake_case       :      Union[str, Any]						      =     (
         (
             SwinModel,
             SwinBackbone,
             SwinForImageClassification,
             SwinForMaskedImageModeling,
         )
         if is_torch_available()
         else ()
     )
     __snake_case       :      Union[str, Any]						      =     (
         {"feature-extraction": SwinModel, "image-classification": SwinForImageClassification}
         if is_torch_available()
         else {}
     )
     __snake_case       :      Dict						      =     True

     __snake_case       :      List[str]						      =     False
     __snake_case       :      Dict						      =     False
     __snake_case       :      List[str]						      =     False






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Dict			)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		SwinModelTester(self			)
           SCREAMING_SNAKE_CASE						=		ConfigTester(self		,config_class=lowerCamelCase__		,embed_dim=37			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       int			)	->						Tuple:




           '''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 							SCREAMING_SNAKE_CASE__    (				self		:       Dict			)	->						List[str]:




           '''simple docstring'''


           return






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase__			)






     @unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""			)
     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]			)	->						Optional[int]:




           '''simple docstring'''


           pass






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Any			)	->						Dict:




           '''simple docstring'''


           super().test_training_gradient_checkpointing()






     def 							SCREAMING_SNAKE_CASE__    (				self		:       int			)	->						Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_backbone(*lowerCamelCase__			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase__			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Tuple			)	->						str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__			)






     @unittest.skip(reason="""Swin does not use inputs_embeds"""			)
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						Tuple:




           '''simple docstring'''


           pass






     @unittest.skip(reason="""Swin Transformer does not use feedforward chunking"""			)
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Union[str, Any]			)	->						Dict:




           '''simple docstring'''


           pass






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs_for_common()

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






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs_for_common()

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

                 SCREAMING_SNAKE_CASE						=		["""pixel_values"""]
                 self.assertListEqual(arg_names[:1]		,lowerCamelCase__			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Dict			)	->						str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs_for_common()
           SCREAMING_SNAKE_CASE						=		True

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

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

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

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

                 # also another +1 for reshaped_hidden_states
                 SCREAMING_SNAKE_CASE						=		1 if model_class.__name__ == """SwinBackbone""" else 2
                 self.assertEqual(out_len + added_hidden_states		,len(lowerCamelCase__			)			)

                 SCREAMING_SNAKE_CASE						=		outputs.attentions

                 self.assertEqual(len(lowerCamelCase__			)		,lowerCamelCase__			)

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






     def 							SCREAMING_SNAKE_CASE__    (				self		:       int		,lowerCamelCase__		:       Any		,lowerCamelCase__		:       Union[str, Any]		,lowerCamelCase__		:       Optional[int]		,lowerCamelCase__		:       int			)	->						List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		model_class(lowerCamelCase__			)
           model.to(lowerCamelCase__			)
           model.eval()

           with torch.no_grad():
                 SCREAMING_SNAKE_CASE						=		model(**self._prepare_for_class(lowerCamelCase__		,lowerCamelCase__			)			)

           SCREAMING_SNAKE_CASE						=		outputs.hidden_states

           SCREAMING_SNAKE_CASE						=		getattr(
               self.model_tester		,"""expected_num_hidden_layers"""		,len(self.model_tester.depths			) + 1			)
           self.assertEqual(len(lowerCamelCase__			)		,lowerCamelCase__			)

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

           SCREAMING_SNAKE_CASE						=		(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":
                 SCREAMING_SNAKE_CASE						=		outputs.reshaped_hidden_states
                 self.assertEqual(len(lowerCamelCase__			)		,lowerCamelCase__			)

                 SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		reshaped_hidden_states[0].shape
                 SCREAMING_SNAKE_CASE						=		(
                     reshaped_hidden_states[0].view(lowerCamelCase__		,lowerCamelCase__		,height * width			).permute(0		,2		,1			)
                 )
                 self.assertListEqual(
                     list(reshaped_hidden_states.shape[-2:]			)		,[num_patches, self.model_tester.embed_dim]		,)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]			)	->						Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs_for_common()

           SCREAMING_SNAKE_CASE						=		(
               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:
                 SCREAMING_SNAKE_CASE						=		True
                 self.check_hidden_states_output(lowerCamelCase__		,lowerCamelCase__		,lowerCamelCase__		,lowerCamelCase__			)

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

                 self.check_hidden_states_output(lowerCamelCase__		,lowerCamelCase__		,lowerCamelCase__		,lowerCamelCase__			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[Any]			)	->						List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs_for_common()
           SCREAMING_SNAKE_CASE						=		3

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

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

           for model_class in self.all_model_classes:
                 SCREAMING_SNAKE_CASE						=		True
                 self.check_hidden_states_output(lowerCamelCase__		,lowerCamelCase__		,lowerCamelCase__		,(padded_height, padded_width)			)

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






     @slow
     def 							SCREAMING_SNAKE_CASE__    (				self		:       str			)	->						Optional[Any]:




           '''simple docstring'''


           for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 SCREAMING_SNAKE_CASE						=		SwinModel.from_pretrained(lowerCamelCase__			)
                 self.assertIsNotNone(lowerCamelCase__			)






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Tuple			)	->						List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		self.model_tester.prepare_config_and_inputs_for_common()

           SCREAMING_SNAKE_CASE						=		_config_zero_init(lowerCamelCase__			)
           for model_class in self.all_model_classes:
                 SCREAMING_SNAKE_CASE						=		model_class(config=lowerCamelCase__			)
                 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 						UpperCamelCase__					( unittest.TestCase  ):



     '''simple docstring'''

     @cached_property
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[int]			)	->						Tuple:




           '''simple docstring'''


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






     @slow
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Tuple			)	->						int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		SwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""			).to(lowerCamelCase__			)
           SCREAMING_SNAKE_CASE						=		self.default_image_processor

           SCREAMING_SNAKE_CASE						=		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
           SCREAMING_SNAKE_CASE						=		image_processor(images=lowerCamelCase__		,return_tensors="""pt"""			).to(lowerCamelCase__			)

           # forward pass
           with torch.no_grad():
                 SCREAMING_SNAKE_CASE						=		model(**lowerCamelCase__			)

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

@require_torch
class 						UpperCamelCase__					( unittest.TestCase				, lowerCAmelCase_  ):



     '''simple docstring'''

     __snake_case       :      Union[str, Any]						      =     (SwinBackbone,) if is_torch_available() else ()
     __snake_case       :      Optional[int]						      =     SwinConfig






     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		SwinModelTester(self			)









from __future__ import annotations

from collections.abc import Iterable

class 						UpperCamelCase__					:



     '''simple docstring'''

     def __init__(				self		:       Optional[Any]		,lowerCamelCase__		:       Optional[int]		,lowerCamelCase__		:       List[Any]			)	->						int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,   SCREAMING_SNAKE_CASE						=		float(lowerCamelCase__			), float(lowerCamelCase__			)






     def __eq__(				self		:       int		,lowerCamelCase__		:       Union[str, Any]			)	->						List[str]:




           '''simple docstring'''


           return self.x == other.x and self.y == other.y






     def __ne__(				self		:       Optional[int]		,lowerCamelCase__		:       int			)	->						Dict:




           '''simple docstring'''


           return not self == other






     def __gt__(				self		:       Optional[Any]		,lowerCamelCase__		:       Optional[Any]			)	->						List[Any]:




           '''simple docstring'''


           if self.x > other.x:
                 return True
           elif self.x == other.x:
                 return self.y > other.y
           return False






     def __lt__(				self		:       Union[str, Any]		,lowerCamelCase__		:       Optional[Any]			)	->						Optional[Any]:




           '''simple docstring'''


           return not self > other






     def __ge__(				self		:       Optional[Any]		,lowerCamelCase__		:       Tuple			)	->						Optional[Any]:




           '''simple docstring'''


           if self.x > other.x:
                 return True
           elif self.x == other.x:
                 return self.y >= other.y
           return False






     def __le__(				self		:       Tuple		,lowerCamelCase__		:       int			)	->						Dict:




           '''simple docstring'''


           if self.x < other.x:
                 return True
           elif self.x == other.x:
                 return self.y <= other.y
           return False






     def __repr__(				self		:       Dict			)	->						Any:




           '''simple docstring'''


           return F"""({self.x}, {self.y})"""






     def __hash__(				self		:       List[Any]			)	->						List[Any]:




           '''simple docstring'''


           return hash(self.x			)



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		)					->  list[Point]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE						=		[]
      if list_of_tuples:
            for p in list_of_tuples:
                  if isinstance(_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      ):
                        points.append(_SCREAMING_SNAKE_CASE      )
                  else:
                        try:
                              points.append(Point(p[0]					,		p[1]      )      )
                        except (IndexError, TypeError):
                              print(
                                  F"""Ignoring deformed point {p}. All points"""
                                  """ must have at least 2 coordinates."""      )
      return points



def   __lowercase  ( _SCREAMING_SNAKE_CASE      )					->  list[Point]:


      '''simple docstring'''


      if not hasattr(_SCREAMING_SNAKE_CASE					,		"""__iter__"""      ):
            SCREAMING_SNAKE_CASE						=		F"""Expecting an iterable object but got an non-iterable type {points}"""
            raise ValueError(_SCREAMING_SNAKE_CASE      )

      if not points:
            SCREAMING_SNAKE_CASE						=		F"""Expecting a list of points but got {points}"""
            raise ValueError(_SCREAMING_SNAKE_CASE      )

      return _construct_points(_SCREAMING_SNAKE_CASE      )



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  float:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE						=		(a.x * b.y + b.x * c.y + c.x * a.y) - (a.y * b.x + b.y * c.x + c.y * a.x)
      return det



def   __lowercase  ( _SCREAMING_SNAKE_CASE      )					->  list[Point]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE						=		sorted(_validate_input(_SCREAMING_SNAKE_CASE      )      )
      SCREAMING_SNAKE_CASE						=		len(_SCREAMING_SNAKE_CASE      )
      SCREAMING_SNAKE_CASE						=		set()

      for i in range(n - 1      ):
            for j in range(i + 1					,		_SCREAMING_SNAKE_CASE      ):
                  SCREAMING_SNAKE_CASE						=		SCREAMING_SNAKE_CASE						=		False
                  SCREAMING_SNAKE_CASE						=		True
                  for k in range(_SCREAMING_SNAKE_CASE      ):
                        if k != i and k != j:
                              SCREAMING_SNAKE_CASE						=		_det(points[i]					,		points[j]					,		points[k]      )

                              if det_k > 0:
                                    SCREAMING_SNAKE_CASE						=		True
                              elif det_k < 0:
                                    SCREAMING_SNAKE_CASE						=		True
                              else:
                                    # point[i], point[j], point[k] all lie on a straight line
                                    # if point[k] is to the left of point[i] or it's to the
                                    # right of point[j], then point[i], point[j] cannot be
                                    # part of the convex hull of A
                                    if points[k] < points[i] or points[k] > points[j]:
                                          SCREAMING_SNAKE_CASE						=		False
                                          break

                        if points_left_of_ij and points_right_of_ij:
                              SCREAMING_SNAKE_CASE						=		False
                              break

                  if ij_part_of_convex_hull:
                        convex_set.update([points[i], points[j]]      )

      return sorted(_SCREAMING_SNAKE_CASE      )



def   __lowercase  ( _SCREAMING_SNAKE_CASE      )					->  list[Point]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE						=		sorted(_validate_input(_SCREAMING_SNAKE_CASE      )      )
      SCREAMING_SNAKE_CASE						=		len(_SCREAMING_SNAKE_CASE      )

      # divide all the points into an upper hull and a lower hull
      # the left most point and the right most point are definitely
      # members of the convex hull by definition.
      # use these two anchors to divide all the points into two hulls,
      # an upper hull and a lower hull.

      # all points to the left (above) the line joining the extreme points belong to the
      # upper hull
      # all points to the right (below) the line joining the extreme points below to the
      # lower hull
      # ignore all points on the line joining the extreme points since they cannot be
      # part of the convex hull

      SCREAMING_SNAKE_CASE						=		points[0]
      SCREAMING_SNAKE_CASE						=		points[n - 1]

      SCREAMING_SNAKE_CASE						=		{left_most_point, right_most_point}
      SCREAMING_SNAKE_CASE						=		[]
      SCREAMING_SNAKE_CASE						=		[]

      for i in range(1					,		n - 1      ):
            SCREAMING_SNAKE_CASE						=		_det(_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		points[i]      )

            if det > 0:
                  upper_hull.append(points[i]      )
            elif det < 0:
                  lower_hull.append(points[i]      )

      _construct_hull(_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )
      _construct_hull(_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )

      return sorted(_SCREAMING_SNAKE_CASE      )



def   __lowercase  ( _SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )					->  None:


      '''simple docstring'''


      if points:
            SCREAMING_SNAKE_CASE						=		None
            SCREAMING_SNAKE_CASE						=		float("""-inf"""      )
            SCREAMING_SNAKE_CASE						=		[]

            for p in points:
                  SCREAMING_SNAKE_CASE						=		_det(_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )

                  if det > 0:
                        candidate_points.append(_SCREAMING_SNAKE_CASE      )

                        if det > extreme_point_distance:
                              SCREAMING_SNAKE_CASE						=		det
                              SCREAMING_SNAKE_CASE						=		p

            if extreme_point:
                  _construct_hull(_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )
                  convex_set.add(_SCREAMING_SNAKE_CASE      )
                  _construct_hull(_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      )



def   __lowercase  ( _SCREAMING_SNAKE_CASE      )					->  list[Point]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE						=		sorted(_validate_input(_SCREAMING_SNAKE_CASE      )      )
      SCREAMING_SNAKE_CASE						=		len(_SCREAMING_SNAKE_CASE      )

      SCREAMING_SNAKE_CASE						=		points[:2]
      for i in range(2					,		_SCREAMING_SNAKE_CASE      ):
            SCREAMING_SNAKE_CASE						=		_det(convex_hull[1]					,		convex_hull[0]					,		points[i]      )
            if det > 0:
                  convex_hull.insert(0					,		points[i]      )
                  break
            elif det < 0:
                  convex_hull.append(points[i]      )
                  break
            else:
                  SCREAMING_SNAKE_CASE						=		points[i]
      i += 1

      for j in range(_SCREAMING_SNAKE_CASE					,		_SCREAMING_SNAKE_CASE      ):
            if (
                _det(convex_hull[0]					,		convex_hull[-1]					,		points[j]      ) > 0
                and _det(convex_hull[-1]					,		convex_hull[0]					,		points[1]      ) < 0
            ):
                  # The point lies within the convex hull
                  continue

            convex_hull.insert(0					,		points[j]      )
            convex_hull.append(points[j]      )
            while _det(convex_hull[0]					,		convex_hull[1]					,		convex_hull[2]      ) >= 0:
                  del convex_hull[1]
            while _det(convex_hull[-1]					,		convex_hull[-2]					,		convex_hull[-3]      ) <= 0:
                  del convex_hull[-2]

    # `convex_hull` is contains the convex hull in circular order
      return sorted(convex_hull[1:] if len(_SCREAMING_SNAKE_CASE      ) > 3 else convex_hull      )



def   __lowercase  ( )					->  Any:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE						=		[
          (0, 3),
          (2, 2),
          (1, 1),
          (2, 1),
          (3, 0),
          (0, 0),
          (3, 3),
          (2, -1),
          (2, -4),
          (1, -3),
      ]
      # the convex set of points is
      # [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
      SCREAMING_SNAKE_CASE						=		convex_hull_bf(_SCREAMING_SNAKE_CASE      )

      SCREAMING_SNAKE_CASE						=		convex_hull_recursive(_SCREAMING_SNAKE_CASE      )
      assert results_bf == results_recursive

      SCREAMING_SNAKE_CASE						=		convex_hull_melkman(_SCREAMING_SNAKE_CASE      )
      assert results_bf == results_melkman

      print(_SCREAMING_SNAKE_CASE      )


if __name__ == "__main__":
      main()


