






'''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 		_UpperCAmelCase   (							__A							:   Any      ):
				a_		:  Any											=      VideoMAEConfig()

				set_architecture_configs(__SCREAMING_SNAKE_CASE						,		__SCREAMING_SNAKE_CASE      )

				if "finetuned" not in model_name:
								a_		:  Dict											=      False

				if "finetuned" in model_name:
								a_		:  List[str]											=      "huggingface/label-files"
								if "kinetics" in model_name:
												a_		:  List[Any]											=      4_00
												a_		:  int											=      "kinetics400-id2label.json"
								elif "ssv2" in model_name:
												a_		:  Union[str, Any]											=      1_74
												a_		:  Any											=      "something-something-v2-id2label.json"
								else:
												raise ValueError('''Model name should either contain \'kinetics\' or \'ssv2\' in case it\'s fine-tuned.'''      )
								a_		:  str											=      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_		:  Optional[int]											=      idalabel
								a_		:  int											=      {v: k for k, v in idalabel.items()}

				return config





def 		_UpperCAmelCase   (							__A							:   Any						,		__A							:   str      ):






				if "small" in model_name:
								a_		:  Optional[int]											=      3_84
								a_		:  Tuple											=      15_36
								a_		:  Dict											=      12
								a_		:  int											=      16
								a_		:  Optional[int]											=      12
								a_		:  Union[str, Any]											=      3
								a_		:  int											=      1_92
								a_		:  Optional[int]											=      7_68
				elif "large" in model_name:
								a_		:  Any											=      10_24
								a_		:  List[str]											=      40_96
								a_		:  Tuple											=      24
								a_		:  Tuple											=      16
								a_		:  Union[str, Any]											=      12
								a_		:  List[str]											=      8
								a_		:  Optional[int]											=      5_12
								a_		:  Optional[Any]											=      20_48
				elif "huge" in model_name:
								a_		:  List[Any]											=      12_80
								a_		:  Dict											=      51_20
								a_		:  List[Any]											=      32
								a_		:  Optional[int]											=      16
								a_		:  List[str]											=      12
								a_		:  List[Any]											=      8
								a_		:  Optional[int]											=      6_40
								a_		:  Any											=      25_60
				elif "base" not in model_name:
								raise ValueError('''Model name should include either \"small\", \"base\", \"large\", or \"huge\"'''      )





def 		_UpperCAmelCase   (							__A							:   Optional[Any]      ):






				if "encoder." in name:
								a_		:  int											=      name.replace('''encoder.'''						,		''''''      )
				if "cls_token" in name:
								a_		:  Dict											=      name.replace('''cls_token'''						,		'''videomae.embeddings.cls_token'''      )
				if "decoder_pos_embed" in name:
								a_		:  Tuple											=      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_		:  List[Any]											=      name.replace('''patch_embed.proj'''						,		'''videomae.embeddings.patch_embeddings.projection'''      )
				if "patch_embed.norm" in name:
								a_		:  str											=      name.replace('''patch_embed.norm'''						,		'''videomae.embeddings.norm'''      )
				if "decoder.blocks" in name:
								a_		:  Optional[int]											=      name.replace('''decoder.blocks'''						,		'''decoder.decoder_layers'''      )
				if "blocks" in name:
								a_		:  int											=      name.replace('''blocks'''						,		'''videomae.encoder.layer'''      )
				if "attn.proj" in name:
								a_		:  Union[str, Any]											=      name.replace('''attn.proj'''						,		'''attention.output.dense'''      )
				if "attn" in name and "bias" not in name:
								a_		:  Tuple											=      name.replace('''attn'''						,		'''attention.self'''      )
				if "attn" in name:
								a_		:  Tuple											=      name.replace('''attn'''						,		'''attention.attention'''      )
				if "norm1" in name:
								a_		:  int											=      name.replace('''norm1'''						,		'''layernorm_before'''      )
				if "norm2" in name:
								a_		:  List[Any]											=      name.replace('''norm2'''						,		'''layernorm_after'''      )
				if "mlp.fc1" in name:
								a_		:  Any											=      name.replace('''mlp.fc1'''						,		'''intermediate.dense'''      )
				if "mlp.fc2" in name:
								a_		:  int											=      name.replace('''mlp.fc2'''						,		'''output.dense'''      )
				if "decoder_embed" in name:
								a_		:  List[str]											=      name.replace('''decoder_embed'''						,		'''decoder.decoder_embed'''      )
				if "decoder_norm" in name:
								a_		:  Union[str, Any]											=      name.replace('''decoder_norm'''						,		'''decoder.decoder_norm'''      )
				if "decoder_pred" in name:
								a_		:  Optional[Any]											=      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_		:  Optional[int]											=      name.replace('''head'''						,		'''classifier'''      )

				return name





