



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      __snake_case	(			_UpperCAmelCase				):
    __a						       =				VideoMAEConfig()

    set_architecture_configs(_UpperCAmelCase   , _UpperCAmelCase				)

    if "finetuned" not in model_name:
        __a						       =				False

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

    return config





def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase				):
    if "small" in model_name:
        __a						       =				384
        __a						       =				1536
        __a						       =				12
        __a						       =				16
        __a						       =				12
        __a						       =				3
        __a						       =				192
        __a						       =				768
    elif "large" in model_name:
        __a						       =				1024
        __a						       =				4096
        __a						       =				24
        __a						       =				16
        __a						       =				12
        __a						       =				8
        __a						       =				512
        __a						       =				2048
    elif "huge" in model_name:
        __a						       =				1280
        __a						       =				5120
        __a						       =				32
        __a						       =				16
        __a						       =				12
        __a						       =				8
        __a						       =				640
        __a						       =				2560
    elif "base" not in model_name:
        raise ValueError('''Model name should include either "small", "base", "large", or "huge"'''				)





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

    return name





def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase				):
    for key in orig_state_dict.copy().keys():
        __a						       =				orig_state_dict.pop(_UpperCAmelCase				)

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

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

    return orig_state_dict





def      __snake_case	(			):
    __a						       =				hf_hub_download(
        repo_id='''hf-internal-testing/spaghetti-video'''   , filename='''eating_spaghetti.npy'''   , repo_type='''dataset'''				)
    __a						       =				np.load(_UpperCAmelCase				)
    return list(_UpperCAmelCase				)





def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase				):
    __a						       =				get_videomae_config(_UpperCAmelCase				)

    if "finetuned" in model_name:
        __a						       =				VideoMAEForVideoClassification(_UpperCAmelCase				)
    else:
        __a						       =				VideoMAEForPreTraining(_UpperCAmelCase				)

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

    model.load_state_dict(_UpperCAmelCase				)
    model.eval()

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

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

    __a						       =				model(**_UpperCAmelCase				)
    __a						       =				outputs.logits

    __a						       =				[
        '''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":
        __a						       =				torch.Size([1, 400]				)
        __a						       =				torch.tensor([-0.92_91, -0.40_61, -0.93_07]				)
    elif model_name == "videomae-small-finetuned-ssv2":
        __a						       =				torch.Size([1, 174]				)
        __a						       =				torch.tensor([0.26_71, -0.46_89, -0.82_35]				)
    elif model_name == "videomae-base":
        __a						       =				torch.Size([1, 1408, 1536]				)
        __a						       =				torch.tensor([[0.77_39, 0.79_68, 0.70_89], [0.67_01, 0.74_87, 0.62_09], [0.42_87, 0.51_58, 0.47_73]]				)
    elif model_name == "videomae-base-short":
        __a						       =				torch.Size([1, 1408, 1536]				)
        __a						       =				torch.tensor([[0.79_94, 0.96_12, 0.85_08], [0.74_01, 0.89_58, 0.83_02], [0.58_62, 0.74_68, 0.73_25]]				)
        # we verified the loss both for normalized and unnormalized targets for this one
        __a						       =				torch.tensor([0.51_42]				) if config.norm_pix_loss else torch.tensor([0.64_69]				)
    elif model_name == "videomae-large":
        __a						       =				torch.Size([1, 1408, 1536]				)
        __a						       =				torch.tensor([[0.71_49, 0.79_97, 0.69_66], [0.67_68, 0.78_69, 0.69_48], [0.51_39, 0.62_21, 0.56_05]]				)
    elif model_name == "videomae-large-finetuned-kinetics":
        __a						       =				torch.Size([1, 400]				)
        __a						       =				torch.tensor([0.07_71, 0.00_11, -0.36_25]				)
    elif model_name == "videomae-huge-finetuned-kinetics":
        __a						       =				torch.Size([1, 400]				)
        __a						       =				torch.tensor([0.24_33, 0.16_32, -0.48_94]				)
    elif model_name == "videomae-base-short-finetuned-kinetics":
        __a						       =				torch.Size([1, 400]				)
        __a						       =				torch.tensor([0.65_88, 0.09_90, -0.24_93]				)
    elif model_name == "videomae-base-finetuned-kinetics":
        __a						       =				torch.Size([1, 400]				)
        __a						       =				torch.tensor([0.36_69, -0.06_88, -0.24_21]				)
    elif model_name == "videomae-base-short-ssv2":
        __a						       =				torch.Size([1, 1408, 1536]				)
        __a						       =				torch.tensor([[0.47_12, 0.52_96, 0.57_86], [0.22_78, 0.27_29, 0.40_26], [0.03_52, 0.07_30, 0.25_06]]				)
    elif model_name == "videomae-base-short-finetuned-ssv2":
        __a						       =				torch.Size([1, 174]				)
        __a						       =				torch.tensor([-0.05_37, -0.15_39, -0.32_66]				)
    elif model_name == "videomae-base-ssv2":
        __a						       =				torch.Size([1, 1408, 1536]				)
        __a						       =				torch.tensor([[0.81_31, 0.87_27, 0.85_46], [0.73_66, 0.93_77, 0.88_70], [0.59_35, 0.88_74, 0.85_64]]				)
    elif model_name == "videomae-base-finetuned-ssv2":
        __a						       =				torch.Size([1, 174]				)
        __a						       =				torch.tensor([0.19_61, -0.83_37, -0.63_89]				)
    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]   , _UpperCAmelCase   , atol=1E-4				)
    else:
        print('''Logits:'''   , logits[0, :3, :3]				)
        assert torch.allclose(logits[0, :3, :3]   , _UpperCAmelCase   , atol=1E-4				)
    print('''Logits ok!'''				)

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

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


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

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










import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_convbert import ConvBertTokenizer


__snake_case						:str      		=     logging.get_logger(__name__)

__snake_case						:int      		=     {'''vocab_file''': '''vocab.txt'''}

__snake_case						:List[Any]      		=     {
    '''vocab_file''': {
        '''YituTech/conv-bert-base''': '''https://huggingface.co/YituTech/conv-bert-base/resolve/main/vocab.txt''',
        '''YituTech/conv-bert-medium-small''': (
            '''https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/vocab.txt'''
        ),
        '''YituTech/conv-bert-small''': '''https://huggingface.co/YituTech/conv-bert-small/resolve/main/vocab.txt''',
    }
}

