





'''simple docstring'''






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


__UpperCamelCase										=  logging.get_logger(__name__)

__UpperCamelCase										=  {
    "ZinengTang/tvlt-base": "https://huggingface.co/ZinengTang/tvlt-base/blob/main/config.json",
}




class    _A   (				__lowercase		):
		lowercase__:      List[Any]							    =      '''tvlt'''

		def __init__(      self				:      Optional[Any]     ,			__magic_name__				:      Optional[int]=2_24     ,			__magic_name__				:      Optional[int]=20_48     ,			__magic_name__				:      Tuple=1_28     ,			__magic_name__				:      List[str]=[16, 16]     ,			__magic_name__				:      Optional[Any]=[16, 16]     ,			__magic_name__				:      Tuple=3     ,			__magic_name__				:      List[str]=1     ,			__magic_name__				:      Dict=8     ,			__magic_name__				:      Optional[int]=7_68     ,			__magic_name__				:      str=12     ,			__magic_name__				:      List[str]=12     ,			__magic_name__				:      List[Any]=30_72     ,			__magic_name__				:      Dict="gelu"     ,			__magic_name__				:      Any=0.0     ,			__magic_name__				:      str=0.0     ,			__magic_name__				:      int=0.02     ,			__magic_name__				:      str=1E-6     ,			__magic_name__				:      List[Any]=True     ,			__magic_name__				:      Tuple=False     ,			__magic_name__				:      Any=16     ,			__magic_name__				:      Union[str, Any]=5_12     ,			__magic_name__				:      Dict=8     ,			__magic_name__				:      Dict=20_48     ,			__magic_name__				:      Optional[int]=0.75     ,			__magic_name__				:      str=0.15     ,			__magic_name__				:      Optional[Any]="frame-level"     ,			__magic_name__				:      int=True     ,			__magic_name__				:      Any=True     ,			__magic_name__				:      Union[str, Any]="classification"     ,			**__magic_name__				:      Optional[Any]     ,			)				->						Any:


					"""simple docstring"""

					super().__init__(**__magic_name__ )

					if audio_mask_type not in ("frame-level", "patch_level"):
								raise ValueError(
								    """audio_mask_type must be one of two acceptable strategies - {'frame_level', 'patch-level') """
								    f'''got {audio_mask_type}''' )

					__snake_case				:			List[Any]       			=    image_size
					__snake_case				:			int       			=    spectrogram_length
					__snake_case				:			Optional[int]       			=    frequency_length
					__snake_case				:			int       			=    image_patch_size
					__snake_case				:			Union[str, Any]       			=    audio_patch_size
					__snake_case				:			Any       			=    num_image_channels
					__snake_case				:			Tuple       			=    num_audio_channels
					__snake_case				:			List[Any]       			=    num_frames

					__snake_case				:			List[Any]       			=    hidden_size
					__snake_case				:			Optional[int]       			=    num_hidden_layers
					__snake_case				:			Any       			=    num_attention_heads
					__snake_case				:			Optional[Any]       			=    intermediate_size
					__snake_case				:			str       			=    hidden_act
					__snake_case				:			Any       			=    hidden_dropout_prob
					__snake_case				:			List[str]       			=    attention_probs_dropout_prob
					__snake_case				:			int       			=    initializer_range
					__snake_case				:			str       			=    layer_norm_eps
					__snake_case				:			int       			=    qkv_bias
					__snake_case				:			Optional[Any]       			=    use_mean_pooling

					__snake_case				:			Any       			=    decoder_num_attention_heads
					__snake_case				:			List[str]       			=    decoder_hidden_size
					__snake_case				:			Any       			=    decoder_num_hidden_layers
					__snake_case				:			Tuple       			=    decoder_intermediate_size
					__snake_case				:			Optional[Any]       			=    pixel_mask_ratio
					__snake_case				:			Any       			=    audio_mask_ratio
					__snake_case				:			List[str]       			=    audio_mask_type

					__snake_case				:			Dict       			=    task_matching
					__snake_case				:			Union[str, Any]       			=    task_mae
					__snake_case				:			Optional[int]       			=    loss_type









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



			"""simple docstring"""


			__snake_case				:			str       			=    """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 				_a	(					)   ->							VivitConfig:



			"""simple docstring"""


			__snake_case				:			str       			=    VivitConfig()

			__snake_case				:			int       			=    400
			__snake_case				:			str       			=    """huggingface/label-files"""
			__snake_case				:			Any       			=    """kinetics400-id2label.json"""

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







def 				_a	(					)   ->							Any:



			"""simple docstring"""


			__snake_case				:			Any       			=    hf_hub_download(
			    repo_id="""hf-internal-testing/spaghetti-video"""						,  filename="""eating_spaghetti_32_frames.npy"""						,  repo_type="""dataset"""   )
			__snake_case				:			Any       			=    np.load(_lowerCamelCase   )
			return list(_lowerCamelCase   )







def 				_a	(					_lowerCamelCase   )   ->							Union[str, Any]:



			"""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 				_a	(					_lowerCamelCase   )   ->							Any:



			"""simple docstring"""


			return current.flatten()







