code: 
  '''simple docstring'''
  
  
  
  
  
  import warnings
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  import torch
  from PIL import Image
  
  from .configuration_utils import ConfigMixin, register_to_config
  from .utils import CONFIG_NAME, PIL_INTERPOLATION, deprecate
  
  
  
  class  lowerCAmelCase__   (       UpperCamelCase       ):
  
  
  
   '''simple docstring'''
  
  
  
  
  
  
   _UpperCamelCase						= CONFIG_NAME
  
   @register_to_config
   def __init__(self  : List[str]	, lowerCAmelCase_  : bool = True	, lowerCAmelCase_  : int = 8	, lowerCAmelCase_  : str = "lanczos"	, lowerCAmelCase_  : bool = True	, lowerCAmelCase_  : bool = False	, )   ->       Optional[Any]:
         super().__init__()
  
   @staticmethod
   def 		_lowerCamelCase	(lowerCAmelCase_  : np.ndarray    )   ->       PIL.Image.Image:
         if images.ndim == 3:
               snake_case_						       =							images[None, ...]
         snake_case_						       =							(images * 2_55).round().astype("uint8"    )
         if images.shape[-1] == 1:
               # special case for grayscale (single channel) images
               snake_case_						       =							[Image.fromarray(image.squeeze()	, mode="L"    ) for image in images]
         else:
               snake_case_						       =							[Image.fromarray(lowerCAmelCase_    ) for image in images]
  
         return pil_images
  
   @staticmethod
   def 		_lowerCamelCase	(lowerCAmelCase_  : Union[List[PIL.Image.Image], PIL.Image.Image]    )   ->       np.ndarray:
         if not isinstance(lowerCAmelCase_	, lowerCAmelCase_    ):
               snake_case_						       =							[images]
         snake_case_						       =							[np.array(lowerCAmelCase_    ).astype(np.floataa    ) / 255.0 for image in images]
         snake_case_						       =							np.stack(lowerCAmelCase_	, axis=0    )
  
         return images
  
   @staticmethod
   def 		_lowerCamelCase	(lowerCAmelCase_  : np.ndarray    )   ->       torch.FloatTensor:
         if images.ndim == 3:
               snake_case_						       =							images[..., None]
  
         snake_case_						       =							torch.from_numpy(images.transpose(0	, 3	, 1	, 2    )    )
         return images
  
   @staticmethod
   def 		_lowerCamelCase	(lowerCAmelCase_  : torch.FloatTensor    )   ->       np.ndarray:
         snake_case_						       =							images.cpu().permute(0	, 2	, 3	, 1    ).float().numpy()
         return images
  
   @staticmethod
   def 		_lowerCamelCase	(lowerCAmelCase_  : List[Any]    )   ->       Optional[Any]:
         return 2.0 * images - 1.0
  
   @staticmethod
   def 		_lowerCamelCase	(lowerCAmelCase_  : int    )   ->       int:
         return (images / 2 + 0.5).clamp(0	, 1    )
  
   @staticmethod
   def 		_lowerCamelCase	(lowerCAmelCase_  : PIL.Image.Image    )   ->       PIL.Image.Image:
         snake_case_						       =							image.convert("RGB"    )
         return image
  
   def 		_lowerCamelCase	(self  : Any	, lowerCAmelCase_  : PIL.Image.Image	, lowerCAmelCase_  : Optional[int] = None	, lowerCAmelCase_  : Optional[int] = None	, )   ->       PIL.Image.Image:
         if height is None:
               snake_case_						       =							image.height
         if width is None:
               snake_case_						       =							image.width
  
         snake_case_       ,	snake_case_						       =							(
             x - x % self.config.vae_scale_factor for x in (width, height)
         )  # resize to integer multiple of vae_scale_factor
         snake_case_						       =							image.resize((width, height)	, resample=PIL_INTERPOLATION[self.config.resample]    )
         return image
  
   def 		_lowerCamelCase	(self  : Dict	, lowerCAmelCase_  : Union[torch.FloatTensor, PIL.Image.Image, np.ndarray]	, lowerCAmelCase_  : Optional[int] = None	, lowerCAmelCase_  : Optional[int] = None	, )   ->       torch.Tensor:
         snake_case_						       =							(PIL.Image.Image, np.ndarray, torch.Tensor)
         if isinstance(lowerCAmelCase_	, lowerCAmelCase_    ):
               snake_case_						       =							[image]
         elif not (isinstance(lowerCAmelCase_	, lowerCAmelCase_    ) and all(isinstance(lowerCAmelCase_	, lowerCAmelCase_    ) for i in image    )):
               raise ValueError(
                   f'''Input is in incorrect format: {[type(lowerCAmelCase_    ) for i in image]}. Currently, we only support {', '.join(lowerCAmelCase_    )}'''    )
  
         if isinstance(image[0]	, PIL.Image.Image    ):
               if self.config.do_convert_rgb:
                     snake_case_						       =							[self.convert_to_rgb(lowerCAmelCase_    ) for i in image]
               if self.config.do_resize:
                     snake_case_						       =							[self.resize(lowerCAmelCase_	, lowerCAmelCase_	, lowerCAmelCase_    ) for i in image]
               snake_case_						       =							self.pil_to_numpy(lowerCAmelCase_    )  # to np
               snake_case_						       =							self.numpy_to_pt(lowerCAmelCase_    )  # to pt
  
         elif isinstance(image[0]	, np.ndarray    ):
               snake_case_						       =							np.concatenate(lowerCAmelCase_	, axis=0    ) if image[0].ndim == 4 else np.stack(lowerCAmelCase_	, axis=0    )
               snake_case_						       =							self.numpy_to_pt(lowerCAmelCase_    )
               snake_case_       ,	snake_case_       ,	snake_case_       ,	snake_case_						       =							image.shape
               if self.config.do_resize and (
                   height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
               ):
                     raise ValueError(
                         f'''Currently we only support resizing for PIL image - please resize your numpy array to be divisible by {self.config.vae_scale_factor}'''
                         f'''currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'''    )
  
         elif isinstance(image[0]	, torch.Tensor    ):
               snake_case_						       =							torch.cat(lowerCAmelCase_	, axis=0    ) if image[0].ndim == 4 else torch.stack(lowerCAmelCase_	, axis=0    )
               snake_case_       ,	snake_case_       ,	snake_case_       ,	snake_case_						       =							image.shape
  
               # don't need any preprocess if the image is latents
               if channel == 4:
                     return image
  
               if self.config.do_resize and (
                   height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
               ):
                     raise ValueError(
                         f'''Currently we only support resizing for PIL image - please resize your pytorch tensor to be divisible by {self.config.vae_scale_factor}'''
                         f'''currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'''    )
  
          # expected range [0,1], normalize to [-1,1]
         snake_case_						       =							self.config.do_normalize
         if image.min() < 0:
               warnings.warn(
                   "Passing `image` as torch tensor with value range in [-1,1] is deprecated. The expected value range for image tensor is [0,1] "
                   f'''when passing as pytorch tensor or numpy Array. You passed `image` with value range [{image.min()},{image.max()}]'''	, lowerCAmelCase_	, )
               snake_case_						       =							False
  
         if do_normalize:
               snake_case_						       =							self.normalize(lowerCAmelCase_    )
  
         return image
  
  
   def 		_lowerCamelCase	(self  : List[str]	, lowerCAmelCase_  : torch.FloatTensor	, lowerCAmelCase_  : str = "pil"	, lowerCAmelCase_  : Optional[List[bool]] = None	, )   ->       Tuple:
         if not isinstance(lowerCAmelCase_	, torch.Tensor    ):
               raise ValueError(
                   f'''Input for postprocessing is in incorrect format: {type(lowerCAmelCase_    )}. We only support pytorch tensor'''    )
         if output_type not in ["latent", "pt", "np", "pil"]:
               snake_case_						       =							(
                   f'''the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '''
                   "`pil`, `np`, `pt`, `latent`"
               )
               deprecate("Unsupported output_type"	, "1.0.0"	, lowerCAmelCase_	, standard_warn=lowerCAmelCase_    )
               snake_case_						       =							"np"
  
         if output_type == "latent":
               return image
  
         if do_denormalize is None:
               snake_case_						       =							[self.config.do_normalize] * image.shape[0]
  
         snake_case_						       =							torch.stack(
             [self.denormalize(image[i]    ) if do_denormalize[i] else image[i] for i in range(image.shape[0]    )]    )
  
         if output_type == "pt":
               return image
  
         snake_case_						       =							self.pt_to_numpy(lowerCAmelCase_    )
  
         if output_type == "np":
               return image
  
         if output_type == "pil":
               return self.numpy_to_pil(lowerCAmelCase_    )
  
  
  
  class  lowerCAmelCase__   (       UpperCamelCase       ):
  
  
  
   '''simple docstring'''
  
  
  
  
  
  
   _UpperCamelCase						= CONFIG_NAME
  
   @register_to_config
   def __init__(self  : str	, lowerCAmelCase_  : bool = True	, lowerCAmelCase_  : int = 8	, lowerCAmelCase_  : str = "lanczos"	, lowerCAmelCase_  : bool = True	, )   ->       Union[str, Any]:
         super().__init__()
  
   @staticmethod
   def 		_lowerCamelCase	(lowerCAmelCase_  : Optional[Any]    )   ->       List[str]:
         if images.ndim == 3:
               snake_case_						       =							images[None, ...]
         snake_case_						       =							(images * 2_55).round().astype("uint8"    )
         if images.shape[-1] == 1:
               # special case for grayscale (single channel) images
               snake_case_						       =							[Image.fromarray(image.squeeze()	, mode="L"    ) for image in images]
         else:
               snake_case_						       =							[Image.fromarray(image[:, :, :3]    ) for image in images]
  
         return pil_images
  
   @staticmethod
   def 		_lowerCamelCase	(lowerCAmelCase_  : Dict    )   ->       Optional[int]:
         return image[:, :, 1] * 2**8 + image[:, :, 2]
  
   def 		_lowerCamelCase	(self  : Dict	, lowerCAmelCase_  : str    )   ->       Any:
         if images.ndim == 3:
               snake_case_						       =							images[None, ...]
         snake_case_						       =							images[:, :, :, 3:]
         if images.shape[-1] == 6:
               snake_case_						       =							(images_depth * 2_55).round().astype("uint8"    )
               snake_case_						       =							[
                   Image.fromarray(self.rgblike_to_depthmap(lowerCAmelCase_    )	, mode="I;16"    ) for image_depth in images_depth
               ]
         elif images.shape[-1] == 4:
               snake_case_						       =							(images_depth * 6_55_35.0).astype(np.uintaa    )
               snake_case_						       =							[Image.fromarray(lowerCAmelCase_	, mode="I;16"    ) for image_depth in images_depth]
         else:
               raise Exception("Not supported"    )
  
         return pil_images
  
  
   def 		_lowerCamelCase	(self  : Tuple	, lowerCAmelCase_  : torch.FloatTensor	, lowerCAmelCase_  : str = "pil"	, lowerCAmelCase_  : Optional[List[bool]] = None	, )   ->       int:
         if not isinstance(lowerCAmelCase_	, torch.Tensor    ):
               raise ValueError(
                   f'''Input for postprocessing is in incorrect format: {type(lowerCAmelCase_    )}. We only support pytorch tensor'''    )
         if output_type not in ["latent", "pt", "np", "pil"]:
               snake_case_						       =							(
                   f'''the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '''
                   "`pil`, `np`, `pt`, `latent`"
               )
               deprecate("Unsupported output_type"	, "1.0.0"	, lowerCAmelCase_	, standard_warn=lowerCAmelCase_    )
               snake_case_						       =							"np"
  
         if do_denormalize is None:
               snake_case_						       =							[self.config.do_normalize] * image.shape[0]
  
         snake_case_						       =							torch.stack(
             [self.denormalize(image[i]    ) if do_denormalize[i] else image[i] for i in range(image.shape[0]    )]    )
  
         snake_case_						       =							self.pt_to_numpy(lowerCAmelCase_    )
  
         if output_type == "np":
               if image.shape[-1] == 6:
                     snake_case_						       =							np.stack([self.rgblike_to_depthmap(im[:, :, 3:]    ) for im in image]	, axis=0    )
               else:
                     snake_case_						       =							image[:, :, :, 3:]
               return image[:, :, :, :3], image_depth
  
         if output_type == "pil":
               return self.numpy_to_pil(lowerCAmelCase_    ), self.numpy_to_depth(lowerCAmelCase_    )
         else:
               raise Exception(f'''This type {output_type} is not supported'''    )
  
  
