





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 				lowerCAmelCase_ (							A_):
    UpperCamelCase__:	int					=     VideoMAEConfig()

    set_architecture_configs(A_    ,A_)

    if "finetuned" not in model_name:
        UpperCamelCase__:	List[str]					=     False

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

    return config



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



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

    return name



def 				lowerCAmelCase_ (							A_    ,A_):
    for key in orig_state_dict.copy().keys():
        UpperCamelCase__:	Dict					=     orig_state_dict.pop(A_)

        if key.startswith("encoder."):
            UpperCamelCase__:	int					=     key.replace("encoder."    ,"")

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

    return orig_state_dict



def 				lowerCAmelCase_ (							):
    UpperCamelCase__:	List[str]					=     hf_hub_download(
        repo_id="hf-internal-testing/spaghetti-video"    ,filename="eating_spaghetti.npy"    ,repo_type="dataset")
    UpperCamelCase__:	List[str]					=     np.load(A_)
    return list(A_)



def 				lowerCAmelCase_ (							A_    ,A_    ,A_    ,A_):
    UpperCamelCase__:	List[Any]					=     get_videomae_config(A_)

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

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

    model.load_state_dict(A_)
    model.eval()

    # verify model on basic input
    UpperCamelCase__:	Optional[Any]					=     VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]    ,image_std=[0.5, 0.5, 0.5])
    UpperCamelCase__:	int					=     prepare_video()
    UpperCamelCase__:	Dict					=     image_processor(A_    ,return_tensors="pt")

    if "finetuned" not in model_name:
        UpperCamelCase__:	int					=     hf_hub_download(repo_id="hf-internal-testing/bool-masked-pos"    ,filename="bool_masked_pos.pt")
        UpperCamelCase__:	Tuple					=     torch.load(A_)

    UpperCamelCase__:	Optional[Any]					=     model(**A_)
    UpperCamelCase__:	List[str]					=     outputs.logits

    UpperCamelCase__:	Any					=     [
        "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":
        UpperCamelCase__:	List[Any]					=     torch.Size([1, 4_00])
        UpperCamelCase__:	Any					=     torch.tensor([-0.9291, -0.4061, -0.9307])
    elif model_name == "videomae-small-finetuned-ssv2":
        UpperCamelCase__:	List[Any]					=     torch.Size([1, 1_74])
        UpperCamelCase__:	Dict					=     torch.tensor([0.2671, -0.4689, -0.8235])
    elif model_name == "videomae-base":
        UpperCamelCase__:	Dict					=     torch.Size([1, 14_08, 15_36])
        UpperCamelCase__:	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":
        UpperCamelCase__:	str					=     torch.Size([1, 14_08, 15_36])
        UpperCamelCase__:	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
        UpperCamelCase__:	Any					=     torch.tensor([0.5142]) if config.norm_pix_loss else torch.tensor([0.6469])
    elif model_name == "videomae-large":
        UpperCamelCase__:	List[str]					=     torch.Size([1, 14_08, 15_36])
        UpperCamelCase__:	Union[str, Any]					=     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":
        UpperCamelCase__:	List[Any]					=     torch.Size([1, 4_00])
        UpperCamelCase__:	Tuple					=     torch.tensor([0.0771, 0.0011, -0.3625])
    elif model_name == "videomae-huge-finetuned-kinetics":
        UpperCamelCase__:	List[Any]					=     torch.Size([1, 4_00])
        UpperCamelCase__:	Union[str, Any]					=     torch.tensor([0.2433, 0.1632, -0.4894])
    elif model_name == "videomae-base-short-finetuned-kinetics":
        UpperCamelCase__:	str					=     torch.Size([1, 4_00])
        UpperCamelCase__:	Union[str, Any]					=     torch.tensor([0.6588, 0.0990, -0.2493])
    elif model_name == "videomae-base-finetuned-kinetics":
        UpperCamelCase__:	Any					=     torch.Size([1, 4_00])
        UpperCamelCase__:	List[str]					=     torch.tensor([0.3669, -0.0688, -0.2421])
    elif model_name == "videomae-base-short-ssv2":
        UpperCamelCase__:	List[str]					=     torch.Size([1, 14_08, 15_36])
        UpperCamelCase__:	Tuple					=     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":
        UpperCamelCase__:	Tuple					=     torch.Size([1, 1_74])
        UpperCamelCase__:	Optional[int]					=     torch.tensor([-0.0537, -0.1539, -0.3266])
    elif model_name == "videomae-base-ssv2":
        UpperCamelCase__:	Dict					=     torch.Size([1, 14_08, 15_36])
        UpperCamelCase__:	List[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":
        UpperCamelCase__:	List[str]					=     torch.Size([1, 1_74])
        UpperCamelCase__:	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]    ,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":
        UpperCamelCase__:	int					=     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__:    Union[str, Any]  	=	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__:    Dict  	=	parser.parse_args()
   convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)








import unittest

from knapsack import knapsack as k




class        _a    (    unittest.TestCase):

      """simple docstring"""


      def 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          UpperCamelCase__:	Tuple					=     0
          UpperCamelCase__:	Optional[int]					=     [0]
          UpperCamelCase__:	Dict					=     [0]
          UpperCamelCase__:	str					=     len(__lowerCamelCase					)
          self.assertEqual(k.knapsack(__lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase					)	,    0					)

          UpperCamelCase__:	Tuple					=     [60]
          UpperCamelCase__:	List[Any]					=     [10]
          UpperCamelCase__:	Any					=     len(__lowerCamelCase					)
          self.assertEqual(k.knapsack(__lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase					)	,    0					)






      def 			UpperCAmelCase_       (		self:			Any					):
          '''simple docstring'''


          UpperCamelCase__:	List[str]					=     3
          UpperCamelCase__:	Any					=     [1, 2, 3]
          UpperCamelCase__:	Dict					=     [3, 2, 1]
          UpperCamelCase__:	List[str]					=     len(__lowerCamelCase					)
          self.assertEqual(k.knapsack(__lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase					)	,    5					)






      def 			UpperCAmelCase_       (		self:			List[Any]					):
          '''simple docstring'''


          UpperCamelCase__:	List[str]					=     50
          UpperCamelCase__:	Optional[Any]					=     [60, 100, 120]
          UpperCamelCase__:	Optional[Any]					=     [10, 20, 30]
          UpperCamelCase__:	Any					=     len(__lowerCamelCase					)
          self.assertEqual(k.knapsack(__lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase					)	,    220					)


if __name__ == "__main__":
   unittest.main()

