


'''simple docstring'''






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 lowerCamelCase__			(						__lowerCamelCase       :							List[str]							):







   '''simple docstring'''




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

   with open(A__       ,    'wb'							) as f:
      with requests.get(A__       ,    stream=A__							) as req:
         for chunk in req.iter_content(chunk_size=2_0_4_8							):
            f.write(A__							)





def lowerCamelCase__			(						):







   '''simple docstring'''




   _UpperCAmelCase   :   int							    =VivitConfig()

   _UpperCAmelCase   :   Optional[Any]							    =4_0_0
   _UpperCAmelCase   :   Union[str, Any]							    ='huggingface/label-files'
   _UpperCAmelCase   :   Optional[Any]							    ='kinetics400-id2label.json'

   _UpperCAmelCase   :   Any							    =json.load(open(hf_hub_download(A__       ,    A__       ,    repo_type='dataset'							)       ,    'r'							)							)
   _UpperCAmelCase   :   int							    ={int(A__							): v for k, v in idalabel.items()}
   _UpperCAmelCase   :   Dict							    =idalabel
   _UpperCAmelCase   :   Optional[Any]							    ={v: k for k, v in idalabel.items()}
   return config





def lowerCamelCase__			(						):







   '''simple docstring'''




   _UpperCAmelCase   :   Optional[Any]							    =hf_hub_download(
       repo_id='hf-internal-testing/spaghetti-video'       ,    filename='eating_spaghetti_32_frames.npy'       ,    repo_type='dataset'							)
   _UpperCAmelCase   :   Union[str, Any]							    =np.load(A__							)
   return list(A__							)





def lowerCamelCase__			(						__lowerCamelCase       :							List[str]							):







   '''simple docstring'''




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

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

   else:
      raise Exception(f"Invalid number of dimesions: {np.ndim(A__							)}"							)





def lowerCamelCase__			(						__lowerCamelCase       :							int							):







   '''simple docstring'''




   return current.flatten()





def lowerCamelCase__			(						__lowerCamelCase       :							Optional[int]							):







   '''simple docstring'''




   return np.reshape(A__       ,    (current.shape[0], current.shape[1] * current.shape[2])							).T





def lowerCamelCase__			(						__lowerCamelCase       :							List[Any]							):







   '''simple docstring'''




   return np.reshape(A__       ,    (current.shape[0] * current.shape[1], current.shape[2])							).T





