

"""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  (   __UpperCamelCase ):
 '''simple docstring'''





 UpperCAmelCase__   :					Tuple   				=   TimesformerConfig()

 if "large" in model_name:
  UpperCAmelCase__   :					Optional[int]   				=   96

 if "hr" in model_name:
  UpperCAmelCase__   :					List[str]   				=   16
  UpperCAmelCase__   :					str   				=   448

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

 return config
def 					lowerCAmelCase  (   __UpperCamelCase ):
 '''simple docstring'''





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

 return name
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase ):
 '''simple docstring'''





 for key in orig_state_dict.copy().keys():
  UpperCAmelCase__   :					int   				=   orig_state_dict.pop(_lowerCAmelCase )

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

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

 return orig_state_dict
def 					lowerCAmelCase  (   ):
 '''simple docstring'''





 UpperCAmelCase__   :					List[str]   				=   hf_hub_download(
     repo_id="""hf-internal-testing/spaghetti-video"""							,      filename="""eating_spaghetti.npy"""							,      repo_type="""dataset""" )
 UpperCAmelCase__   :					Optional[Any]   				=   np.load(_lowerCAmelCase )
 return list(_lowerCAmelCase )
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase							,      __UpperCamelCase ):
 '''simple docstring'''





 UpperCAmelCase__   :					List[Any]   				=   get_timesformer_config(_lowerCAmelCase )

 UpperCAmelCase__   :					Tuple   				=   TimesformerForVideoClassification(_lowerCAmelCase )

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

 model.load_state_dict(_lowerCAmelCase )
 model.eval()

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

 UpperCAmelCase__   :					Tuple   				=   model(**_lowerCAmelCase )
 UpperCAmelCase__   :					str   				=   outputs.logits

 UpperCAmelCase__   :					List[str]   				=   [
     # 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":
  UpperCAmelCase__   :					Any   				=   torch.Size([1, 400] )
  UpperCAmelCase__   :					int   				=   torch.tensor([-0.3016, -0.7713, -0.4205] )
 elif model_name == "timesformer-base-finetuned-k600":
  UpperCAmelCase__   :					Optional[int]   				=   torch.Size([1, 600] )
  UpperCAmelCase__   :					Union[str, Any]   				=   torch.tensor([-0.7267, -0.7466, 3.2404] )
 elif model_name == "timesformer-base-finetuned-ssv2":
  UpperCAmelCase__   :					List[Any]   				=   torch.Size([1, 174] )
  UpperCAmelCase__   :					Dict   				=   torch.tensor([-0.9059, 0.6433, -3.1457] )
 elif model_name == "timesformer-large-finetuned-k400":
  UpperCAmelCase__   :					int   				=   torch.Size([1, 400] )
  UpperCAmelCase__   :					List[Any]   				=   torch.tensor([0, 0, 0] )
 elif model_name == "timesformer-large-finetuned-k600":
  UpperCAmelCase__   :					int   				=   torch.Size([1, 600] )
  UpperCAmelCase__   :					List[str]   				=   torch.tensor([0, 0, 0] )
 elif model_name == "timesformer-large-finetuned-ssv2":
  UpperCAmelCase__   :					List[str]   				=   torch.Size([1, 174] )
  UpperCAmelCase__   :					List[Any]   				=   torch.tensor([0, 0, 0] )
 elif model_name == "timesformer-hr-finetuned-k400":
  UpperCAmelCase__   :					Optional[int]   				=   torch.Size([1, 400] )
  UpperCAmelCase__   :					str   				=   torch.tensor([-0.9617, -3.7311, -3.7708] )
 elif model_name == "timesformer-hr-finetuned-k600":
  UpperCAmelCase__   :					int   				=   torch.Size([1, 600] )
  UpperCAmelCase__   :					List[str]   				=   torch.tensor([2.5273, 0.7127, 1.8848] )
 elif model_name == "timesformer-hr-finetuned-ssv2":
  UpperCAmelCase__   :					List[Any]   				=   torch.Size([1, 174] )
  UpperCAmelCase__   :					Optional[Any]   				=   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]							,      _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	=			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	=			parser.parse_args()
      convert_timesformer_checkpoint(
          args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
      )








"""simple docstring"""




from math import factorial
def 					lowerCAmelCase  (   __UpperCamelCase							,      __UpperCamelCase ):
 '''simple docstring'''





 return factorial(__UpperCamelCase ) / (factorial(__UpperCamelCase ) * factorial(n - r ))
def 					lowerCAmelCase  (   ):
 '''simple docstring'''





 UpperCAmelCase__   :					Any   				=   0

 for i in range(1							,      101 ):
  for j in range(1							,      i + 1 ):
   if combinations(__UpperCamelCase							,      __UpperCamelCase ) > 1e6:
    total += 1
 return total


if __name__ == "__main__":
      print(solution())





