


'''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 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					Dict )		->       Optional[Any]:





   '''simple docstring'''







   UpperCamelCase__			    =    TimesformerConfig()

   if "large" in model_name:
      UpperCamelCase__			    =    96

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

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

   return config



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					Optional[int] )		->       Tuple:





   '''simple docstring'''







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

   return name



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					int     ,		_UpperCamelCase   :					int )		->       Optional[int]:





   '''simple docstring'''







   for key in orig_state_dict.copy().keys():
      UpperCamelCase__			    =    orig_state_dict.pop(_UpperCamelCase )

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

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

   return orig_state_dict



def 							SCREAMING_SNAKE_CASE__(		)		->       int:





   '''simple docstring'''







   UpperCamelCase__			    =    hf_hub_download(
       repo_id="hf-internal-testing/spaghetti-video"     ,		filename="eating_spaghetti.npy"     ,		repo_type="dataset" )
   UpperCamelCase__			    =    np.load(_UpperCamelCase )
   return list(_UpperCamelCase )



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					Optional[int]     ,		_UpperCamelCase   :					Optional[int]     ,		_UpperCamelCase   :					List[str]     ,		_UpperCamelCase   :					List[str] )		->       Optional[Any]:





   '''simple docstring'''







   UpperCamelCase__			    =    get_timesformer_config(_UpperCamelCase )

   UpperCamelCase__			    =    TimesformerForVideoClassification(_UpperCamelCase )

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

   model.load_state_dict(_UpperCamelCase )
   model.eval()

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

   UpperCamelCase__			    =    model(**_UpperCamelCase )
   UpperCamelCase__			    =    outputs.logits

   UpperCamelCase__			    =    [
       # 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":
      UpperCamelCase__			    =    torch.Size([1, 4_00] )
      UpperCamelCase__			    =    torch.tensor([-0.3_0_1_6, -0.7_7_1_3, -0.4_2_0_5] )
   elif model_name == "timesformer-base-finetuned-k600":
      UpperCamelCase__			    =    torch.Size([1, 6_00] )
      UpperCamelCase__			    =    torch.tensor([-0.7_2_6_7, -0.7_4_6_6, 3.2_4_0_4] )
   elif model_name == "timesformer-base-finetuned-ssv2":
      UpperCamelCase__			    =    torch.Size([1, 1_74] )
      UpperCamelCase__			    =    torch.tensor([-0.9_0_5_9, 0.6_4_3_3, -3.1_4_5_7] )
   elif model_name == "timesformer-large-finetuned-k400":
      UpperCamelCase__			    =    torch.Size([1, 4_00] )
      UpperCamelCase__			    =    torch.tensor([0, 0, 0] )
   elif model_name == "timesformer-large-finetuned-k600":
      UpperCamelCase__			    =    torch.Size([1, 6_00] )
      UpperCamelCase__			    =    torch.tensor([0, 0, 0] )
   elif model_name == "timesformer-large-finetuned-ssv2":
      UpperCamelCase__			    =    torch.Size([1, 1_74] )
      UpperCamelCase__			    =    torch.tensor([0, 0, 0] )
   elif model_name == "timesformer-hr-finetuned-k400":
      UpperCamelCase__			    =    torch.Size([1, 4_00] )
      UpperCamelCase__			    =    torch.tensor([-0.9_6_1_7, -3.7_3_1_1, -3.7_7_0_8] )
   elif model_name == "timesformer-hr-finetuned-k600":
      UpperCamelCase__			    =    torch.Size([1, 6_00] )
      UpperCamelCase__			    =    torch.tensor([2.5_2_7_3, 0.7_1_2_7, 1.8_8_4_8] )
   elif model_name == "timesformer-hr-finetuned-ssv2":
      UpperCamelCase__			    =    torch.Size([1, 1_74] )
      UpperCamelCase__			    =    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]     ,		_UpperCamelCase     ,		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(_UpperCamelCase )
      model.save_pretrained(_UpperCamelCase )

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


if __name__ == "__main__":
       __lowercase:		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."
       )

       __lowercase:		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 numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import OwlViTImageProcessor







class 			UpperCAmelCase			(							unittest.TestCase):

 def __init__(			self			:						Optional[Any],       a_			:						Optional[int],       a_			:						Dict=7,       a_			:						List[str]=3,       a_			:						int=18,       a_			:						Tuple=30,       a_			:						Any=400,       a_			:						Optional[int]=True,       a_			:						Optional[int]=None,       a_			:						Any=True,       a_			:						Optional[int]=None,       a_			:						int=True,       a_			:						Optional[int]=[0.48_145_466, 0.4_578_275, 0.40_821_073],       a_			:						Optional[Any]=[0.26_862_954, 0.26_130_258, 0.27_577_711],       a_			:						Optional[int]=True,       ):





    """simple docstring"""



    UpperCamelCase__			    =    parent
    UpperCamelCase__			    =    batch_size
    UpperCamelCase__			    =    num_channels
    UpperCamelCase__			    =    image_size
    UpperCamelCase__			    =    min_resolution
    UpperCamelCase__			    =    max_resolution
    UpperCamelCase__			    =    do_resize
    UpperCamelCase__			    =    size if size is not None else {"height": 18, "width": 18}
    UpperCamelCase__			    =    do_center_crop
    UpperCamelCase__			    =    crop_size if crop_size is not None else {"height": 18, "width": 18}
    UpperCamelCase__			    =    do_normalize
    UpperCamelCase__			    =    image_mean
    UpperCamelCase__			    =    image_std
    UpperCamelCase__			    =    do_convert_rgb

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    return {
        "do_resize": self.do_resize,
        "size": self.size,
        "do_center_crop": self.do_center_crop,
        "crop_size": self.crop_size,
        "do_normalize": self.do_normalize,
        "image_mean": self.image_mean,
        "image_std": self.image_std,
        "do_convert_rgb": self.do_convert_rgb,
    }







@require_torch
@require_vision
class 			UpperCAmelCase			(							SCREAMING_SNAKE_CASE__		,      unittest.TestCase):
 _lowerCamelCase			:       Tuple            =       OwlViTImageProcessor if is_vision_available() else None

 def 		lowercase_    (			self			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    OwlViTImageProcessingTester(self       )

 @property
 def 		lowercase_    (			self			:						str       ):





    """simple docstring"""



    return self.image_processor_tester.prepare_image_processor_dict()

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.image_processing_class(**self.image_processor_dict       )
    self.assertTrue(hasattr(a_,       "do_resize"       )       )
    self.assertTrue(hasattr(a_,       "size"       )       )
    self.assertTrue(hasattr(a_,       "do_center_crop"       )       )
    self.assertTrue(hasattr(a_,       "center_crop"       )       )
    self.assertTrue(hasattr(a_,       "do_normalize"       )       )
    self.assertTrue(hasattr(a_,       "image_mean"       )       )
    self.assertTrue(hasattr(a_,       "image_std"       )       )
    self.assertTrue(hasattr(a_,       "do_convert_rgb"       )       )

 def 		lowercase_    (			self			:						Any       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.image_processing_class.from_dict(self.image_processor_dict       )
    self.assertEqual(image_processor.size,       {"height": 18, "width": 18}       )
    self.assertEqual(image_processor.crop_size,       {"height": 18, "width": 18}       )

    UpperCamelCase__			    =    self.image_processing_class.from_dict(self.image_processor_dict,       size=42,       crop_size=84       )
    self.assertEqual(image_processor.size,       {"height": 42, "width": 42}       )
    self.assertEqual(image_processor.crop_size,       {"height": 84, "width": 84}       )

 def 		lowercase_    (			self			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.image_processing_class(**self.image_processor_dict       )
    # create random PIL images
    UpperCamelCase__			    =    prepare_image_inputs(self.image_processor_tester,       equal_resolution=a_       )

    for image in image_inputs:
       self.assertIsInstance(a_,       Image.Image       )

    # Test not batched input
    UpperCamelCase__			    =    image_processing(image_inputs[0],       return_tensors="pt"       ).pixel_values
    self.assertEqual(
        encoded_images.shape,       (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),       )

    # Test batched
    UpperCamelCase__			    =    image_processing(a_,       return_tensors="pt"       ).pixel_values
    self.assertEqual(
        encoded_images.shape,       (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),       )

 def 		lowercase_    (			self			:						Any       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.image_processing_class(**self.image_processor_dict       )
    # create random numpy tensors
    UpperCamelCase__			    =    prepare_image_inputs(self.image_processor_tester,       equal_resolution=a_,       numpify=a_       )
    for image in image_inputs:
       self.assertIsInstance(a_,       np.ndarray       )

    # Test not batched input
    UpperCamelCase__			    =    image_processing(image_inputs[0],       return_tensors="pt"       ).pixel_values
    self.assertEqual(
        encoded_images.shape,       (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),       )

    # Test batched
    UpperCamelCase__			    =    image_processing(a_,       return_tensors="pt"       ).pixel_values
    self.assertEqual(
        encoded_images.shape,       (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),       )

 def 		lowercase_    (			self			:						Any       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.image_processing_class(**self.image_processor_dict       )
    # create random PyTorch tensors
    UpperCamelCase__			    =    prepare_image_inputs(self.image_processor_tester,       equal_resolution=a_,       torchify=a_       )
    for image in image_inputs:
       self.assertIsInstance(a_,       torch.Tensor       )

    # Test not batched input
    UpperCamelCase__			    =    image_processing(image_inputs[0],       return_tensors="pt"       ).pixel_values
    self.assertEqual(
        encoded_images.shape,       (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),       )

    # Test batched
    UpperCamelCase__			    =    image_processing(a_,       return_tensors="pt"       ).pixel_values
    self.assertEqual(
        encoded_images.shape,       (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),       )