def 				_a	(					_lowerCamelCase   )   ->							Optional[int]:



			"""simple docstring"""


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







def 				_a	(					_lowerCamelCase   )   ->							int:



			"""simple docstring"""


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







def 				_a	(					_lowerCamelCase						,  _lowerCamelCase   )   ->							Dict:



			"""simple docstring"""


			__snake_case				:			Optional[Any]       			=    state_dict["""optimizer"""]["""target"""]["""Transformer"""][F'''encoderblock_{i}''']

			__snake_case				:			str       			=    F'''encoder.layer.{i}.'''
			__snake_case				:			Optional[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 				_a	(					_lowerCamelCase   )   ->							List[Any]:



			"""simple docstring"""


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







def 				_a	(					_lowerCamelCase						,  _lowerCamelCase=False   )   ->							str:



			"""simple docstring"""


			__snake_case				:			Optional[int]       			=    get_n_layers(_lowerCamelCase   )

			__snake_case				:			Optional[Any]       			=    OrderedDict()

			__snake_case				:			Tuple       			=    state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""encoder_norm"""]["""bias"""]
			__snake_case				:			str       			=    state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""encoder_norm"""]["""scale"""]

			__snake_case				:			Optional[Any]       			=    np.transpose(
			    state_dict["""optimizer"""]["""target"""]["""embedding"""]["""kernel"""]						,  (4, 3, 0, 1, 2)   )
			__snake_case				:			Tuple       			=    state_dict["""optimizer"""]["""target"""]["""embedding"""]["""bias"""]

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

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







def 				_a	(					)   ->							VivitImageProcessor:



			"""simple docstring"""


			__snake_case				:			Optional[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 				_a	(					_lowerCamelCase   )   ->							Optional[int]:



			"""simple docstring"""


			__snake_case				:			Optional[int]       			=    """checkpoint"""

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

			__snake_case				:			int       			=    restore_checkpoint(_lowerCamelCase						,  _lowerCamelCase   )
			__snake_case				:			Union[str, Any]       			=    transform_state(_lowerCamelCase						,  classification_head=_lowerCamelCase   )

			__snake_case				:			Optional[Any]       			=    get_vivit_config()

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

			__snake_case				:			List[Any]       			=    VivitForVideoClassification(_lowerCamelCase   )
			model.load_state_dict(_lowerCamelCase   )
			model.eval()

			__snake_case				:			int       			=    get_processor()

			__snake_case				:			int       			=    prepare_video()
			__snake_case				:			List[str]       			=    extractor(_lowerCamelCase						,  return_tensors="""pt"""   )

			__snake_case				:			Optional[int]       			=    model(**_lowerCamelCase   )

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

			model.save_pretrained(_lowerCamelCase   )
			extractor.save_pretrained(_lowerCamelCase   )


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

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

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


