






import argparse
import json

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    VideoMAEConfig,
    VideoMAEForPreTraining,
    VideoMAEForVideoClassification,
    VideoMAEImageProcessor,
)






def 				lowerCamelCase__      (    __lowerCamelCase			:     Optional[Any]		):
  __UpperCAmelCase							:	Any           =  VideoMAEConfig()

  set_architecture_configs(__lowerCamelCase  ,		__lowerCamelCase		)

  if "finetuned" not in model_name:
    __UpperCAmelCase							:	str           =  False

  if "finetuned" in model_name:
    __UpperCAmelCase							:	int           =  """huggingface/label-files"""
    if "kinetics" in model_name:
      __UpperCAmelCase							:	Any           =  400
      __UpperCAmelCase							:	Optional[Any]           =  """kinetics400-id2label.json"""
    elif "ssv2" in model_name:
      __UpperCAmelCase							:	Optional[int]           =  174
      __UpperCAmelCase							:	Optional[int]           =  """something-something-v2-id2label.json"""
    else:
      raise ValueError("""Model name should either contain \'kinetics\' or \'ssv2\' in case it\'s fine-tuned."""		)
    __UpperCAmelCase							:	List[str]           =  json.load(open(hf_hub_download(__lowerCamelCase  ,		__lowerCamelCase  ,		repo_type="""dataset"""		)  ,		"""r"""		)		)
    __UpperCAmelCase							:	Tuple           =  {int(__lowerCamelCase		): v for k, v in idalabel.items()}
    __UpperCAmelCase							:	Tuple           =  idalabel
    __UpperCAmelCase							:	List[str]           =  {v: k for k, v in idalabel.items()}

  return config






def 				lowerCamelCase__      (    __lowerCamelCase			:     Union[str, Any]  ,		__lowerCamelCase			:     Any		):

  if "small" in model_name:
    __UpperCAmelCase							:	Optional[Any]           =  384
    __UpperCAmelCase							:	List[str]           =  1536
    __UpperCAmelCase							:	List[Any]           =  12
    __UpperCAmelCase							:	int           =  16
    __UpperCAmelCase							:	Optional[int]           =  12
    __UpperCAmelCase							:	List[str]           =  3
    __UpperCAmelCase							:	Tuple           =  192
    __UpperCAmelCase							:	int           =  768
  elif "large" in model_name:
    __UpperCAmelCase							:	str           =  1024
    __UpperCAmelCase							:	int           =  4096
    __UpperCAmelCase							:	Optional[Any]           =  24
    __UpperCAmelCase							:	str           =  16
    __UpperCAmelCase							:	Dict           =  12
    __UpperCAmelCase							:	List[Any]           =  8
    __UpperCAmelCase							:	Optional[int]           =  512
    __UpperCAmelCase							:	str           =  2048
  elif "huge" in model_name:
    __UpperCAmelCase							:	int           =  1280
    __UpperCAmelCase							:	str           =  5120
    __UpperCAmelCase							:	Union[str, Any]           =  32
    __UpperCAmelCase							:	Union[str, Any]           =  16
    __UpperCAmelCase							:	Tuple           =  12
    __UpperCAmelCase							:	Optional[Any]           =  8
    __UpperCAmelCase							:	Tuple           =  640
    __UpperCAmelCase							:	Tuple           =  2560
  elif "base" not in model_name:
    raise ValueError("""Model name should include either \"small\", \"base\", \"large\", or \"huge\""""		)






