






import argparse
import json

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

from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						TimesformerConfig()

    if "large" in model_name:
        _lowercase     			=						96

    if "hr" in model_name:
        _lowercase     			=						16
        _lowercase     			=						448

    _lowercase     			=						'huggingface/label-files'
    if "k400" in model_name:
        _lowercase     			=						400
        _lowercase     			=						'kinetics400-id2label.json'
    elif "k600" in model_name:
        _lowercase     			=						600
        _lowercase     			=						'kinetics600-id2label.json'
    elif "ssv2" in model_name:
        _lowercase     			=						174
        _lowercase     			=						'something-something-v2-id2label.json'
    else:
        raise ValueError('Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'   )
    _lowercase     			=						json.load(open(hf_hub_download(_lowercase,   _lowercase,   repo_type='dataset'   ),   'r'   )   )
    _lowercase     			=						{int(_lowercase   ): v for k, v in idalabel.items()}
    _lowercase     			=						idalabel
    _lowercase     			=						{v: k for k, v in idalabel.items()}

    return config
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    if "encoder." in name:
        _lowercase     			=						name.replace('encoder.',   ''   )
    if "cls_token" in name:
        _lowercase     			=						name.replace('cls_token',   'timesformer.embeddings.cls_token'   )
    if "pos_embed" in name:
        _lowercase     			=						name.replace('pos_embed',   'timesformer.embeddings.position_embeddings'   )
    if "time_embed" in name:
        _lowercase     			=						name.replace('time_embed',   'timesformer.embeddings.time_embeddings'   )
    if "patch_embed.proj" in name:
        _lowercase     			=						name.replace('patch_embed.proj',   'timesformer.embeddings.patch_embeddings.projection'   )
    if "patch_embed.norm" in name:
        _lowercase     			=						name.replace('patch_embed.norm',   'timesformer.embeddings.norm'   )
    if "blocks" in name:
        _lowercase     			=						name.replace('blocks',   'timesformer.encoder.layer'   )
    if "attn.proj" in name:
        _lowercase     			=						name.replace('attn.proj',   'attention.output.dense'   )
    if "attn" in name and "bias" not in name and "temporal" not in name:
        _lowercase     			=						name.replace('attn',   'attention.self'   )
    if "attn" in name and "temporal" not in name:
        _lowercase     			=						name.replace('attn',   'attention.attention'   )
    if "temporal_norm1" in name:
        _lowercase     			=						name.replace('temporal_norm1',   'temporal_layernorm'   )
    if "temporal_attn.proj" in name:
        _lowercase     			=						name.replace('temporal_attn',   'temporal_attention.output.dense'   )
    if "temporal_fc" in name:
        _lowercase     			=						name.replace('temporal_fc',   'temporal_dense'   )
    if "norm1" in name and "temporal" not in name:
        _lowercase     			=						name.replace('norm1',   'layernorm_before'   )
    if "norm2" in name:
        _lowercase     			=						name.replace('norm2',   'layernorm_after'   )
    if "mlp.fc1" in name:
        _lowercase     			=						name.replace('mlp.fc1',   'intermediate.dense'   )
    if "mlp.fc2" in name:
        _lowercase     			=						name.replace('mlp.fc2',   'output.dense'   )
    if "norm.weight" in name and "fc" not in name and "temporal" not in name:
        _lowercase     			=						name.replace('norm.weight',   'timesformer.layernorm.weight'   )
    if "norm.bias" in name and "fc" not in name and "temporal" not in name:
        _lowercase     			=						name.replace('norm.bias',   'timesformer.layernorm.bias'   )
    if "head" in name:
        _lowercase     			=						name.replace('head',   'classifier'   )

    return name
def 							UpperCAmelCase   ( _lowercase,   _lowercase   ):


    '''simple docstring'''



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

        if key.startswith('model.'   ):
            _lowercase     			=						key.replace('model.',   ''   )

        if "qkv" in key:
            _lowercase     			=						key.split('.'   )
            _lowercase     			=						int(key_split[1]   )
            _lowercase     			=						'timesformer.encoder.layer.'
            if "temporal" in key:
                _lowercase     			=						'.temporal_attention.attention.qkv.'
            else:
                _lowercase     			=						'.attention.attention.qkv.'
            if "weight" in key:
                _lowercase     			=						val
            else:
                _lowercase     			=						val
        else:
            _lowercase     			=						val

    return orig_state_dict
