"""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						(	__lowercase						:			Any     ):
		'''simple docstring'''




		A_		:    Optional[int]         =				VideoMAEConfig()

		set_architecture_configs(snake_case_						,snake_case_     )

		if "finetuned" not in model_name:
				A_		:    Tuple         =				False

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

		return config




def     UpperCamelCase						(	__lowercase						:			Optional[int]						,__lowercase						:			List[Any]     ):
		'''simple docstring'''




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




def     UpperCamelCase						(	__lowercase						:			Dict     ):
		'''simple docstring'''




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

		return name




def     UpperCamelCase						(	__lowercase						:			Union[str, Any]						,__lowercase						:			int     ):
		'''simple docstring'''




		for key in orig_state_dict.copy().keys():
				A_		:    Tuple         =				orig_state_dict.pop(snake_case_     )

				if key.startswith('encoder.'     ):
						A_		:    Union[str, Any]         =				key.replace('encoder.'						,''     )

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

		return orig_state_dict




def     UpperCamelCase						(	):
		'''simple docstring'''




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




def     UpperCamelCase						(	__lowercase						:			Union[str, Any]						,__lowercase						:			Optional[Any]						,__lowercase						:			Optional[Any]						,__lowercase						:			Tuple     ):
		'''simple docstring'''




		A_		:    int         =				get_videomae_config(snake_case_     )

		if "finetuned" in model_name:
				A_		:    Any         =				VideoMAEForVideoClassification(snake_case_     )
		else:
				A_		:    Dict         =				VideoMAEForPreTraining(snake_case_     )

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

		model.load_state_dict(snake_case_     )
		model.eval()

		# verify model on basic input
		A_		:    Dict         =				VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]						,image_std=[0.5, 0.5, 0.5]     )
		A_		:    Optional[int]         =				prepare_video()
		A_		:    Any         =				image_processor(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_		:    Optional[Any]         =				torch.load(snake_case_     )

		A_		:    Any         =				model(**snake_case_     )
		A_		:    List[Any]         =				outputs.logits

		A_		:    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":
				A_		:    Tuple         =				torch.Size([1, 4_00]     )
				A_		:    Optional[Any]         =				torch.tensor([-0.92_91, -0.40_61, -0.93_07]     )
		elif model_name == "videomae-small-finetuned-ssv2":
				A_		:    Optional[Any]         =				torch.Size([1, 1_74]     )
				A_		:    Dict         =				torch.tensor([0.26_71, -0.46_89, -0.82_35]     )
		elif model_name == "videomae-base":
				A_		:    List[Any]         =				torch.Size([1, 14_08, 15_36]     )
				A_		:    Dict         =				torch.tensor([[0.77_39, 0.79_68, 0.70_89], [0.67_01, 0.74_87, 0.62_09], [0.42_87, 0.51_58, 0.47_73]]     )
		elif model_name == "videomae-base-short":
				A_		:    Optional[int]         =				torch.Size([1, 14_08, 15_36]     )
				A_		:    Optional[int]         =				torch.tensor([[0.79_94, 0.96_12, 0.85_08], [0.74_01, 0.89_58, 0.83_02], [0.58_62, 0.74_68, 0.73_25]]     )
				# we verified the loss both for normalized and unnormalized targets for this one
				A_		:    str         =				torch.tensor([0.51_42]     ) if config.norm_pix_loss else torch.tensor([0.64_69]     )
		elif model_name == "videomae-large":
				A_		:    Any         =				torch.Size([1, 14_08, 15_36]     )
				A_		:    str         =				torch.tensor([[0.71_49, 0.79_97, 0.69_66], [0.67_68, 0.78_69, 0.69_48], [0.51_39, 0.62_21, 0.56_05]]     )
		elif model_name == "videomae-large-finetuned-kinetics":
				A_		:    Optional[int]         =				torch.Size([1, 4_00]     )
				A_		:    Union[str, Any]         =				torch.tensor([0.07_71, 0.00_11, -0.36_25]     )
		elif model_name == "videomae-huge-finetuned-kinetics":
				A_		:    int         =				torch.Size([1, 4_00]     )
				A_		:    Tuple         =				torch.tensor([0.24_33, 0.16_32, -0.48_94]     )
		elif model_name == "videomae-base-short-finetuned-kinetics":
				A_		:    Union[str, Any]         =				torch.Size([1, 4_00]     )
				A_		:    Any         =				torch.tensor([0.65_88, 0.09_90, -0.24_93]     )
		elif model_name == "videomae-base-finetuned-kinetics":
				A_		:    Optional[int]         =				torch.Size([1, 4_00]     )
				A_		:    Optional[int]         =				torch.tensor([0.36_69, -0.06_88, -0.24_21]     )
		elif model_name == "videomae-base-short-ssv2":
				A_		:    Dict         =				torch.Size([1, 14_08, 15_36]     )
				A_		:    List[Any]         =				torch.tensor([[0.47_12, 0.52_96, 0.57_86], [0.22_78, 0.27_29, 0.40_26], [0.03_52, 0.07_30, 0.25_06]]     )
		elif model_name == "videomae-base-short-finetuned-ssv2":
				A_		:    int         =				torch.Size([1, 1_74]     )
				A_		:    Union[str, Any]         =				torch.tensor([-0.05_37, -0.15_39, -0.32_66]     )
		elif model_name == "videomae-base-ssv2":
				A_		:    int         =				torch.Size([1, 14_08, 15_36]     )
				A_		:    Union[str, Any]         =				torch.tensor([[0.81_31, 0.87_27, 0.85_46], [0.73_66, 0.93_77, 0.88_70], [0.59_35, 0.88_74, 0.85_64]]     )
		elif model_name == "videomae-base-finetuned-ssv2":
				A_		:    int         =				torch.Size([1, 1_74]     )
				A_		:    Any         =				torch.tensor([0.19_61, -0.83_37, -0.63_89]     )
		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]						,snake_case_						,atol=1e-4     )
		else:
				print('Logits:'						,logits[0, :3, :3]     )
				assert torch.allclose(logits[0, :3, :3]						,snake_case_						,atol=1e-4     )
		print('Logits ok!'     )

		# verify loss, if applicable
		if model_name == "videomae-base-short":
				A_		:    Tuple         =				outputs.loss
				assert torch.allclose(snake_case_						,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(snake_case_     )
				model.save_pretrained(snake_case_     )

		if push_to_hub:
				print('Pushing to the hub...'     )
				model.push_to_hub(snake_case_						,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 json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_squeezebert import SqueezeBertTokenizer


_UpperCAmelCase            =		logging.get_logger(__name__)

_UpperCAmelCase            =		{"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

_UpperCAmelCase            =		{
    """vocab_file""": {
        """squeezebert/squeezebert-uncased""": (
            """https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/vocab.txt"""
        ),
        """squeezebert/squeezebert-mnli""": """https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/vocab.txt""",
        """squeezebert/squeezebert-mnli-headless""": (
            """https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """squeezebert/squeezebert-uncased""": (
            """https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/tokenizer.json"""
        ),
        """squeezebert/squeezebert-mnli""": (
            """https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/tokenizer.json"""
        ),
        """squeezebert/squeezebert-mnli-headless""": (
            """https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/tokenizer.json"""
        ),
    },
}

