





'''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 				__snake_case     (					_snake_case							):





	def   _snake_case   (		self		)      ->		Optional[int]:
		snake_case__	       =   self.config_class(**self.inputs_dict		)
		self.parent.assertTrue(hasattr(UpperCamelCase_      ,       'hidden_sizes'		)		)
		self.parent.assertTrue(hasattr(UpperCamelCase_      ,       'num_attention_heads'		)		)






class 				__snake_case     :





	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.0_2      ,       UpperCamelCase_=True      ,       UpperCamelCase_=True      ,       UpperCamelCase_=2      ,       )      ->		Optional[Any]:
		snake_case__	       =   parent
		snake_case__	       =   batch_size
		snake_case__	       =   image_size
		snake_case__	       =   num_channels
		snake_case__	       =   kernel_size
		snake_case__	       =   stride
		snake_case__	       =   padding
		snake_case__	       =   hidden_sizes
		snake_case__	       =   num_attention_heads
		snake_case__	       =   depths
		snake_case__	       =   key_dim
		snake_case__	       =   drop_path_rate
		snake_case__	       =   patch_size
		snake_case__	       =   attention_ratio
		snake_case__	       =   mlp_ratio
		snake_case__	       =   initializer_range
		snake_case__	       =   [
		    ['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],
		]
		snake_case__	       =   is_training
		snake_case__	       =   use_labels
		snake_case__	       =   num_labels
		snake_case__	       =   initializer_range





	def   _snake_case   (		self		)      ->		Tuple:
		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.num_labels		)

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





	def   _snake_case   (		self		)      ->		Optional[Any]:
		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   _snake_case   (		self      ,       UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_		)      ->		List[str]:
		snake_case__	       =   LevitModel(config=UpperCamelCase_		)
		model.to(UpperCamelCase_		)
		model.eval()
		snake_case__	       =   model(UpperCamelCase_		)
		snake_case__	       =   (self.image_size, self.image_size)
		snake_case__       ,  snake_case__	       =   image_size[0], image_size[1]
		for _ in range(4		):
			snake_case__	       =   floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1		)
			snake_case__	       =   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   _snake_case   (		self      ,       UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_		)      ->		Union[str, Any]:
		snake_case__	       =   self.num_labels
		snake_case__	       =   LevitForImageClassification(UpperCamelCase_		)
		model.to(UpperCamelCase_		)
		model.eval()
		snake_case__	       =   model(UpperCamelCase_      ,       labels=UpperCamelCase_		)
		self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.num_labels)		)





	def   _snake_case   (		self		)      ->		str:
		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     (					_snake_case       ,       _snake_case       ,       unittest.TestCase							):
	__lowerCAmelCase       						=  (
	    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
	    if is_torch_available()
	    else ()
	)
	__lowerCAmelCase       						=  (
	    {
	        'feature-extraction': LevitModel,
	        'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
	    }
	    if is_torch_available()
	    else {}
	)

	__lowerCAmelCase       						=  False
	__lowerCAmelCase       						=  False
	__lowerCAmelCase       						=  False
	__lowerCAmelCase       						=  False
	__lowerCAmelCase       						=  False





	def   _snake_case   (		self		)      ->		int:
		snake_case__	       =   LevitModelTester(self		)
		snake_case__	       =   ConfigTester(self      ,       config_class=UpperCamelCase_      ,       has_text_modality=UpperCamelCase_      ,       hidden_size=37		)





	def   _snake_case   (		self		)      ->		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		)      ->		Any:
		return





	@unittest.skip(reason='Levit does not use inputs_embeds'		)
	def   _snake_case   (		self		)      ->		List[Any]:
		pass





	@unittest.skip(reason='Levit does not support input and output embeddings'		)
	def   _snake_case   (		self		)      ->		int:
		pass





	@unittest.skip(reason='Levit does not output attentions'		)
	def   _snake_case   (		self		)      ->		str:
		pass





	def   _snake_case   (		self		)      ->		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_		)





	def   _snake_case   (		self		)      ->		Union[str, Any]:

		def check_hidden_states_output(UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_		):
			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__	       =   len(self.model_tester.depths		) + 1
			self.assertEqual(len(UpperCamelCase_		)      ,       UpperCamelCase_		)

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

		snake_case__       ,  snake_case__	       =   self.model_tester.prepare_config_and_inputs_for_common()

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

			# check that output_hidden_states also work using config
			del inputs_dict["output_hidden_states"]
			snake_case__	       =   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   _snake_case   (		self		)      ->		Union[str, Any]:
		pass





	def   _snake_case   (		self      ,       UpperCamelCase_      ,       UpperCamelCase_      ,       UpperCamelCase_=False		)      ->		str:
		snake_case__	       =   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   _snake_case   (		self		)      ->		Dict:
		snake_case__	       =   self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*UpperCamelCase_		)





	def   _snake_case   (		self		)      ->		str:
		snake_case__	       =   self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_		)





	def   _snake_case   (		self		)      ->		Tuple:

		if not self.model_tester.is_training:
			return

		snake_case__       ,  snake_case__	       =   self.model_tester.prepare_config_and_inputs_for_common()
		snake_case__	       =   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
			snake_case__	       =   model_class(UpperCamelCase_		)
			model.to(UpperCamelCase_		)
			model.train()
			snake_case__	       =   self._prepare_for_class(UpperCamelCase_      ,       UpperCamelCase_      ,       return_labels=UpperCamelCase_		)
			snake_case__	       =   model(**UpperCamelCase_		).loss
			loss.backward()





	def   _snake_case   (		self		)      ->		int:
		snake_case__       ,  snake_case__	       =   self.model_tester.prepare_config_and_inputs_for_common()
		if not self.model_tester.is_training:
			return

		snake_case__	       =   False
		snake_case__	       =   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
			snake_case__	       =   model_class(UpperCamelCase_		)
			model.gradient_checkpointing_enable()
			model.to(UpperCamelCase_		)
			model.train()
			snake_case__	       =   self._prepare_for_class(UpperCamelCase_      ,       UpperCamelCase_      ,       return_labels=UpperCamelCase_		)
			snake_case__	       =   model(**UpperCamelCase_		).loss
			loss.backward()





	def   _snake_case   (		self		)      ->		List[Any]:
		snake_case__       ,  snake_case__	       =   self.model_tester.prepare_config_and_inputs_for_common()

		snake_case__	       =   [
		    {'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']}'''		):
					snake_case__	       =   problem_type['title']
					snake_case__	       =   problem_type['num_labels']

					snake_case__	       =   model_class(UpperCamelCase_		)
					model.to(UpperCamelCase_		)
					model.train()

					snake_case__	       =   self._prepare_for_class(UpperCamelCase_      ,       UpperCamelCase_      ,       return_labels=UpperCamelCase_		)

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

					snake_case__	       =   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:
						snake_case__	       =   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   _snake_case   (		self		)      ->		Union[str, Any]:

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





