


'''simple docstring'''


def      snake_case_  (    SCREAMING_SNAKE_CASE__	):







				"""simple docstring"""





				if isinstance(SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	):
								raise TypeError("""'float' object cannot be interpreted as an integer"""	)
				if isinstance(SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__	):
								raise TypeError("""'str' object cannot be interpreted as an integer"""	)

				if num == 0:
								return "0b0"

				_SCREAMING_SNAKE_CASE					:			str							= False

				if num < 0:
								_SCREAMING_SNAKE_CASE					:			Any							= True
								_SCREAMING_SNAKE_CASE					:			str							= -num

				_SCREAMING_SNAKE_CASE					:			list[int]							= []
				while num > 0:
								binary.insert(0				, num % 2	)
								num >>= 1

				if negative:
								return "-0b" + "".join(str(SCREAMING_SNAKE_CASE__	) for e in binary	)

				return "0b" + "".join(str(SCREAMING_SNAKE_CASE__	) for e in binary	)


if __name__ == "__main__":
				import doctest

				doctest.testmod()








'''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        lowercase__    :





							'''simple docstring'''


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






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

											_SCREAMING_SNAKE_CASE					:			Any							= None
											if self.use_labels:
															_SCREAMING_SNAKE_CASE					:			int							= ids_tensor([self.batch_size]       ,   self.type_sequence_label_size    )

											_SCREAMING_SNAKE_CASE					:			List[str]							= self.get_config()

											return config, pixel_values, labels






							def UpperCAmelCase_      (       self    ):
											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 UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			Any							= MaskFormerSwinModel(config=__snake_case    )
											model.to(__snake_case    )
											model.eval()
											_SCREAMING_SNAKE_CASE					:			Any							= model(__snake_case    )

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






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= self.prepare_config_and_inputs()
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[str]							= config_and_inputs
											_SCREAMING_SNAKE_CASE					:			List[str]							= {"""pixel_values""": pixel_values}
											return config, inputs_dict





@require_torch
class        lowercase__    (		_snake_case	,	_snake_case	,	unittest.TestCase   ):





							'''simple docstring'''


							A_				: Any       =    (
							    (
							        MaskFormerSwinModel,
							        MaskFormerSwinBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							A_				: List[Any]       =    {"""feature-extraction""": MaskFormerSwinModel} if is_torch_available() else {}
							A_				: Optional[Any]       =    False
							A_				: Dict       =    False
							A_				: Optional[int]       =    False
							A_				: Union[str, Any]       =    False
							A_				: Union[str, Any]       =    False






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			str							= MaskFormerSwinModelTester(self    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= ConfigTester(self       ,   config_class=__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 UpperCAmelCase_      (       self    ):
											pass






							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    ):
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Tuple							= self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_backbone(*__snake_case    )






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






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






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.model_tester.prepare_config_and_inputs_for_common()

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






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			int							= self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= model_class(__snake_case    )
															_SCREAMING_SNAKE_CASE					:			List[Any]							= inspect.signature(model.forward    )
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= [*signature.parameters.keys()]

															_SCREAMING_SNAKE_CASE					:			str							= ["""pixel_values"""]
															self.assertListEqual(arg_names[:1]       ,   __snake_case    )






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






							@unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""    )
							def UpperCAmelCase_      (       self    ):
											pass






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			List[str]							= model_class(__snake_case    )
											model.to(__snake_case    )
											model.eval()

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

											_SCREAMING_SNAKE_CASE					:			str							= outputs.hidden_states

											_SCREAMING_SNAKE_CASE					:			Optional[int]							= getattr(
											    self.model_tester       ,   """expected_num_hidden_layers"""       ,   len(self.model_tester.depths    ) + 1    )
											self.assertEqual(len(__snake_case    )       ,   __snake_case    )

											# 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					:			Optional[int]							= (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 UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[Any]							= self.model_tester.prepare_config_and_inputs_for_common()

											_SCREAMING_SNAKE_CASE					:			str							= (
											    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					:			Union[str, Any]							= True
															self.check_hidden_states_output(__snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case    )

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															_SCREAMING_SNAKE_CASE					:			List[str]							= True

															self.check_hidden_states_output(__snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= self.model_tester.prepare_config_and_inputs_for_common()
											_SCREAMING_SNAKE_CASE					:			str							= 3

											_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)
											)
											_SCREAMING_SNAKE_CASE					:			Dict							= (
											    config.patch_size
											    if isinstance(config.patch_size       ,   collections.abc.Iterable    )
											    else (config.patch_size, config.patch_size)
											)

											_SCREAMING_SNAKE_CASE					:			Tuple							= image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE					:			List[str]							= True
															self.check_hidden_states_output(__snake_case       ,   __snake_case       ,   __snake_case       ,   (padded_height, padded_width)    )

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






							@unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""    )
							def UpperCAmelCase_      (       self    ):
											pass






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






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






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[Any]							= self.model_tester.prepare_config_and_inputs_for_common()

											def set_nan_tensor_to_zero(__snake_case    ):
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= 0
															return t

											def check_equivalence(__snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case={}    ):
															with torch.no_grad():
																			_SCREAMING_SNAKE_CASE					:			Dict							= model(**__snake_case       ,   return_dict=__snake_case       ,   **__snake_case    )
																			_SCREAMING_SNAKE_CASE					:			Optional[int]							= model(**__snake_case       ,   return_dict=__snake_case       ,   **__snake_case    ).to_tuple()

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

																			recursive_check(__snake_case       ,   __snake_case    )

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= model_class(__snake_case    )
															model.to(__snake_case    )
															model.eval()

															_SCREAMING_SNAKE_CASE					:			str							= self._prepare_for_class(__snake_case       ,   __snake_case    )
															_SCREAMING_SNAKE_CASE					:			str							= self._prepare_for_class(__snake_case       ,   __snake_case    )
															check_equivalence(__snake_case       ,   __snake_case       ,   __snake_case    )

															_SCREAMING_SNAKE_CASE					:			Any							= self._prepare_for_class(__snake_case       ,   __snake_case       ,   return_labels=__snake_case    )
															_SCREAMING_SNAKE_CASE					:			int							= self._prepare_for_class(__snake_case       ,   __snake_case       ,   return_labels=__snake_case    )
															check_equivalence(__snake_case       ,   __snake_case       ,   __snake_case    )

															_SCREAMING_SNAKE_CASE					:			List[str]							= self._prepare_for_class(__snake_case       ,   __snake_case    )
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= self._prepare_for_class(__snake_case       ,   __snake_case    )
															check_equivalence(__snake_case       ,   __snake_case       ,   __snake_case       ,   {"""output_hidden_states""": True}    )

															_SCREAMING_SNAKE_CASE					:			List[Any]							= self._prepare_for_class(__snake_case       ,   __snake_case       ,   return_labels=__snake_case    )
															_SCREAMING_SNAKE_CASE					:			Optional[Any]							= self._prepare_for_class(__snake_case       ,   __snake_case       ,   return_labels=__snake_case    )
															check_equivalence(__snake_case       ,   __snake_case       ,   __snake_case       ,   {"""output_hidden_states""": True}    )





@require_torch
class        lowercase__    (		unittest.TestCase	,	_snake_case   ):





							'''simple docstring'''


							A_				: Any       =    (MaskFormerSwinBackbone,) if is_torch_available() else ()
							A_				: List[Any]       =    MaskFormerSwinConfig






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= MaskFormerSwinModelTester(self    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.model_tester.prepare_config_and_inputs_for_common()
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= inputs_dict["""pixel_values"""].shape[0]

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

															_SCREAMING_SNAKE_CASE					:			List[str]							= backbone(**__snake_case    )

															# Test default outputs and verify feature maps
															self.assertIsInstance(outputs.feature_maps       ,   __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
															_SCREAMING_SNAKE_CASE					:			Optional[Any]							= backbone(**__snake_case       ,   output_hidden_states=__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)
																							_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Dict							= 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					:			Optional[int]							= backbone(**__snake_case       ,   output_attentions=__snake_case    )
																			self.assertIsNotNone(outputs.attentions    )




