






"""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 					_UpperCamelCase		:






    def __init__(self						,      lowerCamelCase__						,      lowerCamelCase__=1_3						,      lowerCamelCase__=3_2						,      lowerCamelCase__=2						,      lowerCamelCase__=3						,      lowerCamelCase__=1_6						,      lowerCamelCase__=[1, 2, 1]						,      lowerCamelCase__=[2, 2, 4]						,      lowerCamelCase__=2						,      lowerCamelCase__=2.0						,      lowerCamelCase__=True						,      lowerCamelCase__=0.0						,      lowerCamelCase__=0.0						,      lowerCamelCase__=0.1						,      lowerCamelCase__="gelu"						,      lowerCamelCase__=False						,      lowerCamelCase__=True						,      lowerCamelCase__=0.0_2						,      lowerCamelCase__=1E-5						,      lowerCamelCase__=True						,      lowerCamelCase__=None						,      lowerCamelCase__=True						,      lowerCamelCase__=1_0						,      lowerCamelCase__=8						,      lowerCamelCase__=["stage1", "stage2"]						,      lowerCamelCase__=[1, 2]						,      ):


      """simple docstring"""
      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
      A__											=							out_features
      A__											=							out_indices






    def  A    (self   ):


      """simple docstring"""
      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  A    (self   ):


      """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  A    (self						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__   ):


      """simple docstring"""
      A__											=							SwinModel(config=lowerCamelCase__   )
      model.to(lowerCamelCase__   )
      model.eval()
      A__											=							model(lowerCamelCase__   )

      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  A    (self						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__   ):


      """simple docstring"""
      A__											=							SwinBackbone(config=lowerCamelCase__   )
      model.to(lowerCamelCase__   )
      model.eval()
      A__											=							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], 1_6, 1_6]   )

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

      # verify backbone works with out_features=None
      A__											=							None
      A__											=							SwinBackbone(config=lowerCamelCase__   )
      model.to(lowerCamelCase__   )
      model.eval()
      A__											=							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  A    (self						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__   ):


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

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

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






    def  A    (self						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__   ):


      """simple docstring"""
      A__											=							self.type_sequence_label_size
      A__											=							SwinForImageClassification(lowerCamelCase__   )
      model.to(lowerCamelCase__   )
      model.eval()
      A__											=							model(lowerCamelCase__						,      labels=lowerCamelCase__   )
      self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.type_sequence_label_size)   )

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

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






    def  A    (self   ):


      """simple docstring"""
      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		( __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   ):


      """simple docstring"""
      A__											=							SwinModelTester(self   )
      A__											=							ConfigTester(self						,      config_class=lowerCamelCase__						,      embed_dim=3_7   )






    def  A    (self   ):


      """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  A    (self   ):


      """simple docstring"""
      return






    def  A    (self   ):


      """simple docstring"""
      A__											=							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  A    (self   ):


      """simple docstring"""
      pass






    def  A    (self   ):


      """simple docstring"""
      super().test_training_gradient_checkpointing()






    def  A    (self   ):


      """simple docstring"""
      A__											=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*lowerCamelCase__   )






    def  A    (self   ):


      """simple docstring"""
      A__											=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase__   )






    def  A    (self   ):


      """simple docstring"""
      A__											=							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  A    (self   ):


      """simple docstring"""
      pass






    @unittest.skip(reason="""Swin Transformer does not use feedforward chunking"""   )
    def  A    (self   ):


      """simple docstring"""
      pass






    def  A    (self   ):


      """simple docstring"""
      A__						,A__											=							self.model_tester.prepare_config_and_inputs_for_common()

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






    def  A    (self   ):


      """simple docstring"""
      A__						,A__											=							self.model_tester.prepare_config_and_inputs_for_common()

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






    def  A    (self   ):


      """simple docstring"""
      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(lowerCamelCase__   )
        model.to(lowerCamelCase__   )
        model.eval()
        with torch.no_grad():
          A__											=							model(**self._prepare_for_class(lowerCamelCase__						,      lowerCamelCase__   )   )
        A__											=							outputs.attentions
        A__											=							len(self.model_tester.depths   )
        self.assertEqual(len(lowerCamelCase__   )						,      lowerCamelCase__   )

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

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

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

        A__											=							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  A    (self						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__   ):


      """simple docstring"""
      A__											=							model_class(lowerCamelCase__   )
      model.to(lowerCamelCase__   )
      model.eval()

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

      A__											=							outputs.hidden_states

      A__											=							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
      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]						,      )

      if not model_class.__name__ == "SwinBackbone":
        A__											=							outputs.reshaped_hidden_states
        self.assertEqual(len(lowerCamelCase__   )						,      lowerCamelCase__   )

        A__						,A__						,A__						,A__											=							reshaped_hidden_states[0].shape
        A__											=							(
            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  A    (self   ):


      """simple docstring"""
      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(lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__   )

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

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






    def  A    (self   ):


      """simple docstring"""
      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(lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      (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(lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__						,      (padded_height, padded_width)   )






    @slow
    def  A    (self   ):


      """simple docstring"""
      for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        A__											=							SwinModel.from_pretrained(lowerCamelCase__   )
        self.assertIsNotNone(lowerCamelCase__   )






    def  A    (self   ):


      """simple docstring"""
      A__						,A__											=							self.model_tester.prepare_config_and_inputs_for_common()

      A__											=							_config_zero_init(lowerCamelCase__   )
      for model_class in self.all_model_classes:
        A__											=							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):






    @cached_property
    def  A    (self   ):


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






    @slow
    def  A    (self   ):


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

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

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

      # verify the logits
      A__											=							torch.Size((1, 1_0_0_0)   )
      self.assertEqual(outputs.logits.shape						,      lowerCamelCase__   )
      A__											=							torch.tensor([-0.0_9_4_8, -0.6_4_5_4, -0.0_9_2_1]   ).to(lowerCamelCase__   )
      self.assertTrue(torch.allclose(outputs.logits[0, :3]						,      lowerCamelCase__						,      atol=1E-4   )   )







@require_torch
class 					_UpperCamelCase		( unittest.TestCase						, __snake_case):
    __lowerCamelCase         =  (SwinBackbone,) if is_torch_available() else ()
    __lowerCamelCase         =  SwinConfig






    def  A    (self   ):


      """simple docstring"""
      A__											=							SwinModelTester(self   )












"""simple docstring"""




def 						_SCREAMING_SNAKE_CASE							( UpperCamelCase     :	Dict    ):
  A__											=							len(UpperCamelCase    )
  for _ in range(
      0		,				int(((no_of_elements - 1) / 2) + 1    )    ):  # we don't need to traverse to end of list as
    for j in range(0		,				no_of_elements - 1    ):
      if (
          lst[j + 1] < lst[j]
      ):  # applying bubble sort algorithm from left to right (or forwards)
        A__											=							lst[j + 1]
        A__											=							lst[j]
        A__											=							temp
      if (
          lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
      ):  # applying bubble sort algorithm from right to left (or backwards)
        A__											=							lst[no_of_elements - 1 - j]
        A__											=							lst[no_of_elements - 2 - j]
        A__											=							temp
  return lst


if __name__ == "__main__":
      print("enter the list to be sorted")
      lowerCamelCase__			=   [int(x) for x in input().split()]  # inputing elements of the list in one line
      lowerCamelCase__			=   double_sort(lst)
      print("the sorted list is")
      print(sorted_lst)




