






'''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        _SCREAMING_SNAKE_CASE  (				A  :       List[str]  )    -> Tuple:







   """simple docstring"""
   __snake_case				:      Any     							= VideoMAEConfig()

   set_architecture_configs(A  ,		A  )

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

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

   return config




def        _SCREAMING_SNAKE_CASE  (				A  :       List[Any]  ,		A  :       Optional[Any]  )    -> Optional[int]:







   """simple docstring"""
   if "small" in model_name:
      __snake_case				:      Optional[int]     							= 3_84
      __snake_case				:      Optional[int]     							= 15_36
      __snake_case				:      List[Any]     							= 12
      __snake_case				:      Dict     							= 16
      __snake_case				:      List[Any]     							= 12
      __snake_case				:      int     							= 3
      __snake_case				:      Union[str, Any]     							= 1_92
      __snake_case				:      Union[str, Any]     							= 7_68
   elif "large" in model_name:
      __snake_case				:      Optional[Any]     							= 10_24
      __snake_case				:      Union[str, Any]     							= 40_96
      __snake_case				:      str     							= 24
      __snake_case				:      Union[str, Any]     							= 16
      __snake_case				:      List[Any]     							= 12
      __snake_case				:      Dict     							= 8
      __snake_case				:      Dict     							= 5_12
      __snake_case				:      Dict     							= 20_48
   elif "huge" in model_name:
      __snake_case				:      int     							= 12_80
      __snake_case				:      List[Any]     							= 51_20
      __snake_case				:      Any     							= 32
      __snake_case				:      Dict     							= 16
      __snake_case				:      Optional[int]     							= 12
      __snake_case				:      int     							= 8
      __snake_case				:      List[str]     							= 6_40
      __snake_case				:      List[Any]     							= 25_60
   elif "base" not in model_name:
      raise ValueError('Model name should include either "small", "base", "large", or "huge"'  )




def        _SCREAMING_SNAKE_CASE  (				A  :       List[str]  )    -> List[str]:







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

   return name




def        _SCREAMING_SNAKE_CASE  (				A  :       List[str]  ,		A  :       Optional[int]  )    -> Optional[Any]:







   """simple docstring"""
   for key in orig_state_dict.copy().keys():
      __snake_case				:      Dict     							= orig_state_dict.pop(A  )

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

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

   return orig_state_dict




def        _SCREAMING_SNAKE_CASE  (				)    -> Union[str, Any]:







   """simple docstring"""
   __snake_case				:      List[str]     							= hf_hub_download(
       repo_id='hf-internal-testing/spaghetti-video'  ,		filename='eating_spaghetti.npy'  ,		repo_type='dataset'  )
   __snake_case				:      Dict     							= np.load(A  )
   return list(A  )




def        _SCREAMING_SNAKE_CASE  (				A  :       Union[str, Any]  ,		A  :       List[Any]  ,		A  :       Dict  ,		A  :       List[Any]  )    -> int:







   """simple docstring"""
   __snake_case				:      str     							= get_videomae_config(A  )

   if "finetuned" in model_name:
      __snake_case				:      List[Any]     							= VideoMAEForVideoClassification(A  )
   else:
      __snake_case				:      Any     							= VideoMAEForPreTraining(A  )

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

   model.load_state_dict(A  )
   model.eval()

   # verify model on basic input
   __snake_case				:      List[str]     							= VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]  ,		image_std=[0.5, 0.5, 0.5]  )
   __snake_case				:      Union[str, Any]     							= prepare_video()
   __snake_case				:      Optional[Any]     							= image_processor(A  ,		return_tensors='pt'  )

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

   __snake_case				:      Optional[Any]     							= model(**A  )
   __snake_case				:      List[str]     							= outputs.logits

   __snake_case				:      Optional[int]     							= [
       '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":
      __snake_case				:      Dict     							= torch.Size([1, 4_00]  )
      __snake_case				:      List[Any]     							= torch.tensor([-0.9291, -0.4061, -0.9307]  )
   elif model_name == "videomae-small-finetuned-ssv2":
      __snake_case				:      Optional[Any]     							= torch.Size([1, 1_74]  )
      __snake_case				:      Tuple     							= torch.tensor([0.2671, -0.4689, -0.8235]  )
   elif model_name == "videomae-base":
      __snake_case				:      List[str]     							= torch.Size([1, 14_08, 15_36]  )
      __snake_case				:      Optional[int]     							= 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":
      __snake_case				:      Optional[Any]     							= torch.Size([1, 14_08, 15_36]  )
      __snake_case				:      str     							= 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
      __snake_case				:      List[str]     							= torch.tensor([0.5142]  ) if config.norm_pix_loss else torch.tensor([0.6469]  )
   elif model_name == "videomae-large":
      __snake_case				:      List[str]     							= torch.Size([1, 14_08, 15_36]  )
      __snake_case				:      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":
      __snake_case				:      Optional[Any]     							= torch.Size([1, 4_00]  )
      __snake_case				:      Optional[Any]     							= torch.tensor([0.0771, 0.0011, -0.3625]  )
   elif model_name == "videomae-huge-finetuned-kinetics":
      __snake_case				:      int     							= torch.Size([1, 4_00]  )
      __snake_case				:      Optional[Any]     							= torch.tensor([0.2433, 0.1632, -0.4894]  )
   elif model_name == "videomae-base-short-finetuned-kinetics":
      __snake_case				:      Tuple     							= torch.Size([1, 4_00]  )
      __snake_case				:      Optional[Any]     							= torch.tensor([0.6588, 0.0990, -0.2493]  )
   elif model_name == "videomae-base-finetuned-kinetics":
      __snake_case				:      Optional[Any]     							= torch.Size([1, 4_00]  )
      __snake_case				:      int     							= torch.tensor([0.3669, -0.0688, -0.2421]  )
   elif model_name == "videomae-base-short-ssv2":
      __snake_case				:      Tuple     							= torch.Size([1, 14_08, 15_36]  )
      __snake_case				:      Dict     							= 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":
      __snake_case				:      Dict     							= torch.Size([1, 1_74]  )
      __snake_case				:      Tuple     							= torch.tensor([-0.0537, -0.1539, -0.3266]  )
   elif model_name == "videomae-base-ssv2":
      __snake_case				:      List[Any]     							= torch.Size([1, 14_08, 15_36]  )
      __snake_case				:      str     							= 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":
      __snake_case				:      Optional[int]     							= torch.Size([1, 1_74]  )
      __snake_case				:      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]  ,		A  ,		atol=1e-4  )
   else:
      print('Logits:'  ,		logits[0, :3, :3]  )
      assert torch.allclose(logits[0, :3, :3]  ,		A  ,		atol=1e-4  )
   print('Logits ok!'  )

   # verify loss, if applicable
   if model_name == "videomae-base-short":
      __snake_case				:      Dict     							= outputs.loss
      assert torch.allclose(A  ,		A  ,		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(A  )
      model.save_pretrained(A  )

   if push_to_hub:
      print('Pushing to the hub...'  )
      model.push_to_hub(A  ,		organization='nielsr'  )


if __name__ == "__main__":
      __A    	=   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.'''
      )

      __A    	=   parser.parse_args()
      convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)







