





"""simple docstring"""






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






       def __init__( self     ,	a__     ,	a__=13     ,	a__=32     ,	a__=2     ,	a__=3     ,	a__=16     ,	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.02     ,	a__=1E-5     ,	a__=True     ,	a__=None     ,	a__=True     ,	a__=10     ,	a__=8     ,	a__=["stage1", "stage2"]     ,	a__=[1, 2]     ,	):
              _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
              _UpperCAmelCase			     =  out_features
              _UpperCAmelCase			     =  out_indices






       def 				__A			( self  ):
              _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 				__A			( self  ):
              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 				__A			( self     ,	a__     ,	a__     ,	a__  ):
              _UpperCAmelCase			     =  SwinModel(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 				__A			( self     ,	a__     ,	a__     ,	a__  ):
              _UpperCAmelCase			     =  SwinBackbone(config=a__  )
              model.to(a__  )
              model.eval()
              _UpperCAmelCase			     =  model(a__  )

              # verify hidden states
              self.parent.assertEqual(len(result.feature_maps  )     ,	len(config.out_features  )  )
              self.parent.assertListEqual(list(result.feature_maps[0].shape  )     ,	[self.batch_size, model.channels[0], 16, 16]  )

              # verify channels
              self.parent.assertEqual(len(model.channels  )     ,	len(config.out_features  )  )

              # verify backbone works with out_features=None
              _UpperCAmelCase			     =  None
              _UpperCAmelCase			     =  SwinBackbone(config=a__  )
              model.to(a__  )
              model.eval()
              _UpperCAmelCase			     =  model(a__  )

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

              # verify channels
              self.parent.assertEqual(len(model.channels  )     ,	1  )






       def 				__A			( self     ,	a__     ,	a__     ,	a__  ):
              _UpperCAmelCase			     =  SwinForMaskedImageModeling(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			     =  SwinForMaskedImageModeling(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 				__A			( self     ,	a__     ,	a__     ,	a__  ):
              _UpperCAmelCase			     =  self.type_sequence_label_size
              _UpperCAmelCase			     =  SwinForImageClassification(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)  )

              # test greyscale images
              _UpperCAmelCase			     =  1
              _UpperCAmelCase			     =  SwinForImageClassification(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, self.type_sequence_label_size)  )






       def 				__A			( self  ):
              _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       (   snake_case      ,						snake_case      ,						unittest.TestCase				):
       lowerCAmelCase__    			=	(
           (
               SwinModel,
               SwinBackbone,
               SwinForImageClassification,
               SwinForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       lowerCAmelCase__    			=	(
           {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
           if is_torch_available()
           else {}
       )
       lowerCAmelCase__    			=	True

       lowerCAmelCase__    			=	False
       lowerCAmelCase__    			=	False
       lowerCAmelCase__    			=	False






       def 				__A			( self  ):
              _UpperCAmelCase			     =  SwinModelTester(self  )
              _UpperCAmelCase			     =  ConfigTester(self     ,	config_class=a__     ,	embed_dim=37  )






       def 				__A			( self  ):
              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 				__A			( self  ):
              return






       def 				__A			( self  ):
              _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 				__A			( self  ):
              pass






       def 				__A			( self  ):
              super().test_training_gradient_checkpointing()






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_backbone(*a__  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_masked_image_modeling(*a__  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_image_classification(*a__  )






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






       @unittest.skip(reason='Swin Transformer does not use feedforward chunking'  )
       def 				__A			( self  ):
              pass






       def 				__A			( self  ):
              _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 				__A			( self  ):
              _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 				__A			( self  ):
              _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__  )  )

                     # also another +1 for reshaped_hidden_states
                     _UpperCAmelCase			     =  1 if model_class.__name__ == 'SwinBackbone' else 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 				__A			( self     ,	a__     ,	a__     ,	a__     ,	a__  ):
              _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__  )

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

              if not model_class.__name__ == "SwinBackbone":
                     _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 				__A			( self  ):
              _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 				__A			( self  ):
              _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)  )






       @slow
       def 				__A			( self  ):
              for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     _UpperCAmelCase			     =  SwinModel.from_pretrained(a__  )
                     self.assertIsNotNone(a__  )






       def 				__A			( self  ):
              _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 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				):






       @cached_property
       def 				__A			( self  ):
              return (
                  AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'  )
                  if is_vision_available()
                  else None
              )






       @slow
       def 				__A			( self  ):
              _UpperCAmelCase			     =  SwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'  ).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, 10_00)  )
              self.assertEqual(outputs.logits.shape     ,	a__  )
              _UpperCAmelCase			     =  torch.tensor([-0.0_948, -0.6_454, -0.0_921]  ).to(a__  )
              self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,	a__     ,	atol=1E-4  )  )



@require_torch
class 						lowerCAmelCase       (   unittest.TestCase      ,						snake_case				):
       lowerCAmelCase__    			=	(SwinBackbone,) if is_torch_available() else ()
       lowerCAmelCase__    			=	SwinConfig






       def 				__A			( self  ):
              _UpperCAmelCase			     =  SwinModelTester(self  )













"""simple docstring"""






from __future__ import annotations

def    __lowerCamelCase     (							SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE				)		->							list:






       """simple docstring"""




       _UpperCAmelCase			     =  [None] * (len(SCREAMING_SNAKE_CASE				) + len(SCREAMING_SNAKE_CASE				))

       _UpperCAmelCase			     =  0  # pointer to current index for left Half
       _UpperCAmelCase			     =  0  # pointer to current index for the right Half
       _UpperCAmelCase			     =  0  # pointer to current index for the sorted array Half

       while pointera < len(SCREAMING_SNAKE_CASE				) and pointera < len(SCREAMING_SNAKE_CASE				):
              if left_half[pointera] < right_half[pointera]:
                     _UpperCAmelCase			     =  left_half[pointera]
                     pointera += 1
                     index += 1
              else:
                     _UpperCAmelCase			     =  right_half[pointera]
                     pointera += 1
                     index += 1
       while pointera < len(SCREAMING_SNAKE_CASE				):
              _UpperCAmelCase			     =  left_half[pointera]
              pointera += 1
              index += 1

       while pointera < len(SCREAMING_SNAKE_CASE				):
              _UpperCAmelCase			     =  right_half[pointera]
              pointera += 1
              index += 1

       return sorted_array

def    __lowerCamelCase     (							SCREAMING_SNAKE_CASE				)		->							list:






       """simple docstring"""




       if len(SCREAMING_SNAKE_CASE				) <= 1:
              return array
       # the actual formula to calculate the middle element = left + (right - left) // 2
       # this avoids integer overflow in case of large N
       _UpperCAmelCase			     =  0 + (len(SCREAMING_SNAKE_CASE				) - 0) // 2

       # Split the array into halves till the array length becomes equal to One
       # merge the arrays of single length returned by mergeSort function and
       # pass them into the merge arrays function which merges the array
       _UpperCAmelCase			     =  array[:middle]
       _UpperCAmelCase			     =  array[middle:]

       return merge(merge_sort(SCREAMING_SNAKE_CASE				),merge_sort(SCREAMING_SNAKE_CASE				)				)


if __name__ == "__main__":
    import doctest

    doctest.testmod()






