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 			__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
  			)
  
  
  
  
  
  
  
style_context: 
  
  
  
  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() = }''')
  
  
  
  
  
  
  