



"""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      (			_A							):




     """simple docstring"""
     snake_case_						:Dict								=						"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_048							):
                    f.write(_A							)
def      A      (			):




     """simple docstring"""
     snake_case_						:str								=						VivitConfig()

     snake_case_						:Union[str, Any]								=						400
     snake_case_						:Union[str, Any]								=						"huggingface/label-files"
     snake_case_						:int								=						"kinetics400-id2label.json"

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




     """simple docstring"""
     snake_case_						:Optional[int]								=						hf_hub_download(
         repo_id="hf-internal-testing/spaghetti-video",     filename="eating_spaghetti_32_frames.npy",     repo_type="dataset"							)
     snake_case_						:Union[str, Any]								=						np.load(_A							)
     return list(_A							)
def      A      (			_A							):




     """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      A      (			_A							):




     """simple docstring"""
     return current.flatten()
def      A      (			_A							):




     """simple docstring"""
     return np.reshape(_A,     (current.shape[0], current.shape[1] * current.shape[2])							).T
def      A      (			_A							):




     """simple docstring"""
     return np.reshape(_A,     (current.shape[0] * current.shape[1], current.shape[2])							).T
def      A      (			_A,     _A							):




     """simple docstring"""
     snake_case_						:Union[str, Any]								=						state_dict["optimizer"]["target"]["Transformer"][F'''encoderblock_{i}''']

     snake_case_						:Any								=						F'''encoder.layer.{i}.'''
     snake_case_						:List[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      (			_A							):




     """simple docstring"""
     return sum([1 if "encoderblock_" in k else 0 for k in state_dict["optimizer"]["target"]["Transformer"].keys()]							)
def      A      (			_A,     _A=False							):




     """simple docstring"""
     snake_case_						:str								=						get_n_layers(_A							)

     snake_case_						:int								=						OrderedDict()

     snake_case_						:str								=						state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["bias"]
     snake_case_						:int								=						state_dict["optimizer"]["target"]["Transformer"]["encoder_norm"]["scale"]

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

     snake_case_						:Dict								=						state_dict["optimizer"]["target"]["cls"]
     snake_case_						:List[str]								=						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:
          snake_case_						:Optional[int]								=						{"vivit." + k: v for k, v in new_state.items()}
          snake_case_						:List[str]								=						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(_A							) for k, v in new_state.items()}
def      A      (			):




     """simple docstring"""
     snake_case_						: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      (			_A							):




     """simple docstring"""
     snake_case_						:Optional[Any]								=						"checkpoint"

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

     snake_case_						:Any								=						restore_checkpoint(_A,     _A							)
     snake_case_						:str								=						transform_state(_A,     classification_head=_A							)

     snake_case_						:Union[str, Any]								=						get_vivit_config()

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

     snake_case_						:Union[str, Any]								=						VivitForVideoClassification(_A							)
     model.load_state_dict(_A							)
     model.eval()

     snake_case_						:Optional[Any]								=						get_processor()

     snake_case_						:Union[str, Any]								=						prepare_video()
     snake_case_						:Dict								=						extractor(_A,     return_tensors="pt"							)

     snake_case_						:List[str]								=						model(**_A							)

     snake_case_						:int								=						torch.Size([1, 400]							)
     snake_case_						:Tuple								=						torch.tensor([-1.0_543, 2.0_764, -0.2_104, 0.4_439, -0.9_658]							)

     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__":
    __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)






"""simple docstring"""






import warnings
from typing import List, Optional, Union

import numpy as np
import PIL
import torch
from PIL import Image

from .configuration_utils import ConfigMixin, register_to_config
from .utils import CONFIG_NAME, PIL_INTERPOLATION, deprecate