style_context: 
  '''simple docstring'''
  
  
  
  
  
  from __future__ import annotations
  
  import inspect
  import unittest
  
  import numpy as np
  
  from transformers import SwinConfig
  from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
  from transformers.utils import cached_property, is_tf_available, is_vision_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
       import tensorflow as tf
  
       from transformers.models.swin.modeling_tf_swin import (
           TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
           TFSwinForImageClassification,
           TFSwinForMaskedImageModeling,
           TFSwinModel,
       )
  
  
  if is_vision_available():
       from PIL import Image
  
       from transformers import AutoImageProcessor
  
  
  
  class  lowerCAmelCase__   :
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    def __init__(self  : Optional[int]	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : Any=13	, lowerCAmelCase_  : int=32	, lowerCAmelCase_  : int=2	, lowerCAmelCase_  : List[str]=3	, lowerCAmelCase_  : Any=16	, lowerCAmelCase_  : Tuple=[1, 2, 1]	, lowerCAmelCase_  : List[str]=[2, 2, 4]	, lowerCAmelCase_  : Dict=2	, lowerCAmelCase_  : str=2.0	, lowerCAmelCase_  : int=True	, lowerCAmelCase_  : List[Any]=0.0	, lowerCAmelCase_  : List[Any]=0.0	, lowerCAmelCase_  : List[Any]=0.1	, lowerCAmelCase_  : Optional[int]="gelu"	, lowerCAmelCase_  : Dict=False	, lowerCAmelCase_  : str=True	, lowerCAmelCase_  : Optional[int]=0.02	, lowerCAmelCase_  : List[str]=1E-5	, lowerCAmelCase_  : Dict=True	, lowerCAmelCase_  : Tuple=None	, lowerCAmelCase_  : List[str]=True	, lowerCAmelCase_  : str=10	, lowerCAmelCase_  : Tuple=8	, )   ->       None:
          snake_case_						       =							parent
          snake_case_						       =							batch_size
          snake_case_						       =							image_size
          snake_case_						       =							patch_size
          snake_case_						       =							num_channels
          snake_case_						       =							embed_dim
          snake_case_						       =							depths
          snake_case_						       =							num_heads
          snake_case_						       =							window_size
          snake_case_						       =							mlp_ratio
          snake_case_						       =							qkv_bias
          snake_case_						       =							hidden_dropout_prob
          snake_case_						       =							attention_probs_dropout_prob
          snake_case_						       =							drop_path_rate
          snake_case_						       =							hidden_act
          snake_case_						       =							use_absolute_embeddings
          snake_case_						       =							patch_norm
          snake_case_						       =							layer_norm_eps
          snake_case_						       =							initializer_range
          snake_case_						       =							is_training
          snake_case_						       =							scope
          snake_case_						       =							use_labels
          snake_case_						       =							type_sequence_label_size
          snake_case_						       =							encoder_stride
  
    def 		_lowerCamelCase	(self  : Optional[int]    )   ->       Dict:
          snake_case_						       =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )
  
          snake_case_						       =							None
          if self.use_labels:
                snake_case_						       =							ids_tensor([self.batch_size]	, self.type_sequence_label_size    )
  
          snake_case_						       =							self.get_config()
  
          return config, pixel_values, labels
  
    def 		_lowerCamelCase	(self  : str    )   ->       Tuple:
          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	, )
  
    def 		_lowerCamelCase	(self  : Optional[int]	, lowerCAmelCase_  : int	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : Optional[int]    )   ->       Any:
          snake_case_						       =							TFSwinModel(config=lowerCAmelCase_    )
          snake_case_						       =							model(lowerCAmelCase_    )
  
          snake_case_						       =							((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
          snake_case_						       =							int(config.embed_dim * 2 ** (len(config.depths    ) - 1)    )
  
          self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, expected_seq_len, expected_dim)    )
  
    def 		_lowerCamelCase	(self  : Optional[Any]	, lowerCAmelCase_  : Optional[int]	, lowerCAmelCase_  : Dict	, lowerCAmelCase_  : Optional[int]    )   ->       Optional[int]:
          snake_case_						       =							TFSwinForMaskedImageModeling(config=lowerCAmelCase_    )
          snake_case_						       =							model(lowerCAmelCase_    )
          self.parent.assertEqual(
              result.logits.shape	, (self.batch_size, self.num_channels, self.image_size, self.image_size)    )
  
          # test greyscale images
          snake_case_						       =							1
          snake_case_						       =							TFSwinForMaskedImageModeling(lowerCAmelCase_    )
  
          snake_case_						       =							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
          snake_case_						       =							model(lowerCAmelCase_    )
          self.parent.assertEqual(result.logits.shape	, (self.batch_size, 1, self.image_size, self.image_size)    )
  
    def 		_lowerCamelCase	(self  : Dict	, lowerCAmelCase_  : Tuple	, lowerCAmelCase_  : List[str]	, lowerCAmelCase_  : Optional[Any]    )   ->       Tuple:
          snake_case_						       =							self.type_sequence_label_size
          snake_case_						       =							TFSwinForImageClassification(lowerCAmelCase_    )
          snake_case_						       =							model(lowerCAmelCase_	, labels=lowerCAmelCase_    )
          self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.type_sequence_label_size)    )
  
          # test greyscale images
          snake_case_						       =							1
          snake_case_						       =							TFSwinForImageClassification(lowerCAmelCase_    )
          snake_case_						       =							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
          snake_case_						       =							model(lowerCAmelCase_    )
          self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.type_sequence_label_size)    )
  
  
    def 		_lowerCamelCase	(self  : Optional[Any]    )   ->       str:
          snake_case_						       =							self.prepare_config_and_inputs()
          snake_case_       ,	snake_case_       ,	snake_case_						       =							config_and_inputs
          snake_case_						       =							{"pixel_values": pixel_values}
          return config, inputs_dict
  
  
  
  @require_tf
  class  lowerCAmelCase__   (       UpperCamelCase					,							UpperCamelCase					,							unittest.TestCase       ):
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    _UpperCamelCase						= (
        (
            TFSwinModel,
            TFSwinForImageClassification,
            TFSwinForMaskedImageModeling,
        )
        if is_tf_available()
        else ()
    )
    _UpperCamelCase						= (
        {'feature-extraction': TFSwinModel, 'image-classification': TFSwinForImageClassification}
        if is_tf_available()
        else {}
    )
  
    _UpperCamelCase						= False
    _UpperCamelCase						= False
    _UpperCamelCase						= False
    _UpperCamelCase						= False
  
    def 		_lowerCamelCase	(self  : Any    )   ->       List[Any]:
          snake_case_						       =							TFSwinModelTester(self    )
          snake_case_						       =							ConfigTester(self	, config_class=lowerCAmelCase_	, embed_dim=37    )
  
    def 		_lowerCamelCase	(self  : Optional[int]    )   ->       Optional[Any]:
          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 		_lowerCamelCase	(self  : List[Any]    )   ->       List[str]:
          return
  
    def 		_lowerCamelCase	(self  : Any    )   ->       Dict:
          snake_case_						       =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowerCAmelCase_    )
  
    def 		_lowerCamelCase	(self  : int    )   ->       Any:
          snake_case_						       =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_    )
  
    def 		_lowerCamelCase	(self  : Tuple    )   ->       Optional[Any]:
          snake_case_						       =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_    )
  
    @unittest.skip(reason="Swin does not use inputs_embeds"    )
    def 		_lowerCamelCase	(self  : Optional[Any]    )   ->       Union[str, Any]:
          pass
  
    def 		_lowerCamelCase	(self  : List[str]    )   ->       Any:
          snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
  
          for model_class in self.all_model_classes:
                snake_case_						       =							model_class(lowerCAmelCase_    )
                self.assertIsInstance(model.get_input_embeddings()	, tf.keras.layers.Layer    )
                snake_case_						       =							model.get_output_embeddings()
                self.assertTrue(x is None or isinstance(lowerCAmelCase_	, tf.keras.layers.Dense    )    )
  
    def 		_lowerCamelCase	(self  : Dict    )   ->       Dict:
          snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
  
          for model_class in self.all_model_classes:
                snake_case_						       =							model_class(lowerCAmelCase_    )
                snake_case_						       =							inspect.signature(model.call    )
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                snake_case_						       =							[*signature.parameters.keys()]
  
                snake_case_						       =							["pixel_values"]
                self.assertListEqual(arg_names[:1]	, lowerCAmelCase_    )
  
    def 		_lowerCamelCase	(self  : Dict    )   ->       Any:
          snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
          snake_case_						       =							True
  
          for model_class in self.all_model_classes:
                snake_case_						       =							True
                snake_case_						       =							False
                snake_case_						       =							True
                snake_case_						       =							model_class(lowerCAmelCase_    )
                snake_case_						       =							model(**self._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_    )    )
                snake_case_						       =							outputs.attentions
                snake_case_						       =							len(self.model_tester.depths    )
                self.assertEqual(len(lowerCAmelCase_    )	, lowerCAmelCase_    )
  
                # check that output_attentions also work using config
                del inputs_dict["output_attentions"]
                snake_case_						       =							True
                snake_case_						       =							config.window_size**2
                snake_case_						       =							model_class(lowerCAmelCase_    )
                snake_case_						       =							model(**self._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_    )    )
                snake_case_						       =							outputs.attentions
                self.assertEqual(len(lowerCAmelCase_    )	, lowerCAmelCase_    )
  
                self.assertListEqual(
                    list(attentions[0].shape[-3:]    )	, [self.model_tester.num_heads[0], window_size_squared, window_size_squared]	, )
                snake_case_						       =							len(lowerCAmelCase_    )
  
                # Check attention is always last and order is fine
                snake_case_						       =							True
                snake_case_						       =							True
                snake_case_						       =							model_class(lowerCAmelCase_    )
                snake_case_						       =							model(**self._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_    )    )
  
                if hasattr(self.model_tester	, "num_hidden_states_types"    ):
                      snake_case_						       =							self.model_tester.num_hidden_states_types
                else:
                      # also another +1 for reshaped_hidden_states
                      snake_case_						       =							2
                self.assertEqual(out_len + added_hidden_states	, len(lowerCAmelCase_    )    )
  
                snake_case_						       =							outputs.attentions
  
                self.assertEqual(len(lowerCAmelCase_    )	, lowerCAmelCase_    )
  
                self.assertListEqual(
                    list(self_attentions[0].shape[-3:]    )	, [self.model_tester.num_heads[0], window_size_squared, window_size_squared]	, )
  
    def 		_lowerCamelCase	(self  : Optional[int]	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : int	, lowerCAmelCase_  : Dict	, lowerCAmelCase_  : List[Any]    )   ->       Optional[int]:
          snake_case_						       =							model_class(lowerCAmelCase_    )
          snake_case_						       =							model(**self._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_    )    )
          snake_case_						       =							outputs.hidden_states
  
          snake_case_						       =							getattr(
              self.model_tester	, "expected_num_hidden_layers"	, len(self.model_tester.depths    ) + 1    )
          self.assertEqual(len(lowerCAmelCase_    )	, lowerCAmelCase_    )
  
          # Swin has a different seq_length
          snake_case_						       =							to_atuple(config.patch_size    )
  
          snake_case_						       =							(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
  
          self.assertListEqual(
              list(hidden_states[0].shape[-2:]    )	, [num_patches, self.model_tester.embed_dim]	, )
  
          snake_case_						       =							outputs.reshaped_hidden_states
          self.assertEqual(len(lowerCAmelCase_    )	, lowerCAmelCase_    )
  
          snake_case_       ,	snake_case_       ,	snake_case_       ,	snake_case_						       =							reshaped_hidden_states[0].shape
  
          snake_case_						       =							tf.reshape(reshaped_hidden_states[0]	, (batch_size, num_channels, height * width)    )
          snake_case_						       =							tf.transpose(lowerCAmelCase_	, (0, 2, 1)    )
  
          self.assertListEqual(
              list(reshaped_hidden_states.shape[-2:]    )	, [num_patches, self.model_tester.embed_dim]	, )
  
    def 		_lowerCamelCase	(self  : Dict    )   ->       str:
          snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
  
          snake_case_						       =							to_atuple(self.model_tester.image_size    )
  
          for model_class in self.all_model_classes:
                snake_case_						       =							True
                self.check_hidden_states_output(lowerCAmelCase_	, lowerCAmelCase_	, lowerCAmelCase_	, lowerCAmelCase_    )
  
                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                snake_case_						       =							True
  
                self.check_hidden_states_output(lowerCAmelCase_	, lowerCAmelCase_	, lowerCAmelCase_	, lowerCAmelCase_    )
  
    def 		_lowerCamelCase	(self  : Tuple    )   ->       List[Any]:
          snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
          snake_case_						       =							3
  
          snake_case_						       =							to_atuple(self.model_tester.image_size    )
          snake_case_						       =							to_atuple(config.patch_size    )
  
          snake_case_						       =							image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          snake_case_						       =							image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])
  
          for model_class in self.all_model_classes:
                snake_case_						       =							True
                self.check_hidden_states_output(lowerCAmelCase_	, lowerCAmelCase_	, lowerCAmelCase_	, (padded_height, padded_width)    )
  
                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                snake_case_						       =							True
                self.check_hidden_states_output(lowerCAmelCase_	, lowerCAmelCase_	, lowerCAmelCase_	, (padded_height, padded_width)    )
  
  
    @slow
    def 		_lowerCamelCase	(self  : Any    )   ->       List[str]:
          for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                snake_case_						       =							TFSwinModel.from_pretrained(lowerCAmelCase_    )
                self.assertIsNotNone(lowerCAmelCase_    )
  
  
  
  @require_vision
  @require_tf
  class  lowerCAmelCase__   (       unittest.TestCase       ):
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    @cached_property
    def 		_lowerCamelCase	(self  : Dict    )   ->       str:
          return (
              AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224"    )
              if is_vision_available()
              else None
          )
  
  
    @slow
    def 		_lowerCamelCase	(self  : Optional[int]    )   ->       str:
          snake_case_						       =							TFSwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224"    )
          snake_case_						       =							self.default_image_processor
  
          snake_case_						       =							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
          snake_case_						       =							image_processor(images=lowerCAmelCase_	, return_tensors="tf"    )
  
          # forward pass
          snake_case_						       =							model(lowerCAmelCase_    )
  
          # verify the logits
          snake_case_						       =							tf.TensorShape((1, 10_00)    )
          self.assertEqual(outputs.logits.shape	, lowerCAmelCase_    )
          snake_case_						       =							tf.constant([-0.0_948, -0.6_454, -0.0_921]    )
          self.assertTrue(np.allclose(outputs.logits[0, :3]	, lowerCAmelCase_	, atol=1E-4    )    )
  
  