





"""simple docstring"""
import math



def   __lowerCamelCase     (							a_  :	int							)    ->   str:
      if number == 0:
            __SCREAMING_SNAKE_CASE     :Optional[int]	       =						'''Zero'''
            return words
      else:
            __SCREAMING_SNAKE_CASE     :int	       =						math.logaa(a_							)
            __SCREAMING_SNAKE_CASE     :Any	       =						digits + 1
            __SCREAMING_SNAKE_CASE     :Dict	       =						{}
            __SCREAMING_SNAKE_CASE     :Optional[int]	       =						''''''
            __SCREAMING_SNAKE_CASE     :Tuple	       =						'''One'''
            __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						'''Two'''
            __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						'''Three'''
            __SCREAMING_SNAKE_CASE     :str	       =						'''Four'''
            __SCREAMING_SNAKE_CASE     :Dict	       =						'''Five'''
            __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						'''Six'''
            __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						'''Seven'''
            __SCREAMING_SNAKE_CASE     :str	       =						'''Eight'''
            __SCREAMING_SNAKE_CASE     :Dict	       =						'''Nine'''

            __SCREAMING_SNAKE_CASE     :str	       =						{}
            __SCREAMING_SNAKE_CASE     :str	       =						''''''
            __SCREAMING_SNAKE_CASE     :List[str]	       =						'''Twenty'''
            __SCREAMING_SNAKE_CASE     :Any	       =						'''Thirty'''
            __SCREAMING_SNAKE_CASE     :str	       =						'''Forty'''
            __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						'''Fifty'''
            __SCREAMING_SNAKE_CASE     :Tuple	       =						'''Sixty'''
            __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						'''Seventy'''
            __SCREAMING_SNAKE_CASE     :Optional[int]	       =						'''Eighty'''
            __SCREAMING_SNAKE_CASE     :List[str]	       =						'''Ninety'''

            __SCREAMING_SNAKE_CASE     :Any	       =						{}
            __SCREAMING_SNAKE_CASE     :str	       =						'''Ten'''
            __SCREAMING_SNAKE_CASE     :Tuple	       =						'''Eleven'''
            __SCREAMING_SNAKE_CASE     :Tuple	       =						'''Twelve'''
            __SCREAMING_SNAKE_CASE     :int	       =						'''Thirteen'''
            __SCREAMING_SNAKE_CASE     :Any	       =						'''Fourteen'''
            __SCREAMING_SNAKE_CASE     :Any	       =						'''Fifteen'''
            __SCREAMING_SNAKE_CASE     :Tuple	       =						'''Sixteen'''
            __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						'''Seventeen'''
            __SCREAMING_SNAKE_CASE     :Any	       =						'''Eighteen'''
            __SCREAMING_SNAKE_CASE     :List[Any]	       =						'''Nineteen'''

            __SCREAMING_SNAKE_CASE     :str	       =						{}
            __SCREAMING_SNAKE_CASE     :Optional[int]	       =						'''Hundred,'''
            __SCREAMING_SNAKE_CASE     :List[str]	       =						'''Thousand,'''
            __SCREAMING_SNAKE_CASE     :str	       =						'''Lakh,'''
            __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						'''Crore,'''

            __SCREAMING_SNAKE_CASE     :Dict	       =						number
            __SCREAMING_SNAKE_CASE     :Dict	       =						''''''
            __SCREAMING_SNAKE_CASE     :Optional[int]	       =						0
            __SCREAMING_SNAKE_CASE     :Tuple	       =						int(a_							)
            while counter < digits:
                  __SCREAMING_SNAKE_CASE     :Tuple	       =						temp_num % 10
                  if counter % 2 == 0:
                        __SCREAMING_SNAKE_CASE     :List[Any]	       =						''''''
                        if counter in placevalue and current != 0:
                              __SCREAMING_SNAKE_CASE     :Optional[int]	       =						placevalue[counter]
                        if counter == 2:
                              __SCREAMING_SNAKE_CASE     :Dict	       =						singles[current] + addition + words
                        elif counter == 0:
                              if ((temp_num % 1_00) // 10) == 1:
                                    __SCREAMING_SNAKE_CASE     :Dict	       =						teens[current] + addition + words
                                    __SCREAMING_SNAKE_CASE     :int	       =						temp_num // 10
                                    counter += 1
                              else:
                                    __SCREAMING_SNAKE_CASE     :str	       =						singles[current] + addition + words

                        else:
                              __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						doubles[current] + addition + words

                  else:
                        if counter == 1:
                              if current == 1:
                                    __SCREAMING_SNAKE_CASE     :Any	       =						teens[number % 10] + words
                              else:
                                    __SCREAMING_SNAKE_CASE     :Dict	       =						''''''
                                    if counter in placevalue:
                                          __SCREAMING_SNAKE_CASE     :Tuple	       =						placevalue[counter]
                                    __SCREAMING_SNAKE_CASE     :List[Any]	       =						doubles[current] + addition + words
                        else:
                              __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						''''''
                              if counter in placevalue:
                                    if current == 0 and ((temp_num % 1_00) // 10) == 0:
                                          __SCREAMING_SNAKE_CASE     :Tuple	       =						''''''
                                    else:
                                          __SCREAMING_SNAKE_CASE     :Any	       =						placevalue[counter]
                              if ((temp_num % 1_00) // 10) == 1:
                                    __SCREAMING_SNAKE_CASE     :Optional[int]	       =						teens[current] + addition + words
                                    __SCREAMING_SNAKE_CASE     :List[str]	       =						temp_num // 10
                                    counter += 1
                              else:
                                    __SCREAMING_SNAKE_CASE     :List[str]	       =						singles[current] + addition + words
                  counter += 1
                  __SCREAMING_SNAKE_CASE     :Any	       =						temp_num // 10
      return words


if __name__ == "__main__":
  import doctest

  doctest.testmod()






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

      if "large" in model_name:
            __SCREAMING_SNAKE_CASE     :Dict	       =						96

      if "hr" in model_name:
            __SCREAMING_SNAKE_CASE     :List[Any]	       =						16
            __SCREAMING_SNAKE_CASE     :int	       =						4_48

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

      return config



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

      return name



def   __lowerCamelCase     (							a_  :	Optional[Any]				,     a_  :	Tuple							)    ->   Optional[int]:
      for key in orig_state_dict.copy().keys():
            __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						orig_state_dict.pop(a_							)

            if key.startswith('''model.'''							):
                  __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						key.replace('''model.'''				,     ''''''							)

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

      return orig_state_dict



def   __lowerCamelCase     (							)    ->   Optional[int]:
      __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						hf_hub_download(
          repo_id='''hf-internal-testing/spaghetti-video'''				,     filename='''eating_spaghetti.npy'''				,     repo_type='''dataset'''							)
      __SCREAMING_SNAKE_CASE     :Tuple	       =						np.load(a_							)
      return list(a_							)



def   __lowerCamelCase     (							a_  :	List[Any]				,     a_  :	int				,     a_  :	Optional[int]				,     a_  :	Optional[Any]							)    ->   Union[str, Any]:
      __SCREAMING_SNAKE_CASE     :List[Any]	       =						get_timesformer_config(a_							)

      __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						TimesformerForVideoClassification(a_							)

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

      model.load_state_dict(a_							)
      model.eval()

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

      __SCREAMING_SNAKE_CASE     :Tuple	       =						model(**a_							)
      __SCREAMING_SNAKE_CASE     :List[str]	       =						outputs.logits

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