
'''simple docstring'''
import argparse
import json

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    VideoMAEConfig,
    VideoMAEForPreTraining,
    VideoMAEForVideoClassification,
    VideoMAEImageProcessor,
)







def        A_     (						__SCREAMING_SNAKE_CASE						:  Union[str, Any] )				->       Dict:





  """simple docstring"""

  __A		:     Union[str, Any]												=		VideoMAEConfig()

  set_architecture_configs(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )

  if "finetuned" not in model_name:
    __A		:     Union[str, Any]												=		False

  if "finetuned" in model_name:
    __A		:     Dict												=		"""huggingface/label-files"""
    if "kinetics" in model_name:
      __A		:     int												=		400
      __A		:     Optional[int]												=		"""kinetics400-id2label.json"""
    elif "ssv2" in model_name:
      __A		:     Any												=		174
      __A		:     List[str]												=		"""something-something-v2-id2label.json"""
    else:
      raise ValueError("""Model name should either contain 'kinetics' or 'ssv2' in case it's fine-tuned.""" )
    __A		:     List[Any]												=		json.load(open(hf_hub_download(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     repo_type="""dataset""" )			,     """r""" ) )
    __A		:     List[str]												=		{int(__SCREAMING_SNAKE_CASE ): v for k, v in idalabel.items()}
    __A		:     Any												=		idalabel
    __A		:     Union[str, Any]												=		{v: k for k, v in idalabel.items()}

  return config







def        A_     (						__SCREAMING_SNAKE_CASE						:  int			,     __SCREAMING_SNAKE_CASE						:  Tuple )				->       List[Any]:





  """simple docstring"""

  if "small" in model_name:
    __A		:     List[str]												=		384
    __A		:     List[str]												=		1536
    __A		:     List[Any]												=		12
    __A		:     str												=		16
    __A		:     Dict												=		12
    __A		:     Any												=		3
    __A		:     int												=		192
    __A		:     Any												=		768
  elif "large" in model_name:
    __A		:     Tuple												=		1024
    __A		:     Optional[int]												=		4096
    __A		:     Optional[Any]												=		24
    __A		:     List[str]												=		16
    __A		:     str												=		12
    __A		:     Dict												=		8
    __A		:     Dict												=		512
    __A		:     str												=		2048
  elif "huge" in model_name:
    __A		:     Any												=		1280
    __A		:     List[Any]												=		5120
    __A		:     Union[str, Any]												=		32
    __A		:     str												=		16
    __A		:     Optional[Any]												=		12
    __A		:     Dict												=		8
    __A		:     Optional[int]												=		640
    __A		:     str												=		2560
  elif "base" not in model_name:
    raise ValueError("""Model name should include either \"small\", \"base\", \"large\", or \"huge\"""" )







