
"""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 						UpperCAmelCase   (						a_     ):





		'''simple docstring'''


		lowerCamelCase	:     Dict            =       '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=2048     ):
								f.write(a_     )
def 						UpperCAmelCase   (						):





		'''simple docstring'''


		lowerCamelCase	:     List[str]            =       VivitConfig()

		lowerCamelCase	:     Any            =       400
		lowerCamelCase	:     List[str]            =       'huggingface/label-files'
		lowerCamelCase	:     Tuple            =       'kinetics400-id2label.json'

		lowerCamelCase	:     List[str]            =       json.load(open(hf_hub_download(a_,		a_,		repo_type='dataset'     ),		'r'     )     )
		lowerCamelCase	:     Tuple            =       {int(a_     ): v for k, v in idalabel.items()}
		lowerCamelCase	:     int            =       idalabel
		lowerCamelCase	:     List[str]            =       {v: k for k, v in idalabel.items()}
		return config
def 						UpperCAmelCase   (						):





		'''simple docstring'''


		lowerCamelCase	:     Union[str, Any]            =       hf_hub_download(
		    repo_id='hf-internal-testing/spaghetti-video',		filename='eating_spaghetti_32_frames.npy',		repo_type='dataset'     )
		lowerCamelCase	:     int            =       np.load(a_     )
		return list(a_     )
def 						UpperCAmelCase   (						a_     ):





		'''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 						UpperCAmelCase   (						a_     ):





		'''simple docstring'''


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





		'''simple docstring'''


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





		'''simple docstring'''


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





		'''simple docstring'''


		lowerCamelCase	:     str            =       state_dict['optimizer']['target']['Transformer'][F"""encoderblock_{i}"""]

		lowerCamelCase	:     str            =       F"""encoder.layer.{i}."""
		lowerCamelCase	:     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 						UpperCAmelCase   (						a_     ):





		'''simple docstring'''


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





		'''simple docstring'''


		lowerCamelCase	:     Union[str, Any]            =       get_n_layers(a_     )

		lowerCamelCase	:     str            =       OrderedDict()

		lowerCamelCase	:     int            =       state_dict['optimizer']['target']['Transformer']['encoder_norm']['bias']
		lowerCamelCase	:     List[Any]            =       state_dict['optimizer']['target']['Transformer']['encoder_norm']['scale']

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

		lowerCamelCase	:     List[str]            =       state_dict['optimizer']['target']['cls']
		lowerCamelCase	:     Any            =       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:
				lowerCamelCase	:     int            =       {'vivit.' + k: v for k, v in new_state.items()}
				lowerCamelCase	:     Any            =       np.transpose(state_dict['optimizer']['target']['output_projection']['kernel']     )
				lowerCamelCase	:     Optional[int]            =       np.transpose(state_dict['optimizer']['target']['output_projection']['bias']     )

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





		'''simple docstring'''


		lowerCamelCase	:     List[Any]            =       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   (						a_     ):





		'''simple docstring'''


		lowerCamelCase	:     Tuple            =       'checkpoint'

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

		lowerCamelCase	:     List[str]            =       restore_checkpoint(a_,		a_     )
		lowerCamelCase	:     Union[str, Any]            =       transform_state(a_,		classification_head=a_     )

		lowerCamelCase	:     int            =       get_vivit_config()

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

		lowerCamelCase	:     Optional[Any]            =       VivitForVideoClassification(a_     )
		model.load_state_dict(a_     )
		model.eval()

		lowerCamelCase	:     List[Any]            =       get_processor()

		lowerCamelCase	:     List[str]            =       prepare_video()
		lowerCamelCase	:     Optional[Any]            =       extractor(a_,		return_tensors='pt'     )

		lowerCamelCase	:     int            =       model(**a_     )

		lowerCamelCase	:     Tuple            =       torch.Size([1, 400]     )
		lowerCamelCase	:     str            =       torch.tensor([-1.0_5_4_3, 2.0_7_6_4, -0.2_1_0_4, 0.4_4_3_9, -0.9_6_5_8]     )

		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__":
					_A				=					argparse.ArgumentParser()

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

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








"""simple docstring"""

def 						UpperCAmelCase   (						a_     ):





		'''simple docstring'''


		if not isinstance(a_,		a_     ):
				raise TypeError('recursive_lucas_number accepts only integer arguments.'     )
		if n_th_number == 0:
				return 2
		if n_th_number == 1:
				return 1

		return recursive_lucas_number(n_th_number - 1     ) + recursive_lucas_number(
		    n_th_number - 2     )
def 						UpperCAmelCase   (						a_     ):





		'''simple docstring'''


		if not isinstance(a_,		a_     ):
				raise TypeError('dynamic_lucas_number accepts only integer arguments.'     )
		lowerCamelCase      ,       lowerCamelCase	:     Optional[int]            =       2, 1
		for _ in range(a_     ):
				lowerCamelCase      ,       lowerCamelCase	:     Optional[int]            =       b, a + b
		return a


if __name__ == "__main__":
					from doctest import testmod

					testmod()
					_A				=					int(input('Enter the number of terms in lucas series:\n').strip())
					print('Using recursive function to calculate lucas series:')
					print(' '.join(str(recursive_lucas_number(i)) for i in range(n)))
					print('\nUsing dynamic function to calculate lucas series:')
					print(' '.join(str(dynamic_lucas_number(i)) for i in range(n)))






