




'''simple docstring'''
import argparse
import json

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

from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor
def     snake_case_  (       a__		:     Union[str, Any]      ):



    """simple docstring"""




    __lowercase          =						TimesformerConfig()

    if "large" in model_name:
        __lowercase          =						96

    if "hr" in model_name:
        __lowercase          =						16
        __lowercase          =						4_48

    __lowercase          =						"""huggingface/label-files"""
    if "k400" in model_name:
        __lowercase          =						4_00
        __lowercase          =						"""kinetics400-id2label.json"""
    elif "k600" in model_name:
        __lowercase          =						6_00
        __lowercase          =						"""kinetics600-id2label.json"""
    elif "ssv2" in model_name:
        __lowercase          =						1_74
        __lowercase          =						"""something-something-v2-id2label.json"""
    else:
        raise ValueError("""Model name should either contain 'k400', 'k600' or 'ssv2'."""      )
    __lowercase          =						json.load(open(hf_hub_download(a__   ,a__   ,repo_type="""dataset"""      )   ,"""r"""      )      )
    __lowercase          =						{int(a__      ): v for k, v in idalabel.items()}
    __lowercase          =						idalabel
    __lowercase          =						{v: k for k, v in idalabel.items()}

    return config
def     snake_case_  (       a__		:     Union[str, Any]      ):



    """simple docstring"""




    if "encoder." in name:
        __lowercase          =						name.replace("""encoder."""   ,""""""      )
    if "cls_token" in name:
        __lowercase          =						name.replace("""cls_token"""   ,"""timesformer.embeddings.cls_token"""      )
    if "pos_embed" in name:
        __lowercase          =						name.replace("""pos_embed"""   ,"""timesformer.embeddings.position_embeddings"""      )
    if "time_embed" in name:
        __lowercase          =						name.replace("""time_embed"""   ,"""timesformer.embeddings.time_embeddings"""      )
    if "patch_embed.proj" in name:
        __lowercase          =						name.replace("""patch_embed.proj"""   ,"""timesformer.embeddings.patch_embeddings.projection"""      )
    if "patch_embed.norm" in name:
        __lowercase          =						name.replace("""patch_embed.norm"""   ,"""timesformer.embeddings.norm"""      )
    if "blocks" in name:
        __lowercase          =						name.replace("""blocks"""   ,"""timesformer.encoder.layer"""      )
    if "attn.proj" in name:
        __lowercase          =						name.replace("""attn.proj"""   ,"""attention.output.dense"""      )
    if "attn" in name and "bias" not in name and "temporal" not in name:
        __lowercase          =						name.replace("""attn"""   ,"""attention.self"""      )
    if "attn" in name and "temporal" not in name:
        __lowercase          =						name.replace("""attn"""   ,"""attention.attention"""      )
    if "temporal_norm1" in name:
        __lowercase          =						name.replace("""temporal_norm1"""   ,"""temporal_layernorm"""      )
    if "temporal_attn.proj" in name:
        __lowercase          =						name.replace("""temporal_attn"""   ,"""temporal_attention.output.dense"""      )
    if "temporal_fc" in name:
        __lowercase          =						name.replace("""temporal_fc"""   ,"""temporal_dense"""      )
    if "norm1" in name and "temporal" not in name:
        __lowercase          =						name.replace("""norm1"""   ,"""layernorm_before"""      )
    if "norm2" in name:
        __lowercase          =						name.replace("""norm2"""   ,"""layernorm_after"""      )
    if "mlp.fc1" in name:
        __lowercase          =						name.replace("""mlp.fc1"""   ,"""intermediate.dense"""      )
    if "mlp.fc2" in name:
        __lowercase          =						name.replace("""mlp.fc2"""   ,"""output.dense"""      )
    if "norm.weight" in name and "fc" not in name and "temporal" not in name:
        __lowercase          =						name.replace("""norm.weight"""   ,"""timesformer.layernorm.weight"""      )
    if "norm.bias" in name and "fc" not in name and "temporal" not in name:
        __lowercase          =						name.replace("""norm.bias"""   ,"""timesformer.layernorm.bias"""      )
    if "head" in name:
        __lowercase          =						name.replace("""head"""   ,"""classifier"""      )

    return name
def     snake_case_  (       a__		:     str   ,a__		:     Any      ):



    """simple docstring"""




    for key in orig_state_dict.copy().keys():
        __lowercase          =						orig_state_dict.pop(a__      )

        if key.startswith("""model."""      ):
            __lowercase          =						key.replace("""model."""   ,""""""      )

        if "qkv" in key:
            __lowercase          =						key.split("""."""      )
            __lowercase          =						int(key_split[1]      )
            __lowercase          =						"""timesformer.encoder.layer."""
            if "temporal" in key:
                __lowercase          =						""".temporal_attention.attention.qkv."""
            else:
                __lowercase          =						""".attention.attention.qkv."""
            if "weight" in key:
                __lowercase          =						val
            else:
                __lowercase          =						val
        else:
            __lowercase          =						val

    return orig_state_dict
def     snake_case_  (       ):



    """simple docstring"""




    __lowercase          =						hf_hub_download(
        repo_id="""hf-internal-testing/spaghetti-video"""   ,filename="""eating_spaghetti.npy"""   ,repo_type="""dataset"""      )
    __lowercase          =						np.load(a__      )
    return list(a__      )
