



'''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_							(		lowercase__							):


     '''simple docstring'''







     a_									="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=2_0_4_8							):
                    f.write(__A							)






def 			UpperCAmelCase_							(		):


     '''simple docstring'''







     a_									=VivitConfig()

     a_									=4_0_0
     a_									="huggingface/label-files"
     a_									="kinetics400-id2label.json"

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






def 			UpperCAmelCase_							(		):


     '''simple docstring'''







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






def 			UpperCAmelCase_							(		lowercase__							):


     '''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_							(		lowercase__							):


     '''simple docstring'''







     return current.flatten()






def 			UpperCAmelCase_							(		lowercase__							):


     '''simple docstring'''







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






def 			UpperCAmelCase_							(		lowercase__							):


     '''simple docstring'''







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






def 			UpperCAmelCase_							(		lowercase__							,						lowercase__							):


     '''simple docstring'''







     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 			UpperCAmelCase_							(		lowercase__							):


     '''simple docstring'''







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






def 			UpperCAmelCase_							(		lowercase__							,						lowercase__=False							):


     '''simple docstring'''







     a_									=get_n_layers(__A							)

     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(__A							):
          new_state.update(transform_state_encoder_block(__A							,						__A							)							)

     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(__A							) for k, v in new_state.items()}






def 			UpperCAmelCase_							(		):


     '''simple docstring'''







     a_									=VivitImageProcessor()

     assert extractor.do_resize is True
     assert extractor.size == {"shortest_edge": 2_5_6}
     assert extractor.do_center_crop is True
     assert extractor.crop_size == {"width": 2_2_4, "height": 2_2_4}
     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_5_5

     # zero-centering = True in original implementation
     assert extractor.do_zero_centering is True

     return extractor






def 			UpperCAmelCase_							(		lowercase__							):


     '''simple docstring'''







     a_									="checkpoint"

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

     a_									=restore_checkpoint(__A							,						__A							)
     a_									=transform_state(__A							,						classification_head=__A							)

     a_									=get_vivit_config()

     assert config.image_size == 2_2_4
     assert config.num_frames == 3_2

     a_									=VivitForVideoClassification(__A							)
     model.load_state_dict(__A							)
     model.eval()

     a_									=get_processor()

     a_									=prepare_video()
     a_									=extractor(__A							,						return_tensors="pt"							)

     a_									=model(**__A							)

     a_									=torch.Size([1, 4_0_0]							)
     a_									=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]							,						__A							,						atol=1E-4							), outputs.logits[0, :5]

     model.save_pretrained(__A							)
     extractor.save_pretrained(__A							)


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

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

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






'''simple docstring'''







from __future__ import annotations

from collections.abc import Callable
from typing import Generic, TypeVar

a__    :   Dict								=			TypeVar('T')
a__    :   Optional[Any]								=			TypeVar('U')
class    lowercase_	(       Generic[T, U]  ):


    def __init__(	self    ,   a    ,   a       ):
          UpperCamelCase__      =							key
          UpperCamelCase__      =							val
          UpperCamelCase__      =							0
          UpperCamelCase__      =							None
          UpperCamelCase__      =							None


    def __repr__(	self       ):
          return "Node: key: {}, val: {}, freq: {}, has next: {}, has prev: {}".format(
              self.key    ,   self.val    ,   self.freq    ,   self.next is not None    ,   self.prev is not None       )