def 				lowerCamelCase__      (    __lowerCamelCase			:     int		):

  if "encoder." in name:
    __UpperCAmelCase							:	Optional[Any]           =  name.replace("""encoder."""  ,		""""""		)
  if "cls_token" in name:
    __UpperCAmelCase							:	Tuple           =  name.replace("""cls_token"""  ,		"""videomae.embeddings.cls_token"""		)
  if "decoder_pos_embed" in name:
    __UpperCAmelCase							:	Tuple           =  name.replace("""decoder_pos_embed"""  ,		"""decoder.decoder_pos_embed"""		)
  if "pos_embed" in name and "decoder" not in name:
    __UpperCAmelCase							:	Optional[int]           =  name.replace("""pos_embed"""  ,		"""videomae.embeddings.position_embeddings"""		)
  if "patch_embed.proj" in name:
    __UpperCAmelCase							:	Union[str, Any]           =  name.replace("""patch_embed.proj"""  ,		"""videomae.embeddings.patch_embeddings.projection"""		)
  if "patch_embed.norm" in name:
    __UpperCAmelCase							:	Any           =  name.replace("""patch_embed.norm"""  ,		"""videomae.embeddings.norm"""		)
  if "decoder.blocks" in name:
    __UpperCAmelCase							:	Tuple           =  name.replace("""decoder.blocks"""  ,		"""decoder.decoder_layers"""		)
  if "blocks" in name:
    __UpperCAmelCase							:	Dict           =  name.replace("""blocks"""  ,		"""videomae.encoder.layer"""		)
  if "attn.proj" in name:
    __UpperCAmelCase							:	str           =  name.replace("""attn.proj"""  ,		"""attention.output.dense"""		)
  if "attn" in name and "bias" not in name:
    __UpperCAmelCase							:	Any           =  name.replace("""attn"""  ,		"""attention.self"""		)
  if "attn" in name:
    __UpperCAmelCase							:	Union[str, Any]           =  name.replace("""attn"""  ,		"""attention.attention"""		)
  if "norm1" in name:
    __UpperCAmelCase							:	Tuple           =  name.replace("""norm1"""  ,		"""layernorm_before"""		)
  if "norm2" in name:
    __UpperCAmelCase							:	Union[str, Any]           =  name.replace("""norm2"""  ,		"""layernorm_after"""		)
  if "mlp.fc1" in name:
    __UpperCAmelCase							:	Tuple           =  name.replace("""mlp.fc1"""  ,		"""intermediate.dense"""		)
  if "mlp.fc2" in name:
    __UpperCAmelCase							:	List[Any]           =  name.replace("""mlp.fc2"""  ,		"""output.dense"""		)
  if "decoder_embed" in name:
    __UpperCAmelCase							:	List[Any]           =  name.replace("""decoder_embed"""  ,		"""decoder.decoder_embed"""		)
  if "decoder_norm" in name:
    __UpperCAmelCase							:	str           =  name.replace("""decoder_norm"""  ,		"""decoder.decoder_norm"""		)
  if "decoder_pred" in name:
    __UpperCAmelCase							:	Dict           =  name.replace("""decoder_pred"""  ,		"""decoder.decoder_pred"""		)
  if "norm.weight" in name and "decoder" not in name and "fc" not in name:
    __UpperCAmelCase							:	Any           =  name.replace("""norm.weight"""  ,		"""videomae.layernorm.weight"""		)
  if "norm.bias" in name and "decoder" not in name and "fc" not in name:
    __UpperCAmelCase							:	Dict           =  name.replace("""norm.bias"""  ,		"""videomae.layernorm.bias"""		)
  if "head" in name and "decoder" not in name:
    __UpperCAmelCase							:	Tuple           =  name.replace("""head"""  ,		"""classifier"""		)

  return name






