





'''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      lowercase  (  lowerCAmelCase :						Optional[Any]):



				"""simple docstring"""


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

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





def      lowercase  (  ):



				"""simple docstring"""


				_A :				Union[str, Any]				=  VivitConfig()

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

				_A :				str				=  json.load(open(hf_hub_download(lowerCAmelCase   , lowerCAmelCase   , repo_type='''dataset''')   , '''r'''))
				_A :				Union[str, Any]				=  {int(lowerCAmelCase): v for k, v in idalabel.items()}
				_A :				int				=  idalabel
				_A :				str				=  {v: k for k, v in idalabel.items()}
				return config





def      lowercase  (  ):



				"""simple docstring"""


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





def      lowercase  (  lowerCAmelCase :						np.ndarray):



				"""simple docstring"""


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

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

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





def      lowercase  (  lowerCAmelCase :						np.ndarray):



				"""simple docstring"""


				return current.flatten()





def      lowercase  (  lowerCAmelCase :						np.ndarray):



				"""simple docstring"""


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





def      lowercase  (  lowerCAmelCase :						np.ndarray):



				"""simple docstring"""


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





def      lowercase  (  lowerCAmelCase :						str   , lowerCAmelCase :						int):



				"""simple docstring"""


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

				_A :				Union[str, Any]				=  f"""encoder.layer.{i}."""
				_A :				Union[str, Any]				=  {
				    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      lowercase  (  lowerCAmelCase :						List[str]):



				"""simple docstring"""


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





def      lowercase  (  lowerCAmelCase :						int   , lowerCAmelCase :						Tuple=False):



				"""simple docstring"""


				_A :				int				=  get_n_layers(lowerCAmelCase)

				_A :				Tuple				=  OrderedDict()

				_A :				Dict				=  state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''bias''']
				_A :				str				=  state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''scale''']

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

				_A :				Optional[int]				=  state_dict['''optimizer''']['''target''']['''cls''']
				_A :				Tuple				=  state_dict['''optimizer''']['''target''']['''Transformer''']['''posembed_input'''][
				    '''pos_embedding'''
				]

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

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

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





def      lowercase  (  ):



				"""simple docstring"""


				_A :				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      lowercase  (  lowerCAmelCase :						str):



				"""simple docstring"""


				_A :				List[str]				=  '''checkpoint'''

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

				_A :				Tuple				=  restore_checkpoint(lowerCAmelCase   , lowerCAmelCase)
				_A :				Union[str, Any]				=  transform_state(lowerCAmelCase   , classification_head=lowerCAmelCase)

				_A :				Dict				=  get_vivit_config()

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

				_A :				List[Any]				=  VivitForVideoClassification(lowerCAmelCase)
				model.load_state_dict(lowerCAmelCase)
				model.eval()

				_A :				List[str]				=  get_processor()

				_A :				Tuple				=  prepare_video()
				_A :				Optional[Any]				=  extractor(lowerCAmelCase   , return_tensors='''pt''')

				_A :				Dict				=  model(**lowerCAmelCase)

				_A :				List[Any]				=  torch.Size([1, 400])
				_A :				List[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]   , lowerCAmelCase   , atol=1e-4), outputs.logits[0, :5]

				model.save_pretrained(lowerCAmelCase)
				extractor.save_pretrained(lowerCAmelCase)


if __name__ == "__main__":
	__UpperCamelCase      :   Tuple								=     argparse.ArgumentParser()

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

	__UpperCamelCase      :   str								=     parser.parse_args()
	convert(args.output_model_name)







'''simple docstring'''






import sys

sys.set_int_max_str_digits(0)  # type: ignore





def      lowercase  (  lowerCAmelCase :						int):



				"""simple docstring"""


				_A :				List[Any]				=  [0] * 11
				_A :				Optional[Any]				=  [0] * 11

				# mark last 9 numbers
				for _ in range(9):
								_A :				Dict				=  1
								_A :				Optional[int]				=  number // 10
				# flag
				_A :				str				=  True

				# check last 9 numbers for pandigitality

				for x in range(9):
								if not check_last[x + 1]:
												_A :				Dict				=  False
				if not f:
								return f

				# mark first 9 numbers
				_A :				str				=  int(str(lowerCAmelCase)[:9])

				for _ in range(9):
								_A :				Tuple				=  1
								_A :				Union[str, Any]				=  number // 10

				# check first 9 numbers for pandigitality

				for x in range(9):
								if not check_front[x + 1]:
												_A :				Union[str, Any]				=  False
				return f





def      lowercase  (  lowerCAmelCase :						int):



				"""simple docstring"""


				_A :				Tuple				=  [0] * 11

				# mark last 9 numbers
				for _ in range(9):
								_A :				int				=  1
								_A :				Optional[int]				=  number // 10
				# flag
				_A :				List[str]				=  True

				# check last 9 numbers for pandigitality

				for x in range(9):
								if not check_last[x + 1]:
												_A :				Any				=  False
				return f





def      lowercase  (  ):



				"""simple docstring"""


				_A :				Union[str, Any]				=  1
				_A :				Tuple				=  1
				_A :				List[str]				=  2
				# temporary Fibonacci numbers

				_A :				List[str]				=  1
				_A :				str				=  1
				_A :				List[str]				=  2
				# temporary Fibonacci numbers mod 1e9

				# mod m=1e9, done for fast optimisation
				_A :				Any				=  [0] * 100_0000
				_A :				List[Any]				=  10_0000_0000

				for x in range(100_0000):
								_A :				Dict				=  (aa + ba) % m
								_A :				str				=  ba % m
								_A :				Union[str, Any]				=  ca % m
								if checka(lowerCAmelCase):
												_A :				List[str]				=  1

				for x in range(100_0000):
								_A :				str				=  a + b
								_A :				List[str]				=  b
								_A :				int				=  c
								# perform check only if in tocheck
								if tocheck[x + 3] and check(lowerCAmelCase):
												return x + 3  # first 2 already done
				return -1


if __name__ == "__main__":
	print(f'{solution() = }')