def        A_     (						__SCREAMING_SNAKE_CASE						:  Union[str, Any] )				->       Optional[Any]:





  """simple docstring"""

  if "encoder." in name:
    __A		:     List[str]												=		name.replace("""encoder."""			,     """""" )
  if "cls_token" in name:
    __A		:     List[str]												=		name.replace("""cls_token"""			,     """videomae.embeddings.cls_token""" )
  if "decoder_pos_embed" in name:
    __A		:     List[str]												=		name.replace("""decoder_pos_embed"""			,     """decoder.decoder_pos_embed""" )
  if "pos_embed" in name and "decoder" not in name:
    __A		:     Dict												=		name.replace("""pos_embed"""			,     """videomae.embeddings.position_embeddings""" )
  if "patch_embed.proj" in name:
    __A		:     Dict												=		name.replace("""patch_embed.proj"""			,     """videomae.embeddings.patch_embeddings.projection""" )
  if "patch_embed.norm" in name:
    __A		:     Tuple												=		name.replace("""patch_embed.norm"""			,     """videomae.embeddings.norm""" )
  if "decoder.blocks" in name:
    __A		:     Dict												=		name.replace("""decoder.blocks"""			,     """decoder.decoder_layers""" )
  if "blocks" in name:
    __A		:     Union[str, Any]												=		name.replace("""blocks"""			,     """videomae.encoder.layer""" )
  if "attn.proj" in name:
    __A		:     Tuple												=		name.replace("""attn.proj"""			,     """attention.output.dense""" )
  if "attn" in name and "bias" not in name:
    __A		:     Union[str, Any]												=		name.replace("""attn"""			,     """attention.self""" )
  if "attn" in name:
    __A		:     Optional[int]												=		name.replace("""attn"""			,     """attention.attention""" )
  if "norm1" in name:
    __A		:     Any												=		name.replace("""norm1"""			,     """layernorm_before""" )
  if "norm2" in name:
    __A		:     List[Any]												=		name.replace("""norm2"""			,     """layernorm_after""" )
  if "mlp.fc1" in name:
    __A		:     Union[str, Any]												=		name.replace("""mlp.fc1"""			,     """intermediate.dense""" )
  if "mlp.fc2" in name:
    __A		:     Optional[Any]												=		name.replace("""mlp.fc2"""			,     """output.dense""" )
  if "decoder_embed" in name:
    __A		:     Any												=		name.replace("""decoder_embed"""			,     """decoder.decoder_embed""" )
  if "decoder_norm" in name:
    __A		:     Optional[int]												=		name.replace("""decoder_norm"""			,     """decoder.decoder_norm""" )
  if "decoder_pred" in name:
    __A		:     Dict												=		name.replace("""decoder_pred"""			,     """decoder.decoder_pred""" )
  if "norm.weight" in name and "decoder" not in name and "fc" not in name:
    __A		:     List[str]												=		name.replace("""norm.weight"""			,     """videomae.layernorm.weight""" )
  if "norm.bias" in name and "decoder" not in name and "fc" not in name:
    __A		:     Optional[Any]												=		name.replace("""norm.bias"""			,     """videomae.layernorm.bias""" )
  if "head" in name and "decoder" not in name:
    __A		:     str												=		name.replace("""head"""			,     """classifier""" )

  return name







def        A_     (						__SCREAMING_SNAKE_CASE						:  Optional[int]			,     __SCREAMING_SNAKE_CASE						:  str )				->       Dict:





  """simple docstring"""

  for key in orig_state_dict.copy().keys():
    __A		:     Any												=		orig_state_dict.pop(__SCREAMING_SNAKE_CASE )

    if key.startswith("""encoder.""" ):
      __A		:     Optional[int]												=		key.replace("""encoder."""			,     """""" )

    if "qkv" in key:
      __A		:     Dict												=		key.split(""".""" )
      if key.startswith("""decoder.blocks""" ):
        __A		:     Any												=		config.decoder_hidden_size
        __A		:     Tuple												=		int(key_split[2] )
        __A		:     str												=		"""decoder.decoder_layers."""
        if "weight" in key:
          __A		:     str												=		val[:dim, :]
          __A		:     Any												=		val[dim : dim * 2, :]
          __A		:     int												=		val[-dim:, :]
      else:
        __A		:     Union[str, Any]												=		config.hidden_size
        __A		:     List[Any]												=		int(key_split[1] )
        __A		:     Optional[Any]												=		"""videomae.encoder.layer."""
        if "weight" in key:
          __A		:     Tuple												=		val[:dim, :]
          __A		:     Union[str, Any]												=		val[dim : dim * 2, :]
          __A		:     str												=		val[-dim:, :]
    else:
      __A		:     int												=		val

  return orig_state_dict







def        A_     (						)				->       Optional[int]:





  """simple docstring"""

  __A		:     Tuple												=		hf_hub_download(
      repo_id="""hf-internal-testing/spaghetti-video"""			,     filename="""eating_spaghetti.npy"""			,     repo_type="""dataset""" )
  __A		:     Optional[Any]												=		np.load(__SCREAMING_SNAKE_CASE )
  return list(__SCREAMING_SNAKE_CASE )