class 	__lowerCAmelCase							(__UpperCamelCase  ):


					'''simple docstring'''


					a__        =     CONFIG_NAME







					@register_to_config
					def __init__(      self    ,       a = True    ,       a = 8    ,       a = "lanczos"    ,       a = True    ,       a = False    ,       ):




										"""simple docstring"""





										super().__init__()







					@staticmethod
					def 		_a (      a   ):




										"""simple docstring"""





										if images.ndim == 3:
															snake_case_						:Union[str, Any]								=						images[None, ...]
										snake_case_						:Optional[int]								=						(images * 2_55).round().astype("uint8"   )
										if images.shape[-1] == 1:
															# special case for grayscale (single channel) images
															snake_case_						:List[str]								=						[Image.fromarray(image.squeeze()    ,       mode="L"   ) for image in images]
										else:
															snake_case_						:str								=						[Image.fromarray(a   ) for image in images]

										return pil_images







					@staticmethod
					def 		_a (      a   ):




										"""simple docstring"""





										if not isinstance(a    ,       a   ):
															snake_case_						:Dict								=						[images]
										snake_case_						:Optional[int]								=						[np.array(a   ).astype(np.floataa   ) / 255.0 for image in images]
										snake_case_						:Optional[int]								=						np.stack(a    ,       axis=0   )

										return images







					@staticmethod
					def 		_a (      a   ):




										"""simple docstring"""





										if images.ndim == 3:
															snake_case_						:int								=						images[..., None]

										snake_case_						:str								=						torch.from_numpy(images.transpose(0    ,       3    ,       1    ,       2   )   )
										return images







					@staticmethod
					def 		_a (      a   ):




										"""simple docstring"""





										snake_case_						:str								=						images.cpu().permute(0    ,       2    ,       3    ,       1   ).float().numpy()
										return images







					@staticmethod
					def 		_a (      a   ):




										"""simple docstring"""





										return 2.0 * images - 1.0







					@staticmethod
					def 		_a (      a   ):




										"""simple docstring"""





										return (images / 2 + 0.5).clamp(0    ,       1   )







					@staticmethod
					def 		_a (      a   ):




										"""simple docstring"""





										snake_case_						:List[str]								=						image.convert("RGB"   )
										return image







					def 		_a (      self    ,       a    ,       a = None    ,       a = None    ,       ):




										"""simple docstring"""





										if height is None:
															snake_case_						:Optional[Any]								=						image.height
										if width is None:
															snake_case_						:Dict								=						image.width

										snake_case_	,  snake_case_						:Optional[Any]								=						(
										    x - x % self.config.vae_scale_factor for x in (width, height)
										)  # resize to integer multiple of vae_scale_factor
										snake_case_						:Any								=						image.resize((width, height)    ,       resample=PIL_INTERPOLATION[self.config.resample]   )
										return image







					def 		_a (      self    ,       a    ,       a = None    ,       a = None    ,       ):




										"""simple docstring"""





										snake_case_						:Optional[Any]								=						(PIL.Image.Image, np.ndarray, torch.Tensor)
										if isinstance(a    ,       a   ):
															snake_case_						:str								=						[image]
										elif not (isinstance(a    ,       a   ) and all(isinstance(a    ,       a   ) for i in image   )):
															raise ValueError(
															    F'''Input is in incorrect format: {[type(a   ) for i in image]}. Currently, we only support {', '.join(a   )}'''   )

										if isinstance(image[0]    ,       PIL.Image.Image   ):
															if self.config.do_convert_rgb:
																				snake_case_						:int								=						[self.convert_to_rgb(a   ) for i in image]
															if self.config.do_resize:
																				snake_case_						:Tuple								=						[self.resize(a    ,       a    ,       a   ) for i in image]
															snake_case_						:Dict								=						self.pil_to_numpy(a   )  # to np
															snake_case_						:int								=						self.numpy_to_pt(a   )  # to pt

										elif isinstance(image[0]    ,       np.ndarray   ):
															snake_case_						:Optional[Any]								=						np.concatenate(a    ,       axis=0   ) if image[0].ndim == 4 else np.stack(a    ,       axis=0   )
															snake_case_						:List[Any]								=						self.numpy_to_pt(a   )
															snake_case_	,  snake_case_	,  snake_case_	,  snake_case_						:Optional[int]								=						image.shape
															if self.config.do_resize and (
															    height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
															):
																				raise ValueError(
																				    F'''Currently we only support resizing for PIL image - please resize your numpy array to be divisible by {self.config.vae_scale_factor}'''
																				    F'''currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'''   )

										elif isinstance(image[0]    ,       torch.Tensor   ):
															snake_case_						:Optional[Any]								=						torch.cat(a    ,       axis=0   ) if image[0].ndim == 4 else torch.stack(a    ,       axis=0   )
															snake_case_	,  snake_case_	,  snake_case_	,  snake_case_						:int								=						image.shape

															# don't need any preprocess if the image is latents
															if channel == 4:
																				return image

															if self.config.do_resize and (
															    height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
															):
																				raise ValueError(
																				    F'''Currently we only support resizing for PIL image - please resize your pytorch tensor to be divisible by {self.config.vae_scale_factor}'''
																				    F'''currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'''   )

        # expected range [0,1], normalize to [-1,1]
										snake_case_						:Union[str, Any]								=						self.config.do_normalize
										if image.min() < 0:
															warnings.warn(
															    "Passing `image` as torch tensor with value range in [-1,1] is deprecated. The expected value range for image tensor is [0,1] "
															    F'''when passing as pytorch tensor or numpy Array. You passed `image` with value range [{image.min()},{image.max()}]'''    ,       a    ,       )
															snake_case_						:Optional[int]								=						False

										if do_normalize:
															snake_case_						:Tuple								=						self.normalize(a   )

										return image







					def 		_a (      self    ,       a    ,       a = "pil"    ,       a = None    ,       ):




										"""simple docstring"""





										if not isinstance(a    ,       torch.Tensor   ):
															raise ValueError(
															    F'''Input for postprocessing is in incorrect format: {type(a   )}. We only support pytorch tensor'''   )
										if output_type not in ["latent", "pt", "np", "pil"]:
															snake_case_						:List[Any]								=						(
															    F'''the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '''
															    "`pil`, `np`, `pt`, `latent`"
															)
															deprecate("Unsupported output_type"    ,       "1.0.0"    ,       a    ,       standard_warn=a   )
															snake_case_						:Dict								=						"np"

										if output_type == "latent":
															return image

										if do_denormalize is None:
															snake_case_						:List[Any]								=						[self.config.do_normalize] * image.shape[0]

										snake_case_						:Any								=						torch.stack(
										    [self.denormalize(image[i]   ) if do_denormalize[i] else image[i] for i in range(image.shape[0]   )]   )

										if output_type == "pt":
															return image

										snake_case_						:int								=						self.pt_to_numpy(a   )

										if output_type == "np":
															return image

										if output_type == "pil":
															return self.numpy_to_pil(a   )



