

'''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 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		str       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						VideoMAEConfig()

    set_architecture_configs(lowerCAmelCase__ ,   lowerCAmelCase__       )

    if "finetuned" not in model_name:
        SCREAMING_SNAKE_CASE_									=						False

    if "finetuned" in model_name:
        SCREAMING_SNAKE_CASE_									=						'huggingface/label-files'
        if "kinetics" in model_name:
            SCREAMING_SNAKE_CASE_									=						400
            SCREAMING_SNAKE_CASE_									=						'kinetics400-id2label.json'
        elif "ssv2" in model_name:
            SCREAMING_SNAKE_CASE_									=						174
            SCREAMING_SNAKE_CASE_									=						'something-something-v2-id2label.json'
        else:
            raise ValueError('Model name should either contain \'kinetics\' or \'ssv2\' in case it\'s fine-tuned.'       )
        SCREAMING_SNAKE_CASE_									=						json.load(open(hf_hub_download(lowerCAmelCase__ ,   lowerCAmelCase__ ,   repo_type='dataset'       ) ,   'r'       )       )
        SCREAMING_SNAKE_CASE_									=						{int(lowerCAmelCase__       ): v for k, v in idalabel.items()}
        SCREAMING_SNAKE_CASE_									=						idalabel
        SCREAMING_SNAKE_CASE_									=						{v: k for k, v in idalabel.items()}

    return config


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Union[str, Any] ,   _SCREAMING_SNAKE_CASE					:		Optional[Any]       ):





    """simple docstring"""


    if "small" in model_name:
        SCREAMING_SNAKE_CASE_									=						384
        SCREAMING_SNAKE_CASE_									=						1_536
        SCREAMING_SNAKE_CASE_									=						12
        SCREAMING_SNAKE_CASE_									=						16
        SCREAMING_SNAKE_CASE_									=						12
        SCREAMING_SNAKE_CASE_									=						3
        SCREAMING_SNAKE_CASE_									=						192
        SCREAMING_SNAKE_CASE_									=						768
    elif "large" in model_name:
        SCREAMING_SNAKE_CASE_									=						1_024
        SCREAMING_SNAKE_CASE_									=						4_096
        SCREAMING_SNAKE_CASE_									=						24
        SCREAMING_SNAKE_CASE_									=						16
        SCREAMING_SNAKE_CASE_									=						12
        SCREAMING_SNAKE_CASE_									=						8
        SCREAMING_SNAKE_CASE_									=						512
        SCREAMING_SNAKE_CASE_									=						2_048
    elif "huge" in model_name:
        SCREAMING_SNAKE_CASE_									=						1_280
        SCREAMING_SNAKE_CASE_									=						5_120
        SCREAMING_SNAKE_CASE_									=						32
        SCREAMING_SNAKE_CASE_									=						16
        SCREAMING_SNAKE_CASE_									=						12
        SCREAMING_SNAKE_CASE_									=						8
        SCREAMING_SNAKE_CASE_									=						640
        SCREAMING_SNAKE_CASE_									=						2_560
    elif "base" not in model_name:
        raise ValueError('Model name should include either \"small\", \"base\", \"large\", or \"huge\"'       )


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Optional[int]       ):





    """simple docstring"""


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

    return name


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Optional[int] ,   _SCREAMING_SNAKE_CASE					:		Optional[Any]       ):





    """simple docstring"""


    for key in orig_state_dict.copy().keys():
        SCREAMING_SNAKE_CASE_									=						orig_state_dict.pop(lowerCAmelCase__       )

        if key.startswith('encoder.'       ):
            SCREAMING_SNAKE_CASE_									=						key.replace('encoder.' ,   ''       )

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

    return orig_state_dict


def 					_UpperCAmelCase       (  ):





    """simple docstring"""


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


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Dict ,   _SCREAMING_SNAKE_CASE					:		Any ,   _SCREAMING_SNAKE_CASE					:		Any ,   _SCREAMING_SNAKE_CASE					:		int       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						get_videomae_config(lowerCAmelCase__       )

    if "finetuned" in model_name:
        SCREAMING_SNAKE_CASE_									=						VideoMAEForVideoClassification(lowerCAmelCase__       )
    else:
        SCREAMING_SNAKE_CASE_									=						VideoMAEForPreTraining(lowerCAmelCase__       )

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

    model.load_state_dict(lowerCAmelCase__       )
    model.eval()

    # verify model on basic input
    SCREAMING_SNAKE_CASE_									=						VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] ,   image_std=[0.5, 0.5, 0.5]       )
    SCREAMING_SNAKE_CASE_									=						prepare_video()
    SCREAMING_SNAKE_CASE_									=						image_processor(lowerCAmelCase__ ,   return_tensors='pt'       )

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

    SCREAMING_SNAKE_CASE_									=						model(**lowerCAmelCase__       )
    SCREAMING_SNAKE_CASE_									=						outputs.logits

    SCREAMING_SNAKE_CASE_									=						[
        '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":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 400]       )
        SCREAMING_SNAKE_CASE_									=						torch.tensor([-0.9291, -0.4061, -0.9307]       )
    elif model_name == "videomae-small-finetuned-ssv2":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 174]       )
        SCREAMING_SNAKE_CASE_									=						torch.tensor([0.2671, -0.4689, -0.8235]       )
    elif model_name == "videomae-base":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 1_408, 1_536]       )
        SCREAMING_SNAKE_CASE_									=						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":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 1_408, 1_536]       )
        SCREAMING_SNAKE_CASE_									=						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
        SCREAMING_SNAKE_CASE_									=						torch.tensor([0.5142]       ) if config.norm_pix_loss else torch.tensor([0.6469]       )
    elif model_name == "videomae-large":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 1_408, 1_536]       )
        SCREAMING_SNAKE_CASE_									=						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":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 400]       )
        SCREAMING_SNAKE_CASE_									=						torch.tensor([0.0771, 0.0011, -0.3625]       )
    elif model_name == "videomae-huge-finetuned-kinetics":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 400]       )
        SCREAMING_SNAKE_CASE_									=						torch.tensor([0.2433, 0.1632, -0.4894]       )
    elif model_name == "videomae-base-short-finetuned-kinetics":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 400]       )
        SCREAMING_SNAKE_CASE_									=						torch.tensor([0.6588, 0.0990, -0.2493]       )
    elif model_name == "videomae-base-finetuned-kinetics":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 400]       )
        SCREAMING_SNAKE_CASE_									=						torch.tensor([0.3669, -0.0688, -0.2421]       )
    elif model_name == "videomae-base-short-ssv2":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 1_408, 1_536]       )
        SCREAMING_SNAKE_CASE_									=						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":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 174]       )
        SCREAMING_SNAKE_CASE_									=						torch.tensor([-0.0537, -0.1539, -0.3266]       )
    elif model_name == "videomae-base-ssv2":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 1_408, 1_536]       )
        SCREAMING_SNAKE_CASE_									=						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":
        SCREAMING_SNAKE_CASE_									=						torch.Size([1, 174]       )
        SCREAMING_SNAKE_CASE_									=						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":
        SCREAMING_SNAKE_CASE_									=						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__":
       UpperCamelCase__  :      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."
       )

       UpperCamelCase__  :      Union[str, Any]			=    parser.parse_args()
       convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)





def 					_UpperCAmelCase       (  ):





    """simple docstring"""


    for n in range(1 ,   1_000_000       ):
        yield n * (n + 1) // 2


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Tuple       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						1
    SCREAMING_SNAKE_CASE_									=						2
    while i * i <= n:
        SCREAMING_SNAKE_CASE_									=						0
        while n % i == 0:
            n //= i
            multiplicity += 1
        divisors_count *= multiplicity + 1
        i += 1
    if n > 1:
        divisors_count *= 2
    return divisors_count


def 					_UpperCAmelCase       (  ):





    """simple docstring"""


    return next(i for i in triangle_number_generator() if count_divisors(_SCREAMING_SNAKE_CASE       ) > 500       )


if __name__ == "__main__":
       print(solution())


