






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 			SCREAMING_SNAKE_CASE      :
     '''simple docstring'''


     def __init__(					self							:						List[Any]       ,			UpperCAmelCase_							:						Union[str, Any]       ,			UpperCAmelCase_							:						Optional[Any]=13       ,			UpperCAmelCase_							:						List[Any]=32       ,			UpperCAmelCase_							:						Dict=2       ,			UpperCAmelCase_							:						Optional[Any]=3       ,			UpperCAmelCase_							:						int=16       ,			UpperCAmelCase_							:						Any=[1, 2, 1]       ,			UpperCAmelCase_							:						Any=[2, 2, 4]       ,			UpperCAmelCase_							:						Tuple=2       ,			UpperCAmelCase_							:						Union[str, Any]=2.0       ,			UpperCAmelCase_							:						Any=True       ,			UpperCAmelCase_							:						int=0.0       ,			UpperCAmelCase_							:						str=0.0       ,			UpperCAmelCase_							:						Any=0.1       ,			UpperCAmelCase_							:						List[Any]="gelu"       ,			UpperCAmelCase_							:						int=False       ,			UpperCAmelCase_							:						Optional[int]=True       ,			UpperCAmelCase_							:						Optional[Any]=0.02       ,			UpperCAmelCase_							:						int=1E-5       ,			UpperCAmelCase_							:						Dict=True       ,			UpperCAmelCase_							:						List[str]=None       ,			UpperCAmelCase_							:						List[Any]=True       ,			UpperCAmelCase_							:						Optional[Any]=10       ,			UpperCAmelCase_							:						Optional[Any]=8       ,			UpperCAmelCase_							:						Dict=["stage1", "stage2", "stage3"]       ,			UpperCAmelCase_							:						Optional[int]=[1, 2, 3]       ,			):
       SCREAMING_SNAKE_CASE							:   Any						    =     parent
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     batch_size
       SCREAMING_SNAKE_CASE							:   List[str]						    =     image_size
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     patch_size
       SCREAMING_SNAKE_CASE							:   List[str]						    =     num_channels
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     embed_dim
       SCREAMING_SNAKE_CASE							:   Tuple						    =     depths
       SCREAMING_SNAKE_CASE							:   List[str]						    =     num_heads
       SCREAMING_SNAKE_CASE							:   Any						    =     window_size
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     mlp_ratio
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     qkv_bias
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     hidden_dropout_prob
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE							:   List[str]						    =     drop_path_rate
       SCREAMING_SNAKE_CASE							:   int						    =     hidden_act
       SCREAMING_SNAKE_CASE							:   int						    =     use_absolute_embeddings
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     patch_norm
       SCREAMING_SNAKE_CASE							:   Dict						    =     layer_norm_eps
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     initializer_range
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     is_training
       SCREAMING_SNAKE_CASE							:   str						    =     scope
       SCREAMING_SNAKE_CASE							:   Dict						    =     use_labels
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     type_sequence_label_size
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     encoder_stride
       SCREAMING_SNAKE_CASE							:   int						    =     out_features
       SCREAMING_SNAKE_CASE							:   int						    =     out_indices


     def 					_A							(					self							:						Optional[Any]   ):
       SCREAMING_SNAKE_CASE							:   Dict						    =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

       SCREAMING_SNAKE_CASE							:   List[Any]						    =     None
       if self.use_labels:
         SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     ids_tensor([self.batch_size]       ,			self.type_sequence_label_size   )

       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     self.get_config()

       return config, pixel_values, labels


     def 					_A							(					self							:						List[str]   ):
       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							:						List[Any]       ,			UpperCAmelCase_							:						Dict       ,			UpperCAmelCase_							:						Union[str, Any]       ,			UpperCAmelCase_							:						List[Any]   ):
       SCREAMING_SNAKE_CASE							:   Dict						    =     MaskFormerSwinModel(config=UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()
       SCREAMING_SNAKE_CASE							:   Tuple						    =     model(UpperCAmelCase_   )

       SCREAMING_SNAKE_CASE							:   int						    =     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     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							:						List[Any]       ,			UpperCAmelCase_							:						Union[str, Any]       ,			UpperCAmelCase_							:						Dict       ,			UpperCAmelCase_							:						List[Any]   ):
       SCREAMING_SNAKE_CASE							:   int						    =     MaskFormerSwinBackbone(config=UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()
       SCREAMING_SNAKE_CASE							:   str						    =     model(UpperCAmelCase_   )

       # 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(UpperCAmelCase_   ):
         SCREAMING_SNAKE_CASE							:   List[Any]						    =     ["stem"]
         SCREAMING_SNAKE_CASE							:   List[str]						    =     MaskFormerSwinBackbone(config=UpperCAmelCase_   )






     def 					_A							(					self							:						Any   ):
       SCREAMING_SNAKE_CASE							:   int						    =     self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     config_and_inputs
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     {"pixel_values": pixel_values}
       return config, inputs_dict





@require_torch
class 			SCREAMING_SNAKE_CASE      (      lowerCAmelCase   ,		lowerCAmelCase   ,		unittest.TestCase       ):
     '''simple docstring'''


     UpperCamelCase_				:		Optional[Any]								=						(
         (
             MaskFormerSwinModel,
             MaskFormerSwinBackbone,
         )
         if is_torch_available()
         else ()
     )
     UpperCamelCase_				:		Tuple								=						{'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {}
     UpperCamelCase_				:		Any								=						False
     UpperCamelCase_				:		Tuple								=						False
     UpperCamelCase_				:		int								=						False
     UpperCamelCase_				:		int								=						False
     UpperCamelCase_				:		int								=						False


     def 					_A							(					self							:						List[str]   ):
       SCREAMING_SNAKE_CASE							:   List[str]						    =     MaskFormerSwinModelTester(self   )
       SCREAMING_SNAKE_CASE							:   Tuple						    =     ConfigTester(self       ,			config_class=UpperCAmelCase_       ,			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							:						Optional[Any]   ):
       pass


     def 					_A							(					self							:						Union[str, 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 					_A							(					self							:						Union[str, Any]   ):
       return


     def 					_A							(					self							:						Dict   ):
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCAmelCase_   )


     def 					_A							(					self							:						Any   ):
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*UpperCAmelCase_   )


     @unittest.skip("Swin does not use inputs_embeds"   )
     def 					_A							(					self							:						Tuple   ):
       pass


     @unittest.skip("Swin does not support feedforward chunking"   )
     def 					_A							(					self							:						Any   ):
       pass


     def 					_A							(					self							:						int   ):
       SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE							:   Any						    =     self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE							:   List[str]						    =     model_class(UpperCAmelCase_   )
         self.assertIsInstance(model.get_input_embeddings()       ,			(nn.Module)   )
         SCREAMING_SNAKE_CASE							:   List[str]						    =     model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(UpperCAmelCase_       ,			nn.Linear   )   )


     def 					_A							(					self							:						List[str]   ):
       SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE							:   List[str]						    =     self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE							:   Tuple						    =     model_class(UpperCAmelCase_   )
         SCREAMING_SNAKE_CASE							:   Dict						    =     inspect.signature(model.forward   )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         SCREAMING_SNAKE_CASE							:   List[str]						    =     [*signature.parameters.keys()]

         SCREAMING_SNAKE_CASE							:   Dict						    =     ["pixel_values"]
         self.assertListEqual(arg_names[:1]       ,			UpperCAmelCase_   )


     @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions"   )
     def 					_A							(					self							:						Optional[Any]   ):
       pass


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


     def 					_A							(					self							:						List[str]       ,			UpperCAmelCase_							:						Dict       ,			UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						Optional[Any]       ,			UpperCAmelCase_							:						Tuple   ):
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     model_class(UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()

       with torch.no_grad():
         SCREAMING_SNAKE_CASE							:   List[str]						    =     model(**self._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_   )   )

       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     outputs.hidden_states

       SCREAMING_SNAKE_CASE							:   List[Any]						    =     getattr(
           self.model_tester       ,			"expected_num_hidden_layers"       ,			len(self.model_tester.depths   ) + 1   )
       self.assertEqual(len(UpperCAmelCase_   )       ,			UpperCAmelCase_   )

       # Swin has a different seq_length
       SCREAMING_SNAKE_CASE							:   Any						    =     (
           config.patch_size
           if isinstance(config.patch_size       ,			collections.abc.Iterable   )
           else (config.patch_size, config.patch_size)
       )

       SCREAMING_SNAKE_CASE							:   Any						    =     (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							:						List[Any]   ):
       SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE							:   str						    =     self.model_tester.prepare_config_and_inputs_for_common()

       SCREAMING_SNAKE_CASE							:   List[Any]						    =     (
           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:
         SCREAMING_SNAKE_CASE							:   Dict						    =     True
         self.check_hidden_states_output(UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_   )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         SCREAMING_SNAKE_CASE							:   Optional[int]						    =     True

         self.check_hidden_states_output(UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_   )


     def 					_A							(					self							:						List[str]   ):
       SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     3

       SCREAMING_SNAKE_CASE							:   Dict						    =     (
           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)
       )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     (
           config.patch_size
           if isinstance(config.patch_size       ,			collections.abc.Iterable   )
           else (config.patch_size, config.patch_size)
       )

       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       SCREAMING_SNAKE_CASE							:   Dict						    =     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     True
         self.check_hidden_states_output(UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_       ,			(padded_height, padded_width)   )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         SCREAMING_SNAKE_CASE							:   Any						    =     True
         self.check_hidden_states_output(UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_       ,			(padded_height, padded_width)   )


     @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints"   )
     def 					_A							(					self							:						List[Any]   ):
       pass


     @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"   )
     def 					_A							(					self							:						int   ):
       pass


     @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"   )
     def 					_A							(					self							:						Optional[int]   ):
       pass






     def 					_A							(					self							:						Optional[int]   ):
       SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE							:   Optional[int]						    =     self.model_tester.prepare_config_and_inputs_for_common()

       def set_nan_tensor_to_zero(UpperCAmelCase_							:						Any   ):
         SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     0
         return t

       def check_equivalence(UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						List[str]       ,			UpperCAmelCase_							:						Optional[Any]       ,			UpperCAmelCase_							:						Optional[Any]={}   ):
         with torch.no_grad():
           SCREAMING_SNAKE_CASE							:   List[Any]						    =     model(**UpperCAmelCase_       ,			return_dict=UpperCAmelCase_       ,			**UpperCAmelCase_   )
           SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     model(**UpperCAmelCase_       ,			return_dict=UpperCAmelCase_       ,			**UpperCAmelCase_   ).to_tuple()

           def recursive_check(UpperCAmelCase_							:						str       ,			UpperCAmelCase_							:						Tuple   ):
             if isinstance(UpperCAmelCase_       ,			(List, Tuple)   ):
               for tuple_iterable_value, dict_iterable_value in zip(UpperCAmelCase_       ,			UpperCAmelCase_   ):
                 recursive_check(UpperCAmelCase_       ,			UpperCAmelCase_   )
             elif isinstance(UpperCAmelCase_       ,			UpperCAmelCase_   ):
               for tuple_iterable_value, dict_iterable_value in zip(
                   tuple_object.values()       ,			dict_object.values()   ):
                 recursive_check(UpperCAmelCase_       ,			UpperCAmelCase_   )
             elif tuple_object is None:
               return
             else:
               self.assertTrue(
                   torch.allclose(
                       set_nan_tensor_to_zero(UpperCAmelCase_   )       ,			set_nan_tensor_to_zero(UpperCAmelCase_   )       ,			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(UpperCAmelCase_   ).any()} and `inf`: {torch.isinf(UpperCAmelCase_   )}. Dict has'''
                       f''' `nan`: {torch.isnan(UpperCAmelCase_   ).any()} and `inf`: {torch.isinf(UpperCAmelCase_   )}.'''
                   )       ,			)

           recursive_check(UpperCAmelCase_       ,			UpperCAmelCase_   )

       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE							:   Any						    =     model_class(UpperCAmelCase_   )
         model.to(UpperCAmelCase_   )
         model.eval()

         SCREAMING_SNAKE_CASE							:   Tuple						    =     self._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_   )
         SCREAMING_SNAKE_CASE							:   Any						    =     self._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_   )
         check_equivalence(UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_   )

         SCREAMING_SNAKE_CASE							:   Dict						    =     self._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_       ,			return_labels=UpperCAmelCase_   )
         SCREAMING_SNAKE_CASE							:   Dict						    =     self._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_       ,			return_labels=UpperCAmelCase_   )
         check_equivalence(UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_   )

         SCREAMING_SNAKE_CASE							:   List[str]						    =     self._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_   )
         SCREAMING_SNAKE_CASE							:   List[str]						    =     self._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_   )
         check_equivalence(UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_       ,			{"output_hidden_states": True}   )

         SCREAMING_SNAKE_CASE							:   int						    =     self._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_       ,			return_labels=UpperCAmelCase_   )
         SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_       ,			return_labels=UpperCAmelCase_   )
         check_equivalence(UpperCAmelCase_       ,			UpperCAmelCase_       ,			UpperCAmelCase_       ,			{"output_hidden_states": True}   )





@require_torch
class 			SCREAMING_SNAKE_CASE      (      unittest.TestCase   ,		lowerCAmelCase       ):
     '''simple docstring'''


     UpperCamelCase_				:		List[Any]								=						(MaskFormerSwinBackbone,) if is_torch_available() else ()
     UpperCamelCase_				:		Optional[int]								=						MaskFormerSwinConfig


     def 					_A							(					self							:						str   ):
       SCREAMING_SNAKE_CASE							:   str						    =     MaskFormerSwinModelTester(self   )






     def 					_A							(					self							:						Dict   ):
       SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE							:   int						    =     inputs_dict["pixel_values"].shape[0]

       for backbone_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE							:   List[Any]						    =     backbone_class(UpperCAmelCase_   )
         backbone.to(UpperCAmelCase_   )
         backbone.eval()

         SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     backbone(**UpperCAmelCase_   )

         # Test default outputs and verify feature maps
         self.assertIsInstance(outputs.feature_maps       ,			UpperCAmelCase_   )
         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
         SCREAMING_SNAKE_CASE							:   Optional[int]						    =     backbone(**UpperCAmelCase_       ,			output_hidden_states=UpperCAmelCase_   )
         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)
             SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE    ,	SCREAMING_SNAKE_CASE							:   str						    =     hidden_state.shape
             self.assertTrue((h_batch_size, h_n_channels)       ,			(batch_size, n_channels)   )

            # Test output_attentions=True
         if self.has_attentions:
           SCREAMING_SNAKE_CASE							:   Any						    =     backbone(**UpperCAmelCase_       ,			output_attentions=UpperCAmelCase_   )
           self.assertIsNotNone(outputs.attentions   )












def        __UpperCAmelCase						(							lowerCamelCase_ :     str  )       ->  bool:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : Any					  =      0
			for ch in input_str:
						SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      ord(lowerCamelCase_  )
						SCREAMING_SNAKE_CASE_   : Tuple					  =      pow(2  ,							lowerCamelCase_  )

						# If we already turned on bit for current character's unicode
						if bitmap >> ch_unicode & 1 == 1:
									return False
						bitmap |= ch_bit_index_on
			return True


if __name__ == "__main__":
						import doctest

						doctest.testmod()