class 	__lowerCAmelCase							(__UpperCamelCase  ):


					'''simple docstring'''


					a__        =     CONFIG_NAME







					@register_to_config
					def __init__(      self    ,       a = True    ,       a = 8    ,       a = "lanczos"    ,       a = True    ,       ):




										"""simple docstring"""





										super().__init__()







					@staticmethod
					def 		_a (      a   ):




										"""simple docstring"""





										if images.ndim == 3:
															snake_case_						:List[Any]								=						images[None, ...]
										snake_case_						:Optional[int]								=						(images * 2_55).round().astype("uint8"   )
										if images.shape[-1] == 1:
															# special case for grayscale (single channel) images
															snake_case_						:str								=						[Image.fromarray(image.squeeze()    ,       mode="L"   ) for image in images]
										else:
															snake_case_						:Any								=						[Image.fromarray(image[:, :, :3]   ) for image in images]

										return pil_images







					@staticmethod
					def 		_a (      a   ):




										"""simple docstring"""





										return image[:, :, 1] * 2**8 + image[:, :, 2]







					def 		_a (      self    ,       a   ):




										"""simple docstring"""





										if images.ndim == 3:
															snake_case_						:Optional[int]								=						images[None, ...]
										snake_case_						:Union[str, Any]								=						images[:, :, :, 3:]
										if images.shape[-1] == 6:
															snake_case_						:Tuple								=						(images_depth * 2_55).round().astype("uint8"   )
															snake_case_						:Optional[Any]								=						[
															    Image.fromarray(self.rgblike_to_depthmap(a   )    ,       mode="I;16"   ) for image_depth in images_depth
															]
										elif images.shape[-1] == 4:
															snake_case_						:Optional[Any]								=						(images_depth * 65535.0).astype(np.uintaa   )
															snake_case_						:List[Any]								=						[Image.fromarray(a    ,       mode="I;16"   ) for image_depth in images_depth]
										else:
															raise Exception("Not supported"   )

										return pil_images







					def 		_a (      self    ,       a    ,       a = "pil"    ,       a = None    ,       ):




										"""simple docstring"""





										if not isinstance(a    ,       torch.Tensor   ):
															raise ValueError(
															    F'''Input for postprocessing is in incorrect format: {type(a   )}. We only support pytorch tensor'''   )
										if output_type not in ["latent", "pt", "np", "pil"]:
															snake_case_						:Any								=						(
															    F'''the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '''
															    "`pil`, `np`, `pt`, `latent`"
															)
															deprecate("Unsupported output_type"    ,       "1.0.0"    ,       a    ,       standard_warn=a   )
															snake_case_						:Optional[Any]								=						"np"

										if do_denormalize is None:
															snake_case_						:Any								=						[self.config.do_normalize] * image.shape[0]

										snake_case_						:Tuple								=						torch.stack(
										    [self.denormalize(image[i]   ) if do_denormalize[i] else image[i] for i in range(image.shape[0]   )]   )

										snake_case_						:List[str]								=						self.pt_to_numpy(a   )

										if output_type == "np":
															if image.shape[-1] == 6:
																				snake_case_						:Optional[int]								=						np.stack([self.rgblike_to_depthmap(im[:, :, 3:]   ) for im in image]    ,       axis=0   )
															else:
																				snake_case_						:Any								=						image[:, :, :, 3:]
															return image[:, :, :, :3], image_depth

										if output_type == "pil":
															return self.numpy_to_pil(a   ), self.numpy_to_depth(a   )
										else:
															raise Exception(F'''This type {output_type} is not supported'''   )