'''simple docstring'''






from __future__ import annotations

from collections import deque
from collections.abc import Sequence
from dataclasses import dataclass
from typing import Any




@dataclass
class a_    :
   _snake_case        =							42
   _snake_case        =							None
   _snake_case        =							None




def        _SCREAMING_SNAKE_CASE  (				)    -> Node | None:







   """simple docstring"""
   __snake_case				:      str     							= Node(1  )
   __snake_case				:      Tuple     							= Node(2  )
   __snake_case				:      Optional[int]     							= Node(3  )
   __snake_case				:      List[str]     							= Node(4  )
   __snake_case				:      List[str]     							= Node(5  )
   return tree




def        _SCREAMING_SNAKE_CASE  (				A  :       Node | None  )    -> list[int]:







   """simple docstring"""
   return [root.data, *preorder(root.left  ), *preorder(root.right  )] if root else []




def        _SCREAMING_SNAKE_CASE  (				A  :       Node | None  )    -> list[int]:







   """simple docstring"""
   return postorder(root.left  ) + postorder(root.right  ) + [root.data] if root else []




def        _SCREAMING_SNAKE_CASE  (				A  :       Node | None  )    -> list[int]:







   """simple docstring"""
   return [*inorder(root.left  ), root.data, *inorder(root.right  )] if root else []




