



'''simple docstring'''



import os
from shutil import copyfile
from typing import Optional, Tuple

from ...file_utils import is_sentencepiece_available
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging


if is_sentencepiece_available():
	from .tokenization_deberta_va import DebertaVaTokenizer
else:
	lowerCAmelCase						:		Optional[int]						      = None

lowerCAmelCase						:		List[str]						      = logging.get_logger(__name__)

lowerCAmelCase						:		List[Any]						      = {'''vocab_file''': '''spm.model''', '''tokenizer_file''': '''tokenizer.json'''}

lowerCAmelCase						:		Any						      = {
    '''vocab_file''': {
        '''microsoft/deberta-v2-xlarge''': '''https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/spm.model''',
        '''microsoft/deberta-v2-xxlarge''': '''https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/spm.model''',
        '''microsoft/deberta-v2-xlarge-mnli''': (
            '''https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/spm.model'''
        ),
        '''microsoft/deberta-v2-xxlarge-mnli''': (
            '''https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/spm.model'''
        ),
    }
}

lowerCAmelCase						:		Dict						      = {
    '''microsoft/deberta-v2-xlarge''': 5_1_2,
    '''microsoft/deberta-v2-xxlarge''': 5_1_2,
    '''microsoft/deberta-v2-xlarge-mnli''': 5_1_2,
    '''microsoft/deberta-v2-xxlarge-mnli''': 5_1_2,
}

lowerCAmelCase						:		int						      = {
    '''microsoft/deberta-v2-xlarge''': {'''do_lower_case''': False},
    '''microsoft/deberta-v2-xxlarge''': {'''do_lower_case''': False},
    '''microsoft/deberta-v2-xlarge-mnli''': {'''do_lower_case''': False},
    '''microsoft/deberta-v2-xxlarge-mnli''': {'''do_lower_case''': False},
}






class        UpperCAmelCase__						(		UpperCamelCase__			):
					a   :  int   =				VOCAB_FILES_NAMES
					a   :  Tuple   =				PRETRAINED_VOCAB_FILES_MAP
					a   :  Optional[int]   =				PRETRAINED_INIT_CONFIGURATION
					a   :  int   =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					a   :  Optional[int]   =				DebertaVaTokenizer



					def __init__(     self      ,					UpperCamelCase=None      ,					UpperCamelCase=None      ,					UpperCamelCase=False      ,					UpperCamelCase=False      ,					UpperCamelCase="[CLS]"      ,					UpperCamelCase="[SEP]"      ,					UpperCamelCase="[UNK]"      ,					UpperCamelCase="[SEP]"      ,					UpperCamelCase="[PAD]"      ,					UpperCamelCase="[CLS]"      ,					UpperCamelCase="[MASK]"      ,					**UpperCamelCase      ,					)  ->      None:
						super().__init__(
						    UpperCamelCase      ,					tokenizer_file=UpperCamelCase      ,					do_lower_case=UpperCamelCase      ,					bos_token=UpperCamelCase      ,					eos_token=UpperCamelCase      ,					unk_token=UpperCamelCase      ,					sep_token=UpperCamelCase      ,					pad_token=UpperCamelCase      ,					cls_token=UpperCamelCase      ,					mask_token=UpperCamelCase      ,					split_by_punct=UpperCamelCase      ,					**UpperCamelCase      ,					)

						__lowerCAmelCase       				=	do_lower_case
						__lowerCAmelCase       				=	split_by_punct
						__lowerCAmelCase       				=	vocab_file
						__lowerCAmelCase       				=	False if not self.vocab_file else True



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase      ,					UpperCamelCase=None  )  ->      List[Any]:

						if token_ids_a is None:
							return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
						__lowerCAmelCase       				=	[self.cls_token_id]
						__lowerCAmelCase       				=	[self.sep_token_id]
						return cls + token_ids_a + sep + token_ids_a + sep



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase      ,					UpperCamelCase=None      ,					UpperCamelCase=False  )  ->      Tuple:

						if already_has_special_tokens:
							return super().get_special_tokens_mask(
							    token_ids_a=UpperCamelCase      ,					token_ids_a=UpperCamelCase      ,					already_has_special_tokens=UpperCamelCase  )

						if token_ids_a is not None:
							return [1] + ([0] * len(UpperCamelCase  )) + [1] + ([0] * len(UpperCamelCase  )) + [1]
						return [1] + ([0] * len(UpperCamelCase  )) + [1]



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase      ,					UpperCamelCase=None  )  ->      List[str]:
						__lowerCAmelCase       				=	[self.sep_token_id]
						__lowerCAmelCase       				=	[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 							UpperCAmelCase_			(     self      ,					UpperCamelCase      ,					UpperCamelCase = None  )  ->      Tuple[str]:
						if not self.can_save_slow_tokenizer:
							raise ValueError(
							    "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
							    "tokenizer."  )

						if not os.path.isdir(UpperCamelCase  ):
							logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''  )
							return
						__lowerCAmelCase       				=	os.path.join(
						    UpperCamelCase      ,					(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]  )

						if os.path.abspath(self.vocab_file  ) != os.path.abspath(UpperCamelCase  ):
							copyfile(self.vocab_file      ,					UpperCamelCase  )

						return (out_vocab_file,)