def        A_     (						__SCREAMING_SNAKE_CASE						:  Optional[Any]			,     __SCREAMING_SNAKE_CASE						:  str			,     __SCREAMING_SNAKE_CASE						:  Optional[int]			,     __SCREAMING_SNAKE_CASE						:  Dict )				->       Optional[Any]:





  """simple docstring"""

  __A		:     Optional[int]												=		get_videomae_config(__SCREAMING_SNAKE_CASE )

  if "finetuned" in model_name:
    __A		:     str												=		VideoMAEForVideoClassification(__SCREAMING_SNAKE_CASE )
  else:
    __A		:     Tuple												=		VideoMAEForPreTraining(__SCREAMING_SNAKE_CASE )

  # download original checkpoint, hosted on Google Drive
  __A		:     List[Any]												=		"""pytorch_model.bin"""
  gdown.cached_download(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     quiet=__SCREAMING_SNAKE_CASE )
  __A		:     str												=		torch.load(__SCREAMING_SNAKE_CASE			,     map_location="""cpu""" )
  if "model" in files:
    __A		:     int												=		files["""model"""]
  else:
    __A		:     List[str]												=		files["""module"""]
  __A		:     int												=		convert_state_dict(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )

  model.load_state_dict(__SCREAMING_SNAKE_CASE )
  model.eval()

  # verify model on basic input
  __A		:     List[Any]												=		VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]			,     image_std=[0.5, 0.5, 0.5] )
  __A		:     Tuple												=		prepare_video()
  __A		:     Tuple												=		image_processor(__SCREAMING_SNAKE_CASE			,     return_tensors="""pt""" )

  if "finetuned" not in model_name:
    __A		:     Any												=		hf_hub_download(repo_id="""hf-internal-testing/bool-masked-pos"""			,     filename="""bool_masked_pos.pt""" )
    __A		:     List[str]												=		torch.load(__SCREAMING_SNAKE_CASE )

  __A		:     int												=		model(**__SCREAMING_SNAKE_CASE )
  __A		:     List[str]												=		outputs.logits

  __A		:     List[Any]												=		[
      """videomae-small-finetuned-kinetics""",
      """videomae-small-finetuned-ssv2""",
      # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600)
      """videomae-base-short""",
      """videomae-base-short-finetuned-kinetics""",
      """videomae-base""",
      """videomae-base-finetuned-kinetics""",
      """videomae-large""",
      """videomae-large-finetuned-kinetics""",
      """videomae-huge-finetuned-kinetics""",
      # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400)
      """videomae-base-short-ssv2""",
      """videomae-base-short-finetuned-ssv2""",
      """videomae-base-ssv2""",
      """videomae-base-finetuned-ssv2""",
  ]

  # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
  if model_name == "videomae-small-finetuned-kinetics":
    __A		:     Union[str, Any]												=		torch.Size([1, 400] )
    __A		:     Tuple												=		torch.tensor([-0.9_291, -0.4_061, -0.9_307] )
  elif model_name == "videomae-small-finetuned-ssv2":
    __A		:     str												=		torch.Size([1, 174] )
    __A		:     str												=		torch.tensor([0.2_671, -0.4_689, -0.8_235] )
  elif model_name == "videomae-base":
    __A		:     Any												=		torch.Size([1, 1408, 1536] )
    __A		:     Any												=		torch.tensor([[0.7_739, 0.7_968, 0.7_089], [0.6_701, 0.7_487, 0.6_209], [0.4_287, 0.5_158, 0.4_773]] )
  elif model_name == "videomae-base-short":
    __A		:     List[str]												=		torch.Size([1, 1408, 1536] )
    __A		:     Union[str, Any]												=		torch.tensor([[0.7_994, 0.9_612, 0.8_508], [0.7_401, 0.8_958, 0.8_302], [0.5_862, 0.7_468, 0.7_325]] )
    # we verified the loss both for normalized and unnormalized targets for this one
    __A		:     Tuple												=		torch.tensor([0.5_142] ) if config.norm_pix_loss else torch.tensor([0.6_469] )
  elif model_name == "videomae-large":
    __A		:     List[Any]												=		torch.Size([1, 1408, 1536] )
    __A		:     List[Any]												=		torch.tensor([[0.7_149, 0.7_997, 0.6_966], [0.6_768, 0.7_869, 0.6_948], [0.5_139, 0.6_221, 0.5_605]] )
  elif model_name == "videomae-large-finetuned-kinetics":
    __A		:     Union[str, Any]												=		torch.Size([1, 400] )
    __A		:     Optional[Any]												=		torch.tensor([0.0_771, 0.0_011, -0.3_625] )
  elif model_name == "videomae-huge-finetuned-kinetics":
    __A		:     Any												=		torch.Size([1, 400] )
    __A		:     Any												=		torch.tensor([0.2_433, 0.1_632, -0.4_894] )
  elif model_name == "videomae-base-short-finetuned-kinetics":
    __A		:     List[str]												=		torch.Size([1, 400] )
    __A		:     int												=		torch.tensor([0.6_588, 0.0_990, -0.2_493] )
  elif model_name == "videomae-base-finetuned-kinetics":
    __A		:     Dict												=		torch.Size([1, 400] )
    __A		:     Union[str, Any]												=		torch.tensor([0.3_669, -0.0_688, -0.2_421] )
  elif model_name == "videomae-base-short-ssv2":
    __A		:     Dict												=		torch.Size([1, 1408, 1536] )
    __A		:     List[str]												=		torch.tensor([[0.4_712, 0.5_296, 0.5_786], [0.2_278, 0.2_729, 0.4_026], [0.0_352, 0.0_730, 0.2_506]] )
  elif model_name == "videomae-base-short-finetuned-ssv2":
    __A		:     Optional[Any]												=		torch.Size([1, 174] )
    __A		:     Optional[Any]												=		torch.tensor([-0.0_537, -0.1_539, -0.3_266] )
  elif model_name == "videomae-base-ssv2":
    __A		:     int												=		torch.Size([1, 1408, 1536] )
    __A		:     str												=		torch.tensor([[0.8_131, 0.8_727, 0.8_546], [0.7_366, 0.9_377, 0.8_870], [0.5_935, 0.8_874, 0.8_564]] )
  elif model_name == "videomae-base-finetuned-ssv2":
    __A		:     Union[str, Any]												=		torch.Size([1, 174] )
    __A		:     Optional[Any]												=		torch.tensor([0.1_961, -0.8_337, -0.6_389] )
  else:
    raise ValueError(F"Model name not supported. Should be one of {model_names}" )

  # verify logits
  assert logits.shape == expected_shape
  if "finetuned" in model_name:
    assert torch.allclose(logits[0, :3]			,     __SCREAMING_SNAKE_CASE			,     atol=1e-4 )
  else:
    print("""Logits:"""			,     logits[0, :3, :3] )
    assert torch.allclose(logits[0, :3, :3]			,     __SCREAMING_SNAKE_CASE			,     atol=1e-4 )
  print("""Logits ok!""" )

  # verify loss, if applicable
  if model_name == "videomae-base-short":
    __A		:     str												=		outputs.loss
    assert torch.allclose(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     atol=1e-4 )
    print("""Loss ok!""" )

  if pytorch_dump_folder_path is not None:
    print(F"Saving model and image processor to {pytorch_dump_folder_path}" )
    image_processor.save_pretrained(__SCREAMING_SNAKE_CASE )
    model.save_pretrained(__SCREAMING_SNAKE_CASE )

  if push_to_hub:
    print("""Pushing to the hub...""" )
    model.push_to_hub(__SCREAMING_SNAKE_CASE			,     organization="""nielsr""" )


