





'''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      lowercase  (  lowerCAmelCase :						Any):



				"""simple docstring"""


				_A :				str				=  TimesformerConfig()

				if "large" in model_name:
								_A :				Union[str, Any]				=  96

				if "hr" in model_name:
								_A :				Any				=  16
								_A :				List[Any]				=  448

				_A :				List[str]				=  '''huggingface/label-files'''
				if "k400" in model_name:
								_A :				Optional[int]				=  400
								_A :				List[str]				=  '''kinetics400-id2label.json'''
				elif "k600" in model_name:
								_A :				Dict				=  600
								_A :				Dict				=  '''kinetics600-id2label.json'''
				elif "ssv2" in model_name:
								_A :				str				=  174
								_A :				Optional[int]				=  '''something-something-v2-id2label.json'''
				else:
								raise ValueError('''Model name should either contain \'k400\', \'k600\' or \'ssv2\'.''')
				_A :				Dict				=  json.load(open(hf_hub_download(lowerCAmelCase   , lowerCAmelCase   , repo_type='''dataset''')   , '''r'''))
				_A :				int				=  {int(lowerCAmelCase): v for k, v in idalabel.items()}
				_A :				Dict				=  idalabel
				_A :				List[str]				=  {v: k for k, v in idalabel.items()}

				return config





def      lowercase  (  lowerCAmelCase :						Optional[int]):



				"""simple docstring"""


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

				return name





def      lowercase  (  lowerCAmelCase :						Any   , lowerCAmelCase :						Optional[int]):



				"""simple docstring"""


				for key in orig_state_dict.copy().keys():
								_A :				Dict				=  orig_state_dict.pop(lowerCAmelCase)

								if key.startswith('''model.'''):
												_A :				Dict				=  key.replace('''model.'''   , '''''')

								if "qkv" in key:
												_A :				Optional[int]				=  key.split('''.''')
												_A :				str				=  int(key_split[1])
												_A :				Union[str, Any]				=  '''timesformer.encoder.layer.'''
												if "temporal" in key:
																_A :				Tuple				=  '''.temporal_attention.attention.qkv.'''
												else:
																_A :				Dict				=  '''.attention.attention.qkv.'''
												if "weight" in key:
																_A :				Dict				=  val
												else:
																_A :				int				=  val
								else:
												_A :				int				=  val

				return orig_state_dict





def      lowercase  (  ):



				"""simple docstring"""


				_A :				str				=  hf_hub_download(
				    repo_id='''hf-internal-testing/spaghetti-video'''   , filename='''eating_spaghetti.npy'''   , repo_type='''dataset''')
				_A :				Dict				=  np.load(lowerCAmelCase)
				return list(lowerCAmelCase)





