

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 	snake_case_   :







			'''simple docstring'''

			def __init__(     self :				List[Any]							,   _UpperCamelCase :				Dict							,   _UpperCamelCase :				List[str]=1_3							,   _UpperCamelCase :				int=3_2							,   _UpperCamelCase :				Optional[Any]=2							,   _UpperCamelCase :				Any=3							,   _UpperCamelCase :				Optional[int]=1_6							,   _UpperCamelCase :				Optional[Any]=[1, 2, 1]							,   _UpperCamelCase :				Tuple=[2, 2, 4]							,   _UpperCamelCase :				List[Any]=2							,   _UpperCamelCase :				Optional[int]=2.0							,   _UpperCamelCase :				Any=True							,   _UpperCamelCase :				Union[str, Any]=0.0							,   _UpperCamelCase :				int=0.0							,   _UpperCamelCase :				Union[str, Any]=0.1							,   _UpperCamelCase :				List[str]="gelu"							,   _UpperCamelCase :				Union[str, Any]=False							,   _UpperCamelCase :				List[str]=True							,   _UpperCamelCase :				Optional[Any]=0.02							,   _UpperCamelCase :				List[Any]=1e-5							,   _UpperCamelCase :				Optional[int]=True							,   _UpperCamelCase :				int=None							,   _UpperCamelCase :				Union[str, Any]=True							,   _UpperCamelCase :				Union[str, Any]=1_0							,   _UpperCamelCase :				int=8							,   _UpperCamelCase :				Tuple=["stage1", "stage2", "stage3"]							,   _UpperCamelCase :				Union[str, Any]=[1, 2, 3]							,   )      ->Any:
									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
									snake_case_   =	out_features
									snake_case_   =	out_indices







			def 				snake_case__(     self :				Tuple							)      ->List[Any]:
									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 				snake_case__(     self :				List[Any]							)      ->Dict:
									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 				snake_case__(     self :				int							,   _UpperCamelCase :				List[str]							,   _UpperCamelCase :				List[str]							,   _UpperCamelCase :				Any							)      ->Any:
									snake_case_   =	MaskFormerSwinModel(config=_UpperCamelCase							)
									model.to(_UpperCamelCase							)
									model.eval()
									snake_case_   =	model(_UpperCamelCase							)

									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 				snake_case__(     self :				Dict							,   _UpperCamelCase :				str							,   _UpperCamelCase :				Tuple							,   _UpperCamelCase :				Tuple							)      ->Tuple:
									snake_case_   =	MaskFormerSwinBackbone(config=_UpperCamelCase							)
									model.to(_UpperCamelCase							)
									model.eval()
									snake_case_   =	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							)							,   [1_3, 1_6, 1_6, 1_6]							)

									# verify channels
									self.parent.assertEqual(len(model.channels							)							,   len(config.out_features							)							)
									self.parent.assertListEqual(model.channels							,   [1_6, 3_2, 6_4]							)

									# verify ValueError
									with self.parent.assertRaises(_UpperCamelCase							):
															snake_case_   =	['''stem''']
															snake_case_   =	MaskFormerSwinBackbone(config=_UpperCamelCase							)







			def 				snake_case__(     self :				Tuple							)      ->List[Any]:
									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_torch