'''simple docstring'''



import argparse
import json

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

from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor



def 	__lowerCAmelCase       (				lowerCamelCase :    str       ):






	'''simple docstring'''




	__lowerCAmelCase       				=	TimesformerConfig()

	if "large" in model_name:
		__lowerCAmelCase       				=	96

	if "hr" in model_name:
		__lowerCAmelCase       				=	16
		__lowerCAmelCase       				=	4_48

	__lowerCAmelCase       				=	"huggingface/label-files"
	if "k400" in model_name:
		__lowerCAmelCase       				=	4_00
		__lowerCAmelCase       				=	"kinetics400-id2label.json"
	elif "k600" in model_name:
		__lowerCAmelCase       				=	6_00
		__lowerCAmelCase       				=	"kinetics600-id2label.json"
	elif "ssv2" in model_name:
		__lowerCAmelCase       				=	1_74
		__lowerCAmelCase       				=	"something-something-v2-id2label.json"
	else:
		raise ValueError("Model name should either contain 'k400', 'k600' or 'ssv2'."       )
	__lowerCAmelCase       				=	json.load(open(hf_hub_download(lowerCamelCase					,		lowerCamelCase					,		repo_type="dataset"       )					,		"r"       )       )
	__lowerCAmelCase       				=	{int(lowerCamelCase       ): v for k, v in idalabel.items()}
	__lowerCAmelCase       				=	idalabel
	__lowerCAmelCase       				=	{v: k for k, v in idalabel.items()}

	return config