def 		_UpperCAmelCase   (							__A							:   Any						,		__A							:   Optional[Any]      ):






				for key in orig_state_dict.copy().keys():
								a_		:  Dict											=      orig_state_dict.pop(__SCREAMING_SNAKE_CASE      )

								if key.startswith('''encoder.'''      ):
												a_		:  List[str]											=      key.replace('''encoder.'''						,		''''''      )

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

				return orig_state_dict





def 		_UpperCAmelCase   (							):
				a_		:  List[str]											=      hf_hub_download(
				    repo_id='''hf-internal-testing/spaghetti-video'''						,		filename='''eating_spaghetti.npy'''						,		repo_type='''dataset'''      )
				a_		:  Union[str, Any]											=      np.load(__SCREAMING_SNAKE_CASE      )
				return list(__SCREAMING_SNAKE_CASE      )





def 		_UpperCAmelCase   (							__A							:   Optional[Any]						,		__A							:   int						,		__A							:   str						,		__A							:   Dict      ):
				a_		:  List[str]											=      get_videomae_config(__SCREAMING_SNAKE_CASE      )

				if "finetuned" in model_name:
								a_		:  int											=      VideoMAEForVideoClassification(__SCREAMING_SNAKE_CASE      )
				else:
								a_		:  str											=      VideoMAEForPreTraining(__SCREAMING_SNAKE_CASE      )

				# download original checkpoint, hosted on Google Drive
				a_		:  Dict											=      "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_		:  str											=      files["model"]
				else:
								a_		:  Optional[Any]											=      files["module"]
				a_		:  Any											=      convert_state_dict(__SCREAMING_SNAKE_CASE						,		__SCREAMING_SNAKE_CASE      )

				model.load_state_dict(__SCREAMING_SNAKE_CASE      )
				model.eval()

				# verify model on basic input
				a_		:  Tuple											=      VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]						,		image_std=[0.5, 0.5, 0.5]      )
				a_		:  Union[str, Any]											=      prepare_video()
				a_		:  str											=      image_processor(__SCREAMING_SNAKE_CASE						,		return_tensors='''pt'''      )

				if "finetuned" not in model_name:
								a_		:  Tuple											=      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_		:  int											=      outputs.logits

				a_		:  Dict											=      [
				    "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_		:  Tuple											=      torch.Size([1, 4_00]      )
								a_		:  Dict											=      torch.tensor([-0.9291, -0.4061, -0.9307]      )
				elif model_name == "videomae-small-finetuned-ssv2":
								a_		:  Union[str, Any]											=      torch.Size([1, 1_74]      )
								a_		:  str											=      torch.tensor([0.2671, -0.4689, -0.8235]      )
				elif model_name == "videomae-base":
								a_		:  List[str]											=      torch.Size([1, 14_08, 15_36]      )
								a_		:  Dict											=      torch.tensor([[0.7739, 0.7968, 0.7089], [0.6701, 0.7487, 0.6209], [0.4287, 0.5158, 0.4773]]      )
				elif model_name == "videomae-base-short":
								a_		:  Any											=      torch.Size([1, 14_08, 15_36]      )
								a_		:  Any											=      torch.tensor([[0.7994, 0.9612, 0.8508], [0.7401, 0.8958, 0.8302], [0.5862, 0.7468, 0.7325]]      )
								# we verified the loss both for normalized and unnormalized targets for this one
								a_		:  Tuple											=      torch.tensor([0.5142]      ) if config.norm_pix_loss else torch.tensor([0.6469]      )
				elif model_name == "videomae-large":
								a_		:  Union[str, Any]											=      torch.Size([1, 14_08, 15_36]      )
								a_		:  Any											=      torch.tensor([[0.7149, 0.7997, 0.6966], [0.6768, 0.7869, 0.6948], [0.5139, 0.6221, 0.5605]]      )
				elif model_name == "videomae-large-finetuned-kinetics":
								a_		:  Tuple											=      torch.Size([1, 4_00]      )
								a_		:  Any											=      torch.tensor([0.0771, 0.0011, -0.3625]      )
				elif model_name == "videomae-huge-finetuned-kinetics":
								a_		:  Optional[Any]											=      torch.Size([1, 4_00]      )
								a_		:  str											=      torch.tensor([0.2433, 0.1632, -0.4894]      )
				elif model_name == "videomae-base-short-finetuned-kinetics":
								a_		:  Optional[int]											=      torch.Size([1, 4_00]      )
								a_		:  List[Any]											=      torch.tensor([0.6588, 0.0990, -0.2493]      )
				elif model_name == "videomae-base-finetuned-kinetics":
								a_		:  Optional[int]											=      torch.Size([1, 4_00]      )
								a_		:  Dict											=      torch.tensor([0.3669, -0.0688, -0.2421]      )
				elif model_name == "videomae-base-short-ssv2":
								a_		:  List[Any]											=      torch.Size([1, 14_08, 15_36]      )
								a_		:  Optional[Any]											=      torch.tensor([[0.4712, 0.5296, 0.5786], [0.2278, 0.2729, 0.4026], [0.0352, 0.0730, 0.2506]]      )
				elif model_name == "videomae-base-short-finetuned-ssv2":
								a_		:  List[Any]											=      torch.Size([1, 1_74]      )
								a_		:  Union[str, Any]											=      torch.tensor([-0.0537, -0.1539, -0.3266]      )
				elif model_name == "videomae-base-ssv2":
								a_		:  List[str]											=      torch.Size([1, 14_08, 15_36]      )
								a_		:  Optional[Any]											=      torch.tensor([[0.8131, 0.8727, 0.8546], [0.7366, 0.9377, 0.8870], [0.5935, 0.8874, 0.8564]]      )
				elif model_name == "videomae-base-finetuned-ssv2":
								a_		:  int											=      torch.Size([1, 1_74]      )
								a_		:  Union[str, Any]											=      torch.tensor([0.1961, -0.8337, -0.6389]      )
				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_		:  int											=      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__":
		__lowerCAmelCase       		=      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.'
		)

		__lowerCAmelCase       		=      parser.parse_args()
		convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)












'''simple docstring'''







import sys

__lowerCAmelCase       		=      (
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)





def 		_UpperCAmelCase   (							__A							:   str      ):
				a_		:  Tuple											=      1
				for digit in s:
								product *= int(__A      )
				return product





def 		_UpperCAmelCase   (							__A							:   str = N      ):
				a_		:  Dict											=      -sys.maxsize - 1
				a_		:  Optional[int]											=      n[:13]
				a_		:  str											=      13
				while cur_index < len(__A      ) - 13:
								if int(n[cur_index]      ) >= int(substr[0]      ):
												a_		:  Tuple											=      substr[1:] + n[cur_index]
												cur_index += 1
								else:
												a_		:  Dict											=      max(__A						,		str_eval(__A      )      )
												a_		:  List[str]											=      n[cur_index : cur_index + 13]
												cur_index += 13
				return largest_product


if __name__ == "__main__":
		print(F"""{solution() = }""")