__snake_case						:List[str]      		=     {
    '''YituTech/conv-bert-base''': 512,
    '''YituTech/conv-bert-medium-small''': 512,
    '''YituTech/conv-bert-small''': 512,
}


__snake_case						:Optional[int]      		=     {
    '''YituTech/conv-bert-base''': {'''do_lower_case''': True},
    '''YituTech/conv-bert-medium-small''': {'''do_lower_case''': True},
    '''YituTech/conv-bert-small''': {'''do_lower_case''': True},
}

class     _A       (	__UpperCAmelCase    ):
       UpperCamelCase__  :    Optional[int]											=						VOCAB_FILES_NAMES
       UpperCamelCase__  :    str											=						PRETRAINED_VOCAB_FILES_MAP
       UpperCamelCase__  :    Optional[Any]											=						PRETRAINED_INIT_CONFIGURATION
       UpperCamelCase__  :    Optional[int]											=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       UpperCamelCase__  :    int											=						ConvBertTokenizer



       def __init__(		self							:     Optional[Any]     ,		__SCREAMING_SNAKE_CASE							:     Optional[Any]=None     ,		__SCREAMING_SNAKE_CASE							:     Dict=None     ,		__SCREAMING_SNAKE_CASE							:     Tuple=True     ,		__SCREAMING_SNAKE_CASE							:     Optional[int]="[UNK]"     ,		__SCREAMING_SNAKE_CASE							:     int="[SEP]"     ,		__SCREAMING_SNAKE_CASE							:     List[Any]="[PAD]"     ,		__SCREAMING_SNAKE_CASE							:     int="[CLS]"     ,		__SCREAMING_SNAKE_CASE							:     Optional[int]="[MASK]"     ,		__SCREAMING_SNAKE_CASE							:     Optional[int]=True     ,		__SCREAMING_SNAKE_CASE							:     Union[str, Any]=None     ,		**__SCREAMING_SNAKE_CASE							:     Dict     ,		):


           '''simple docstring'''

           super().__init__(
               __SCREAMING_SNAKE_CASE     ,		tokenizer_file=__SCREAMING_SNAKE_CASE     ,		do_lower_case=__SCREAMING_SNAKE_CASE     ,		unk_token=__SCREAMING_SNAKE_CASE     ,		sep_token=__SCREAMING_SNAKE_CASE     ,		pad_token=__SCREAMING_SNAKE_CASE     ,		cls_token=__SCREAMING_SNAKE_CASE     ,		mask_token=__SCREAMING_SNAKE_CASE     ,		tokenize_chinese_chars=__SCREAMING_SNAKE_CASE     ,		strip_accents=__SCREAMING_SNAKE_CASE     ,		**__SCREAMING_SNAKE_CASE     ,		)

           __a						       =				json.loads(self.backend_tokenizer.normalizer.__getstate__())
           if (
               normalizer_state.get('''lowercase'''     ,		__SCREAMING_SNAKE_CASE) != do_lower_case
               or normalizer_state.get('''strip_accents'''     ,		__SCREAMING_SNAKE_CASE) != strip_accents
               or normalizer_state.get('''handle_chinese_chars'''     ,		__SCREAMING_SNAKE_CASE) != tokenize_chinese_chars
           ):
               __a						       =				getattr(__SCREAMING_SNAKE_CASE     ,		normalizer_state.pop('''type'''))
               __a						       =				do_lower_case
               __a						       =				strip_accents
               __a						       =				tokenize_chinese_chars
               __a						       =				normalizer_class(**__SCREAMING_SNAKE_CASE)

           __a						       =				do_lower_case



       def 		_lowerCamelCase			(		self							:     int     ,		__SCREAMING_SNAKE_CASE							:     Dict     ,		__SCREAMING_SNAKE_CASE							:     Any=None):


           '''simple docstring'''

           __a						       =				[self.cls_token_id] + token_ids_a + [self.sep_token_id]

           if token_ids_a:
               output += token_ids_a + [self.sep_token_id]

           return output



       def 		_lowerCamelCase			(		self							:     str     ,		__SCREAMING_SNAKE_CASE							:     List[int]     ,		__SCREAMING_SNAKE_CASE							:     Optional[List[int]] = None):


           '''simple docstring'''

           __a						       =				[self.sep_token_id]
           __a						       =				[self.cls_token_id]
           if token_ids_a is None:
               return len(cls + token_ids_a + sep) * [0]
           return len(cls + token_ids_a + sep) * [0] + len(token_ids_a + sep) * [1]





       def 		_lowerCamelCase			(		self							:     Optional[Any]     ,		__SCREAMING_SNAKE_CASE							:     str     ,		__SCREAMING_SNAKE_CASE							:     Optional[str] = None):


           '''simple docstring'''

           __a						       =				self._tokenizer.model.save(__SCREAMING_SNAKE_CASE     ,		name=__SCREAMING_SNAKE_CASE)
           return tuple(__SCREAMING_SNAKE_CASE)





