



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   )    ->			List[Any]:







			'''simple docstring'''
			_UpperCAmelCase			=       VideoMAEConfig()

			set_architecture_configs(_UpperCAmelCase							,       _UpperCAmelCase   )

			if "finetuned" not in model_name:
						_UpperCAmelCase			=       False

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

			return config





def 							A     (					_UpperCAmelCase    :       Optional[int]							,       _UpperCAmelCase    :       Optional[int]   )    ->			Any:







			'''simple docstring'''
			if "small" in model_name:
						_UpperCAmelCase			=       384
						_UpperCAmelCase			=       1_536
						_UpperCAmelCase			=       12
						_UpperCAmelCase			=       16
						_UpperCAmelCase			=       12
						_UpperCAmelCase			=       3
						_UpperCAmelCase			=       192
						_UpperCAmelCase			=       768
			elif "large" in model_name:
						_UpperCAmelCase			=       1_024
						_UpperCAmelCase			=       4_096
						_UpperCAmelCase			=       24
						_UpperCAmelCase			=       16
						_UpperCAmelCase			=       12
						_UpperCAmelCase			=       8
						_UpperCAmelCase			=       512
						_UpperCAmelCase			=       2_048
			elif "huge" in model_name:
						_UpperCAmelCase			=       1_280
						_UpperCAmelCase			=       5_120
						_UpperCAmelCase			=       32
						_UpperCAmelCase			=       16
						_UpperCAmelCase			=       12
						_UpperCAmelCase			=       8
						_UpperCAmelCase			=       640
						_UpperCAmelCase			=       2_560
			elif "base" not in model_name:
						raise ValueError('Model name should include either "small", "base", "large", or "huge"'   )





def 							A     (					_UpperCAmelCase    :       Any   )    ->			Optional[Any]:







			'''simple docstring'''
			if "encoder." in name:
						_UpperCAmelCase			=       name.replace('encoder.'							,       ''   )
			if "cls_token" in name:
						_UpperCAmelCase			=       name.replace('cls_token'							,       'videomae.embeddings.cls_token'   )
			if "decoder_pos_embed" in name:
						_UpperCAmelCase			=       name.replace('decoder_pos_embed'							,       'decoder.decoder_pos_embed'   )
			if "pos_embed" in name and "decoder" not in name:
						_UpperCAmelCase			=       name.replace('pos_embed'							,       'videomae.embeddings.position_embeddings'   )
			if "patch_embed.proj" in name:
						_UpperCAmelCase			=       name.replace('patch_embed.proj'							,       'videomae.embeddings.patch_embeddings.projection'   )
			if "patch_embed.norm" in name:
						_UpperCAmelCase			=       name.replace('patch_embed.norm'							,       'videomae.embeddings.norm'   )
			if "decoder.blocks" in name:
						_UpperCAmelCase			=       name.replace('decoder.blocks'							,       'decoder.decoder_layers'   )
			if "blocks" in name:
						_UpperCAmelCase			=       name.replace('blocks'							,       'videomae.encoder.layer'   )
			if "attn.proj" in name:
						_UpperCAmelCase			=       name.replace('attn.proj'							,       'attention.output.dense'   )
			if "attn" in name and "bias" not in name:
						_UpperCAmelCase			=       name.replace('attn'							,       'attention.self'   )
			if "attn" in name:
						_UpperCAmelCase			=       name.replace('attn'							,       'attention.attention'   )
			if "norm1" in name:
						_UpperCAmelCase			=       name.replace('norm1'							,       'layernorm_before'   )
			if "norm2" in name:
						_UpperCAmelCase			=       name.replace('norm2'							,       'layernorm_after'   )
			if "mlp.fc1" in name:
						_UpperCAmelCase			=       name.replace('mlp.fc1'							,       'intermediate.dense'   )
			if "mlp.fc2" in name:
						_UpperCAmelCase			=       name.replace('mlp.fc2'							,       'output.dense'   )
			if "decoder_embed" in name:
						_UpperCAmelCase			=       name.replace('decoder_embed'							,       'decoder.decoder_embed'   )
			if "decoder_norm" in name:
						_UpperCAmelCase			=       name.replace('decoder_norm'							,       'decoder.decoder_norm'   )
			if "decoder_pred" in name:
						_UpperCAmelCase			=       name.replace('decoder_pred'							,       'decoder.decoder_pred'   )
			if "norm.weight" in name and "decoder" not in name and "fc" not in name:
						_UpperCAmelCase			=       name.replace('norm.weight'							,       'videomae.layernorm.weight'   )
			if "norm.bias" in name and "decoder" not in name and "fc" not in name:
						_UpperCAmelCase			=       name.replace('norm.bias'							,       'videomae.layernorm.bias'   )
			if "head" in name and "decoder" not in name:
						_UpperCAmelCase			=       name.replace('head'							,       'classifier'   )

			return name