class 	snake_case_   (		__A	,       __A	,       unittest.TestCase					):







			'''simple docstring'''

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







			def 				snake_case__(     self :				str							)      ->Tuple:
									snake_case_   =	MaskFormerSwinModelTester(self							)
									snake_case_   =	ConfigTester(self							,   config_class=_UpperCamelCase							,   embed_dim=3_7							)







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







			def 				snake_case__(     self :				int							)      ->List[str]:
									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 				snake_case__(     self :				int							)      ->str:
									return







			def 				snake_case__(     self :				Optional[Any]							)      ->Tuple:
									snake_case_   =	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_UpperCamelCase							)







			def 				snake_case__(     self :				str							)      ->Union[str, Any]:
									snake_case_   =	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_backbone(*_UpperCamelCase							)







			@unittest.skip('''Swin does not use inputs_embeds'''							)
			def 				snake_case__(     self :				List[str]							)      ->Tuple:
									pass







			@unittest.skip('''Swin does not support feedforward chunking'''							)
			def 				snake_case__(     self :				List[Any]							)      ->str:
									pass







			def 				snake_case__(     self :				Optional[int]							)      ->List[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(_UpperCamelCase							)
															self.assertIsInstance(model.get_input_embeddings()							,   (nn.Module)							)
															snake_case_   =	model.get_output_embeddings()
															self.assertTrue(x is None or isinstance(_UpperCamelCase							,   nn.Linear							)							)







			def 				snake_case__(     self :				Optional[int]							)      ->Union[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(_UpperCamelCase							)
															snake_case_   =	inspect.signature(model.forward							)
															# 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]							,   _UpperCamelCase							)







			@unittest.skip(reason='''MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'''							)
			def 				snake_case__(     self :				Optional[Any]							)      ->List[str]:
									pass







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







			def 				snake_case__(     self :				List[Any]							,   _UpperCamelCase :				Optional[Any]							,   _UpperCamelCase :				List[str]							,   _UpperCamelCase :				List[Any]							,   _UpperCamelCase :				Optional[Any]							)      ->List[Any]:
									snake_case_   =	model_class(_UpperCamelCase							)
									model.to(_UpperCamelCase							)
									model.eval()

									with torch.no_grad():
															snake_case_   =	model(**self._prepare_for_class(_UpperCamelCase							,   _UpperCamelCase							)							)

									snake_case_   =	outputs.hidden_states

									snake_case_   =	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
									snake_case_   =	(
									    config.patch_size
									    if isinstance(config.patch_size							,   collections.abc.Iterable							)
									    else (config.patch_size, 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]							,   )







			def 				snake_case__(     self :				List[str]							)      ->Optional[int]:
									snake_case_,    snake_case_   =	self.model_tester.prepare_config_and_inputs_for_common()

									snake_case_   =	(
									    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:
															snake_case_   =	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"]
															snake_case_   =	True

															self.check_hidden_states_output(_UpperCamelCase							,   _UpperCamelCase							,   _UpperCamelCase							,   _UpperCamelCase							)







			def 				snake_case__(     self :				str							)      ->Any:
									snake_case_,    snake_case_   =	self.model_tester.prepare_config_and_inputs_for_common()
									snake_case_   =	3

									snake_case_   =	(
									    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)
									)
									snake_case_   =	(
									    config.patch_size
									    if isinstance(config.patch_size							,   collections.abc.Iterable							)
									    else (config.patch_size, 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(_UpperCamelCase							,   _UpperCamelCase							,   _UpperCamelCase							,   (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(_UpperCamelCase							,   _UpperCamelCase							,   _UpperCamelCase							,   (padded_height, padded_width)							)







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







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







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







			def 				snake_case__(     self :				Optional[int]							)      ->Union[str, Any]:
									snake_case_,    snake_case_   =	self.model_tester.prepare_config_and_inputs_for_common()

									def set_nan_tensor_to_zero(_UpperCamelCase :				Any							):
															snake_case_   =	0
															return t

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

																					def recursive_check(_UpperCamelCase :				Tuple							,   _UpperCamelCase :				List[str]							):
																											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:
															snake_case_   =	model_class(_UpperCamelCase							)
															model.to(_UpperCamelCase							)
															model.eval()

															snake_case_   =	self._prepare_for_class(_UpperCamelCase							,   _UpperCamelCase							)
															snake_case_   =	self._prepare_for_class(_UpperCamelCase							,   _UpperCamelCase							)
															check_equivalence(_UpperCamelCase							,   _UpperCamelCase							,   _UpperCamelCase							)

															snake_case_   =	self._prepare_for_class(_UpperCamelCase							,   _UpperCamelCase							,   return_labels=_UpperCamelCase							)
															snake_case_   =	self._prepare_for_class(_UpperCamelCase							,   _UpperCamelCase							,   return_labels=_UpperCamelCase							)
															check_equivalence(_UpperCamelCase							,   _UpperCamelCase							,   _UpperCamelCase							)

															snake_case_   =	self._prepare_for_class(_UpperCamelCase							,   _UpperCamelCase							)
															snake_case_   =	self._prepare_for_class(_UpperCamelCase							,   _UpperCamelCase							)
															check_equivalence(_UpperCamelCase							,   _UpperCamelCase							,   _UpperCamelCase							,   {'''output_hidden_states''': True}							)

															snake_case_   =	self._prepare_for_class(_UpperCamelCase							,   _UpperCamelCase							,   return_labels=_UpperCamelCase							)
															snake_case_   =	self._prepare_for_class(_UpperCamelCase							,   _UpperCamelCase							,   return_labels=_UpperCamelCase							)
															check_equivalence(_UpperCamelCase							,   _UpperCamelCase							,   _UpperCamelCase							,   {'''output_hidden_states''': True}							)






@require_torch
class 	snake_case_   (		unittest.TestCase	,       __A					):







			'''simple docstring'''

			SCREAMING_SNAKE_CASE     :   int									=				(MaskFormerSwinBackbone,) if is_torch_available() else ()
			SCREAMING_SNAKE_CASE     :   int									=				MaskFormerSwinConfig







			def 				snake_case__(     self :				Any							)      ->Union[str, Any]:
									snake_case_   =	MaskFormerSwinModelTester(self							)







			def 				snake_case__(     self :				Dict							)      ->str:
									snake_case_,    snake_case_   =	self.model_tester.prepare_config_and_inputs_for_common()
									snake_case_   =	inputs_dict['''pixel_values'''].shape[0]

									for backbone_class in self.all_model_classes:
															snake_case_   =	backbone_class(_UpperCamelCase							)
															backbone.to(_UpperCamelCase							)
															backbone.eval()

															snake_case_   =	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
															snake_case_   =	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)
																											snake_case_,    snake_case_,    snake_case_   =	hidden_state.shape
																											self.assertTrue((h_batch_size, h_n_channels)							,   (batch_size, n_channels)							)

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


import math


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       ):
						if 0 not in (x, y):
												# We use the relation x^y = y*log10(x), where 10 is the base.
												return y * math.logaa(SCREAMING_SNAKE_CASE__       )
						else:
												if x == 0:  # 0 raised to any number is 0
																		return 0
												elif y == 0:
																		return 1  # any number raised to 0 is 1
						raise AssertionError('''This should never happen'''       )


if __name__ == "__main__":  # Main function
					# Read two numbers from input and typecast them to int using map function.
					# Here x is the base and y is the power.
					lowerCAmelCase_       	=	'''Enter the base and the power separated by a comma: '''
					lowerCAmelCase_	,      lowerCAmelCase_       	=	map(int, input(prompt).split(''','''))
					lowerCAmelCase_	,      lowerCAmelCase_       	=	map(int, input(prompt).split(''','''))

					# We find the log of each number, using the function res(), which takes two
					# arguments.
					lowerCAmelCase_       	=	res(xa, ya)
					lowerCAmelCase_       	=	res(xa, ya)

					# We check for the largest number
					if resa > resa:
										print('''Largest number is''', xa, '''^''', ya)
					elif resa > resa:
										print('''Largest number is''', xa, '''^''', ya)
					else:
										print('''Both are equal''')