






'''simple docstring'''



import argparse
import json

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    VideoMAEConfig,
    VideoMAEForPreTraining,
    VideoMAEForVideoClassification,
    VideoMAEImageProcessor,
)


def 							lowercase_				(    __A :       Any			)       ->      Tuple:



 """simple docstring"""




 lowercase					:   int				  =VideoMAEConfig()

 set_architecture_configs(lowerCAmelCase__					,      lowerCAmelCase__			)

 if "finetuned" not in model_name:
  lowercase					:   List[Any]				  =False

 if "finetuned" in model_name:
  lowercase					:   Union[str, Any]				  ='''huggingface/label-files'''
  if "kinetics" in model_name:
   lowercase					:   str				  =4_0_0
   lowercase					:   Any				  ='''kinetics400-id2label.json'''
  elif "ssv2" in model_name:
   lowercase					:   Union[str, Any]				  =1_7_4
   lowercase					:   Optional[Any]				  ='''something-something-v2-id2label.json'''
  else:
   raise ValueError('''Model name should either contain \'kinetics\' or \'ssv2\' in case it\'s fine-tuned.'''			)
  lowercase					:   Optional[Any]				  =json.load(open(hf_hub_download(lowerCAmelCase__					,      lowerCAmelCase__					,      repo_type='''dataset'''			)					,      '''r'''			)			)
  lowercase					:   Dict				  ={int(lowerCAmelCase__			): v for k, v in idalabel.items()}
  lowercase					:   int				  =idalabel
  lowercase					:   Optional[Any]				  ={v: k for k, v in idalabel.items()}

 return config


def 							lowercase_				(    __A :       str					,      __A :       int			)       ->      Optional[Any]:



 """simple docstring"""




 if "small" in model_name:
  lowercase					:   Dict				  =3_8_4
  lowercase					:   Optional[Any]				  =1_5_3_6
  lowercase					:   Union[str, Any]				  =1_2
  lowercase					:   List[str]				  =1_6
  lowercase					:   Union[str, Any]				  =1_2
  lowercase					:   Tuple				  =3
  lowercase					:   str				  =1_9_2
  lowercase					:   List[str]				  =7_6_8
 elif "large" in model_name:
  lowercase					:   Any				  =1_0_2_4
  lowercase					:   Tuple				  =4_0_9_6
  lowercase					:   List[Any]				  =2_4
  lowercase					:   Tuple				  =1_6
  lowercase					:   int				  =1_2
  lowercase					:   List[Any]				  =8
  lowercase					:   List[Any]				  =5_1_2
  lowercase					:   Optional[Any]				  =2_0_4_8
 elif "huge" in model_name:
  lowercase					:   Any				  =1_2_8_0
  lowercase					:   Union[str, Any]				  =5_1_2_0
  lowercase					:   Dict				  =3_2
  lowercase					:   Optional[int]				  =1_6
  lowercase					:   List[str]				  =1_2
  lowercase					:   Optional[int]				  =8
  lowercase					:   Optional[int]				  =6_4_0
  lowercase					:   Union[str, Any]				  =2_5_6_0
 elif "base" not in model_name:
  raise ValueError('''Model name should include either \"small\", \"base\", \"large\", or \"huge\"'''			)