def      lowercase  (  lowerCAmelCase :						Any   , lowerCAmelCase :						Tuple   , lowerCAmelCase :						int   , lowerCAmelCase :						List[str]):



				"""simple docstring"""


				_A :				List[str]				=  get_timesformer_config(lowerCAmelCase)

				_A :				Optional[int]				=  TimesformerForVideoClassification(lowerCAmelCase)

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

				model.load_state_dict(lowerCAmelCase)
				model.eval()

				# verify model on basic input
				_A :				List[str]				=  VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]   , image_std=[0.5, 0.5, 0.5])
				_A :				Optional[Any]				=  prepare_video()
				_A :				List[Any]				=  image_processor(video[:8]   , return_tensors='''pt''')

				_A :				Tuple				=  model(**lowerCAmelCase)
				_A :				Tuple				=  outputs.logits

				_A :				Optional[int]				=  [
				    # 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":
								_A :				Tuple				=  torch.Size([1, 400])
								_A :				Tuple				=  torch.tensor([-0.3_0_1_6, -0.7_7_1_3, -0.4_2_0_5])
				elif model_name == "timesformer-base-finetuned-k600":
								_A :				Optional[int]				=  torch.Size([1, 600])
								_A :				List[Any]				=  torch.tensor([-0.7_2_6_7, -0.7_4_6_6, 3.2_4_0_4])
				elif model_name == "timesformer-base-finetuned-ssv2":
								_A :				Dict				=  torch.Size([1, 174])
								_A :				List[str]				=  torch.tensor([-0.9_0_5_9, 0.6_4_3_3, -3.1_4_5_7])
				elif model_name == "timesformer-large-finetuned-k400":
								_A :				Dict				=  torch.Size([1, 400])
								_A :				str				=  torch.tensor([0, 0, 0])
				elif model_name == "timesformer-large-finetuned-k600":
								_A :				str				=  torch.Size([1, 600])
								_A :				List[Any]				=  torch.tensor([0, 0, 0])
				elif model_name == "timesformer-large-finetuned-ssv2":
								_A :				List[Any]				=  torch.Size([1, 174])
								_A :				Optional[Any]				=  torch.tensor([0, 0, 0])
				elif model_name == "timesformer-hr-finetuned-k400":
								_A :				Optional[Any]				=  torch.Size([1, 400])
								_A :				Dict				=  torch.tensor([-0.9_6_1_7, -3.7_3_1_1, -3.7_7_0_8])
				elif model_name == "timesformer-hr-finetuned-k600":
								_A :				Tuple				=  torch.Size([1, 600])
								_A :				List[str]				=  torch.tensor([2.5_2_7_3, 0.7_1_2_7, 1.8_8_4_8])
				elif model_name == "timesformer-hr-finetuned-ssv2":
								_A :				List[Any]				=  torch.Size([1, 174])
								_A :				Optional[int]				=  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__":
	__UpperCamelCase      :   Optional[Any]								=     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.'''
	)

	__UpperCamelCase      :   int								=     parser.parse_args()
	convert_timesformer_checkpoint(
	    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
	)







'''simple docstring'''






import sys

sys.set_int_max_str_digits(0)  # type: ignore





def      lowercase  (  lowerCAmelCase :						int):



				"""simple docstring"""


				_A :				List[Any]				=  [0] * 11
				_A :				Optional[Any]				=  [0] * 11

				# mark last 9 numbers
				for _ in range(9):
								_A :				Dict				=  1
								_A :				Optional[int]				=  number // 10
				# flag
				_A :				str				=  True

				# check last 9 numbers for pandigitality

				for x in range(9):
								if not check_last[x + 1]:
												_A :				Dict				=  False
				if not f:
								return f

				# mark first 9 numbers
				_A :				str				=  int(str(lowerCAmelCase)[:9])

				for _ in range(9):
								_A :				Tuple				=  1
								_A :				Union[str, Any]				=  number // 10

				# check first 9 numbers for pandigitality

				for x in range(9):
								if not check_front[x + 1]:
												_A :				Union[str, Any]				=  False
				return f





def      lowercase  (  lowerCAmelCase :						int):



				"""simple docstring"""


				_A :				Tuple				=  [0] * 11

				# mark last 9 numbers
				for _ in range(9):
								_A :				int				=  1
								_A :				Optional[int]				=  number // 10
				# flag
				_A :				List[str]				=  True

				# check last 9 numbers for pandigitality

				for x in range(9):
								if not check_last[x + 1]:
												_A :				Any				=  False
				return f





def      lowercase  (  ):



				"""simple docstring"""


				_A :				Union[str, Any]				=  1
				_A :				Tuple				=  1
				_A :				List[str]				=  2
				# temporary Fibonacci numbers

				_A :				List[str]				=  1
				_A :				str				=  1
				_A :				List[str]				=  2
				# temporary Fibonacci numbers mod 1e9

				# mod m=1e9, done for fast optimisation
				_A :				Any				=  [0] * 100_0000
				_A :				List[Any]				=  10_0000_0000

				for x in range(100_0000):
								_A :				Dict				=  (aa + ba) % m
								_A :				str				=  ba % m
								_A :				Union[str, Any]				=  ca % m
								if checka(lowerCAmelCase):
												_A :				List[str]				=  1

				for x in range(100_0000):
								_A :				str				=  a + b
								_A :				List[str]				=  b
								_A :				int				=  c
								# perform check only if in tocheck
								if tocheck[x + 3] and check(lowerCAmelCase):
												return x + 3  # first 2 already done
				return -1


if __name__ == "__main__":
	print(f'{solution() = }')
