


'''simple docstring'''
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    lowercase	(							A__					):

		"""simple docstring"""

		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Union[str, Any]												= self.config_class(**self.inputs_dict							)
							self.parent.assertTrue(hasattr(UpperCamelCase_    ,   '''hidden_sizes'''							)							)
							self.parent.assertTrue(hasattr(UpperCamelCase_    ,   '''num_attention_heads'''							)							)



class    lowercase	:

		"""simple docstring"""

		def __init__(		self    ,   UpperCamelCase_    ,   UpperCamelCase_=13    ,   UpperCamelCase_=64    ,   UpperCamelCase_=3    ,   UpperCamelCase_=3    ,   UpperCamelCase_=2    ,   UpperCamelCase_=1    ,   UpperCamelCase_=16    ,   UpperCamelCase_=[128, 256, 384]    ,   UpperCamelCase_=[4, 6, 8]    ,   UpperCamelCase_=[2, 3, 4]    ,   UpperCamelCase_=[16, 16, 16]    ,   UpperCamelCase_=0    ,   UpperCamelCase_=[2, 2, 2]    ,   UpperCamelCase_=[2, 2, 2]    ,   UpperCamelCase_=0.02    ,   UpperCamelCase_=True    ,   UpperCamelCase_=True    ,   UpperCamelCase_=2    ,   ):

							'''simple docstring'''


							UpperCamelCase__   :Any												= parent
							UpperCamelCase__   :List[Any]												= batch_size
							UpperCamelCase__   :str												= image_size
							UpperCamelCase__   :Dict												= num_channels
							UpperCamelCase__   :Optional[int]												= kernel_size
							UpperCamelCase__   :List[str]												= stride
							UpperCamelCase__   :Dict												= padding
							UpperCamelCase__   :Optional[int]												= hidden_sizes
							UpperCamelCase__   :int												= num_attention_heads
							UpperCamelCase__   :List[Any]												= depths
							UpperCamelCase__   :int												= key_dim
							UpperCamelCase__   :int												= drop_path_rate
							UpperCamelCase__   :int												= patch_size
							UpperCamelCase__   :List[Any]												= attention_ratio
							UpperCamelCase__   :Optional[int]												= mlp_ratio
							UpperCamelCase__   :Optional[int]												= initializer_range
							UpperCamelCase__   :Any												= [
							    ['''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],
							]
							UpperCamelCase__   :Optional[int]												= is_training
							UpperCamelCase__   :Optional[Any]												= use_labels
							UpperCamelCase__   :Dict												= num_labels
							UpperCamelCase__   :str												= initializer_range




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :List[Any]												= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

							UpperCamelCase__   :int												= None
							if self.use_labels:
												UpperCamelCase__   :str												= ids_tensor([self.batch_size]    ,   self.num_labels							)

							UpperCamelCase__   :Optional[Any]												= self.get_config()
							return config, pixel_values, labels




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							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     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__   :Optional[Any]												= LevitModel(config=UpperCamelCase_							)
							model.to(UpperCamelCase_							)
							model.eval()
							UpperCamelCase__   :int												= model(UpperCamelCase_							)
							UpperCamelCase__   :int												= (self.image_size, self.image_size)
							UpperCamelCase__					,				UpperCamelCase__   :Optional[int]												= image_size[0], image_size[1]
							for _ in range(4							):
												UpperCamelCase__   :int												= floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1							)
												UpperCamelCase__   :Optional[Any]												= 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     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__   :Tuple												= self.num_labels
							UpperCamelCase__   :List[Any]												= LevitForImageClassification(UpperCamelCase_							)
							model.to(UpperCamelCase_							)
							model.eval()
							UpperCamelCase__   :Optional[int]												= model(UpperCamelCase_    ,   labels=UpperCamelCase_							)
							self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_labels)							)




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :List[str]												= self.prepare_config_and_inputs()
							UpperCamelCase__					,				UpperCamelCase__					,				UpperCamelCase__   :Union[str, Any]												= config_and_inputs
							UpperCamelCase__   :List[str]												= {'''pixel_values''': pixel_values}
							return config, inputs_dict



@require_torch
class    lowercase	(							A__	,		A__	,		unittest.TestCase					):

		"""simple docstring"""

		_a     =				(
		    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
		    if is_torch_available()
		    else ()
		)
		_a     =				(
		    {
		        'feature-extraction': LevitModel,
		        'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
		    }
		    if is_torch_available()
		    else {}
		)

		_a     =				False
		_a     =				False
		_a     =				False
		_a     =				False
		_a     =				False




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Optional[int]												= LevitModelTester(self							)
							UpperCamelCase__   :Union[str, Any]												= ConfigTester(self    ,   config_class=UpperCamelCase_    ,   has_text_modality=UpperCamelCase_    ,   hidden_size=37							)




		def     lowerCAmelCase__				(		self							):

							'''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     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							return




		@unittest.skip(reason='''Levit does not use inputs_embeds'''							)
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							pass




		@unittest.skip(reason='''Levit does not support input and output embeddings'''							)
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							pass




		@unittest.skip(reason='''Levit does not output attentions'''							)
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							pass




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__					,				UpperCamelCase__   :Optional[int]												= self.model_tester.prepare_config_and_inputs_for_common()

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

												UpperCamelCase__   :Tuple												= ['''pixel_values''']
												self.assertListEqual(arg_names[:1]    ,   UpperCamelCase_							)




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							def check_hidden_states_output(UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							):
												UpperCamelCase__   :str												= model_class(UpperCamelCase_							)
												model.to(UpperCamelCase_							)
												model.eval()

												with torch.no_grad():
																	UpperCamelCase__   :Union[str, Any]												= model(**self._prepare_for_class(UpperCamelCase_    ,   UpperCamelCase_							)							)

												UpperCamelCase__   :List[str]												= outputs.hidden_states

												UpperCamelCase__   :int												= len(self.model_tester.depths							) + 1
												self.assertEqual(len(UpperCamelCase_							)    ,   UpperCamelCase_							)

												UpperCamelCase__   :Any												= (self.model_tester.image_size, self.model_tester.image_size)
												UpperCamelCase__					,				UpperCamelCase__   :Optional[Any]												= image_size[0], image_size[1]
												for _ in range(4							):
																	UpperCamelCase__   :Optional[Any]												= floor(
																	    (
																	        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																	        / self.model_tester.stride
																	    )
																	    + 1							)
																	UpperCamelCase__   :Union[str, Any]												= 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],
												    ]    ,   )

							UpperCamelCase__					,				UpperCamelCase__   :List[str]												= self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												UpperCamelCase__   :Any												= True
												check_hidden_states_output(UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							)

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												UpperCamelCase__   :Union[str, Any]												= True

												check_hidden_states_output(UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_							)




		@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''							)
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							pass




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_=False							):

							'''simple docstring'''


							UpperCamelCase__   :Optional[Any]												= super()._prepare_for_class(UpperCamelCase_    ,   UpperCamelCase_    ,   return_labels=UpperCamelCase_							)

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

							return inputs_dict




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :List[Any]												= self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*UpperCamelCase_							)




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Union[str, Any]												= self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_							)




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							if not self.model_tester.is_training:
												return

							UpperCamelCase__					,				UpperCamelCase__   :int												= self.model_tester.prepare_config_and_inputs_for_common()
							UpperCamelCase__   :str												= True

							for model_class in self.all_model_classes:
												# LevitForImageClassificationWithTeacher supports inference-only
												if (
												    model_class in get_values(UpperCamelCase_							)
												    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
												):
																	continue
												UpperCamelCase__   :List[Any]												= model_class(UpperCamelCase_							)
												model.to(UpperCamelCase_							)
												model.train()
												UpperCamelCase__   :Tuple												= self._prepare_for_class(UpperCamelCase_    ,   UpperCamelCase_    ,   return_labels=UpperCamelCase_							)
												UpperCamelCase__   :Any												= model(**UpperCamelCase_							).loss
												loss.backward()




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__					,				UpperCamelCase__   :List[str]												= self.model_tester.prepare_config_and_inputs_for_common()
							if not self.model_tester.is_training:
												return

							UpperCamelCase__   :int												= False
							UpperCamelCase__   :Dict												= True

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




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__					,				UpperCamelCase__   :Any												= self.model_tester.prepare_config_and_inputs_for_common()

							UpperCamelCase__   :int												= [
							    {'''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(UpperCamelCase_							),
												    ]
												    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
												):
																	continue

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

																						UpperCamelCase__   :int												= model_class(UpperCamelCase_							)
																						model.to(UpperCamelCase_							)
																						model.train()

																						UpperCamelCase__   :Optional[Any]												= self._prepare_for_class(UpperCamelCase_    ,   UpperCamelCase_    ,   return_labels=UpperCamelCase_							)

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

																						UpperCamelCase__   :Union[str, Any]												= 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=UpperCamelCase_							) as warning_list:
																											UpperCamelCase__   :Optional[int]												= model(**UpperCamelCase_							).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     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												UpperCamelCase__   :Dict												= LevitModel.from_pretrained(UpperCamelCase_							)
												self.assertIsNotNone(UpperCamelCase_							)



def 			a      (			)  ->	int:



					'''simple docstring'''






					UpperCamelCase__   :List[str]												= Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
					return image







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

		"""simple docstring"""

		@cached_property
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)




		@slow
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :List[str]												= LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(
							    UpperCamelCase_							)

							UpperCamelCase__   :Dict												= self.default_image_processor
							UpperCamelCase__   :Union[str, Any]												= prepare_img()
							UpperCamelCase__   :List[Any]												= image_processor(images=UpperCamelCase_    ,   return_tensors='''pt'''							).to(UpperCamelCase_							)

							# forward pass
							with torch.no_grad():
												UpperCamelCase__   :List[Any]												= model(**UpperCamelCase_							)

							# verify the logits
							UpperCamelCase__   :int												= torch.Size((1, 1000)							)
							self.assertEqual(outputs.logits.shape    ,   UpperCamelCase_							)

							UpperCamelCase__   :int												= torch.tensor([1.0448, -0.3745, -1.8317]							).to(UpperCamelCase_							)

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



'''simple docstring'''
def 			a      (			)  ->	Union[str, Any]:



					'''simple docstring'''






					UpperCamelCase__   :Optional[int]												= []
					UpperCamelCase__   :int												= 1

					while len(__a   ) < 1e6:
										constant.append(str(__a   )   )
										i += 1

					UpperCamelCase__   :Union[str, Any]												= ''''''.join(__a   )

					return (
					    int(constant[0]   )
					    * int(constant[9]   )
					    * int(constant[99]   )
					    * int(constant[999]   )
					    * int(constant[9999]   )
					    * int(constant[99999]   )
					    * int(constant[999999]   )
					)


if __name__ == "__main__":
		print(solution())