



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     (				a__     )       ->				Union[str, Any]:
							__SCREAMING_SNAKE_CASE								=      TimesformerConfig()

							if "large" in model_name:
														__SCREAMING_SNAKE_CASE								=      96

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

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

							return config






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

							return name






def 			__lowercase     (				a__							,     a__     )       ->				Optional[int]:
							for key in orig_state_dict.copy().keys():
														__SCREAMING_SNAKE_CASE								=      orig_state_dict.pop(a__     )

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

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

							return orig_state_dict






def 			__lowercase     (				)       ->				List[str]:
							__SCREAMING_SNAKE_CASE								=      hf_hub_download(
							    repo_id='hf-internal-testing/spaghetti-video'							,     filename='eating_spaghetti.npy'							,     repo_type='dataset'     )
							__SCREAMING_SNAKE_CASE								=      np.load(a__     )
							return list(a__     )






def 			__lowercase     (				a__							,     a__							,     a__							,     a__     )       ->				int:
							__SCREAMING_SNAKE_CASE								=      get_timesformer_config(a__     )

							__SCREAMING_SNAKE_CASE								=      TimesformerForVideoClassification(a__     )

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

							model.load_state_dict(a__     )
							model.eval()

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

							__SCREAMING_SNAKE_CASE								=      model(**a__     )
							__SCREAMING_SNAKE_CASE								=      outputs.logits

							__SCREAMING_SNAKE_CASE								=      [
							    # 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":
														__SCREAMING_SNAKE_CASE								=      torch.Size([1, 4_00]     )
														__SCREAMING_SNAKE_CASE								=      torch.tensor([-0.3016, -0.7713, -0.4205]     )
							elif model_name == "timesformer-base-finetuned-k600":
														__SCREAMING_SNAKE_CASE								=      torch.Size([1, 6_00]     )
														__SCREAMING_SNAKE_CASE								=      torch.tensor([-0.7267, -0.7466, 3.2404]     )
							elif model_name == "timesformer-base-finetuned-ssv2":
														__SCREAMING_SNAKE_CASE								=      torch.Size([1, 1_74]     )
														__SCREAMING_SNAKE_CASE								=      torch.tensor([-0.9059, 0.6433, -3.1457]     )
							elif model_name == "timesformer-large-finetuned-k400":
														__SCREAMING_SNAKE_CASE								=      torch.Size([1, 4_00]     )
														__SCREAMING_SNAKE_CASE								=      torch.tensor([0, 0, 0]     )
							elif model_name == "timesformer-large-finetuned-k600":
														__SCREAMING_SNAKE_CASE								=      torch.Size([1, 6_00]     )
														__SCREAMING_SNAKE_CASE								=      torch.tensor([0, 0, 0]     )
							elif model_name == "timesformer-large-finetuned-ssv2":
														__SCREAMING_SNAKE_CASE								=      torch.Size([1, 1_74]     )
														__SCREAMING_SNAKE_CASE								=      torch.tensor([0, 0, 0]     )
							elif model_name == "timesformer-hr-finetuned-k400":
														__SCREAMING_SNAKE_CASE								=      torch.Size([1, 4_00]     )
														__SCREAMING_SNAKE_CASE								=      torch.tensor([-0.9617, -3.7311, -3.7708]     )
							elif model_name == "timesformer-hr-finetuned-k600":
														__SCREAMING_SNAKE_CASE								=      torch.Size([1, 6_00]     )
														__SCREAMING_SNAKE_CASE								=      torch.tensor([2.5273, 0.7127, 1.8848]     )
							elif model_name == "timesformer-hr-finetuned-ssv2":
														__SCREAMING_SNAKE_CASE								=      torch.Size([1, 1_74]     )
														__SCREAMING_SNAKE_CASE								=      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]							,     a__							,     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(a__     )
														model.save_pretrained(a__     )

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


if __name__ == "__main__":
			lowerCAmelCase__	:  str 		=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__	:  List[str] 		=parser.parse_args()
			convert_timesformer_checkpoint(
			    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
			)











from itertools import combinations, product






def 			__lowercase     (				a__							,     a__							,     a__							,     a__     )       ->				bool:
							if xa == ya == 0 or xa == ya == 0:
														return False
							__SCREAMING_SNAKE_CASE								=      xa * xa + ya * ya
							__SCREAMING_SNAKE_CASE								=      xa * xa + ya * ya
							__SCREAMING_SNAKE_CASE								=      (xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
							return (
							    a_square + b_square == c_square
							    or a_square + c_square == b_square
							    or b_square + c_square == a_square
							)






def 			__lowercase     (				a__ = 50     )       ->				int:
							return sum(
							    1
							    for pta, pta in combinations(product(range(limit + 1     )							,     repeat=2     )							,     2     )
							    if is_right(*a__							,     *a__     )     )


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