def 							UpperCAmelCase   ( ):


    '''simple docstring'''



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


    '''simple docstring'''



    _lowercase     			=						get_timesformer_config(_lowercase   )

    _lowercase     			=						TimesformerForVideoClassification(_lowercase   )

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

    model.load_state_dict(_lowercase   )
    model.eval()

    # verify model on basic input
    _lowercase     			=						VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5],   image_std=[0.5, 0.5, 0.5]   )
    _lowercase     			=						prepare_video()
    _lowercase     			=						image_processor(video[:8],   return_tensors='pt'   )

    _lowercase     			=						model(**_lowercase   )
    _lowercase     			=						outputs.logits

    _lowercase     			=						[
        # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
        'timesformer-base-finetuned-k400',
        'timesformer-large-finetuned-k400',
        'timesformer-hr-finetuned-k400',
        # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
        'timesformer-base-finetuned-k600',
        'timesformer-large-finetuned-k600',
        'timesformer-hr-finetuned-k600',
        # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
        'timesformer-base-finetuned-ssv2',
        'timesformer-large-finetuned-ssv2',
        'timesformer-hr-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 == "timesformer-base-finetuned-k400":
        _lowercase     			=						torch.Size([1, 400]   )
        _lowercase     			=						torch.tensor([-0.3_016, -0.7_713, -0.4_205]   )
    elif model_name == "timesformer-base-finetuned-k600":
        _lowercase     			=						torch.Size([1, 600]   )
        _lowercase     			=						torch.tensor([-0.7_267, -0.7_466, 3.2_404]   )
    elif model_name == "timesformer-base-finetuned-ssv2":
        _lowercase     			=						torch.Size([1, 174]   )
        _lowercase     			=						torch.tensor([-0.9_059, 0.6_433, -3.1_457]   )
    elif model_name == "timesformer-large-finetuned-k400":
        _lowercase     			=						torch.Size([1, 400]   )
        _lowercase     			=						torch.tensor([0, 0, 0]   )
    elif model_name == "timesformer-large-finetuned-k600":
        _lowercase     			=						torch.Size([1, 600]   )
        _lowercase     			=						torch.tensor([0, 0, 0]   )
    elif model_name == "timesformer-large-finetuned-ssv2":
        _lowercase     			=						torch.Size([1, 174]   )
        _lowercase     			=						torch.tensor([0, 0, 0]   )
    elif model_name == "timesformer-hr-finetuned-k400":
        _lowercase     			=						torch.Size([1, 400]   )
        _lowercase     			=						torch.tensor([-0.9_617, -3.7_311, -3.7_708]   )
    elif model_name == "timesformer-hr-finetuned-k600":
        _lowercase     			=						torch.Size([1, 600]   )
        _lowercase     			=						torch.tensor([2.5_273, 0.7_127, 1.8_848]   )
    elif model_name == "timesformer-hr-finetuned-ssv2":
        _lowercase     			=						torch.Size([1, 174]   )
        _lowercase     			=						torch.tensor([-3.6_756, -0.7_513, 0.7_180]   )
    else:
        raise ValueError(f'''Model name not supported. Should be one of {model_names}'''   )

    # verify logits
    assert logits.shape == expected_shape
    assert torch.allclose(logits[0, :3],   _lowercase,   atol=1e-4   )
    print('Logits 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(_lowercase   )
        model.save_pretrained(_lowercase   )

    if push_to_hub:
        print('Pushing to the hub...'   )
        model.push_to_hub(f'''fcakyon/{model_name}'''   )


if __name__ == "__main__":
   lowerCamelCase					    =	argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '''--checkpoint_url''',
       default='''https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download''',
       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='''''',
       type=str,
       help='''Path to the output PyTorch model directory.''',
   )
   parser.add_argument('''--model_name''', default='''timesformer-base-finetuned-k400''', 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.'''
   )

   lowerCamelCase					    =	parser.parse_args()
   convert_timesformer_checkpoint(
       args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
   )








import math
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						math.log(2,   10   ) * number
    _lowercase     			=						round((log_number - int(_lowercase   )),   15   )

    return difference
def 							UpperCAmelCase   ( _lowercase = 678910   ):


    '''simple docstring'''



    _lowercase     			=						90
    _lowercase     			=						0

    _lowercase     			=						math.log(1.23,   10   )
    _lowercase     			=						math.log(1.24,   10   )
    _lowercase     			=						0

    while position < number:
        _lowercase     			=						log_difference(_lowercase   )

        if difference >= upper_limit:
            power_iterator += 93

        elif difference < lower_limit:
            power_iterator += 196

        else:
            _lowercase     			=						power_iterator
            power_iterator += 196
            position += 1

    return previous_power


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   print(f"{solution() = }")
