






'''simple docstring'''

from cva import destroyAllWindows, imread, imshow, waitKey







def 					lowercase__				(   __UpperCamelCase					)->				Optional[int]:
      # getting number of pixels in the image
      UpperCamelCase						,UpperCamelCase       						=      img.shape[0], img.shape[1]

      # converting each pixel's color to its negative
      for i in range(__UpperCamelCase					):
            for j in range(__UpperCamelCase					):
                  UpperCamelCase       						=      [255, 255, 255] - img[i][j]

      return img


if __name__ == "__main__":
     # read original image
     SCREAMING_SNAKE_CASE__											=     imread('image_data/lena.jpg', 1)

     # convert to its negative
     SCREAMING_SNAKE_CASE__											=     convert_to_negative(img)

     # show result image
     imshow('negative of original image', img)
     waitKey(0)
     destroyAllWindows()








'''simple docstring'''

import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import MaskFormerSwinBackbone
     from transformers.models.maskformer import MaskFormerSwinModel






class        a_		:

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE=13    ,	_SCREAMING_SNAKE_CASE=32    ,	_SCREAMING_SNAKE_CASE=2    ,	_SCREAMING_SNAKE_CASE=3    ,	_SCREAMING_SNAKE_CASE=16    ,	_SCREAMING_SNAKE_CASE=[1, 2, 1]    ,	_SCREAMING_SNAKE_CASE=[2, 2, 4]    ,	_SCREAMING_SNAKE_CASE=2    ,	_SCREAMING_SNAKE_CASE=2.0    ,	_SCREAMING_SNAKE_CASE=True    ,	_SCREAMING_SNAKE_CASE=0.0    ,	_SCREAMING_SNAKE_CASE=0.0    ,	_SCREAMING_SNAKE_CASE=0.1    ,	_SCREAMING_SNAKE_CASE="gelu"    ,	_SCREAMING_SNAKE_CASE=False    ,	_SCREAMING_SNAKE_CASE=True    ,	_SCREAMING_SNAKE_CASE=0.0_2    ,	_SCREAMING_SNAKE_CASE=1e-5    ,	_SCREAMING_SNAKE_CASE=True    ,	_SCREAMING_SNAKE_CASE=None    ,	_SCREAMING_SNAKE_CASE=True    ,	_SCREAMING_SNAKE_CASE=10    ,	_SCREAMING_SNAKE_CASE=8    ,	_SCREAMING_SNAKE_CASE=["stage1", "stage2", "stage3"]    ,	_SCREAMING_SNAKE_CASE=[1, 2, 3]    ,	)						->   Any:



        """simple docstring"""






        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   )						->   Any:



        """simple docstring"""






        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   )						->   str:



        """simple docstring"""






        return MaskFormerSwinConfig(
            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    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )						->   Union[str, Any]:



        """simple docstring"""






        UpperCamelCase       						=      MaskFormerSwinModel(config=_SCREAMING_SNAKE_CASE   )
        model.to(_SCREAMING_SNAKE_CASE   )
        model.eval()
        UpperCamelCase       						=      model(_SCREAMING_SNAKE_CASE   )

        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    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )						->   Dict:



        """simple docstring"""






        UpperCamelCase       						=      MaskFormerSwinBackbone(config=_SCREAMING_SNAKE_CASE   )
        model.to(_SCREAMING_SNAKE_CASE   )
        model.eval()
        UpperCamelCase       						=      model(_SCREAMING_SNAKE_CASE   )

        # verify feature maps
        self.parent.assertEqual(len(result.feature_maps   )    ,	len(config.out_features   )   )
        self.parent.assertListEqual(list(result.feature_maps[0].shape   )    ,	[13, 16, 16, 16]   )

        # verify channels
        self.parent.assertEqual(len(model.channels   )    ,	len(config.out_features   )   )
        self.parent.assertListEqual(model.channels    ,	[16, 32, 64]   )

        # verify ValueError
        with self.parent.assertRaises(_SCREAMING_SNAKE_CASE   ):
              UpperCamelCase       						=      ["""stem"""]
              UpperCamelCase       						=      MaskFormerSwinBackbone(config=_SCREAMING_SNAKE_CASE   )


  def 						A__		(   self   )						->   str:



        """simple docstring"""






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