def 							lowercase_				(    __A :       Optional[Any]			)       ->      Optional[Any]:



 """simple docstring"""




 if "encoder." in name:
  lowercase					:   List[Any]				  =name.replace('''encoder.'''					,      ''''''			)
 if "cls_token" in name:
  lowercase					:   int				  =name.replace('''cls_token'''					,      '''videomae.embeddings.cls_token'''			)
 if "decoder_pos_embed" in name:
  lowercase					:   Union[str, Any]				  =name.replace('''decoder_pos_embed'''					,      '''decoder.decoder_pos_embed'''			)
 if "pos_embed" in name and "decoder" not in name:
  lowercase					:   int				  =name.replace('''pos_embed'''					,      '''videomae.embeddings.position_embeddings'''			)
 if "patch_embed.proj" in name:
  lowercase					:   Any				  =name.replace('''patch_embed.proj'''					,      '''videomae.embeddings.patch_embeddings.projection'''			)
 if "patch_embed.norm" in name:
  lowercase					:   int				  =name.replace('''patch_embed.norm'''					,      '''videomae.embeddings.norm'''			)
 if "decoder.blocks" in name:
  lowercase					:   str				  =name.replace('''decoder.blocks'''					,      '''decoder.decoder_layers'''			)
 if "blocks" in name:
  lowercase					:   Union[str, Any]				  =name.replace('''blocks'''					,      '''videomae.encoder.layer'''			)
 if "attn.proj" in name:
  lowercase					:   Union[str, Any]				  =name.replace('''attn.proj'''					,      '''attention.output.dense'''			)
 if "attn" in name and "bias" not in name:
  lowercase					:   str				  =name.replace('''attn'''					,      '''attention.self'''			)
 if "attn" in name:
  lowercase					:   int				  =name.replace('''attn'''					,      '''attention.attention'''			)
 if "norm1" in name:
  lowercase					:   List[Any]				  =name.replace('''norm1'''					,      '''layernorm_before'''			)
 if "norm2" in name:
  lowercase					:   List[Any]				  =name.replace('''norm2'''					,      '''layernorm_after'''			)
 if "mlp.fc1" in name:
  lowercase					:   int				  =name.replace('''mlp.fc1'''					,      '''intermediate.dense'''			)
 if "mlp.fc2" in name:
  lowercase					:   Optional[Any]				  =name.replace('''mlp.fc2'''					,      '''output.dense'''			)
 if "decoder_embed" in name:
  lowercase					:   Tuple				  =name.replace('''decoder_embed'''					,      '''decoder.decoder_embed'''			)
 if "decoder_norm" in name:
  lowercase					:   Optional[int]				  =name.replace('''decoder_norm'''					,      '''decoder.decoder_norm'''			)
 if "decoder_pred" in name:
  lowercase					:   Tuple				  =name.replace('''decoder_pred'''					,      '''decoder.decoder_pred'''			)
 if "norm.weight" in name and "decoder" not in name and "fc" not in name:
  lowercase					:   int				  =name.replace('''norm.weight'''					,      '''videomae.layernorm.weight'''			)
 if "norm.bias" in name and "decoder" not in name and "fc" not in name:
  lowercase					:   List[str]				  =name.replace('''norm.bias'''					,      '''videomae.layernorm.bias'''			)
 if "head" in name and "decoder" not in name:
  lowercase					:   Tuple				  =name.replace('''head'''					,      '''classifier'''			)

 return name


def 							lowercase_				(    __A :       List[Any]					,      __A :       Tuple			)       ->      int:



 """simple docstring"""




 for key in orig_state_dict.copy().keys():
  lowercase					:   List[Any]				  =orig_state_dict.pop(lowerCAmelCase__			)

  if key.startswith('''encoder.'''			):
   lowercase					:   Optional[Any]				  =key.replace('''encoder.'''					,      ''''''			)

  if "qkv" in key:
   lowercase					:   int				  =key.split('''.'''			)
   if key.startswith('''decoder.blocks'''			):
    lowercase					:   Optional[int]				  =config.decoder_hidden_size
    lowercase					:   List[Any]				  =int(key_split[2]			)
    lowercase					:   Union[str, Any]				  ='''decoder.decoder_layers.'''
    if "weight" in key:
     lowercase					:   Optional[int]				  =val[:dim, :]
     lowercase					:   Optional[Any]				  =val[dim : dim * 2, :]
     lowercase					:   Optional[int]				  =val[-dim:, :]
   else:
    lowercase					:   Tuple				  =config.hidden_size
    lowercase					:   Any				  =int(key_split[1]			)
    lowercase					:   Optional[int]				  ='''videomae.encoder.layer.'''
    if "weight" in key:
     lowercase					:   Optional[Any]				  =val[:dim, :]
     lowercase					:   Tuple				  =val[dim : dim * 2, :]
     lowercase					:   str				  =val[-dim:, :]
  else:
   lowercase					:   int				  =val

 return orig_state_dict


def 							lowercase_				(    )       ->      Tuple:



 """simple docstring"""




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


