



import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 transformers import (
							    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
							    MODEL_MAPPING,
							    LevitForImageClassification,
							    LevitForImageClassificationWithTeacher,
							    LevitModel,
							)
							from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import LevitImageProcessor
class 				_snake_case			(					__a):




				def 							A__      (						self					:						Optional[Any]						):
							lowercase__					  =				self.config_class(**self.inputs_dict						)
							self.parent.assertTrue(hasattr(a_,					"hidden_sizes"						)						)
							self.parent.assertTrue(hasattr(a_,					"num_attention_heads"						)						)
class 				_snake_case			:




				def __init__(						self					:						int,					__lowercase					:						Optional[Any],					__lowercase					:						Union[str, Any]=13,					__lowercase					:						Dict=64,					__lowercase					:						Union[str, Any]=3,					__lowercase					:						Union[str, Any]=3,					__lowercase					:						Optional[int]=2,					__lowercase					:						List[str]=1,					__lowercase					:						Optional[Any]=16,					__lowercase					:						str=[128, 256, 384],					__lowercase					:						Optional[int]=[4, 6, 8],					__lowercase					:						Optional[Any]=[2, 3, 4],					__lowercase					:						Optional[Any]=[16, 16, 16],					__lowercase					:						Tuple=0,					__lowercase					:						Dict=[2, 2, 2],					__lowercase					:						Dict=[2, 2, 2],					__lowercase					:						Optional[int]=0.02,					__lowercase					:						Optional[int]=True,					__lowercase					:						List[Any]=True,					__lowercase					:						Optional[int]=2,					):
							lowercase__					  =				parent
							lowercase__					  =				batch_size
							lowercase__					  =				image_size
							lowercase__					  =				num_channels
							lowercase__					  =				kernel_size
							lowercase__					  =				stride
							lowercase__					  =				padding
							lowercase__					  =				hidden_sizes
							lowercase__					  =				num_attention_heads
							lowercase__					  =				depths
							lowercase__					  =				key_dim
							lowercase__					  =				drop_path_rate
							lowercase__					  =				patch_size
							lowercase__					  =				attention_ratio
							lowercase__					  =				mlp_ratio
							lowercase__					  =				initializer_range
							lowercase__					  =				[
							    ["""Subsample""", key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
							    ["""Subsample""", key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
							]
							lowercase__					  =				is_training
							lowercase__					  =				use_labels
							lowercase__					  =				num_labels
							lowercase__					  =				initializer_range




				def 							A__      (						self					:						List[str]						):
							lowercase__					  =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

							lowercase__					  =				None
							if self.use_labels:
										lowercase__					  =				ids_tensor([self.batch_size],					self.num_labels						)

							lowercase__					  =				self.get_config()
							return config, pixel_values, labels




				def 							A__      (						self					:						Optional[int]						):
							return LevitConfig(
							    image_size=self.image_size,					num_channels=self.num_channels,					kernel_size=self.kernel_size,					stride=self.stride,					padding=self.padding,					patch_size=self.patch_size,					hidden_sizes=self.hidden_sizes,					num_attention_heads=self.num_attention_heads,					depths=self.depths,					key_dim=self.key_dim,					drop_path_rate=self.drop_path_rate,					mlp_ratio=self.mlp_ratio,					attention_ratio=self.attention_ratio,					initializer_range=self.initializer_range,					down_ops=self.down_ops,					)




				def 							A__      (						self					:						str,					__lowercase					:						str,					__lowercase					:						Union[str, Any],					__lowercase					:						Tuple						):
							lowercase__					  =				LevitModel(config=a_						)
							model.to(a_						)
							model.eval()
							lowercase__					  =				model(a_						)
							lowercase__					  =				(self.image_size, self.image_size)
							lowercase__					  =				image_size[0], image_size[1]
							for _ in range(4						):
										lowercase__					  =				floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
										lowercase__					  =				floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1						)
							self.parent.assertEqual(
							    result.last_hidden_state.shape,					(self.batch_size, ceil(height / 4						) * ceil(width / 4						), self.hidden_sizes[-1]),					)




				def 							A__      (						self					:						Union[str, Any],					__lowercase					:						List[Any],					__lowercase					:						Optional[Any],					__lowercase					:						str						):
							lowercase__					  =				self.num_labels
							lowercase__					  =				LevitForImageClassification(a_						)
							model.to(a_						)
							model.eval()
							lowercase__					  =				model(a_,					labels=a_						)
							self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.num_labels)						)




				def 							A__      (						self					:						str						):
							lowercase__					  =				self.prepare_config_and_inputs()
							lowercase__					  =				config_and_inputs
							lowercase__					  =				{"""pixel_values""": pixel_values}
							return config, inputs_dict