_UpperCAmelCase            =		{
    """squeezebert/squeezebert-uncased""": 512,
    """squeezebert/squeezebert-mnli""": 512,
    """squeezebert/squeezebert-mnli-headless""": 512,
}


_UpperCAmelCase            =		{
    """squeezebert/squeezebert-uncased""": {"""do_lower_case""": True},
    """squeezebert/squeezebert-mnli""": {"""do_lower_case""": True},
    """squeezebert/squeezebert-mnli-headless""": {"""do_lower_case""": True},
}





class UpperCAmelCase						( __A  ):


				'''simple docstring'''






				lowerCamelCase_    = VOCAB_FILES_NAMES
				lowerCamelCase_    = PRETRAINED_VOCAB_FILES_MAP
				lowerCamelCase_    = PRETRAINED_INIT_CONFIGURATION
				lowerCamelCase_    = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				lowerCamelCase_    = SqueezeBertTokenizer
				def __init__(						self		,     lowercase=None		,     lowercase=None		,     lowercase=True		,     lowercase="[UNK]"		,     lowercase="[SEP]"		,     lowercase="[PAD]"		,     lowercase="[CLS]"		,     lowercase="[MASK]"		,     lowercase=True		,     lowercase=None		,     **lowercase		,     ):



						"""simple docstring"""





						super().__init__(
						    lowercase		,     tokenizer_file=lowercase		,     do_lower_case=lowercase		,     unk_token=lowercase		,     sep_token=lowercase		,     pad_token=lowercase		,     cls_token=lowercase		,     mask_token=lowercase		,     tokenize_chinese_chars=lowercase		,     strip_accents=lowercase		,     **lowercase		,     )

						A_		:    int         =				json.loads(self.backend_tokenizer.normalizer.__getstate__() )
						if (
						    normalizer_state.get('lowercase'		,     lowercase ) != do_lower_case
						    or normalizer_state.get('strip_accents'		,     lowercase ) != strip_accents
						    or normalizer_state.get('handle_chinese_chars'		,     lowercase ) != tokenize_chinese_chars
						):
								A_		:    Dict         =				getattr(lowercase		,     normalizer_state.pop('type' ) )
								A_		:    Optional[int]         =				do_lower_case
								A_		:    Optional[Any]         =				strip_accents
								A_		:    str         =				tokenize_chinese_chars
								A_		:    Any         =				normalizer_class(**lowercase )

						A_		:    Tuple         =				do_lower_case
				def   lowerCAmelCase_       (						self		,     lowercase		,     lowercase=None ):



						"""simple docstring"""





						A_		:    str         =				[self.cls_token_id] + token_ids_a + [self.sep_token_id]

						if token_ids_a:
								output += token_ids_a + [self.sep_token_id]

						return output
				def   lowerCAmelCase_       (						self		,     lowercase		,     lowercase = None ):



						"""simple docstring"""





						A_		:    Dict         =				[self.sep_token_id]
						A_		:    Union[str, Any]         =				[self.cls_token_id]
						if token_ids_a is None:
								return len(cls + token_ids_a + sep ) * [0]
						return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]







				def   lowerCAmelCase_       (						self		,     lowercase		,     lowercase = None ):



						"""simple docstring"""





						A_		:    Dict         =				self._tokenizer.model.save(lowercase		,     name=lowercase )
						return tuple(lowercase )