def 				lowerCamelCase__      (    __lowerCamelCase			:     Tuple  ,		__lowerCamelCase			:     List[str]		):

  for key in orig_state_dict.copy().keys():
    __UpperCAmelCase							:	str           =  orig_state_dict.pop(__lowerCamelCase		)

    if key.startswith("""encoder."""		):
      __UpperCAmelCase							:	str           =  key.replace("""encoder."""  ,		""""""		)

    if "qkv" in key:
      __UpperCAmelCase							:	Optional[Any]           =  key.split("""."""		)
      if key.startswith("""decoder.blocks"""		):
        __UpperCAmelCase							:	Tuple           =  config.decoder_hidden_size
        __UpperCAmelCase							:	Optional[Any]           =  int(key_split[2]		)
        __UpperCAmelCase							:	List[str]           =  """decoder.decoder_layers."""
        if "weight" in key:
          __UpperCAmelCase							:	List[Any]           =  val[:dim, :]
          __UpperCAmelCase							:	Optional[int]           =  val[dim : dim * 2, :]
          __UpperCAmelCase							:	int           =  val[-dim:, :]
      else:
        __UpperCAmelCase							:	Dict           =  config.hidden_size
        __UpperCAmelCase							:	Optional[Any]           =  int(key_split[1]		)
        __UpperCAmelCase							:	Optional[int]           =  """videomae.encoder.layer."""
        if "weight" in key:
          __UpperCAmelCase							:	List[Any]           =  val[:dim, :]
          __UpperCAmelCase							:	int           =  val[dim : dim * 2, :]
          __UpperCAmelCase							:	Optional[Any]           =  val[-dim:, :]
    else:
      __UpperCAmelCase							:	Optional[int]           =  val

  return orig_state_dict






def 				lowerCamelCase__      (    ):
  __UpperCAmelCase							:	Optional[Any]           =  hf_hub_download(
      repo_id="""hf-internal-testing/spaghetti-video"""  ,		filename="""eating_spaghetti.npy"""  ,		repo_type="""dataset"""		)
  __UpperCAmelCase							:	List[Any]           =  np.load(__lowerCamelCase		)
  return list(__lowerCamelCase		)