def 							lowercase_				(    __A :       int					,      __A :       Optional[Any]					,      __A :       Any					,      __A :       Optional[Any]			)       ->      Union[str, Any]:



 """simple docstring"""




 lowercase					:   Tuple				  =get_videomae_config(lowerCAmelCase__			)

 if "finetuned" in model_name:
  lowercase					:   str				  =VideoMAEForVideoClassification(lowerCAmelCase__			)
 else:
  lowercase					:   List[str]				  =VideoMAEForPreTraining(lowerCAmelCase__			)

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

 model.load_state_dict(lowerCAmelCase__			)
 model.eval()

 # verify model on basic input
 lowercase					:   Dict				  =VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]					,      image_std=[0.5, 0.5, 0.5]			)
 lowercase					:   Any				  =prepare_video()
 lowercase					:   int				  =image_processor(lowerCAmelCase__					,      return_tensors='''pt'''			)

 if "finetuned" not in model_name:
  lowercase					:   Dict				  =hf_hub_download(repo_id='''hf-internal-testing/bool-masked-pos'''					,      filename='''bool_masked_pos.pt'''			)
  lowercase					:   Optional[Any]				  =torch.load(lowerCAmelCase__			)

 lowercase					:   Any				  =model(**lowerCAmelCase__			)
 lowercase					:   Union[str, Any]				  =outputs.logits

 lowercase					:   Tuple				  =[
     '''videomae-small-finetuned-kinetics''',
     '''videomae-small-finetuned-ssv2''',
     # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600)
     '''videomae-base-short''',
     '''videomae-base-short-finetuned-kinetics''',
     '''videomae-base''',
     '''videomae-base-finetuned-kinetics''',
     '''videomae-large''',
     '''videomae-large-finetuned-kinetics''',
     '''videomae-huge-finetuned-kinetics''',
     # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400)
     '''videomae-base-short-ssv2''',
     '''videomae-base-short-finetuned-ssv2''',
     '''videomae-base-ssv2''',
     '''videomae-base-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 == "videomae-small-finetuned-kinetics":
  lowercase					:   str				  =torch.Size([1, 4_0_0]			)
  lowercase					:   List[Any]				  =torch.tensor([-0.9291, -0.4061, -0.9307]			)
 elif model_name == "videomae-small-finetuned-ssv2":
  lowercase					:   str				  =torch.Size([1, 1_7_4]			)
  lowercase					:   Union[str, Any]				  =torch.tensor([0.2671, -0.4689, -0.8235]			)
 elif model_name == "videomae-base":
  lowercase					:   Tuple				  =torch.Size([1, 1_4_0_8, 1_5_3_6]			)
  lowercase					:   Optional[Any]				  =torch.tensor([[0.7739, 0.7968, 0.7089], [0.6701, 0.7487, 0.6209], [0.4287, 0.5158, 0.4773]]			)
 elif model_name == "videomae-base-short":
  lowercase					:   Tuple				  =torch.Size([1, 1_4_0_8, 1_5_3_6]			)
  lowercase					:   Any				  =torch.tensor([[0.7994, 0.9612, 0.8508], [0.7401, 0.8958, 0.8302], [0.5862, 0.7468, 0.7325]]			)
  # we verified the loss both for normalized and unnormalized targets for this one
  lowercase					:   List[str]				  =torch.tensor([0.5142]			) if config.norm_pix_loss else torch.tensor([0.6469]			)
 elif model_name == "videomae-large":
  lowercase					:   Dict				  =torch.Size([1, 1_4_0_8, 1_5_3_6]			)
  lowercase					:   Dict				  =torch.tensor([[0.7149, 0.7997, 0.6966], [0.6768, 0.7869, 0.6948], [0.5139, 0.6221, 0.5605]]			)
 elif model_name == "videomae-large-finetuned-kinetics":
  lowercase					:   int				  =torch.Size([1, 4_0_0]			)
  lowercase					:   str				  =torch.tensor([0.0771, 0.0011, -0.3625]			)
 elif model_name == "videomae-huge-finetuned-kinetics":
  lowercase					:   List[Any]				  =torch.Size([1, 4_0_0]			)
  lowercase					:   Tuple				  =torch.tensor([0.2433, 0.1632, -0.4894]			)
 elif model_name == "videomae-base-short-finetuned-kinetics":
  lowercase					:   Union[str, Any]				  =torch.Size([1, 4_0_0]			)
  lowercase					:   Optional[Any]				  =torch.tensor([0.6588, 0.0990, -0.2493]			)
 elif model_name == "videomae-base-finetuned-kinetics":
  lowercase					:   List[Any]				  =torch.Size([1, 4_0_0]			)
  lowercase					:   List[str]				  =torch.tensor([0.3669, -0.0688, -0.2421]			)
 elif model_name == "videomae-base-short-ssv2":
  lowercase					:   Optional[int]				  =torch.Size([1, 1_4_0_8, 1_5_3_6]			)
  lowercase					:   str				  =torch.tensor([[0.4712, 0.5296, 0.5786], [0.2278, 0.2729, 0.4026], [0.0352, 0.0730, 0.2506]]			)
 elif model_name == "videomae-base-short-finetuned-ssv2":
  lowercase					:   Tuple				  =torch.Size([1, 1_7_4]			)
  lowercase					:   str				  =torch.tensor([-0.0537, -0.1539, -0.3266]			)
 elif model_name == "videomae-base-ssv2":
  lowercase					:   List[Any]				  =torch.Size([1, 1_4_0_8, 1_5_3_6]			)
  lowercase					:   Optional[Any]				  =torch.tensor([[0.8131, 0.8727, 0.8546], [0.7366, 0.9377, 0.8870], [0.5935, 0.8874, 0.8564]]			)
 elif model_name == "videomae-base-finetuned-ssv2":
  lowercase					:   Any				  =torch.Size([1, 1_7_4]			)
  lowercase					:   List[Any]				  =torch.tensor([0.1961, -0.8337, -0.6389]			)
 else:
  raise ValueError(F'Model name not supported. Should be one of {model_names}'			)

 # verify logits
 assert logits.shape == expected_shape
 if "finetuned" in model_name:
  assert torch.allclose(logits[0, :3]					,      lowerCAmelCase__					,      atol=1E-4			)
 else:
  print('''Logits:'''					,      logits[0, :3, :3]			)
  assert torch.allclose(logits[0, :3, :3]					,      lowerCAmelCase__					,      atol=1E-4			)
 print('''Logits ok!'''			)

 # verify loss, if applicable
 if model_name == "videomae-base-short":
  lowercase					:   Optional[int]				  =outputs.loss
  assert torch.allclose(lowerCAmelCase__					,      lowerCAmelCase__					,      atol=1E-4			)
  print('''Loss 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(lowerCAmelCase__					,      organization='''nielsr'''			)


if __name__ == "__main__":
      SCREAMING_SNAKE_CASE						=				argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '--checkpoint_url',
          default='https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4',
          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='/Users/nielsrogge/Documents/VideoMAE/Test',
          type=str,
          help='Path to the output PyTorch model directory.',
      )
      parser.add_argument('--model_name', default='videomae-base', 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						=				parser.parse_args()
      convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)