def        _SCREAMING_SNAKE_CASE  (				A  :       Node | None  )    -> int:







   """simple docstring"""
   return (max(height(root.left  )  ,		height(root.right  )  ) + 1) if root else 0




def        _SCREAMING_SNAKE_CASE  (				A  :       Node | None  )    -> Sequence[Node | None]:







   """simple docstring"""
   __snake_case				:      list[Any]     							= []

   if root is None:
      return output

   __snake_case				:      Optional[int]     							= deque([root]  )

   while process_queue:
      __snake_case				:      List[str]     							= process_queue.popleft()
      output.append(node.data  )

      if node.left:
         process_queue.append(node.left  )
      if node.right:
         process_queue.append(node.right  )
   return output




def        _SCREAMING_SNAKE_CASE  (				A  :       Node | None  ,		A  :       int  )    -> Sequence[Node | None]:







   """simple docstring"""
   __snake_case				:      list[Any]     							= []

   def populate_output(A  :       Node | None  ,		A  :       int  ) -> None:
      if not root:
         return
      if level == 1:
         output.append(root.data  )
      elif level > 1:
         populate_output(root.left  ,		level - 1  )
         populate_output(root.right  ,		level - 1  )

   populate_output(A  ,		A  )
   return output




def        _SCREAMING_SNAKE_CASE  (				A  :       Node | None  ,		A  :       int  )    -> Sequence[Node | None]:







   """simple docstring"""
   __snake_case				:      list[Any]     							= []

   def populate_output(A  :       Node | None  ,		A  :       int  ) -> None:
      if root is None:
         return
      if level == 1:
         output.append(root.data  )
      elif level > 1:
         populate_output(root.right  ,		level - 1  )
         populate_output(root.left  ,		level - 1  )

   populate_output(A  ,		A  )
   return output




def        _SCREAMING_SNAKE_CASE  (				A  :       Node | None  )    -> Sequence[Node | None] | list[Any]:







   """simple docstring"""
   if root is None:
      return []

   __snake_case				:      list[Sequence[Node | None]]     							= []

   __snake_case				:      List[Any]     							= 0
   __snake_case				:      int     							= height(A  )

   for h in range(1  ,		height_tree + 1  ):
      if not flag:
         output.append(get_nodes_from_left_to_right(A  ,		A  )  )
         __snake_case				:      int     							= 1
      else:
         output.append(get_nodes_from_right_to_left(A  ,		A  )  )
         __snake_case				:      Tuple     							= 0

   return output




def        _SCREAMING_SNAKE_CASE  (				)    -> None:  # Main function for testing.







   """simple docstring"""
   __snake_case				:      Optional[int]     							= make_tree()
   print(F"""In-order Traversal: {inorder(A  )}"""  )
   print(F"""Pre-order Traversal: {preorder(A  )}"""  )
   print(F"""Post-order Traversal: {postorder(A  )}"""  ,		'\n'  )

   print(F"""Height of Tree: {height(A  )}"""  ,		'\n'  )

   print('Complete Level Order Traversal: '  )
   print(level_order(A  )  ,		'\n'  )

   print('Level-wise order Traversal: '  )

   for level in range(1  ,		height(A  ) + 1  ):
      print(F"""Level {level}:"""  ,		get_nodes_from_left_to_right(A  ,		level=A  )  )

   print('\nZigZag order Traversal: '  )
   print(zigzag(A  )  )


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      main()