def 				lowerCamelCase__      (    __lowerCamelCase			:     Any  ,		__lowerCamelCase			:     Dict  ,		__lowerCamelCase			:     int  ,		__lowerCamelCase			:     str		):
  __UpperCAmelCase							:	Dict           =  get_videomae_config(__lowerCamelCase		)

  if "finetuned" in model_name:
    __UpperCAmelCase							:	Tuple           =  VideoMAEForVideoClassification(__lowerCamelCase		)
  else:
    __UpperCAmelCase							:	Optional[Any]           =  VideoMAEForPreTraining(__lowerCamelCase		)

  # download original checkpoint, hosted on Google Drive
  __UpperCAmelCase							:	Optional[Any]           =  """pytorch_model.bin"""
  gdown.cached_download(__lowerCamelCase  ,		__lowerCamelCase  ,		quiet=__lowerCamelCase		)
  __UpperCAmelCase							:	int           =  torch.load(__lowerCamelCase  ,		map_location="""cpu"""		)
  if "model" in files:
    __UpperCAmelCase							:	str           =  files["""model"""]
  else:
    __UpperCAmelCase							:	List[str]           =  files["""module"""]
  __UpperCAmelCase							:	Dict           =  convert_state_dict(__lowerCamelCase  ,		__lowerCamelCase		)

  model.load_state_dict(__lowerCamelCase		)
  model.eval()

  # verify model on basic input
  __UpperCAmelCase							:	Optional[Any]           =  VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]  ,		image_std=[0.5, 0.5, 0.5]		)
  __UpperCAmelCase							:	int           =  prepare_video()
  __UpperCAmelCase							:	List[Any]           =  image_processor(__lowerCamelCase  ,		return_tensors="""pt"""		)

  if "finetuned" not in model_name:
    __UpperCAmelCase							:	Any           =  hf_hub_download(repo_id="""hf-internal-testing/bool-masked-pos"""  ,		filename="""bool_masked_pos.pt"""		)
    __UpperCAmelCase							:	Dict           =  torch.load(__lowerCamelCase		)

  __UpperCAmelCase							:	List[str]           =  model(**__lowerCamelCase		)
  __UpperCAmelCase							:	Optional[int]           =  outputs.logits

  __UpperCAmelCase							:	Optional[Any]           =  [
      """videomae-small-finetuned-kinetics""",
      """videomae-small-finetuned-ssv2""",
      # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600)
      """videomae-base-short""",
      """videomae-base-short-finetuned-kinetics""",
      """videomae-base""",
      """videomae-base-finetuned-kinetics""",
      """videomae-large""",
      """videomae-large-finetuned-kinetics""",
      """videomae-huge-finetuned-kinetics""",
      # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400)
      """videomae-base-short-ssv2""",
      """videomae-base-short-finetuned-ssv2""",
      """videomae-base-ssv2""",
      """videomae-base-finetuned-ssv2""",
  ]

  # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
  if model_name == "videomae-small-finetuned-kinetics":
    __UpperCAmelCase							:	str           =  torch.Size([1, 400]		)
    __UpperCAmelCase							:	Union[str, Any]           =  torch.tensor([-0.9_2_9_1, -0.4_0_6_1, -0.9_3_0_7]		)
  elif model_name == "videomae-small-finetuned-ssv2":
    __UpperCAmelCase							:	List[Any]           =  torch.Size([1, 174]		)
    __UpperCAmelCase							:	Tuple           =  torch.tensor([0.2_6_7_1, -0.4_6_8_9, -0.8_2_3_5]		)
  elif model_name == "videomae-base":
    __UpperCAmelCase							:	List[str]           =  torch.Size([1, 1408, 1536]		)
    __UpperCAmelCase							:	Optional[int]           =  torch.tensor([[0.7_7_3_9, 0.7_9_6_8, 0.7_0_8_9], [0.6_7_0_1, 0.7_4_8_7, 0.6_2_0_9], [0.4_2_8_7, 0.5_1_5_8, 0.4_7_7_3]]		)
  elif model_name == "videomae-base-short":
    __UpperCAmelCase							:	Dict           =  torch.Size([1, 1408, 1536]		)
    __UpperCAmelCase							:	int           =  torch.tensor([[0.7_9_9_4, 0.9_6_1_2, 0.8_5_0_8], [0.7_4_0_1, 0.8_9_5_8, 0.8_3_0_2], [0.5_8_6_2, 0.7_4_6_8, 0.7_3_2_5]]		)
    # we verified the loss both for normalized and unnormalized targets for this one
    __UpperCAmelCase							:	Optional[Any]           =  torch.tensor([0.5_1_4_2]		) if config.norm_pix_loss else torch.tensor([0.6_4_6_9]		)
  elif model_name == "videomae-large":
    __UpperCAmelCase							:	Union[str, Any]           =  torch.Size([1, 1408, 1536]		)
    __UpperCAmelCase							:	Tuple           =  torch.tensor([[0.7_1_4_9, 0.7_9_9_7, 0.6_9_6_6], [0.6_7_6_8, 0.7_8_6_9, 0.6_9_4_8], [0.5_1_3_9, 0.6_2_2_1, 0.5_6_0_5]]		)
  elif model_name == "videomae-large-finetuned-kinetics":
    __UpperCAmelCase							:	List[str]           =  torch.Size([1, 400]		)
    __UpperCAmelCase							:	Tuple           =  torch.tensor([0.0_7_7_1, 0.0_0_1_1, -0.3_6_2_5]		)
  elif model_name == "videomae-huge-finetuned-kinetics":
    __UpperCAmelCase							:	Tuple           =  torch.Size([1, 400]		)
    __UpperCAmelCase							:	Optional[Any]           =  torch.tensor([0.2_4_3_3, 0.1_6_3_2, -0.4_8_9_4]		)
  elif model_name == "videomae-base-short-finetuned-kinetics":
    __UpperCAmelCase							:	Optional[Any]           =  torch.Size([1, 400]		)
    __UpperCAmelCase							:	Optional[Any]           =  torch.tensor([0.6_5_8_8, 0.0_9_9_0, -0.2_4_9_3]		)
  elif model_name == "videomae-base-finetuned-kinetics":
    __UpperCAmelCase							:	Any           =  torch.Size([1, 400]		)
    __UpperCAmelCase							:	Union[str, Any]           =  torch.tensor([0.3_6_6_9, -0.0_6_8_8, -0.2_4_2_1]		)
  elif model_name == "videomae-base-short-ssv2":
    __UpperCAmelCase							:	Optional[Any]           =  torch.Size([1, 1408, 1536]		)
    __UpperCAmelCase							:	Dict           =  torch.tensor([[0.4_7_1_2, 0.5_2_9_6, 0.5_7_8_6], [0.2_2_7_8, 0.2_7_2_9, 0.4_0_2_6], [0.0_3_5_2, 0.0_7_3_0, 0.2_5_0_6]]		)
  elif model_name == "videomae-base-short-finetuned-ssv2":
    __UpperCAmelCase							:	Optional[Any]           =  torch.Size([1, 174]		)
    __UpperCAmelCase							:	Tuple           =  torch.tensor([-0.0_5_3_7, -0.1_5_3_9, -0.3_2_6_6]		)
  elif model_name == "videomae-base-ssv2":
    __UpperCAmelCase							:	Tuple           =  torch.Size([1, 1408, 1536]		)
    __UpperCAmelCase							:	Optional[Any]           =  torch.tensor([[0.8_1_3_1, 0.8_7_2_7, 0.8_5_4_6], [0.7_3_6_6, 0.9_3_7_7, 0.8_8_7_0], [0.5_9_3_5, 0.8_8_7_4, 0.8_5_6_4]]		)
  elif model_name == "videomae-base-finetuned-ssv2":
    __UpperCAmelCase							:	Union[str, Any]           =  torch.Size([1, 174]		)
    __UpperCAmelCase							:	Optional[Any]           =  torch.tensor([0.1_9_6_1, -0.8_3_3_7, -0.6_3_8_9]		)
  else:
    raise ValueError(f"""Model name not supported. Should be one of {model_names}"""		)

  # verify logits
  assert logits.shape == expected_shape
  if "finetuned" in model_name:
    assert torch.allclose(logits[0, :3]  ,		__lowerCamelCase  ,		atol=1E-4		)
  else:
    print("""Logits:"""  ,		logits[0, :3, :3]		)
    assert torch.allclose(logits[0, :3, :3]  ,		__lowerCamelCase  ,		atol=1E-4		)
  print("""Logits ok!"""		)

  # verify loss, if applicable
  if model_name == "videomae-base-short":
    __UpperCAmelCase							:	str           =  outputs.loss
    assert torch.allclose(__lowerCamelCase  ,		__lowerCamelCase  ,		atol=1E-4		)
    print("""Loss ok!"""		)

  if pytorch_dump_folder_path is not None:
    print(f"""Saving model and image processor to {pytorch_dump_folder_path}"""		)
    image_processor.save_pretrained(__lowerCamelCase		)
    model.save_pretrained(__lowerCamelCase		)

  if push_to_hub:
    print("""Pushing to the hub..."""		)
    model.push_to_hub(__lowerCamelCase  ,		organization="""nielsr"""		)


