






"""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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 ):
    SCREAMING_SNAKE_CASE		=			(
        (
            SwinModel,
            SwinBackbone,
            SwinForImageClassification,
            SwinForMaskedImageModeling,
        )
        if is_torch_available()
        else ()
    )
    SCREAMING_SNAKE_CASE		=			(
        {'''feature-extraction''': SwinModel, '''image-classification''': SwinForImageClassification}
        if is_torch_available()
        else {}
    )
    SCREAMING_SNAKE_CASE		=			True

    SCREAMING_SNAKE_CASE		=			False
    SCREAMING_SNAKE_CASE		=			False
    SCREAMING_SNAKE_CASE		=			False






    def 				_UpperCamelCase							( self					):
          UpperCAmelCase							=       SwinModelTester(self					)
          UpperCAmelCase							=       ConfigTester(self	,config_class=A	,embed_dim=37					)






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






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






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






    def 				_UpperCamelCase							( self					):
          UpperCAmelCase							=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_backbone(*A					)






    def 				_UpperCamelCase							( self					):
          UpperCAmelCase							=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*A					)






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






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






    def 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( 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 				_UpperCamelCase							( self					):
          for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                UpperCAmelCase							=       SwinModel.from_pretrained(A					)
                self.assertIsNotNone(A					)






    def 				_UpperCamelCase							( 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 				_UpperCamelCase							( self					):
          return (
              AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""					)
              if is_vision_available()
              else None
          )






    @slow
    def 				_UpperCamelCase							( 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, 1_000)					)
          self.assertEqual(outputs.logits.shape	,A					)
          UpperCAmelCase							=       torch.tensor([-0.0948, -0.6454, -0.0921]					).to(A					)
          self.assertTrue(torch.allclose(outputs.logits[0, :3]	,A	,atol=1e-4					)					)







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






    def 				_UpperCamelCase							( self					):
          UpperCAmelCase							=       SwinModelTester(self					)











"""simple docstring"""







import cva
import numpy as np

def _a (		_snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case							):







      """simple docstring"""






      try:
            return int(image[x_coordinate][y_coordinate] >= center							)
      except (IndexError, TypeError):
            return 0

def _a (		_snake_case      ,       _snake_case      ,       _snake_case							):







      """simple docstring"""






      UpperCAmelCase							=       image[x_coordinate][y_coordinate]
      UpperCAmelCase							=       [1, 2, 4, 8, 16, 32, 64, 128]

      # skip get_neighbors_pixel if center is null
      if center is None:
            return 0

      # Starting from the top right, assigning value to pixels clockwise
      UpperCAmelCase							=       [
          get_neighbors_pixel(_snake_case      ,       x_coordinate - 1      ,       y_coordinate + 1      ,       _snake_case							),
          get_neighbors_pixel(_snake_case      ,       _snake_case      ,       y_coordinate + 1      ,       _snake_case							),
          get_neighbors_pixel(_snake_case      ,       x_coordinate - 1      ,       _snake_case      ,       _snake_case							),
          get_neighbors_pixel(_snake_case      ,       x_coordinate + 1      ,       y_coordinate + 1      ,       _snake_case							),
          get_neighbors_pixel(_snake_case      ,       x_coordinate + 1      ,       _snake_case      ,       _snake_case							),
          get_neighbors_pixel(_snake_case      ,       x_coordinate + 1      ,       y_coordinate - 1      ,       _snake_case							),
          get_neighbors_pixel(_snake_case      ,       _snake_case      ,       y_coordinate - 1      ,       _snake_case							),
          get_neighbors_pixel(_snake_case      ,       x_coordinate - 1      ,       y_coordinate - 1      ,       _snake_case							),
      ]

      # Converting the binary value to decimal.
      return sum(
          binary_value * power for binary_value, power in zip(_snake_case      ,       _snake_case							)							)


if __name__ == "__main__":
  # Reading the image and converting it to grayscale.
  _UpperCamelCase     			=  cva.imread(
      """digital_image_processing/image_data/lena.jpg""", cva.IMREAD_GRAYSCALE
  )

  # Create a numpy array as the same height and width of read image
  _UpperCamelCase     			=  np.zeros((image.shape[0], image.shape[1]))

  # Iterating through the image and calculating the
  # local binary pattern value for each pixel.
  for i in range(0, image.shape[0]):
    for j in range(0, image.shape[1]):
      _UpperCamelCase     			=  local_binary_value(image, i, j)

  cva.imshow("""local binary pattern""", lbp_image)
  cva.waitKey(0)
  cva.destroyAllWindows()



