






import argparse
import json
import os.path
from collections import OrderedDict

import numpy as np
import requests
import torch
from flax.training.checkpoints import restore_checkpoint
from huggingface_hub import hf_hub_download

from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
from transformers.image_utils import PILImageResampling
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						'https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint'

    with open(_lowercase,   'wb'   ) as f:
        with requests.get(_lowercase,   stream=_lowercase   ) as req:
            for chunk in req.iter_content(chunk_size=2048   ):
                f.write(_lowercase   )
def 							UpperCAmelCase   ( ):


    '''simple docstring'''



    _lowercase     			=						VivitConfig()

    _lowercase     			=						400
    _lowercase     			=						'huggingface/label-files'
    _lowercase     			=						'kinetics400-id2label.json'

    _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   ( ):


    '''simple docstring'''



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


    '''simple docstring'''



    if np.ndim(_lowercase   ) == 2:
        return transform_attention_bias(_lowercase   )

    elif np.ndim(_lowercase   ) == 3:
        return transform_attention_kernel(_lowercase   )

    else:
        raise Exception(f'''Invalid number of dimesions: {np.ndim(_lowercase   )}'''   )
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    return current.flatten()
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    return np.reshape(_lowercase,   (current.shape[0], current.shape[1] * current.shape[2])   ).T
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    return np.reshape(_lowercase,   (current.shape[0] * current.shape[1], current.shape[2])   ).T
def 							UpperCAmelCase   ( _lowercase,   _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						state_dict['optimizer']['target']['Transformer'][f'''encoderblock_{i}''']

    _lowercase     			=						f'''encoder.layer.{i}.'''
    _lowercase     			=						{
        prefix + 'intermediate.dense.bias': state['MlpBlock_0']['Dense_0']['bias'],
        prefix + 'intermediate.dense.weight': np.transpose(state['MlpBlock_0']['Dense_0']['kernel']   ),
        prefix + 'output.dense.bias': state['MlpBlock_0']['Dense_1']['bias'],
        prefix + 'output.dense.weight': np.transpose(state['MlpBlock_0']['Dense_1']['kernel']   ),
        prefix + 'layernorm_before.bias': state['LayerNorm_0']['bias'],
        prefix + 'layernorm_before.weight': state['LayerNorm_0']['scale'],
        prefix + 'layernorm_after.bias': state['LayerNorm_1']['bias'],
        prefix + 'layernorm_after.weight': state['LayerNorm_1']['scale'],
        prefix
        + 'attention.attention.query.bias': transform_attention(
            state['MultiHeadDotProductAttention_0']['query']['bias']   ),
        prefix
        + 'attention.attention.query.weight': transform_attention(
            state['MultiHeadDotProductAttention_0']['query']['kernel']   ),
        prefix
        + 'attention.attention.key.bias': transform_attention(state['MultiHeadDotProductAttention_0']['key']['bias']   ),
        prefix
        + 'attention.attention.key.weight': transform_attention(
            state['MultiHeadDotProductAttention_0']['key']['kernel']   ),
        prefix
        + 'attention.attention.value.bias': transform_attention(
            state['MultiHeadDotProductAttention_0']['value']['bias']   ),
        prefix
        + 'attention.attention.value.weight': transform_attention(
            state['MultiHeadDotProductAttention_0']['value']['kernel']   ),
        prefix + 'attention.output.dense.bias': state['MultiHeadDotProductAttention_0']['out']['bias'],
        prefix
        + 'attention.output.dense.weight': transform_attention_output_weight(
            state['MultiHeadDotProductAttention_0']['out']['kernel']   ),
    }

    return new_state
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    return sum([1 if 'encoderblock_' in k else 0 for k in state_dict['optimizer']['target']['Transformer'].keys()]   )
def 							UpperCAmelCase   ( _lowercase,   _lowercase=False   ):


    '''simple docstring'''



    _lowercase     			=						get_n_layers(_lowercase   )

    _lowercase     			=						OrderedDict()

    _lowercase     			=						state_dict['optimizer']['target']['Transformer']['encoder_norm']['bias']
    _lowercase     			=						state_dict['optimizer']['target']['Transformer']['encoder_norm']['scale']

    _lowercase     			=						np.transpose(
        state_dict['optimizer']['target']['embedding']['kernel'],   (4, 3, 0, 1, 2)   )
    _lowercase     			=						state_dict['optimizer']['target']['embedding']['bias']

    _lowercase     			=						state_dict['optimizer']['target']['cls']
    _lowercase     			=						state_dict['optimizer']['target']['Transformer']['posembed_input'][
        'pos_embedding'
    ]

    for i in range(_lowercase   ):
        new_state.update(transform_state_encoder_block(_lowercase,   _lowercase   )   )

    if classification_head:
        _lowercase     			=						{'vivit.' + k: v for k, v in new_state.items()}
        _lowercase     			=						np.transpose(state_dict['optimizer']['target']['output_projection']['kernel']   )
        _lowercase     			=						np.transpose(state_dict['optimizer']['target']['output_projection']['bias']   )

    return {k: torch.tensor(_lowercase   ) for k, v in new_state.items()}
def 							UpperCAmelCase   ( ):


    '''simple docstring'''



    _lowercase     			=						VivitImageProcessor()

    assert extractor.do_resize is True
    assert extractor.size == {"shortest_edge": 256}
    assert extractor.do_center_crop is True
    assert extractor.crop_size == {"width": 224, "height": 224}
    assert extractor.resample == PILImageResampling.BILINEAR

    # here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
    # one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
    # which effectively means no normalization (and ViViT does not overwrite those when calling this func)
    assert extractor.do_normalize is False
    assert extractor.do_rescale is True
    assert extractor.rescale_factor == 1 / 255

    # zero-centering = True in original implementation
    assert extractor.do_zero_centering is True

    return extractor
def 							UpperCAmelCase   ( _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						'checkpoint'

    if not os.path.exists(_lowercase   ):
        download_checkpoint(_lowercase   )

    _lowercase     			=						restore_checkpoint(_lowercase,   _lowercase   )
    _lowercase     			=						transform_state(_lowercase,   classification_head=_lowercase   )

    _lowercase     			=						get_vivit_config()

    assert config.image_size == 224
    assert config.num_frames == 32

    _lowercase     			=						VivitForVideoClassification(_lowercase   )
    model.load_state_dict(_lowercase   )
    model.eval()

    _lowercase     			=						get_processor()

    _lowercase     			=						prepare_video()
    _lowercase     			=						extractor(_lowercase,   return_tensors='pt'   )

    _lowercase     			=						model(**_lowercase   )

    _lowercase     			=						torch.Size([1, 400]   )
    _lowercase     			=						torch.tensor([-1.0_543, 2.0_764, -0.2_104, 0.4_439, -0.9_658]   )

    assert outputs.logits.shape == expected_shape
    assert torch.allclose(outputs.logits[0, :5],   _lowercase,   atol=1e-4   ), outputs.logits[0, :5]

    model.save_pretrained(_lowercase   )
    extractor.save_pretrained(_lowercase   )


if __name__ == "__main__":
   lowerCamelCase					    =	argparse.ArgumentParser()

   parser.add_argument('''--output_model_name''', '''-o''', type=str, help='''Output path for the converted HuggingFace model''')

   lowerCamelCase					    =	parser.parse_args()
   convert(args.output_model_name)








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() = }")