def 							A     (					_UpperCAmelCase    :       Optional[int]							,       _UpperCAmelCase    :       List[str]   )    ->			Any:







			'''simple docstring'''
			for key in orig_state_dict.copy().keys():
						_UpperCAmelCase			=       orig_state_dict.pop(_UpperCAmelCase   )

						if key.startswith('encoder.'   ):
									_UpperCAmelCase			=       key.replace('encoder.'							,       ''   )

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

			return orig_state_dict





def 							A     (					)    ->			Optional[Any]:







			'''simple docstring'''
			_UpperCAmelCase			=       hf_hub_download(
			    repo_id='hf-internal-testing/spaghetti-video'							,       filename='eating_spaghetti.npy'							,       repo_type='dataset'   )
			_UpperCAmelCase			=       np.load(_UpperCAmelCase   )
			return list(_UpperCAmelCase   )





def 							A     (					_UpperCAmelCase    :       List[Any]							,       _UpperCAmelCase    :       Any							,       _UpperCAmelCase    :       List[Any]							,       _UpperCAmelCase    :       List[Any]   )    ->			Tuple:







			'''simple docstring'''
			_UpperCAmelCase			=       get_videomae_config(_UpperCAmelCase   )

			if "finetuned" in model_name:
						_UpperCAmelCase			=       VideoMAEForVideoClassification(_UpperCAmelCase   )
			else:
						_UpperCAmelCase			=       VideoMAEForPreTraining(_UpperCAmelCase   )

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

			model.load_state_dict(_UpperCAmelCase   )
			model.eval()

			# verify model on basic input
			_UpperCAmelCase			=       VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]							,       image_std=[0.5, 0.5, 0.5]   )
			_UpperCAmelCase			=       prepare_video()
			_UpperCAmelCase			=       image_processor(_UpperCAmelCase							,       return_tensors='pt'   )

			if "finetuned" not in model_name:
						_UpperCAmelCase			=       hf_hub_download(repo_id='hf-internal-testing/bool-masked-pos'							,       filename='bool_masked_pos.pt'   )
						_UpperCAmelCase			=       torch.load(_UpperCAmelCase   )

			_UpperCAmelCase			=       model(**_UpperCAmelCase   )
			_UpperCAmelCase			=       outputs.logits

			_UpperCAmelCase			=       [
			    '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":
						_UpperCAmelCase			=       torch.Size([1, 400]   )
						_UpperCAmelCase			=       torch.tensor([-0.9291, -0.4061, -0.9307]   )
			elif model_name == "videomae-small-finetuned-ssv2":
						_UpperCAmelCase			=       torch.Size([1, 174]   )
						_UpperCAmelCase			=       torch.tensor([0.2671, -0.4689, -0.8235]   )
			elif model_name == "videomae-base":
						_UpperCAmelCase			=       torch.Size([1, 1_408, 1_536]   )
						_UpperCAmelCase			=       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":
						_UpperCAmelCase			=       torch.Size([1, 1_408, 1_536]   )
						_UpperCAmelCase			=       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
						_UpperCAmelCase			=       torch.tensor([0.5142]   ) if config.norm_pix_loss else torch.tensor([0.6469]   )
			elif model_name == "videomae-large":
						_UpperCAmelCase			=       torch.Size([1, 1_408, 1_536]   )
						_UpperCAmelCase			=       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":
						_UpperCAmelCase			=       torch.Size([1, 400]   )
						_UpperCAmelCase			=       torch.tensor([0.0771, 0.0011, -0.3625]   )
			elif model_name == "videomae-huge-finetuned-kinetics":
						_UpperCAmelCase			=       torch.Size([1, 400]   )
						_UpperCAmelCase			=       torch.tensor([0.2433, 0.1632, -0.4894]   )
			elif model_name == "videomae-base-short-finetuned-kinetics":
						_UpperCAmelCase			=       torch.Size([1, 400]   )
						_UpperCAmelCase			=       torch.tensor([0.6588, 0.0990, -0.2493]   )
			elif model_name == "videomae-base-finetuned-kinetics":
						_UpperCAmelCase			=       torch.Size([1, 400]   )
						_UpperCAmelCase			=       torch.tensor([0.3669, -0.0688, -0.2421]   )
			elif model_name == "videomae-base-short-ssv2":
						_UpperCAmelCase			=       torch.Size([1, 1_408, 1_536]   )
						_UpperCAmelCase			=       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":
						_UpperCAmelCase			=       torch.Size([1, 174]   )
						_UpperCAmelCase			=       torch.tensor([-0.0537, -0.1539, -0.3266]   )
			elif model_name == "videomae-base-ssv2":
						_UpperCAmelCase			=       torch.Size([1, 1_408, 1_536]   )
						_UpperCAmelCase			=       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":
						_UpperCAmelCase			=       torch.Size([1, 174]   )
						_UpperCAmelCase			=       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]							,       _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":
						_UpperCAmelCase			=       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__":
						UpperCAmelCase__       =	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."
						)

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