def lowerCamelCase__			(						__lowerCamelCase       :							Tuple       ,    __lowerCamelCase       :							Dict							):







   '''simple docstring'''




   _UpperCAmelCase   :   Optional[int]							    =state_dict['optimizer']['target']['Transformer'][f"encoderblock_{i}"]

   _UpperCAmelCase   :   Tuple							    =f"encoder.layer.{i}."
   _UpperCAmelCase   :   Dict							    ={
       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 lowerCamelCase__			(						__lowerCamelCase       :							Dict							):







   '''simple docstring'''




   return sum([1 if 'encoderblock_' in k else 0 for k in state_dict['optimizer']['target']['Transformer'].keys()]							)





def lowerCamelCase__			(						__lowerCamelCase       :							Union[str, Any]       ,    __lowerCamelCase       :							List[str]=False							):







   '''simple docstring'''




   _UpperCAmelCase   :   Dict							    =get_n_layers(A__							)

   _UpperCAmelCase   :   str							    =OrderedDict()

   _UpperCAmelCase   :   Optional[Any]							    =state_dict['optimizer']['target']['Transformer']['encoder_norm']['bias']
   _UpperCAmelCase   :   Optional[Any]							    =state_dict['optimizer']['target']['Transformer']['encoder_norm']['scale']

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

   _UpperCAmelCase   :   Union[str, Any]							    =state_dict['optimizer']['target']['cls']
   _UpperCAmelCase   :   Optional[int]							    =state_dict['optimizer']['target']['Transformer']['posembed_input'][
       'pos_embedding'
   ]

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

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

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





def lowerCamelCase__			(						):







   '''simple docstring'''




   _UpperCAmelCase   :   Tuple							    =VivitImageProcessor()

   assert extractor.do_resize is True
   assert extractor.size == {"shortest_edge": 2_5_6}
   assert extractor.do_center_crop is True
   assert extractor.crop_size == {"width": 2_2_4, "height": 2_2_4}
   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 / 2_5_5

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

   return extractor





def lowerCamelCase__			(						__lowerCamelCase       :							Union[str, Any]							):







   '''simple docstring'''




   _UpperCAmelCase   :   Optional[int]							    ='checkpoint'

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

   _UpperCAmelCase   :   str							    =restore_checkpoint(A__       ,    A__							)
   _UpperCAmelCase   :   str							    =transform_state(A__       ,    classification_head=A__							)

   _UpperCAmelCase   :   str							    =get_vivit_config()

   assert config.image_size == 2_2_4
   assert config.num_frames == 3_2

   _UpperCAmelCase   :   List[Any]							    =VivitForVideoClassification(A__							)
   model.load_state_dict(A__							)
   model.eval()

   _UpperCAmelCase   :   Tuple							    =get_processor()

   _UpperCAmelCase   :   Optional[Any]							    =prepare_video()
   _UpperCAmelCase   :   Optional[int]							    =extractor(A__       ,    return_tensors='pt'							)

   _UpperCAmelCase   :   Any							    =model(**A__							)

   _UpperCAmelCase   :   List[str]							    =torch.Size([1, 4_0_0]							)
   _UpperCAmelCase   :   Any							    =torch.tensor([-1.05_43, 2.07_64, -0.21_04, 0.44_39, -0.96_58]							)

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

   model.save_pretrained(A__							)
   extractor.save_pretrained(A__							)


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

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

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





from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase__       :	Any     				=logging.get_logger(__name__)

lowerCAmelCase__       :	Union[str, Any]     				={
    'google/reformer-crime-and-punishment': (
        'https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/config.json'
    ),
    'google/reformer-enwik8': 'https://huggingface.co/google/reformer-enwik8/resolve/main/config.json',
}







class      __lowercase  (__SCREAMING_SNAKE_CASE   ):





							"""simple docstring"""







							_UpperCAmelCase     =		"""reformer"""
							_UpperCAmelCase     =		["""past_buckets_states"""]
							_UpperCAmelCase     =		{}






							def __init__(	self       ,		lowerCAmelCase__=6_4       ,		lowerCAmelCase__=["local", "lsh", "local", "lsh", "local", "lsh"]       ,		lowerCAmelCase__=1.0       ,		lowerCAmelCase__=True       ,		lowerCAmelCase__=[6_4, 6_4]       ,		lowerCAmelCase__=[6_4, 1_9_2]       ,		lowerCAmelCase__=0       ,		lowerCAmelCase__=2       ,		lowerCAmelCase__=5_1_2       ,		lowerCAmelCase__=None       ,		lowerCAmelCase__="relu"       ,		lowerCAmelCase__=0.05       ,		lowerCAmelCase__=2_5_6       ,		lowerCAmelCase__=0.02       ,		lowerCAmelCase__=False       ,		lowerCAmelCase__=1E-12       ,		lowerCAmelCase__=1       ,		lowerCAmelCase__=0       ,		lowerCAmelCase__=0.05       ,		lowerCAmelCase__=6_4       ,		lowerCAmelCase__=6_4       ,		lowerCAmelCase__=0.0       ,		lowerCAmelCase__=1       ,		lowerCAmelCase__=0       ,		lowerCAmelCase__=4_0_9_6       ,		lowerCAmelCase__=1_2       ,		lowerCAmelCase__=None       ,		lowerCAmelCase__=1       ,		lowerCAmelCase__=0       ,		lowerCAmelCase__=3_2_0       ,		lowerCAmelCase__=False       ,		lowerCAmelCase__=True       ,		lowerCAmelCase__=None       ,		**lowerCAmelCase__       ,		):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			str       						= hash_seed
										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= vocab_size
										SCREAMING_SNAKE_CASE_						:			Any       						= attention_head_size
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= hidden_size
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= num_attention_heads
										SCREAMING_SNAKE_CASE_						:			Any       						= num_hashes
										SCREAMING_SNAKE_CASE_						:			int       						= len(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			str       						= tuple(lowerCAmelCase__    ) if isinstance(lowerCAmelCase__       ,		lowerCAmelCase__    ) else num_buckets
										SCREAMING_SNAKE_CASE_						:			int       						= lsh_attn_chunk_length
										SCREAMING_SNAKE_CASE_						:			List[str]       						= local_attn_chunk_length
										SCREAMING_SNAKE_CASE_						:			Tuple       						= lsh_num_chunks_after
										SCREAMING_SNAKE_CASE_						:			str       						= lsh_num_chunks_before
										SCREAMING_SNAKE_CASE_						:			List[Any]       						= local_num_chunks_after
										SCREAMING_SNAKE_CASE_						:			Any       						= local_num_chunks_before
										SCREAMING_SNAKE_CASE_						:			Any       						= hidden_act
										SCREAMING_SNAKE_CASE_						:			Dict       						= feed_forward_size
										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= hidden_dropout_prob
										SCREAMING_SNAKE_CASE_						:			Tuple       						= lsh_attention_probs_dropout_prob
										SCREAMING_SNAKE_CASE_						:			Any       						= local_attention_probs_dropout_prob
										SCREAMING_SNAKE_CASE_						:			str       						= max_position_embeddings
										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= initializer_range
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= layer_norm_eps
										SCREAMING_SNAKE_CASE_						:			List[str]       						= axial_pos_embds
										SCREAMING_SNAKE_CASE_						:			List[str]       						= tuple(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Tuple       						= tuple(lowerCAmelCase__    )
										SCREAMING_SNAKE_CASE_						:			Dict       						= axial_norm_std
										SCREAMING_SNAKE_CASE_						:			Any       						= chunk_size_lm_head
										SCREAMING_SNAKE_CASE_						:			int       						= attn_layers
										SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= use_cache
										SCREAMING_SNAKE_CASE_						:			Tuple       						= classifier_dropout
										super().__init__(
										    pad_token_id=lowerCAmelCase__       ,		eos_token_id=lowerCAmelCase__       ,		is_decoder=lowerCAmelCase__       ,		tie_word_embeddings=lowerCAmelCase__       ,		**lowerCAmelCase__       ,		)





