'''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      UpperCamelCase_							( _UpperCAmelCase  :				List[str]   )   ->   Optional[int]:


       """simple docstring"""







       _UpperCAmelCase					:  Optional[int]											=   TimesformerConfig()

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

       if "hr" in model_name:
              _UpperCAmelCase					:  Optional[int]											=   16
              _UpperCAmelCase					:  List[str]											=   448

       _UpperCAmelCase					:  int											=   "huggingface/label-files"
       if "k400" in model_name:
              _UpperCAmelCase					:  List[Any]											=   400
              _UpperCAmelCase					:  Optional[Any]											=   "kinetics400-id2label.json"
       elif "k600" in model_name:
              _UpperCAmelCase					:  Optional[int]											=   600
              _UpperCAmelCase					:  Optional[Any]											=   "kinetics600-id2label.json"
       elif "ssv2" in model_name:
              _UpperCAmelCase					:  Dict											=   174
              _UpperCAmelCase					:  Union[str, Any]											=   "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(lowercase_      ,     lowercase_      ,     repo_type="dataset"   )      ,     "r"   )   )
       _UpperCAmelCase					:  int											=   {int(lowercase_   ): v for k, v in idalabel.items()}
       _UpperCAmelCase					:  Any											=   idalabel
       _UpperCAmelCase					:  int											=   {v: k for k, v in idalabel.items()}

       return config

def      UpperCamelCase_							( _UpperCAmelCase  :				Dict   )   ->   Any:


       """simple docstring"""







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

       return name

def      UpperCamelCase_							( _UpperCAmelCase  :				Tuple      ,     _UpperCAmelCase  :				Union[str, Any]   )   ->   List[Any]:


       """simple docstring"""







       for key in orig_state_dict.copy().keys():
              _UpperCAmelCase					:  List[str]											=   orig_state_dict.pop(lowercase_   )

              if key.startswith("model."   ):
                     _UpperCAmelCase					:  Tuple											=   key.replace("model."      ,     ""   )

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

       return orig_state_dict

def      UpperCamelCase_							( )   ->   Any:


       """simple docstring"""







       _UpperCAmelCase					:  str											=   hf_hub_download(
           repo_id="hf-internal-testing/spaghetti-video"      ,     filename="eating_spaghetti.npy"      ,     repo_type="dataset"   )
       _UpperCAmelCase					:  str											=   np.load(lowercase_   )
       return list(lowercase_   )

def      UpperCamelCase_							( _UpperCAmelCase  :				List[str]      ,     _UpperCAmelCase  :				List[Any]      ,     _UpperCAmelCase  :				Optional[Any]      ,     _UpperCAmelCase  :				int   )   ->   List[Any]:


       """simple docstring"""







       _UpperCAmelCase					:  int											=   get_timesformer_config(lowercase_   )

       _UpperCAmelCase					:  int											=   TimesformerForVideoClassification(lowercase_   )

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

       model.load_state_dict(lowercase_   )
       model.eval()

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

       _UpperCAmelCase					:  List[str]											=   model(**lowercase_   )
       _UpperCAmelCase					:  List[str]											=   outputs.logits

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

  __SCREAMING_SNAKE_CASE	:					List[str]					=  parser.parse_args()
  convert_timesformer_checkpoint(
      args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
  )


'''simple docstring'''




from itertools import compress, repeat
from math import ceil, sqrt

def      UpperCamelCase_							( _UpperCAmelCase  :				int   )   ->   list[int]:


       """simple docstring"""







       if num <= 2:
              return []
       if num == 3:
              return [2]

       # Odd sieve for numbers in range [3, num - 1]
       _UpperCAmelCase					:  Optional[int]											=   bytearray(b"\x01"   ) * ((num >> 1) - 1)

       for i in range(3      ,     int(sqrt(_UpperCAmelCase   )   ) + 1      ,     2   ):
              if sieve[(i >> 1) - 1]:
                     _UpperCAmelCase					:  List[Any]											=   i**2
                     _UpperCAmelCase					:  Optional[int]											=   repeat(
                         0      ,     ceil((num - i_squared) / (i << 1)   )   )

       return [2] + list(compress(range(3      ,     _UpperCAmelCase      ,     2   )      ,     _UpperCAmelCase   )   )


if __name__ == "__main__":
  import doctest

  doctest.testmod()