import string

import numpy





def 							A     (					_UpperCAmelCase    :       int							,       _UpperCAmelCase    :       int   )    ->			int:







			'''simple docstring'''
			return b if a == 0 else greatest_common_divisor(b % a							,       _UpperCAmelCase   )







class       __lowerCAmelCase   :
			UpperCamelCase        =					string.ascii_uppercase + string.digits
			# This cipher takes alphanumerics into account
			# i.e. a total of 36 characters

			# take x and return x % len(key_string)
			UpperCamelCase        =					numpy.vectorize(lambda A						: x % 3_6						)

			UpperCamelCase        =					numpy.vectorize(A						)



			def __init__(						self       :  Tuple			,		A       :  numpy.ndarray)       ->   None:



						"""simple docstring"""






						_UpperCAmelCase			=       self.modulus(A)  # mod36 calc's on the encrypt key
						self.check_determinant()  # validate the determinant of the encryption key
						_UpperCAmelCase			=       encrypt_key.shape[0]



			def    _lowerCamelCase	(						self       :  str			,		A       :  str)       ->   int:



						"""simple docstring"""






						return self.key_string.index(A)



			def    _lowerCamelCase	(						self       :  Any			,		A       :  int)       ->   str:



						"""simple docstring"""






						return self.key_string[round(A)]



			def    _lowerCamelCase	(						self       :  Union[str, Any])       ->   None:



						"""simple docstring"""






						_UpperCAmelCase			=       round(numpy.linalg.det(self.encrypt_key))

						if det < 0:
									_UpperCAmelCase			=       det % len(self.key_string)

						_UpperCAmelCase			=       len(self.key_string)
						if greatest_common_divisor(A			,		len(self.key_string)) != 1:
									_UpperCAmelCase			=       (
									    F"determinant modular {req_l} of encryption key({det}) "
									    F"is not co prime w.r.t {req_l}.\nTry another key."
									)
									raise ValueError(A)



			def    _lowerCamelCase	(						self       :  Union[str, Any]			,		A       :  str)       ->   str:



						"""simple docstring"""






						_UpperCAmelCase			=       [char for char in text.upper() if char in self.key_string]

						_UpperCAmelCase			=       chars[-1]
						while len(A) % self.break_key != 0:
									chars.append(A)

						return "".join(A)



			def    _lowerCamelCase	(						self       :  Union[str, Any]			,		A       :  str)       ->   str:



						"""simple docstring"""






						_UpperCAmelCase			=       self.process_text(text.upper())
						_UpperCAmelCase			=       ''

						for i in range(0			,		len(A) - self.break_key + 1			,		self.break_key):
									_UpperCAmelCase			=       text[i : i + self.break_key]
									_UpperCAmelCase			=       [self.replace_letters(A) for char in batch]
									_UpperCAmelCase			=       numpy.array([vec]).T
									_UpperCAmelCase			=       self.modulus(self.encrypt_key.dot(A)).T.tolist()[
									    0
									]
									_UpperCAmelCase			=       ''.join(
									    self.replace_digits(A) for num in batch_encrypted)
									encrypted += encrypted_batch

						return encrypted



			def    _lowerCamelCase	(						self       :  Optional[Any])       ->   numpy.ndarray:



						"""simple docstring"""






						_UpperCAmelCase			=       round(numpy.linalg.det(self.encrypt_key))

						if det < 0:
									_UpperCAmelCase			=       det % len(self.key_string)
						_UpperCAmelCase			=       None
						for i in range(len(self.key_string)):
									if (det * i) % len(self.key_string) == 1:
												_UpperCAmelCase			=       i
												break

						_UpperCAmelCase			=       (
						    det_inv
						    * numpy.linalg.det(self.encrypt_key)
						    * numpy.linalg.inv(self.encrypt_key)
						)

						return self.to_int(self.modulus(A))



			def    _lowerCamelCase	(						self       :  Tuple			,		A       :  str)       ->   str:



						"""simple docstring"""






						_UpperCAmelCase			=       self.make_decrypt_key()
						_UpperCAmelCase			=       self.process_text(text.upper())
						_UpperCAmelCase			=       ''

						for i in range(0			,		len(A) - self.break_key + 1			,		self.break_key):
									_UpperCAmelCase			=       text[i : i + self.break_key]
									_UpperCAmelCase			=       [self.replace_letters(A) for char in batch]
									_UpperCAmelCase			=       numpy.array([vec]).T
									_UpperCAmelCase			=       self.modulus(decrypt_key.dot(A)).T.tolist()[0]
									_UpperCAmelCase			=       ''.join(
									    self.replace_digits(A) for num in batch_decrypted)
									decrypted += decrypted_batch

						return decrypted





def 							A     (					)    ->			None:







			'''simple docstring'''
			_UpperCAmelCase			=       int(input('Enter the order of the encryption key: '   )   )
			_UpperCAmelCase			=       []

			print('Enter each row of the encryption key with space separated integers'   )
			for _ in range(_UpperCAmelCase   ):
						_UpperCAmelCase			=       [int(_UpperCAmelCase   ) for x in input().split()]
						hill_matrix.append(_UpperCAmelCase   )

			_UpperCAmelCase			=       HillCipher(numpy.array(_UpperCAmelCase   )   )

			print('Would you like to encrypt or decrypt some text? (1 or 2)'   )
			_UpperCAmelCase			=       input('\n1. Encrypt\n2. Decrypt\n'   )
			if option == "1":
						_UpperCAmelCase			=       input('What text would you like to encrypt?: '   )
						print('Your encrypted text is:'   )
						print(hc.encrypt(_UpperCAmelCase   )   )
			elif option == "2":
						_UpperCAmelCase			=       input('What text would you like to decrypt?: '   )
						print('Your decrypted text is:'   )
						print(hc.decrypt(_UpperCAmelCase   )   )


if __name__ == "__main__":
							import doctest

							doctest.testmod()

							main()