if __name__ == "__main__":
     A__   :		int 		=argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--checkpoint_url',
         default='https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4',
         type=str,
         help=(
             'URL of the original PyTorch checkpoint (on Google Drive) you\'d like to convert. Should be a direct'
             ' download link.'
         ),
     )
     parser.add_argument(
         '--pytorch_dump_folder_path',
         default='/Users/nielsrogge/Documents/VideoMAE/Test',
         type=str,
         help='Path to the output PyTorch model directory.',
     )
     parser.add_argument('--model_name', default='videomae-base', type=str, help='Name of the model.')
     parser.add_argument(
         '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
     )

     A__   :		List[Any] 		=parser.parse_args()
     convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)





'''simple docstring'''
def        A_     (						__SCREAMING_SNAKE_CASE						:  int )				->       int:





  """simple docstring"""

  __A		:     Optional[int]												=		1
  for i in range(1			,     num + 1 ):
    fact *= i
  return fact







def        A_     (						__SCREAMING_SNAKE_CASE						:  int )				->       int:





  """simple docstring"""

  __A		:     List[str]												=		0
  while number > 0:
    __A		:     Union[str, Any]												=		number % 10
    sum_of_digits += last_digit
    __A		:     int												=		number // 10  # Removing the last_digit from the given number
  return sum_of_digits







def        A_     (						__SCREAMING_SNAKE_CASE						:  int = 100 )				->       int:





  """simple docstring"""

  __A		:     Union[str, Any]												=		factorial(__SCREAMING_SNAKE_CASE )
  __A		:     Any												=		split_and_add(__SCREAMING_SNAKE_CASE )
  return result


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



