





"""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_     (  lowercase_       :							int		):

 '''simple docstring'''






 __SCREAMING_SNAKE_CASE			:      Optional[Any] 							=	TimesformerConfig()

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

 if "hr" in model_name:
  __SCREAMING_SNAKE_CASE			:      Union[str, Any] 							=	16
  __SCREAMING_SNAKE_CASE			:      Any 							=	448

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

 return config




def 		lowerCAmelCase_     (  lowercase_       :							List[Any]		):

 '''simple docstring'''






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

 return name




def 		lowerCAmelCase_     (  lowercase_       :							List[Any]			,				lowercase_       :							Any		):

 '''simple docstring'''






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

  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			:      Union[str, Any] 							=	int(key_split[1]		)
   __SCREAMING_SNAKE_CASE			:      List[str] 							=	"""timesformer.encoder.layer."""
   if "temporal" in key:
    __SCREAMING_SNAKE_CASE			:      Any 							=	""".temporal_attention.attention.qkv."""
   else:
    __SCREAMING_SNAKE_CASE			:      Dict 							=	""".attention.attention.qkv."""
   if "weight" in key:
    __SCREAMING_SNAKE_CASE			:      Any 							=	val
   else:
    __SCREAMING_SNAKE_CASE			:      Dict 							=	val
  else:
   __SCREAMING_SNAKE_CASE			:      List[str] 							=	val

 return orig_state_dict




def 		lowerCAmelCase_     (  ):

 '''simple docstring'''






 __SCREAMING_SNAKE_CASE			:      int 							=	hf_hub_download(
     repo_id='''hf-internal-testing/spaghetti-video'''			,				filename='''eating_spaghetti.npy'''			,				repo_type='''dataset'''		)
 __SCREAMING_SNAKE_CASE			:      int 							=	np.load(_lowerCamelCase		)
 return list(_lowerCamelCase		)




def 		lowerCAmelCase_     (  lowercase_       :							Tuple			,				lowercase_       :							Union[str, Any]			,				lowercase_       :							Dict			,				lowercase_       :							Dict		):

 '''simple docstring'''






 __SCREAMING_SNAKE_CASE			:      List[Any] 							=	get_timesformer_config(_lowerCamelCase		)

 __SCREAMING_SNAKE_CASE			:      List[Any] 							=	TimesformerForVideoClassification(_lowerCamelCase		)

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

 model.load_state_dict(_lowerCamelCase		)
 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			:      int 							=	prepare_video()
 __SCREAMING_SNAKE_CASE			:      Any 							=	image_processor(video[:8]			,				return_tensors='''pt'''		)

 __SCREAMING_SNAKE_CASE			:      str 							=	model(**_lowerCamelCase		)
 __SCREAMING_SNAKE_CASE			:      int 							=	outputs.logits

 __SCREAMING_SNAKE_CASE			:      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":
  __SCREAMING_SNAKE_CASE			:      Tuple 							=	torch.Size([1, 400]		)
  __SCREAMING_SNAKE_CASE			:      Optional[int] 							=	torch.tensor([-0.3_016, -0.7_713, -0.4_205]		)
 elif model_name == "timesformer-base-finetuned-k600":
  __SCREAMING_SNAKE_CASE			:      Union[str, Any] 							=	torch.Size([1, 600]		)
  __SCREAMING_SNAKE_CASE			:      int 							=	torch.tensor([-0.7_267, -0.7_466, 3.2_404]		)
 elif model_name == "timesformer-base-finetuned-ssv2":
  __SCREAMING_SNAKE_CASE			:      Any 							=	torch.Size([1, 174]		)
  __SCREAMING_SNAKE_CASE			:      Dict 							=	torch.tensor([-0.9_059, 0.6_433, -3.1_457]		)
 elif model_name == "timesformer-large-finetuned-k400":
  __SCREAMING_SNAKE_CASE			:      List[str] 							=	torch.Size([1, 400]		)
  __SCREAMING_SNAKE_CASE			:      List[str] 							=	torch.tensor([0, 0, 0]		)
 elif model_name == "timesformer-large-finetuned-k600":
  __SCREAMING_SNAKE_CASE			:      Dict 							=	torch.Size([1, 600]		)
  __SCREAMING_SNAKE_CASE			:      int 							=	torch.tensor([0, 0, 0]		)
 elif model_name == "timesformer-large-finetuned-ssv2":
  __SCREAMING_SNAKE_CASE			:      Optional[int] 							=	torch.Size([1, 174]		)
  __SCREAMING_SNAKE_CASE			:      int 							=	torch.tensor([0, 0, 0]		)
 elif model_name == "timesformer-hr-finetuned-k400":
  __SCREAMING_SNAKE_CASE			:      Tuple 							=	torch.Size([1, 400]		)
  __SCREAMING_SNAKE_CASE			:      Optional[Any] 							=	torch.tensor([-0.9_617, -3.7_311, -3.7_708]		)
 elif model_name == "timesformer-hr-finetuned-k600":
  __SCREAMING_SNAKE_CASE			:      List[Any] 							=	torch.Size([1, 600]		)
  __SCREAMING_SNAKE_CASE			:      Tuple 							=	torch.tensor([2.5_273, 0.7_127, 1.8_848]		)
 elif model_name == "timesformer-hr-finetuned-ssv2":
  __SCREAMING_SNAKE_CASE			:      Union[str, Any] 							=	torch.Size([1, 174]		)
  __SCREAMING_SNAKE_CASE			:      Tuple 							=	torch.tensor([-3.6_756, -0.7_513, 0.7_180]		)
 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__":
    _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
    )








"""simple docstring"""





#
# Sort large text files in a minimum amount of memory
#
import argparse
import os





class       snake_case		:
      lowerCamelCase__      =			'''block_{0}.dat'''

      def __init__(      self       :int						,							_lowerCamelCase       :Dict						):
       __SCREAMING_SNAKE_CASE			:      List[str] 							=	filename
       __SCREAMING_SNAKE_CASE			:      Tuple 							=	[]

      def 						SCREAMING_SNAKE_CASE_      (      self       :List[Any]						,							_lowerCamelCase       :Tuple						,							_lowerCamelCase       :Union[str, Any]						):
       __SCREAMING_SNAKE_CASE			:      Any 							=	self.BLOCK_FILENAME_FORMAT.format(_lowerCamelCase						)
       with open(_lowerCamelCase						,							'''w'''						) as file:
        file.write(_lowerCamelCase						)
       self.block_filenames.append(_lowerCamelCase						)

      def 						SCREAMING_SNAKE_CASE_      (      self       :int						):
       return self.block_filenames

      def 						SCREAMING_SNAKE_CASE_      (      self       :Tuple						,							_lowerCamelCase       :List[str]						,							_lowerCamelCase       :Optional[Any]=None						):
       __SCREAMING_SNAKE_CASE			:      int 							=	0
       with open(self.filename						) as file:
        while True:
         __SCREAMING_SNAKE_CASE			:      Any 							=	file.readlines(_lowerCamelCase						)

         if lines == []:
          break

         if sort_key is None:
          lines.sort()
         else:
          lines.sort(key=_lowerCamelCase						)

         self.write_block(''''''.join(_lowerCamelCase						)						,							_lowerCamelCase						)
         i += 1



      def 						SCREAMING_SNAKE_CASE_      (      self       :Tuple						):
       map(os.remove						,							self.block_filenames						)







class       snake_case		:

      def 						SCREAMING_SNAKE_CASE_      (      self       :int						,							_lowerCamelCase       :Tuple						):
       __SCREAMING_SNAKE_CASE			:      List[str] 							=	-1
       __SCREAMING_SNAKE_CASE			:      List[str] 							=	None

       for i in range(len(_lowerCamelCase						)						):
        if min_str is None or choices[i] < min_str:
         __SCREAMING_SNAKE_CASE			:      Tuple 							=	i

       return min_index







class       snake_case		:

      def __init__(      self       :str						,							_lowerCamelCase       :Tuple						):
       __SCREAMING_SNAKE_CASE			:      Any 							=	files
       __SCREAMING_SNAKE_CASE			:      str 							=	set()
       __SCREAMING_SNAKE_CASE			:      Dict 							=	len(_lowerCamelCase						)
       __SCREAMING_SNAKE_CASE			:      str 							=	{i: None for i in range(self.num_buffers						)}

      def 						SCREAMING_SNAKE_CASE_      (      self       :Optional[Any]						):
       return {
           i: self.buffers[i] for i in range(self.num_buffers						) if i not in self.empty
       }

      def 						SCREAMING_SNAKE_CASE_      (      self       :Union[str, Any]						):
       for i in range(self.num_buffers						):
        if self.buffers[i] is None and i not in self.empty:
         __SCREAMING_SNAKE_CASE			:      int 							=	self.files[i].readline()

         if self.buffers[i] == "":
          self.empty.add(_lowerCamelCase						)
          self.files[i].close()

       if len(self.empty						) == self.num_buffers:
        return False

       return True



      def 						SCREAMING_SNAKE_CASE_      (      self       :Any						,							_lowerCamelCase       :List[str]						):
       __SCREAMING_SNAKE_CASE			:      Dict 							=	self.buffers[index]
       __SCREAMING_SNAKE_CASE			:      List[Any] 							=	None

       return value







class       snake_case		:

      def __init__(      self       :List[Any]						,							_lowerCamelCase       :Optional[int]						):
       __SCREAMING_SNAKE_CASE			:      Optional[int] 							=	merge_strategy

      def 						SCREAMING_SNAKE_CASE_      (      self       :int						,							_lowerCamelCase       :Tuple						,							_lowerCamelCase       :Any						,							_lowerCamelCase       :str						):
       __SCREAMING_SNAKE_CASE			:      List[Any] 							=	FilesArray(self.get_file_handles(_lowerCamelCase						,							_lowerCamelCase						)						)
       with open(_lowerCamelCase						,							'''w'''						,							_lowerCamelCase						) as outfile:
        while buffers.refresh():
         __SCREAMING_SNAKE_CASE			:      List[Any] 							=	self.merge_strategy.select(buffers.get_dict()						)
         outfile.write(buffers.unshift(_lowerCamelCase						)						)



      def 						SCREAMING_SNAKE_CASE_      (      self       :Union[str, Any]						,							_lowerCamelCase       :int						,							_lowerCamelCase       :Optional[Any]						):
       __SCREAMING_SNAKE_CASE			:      Union[str, Any] 							=	{}

       for i in range(len(_lowerCamelCase						)						):
        __SCREAMING_SNAKE_CASE			:      Optional[int] 							=	open(filenames[i]						,							'''r'''						,							_lowerCamelCase						)  # noqa: UP015

       return files







class       snake_case		:

      def __init__(      self       :Dict						,							_lowerCamelCase       :str						):
       __SCREAMING_SNAKE_CASE			:      int 							=	block_size

      def 						SCREAMING_SNAKE_CASE_      (      self       :Optional[Any]						,							_lowerCamelCase       :List[str]						,							_lowerCamelCase       :Dict=None						):
       __SCREAMING_SNAKE_CASE			:      Dict 							=	self.get_number_blocks(_lowerCamelCase						,							self.block_size						)
       __SCREAMING_SNAKE_CASE			:      Dict 							=	FileSplitter(_lowerCamelCase						)
       splitter.split(self.block_size						,							_lowerCamelCase						)

       __SCREAMING_SNAKE_CASE			:      Any 							=	FileMerger(NWayMerge()						)
       __SCREAMING_SNAKE_CASE			:      List[Any] 							=	self.block_size / (num_blocks + 1)
       merger.merge(splitter.get_block_filenames()						,							filename + '''.out'''						,							_lowerCamelCase						)

       splitter.cleanup()



      def 						SCREAMING_SNAKE_CASE_      (      self       :Dict						,							_lowerCamelCase       :str						,							_lowerCamelCase       :List[Any]						):
       return (os.stat(_lowerCamelCase						).st_size / block_size) + 1







def 		lowerCAmelCase_     (  lowercase_       :							str		):

 '''simple docstring'''






 if string[-1].lower() == "k":
  return int(string[:-1]		) * 1024
 elif string[-1].lower() == "m":
  return int(string[:-1]		) * 1024 * 1024
 elif string[-1].lower() == "g":
  return int(string[:-1]		) * 1024 * 1024 * 1024
 else:
  return int(lowercase_		)




def 		lowerCAmelCase_     (  ):

 '''simple docstring'''






 __SCREAMING_SNAKE_CASE			:      Optional[Any] 							=	argparse.ArgumentParser()
 parser.add_argument(
     '''-m'''			,				'''--mem'''			,				help='''amount of memory to use for sorting'''			,				default='''100M'''		)
 parser.add_argument(
     '''filename'''			,				metavar='''<filename>'''			,				nargs=1			,				help='''name of file to sort'''		)
 __SCREAMING_SNAKE_CASE			:      Optional[Any] 							=	parser.parse_args()

 __SCREAMING_SNAKE_CASE			:      List[str] 							=	ExternalSort(parse_memory(args.mem		)		)
 sorter.sort(args.filename[0]		)


if __name__ == "__main__":
    main()