def 	__lowerCAmelCase       (				lowerCamelCase :    int       ):






	'''simple docstring'''




	if "encoder." in name:
		__lowerCAmelCase       				=	name.replace("encoder."					,		""       )
	if "cls_token" in name:
		__lowerCAmelCase       				=	name.replace("cls_token"					,		"timesformer.embeddings.cls_token"       )
	if "pos_embed" in name:
		__lowerCAmelCase       				=	name.replace("pos_embed"					,		"timesformer.embeddings.position_embeddings"       )
	if "time_embed" in name:
		__lowerCAmelCase       				=	name.replace("time_embed"					,		"timesformer.embeddings.time_embeddings"       )
	if "patch_embed.proj" in name:
		__lowerCAmelCase       				=	name.replace("patch_embed.proj"					,		"timesformer.embeddings.patch_embeddings.projection"       )
	if "patch_embed.norm" in name:
		__lowerCAmelCase       				=	name.replace("patch_embed.norm"					,		"timesformer.embeddings.norm"       )
	if "blocks" in name:
		__lowerCAmelCase       				=	name.replace("blocks"					,		"timesformer.encoder.layer"       )
	if "attn.proj" in name:
		__lowerCAmelCase       				=	name.replace("attn.proj"					,		"attention.output.dense"       )
	if "attn" in name and "bias" not in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("attn"					,		"attention.self"       )
	if "attn" in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("attn"					,		"attention.attention"       )
	if "temporal_norm1" in name:
		__lowerCAmelCase       				=	name.replace("temporal_norm1"					,		"temporal_layernorm"       )
	if "temporal_attn.proj" in name:
		__lowerCAmelCase       				=	name.replace("temporal_attn"					,		"temporal_attention.output.dense"       )
	if "temporal_fc" in name:
		__lowerCAmelCase       				=	name.replace("temporal_fc"					,		"temporal_dense"       )
	if "norm1" in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("norm1"					,		"layernorm_before"       )
	if "norm2" in name:
		__lowerCAmelCase       				=	name.replace("norm2"					,		"layernorm_after"       )
	if "mlp.fc1" in name:
		__lowerCAmelCase       				=	name.replace("mlp.fc1"					,		"intermediate.dense"       )
	if "mlp.fc2" in name:
		__lowerCAmelCase       				=	name.replace("mlp.fc2"					,		"output.dense"       )
	if "norm.weight" in name and "fc" not in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("norm.weight"					,		"timesformer.layernorm.weight"       )
	if "norm.bias" in name and "fc" not in name and "temporal" not in name:
		__lowerCAmelCase       				=	name.replace("norm.bias"					,		"timesformer.layernorm.bias"       )
	if "head" in name:
		__lowerCAmelCase       				=	name.replace("head"					,		"classifier"       )

	return name



def 	__lowerCAmelCase       (				lowerCamelCase :    int					,		lowerCamelCase :    List[str]       ):






	'''simple docstring'''




	for key in orig_state_dict.copy().keys():
		__lowerCAmelCase       				=	orig_state_dict.pop(lowerCamelCase       )

		if key.startswith("model."       ):
			__lowerCAmelCase       				=	key.replace("model."					,		""       )

		if "qkv" in key:
			__lowerCAmelCase       				=	key.split("."       )
			__lowerCAmelCase       				=	int(key_split[1]       )
			__lowerCAmelCase       				=	"timesformer.encoder.layer."
			if "temporal" in key:
				__lowerCAmelCase       				=	".temporal_attention.attention.qkv."
			else:
				__lowerCAmelCase       				=	".attention.attention.qkv."
			if "weight" in key:
				__lowerCAmelCase       				=	val
			else:
				__lowerCAmelCase       				=	val
		else:
			__lowerCAmelCase       				=	val

	return orig_state_dict



def 	__lowerCAmelCase       (				):






	'''simple docstring'''




	__lowerCAmelCase       				=	hf_hub_download(
	    repo_id="hf-internal-testing/spaghetti-video"					,		filename="eating_spaghetti.npy"					,		repo_type="dataset"       )
	__lowerCAmelCase       				=	np.load(lowerCamelCase       )
	return list(lowerCamelCase       )



