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


				'''simple docstring'''






				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						A_		:				Any     =      self.config_class(**self.inputs_dict					)
						self.parent.assertTrue(hasattr(__a		,	'hidden_sizes'					)					)
						self.parent.assertTrue(hasattr(__a		,	'num_attention_heads'					)					)





class UpperCAmelCase						:


				'''simple docstring'''






				def __init__(						self		,	lowercase		,	lowercase=1_3		,	lowercase=6_4		,	lowercase=3		,	lowercase=3		,	lowercase=2		,	lowercase=1		,	lowercase=1_6		,	lowercase=[1_2_8, 2_5_6, 3_8_4]		,	lowercase=[4, 6, 8]		,	lowercase=[2, 3, 4]		,	lowercase=[1_6, 1_6, 1_6]		,	lowercase=0		,	lowercase=[2, 2, 2]		,	lowercase=[2, 2, 2]		,	lowercase=0.02		,	lowercase=True		,	lowercase=True		,	lowercase=2		,	):



						"""simple docstring"""





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



						"""simple docstring"""





						A_		:				Dict     =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

						A_		:				Union[str, 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		,	lowercase		,	lowercase		,	lowercase					):



						"""simple docstring"""





						A_		:				List[str]     =      LevitModel(config=__a					)
						model.to(__a					)
						model.eval()
						A_		:				Union[str, Any]     =      model(__a					)
						A_		:				str     =      (self.image_size, self.image_size)
						A_   ,			A_		:				Tuple     =      image_size[0], image_size[1]
						for _ in range(4					):
								A_		:				Tuple     =      floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1					)
								A_		:				str     =      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		,	lowercase		,	lowercase		,	lowercase					):



						"""simple docstring"""





						A_		:				str     =      self.num_labels
						A_		:				Optional[Any]     =      LevitForImageClassification(__a					)
						model.to(__a					)
						model.eval()
						A_		:				Union[str, Any]     =      model(__a		,	labels=__a					)
						self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.num_labels)					)







				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						A_		:				Optional[Any]     =      self.prepare_config_and_inputs()
						A_   ,			A_   ,			A_		:				int     =      config_and_inputs
						A_		:				Optional[int]     =      {'pixel_values': pixel_values}
						return config, inputs_dict





@require_torch
class UpperCAmelCase						(					lowerCAmelCase__					,       lowerCAmelCase__					,       unittest.TestCase  ):


				'''simple docstring'''






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



						"""simple docstring"""





						A_		:				int     =      LevitModelTester(self					)
						A_		:				str     =      ConfigTester(self		,	config_class=__a		,	has_text_modality=__a		,	hidden_size=3_7					)
				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"""





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

						for model_class in self.all_model_classes:
								A_		:				Optional[int]     =      model_class(__a					)
								A_		:				List[str]     =      inspect.signature(model.forward					)
								# signature.parameters is an OrderedDict => so arg_names order is deterministic
								A_		:				Optional[Any]     =      [*signature.parameters.keys()]

								A_		:				Union[str, Any]     =      ['pixel_values']
								self.assertListEqual(arg_names[:1]		,	__a					)
				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						def check_hidden_states_output(lowercase		,	lowercase		,	lowercase					):
								A_		:				str     =      model_class(__a					)
								model.to(__a					)
								model.eval()

								with torch.no_grad():
										A_		:				Any     =      model(**self._prepare_for_class(__a		,	__a					)					)

								A_		:				Tuple     =      outputs.hidden_states

								A_		:				Tuple     =      len(self.model_tester.depths					) + 1
								self.assertEqual(len(__a					)		,	__a					)

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

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

						for model_class in self.all_model_classes:
								A_		:				str     =      True
								check_hidden_states_output(__a		,	__a		,	__a					)

								# check that output_hidden_states also work using config
								del inputs_dict["output_hidden_states"]
								A_		:				str     =      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   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						pass
				def   lowerCAmelCase_   (						self		,	lowercase		,	lowercase		,	lowercase=False					):



						"""simple docstring"""





						A_		:				Tuple     =      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   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						A_		:				List[Any]     =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__a					)
				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						A_		:				int     =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__a					)
				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						if not self.model_tester.is_training:
								return

						A_   ,			A_		:				Dict     =      self.model_tester.prepare_config_and_inputs_for_common()
						A_		:				Dict     =      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
								A_		:				Optional[int]     =      model_class(__a					)
								model.to(__a					)
								model.train()
								A_		:				Dict     =      self._prepare_for_class(__a		,	__a		,	return_labels=__a					)
								A_		:				Optional[int]     =      model(**__a					).loss
								loss.backward()
				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						A_   ,			A_		:				Optional[Any]     =      self.model_tester.prepare_config_and_inputs_for_common()
						if not self.model_tester.is_training:
								return

						A_		:				Union[str, Any]     =      False
						A_		:				Optional[int]     =      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
								A_		:				Any     =      model_class(__a					)
								model.gradient_checkpointing_enable()
								model.to(__a					)
								model.train()
								A_		:				Any     =      self._prepare_for_class(__a		,	__a		,	return_labels=__a					)
								A_		:				Optional[int]     =      model(**__a					).loss
								loss.backward()
				def   lowerCAmelCase_   (						self					):



						"""simple docstring"""





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

						A_		:				Optional[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(__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']}'''					):
												A_		:				Dict     =      problem_type['title']
												A_		:				List[Any]     =      problem_type['num_labels']

												A_		:				Optional[Any]     =      model_class(__a					)
												model.to(__a					)
												model.train()

												A_		:				List[str]     =      self._prepare_for_class(__a		,	__a		,	return_labels=__a					)

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

												A_		:				str     =      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:
														A_		:				Optional[int]     =      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   lowerCAmelCase_   (						self					):



						"""simple docstring"""





						for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								A_		:				Any     =      LevitModel.from_pretrained(__a					)
								self.assertIsNotNone(__a					)




def 				UpperCamelCase						(       ):
		'''simple docstring'''




		A_		:				Union[str, Any]     =      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
		return image





@require_torch
@require_vision
class UpperCAmelCase						(					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"""





						A_		:				List[Any]     =      LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]					).to(
						    __a					)

						A_		:				Any     =      self.default_image_processor
						A_		:				Optional[Any]     =      prepare_img()
						A_		:				Union[str, Any]     =      image_processor(images=__a		,	return_tensors='pt'					).to(__a					)

						# forward pass
						with torch.no_grad():
								A_		:				str     =      model(**__a					)

						# verify the logits
						A_		:				Any     =      torch.Size((1, 1_0_0_0)					)
						self.assertEqual(outputs.logits.shape		,	__a					)

						A_		:				Union[str, Any]     =      torch.tensor([1.0448, -0.3745, -1.8317]					).to(__a					)

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










"""simple docstring"""


def _lowerCamelCase	(		):

			'''simple docstring'''




			__lowerCAmelCase				    =			[]
			__lowerCAmelCase				    =			1

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

			__lowerCAmelCase				    =			"".join(_UpperCamelCase      )

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


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