@require_torch
class 				_snake_case			(					__a    ,	__a    ,	unittest.TestCase):
				UpperCamelCase__				:					List[Any]  		=(
				    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
				    if is_torch_available()
				    else ()
				)
				UpperCamelCase__				:					Tuple  		=(
				    {
				        """feature-extraction""": LevitModel,
				        """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
				    }
				    if is_torch_available()
				    else {}
				)

				UpperCamelCase__				:					Optional[Any]  		=False
				UpperCamelCase__				:					Optional[int]  		=False
				UpperCamelCase__				:					List[Any]  		=False
				UpperCamelCase__				:					int  		=False
				UpperCamelCase__				:					int  		=False




				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				LevitModelTester(self						)
							lowercase__					  =				ConfigTester(self,					config_class=a_,					has_text_modality=a_,					hidden_size=37						)




				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					:						List[Any]						):
							return




				@unittest.skip(reason="Levit does not use inputs_embeds"						)
				def 							A__      (						self					:						Tuple						):
							pass




				@unittest.skip(reason="Levit does not support input and output embeddings"						)
				def 							A__      (						self					:						Union[str, Any]						):
							pass




				@unittest.skip(reason="Levit does not output attentions"						)
				def 							A__      (						self					:						Optional[int]						):
							pass




				def 							A__      (						self					:						int						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
										lowercase__					  =				model_class(a_						)
										lowercase__					  =				inspect.signature(model.forward						)
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										lowercase__					  =				[*signature.parameters.keys()]

										lowercase__					  =				["""pixel_values"""]
										self.assertListEqual(arg_names[:1],					a_						)




				def 							A__      (						self					:						str						):



							def check_hidden_states_output(__lowercase					:						Optional[int],					__lowercase					:						Tuple,					__lowercase					:						List[Any]						):
										lowercase__					  =				model_class(a_						)
										model.to(a_						)
										model.eval()

										with torch.no_grad():
													lowercase__					  =				model(**self._prepare_for_class(a_,					a_						)						)

										lowercase__					  =				outputs.hidden_states

										lowercase__					  =				len(self.model_tester.depths						) + 1
										self.assertEqual(len(a_						),					a_						)

										lowercase__					  =				(self.model_tester.image_size, self.model_tester.image_size)
										lowercase__					  =				image_size[0], image_size[1]
										for _ in range(4						):
													lowercase__					  =				floor(
													    (
													        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
													        / self.model_tester.stride
													    )
													    + 1						)
													lowercase__					  =				floor(
													    (
													        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
													        / self.model_tester.stride
													    )
													    + 1						)
										# verify the first hidden states (first block)
										self.assertListEqual(
										    list(hidden_states[0].shape[-2:]						),					[
										        height * width,
										        self.model_tester.hidden_sizes[0],
										    ],					)

							lowercase__					  =				self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
										lowercase__					  =				True
										check_hidden_states_output(a_,					a_,					a_						)

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

										check_hidden_states_output(a_,					a_,					a_						)




				@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."						)
				def 							A__      (						self					:						Tuple						):
							pass




				def 							A__      (						self					:						Tuple,					__lowercase					:						List[Any],					__lowercase					:						List[Any],					__lowercase					:						Optional[int]=False						):
							lowercase__					  =				super()._prepare_for_class(a_,					a_,					return_labels=a_						)

							if return_labels:
										if model_class.__name__ == "LevitForImageClassificationWithTeacher":
													del inputs_dict["labels"]

							return inputs_dict




				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*a_						)




				def 							A__      (						self					:						List[Any]						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*a_						)




				def 							A__      (						self					:						Union[str, Any]						):



							if not self.model_tester.is_training:
										return

							lowercase__					  =				self.model_tester.prepare_config_and_inputs_for_common()
							lowercase__					  =				True

							for model_class in self.all_model_classes:
										# LevitForImageClassificationWithTeacher supports inference-only
										if (
										    model_class in get_values(a_						)
										    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
										):
													continue
										lowercase__					  =				model_class(a_						)
										model.to(a_						)
										model.train()
										lowercase__					  =				self._prepare_for_class(a_,					a_,					return_labels=a_						)
										lowercase__					  =				model(**a_						).loss
										loss.backward()




				def 							A__      (						self					:						List[Any]						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs_for_common()
							if not self.model_tester.is_training:
										return

							lowercase__					  =				False
							lowercase__					  =				True

							for model_class in self.all_model_classes:
										if model_class in get_values(a_						) or not model_class.supports_gradient_checkpointing:
													continue
										# LevitForImageClassificationWithTeacher supports inference-only
										if model_class.__name__ == "LevitForImageClassificationWithTeacher":
													continue
										lowercase__					  =				model_class(a_						)
										model.gradient_checkpointing_enable()
										model.to(a_						)
										model.train()
										lowercase__					  =				self._prepare_for_class(a_,					a_,					return_labels=a_						)
										lowercase__					  =				model(**a_						).loss
										loss.backward()




				def 							A__      (						self					:						Any						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs_for_common()

							lowercase__					  =				[
							    {"""title""": """multi_label_classification""", """num_labels""": 2, """dtype""": torch.float},
							    {"""title""": """single_label_classification""", """num_labels""": 1, """dtype""": torch.long},
							    {"""title""": """regression""", """num_labels""": 1, """dtype""": torch.float},
							]

							for model_class in self.all_model_classes:
										if (
										    model_class
										    not in [
										        *get_values(a_						),
										    ]
										    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
										):
													continue

										for problem_type in problem_types:
													with self.subTest(msg=F'''Testing {model_class} with {problem_type["title"]}'''						):
																lowercase__					  =				problem_type["""title"""]
																lowercase__					  =				problem_type["""num_labels"""]

																lowercase__					  =				model_class(a_						)
																model.to(a_						)
																model.train()

																lowercase__					  =				self._prepare_for_class(a_,					a_,					return_labels=a_						)

																if problem_type["num_labels"] > 1:
																			lowercase__					  =				inputs["""labels"""].unsqueeze(1						).repeat(1,					problem_type["num_labels"]						)

																lowercase__					  =				inputs["""labels"""].to(problem_type["dtype"]						)

																# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																# they have the same size." which is a symptom something in wrong for the regression problem.
																# See https://github.com/huggingface/transformers/issues/11780
																with warnings.catch_warnings(record=a_						) as warning_list:
																			lowercase__					  =				model(**a_						).loss
																for w in warning_list:
																			if "Using a target size that is different to the input size" in str(w.message						):
																						raise ValueError(
																						    F'''Something is going wrong in the regression problem: intercepted {w.message}'''						)

																loss.backward()




				@slow
				def 							A__      (						self					:						List[str]						):



							for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowercase__					  =				LevitModel.from_pretrained(a_						)
										self.assertIsNotNone(a_						)



def __lowerCAmelCase (     ):
			lowercase__					  =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
			return image




@require_torch
@require_vision
class 				_snake_case			(					unittest.TestCase):




				@cached_property
				def 							A__      (						self					:						int						):
							return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)




				@slow
				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(
							    a_						)

							lowercase__					  =				self.default_image_processor
							lowercase__					  =				prepare_img()
							lowercase__					  =				image_processor(images=a_,					return_tensors="pt"						).to(a_						)

							# forward pass
							with torch.no_grad():
										lowercase__					  =				model(**a_						)

							# verify the logits
							lowercase__					  =				torch.Size((1, 1000)						)
							self.assertEqual(outputs.logits.shape,					a_						)

							lowercase__					  =				torch.tensor([1.0448, -0.3745, -1.8317]						).to(a_						)

							self.assertTrue(torch.allclose(outputs.logits[0, :3],					a_,					atol=1e-4						)						)









import math



def __lowerCAmelCase (     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.
							lowercase_								=     """Enter the base and the power separated by a comma: """
							lowercase_				,    lowercase_								=     map(int, input(prompt).split(""","""))
							lowercase_				,    lowercase_								=     map(int, input(prompt).split(""","""))

							# We find the log of each number, using the function res(), which takes two
							# arguments.
							lowercase_								=     res(xa, ya)
							lowercase_								=     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""")




