code: 
  '''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 						snake_case__	(      UpperCamelCase	) ->      Tuple:
  		_UpperCamelCase       : Optional[int]    =      "https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint"
  
  		with open(UpperCamelCase			,'''wb'''	) as f:
  				with requests.get(UpperCamelCase			,stream=UpperCamelCase	) as req:
  						for chunk in req.iter_content(chunk_size=20_48	):
  								f.write(UpperCamelCase	)
  
  
  
  
  
  
  
  def 						snake_case__	(      ) ->      VivitConfig:
  		_UpperCamelCase       : int    =      VivitConfig()
  
  		_UpperCamelCase       : int    =      4_00
  		_UpperCamelCase       : Tuple    =      "huggingface/label-files"
  		_UpperCamelCase       : List[str]    =      "kinetics400-id2label.json"
  
  		_UpperCamelCase       : Any    =      json.load(open(hf_hub_download(UpperCamelCase			,UpperCamelCase			,repo_type='''dataset'''	)			,'''r'''	)	)
  		_UpperCamelCase       : Optional[Any]    =      {int(UpperCamelCase	): v for k, v in idalabel.items()}
  		_UpperCamelCase       : List[Any]    =      idalabel
  		_UpperCamelCase       : str    =      {v: k for k, v in idalabel.items()}
  		return config
  
  
  
  
  
  
  
  def 						snake_case__	(      ) ->      Union[str, Any]:
  		_UpperCamelCase       : Union[str, Any]    =      hf_hub_download(
  		    repo_id='''hf-internal-testing/spaghetti-video'''			,filename='''eating_spaghetti_32_frames.npy'''			,repo_type='''dataset'''	)
  		_UpperCamelCase       : str    =      np.load(UpperCamelCase	)
  		return list(UpperCamelCase	)
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase	) ->      Any:
  		if np.ndim(UpperCamelCase	) == 2:
  				return transform_attention_bias(UpperCamelCase	)
  
  		elif np.ndim(UpperCamelCase	) == 3:
  				return transform_attention_kernel(UpperCamelCase	)
  
  		else:
  				raise Exception(f'''Invalid number of dimesions: {np.ndim(UpperCamelCase	)}'''	)
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase	) ->      Optional[Any]:
  		return current.flatten()
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase	) ->      Any:
  		return np.reshape(UpperCamelCase			,(current.shape[0], current.shape[1] * current.shape[2])	).T
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase	) ->      str:
  		return np.reshape(UpperCamelCase			,(current.shape[0] * current.shape[1], current.shape[2])	).T
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase			,UpperCamelCase	) ->      Optional[Any]:
  		_UpperCamelCase       : Dict    =      state_dict["optimizer"]["target"]["Transformer"][f'''encoderblock_{i}''']
  
  		_UpperCamelCase       : Optional[int]    =      f'''encoder.layer.{i}.'''
  		_UpperCamelCase       : str    =      {
  		    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 						snake_case__	(      UpperCamelCase	) ->      str:
  		return sum([1 if '''encoderblock_''' in k else 0 for k in state_dict['''optimizer''']['''target''']['''Transformer'''].keys()]	)
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase			,UpperCamelCase=False	) ->      int:
  		_UpperCamelCase       : Union[str, Any]    =      get_n_layers(UpperCamelCase	)
  
  		_UpperCamelCase       : Optional[Any]    =      OrderedDict()
  
  		_UpperCamelCase       : Union[str, Any]    =      state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["bias"]
  		_UpperCamelCase       : Dict    =      state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["scale"]
  
  		_UpperCamelCase       : Optional[int]    =      np.transpose(
  		    state_dict['''optimizer''']['''target''']['''embedding''']['''kernel''']			,(4, 3, 0, 1, 2)	)
  		_UpperCamelCase       : Dict    =      state_dict["optimizer"]["target"]["embedding"]["bias"]
  
  		_UpperCamelCase       : List[Any]    =      state_dict["optimizer"]["target"]["cls"]
  		_UpperCamelCase       : Optional[int]    =      state_dict["optimizer"]["target"]["Transformer"]["posembed_input"][
  		    "pos_embedding"
  		]
  
  		for i in range(UpperCamelCase	):
  				new_state.update(transform_state_encoder_block(UpperCamelCase			,UpperCamelCase	)	)
  
  		if classification_head:
  				_UpperCamelCase       : Optional[int]    =      {"vivit." + k: v for k, v in new_state.items()}
  				_UpperCamelCase       : List[str]    =      np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''kernel''']	)
  				_UpperCamelCase       : Union[str, Any]    =      np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''bias''']	)
  
  		return {k: torch.tensor(UpperCamelCase	) for k, v in new_state.items()}
  
  
  
  
  
  
  
  def 						snake_case__	(      ) ->      VivitImageProcessor:
  		_UpperCamelCase       : Any    =      VivitImageProcessor()
  
  		assert extractor.do_resize is True
  		assert extractor.size == {"shortest_edge": 2_56}
  		assert extractor.do_center_crop is True
  		assert extractor.crop_size == {"width": 2_24, "height": 2_24}
  		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_55
  
  		# zero-centering = True in original implementation
  		assert extractor.do_zero_centering is True
  
  		return extractor
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase	) ->      str:
  		_UpperCamelCase       : Optional[Any]    =      "checkpoint"
  
  		if not os.path.exists(UpperCamelCase	):
  				download_checkpoint(UpperCamelCase	)
  
  		_UpperCamelCase       : List[str]    =      restore_checkpoint(UpperCamelCase			,UpperCamelCase	)
  		_UpperCamelCase       : List[Any]    =      transform_state(UpperCamelCase			,classification_head=UpperCamelCase	)
  
  		_UpperCamelCase       : str    =      get_vivit_config()
  
  		assert config.image_size == 2_24
  		assert config.num_frames == 32
  
  		_UpperCamelCase       : str    =      VivitForVideoClassification(UpperCamelCase	)
  		model.load_state_dict(UpperCamelCase	)
  		model.eval()
  
  		_UpperCamelCase       : Union[str, Any]    =      get_processor()
  
  		_UpperCamelCase       : Optional[int]    =      prepare_video()
  		_UpperCamelCase       : List[Any]    =      extractor(UpperCamelCase			,return_tensors='''pt'''	)
  
  		_UpperCamelCase       : Tuple    =      model(**UpperCamelCase	)
  
  		_UpperCamelCase       : Dict    =      torch.Size([1, 4_00]	)
  		_UpperCamelCase       : Any    =      torch.tensor([-1.0543, 2.0764, -0.2104, 0.4439, -0.9658]	)
  
  		assert outputs.logits.shape == expected_shape
  		assert torch.allclose(outputs.logits[0, :5]			,UpperCamelCase			,atol=1e-4	), outputs.logits[0, :5]
  
  		model.save_pretrained(UpperCamelCase	)
  		extractor.save_pretrained(UpperCamelCase	)
  
  
  if __name__ == "__main__":
  	_UpperCAmelCase   :      List[Any] 						=  argparse.ArgumentParser()
  
  	parser.add_argument("""--output_model_name""", """-o""", type=str, help="""Output path for the converted HuggingFace model""")
  
  	_UpperCAmelCase   :      Tuple 						=  parser.parse_args()
  	convert(args.output_model_name)
  
  
style_context: 
  '''simple docstring'''
  
  from collections import OrderedDict
  from typing import Mapping
  
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfig
  from ...utils import logging
  
  
  _UpperCAmelCase   :      List[Any] 						=  logging.get_logger(__name__)
  
  _UpperCAmelCase   :      List[Any] 						=  {
      """nghuyong/ernie-1.0-base-zh""": """https://huggingface.co/nghuyong/ernie-1.0-base-zh/resolve/main/config.json""",
      """nghuyong/ernie-2.0-base-en""": """https://huggingface.co/nghuyong/ernie-2.0-base-en/resolve/main/config.json""",
      """nghuyong/ernie-2.0-large-en""": """https://huggingface.co/nghuyong/ernie-2.0-large-en/resolve/main/config.json""",
      """nghuyong/ernie-3.0-base-zh""": """https://huggingface.co/nghuyong/ernie-3.0-base-zh/resolve/main/config.json""",
      """nghuyong/ernie-3.0-medium-zh""": """https://huggingface.co/nghuyong/ernie-3.0-medium-zh/resolve/main/config.json""",
      """nghuyong/ernie-3.0-mini-zh""": """https://huggingface.co/nghuyong/ernie-3.0-mini-zh/resolve/main/config.json""",
      """nghuyong/ernie-3.0-micro-zh""": """https://huggingface.co/nghuyong/ernie-3.0-micro-zh/resolve/main/config.json""",
      """nghuyong/ernie-3.0-nano-zh""": """https://huggingface.co/nghuyong/ernie-3.0-nano-zh/resolve/main/config.json""",
      """nghuyong/ernie-gram-zh""": """https://huggingface.co/nghuyong/ernie-gram-zh/resolve/main/config.json""",
      """nghuyong/ernie-health-zh""": """https://huggingface.co/nghuyong/ernie-health-zh/resolve/main/config.json""",
  }
  
  class 			UpperCAmelCase				(					a_ ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		A__  :   str          =    'ernie'
  		def __init__(    self  ,					_snake_case=30522  ,					_snake_case=768  ,					_snake_case=12  ,					_snake_case=12  ,					_snake_case=3072  ,					_snake_case="gelu"  ,					_snake_case=0.1  ,					_snake_case=0.1  ,					_snake_case=512  ,					_snake_case=2  ,					_snake_case=3  ,					_snake_case=False  ,					_snake_case=0.02  ,					_snake_case=1E-12  ,					_snake_case=0  ,					_snake_case="absolute"  ,					_snake_case=True  ,					_snake_case=None  ,					**_snake_case  ,					)				->    List[Any]:
  				super().__init__(pad_token_id=_snake_case  ,					**_snake_case     )
  
  				_UpperCamelCase       : Dict    =      vocab_size
  				_UpperCamelCase       : int    =      hidden_size
  				_UpperCamelCase       : List[Any]    =      num_hidden_layers
  				_UpperCamelCase       : Tuple    =      num_attention_heads
  				_UpperCamelCase       : List[str]    =      hidden_act
  				_UpperCamelCase       : Optional[int]    =      intermediate_size
  				_UpperCamelCase       : Tuple    =      hidden_dropout_prob
  				_UpperCamelCase       : Optional[int]    =      attention_probs_dropout_prob
  				_UpperCamelCase       : List[str]    =      max_position_embeddings
  				_UpperCamelCase       : Tuple    =      type_vocab_size
  				_UpperCamelCase       : Union[str, Any]    =      task_type_vocab_size
  				_UpperCamelCase       : Union[str, Any]    =      use_task_id
  				_UpperCamelCase       : Any    =      initializer_range
  				_UpperCamelCase       : Optional[int]    =      layer_norm_eps
  				_UpperCamelCase       : str    =      position_embedding_type
  				_UpperCamelCase       : Any    =      use_cache
  				_UpperCamelCase       : str    =      classifier_dropout
  
  
  
  
  
  
  
  class 			UpperCAmelCase				(					a_ ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		@property
  		def _lowercase  (    self     )				->    Mapping[str, Mapping[int, str]]:
  				if self.task == "multiple-choice":
  						_UpperCamelCase       : str    =      {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
  				else:
  						_UpperCamelCase       : Dict    =      {0: '''batch''', 1: '''sequence'''}
  				return OrderedDict(
  				    [
  				        ('''input_ids''', dynamic_axis),
  				        ('''attention_mask''', dynamic_axis),
  				        ('''token_type_ids''', dynamic_axis),
  				        ('''task_type_ids''', dynamic_axis),
  				    ]     )
  
  
  
  
  
  