if __name__ == "__main__":
       a		:       Optional[Any]			     = argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           "--checkpoint_url",
           default="https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4",
           type=str,
           help=(
               "URL of the original PyTorch checkpoint (on Google Drive) you'd like to convert. Should be a direct"
               " download link."
           ),
       )
       parser.add_argument(
           "--pytorch_dump_folder_path",
           default="/Users/nielsrogge/Documents/VideoMAE/Test",
           type=str,
           help="Path to the output PyTorch model directory.",
       )
       parser.add_argument("--model_name", default="videomae-base", type=str, help="Name of the model.")
       parser.add_argument(
           "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
       )

       a		:       Union[str, Any]			     = parser.parse_args()
       convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)




import requests


def       A       (					lowercase    ,       lowercase )   ->  None:
		'''simple docstring'''

		UpperCamelCase		=     {'Content-Type': 'application/json'}
		UpperCamelCase		=     requests.post(lowercase    ,       json={'text': message_body}    ,       headers=lowercase )
		if response.status_code != 200:
				UpperCamelCase		=     (
				    'Request to slack returned an error '
				    f'''{response.status_code}, the response is:\n{response.text}'''
				)
				raise ValueError(lowercase )


if __name__ == "__main__":
					# Set the slack url to the one provided by Slack when you create the webhook at
					# https://my.slack.com/services/new/incoming-webhook/
					send_slack_message("<YOUR MESSAGE BODY>", "<SLACK CHANNEL URL>")
