


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




				def __init__(	self    :				Dict   ,					lowerCAmelCase    :				str   ,					lowerCAmelCase    :				Optional[Any]=13   ,					lowerCAmelCase    :				Optional[int]=32   ,					lowerCAmelCase    :				Union[str, Any]=2   ,					lowerCAmelCase    :				Union[str, Any]=3   ,					lowerCAmelCase    :				List[str]=16   ,					lowerCAmelCase    :				Union[str, Any]=[1, 2, 1]   ,					lowerCAmelCase    :				List[str]=[2, 2, 4]   ,					lowerCAmelCase    :				Optional[int]=2   ,					lowerCAmelCase    :				str=2.0   ,					lowerCAmelCase    :				Dict=True   ,					lowerCAmelCase    :				Tuple=0.0   ,					lowerCAmelCase    :				Any=0.0   ,					lowerCAmelCase    :				List[Any]=0.1   ,					lowerCAmelCase    :				Any="gelu"   ,					lowerCAmelCase    :				List[str]=False   ,					lowerCAmelCase    :				str=True   ,					lowerCAmelCase    :				Optional[int]=0.02   ,					lowerCAmelCase    :				Union[str, Any]=1E-5   ,					lowerCAmelCase    :				Optional[int]=True   ,					lowerCAmelCase    :				int=None   ,					lowerCAmelCase    :				Dict=True   ,					lowerCAmelCase    :				Optional[Any]=10   ,					lowerCAmelCase    :				Tuple=8   ,					lowerCAmelCase    :				str=["stage1", "stage2", "stage3"]   ,					lowerCAmelCase    :				str=[1, 2, 3]   ,					)->  int:

										"""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    :				List[str]   )->  Tuple:

										"""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   )->  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    :				List[str]   ,					lowerCAmelCase    :				Any   ,					lowerCAmelCase    :				Dict   ,					lowerCAmelCase    :				Any   )->  Optional[Any]:

										"""simple docstring"""




										UpperCAmelCase         =			MaskFormerSwinModel(config=lowerCAmelCase   )
										model.to(lowerCAmelCase   )
										model.eval()
										UpperCAmelCase         =			model(lowerCAmelCase   )

										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    :				Tuple   ,					lowerCAmelCase    :				Optional[Any]   ,					lowerCAmelCase    :				Any   ,					lowerCAmelCase    :				int   )->  Union[str, Any]:

										"""simple docstring"""




										UpperCAmelCase         =			MaskFormerSwinBackbone(config=lowerCAmelCase   )
										model.to(lowerCAmelCase   )
										model.eval()
										UpperCAmelCase         =			model(lowerCAmelCase   )

										# 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(lowerCAmelCase   ):
																UpperCAmelCase         =			['''stem''']
																UpperCAmelCase         =			MaskFormerSwinBackbone(config=lowerCAmelCase   )





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

										"""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  UpperCamelCase__(     lowerCAmelCase		,       lowerCAmelCase		,       unittest.TestCase ):
				__magic_name__       :   str							= (
				    (
				        MaskFormerSwinModel,
				        MaskFormerSwinBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				__magic_name__       :   Optional[int]							= {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
				__magic_name__       :   Any							= False
				__magic_name__       :   Optional[int]							= False
				__magic_name__       :   Dict							= False
				__magic_name__       :   str							= False
				__magic_name__       :   Tuple							= False




				def   a__(	self    :				Optional[Any]   )->  int:

										"""simple docstring"""




										UpperCAmelCase         =			MaskFormerSwinModelTester(self   )
										UpperCAmelCase         =			ConfigTester(self   ,					config_class=lowerCAmelCase   ,					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    :				Union[str, Any]   )->  Union[str, Any]:

										"""simple docstring"""




										pass




				def   a__(	self    :				Dict   )->  List[Any]:

										"""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    :				Optional[Any]   )->  List[str]:

										"""simple docstring"""




										return




				def   a__(	self    :				Optional[Any]   )->  Dict:

										"""simple docstring"""




										UpperCAmelCase         =			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase   )




				def   a__(	self    :				Dict   )->  List[Any]:

										"""simple docstring"""




										UpperCAmelCase         =			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*lowerCAmelCase   )




				@unittest.skip('''Swin does not use inputs_embeds'''   )
				def   a__(	self    :				Dict   )->  List[Any]:

										"""simple docstring"""




										pass




				@unittest.skip('''Swin does not support feedforward chunking'''   )
				def   a__(	self    :				Any   )->  Optional[Any]:

										"""simple docstring"""




										pass




				def   a__(	self    :				str   )->  Any:

										"""simple docstring"""




										UpperCAmelCase       ,       UpperCAmelCase         =			self.model_tester.prepare_config_and_inputs_for_common()

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




				def   a__(	self    :				Optional[Any]   )->  List[str]:

										"""simple docstring"""




										UpperCAmelCase       ,       UpperCAmelCase         =			self.model_tester.prepare_config_and_inputs_for_common()

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




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

										"""simple docstring"""




										pass




				@unittest.skip(reason='''MaskFormerSwin is only used as an internal backbone'''   )
				def   a__(	self    :				List[Any]   )->  Optional[Any]:

										"""simple docstring"""




										pass




				def   a__(	self    :				Any   ,					lowerCAmelCase    :				Any   ,					lowerCAmelCase    :				Union[str, Any]   ,					lowerCAmelCase    :				Tuple   ,					lowerCAmelCase    :				List[str]   )->  Optional[int]:

										"""simple docstring"""




										UpperCAmelCase         =			model_class(lowerCAmelCase   )
										model.to(lowerCAmelCase   )
										model.eval()

										with torch.no_grad():
																UpperCAmelCase         =			model(**self._prepare_for_class(lowerCAmelCase   ,					lowerCAmelCase   )   )

										UpperCAmelCase         =			outputs.hidden_states

										UpperCAmelCase         =			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
										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    :				Dict   )->  List[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(lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   )

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

																self.check_hidden_states_output(lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   )




				def   a__(	self    :				Optional[Any]   )->  int:

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




				@unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints'''   )
				def   a__(	self    :				List[str]   )->  List[Any]:

										"""simple docstring"""




										pass




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

										"""simple docstring"""




										pass




				@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''   )
				def   a__(	self    :				List[str]   )->  Optional[int]:

										"""simple docstring"""




										pass





				def   a__(	self    :				int   )->  int:

										"""simple docstring"""




										UpperCAmelCase       ,       UpperCAmelCase         =			self.model_tester.prepare_config_and_inputs_for_common()

										def set_nan_tensor_to_zero(lowerCAmelCase    :				Tuple   ):
																UpperCAmelCase         =			0
																return t

										def check_equivalence(lowerCAmelCase    :				int   ,					lowerCAmelCase    :				List[Any]   ,					lowerCAmelCase    :				Optional[Any]   ,					lowerCAmelCase    :				List[str]={}   ):
																with torch.no_grad():
																						UpperCAmelCase         =			model(**lowerCAmelCase   ,					return_dict=lowerCAmelCase   ,					**lowerCAmelCase   )
																						UpperCAmelCase         =			model(**lowerCAmelCase   ,					return_dict=lowerCAmelCase   ,					**lowerCAmelCase   ).to_tuple()

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

																						recursive_check(lowerCAmelCase   ,					lowerCAmelCase   )

										for model_class in self.all_model_classes:
																UpperCAmelCase         =			model_class(lowerCAmelCase   )
																model.to(lowerCAmelCase   )
																model.eval()

																UpperCAmelCase         =			self._prepare_for_class(lowerCAmelCase   ,					lowerCAmelCase   )
																UpperCAmelCase         =			self._prepare_for_class(lowerCAmelCase   ,					lowerCAmelCase   )
																check_equivalence(lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   )

																UpperCAmelCase         =			self._prepare_for_class(lowerCAmelCase   ,					lowerCAmelCase   ,					return_labels=lowerCAmelCase   )
																UpperCAmelCase         =			self._prepare_for_class(lowerCAmelCase   ,					lowerCAmelCase   ,					return_labels=lowerCAmelCase   )
																check_equivalence(lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   )

																UpperCAmelCase         =			self._prepare_for_class(lowerCAmelCase   ,					lowerCAmelCase   )
																UpperCAmelCase         =			self._prepare_for_class(lowerCAmelCase   ,					lowerCAmelCase   )
																check_equivalence(lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   ,					{'''output_hidden_states''': True}   )

																UpperCAmelCase         =			self._prepare_for_class(lowerCAmelCase   ,					lowerCAmelCase   ,					return_labels=lowerCAmelCase   )
																UpperCAmelCase         =			self._prepare_for_class(lowerCAmelCase   ,					lowerCAmelCase   ,					return_labels=lowerCAmelCase   )
																check_equivalence(lowerCAmelCase   ,					lowerCAmelCase   ,					lowerCAmelCase   ,					{'''output_hidden_states''': True}   )







@require_torch
class  UpperCamelCase__(     unittest.TestCase		,       lowerCAmelCase ):
				__magic_name__       :   List[str]							= (MaskFormerSwinBackbone,) if is_torch_available() else ()
				__magic_name__       :   str							= MaskFormerSwinConfig




				def   a__(	self    :				Union[str, Any]   )->  Optional[int]:

										"""simple docstring"""




										UpperCAmelCase         =			MaskFormerSwinModelTester(self   )





				def   a__(	self    :				Dict   )->  Dict:

										"""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(lowerCAmelCase   )
																backbone.to(lowerCAmelCase   )
																backbone.eval()

																UpperCAmelCase         =			backbone(**lowerCAmelCase   )

																# Test default outputs and verify feature maps
																self.assertIsInstance(outputs.feature_maps   ,					lowerCAmelCase   )
																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(**lowerCAmelCase   ,					output_hidden_states=lowerCAmelCase   )
																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(**lowerCAmelCase   ,					output_attentions=lowerCAmelCase   )
																						self.assertIsNotNone(outputs.attentions   )





'''simple docstring'''



def    lowerCamelCase__   ( A     :    str  ):




						'''simple docstring'''






						assert column_title.isupper()
						UpperCAmelCase         =			0
						UpperCAmelCase         =			len(A  ) - 1
						UpperCAmelCase         =			0

						while index >= 0:
												UpperCAmelCase         =			(ord(column_title[index]  ) - 64) * pow(26   ,     A  )
												answer += value
												power += 1
												index -= 1

						return answer


if __name__ == "__main__":
	from doctest import testmod

	testmod()





