code: 
  
  
  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(			lowercase__			)		->			Union[str, Any]:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowercase=    TimesformerConfig()
  
  		if "large" in model_name:
  				__lowercase=    9_6
  
  		if "hr" in model_name:
  				__lowercase=    1_6
  				__lowercase=    4_4_8
  
  		__lowercase=    "huggingface/label-files"
  		if "k400" in model_name:
  				__lowercase=    4_0_0
  				__lowercase=    "kinetics400-id2label.json"
  		elif "k600" in model_name:
  				__lowercase=    6_0_0
  				__lowercase=    "kinetics600-id2label.json"
  		elif "ssv2" in model_name:
  				__lowercase=    1_7_4
  				__lowercase=    "something-something-v2-id2label.json"
  		else:
  				raise ValueError('Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'			)
  		__lowercase=    json.load(open(hf_hub_download(lowercase__     ,				lowercase__     ,				repo_type='dataset'			)     ,				'r'			)			)
  		__lowercase=    {int(lowercase__			): v for k, v in idalabel.items()}
  		__lowercase=    idalabel
  		__lowercase=    {v: k for k, v in idalabel.items()}
  
  		return config
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__			)		->			Tuple:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if "encoder." in name:
  				__lowercase=    name.replace('encoder.'     ,				''			)
  		if "cls_token" in name:
  				__lowercase=    name.replace('cls_token'     ,				'timesformer.embeddings.cls_token'			)
  		if "pos_embed" in name:
  				__lowercase=    name.replace('pos_embed'     ,				'timesformer.embeddings.position_embeddings'			)
  		if "time_embed" in name:
  				__lowercase=    name.replace('time_embed'     ,				'timesformer.embeddings.time_embeddings'			)
  		if "patch_embed.proj" in name:
  				__lowercase=    name.replace('patch_embed.proj'     ,				'timesformer.embeddings.patch_embeddings.projection'			)
  		if "patch_embed.norm" in name:
  				__lowercase=    name.replace('patch_embed.norm'     ,				'timesformer.embeddings.norm'			)
  		if "blocks" in name:
  				__lowercase=    name.replace('blocks'     ,				'timesformer.encoder.layer'			)
  		if "attn.proj" in name:
  				__lowercase=    name.replace('attn.proj'     ,				'attention.output.dense'			)
  		if "attn" in name and "bias" not in name and "temporal" not in name:
  				__lowercase=    name.replace('attn'     ,				'attention.self'			)
  		if "attn" in name and "temporal" not in name:
  				__lowercase=    name.replace('attn'     ,				'attention.attention'			)
  		if "temporal_norm1" in name:
  				__lowercase=    name.replace('temporal_norm1'     ,				'temporal_layernorm'			)
  		if "temporal_attn.proj" in name:
  				__lowercase=    name.replace('temporal_attn'     ,				'temporal_attention.output.dense'			)
  		if "temporal_fc" in name:
  				__lowercase=    name.replace('temporal_fc'     ,				'temporal_dense'			)
  		if "norm1" in name and "temporal" not in name:
  				__lowercase=    name.replace('norm1'     ,				'layernorm_before'			)
  		if "norm2" in name:
  				__lowercase=    name.replace('norm2'     ,				'layernorm_after'			)
  		if "mlp.fc1" in name:
  				__lowercase=    name.replace('mlp.fc1'     ,				'intermediate.dense'			)
  		if "mlp.fc2" in name:
  				__lowercase=    name.replace('mlp.fc2'     ,				'output.dense'			)
  		if "norm.weight" in name and "fc" not in name and "temporal" not in name:
  				__lowercase=    name.replace('norm.weight'     ,				'timesformer.layernorm.weight'			)
  		if "norm.bias" in name and "fc" not in name and "temporal" not in name:
  				__lowercase=    name.replace('norm.bias'     ,				'timesformer.layernorm.bias'			)
  		if "head" in name:
  				__lowercase=    name.replace('head'     ,				'classifier'			)
  
  		return name
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__			)		->			int:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		for key in orig_state_dict.copy().keys():
  				__lowercase=    orig_state_dict.pop(lowercase__			)
  
  				if key.startswith('model.'			):
  						__lowercase=    key.replace('model.'     ,				''			)
  
  				if "qkv" in key:
  						__lowercase=    key.split('.'			)
  						__lowercase=    int(key_split[1]			)
  						__lowercase=    "timesformer.encoder.layer."
  						if "temporal" in key:
  								__lowercase=    ".temporal_attention.attention.qkv."
  						else:
  								__lowercase=    ".attention.attention.qkv."
  						if "weight" in key:
  								__lowercase=    val
  						else:
  								__lowercase=    val
  				else:
  						__lowercase=    val
  
  		return orig_state_dict
  
  
  
  
  
  
  
  def  _lowerCamelCase(			)		->			Any:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowercase=    hf_hub_download(
  		    repo_id='hf-internal-testing/spaghetti-video'     ,				filename='eating_spaghetti.npy'     ,				repo_type='dataset'			)
  		__lowercase=    np.load(lowercase__			)
  		return list(lowercase__			)
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__     ,				lowercase__			)		->			Optional[int]:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowercase=    get_timesformer_config(lowercase__			)
  
  		__lowercase=    TimesformerForVideoClassification(lowercase__			)
  
  		# download original checkpoint, hosted on Google Drive
  		__lowercase=    "pytorch_model.bin"
  		gdown.cached_download(lowercase__     ,				lowercase__     ,				quiet=lowercase__			)
  		__lowercase=    torch.load(lowercase__     ,				map_location='cpu'			)
  		if "model" in files:
  				__lowercase=    files["model"]
  		elif "module" in files:
  				__lowercase=    files["module"]
  		else:
  				__lowercase=    files["model_state"]
  		__lowercase=    convert_state_dict(lowercase__     ,				lowercase__			)
  
  		model.load_state_dict(lowercase__			)
  		model.eval()
  
  		# verify model on basic input
  		__lowercase=    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]     ,				image_std=[0.5, 0.5, 0.5]			)
  		__lowercase=    prepare_video()
  		__lowercase=    image_processor(video[:8]     ,				return_tensors='pt'			)
  
  		__lowercase=    model(**lowercase__			)
  		__lowercase=    outputs.logits
  
  		__lowercase=    [
  		    # 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":
  				__lowercase=    torch.Size([1, 4_0_0]			)
  				__lowercase=    torch.tensor([-0.3016, -0.7713, -0.4205]			)
  		elif model_name == "timesformer-base-finetuned-k600":
  				__lowercase=    torch.Size([1, 6_0_0]			)
  				__lowercase=    torch.tensor([-0.7267, -0.7466, 3.2404]			)
  		elif model_name == "timesformer-base-finetuned-ssv2":
  				__lowercase=    torch.Size([1, 1_7_4]			)
  				__lowercase=    torch.tensor([-0.9059, 0.6433, -3.1457]			)
  		elif model_name == "timesformer-large-finetuned-k400":
  				__lowercase=    torch.Size([1, 4_0_0]			)
  				__lowercase=    torch.tensor([0, 0, 0]			)
  		elif model_name == "timesformer-large-finetuned-k600":
  				__lowercase=    torch.Size([1, 6_0_0]			)
  				__lowercase=    torch.tensor([0, 0, 0]			)
  		elif model_name == "timesformer-large-finetuned-ssv2":
  				__lowercase=    torch.Size([1, 1_7_4]			)
  				__lowercase=    torch.tensor([0, 0, 0]			)
  		elif model_name == "timesformer-hr-finetuned-k400":
  				__lowercase=    torch.Size([1, 4_0_0]			)
  				__lowercase=    torch.tensor([-0.9617, -3.7311, -3.7708]			)
  		elif model_name == "timesformer-hr-finetuned-k600":
  				__lowercase=    torch.Size([1, 6_0_0]			)
  				__lowercase=    torch.tensor([2.5273, 0.7127, 1.8848]			)
  		elif model_name == "timesformer-hr-finetuned-ssv2":
  				__lowercase=    torch.Size([1, 1_7_4]			)
  				__lowercase=    torch.tensor([-3.6756, -0.7513, 0.7180]			)
  		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]     ,				lowercase__     ,				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(lowercase__			)
  				model.save_pretrained(lowercase__			)
  
  		if push_to_hub:
  				print('Pushing to the hub...'			)
  				model.push_to_hub(F'fcakyon/{model_name}'			)
  
  
  if __name__ == "__main__":
  	lowerCAmelCase					 =	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					 =	parser.parse_args()
  	convert_timesformer_checkpoint(
  	    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
  	)
  
  
  
  
  
  
  
style_context: 
  
  
  def  _lowerCamelCase(			lowercase__			)		->			str:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return " ".join([word[::-1] for word in input_str.split()]			)
  
  
  if __name__ == "__main__":
  	import doctest
  
  	doctest.testmod()
  
  
  
  
  
  
  