'''simple docstring'''



import mpmath  # for roots of unity
import numpy as np
class UpperCAmelCase_					:




      """simple docstring"""




      def __init__( self			:		List[Any]     ,      UpperCAmelCase			:		Dict=None     ,      UpperCAmelCase			:		Optional[int]=None		)  ->  Optional[Any]:


       '''simple docstring'''

       lowercase					:   Any				  =list(poly_a or [0]		)[:]
       lowercase					:   Dict				  =list(poly_b or [0]		)[:]

       # Remove leading zero coefficients
       while self.polyA[-1] == 0:
        self.polyA.pop()
       lowercase					:   int				  =len(self.polyA		)

       while self.polyB[-1] == 0:
        self.polyB.pop()
       lowercase					:   List[str]				  =len(self.polyB		)

       # Add 0 to make lengths equal a power of 2
       lowercase					:   Tuple				  =int(
           2 ** np.ceil(np.loga(len(self.polyA		) + len(self.polyB		) - 1		)		)		)

       while len(self.polyA		) < self.c_max_length:
        self.polyA.append(0		)
       while len(self.polyB		) < self.c_max_length:
        self.polyB.append(0		)
       # A complex root used for the fourier transform
       lowercase					:   Optional[int]				  =complex(mpmath.root(x=1     ,      n=self.c_max_length     ,      k=1		)		)

       # The product
       lowercase					:   str				  =self.__multiply()






      def 				A__      ( self			:		Optional[Any]     ,      UpperCAmelCase			:		Union[str, Any]		)  ->  Tuple:


       '''simple docstring'''

       lowercase					:   Tuple				  =[[x] for x in self.polyA] if which == '''A''' else [[x] for x in self.polyB]
       # Corner case
       if len(UpperCAmelCase		) <= 1:
        return dft[0]
       #
       lowercase					:   List[Any]				  =self.c_max_length // 2
       while next_ncol > 0:
        lowercase					:   str				  =[[] for i in range(UpperCAmelCase		)]
        lowercase					:   List[str]				  =self.root**next_ncol

        # First half of next step
        lowercase					:   Union[str, Any]				  =1
        for j in range(self.c_max_length // (next_ncol * 2)		):
         for i in range(UpperCAmelCase		):
          new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j]		)
         current_root *= root
        # Second half of next step
        lowercase					:   Any				  =1
        for j in range(self.c_max_length // (next_ncol * 2)		):
         for i in range(UpperCAmelCase		):
          new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j]		)
         current_root *= root
        # Update
        lowercase					:   Tuple				  =new_dft
        lowercase					:   List[Any]				  =next_ncol // 2
       return dft[0]






      def 				A__      ( self			:		int		)  ->  str:


       '''simple docstring'''

       lowercase					:   List[Any]				  =self.__dft('''A'''		)
       lowercase					:   Union[str, Any]				  =self.__dft('''B'''		)
       lowercase					:   Any				  =[[dft_a[i] * dft_b[i] for i in range(self.c_max_length		)]]
       del dft_a
       del dft_b

       # Corner Case
       if len(inverce_c[0]		) <= 1:
        return inverce_c[0]
       # Inverse DFT
       lowercase					:   Tuple				  =2
       while next_ncol <= self.c_max_length:
        lowercase					:   Tuple				  =[[] for i in range(UpperCAmelCase		)]
        lowercase					:   Tuple				  =self.root ** (next_ncol // 2)
        lowercase					:   Optional[int]				  =1
        # First half of next step
        for j in range(self.c_max_length // next_ncol		):
         for i in range(next_ncol // 2		):
          # Even positions
          new_inverse_c[i].append(
              (
                  inverce_c[i][j]
                  + inverce_c[i][j + self.c_max_length // next_ncol]
              )
              / 2		)
          # Odd positions
          new_inverse_c[i + next_ncol // 2].append(
              (
                  inverce_c[i][j]
                  - inverce_c[i][j + self.c_max_length // next_ncol]
              )
              / (2 * current_root)		)
         current_root *= root
        # Update
        lowercase					:   List[Any]				  =new_inverse_c
        next_ncol *= 2
       # Unpack
       lowercase					:   List[str]				  =[round(x[0].real     ,      8		) + round(x[0].imag     ,      8		) * 1J for x in inverce_c]

       # Remove leading 0's
       while inverce_c[-1] == 0:
        inverce_c.pop()
       return inverce_c






      def __str__( self			:		Dict		)  ->  Optional[Any]:


       '''simple docstring'''

       lowercase					:   Optional[Any]				  ='''A = ''' + ''' + '''.join(
           f'{coef}*x^{i}' for coef, i in enumerate(self.polyA[: self.len_A]		)		)
       lowercase					:   List[str]				  ='''B = ''' + ''' + '''.join(
           f'{coef}*x^{i}' for coef, i in enumerate(self.polyB[: self.len_B]		)		)
       lowercase					:   Optional[Any]				  ='''A*B = ''' + ''' + '''.join(
           f'{coef}*x^{i}' for coef, i in enumerate(self.product		)		)

       return f'{a}\n{b}\n{c}'


# Unit tests
if __name__ == "__main__":
      import doctest

      doctest.testmod()