def     snake_case_  (       a__		:     Optional[Any]   ,a__		:     Optional[Any]   ,a__		:     Dict   ,a__		:     Tuple      ):



    """simple docstring"""




    __lowercase          =						get_timesformer_config(a__      )

    __lowercase          =						TimesformerForVideoClassification(a__      )

    # download original checkpoint, hosted on Google Drive
    __lowercase          =						"""pytorch_model.bin"""
    gdown.cached_download(a__   ,a__   ,quiet=a__      )
    __lowercase          =						torch.load(a__   ,map_location="""cpu"""      )
    if "model" in files:
        __lowercase          =						files["""model"""]
    elif "module" in files:
        __lowercase          =						files["""module"""]
    else:
        __lowercase          =						files["""model_state"""]
    __lowercase          =						convert_state_dict(a__   ,a__      )

    model.load_state_dict(a__      )
    model.eval()

    # verify model on basic input
    __lowercase          =						VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]   ,image_std=[0.5, 0.5, 0.5]      )
    __lowercase          =						prepare_video()
    __lowercase          =						image_processor(video[:8]   ,return_tensors="""pt"""      )

    __lowercase          =						model(**a__      )
    __lowercase          =						outputs.logits

    __lowercase          =						[
        # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
        """timesformer-base-finetuned-k400""",
        """timesformer-large-finetuned-k400""",
        """timesformer-hr-finetuned-k400""",
        # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
        """timesformer-base-finetuned-k600""",
        """timesformer-large-finetuned-k600""",
        """timesformer-hr-finetuned-k600""",
        # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
        """timesformer-base-finetuned-ssv2""",
        """timesformer-large-finetuned-ssv2""",
        """timesformer-hr-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 == "timesformer-base-finetuned-k400":
        __lowercase          =						torch.Size([1, 4_00]      )
        __lowercase          =						torch.tensor([-0.3_0_1_6, -0.7_7_1_3, -0.4_2_0_5]      )
    elif model_name == "timesformer-base-finetuned-k600":
        __lowercase          =						torch.Size([1, 6_00]      )
        __lowercase          =						torch.tensor([-0.7_2_6_7, -0.7_4_6_6, 3.2_4_0_4]      )
    elif model_name == "timesformer-base-finetuned-ssv2":
        __lowercase          =						torch.Size([1, 1_74]      )
        __lowercase          =						torch.tensor([-0.9_0_5_9, 0.6_4_3_3, -3.1_4_5_7]      )
    elif model_name == "timesformer-large-finetuned-k400":
        __lowercase          =						torch.Size([1, 4_00]      )
        __lowercase          =						torch.tensor([0, 0, 0]      )
    elif model_name == "timesformer-large-finetuned-k600":
        __lowercase          =						torch.Size([1, 6_00]      )
        __lowercase          =						torch.tensor([0, 0, 0]      )
    elif model_name == "timesformer-large-finetuned-ssv2":
        __lowercase          =						torch.Size([1, 1_74]      )
        __lowercase          =						torch.tensor([0, 0, 0]      )
    elif model_name == "timesformer-hr-finetuned-k400":
        __lowercase          =						torch.Size([1, 4_00]      )
        __lowercase          =						torch.tensor([-0.9_6_1_7, -3.7_3_1_1, -3.7_7_0_8]      )
    elif model_name == "timesformer-hr-finetuned-k600":
        __lowercase          =						torch.Size([1, 6_00]      )
        __lowercase          =						torch.tensor([2.5_2_7_3, 0.7_1_2_7, 1.8_8_4_8]      )
    elif model_name == "timesformer-hr-finetuned-ssv2":
        __lowercase          =						torch.Size([1, 1_74]      )
        __lowercase          =						torch.tensor([-3.6_7_5_6, -0.7_5_1_3, 0.7_1_8_0]      )
    else:
        raise ValueError(f'Model name not supported. Should be one of {model_names}'      )

    # verify logits
    assert logits.shape == expected_shape
    assert torch.allclose(logits[0, :3]   ,a__   ,atol=1e-4      )
    print("""Logits 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(a__      )
        model.save_pretrained(a__      )

    if push_to_hub:
        print("""Pushing to the hub..."""      )
        model.push_to_hub(f'fcakyon/{model_name}'      )


if __name__ == "__main__":
  A							:				List[str]			     =	argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--checkpoint_url""",
      default="""https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download""",
      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="""""",
      type=str,
      help="""Path to the output PyTorch model directory.""",
  )
  parser.add_argument("""--model_name""", default="""timesformer-base-finetuned-k400""", 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							:				Optional[int]			     =	parser.parse_args()
  convert_timesformer_checkpoint(
      args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
  )










'''simple docstring'''
import unittest
import warnings
from dataclasses import dataclass

from transformers.convert_slow_tokenizer import SpmConverter
from transformers.testing_utils import get_tests_dir






@dataclass
class 	SCREAMING_SNAKE_CASE:
       snake_case_			:					str






class 	SCREAMING_SNAKE_CASE(    unittest.TestCase					):

       def    snake_case__      (   self					)   -> Optional[int]:

           """simple docstring"""



           __lowercase          =						get_tests_dir("""fixtures/test_sentencepiece.model"""					)
           __lowercase          =						get_tests_dir("""fixtures/test_sentencepiece_with_bytefallback.model"""					)

           __lowercase          =						FakeOriginalTokenizer(vocab_file=lowerCamelCase__					)

           with warnings.catch_warnings(record=lowerCamelCase__					) as w:
               __lowercase          =						SpmConverter(lowerCamelCase__					)
           self.assertEqual(len(lowerCamelCase__					) ,		0					)

           __lowercase          =						FakeOriginalTokenizer(vocab_file=lowerCamelCase__					)

           with warnings.catch_warnings(record=lowerCamelCase__					) as w:
               __lowercase          =						SpmConverter(lowerCamelCase__					)
           self.assertEqual(len(lowerCamelCase__					) ,		1					)

           self.assertIn(
               """The sentencepiece tokenizer that you are converting to a fast tokenizer uses the byte fallback option"""
               """ which is not implemented in the fast tokenizers.""" ,		str(w[0].message					) ,		)




