

'''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   a__    (				__lowerCAmelCase    ):


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : str     	=  self.config_class(**self.inputs_dict    )
      self.parent.assertTrue(hasattr(_SCREAMING_SNAKE_CASE     ,							"hidden_sizes"    )    )
      self.parent.assertTrue(hasattr(_SCREAMING_SNAKE_CASE     ,							"num_attention_heads"    )    )




class   a__    :


   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     ,							):





      """simple docstring"""





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


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : Tuple     	=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

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

      _lowercase     : Tuple     	=  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"""





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





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






   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : int     	=  self.prepare_config_and_inputs()
      _lowercase	, _lowercase	, _lowercase     : int     	=  config_and_inputs
      _lowercase     : Dict     	=  {"pixel_values": pixel_values}
      return config, inputs_dict




@require_torch
class   a__    (				__lowerCAmelCase    , __lowerCAmelCase    , unittest.TestCase    ):
   _SCREAMING_SNAKE_CASE       :	List[Any]      			=				(
       (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
       if is_torch_available()
       else ()
   )
   _SCREAMING_SNAKE_CASE       :	Tuple      			=				(
       {
           """feature-extraction""": LevitModel,
           """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
       }
       if is_torch_available()
       else {}
   )

   _SCREAMING_SNAKE_CASE       :	str      			=				False
   _SCREAMING_SNAKE_CASE       :	int      			=				False
   _SCREAMING_SNAKE_CASE       :	Optional[int]      			=				False
   _SCREAMING_SNAKE_CASE       :	Tuple      			=				False
   _SCREAMING_SNAKE_CASE       :	List[Any]      			=				False


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : List[Any]     	=  LevitModelTester(self    )
      _lowercase     : Union[str, Any]     	=  ConfigTester(self     ,							config_class=_SCREAMING_SNAKE_CASE     ,							has_text_modality=_SCREAMING_SNAKE_CASE     ,							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"""





      _lowercase	, _lowercase     : Dict     	=  self.model_tester.prepare_config_and_inputs_for_common()

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

         _lowercase     : str     	=  ["pixel_values"]
         self.assertListEqual(arg_names[:1]     ,							_SCREAMING_SNAKE_CASE    )


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      def check_hidden_states_output(_UpperCamelCase     ,							_UpperCamelCase     ,							_UpperCamelCase    ):
         _lowercase     : Optional[Any]     	=  model_class(_SCREAMING_SNAKE_CASE    )
         model.to(_SCREAMING_SNAKE_CASE    )
         model.eval()

         with torch.no_grad():
            _lowercase     : Optional[Any]     	=  model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE    )    )

         _lowercase     : Optional[int]     	=  outputs.hidden_states

         _lowercase     : Union[str, Any]     	=  len(self.model_tester.depths    ) + 1
         self.assertEqual(len(_SCREAMING_SNAKE_CASE    )     ,							_SCREAMING_SNAKE_CASE    )

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

      for model_class in self.all_model_classes:
         _lowercase     : int     	=  True
         check_hidden_states_output(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE    )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         _lowercase     : Any     	=  True

         check_hidden_states_output(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE    )


   @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"""





      _lowercase     : int     	=  super()._prepare_for_class(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE     ,							return_labels=_SCREAMING_SNAKE_CASE    )

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

      return inputs_dict


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : Tuple     	=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE    )


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : Any     	=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE    )


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      if not self.model_tester.is_training:
         return

      _lowercase	, _lowercase     : List[Any]     	=  self.model_tester.prepare_config_and_inputs_for_common()
      _lowercase     : Tuple     	=  True

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


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase	, _lowercase     : Dict     	=  self.model_tester.prepare_config_and_inputs_for_common()
      if not self.model_tester.is_training:
         return

      _lowercase     : Optional[Any]     	=  False
      _lowercase     : List[str]     	=  True

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


   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase	, _lowercase     : str     	=  self.model_tester.prepare_config_and_inputs_for_common()

      _lowercase     : Union[str, Any]     	=  [
          {"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(_SCREAMING_SNAKE_CASE    ),
             ]
             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     : str     	=  problem_type["title"]
               _lowercase     : List[str]     	=  problem_type["num_labels"]

               _lowercase     : Dict     	=  model_class(_SCREAMING_SNAKE_CASE    )
               model.to(_SCREAMING_SNAKE_CASE    )
               model.train()

               _lowercase     : Any     	=  self._prepare_for_class(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE     ,							return_labels=_SCREAMING_SNAKE_CASE    )

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

               _lowercase     : List[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=_SCREAMING_SNAKE_CASE    ) as warning_list:
                  _lowercase     : str     	=  model(**_SCREAMING_SNAKE_CASE    ).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]:
         _lowercase     : Any     	=  LevitModel.from_pretrained(_SCREAMING_SNAKE_CASE    )
         self.assertIsNotNone(_SCREAMING_SNAKE_CASE    )







def    _A						(      )     ->      Dict:
   _lowercase     : Any     	=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"	)
   return image


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


   @cached_property
   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )






   @slow
   def 		_lowerCamelCase  (					self    ):





      """simple docstring"""





      _lowercase     : int     	=  LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(
          _SCREAMING_SNAKE_CASE    )

      _lowercase     : Any     	=  self.default_image_processor
      _lowercase     : int     	=  prepare_img()
      _lowercase     : Optional[Any]     	=  image_processor(images=_SCREAMING_SNAKE_CASE     ,							return_tensors="pt"    ).to(_SCREAMING_SNAKE_CASE    )

      # forward pass
      with torch.no_grad():
         _lowercase     : Dict     	=  model(**_SCREAMING_SNAKE_CASE    )

      # verify the logits
      _lowercase     : Optional[Any]     	=  torch.Size((1, 1000)    )
      self.assertEqual(outputs.logits.shape     ,							_SCREAMING_SNAKE_CASE    )

      _lowercase     : int     	=  torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]    ).to(_SCREAMING_SNAKE_CASE    )

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












'''simple docstring'''





from math import factorial





def       __a      (  _UpperCamelCase:       int = 100       )		->					int:

     """simple docstring"""




     return sum(map(_UpperCamelCase   ,		str(factorial(_UpperCamelCase       )       )       )       )


if __name__ == "__main__":
   print(solution(int(input('''Enter the Number: ''').strip())))


