



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				(UpperCamelCase		:      Tuple )  ->Tuple:



			'''simple docstring'''







			lowerCamelCase__ :      Any								=		VideoMAEConfig()

			set_architecture_configs(UpperCamelCase      ,			UpperCamelCase )

			if "finetuned" not in model_name:
						lowerCamelCase__ :      Optional[Any]								=		False

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

			return config






def      _A				(UpperCamelCase		:      str      ,			UpperCamelCase		:      str )  ->int:



			'''simple docstring'''







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






def      _A				(UpperCamelCase		:      Dict )  ->List[str]:



			'''simple docstring'''







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

			return name






def      _A				(UpperCamelCase		:      List[str]      ,			UpperCamelCase		:      Union[str, Any] )  ->List[Any]:



			'''simple docstring'''







			for key in orig_state_dict.copy().keys():
						lowerCamelCase__ :      List[str]								=		orig_state_dict.pop(UpperCamelCase )

						if key.startswith("""encoder.""" ):
									lowerCamelCase__ :      Optional[Any]								=		key.replace("""encoder."""      ,			"""""" )

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

			return orig_state_dict






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



			'''simple docstring'''







			lowerCamelCase__ :      Tuple								=		hf_hub_download(
			    repo_id="""hf-internal-testing/spaghetti-video"""      ,			filename="""eating_spaghetti.npy"""      ,			repo_type="""dataset""" )
			lowerCamelCase__ :      Dict								=		np.load(UpperCamelCase )
			return list(UpperCamelCase )