def 						__lowerCamelCase			(	)   ->Optional[Any]:
	snake_case__	       =   Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
	return image







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





	@cached_property
	def   _snake_case   (		self		)      ->		str:
		return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)





	@slow
	def   _snake_case   (		self		)      ->		Optional[Any]:
		snake_case__	       =   LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(
		    UpperCamelCase_		)

		snake_case__	       =   self.default_image_processor
		snake_case__	       =   prepare_img()
		snake_case__	       =   image_processor(images=UpperCamelCase_      ,       return_tensors='pt'		).to(UpperCamelCase_		)

		# forward pass
		with torch.no_grad():
			snake_case__	       =   model(**UpperCamelCase_		)

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

		snake_case__	       =   torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]		).to(UpperCamelCase_		)

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










'''simple docstring'''

import os
from math import logaa

def     __magic_name__							(				__UpperCAmelCase = "base_exp.txt"   )    ->       int:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							0
   __SCREAMING_SNAKE_CASE   				=							0
   for i, line in enumerate(open(os.path.join(os.path.dirname(__UpperCAmelCase   )				,						__UpperCAmelCase   )   )   ):
      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							list(map(__UpperCAmelCase				,						line.split(""","""   )   )   )
      if x * logaa(__UpperCAmelCase   ) > largest:
         __SCREAMING_SNAKE_CASE   				=							x * logaa(__UpperCAmelCase   )
         __SCREAMING_SNAKE_CASE   				=							i + 1
   return result


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





