

"""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_	:       Dict      ):
     A__				      =	"""https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint"""

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





def 			_snake_case  (     ):
     A__				      =	VivitConfig()

     A__				      =	400
     A__				      =	"""huggingface/label-files"""
     A__				      =	"""kinetics400-id2label.json"""

     A__				      =	json.load(open(hf_hub_download(lowercase_       , lowercase_       , repo_type="""dataset"""      )       , """r"""      )      )
     A__				      =	{int(lowercase_      ): v for k, v in idalabel.items()}
     A__				      =	idalabel
     A__				      =	{v: k for k, v in idalabel.items()}
     return config





def 			_snake_case  (     ):
     A__				      =	hf_hub_download(
         repo_id="""hf-internal-testing/spaghetti-video"""       , filename="""eating_spaghetti_32_frames.npy"""       , repo_type="""dataset"""      )
     A__				      =	np.load(lowercase_      )
     return list(lowercase_      )





def 			_snake_case  (     UpperCAmelCase_	:       List[Any]      ):





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

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

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





def 			_snake_case  (     UpperCAmelCase_	:       List[Any]      ):
     return current.flatten()





def 			_snake_case  (     UpperCAmelCase_	:       str      ):
     return np.reshape(lowercase_       , (current.shape[0], current.shape[1] * current.shape[2])      ).T





def 			_snake_case  (     UpperCAmelCase_	:       Dict      ):
     return np.reshape(lowercase_       , (current.shape[0] * current.shape[1], current.shape[2])      ).T





def 			_snake_case  (     UpperCAmelCase_	:       Optional[Any]       , UpperCAmelCase_	:       Dict      ):
     A__				      =	state_dict["""optimizer"""]["""target"""]["""Transformer"""][F"""encoderblock_{i}"""]

     A__				      =	F"""encoder.layer.{i}."""
     A__				      =	{
         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_	:       Optional[Any]      ):
     return sum([1 if """encoderblock_""" in k else 0 for k in state_dict["""optimizer"""]["""target"""]["""Transformer"""].keys()]      )





def 			_snake_case  (     UpperCAmelCase_	:       Tuple       , UpperCAmelCase_	:       int=False      ):
     A__				      =	get_n_layers(lowercase_      )

     A__				      =	OrderedDict()

     A__				      =	state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""encoder_norm"""]["""bias"""]
     A__				      =	state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""encoder_norm"""]["""scale"""]

     A__				      =	np.transpose(
         state_dict["""optimizer"""]["""target"""]["""embedding"""]["""kernel"""]       , (4, 3, 0, 1, 2)      )
     A__				      =	state_dict["""optimizer"""]["""target"""]["""embedding"""]["""bias"""]

     A__				      =	state_dict["""optimizer"""]["""target"""]["""cls"""]
     A__				      =	state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""posembed_input"""][
         """pos_embedding"""
     ]

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

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

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





def 			_snake_case  (     ):
     A__				      =	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 			_snake_case  (     UpperCAmelCase_	:       List[Any]      ):
     A__				      =	"""checkpoint"""

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

     A__				      =	restore_checkpoint(lowercase_       , lowercase_      )
     A__				      =	transform_state(lowercase_       , classification_head=lowercase_      )

     A__				      =	get_vivit_config()

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

     A__				      =	VivitForVideoClassification(lowercase_      )
     model.load_state_dict(lowercase_      )
     model.eval()

     A__				      =	get_processor()

     A__				      =	prepare_video()
     A__				      =	extractor(lowercase_       , return_tensors="""pt"""      )

     A__				      =	model(**lowercase_      )

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

     model.save_pretrained(lowercase_      )
     extractor.save_pretrained(lowercase_      )


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

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

 SCREAMING_SNAKE_CASE_       :						Any					=    parser.parse_args()
 convert(args.output_model_name)









def   UpperCamelCase(   lowercase_				)      ->							float:





  '''simple docstring'''





  return -num if num < 0 else num



def   UpperCamelCase(   lowercase_				)      ->							int:





  '''simple docstring'''





  if len(lowercase_				) == 0:
    raise ValueError("""abs_min() arg is an empty sequence"""				)
  snake_case_					= x[0]
  for i in x:
    if abs_val(lowercase_				) < abs_val(lowercase_				):
      snake_case_					= i
  return j



def   UpperCamelCase(   lowercase_				)      ->							int:





  '''simple docstring'''





  if len(lowercase_				) == 0:
    raise ValueError("""abs_max() arg is an empty sequence"""				)
  snake_case_					= x[0]
  for i in x:
    if abs(lowercase_				) > abs(lowercase_				):
      snake_case_					= i
  return j



def   UpperCamelCase(   lowercase_				)      ->							int:





  '''simple docstring'''





  if len(lowercase_				) == 0:
    raise ValueError("""abs_max_sort() arg is an empty sequence"""				)
  return sorted(lowercase_     ,   key=lowercase_				)[-1]



def   UpperCamelCase(   )      ->							List[Any]:





  '''simple docstring'''





  assert abs_val(0				) == 0
  assert abs_val(34				) == 34
  assert abs_val(-100000000000				) == 100000000000

  snake_case_					= [-3, -1, 2, -11]
  assert abs_max(lowercase_				) == -11
  assert abs_max_sort(lowercase_				) == -11
  assert abs_min(lowercase_				) == -1


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    test_abs_val()
    print(abs_val(-34))  # --> 34