@require_torch
class        a_		(    lowerCamelCase			, lowerCamelCase			, unittest.TestCase       ):
  lowercase  	=   (
      (
          MaskFormerSwinModel,
          MaskFormerSwinBackbone,
      )
      if is_torch_available()
      else ()
  )
  lowercase  	=   {"""feature-extraction""": MaskFormerSwinModel} if is_torch_available() else {}
  lowercase  	=   False
  lowercase  	=   False
  lowercase  	=   False
  lowercase  	=   False
  lowercase  	=   False

  def 						A__		(   self   )						->   int:



        """simple docstring"""






        UpperCamelCase       						=      MaskFormerSwinModelTester(self   )
        UpperCamelCase       						=      ConfigTester(self    ,	config_class=_SCREAMING_SNAKE_CASE    ,	embed_dim=37   )

  @require_torch_multi_gpu
  @unittest.skip(
      reason=(
          """`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with"""
          """ `nn.DataParallel`"""
      )   )
  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        pass

  def 						A__		(   self   )						->   Dict:



        """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   )						->   int:



        """simple docstring"""






        return

  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        UpperCamelCase       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE   )

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



        """simple docstring"""






        UpperCamelCase       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*_SCREAMING_SNAKE_CASE   )

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



        """simple docstring"""






        pass

  @unittest.skip("""Swin does not support feedforward chunking"""   )
  def 						A__		(   self   )						->   Dict:



        """simple docstring"""






        pass

  def 						A__		(   self   )						->   Optional[int]:



        """simple docstring"""






        UpperCamelCase						,UpperCamelCase       						=      self.model_tester.prepare_config_and_inputs_for_common()

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

  def 						A__		(   self   )						->   int:



        """simple docstring"""






        UpperCamelCase						,UpperCamelCase       						=      self.model_tester.prepare_config_and_inputs_for_common()

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

  @unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn't support output_attentions"""   )
  def 						A__		(   self   )						->   Optional[int]:



        """simple docstring"""






        pass

  @unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""   )
  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        pass

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )						->   Optional[Any]:



        """simple docstring"""






        UpperCamelCase       						=      model_class(_SCREAMING_SNAKE_CASE   )
        model.to(_SCREAMING_SNAKE_CASE   )
        model.eval()

        with torch.no_grad():
              UpperCamelCase       						=      model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )   )

        UpperCamelCase       						=      outputs.hidden_states

        UpperCamelCase       						=      getattr(
            self.model_tester    ,	"""expected_num_hidden_layers"""    ,	len(self.model_tester.depths   ) + 1   )
        self.assertEqual(len(_SCREAMING_SNAKE_CASE   )    ,	_SCREAMING_SNAKE_CASE   )

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

  def 						A__		(   self   )						->   str:



        """simple docstring"""






        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(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

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

              self.check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

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



        """simple docstring"""






        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(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	(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(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	(padded_height, padded_width)   )

  @unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""   )
  def 						A__		(   self   )						->   Union[str, Any]:



        """simple docstring"""






        pass

  @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""   )
  def 						A__		(   self   )						->   str:



        """simple docstring"""






        pass

  @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""   )
  def 						A__		(   self   )						->   List[Any]:



        """simple docstring"""






        pass


  def 						A__		(   self   )						->   Any:



        """simple docstring"""






        UpperCamelCase						,UpperCamelCase       						=      self.model_tester.prepare_config_and_inputs_for_common()

        def set_nan_tensor_to_zero(_SCREAMING_SNAKE_CASE   ):
              UpperCamelCase       						=      0
              return t

        def check_equivalence(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE={}   ):
              with torch.no_grad():
                    UpperCamelCase       						=      model(**_SCREAMING_SNAKE_CASE    ,	return_dict=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE   )
                    UpperCamelCase       						=      model(**_SCREAMING_SNAKE_CASE    ,	return_dict=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE   ).to_tuple()

                    def recursive_check(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   ):
                          if isinstance(_SCREAMING_SNAKE_CASE    ,	(List, Tuple)   ):
                                for tuple_iterable_value, dict_iterable_value in zip(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   ):
                                      recursive_check(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
                          elif isinstance(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   ):
                                for tuple_iterable_value, dict_iterable_value in zip(
                                    tuple_object.values()    ,	dict_object.values()   ):
                                      recursive_check(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
                          elif tuple_object is None:
                                return
                          else:
                                self.assertTrue(
                                    torch.allclose(
                                        set_nan_tensor_to_zero(_SCREAMING_SNAKE_CASE   )    ,	set_nan_tensor_to_zero(_SCREAMING_SNAKE_CASE   )    ,	atol=1e-5   )    ,	msg=(
                                        """Tuple and dict output are not equal. Difference:"""
                                        F" {torch.max(torch.abs(tuple_object - dict_object   )   )}. Tuple has `nan`:"
                                        F" {torch.isnan(_SCREAMING_SNAKE_CASE   ).any()} and `inf`: {torch.isinf(_SCREAMING_SNAKE_CASE   )}. Dict has"
                                        F" `nan`: {torch.isnan(_SCREAMING_SNAKE_CASE   ).any()} and `inf`: {torch.isinf(_SCREAMING_SNAKE_CASE   )}."
                                    )    ,	)

                    recursive_check(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

        for model_class in self.all_model_classes:
              UpperCamelCase       						=      model_class(_SCREAMING_SNAKE_CASE   )
              model.to(_SCREAMING_SNAKE_CASE   )
              model.eval()

              UpperCamelCase       						=      self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
              UpperCamelCase       						=      self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
              check_equivalence(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

              UpperCamelCase       						=      self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	return_labels=_SCREAMING_SNAKE_CASE   )
              UpperCamelCase       						=      self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	return_labels=_SCREAMING_SNAKE_CASE   )
              check_equivalence(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

              UpperCamelCase       						=      self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
              UpperCamelCase       						=      self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
              check_equivalence(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	{"""output_hidden_states""": True}   )

              UpperCamelCase       						=      self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	return_labels=_SCREAMING_SNAKE_CASE   )
              UpperCamelCase       						=      self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	return_labels=_SCREAMING_SNAKE_CASE   )
              check_equivalence(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	{"""output_hidden_states""": True}   )






@require_torch
class        a_		(    unittest.TestCase			, lowerCamelCase       ):
  lowercase  	=   (MaskFormerSwinBackbone,) if is_torch_available() else ()
  lowercase  	=   MaskFormerSwinConfig

  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        UpperCamelCase       						=      MaskFormerSwinModelTester(self   )


  def 						A__		(   self   )						->   str:



        """simple docstring"""






        UpperCamelCase						,UpperCamelCase       						=      self.model_tester.prepare_config_and_inputs_for_common()
        UpperCamelCase       						=      inputs_dict["""pixel_values"""].shape[0]

        for backbone_class in self.all_model_classes:
              UpperCamelCase       						=      backbone_class(_SCREAMING_SNAKE_CASE   )
              backbone.to(_SCREAMING_SNAKE_CASE   )
              backbone.eval()

              UpperCamelCase       						=      backbone(**_SCREAMING_SNAKE_CASE   )

              # Test default outputs and verify feature maps
              self.assertIsInstance(outputs.feature_maps    ,	_SCREAMING_SNAKE_CASE   )
              self.assertTrue(len(outputs.feature_maps   ) == len(backbone.channels   )   )
              for feature_map, n_channels in zip(outputs.feature_maps    ,	backbone.channels   ):
                    self.assertTrue(feature_map.shape[:2]    ,	(batch_size, n_channels)   )
              self.assertIsNone(outputs.hidden_states   )
              self.assertIsNone(outputs.attentions   )

              # Test output_hidden_states=True
              UpperCamelCase       						=      backbone(**_SCREAMING_SNAKE_CASE    ,	output_hidden_states=_SCREAMING_SNAKE_CASE   )
              self.assertIsNotNone(outputs.hidden_states   )
              self.assertTrue(len(outputs.hidden_states   )    ,	len(backbone.stage_names   )   )
              # We skip the stem layer
              for hidden_states, n_channels in zip(outputs.hidden_states[1:]    ,	backbone.channels   ):
                    for hidden_state in hidden_states:
                          # Hidden states are in the format (batch_size, (height * width), n_channels)
                          UpperCamelCase						,UpperCamelCase						,UpperCamelCase       						=      hidden_state.shape
                          self.assertTrue((h_batch_size, h_n_channels)    ,	(batch_size, n_channels)   )

            # Test output_attentions=True
              if self.has_attentions:
                    UpperCamelCase       						=      backbone(**_SCREAMING_SNAKE_CASE    ,	output_attentions=_SCREAMING_SNAKE_CASE   )
                    self.assertIsNotNone(outputs.attentions   )