class    lowercase_	(       Generic[T, U]  ):


    def __init__(	self       ):
          UpperCamelCase__      =							DoubleLinkedListNode(a    ,   a       )
          UpperCamelCase__      =							DoubleLinkedListNode(a    ,   a       )
          UpperCamelCase__   ,      UpperCamelCase__      =							self.rear, self.head


    def __repr__(	self       ):
          UpperCamelCase__      =							["DoubleLinkedList"]
          UpperCamelCase__      =							self.head
          while node.next is not None:
                rep.append(str(a       )       )
                UpperCamelCase__      =							node.next
          rep.append(str(self.rear       )       )
          return ",\n    ".join(a       )


    def   __a				(	self    ,   a       ):
          UpperCamelCase__      =							self.rear.prev

          # All nodes other than self.head are guaranteed to have non-None previous
          assert previous is not None

          UpperCamelCase__      =							node
          UpperCamelCase__      =							previous
          UpperCamelCase__      =							node
          UpperCamelCase__      =							self.rear
          node.freq += 1
          self._position_node(a       )


    def   __a				(	self    ,   a       ):

          while node.prev is not None and node.prev.freq > node.freq:
                # swap node with previous node
                UpperCamelCase__      =							node.prev

                UpperCamelCase__      =							previous_node.prev
                UpperCamelCase__      =							node.prev
                UpperCamelCase__      =							previous_node
                UpperCamelCase__      =							node


    def   __a				(	self    ,   a       ):

          if node.prev is None or node.next is None:
                return None

          UpperCamelCase__      =							node.next
          UpperCamelCase__      =							node.prev
          UpperCamelCase__      =							None
          UpperCamelCase__      =							None
          return node

class    lowercase_	(       Generic[T, U]  ):
    __UpperCAmelCase       =      {}


    def __init__(	self    ,   a       ):
          UpperCamelCase__      =							DoubleLinkedList()
          UpperCamelCase__      =							capacity
          UpperCamelCase__      =							0
          UpperCamelCase__      =							0
          UpperCamelCase__      =							0
          UpperCamelCase__      =							{}


    def __repr__(	self       ):
          return (
              f'''CacheInfo(hits={self.hits}, misses={self.miss}, '''
              f'''capacity={self.capacity}, current_size={self.num_keys})'''
          )


    def __contains__(	self    ,   a       ):
          return key in self.cache


    def   __a				(	self    ,   a       ):

          if key in self.cache:
                self.hits += 1
                UpperCamelCase__      =							self.cache[key]
                UpperCamelCase__      =							self.list.remove(self.cache[key]       )
                assert node == value_node

                # node is guaranteed not None because it is in self.cache
                assert node is not None
                self.list.add(a       )
                return node.val
          self.miss += 1
          return None


    def   __a				(	self    ,   a    ,   a       ):

          if key not in self.cache:
                if self.num_keys >= self.capacity:
                      # delete first node when over capacity
                      UpperCamelCase__      =							self.list.head.next

                      # guaranteed to have a non-None first node when num_keys > 0
                      # explain to type checker via assertions
                      assert first_node is not None
                      assert first_node.key is not None
                      assert self.list.remove(a       ) is not None
                      # first_node guaranteed to be in list

                      del self.cache[first_node.key]
                      self.num_keys -= 1
                UpperCamelCase__      =							DoubleLinkedListNode(a    ,   a       )
                self.list.add(self.cache[key]       )
                self.num_keys += 1

          else:
                UpperCamelCase__      =							self.list.remove(self.cache[key]       )
                assert node is not None  # node guaranteed to be in list
                UpperCamelCase__      =							value
                self.list.add(a       )


    @classmethod
    def   __a				(	cls    ,   a = 1_28       ):

          def cache_decorator_inner(a       ) -> Callable[..., U]:
                def cache_decorator_wrapper(*a       ) -> U:
                      if func not in cls.decorator_function_to_instance_map:
                            UpperCamelCase__      =							LFUCache(a       )

                      UpperCamelCase__      =							cls.decorator_function_to_instance_map[func].get(args[0]       )
                      if result is None:
                            UpperCamelCase__      =							func(*a       )
                            cls.decorator_function_to_instance_map[func].put(args[0]    ,   a       )
                      return result

                def cache_info() -> LFUCache[T, U]:
                      return cls.decorator_function_to_instance_map[func]

                setattr(a    ,   "cache_info"    ,   a       )  # noqa: B010

                return cache_decorator_wrapper

          return cache_decorator_inner


if __name__ == "__main__":
  import doctest

  doctest.testmod()