def      _A				(UpperCamelCase		:      Optional[Any]      ,			UpperCamelCase		:      List[str]      ,			UpperCamelCase		:      Optional[Any]      ,			UpperCamelCase		:      Dict )  ->Any:



			'''simple docstring'''







			lowerCamelCase__ :      Dict								=		get_videomae_config(UpperCamelCase )

			if "finetuned" in model_name:
						lowerCamelCase__ :      Any								=		VideoMAEForVideoClassification(UpperCamelCase )
			else:
						lowerCamelCase__ :      Tuple								=		VideoMAEForPreTraining(UpperCamelCase )

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

			model.load_state_dict(UpperCamelCase )
			model.eval()

			# verify model on basic input
			lowerCamelCase__ :      Union[str, Any]								=		VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]      ,			image_std=[0.5, 0.5, 0.5] )
			lowerCamelCase__ :      str								=		prepare_video()
			lowerCamelCase__ :      Any								=		image_processor(UpperCamelCase      ,			return_tensors="""pt""" )

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

			lowerCamelCase__ :      str								=		model(**UpperCamelCase )
			lowerCamelCase__ :      int								=		outputs.logits

			lowerCamelCase__ :      Tuple								=		[
			    """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":
						lowerCamelCase__ :      Tuple								=		torch.Size([1, 400] )
						lowerCamelCase__ :      List[Any]								=		torch.tensor([-0.9_291, -0.4_061, -0.9_307] )
			elif model_name == "videomae-small-finetuned-ssv2":
						lowerCamelCase__ :      Tuple								=		torch.Size([1, 174] )
						lowerCamelCase__ :      Optional[int]								=		torch.tensor([0.2_671, -0.4_689, -0.8_235] )
			elif model_name == "videomae-base":
						lowerCamelCase__ :      Any								=		torch.Size([1, 1408, 1536] )
						lowerCamelCase__ :      List[str]								=		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":
						lowerCamelCase__ :      List[str]								=		torch.Size([1, 1408, 1536] )
						lowerCamelCase__ :      int								=		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
						lowerCamelCase__ :      Optional[int]								=		torch.tensor([0.5_142] ) if config.norm_pix_loss else torch.tensor([0.6_469] )
			elif model_name == "videomae-large":
						lowerCamelCase__ :      List[str]								=		torch.Size([1, 1408, 1536] )
						lowerCamelCase__ :      Tuple								=		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":
						lowerCamelCase__ :      Any								=		torch.Size([1, 400] )
						lowerCamelCase__ :      Dict								=		torch.tensor([0.0_771, 0.0_011, -0.3_625] )
			elif model_name == "videomae-huge-finetuned-kinetics":
						lowerCamelCase__ :      List[str]								=		torch.Size([1, 400] )
						lowerCamelCase__ :      List[Any]								=		torch.tensor([0.2_433, 0.1_632, -0.4_894] )
			elif model_name == "videomae-base-short-finetuned-kinetics":
						lowerCamelCase__ :      int								=		torch.Size([1, 400] )
						lowerCamelCase__ :      Dict								=		torch.tensor([0.6_588, 0.0_990, -0.2_493] )
			elif model_name == "videomae-base-finetuned-kinetics":
						lowerCamelCase__ :      Union[str, Any]								=		torch.Size([1, 400] )
						lowerCamelCase__ :      List[str]								=		torch.tensor([0.3_669, -0.0_688, -0.2_421] )
			elif model_name == "videomae-base-short-ssv2":
						lowerCamelCase__ :      Union[str, Any]								=		torch.Size([1, 1408, 1536] )
						lowerCamelCase__ :      Tuple								=		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":
						lowerCamelCase__ :      str								=		torch.Size([1, 174] )
						lowerCamelCase__ :      Optional[Any]								=		torch.tensor([-0.0_537, -0.1_539, -0.3_266] )
			elif model_name == "videomae-base-ssv2":
						lowerCamelCase__ :      List[str]								=		torch.Size([1, 1408, 1536] )
						lowerCamelCase__ :      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":
						lowerCamelCase__ :      int								=		torch.Size([1, 174] )
						lowerCamelCase__ :      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]      ,			UpperCamelCase      ,			atol=1E-4 )
			else:
						print("""Logits:"""      ,			logits[0, :3, :3] )
						assert torch.allclose(logits[0, :3, :3]      ,			UpperCamelCase      ,			atol=1E-4 )
			print("""Logits ok!""" )

			# verify loss, if applicable
			if model_name == "videomae-base-short":
						lowerCamelCase__ :      List[Any]								=		outputs.loss
						assert torch.allclose(UpperCamelCase      ,			UpperCamelCase      ,			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(UpperCamelCase )
						model.save_pretrained(UpperCamelCase )

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


if __name__ == "__main__":
				_lowercase     							=						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.'''
				)

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








from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase






def      _A				(UpperCamelCase		:      str )  ->None:



			'''simple docstring'''







			lowerCamelCase__							,lowerCamelCase__ :      List[str]								=		analyze_text(UpperCamelCase )
			lowerCamelCase__ :      Any								=		list(""" """ + ascii_lowercase )
			# what is our total sum of probabilities.
			lowerCamelCase__ :      str								=		sum(single_char_strings.values() )

			# one length string
			lowerCamelCase__ :      Union[str, Any]								=		0
			# for each alpha we go in our dict and if it is in it we calculate entropy
			for ch in my_alphas:
						if ch in single_char_strings:
									lowerCamelCase__ :      List[Any]								=		single_char_strings[ch]
									lowerCamelCase__ :      List[str]								=		my_str / all_sum
									my_fir_sum += prob * math.loga(UpperCamelCase )  # entropy formula.

    # print entropy
			print(f"{round(-1 * my_fir_sum ):.1f}" )

			# two len string
			lowerCamelCase__ :      str								=		sum(two_char_strings.values() )
			lowerCamelCase__ :      int								=		0
			# for each alpha (two in size) calculate entropy.
			for cha in my_alphas:
						for cha in my_alphas:
									lowerCamelCase__ :      str								=		cha + cha
									if sequence in two_char_strings:
												lowerCamelCase__ :      str								=		two_char_strings[sequence]
												lowerCamelCase__ :      int								=		int(UpperCamelCase ) / all_sum
												my_sec_sum += prob * math.loga(UpperCamelCase )

    # print second entropy
			print(f"{round(-1 * my_sec_sum ):.1f}" )

			# print the difference between them
			print(f"{round((-1 * my_sec_sum) - (-1 * my_fir_sum) ):.1f}" )






def      _A				(UpperCamelCase		:      str )  ->tuple[dict, dict]:



			'''simple docstring'''







			lowerCamelCase__ :      Optional[int]								=		Counter()  # type: ignore
			lowerCamelCase__ :      List[Any]								=		Counter()  # type: ignore
			single_char_strings[text[-1]] += 1

			# first case when we have space at start.
			two_char_strings[" " + text[0]] += 1
			for i in range(0      ,			len(UpperCamelCase ) - 1 ):
						single_char_strings[text[i]] += 1
						two_char_strings[text[i : i + 2]] += 1
			return single_char_strings, two_char_strings






def      _A				()  ->List[str]:



			'''simple docstring'''







			import doctest

			doctest.testmod()
			# text = (
			#     "Had repulsive dashwoods suspicion sincerity but advantage now him. Remark "
			#     "easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest "
			#     "jointure saw horrible. He private he on be imagine suppose. Fertile "
			#     "beloved evident through no service elderly is. Blind there if every no so "
			#     "at. Own neglected you preferred way sincerity delivered his attempted. To "
			#     "of message cottage windows do besides against uncivil.  Delightful "
			#     "unreserved impossible few estimating men favourable see entreaties. She "
			#     "propriety immediate was improving. He or entrance humoured likewise "
			#     "moderate. Much nor game son say feel. Fat make met can must form into "
			#     "gate. Me we offending prevailed discovery. "
			# )

			# calculate_prob(text)


if __name__ == "__main__":
				main()



