




'''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    (       UpperCAmelCase_						):
    _a				:							Any							       =      """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=2_048						):
                f.write(UpperCAmelCase_						)





def UpperCAmelCase    (       ):
    _a				:							Optional[int]							       =      VivitConfig()

    _a				:							Optional[int]							       =      400
    _a				:							Optional[Any]							       =      """huggingface/label-files"""
    _a				:							int							       =      """kinetics400-id2label.json"""

    _a				:							Any							       =      json.load(open(hf_hub_download(UpperCAmelCase_   ,	UpperCAmelCase_   ,	repo_type="""dataset"""						)   ,	"""r"""						)						)
    _a				:							List[Any]							       =      {int(UpperCAmelCase_						): v for k, v in idalabel.items()}
    _a				:							Union[str, Any]							       =      idalabel
    _a				:							int							       =      {v: k for k, v in idalabel.items()}
    return config





def UpperCAmelCase    (       ):
    _a				:							int							       =      hf_hub_download(
        repo_id="""hf-internal-testing/spaghetti-video"""   ,	filename="""eating_spaghetti_32_frames.npy"""   ,	repo_type="""dataset"""						)
    _a				:							Optional[int]							       =      np.load(UpperCAmelCase_						)
    return list(UpperCAmelCase_						)





def UpperCAmelCase    (       UpperCAmelCase_						):
    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 UpperCAmelCase    (       UpperCAmelCase_						):
    return current.flatten()





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





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





def UpperCAmelCase    (       UpperCAmelCase_   ,	UpperCAmelCase_						):
    _a				:							str							       =      state_dict["""optimizer"""]["""target"""]["""Transformer"""][F'''encoderblock_{i}''']

    _a				:							List[str]							       =      F'''encoder.layer.{i}.'''
    _a				:							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 UpperCAmelCase    (       UpperCAmelCase_						):
    return sum([1 if """encoderblock_""" in k else 0 for k in state_dict["""optimizer"""]["""target"""]["""Transformer"""].keys()]						)





def UpperCAmelCase    (       UpperCAmelCase_   ,	UpperCAmelCase_=False						):
    _a				:							Optional[int]							       =      get_n_layers(UpperCAmelCase_						)

    _a				:							Optional[int]							       =      OrderedDict()

    _a				:							str							       =      state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""encoder_norm"""]["""bias"""]
    _a				:							Union[str, Any]							       =      state_dict["""optimizer"""]["""target"""]["""Transformer"""]["""encoder_norm"""]["""scale"""]

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

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

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





def UpperCAmelCase    (       ):
    _a				:							Tuple							       =      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 UpperCAmelCase    (       UpperCAmelCase_						):
    _a				:							Dict							       =      """checkpoint"""

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

    _a				:							Optional[int]							       =      restore_checkpoint(UpperCAmelCase_   ,	UpperCAmelCase_						)
    _a				:							Optional[int]							       =      transform_state(UpperCAmelCase_   ,	classification_head=UpperCAmelCase_						)

    _a				:							Optional[int]							       =      get_vivit_config()

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

    _a				:							Dict							       =      VivitForVideoClassification(UpperCAmelCase_						)
    model.load_state_dict(UpperCAmelCase_						)
    model.eval()

    _a				:							Optional[Any]							       =      get_processor()

    _a				:							Optional[Any]							       =      prepare_video()
    _a				:							Any							       =      extractor(UpperCAmelCase_   ,	return_tensors="""pt"""						)

    _a				:							Tuple							       =      model(**UpperCAmelCase_						)

    _a				:							List[Any]							       =      torch.Size([1, 400]						)
    _a				:							Dict							       =      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__":
  a		:	Optional[int]       =      argparse.ArgumentParser()

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

  a		:	Optional[Any]       =      parser.parse_args()
  convert(args.output_model_name)




'''simple docstring'''
A__ :		dict[str, float]					={
    "kilogram": 1,
    "gram": pow(10, 3),
    "milligram": pow(10, 6),
    "metric-ton": pow(10, -3),
    "long-ton": 0.0_0_0_9_8_4_2_0_7_3,
    "short-ton": 0.0_0_1_1_0_2_3_1_2_2,
    "pound": 2.2_0_4_6_2_4_4_2_0_2,
    "stone": 0.1_5_7_4_7_3_1_7_2_8,
    "ounce": 3_5.2_7_3_9_9_0_7_2_3,
    "carrat": 5_000,
    "atomic-mass-unit": 6.0_2_2_1_3_6_6_5_2E2_6,
}

A__ :		dict[str, float]					={
    "kilogram": 1,
    "gram": pow(10, -3),
    "milligram": pow(10, -6),
    "metric-ton": pow(10, 3),
    "long-ton": 1_0_1_6.0_4_6_0_8,
    "short-ton": 9_0_7.1_8_4,
    "pound": 0.4_5_3_5_9_2,
    "stone": 6.3_5_0_2_9,
    "ounce": 0.0_2_8_3_4_9_5,
    "carrat": 0.0_0_0_2,
    "atomic-mass-unit": 1.6_6_0_5_4_0_1_9_9E-2_7,
}







def 							A_  (    __SCREAMING_SNAKE_CASE    :	str      ,  __SCREAMING_SNAKE_CASE    :	str      ,  __SCREAMING_SNAKE_CASE    :	float			)					->							float:





  """simple docstring"""

  if to_type not in KILOGRAM_CHART or from_type not in WEIGHT_TYPE_CHART:
    __A		:  Tuple       				=		(
        F"Invalid 'from_type' or 'to_type' value: {from_type!r}, {to_type!r}\n"
        F"Supported values are: {', '.join(__SCREAMING_SNAKE_CASE			)}"
    )
    raise ValueError(__SCREAMING_SNAKE_CASE			)
  return value * KILOGRAM_CHART[to_type] * WEIGHT_TYPE_CHART[from_type]


if __name__ == "__main__":
     import doctest

     doctest.testmod()