def 	__lowerCAmelCase       (				lowerCamelCase :    Union[str, Any]					,		lowerCamelCase :    Dict					,		lowerCamelCase :    List[Any]					,		lowerCamelCase :    Optional[Any]       ):






	'''simple docstring'''




	__lowerCAmelCase       				=	get_timesformer_config(lowerCamelCase       )

	__lowerCAmelCase       				=	TimesformerForVideoClassification(lowerCamelCase       )

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

	model.load_state_dict(lowerCamelCase       )
	model.eval()

	# verify model on basic input
	__lowerCAmelCase       				=	VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]					,		image_std=[0.5, 0.5, 0.5]       )
	__lowerCAmelCase       				=	prepare_video()
	__lowerCAmelCase       				=	image_processor(video[:8]					,		return_tensors="pt"       )

	__lowerCAmelCase       				=	model(**lowerCamelCase       )
	__lowerCAmelCase       				=	outputs.logits

	__lowerCAmelCase       				=	[
	    # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
	    "timesformer-base-finetuned-k400",
	    "timesformer-large-finetuned-k400",
	    "timesformer-hr-finetuned-k400",
	    # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
	    "timesformer-base-finetuned-k600",
	    "timesformer-large-finetuned-k600",
	    "timesformer-hr-finetuned-k600",
	    # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
	    "timesformer-base-finetuned-ssv2",
	    "timesformer-large-finetuned-ssv2",
	    "timesformer-hr-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 == "timesformer-base-finetuned-k400":
		__lowerCAmelCase       				=	torch.Size([1, 4_00]       )
		__lowerCAmelCase       				=	torch.tensor([-0.3_0_1_6, -0.7_7_1_3, -0.4_2_0_5]       )
	elif model_name == "timesformer-base-finetuned-k600":
		__lowerCAmelCase       				=	torch.Size([1, 6_00]       )
		__lowerCAmelCase       				=	torch.tensor([-0.7_2_6_7, -0.7_4_6_6, 3.2_4_0_4]       )
	elif model_name == "timesformer-base-finetuned-ssv2":
		__lowerCAmelCase       				=	torch.Size([1, 1_74]       )
		__lowerCAmelCase       				=	torch.tensor([-0.9_0_5_9, 0.6_4_3_3, -3.1_4_5_7]       )
	elif model_name == "timesformer-large-finetuned-k400":
		__lowerCAmelCase       				=	torch.Size([1, 4_00]       )
		__lowerCAmelCase       				=	torch.tensor([0, 0, 0]       )
	elif model_name == "timesformer-large-finetuned-k600":
		__lowerCAmelCase       				=	torch.Size([1, 6_00]       )
		__lowerCAmelCase       				=	torch.tensor([0, 0, 0]       )
	elif model_name == "timesformer-large-finetuned-ssv2":
		__lowerCAmelCase       				=	torch.Size([1, 1_74]       )
		__lowerCAmelCase       				=	torch.tensor([0, 0, 0]       )
	elif model_name == "timesformer-hr-finetuned-k400":
		__lowerCAmelCase       				=	torch.Size([1, 4_00]       )
		__lowerCAmelCase       				=	torch.tensor([-0.9_6_1_7, -3.7_3_1_1, -3.7_7_0_8]       )
	elif model_name == "timesformer-hr-finetuned-k600":
		__lowerCAmelCase       				=	torch.Size([1, 6_00]       )
		__lowerCAmelCase       				=	torch.tensor([2.5_2_7_3, 0.7_1_2_7, 1.8_8_4_8]       )
	elif model_name == "timesformer-hr-finetuned-ssv2":
		__lowerCAmelCase       				=	torch.Size([1, 1_74]       )
		__lowerCAmelCase       				=	torch.tensor([-3.6_7_5_6, -0.7_5_1_3, 0.7_1_8_0]       )
	else:
		raise ValueError(f'''Model name not supported. Should be one of {model_names}'''       )

	# verify logits
	assert logits.shape == expected_shape
	assert torch.allclose(logits[0, :3]					,		lowerCamelCase					,		atol=1e-4       )
	print("Logits 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(lowerCamelCase       )
		model.save_pretrained(lowerCamelCase       )

	if push_to_hub:
		print("Pushing to the hub..."       )
		model.push_to_hub(f'''fcakyon/{model_name}'''       )


if __name__ == "__main__":
	lowerCAmelCase						:		Dict						      = argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '''--checkpoint_url''',
	    default='''https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download''',
	    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='''''',
	    type=str,
	    help='''Path to the output PyTorch model directory.''',
	)
	parser.add_argument('''--model_name''', default='''timesformer-base-finetuned-k400''', 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						:		Optional[int]						      = parser.parse_args()
	convert_timesformer_checkpoint(
	    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
	)