






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     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Union[str, Any]    =			TimesformerConfig()

  if "large" in model_name:
    _a						: Tuple    =			9_6

  if "hr" in model_name:
    _a						: Tuple    =			1_6
    _a						: Any    =			4_4_8

  _a						: int    =			'''huggingface/label-files'''
  if "k400" in model_name:
    _a						: Optional[Any]    =			4_0_0
    _a						: Optional[Any]    =			'''kinetics400-id2label.json'''
  elif "k600" in model_name:
    _a						: Union[str, Any]    =			6_0_0
    _a						: Any    =			'''kinetics600-id2label.json'''
  elif "ssv2" in model_name:
    _a						: Any    =			1_7_4
    _a						: str    =			'''something-something-v2-id2label.json'''
  else:
    raise ValueError("""Model name should either contain \'k400\', \'k600\' or \'ssv2\'."""       )
  _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						: Tuple    =			idalabel
  _a						: List[str]    =			{v: k for k, v in idalabel.items()}

  return config

def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  if "encoder." in name:
    _a						: Tuple    =			name.replace("""encoder."""  ,     """"""       )
  if "cls_token" in name:
    _a						: List[str]    =			name.replace("""cls_token"""  ,     """timesformer.embeddings.cls_token"""       )
  if "pos_embed" in name:
    _a						: Tuple    =			name.replace("""pos_embed"""  ,     """timesformer.embeddings.position_embeddings"""       )
  if "time_embed" in name:
    _a						: List[str]    =			name.replace("""time_embed"""  ,     """timesformer.embeddings.time_embeddings"""       )
  if "patch_embed.proj" in name:
    _a						: Tuple    =			name.replace("""patch_embed.proj"""  ,     """timesformer.embeddings.patch_embeddings.projection"""       )
  if "patch_embed.norm" in name:
    _a						: str    =			name.replace("""patch_embed.norm"""  ,     """timesformer.embeddings.norm"""       )
  if "blocks" in name:
    _a						: Tuple    =			name.replace("""blocks"""  ,     """timesformer.encoder.layer"""       )
  if "attn.proj" in name:
    _a						: Optional[Any]    =			name.replace("""attn.proj"""  ,     """attention.output.dense"""       )
  if "attn" in name and "bias" not in name and "temporal" not in name:
    _a						: Dict    =			name.replace("""attn"""  ,     """attention.self"""       )
  if "attn" in name and "temporal" not in name:
    _a						: Tuple    =			name.replace("""attn"""  ,     """attention.attention"""       )
  if "temporal_norm1" in name:
    _a						: Any    =			name.replace("""temporal_norm1"""  ,     """temporal_layernorm"""       )
  if "temporal_attn.proj" in name:
    _a						: List[str]    =			name.replace("""temporal_attn"""  ,     """temporal_attention.output.dense"""       )
  if "temporal_fc" in name:
    _a						: List[str]    =			name.replace("""temporal_fc"""  ,     """temporal_dense"""       )
  if "norm1" in name and "temporal" not in name:
    _a						: Tuple    =			name.replace("""norm1"""  ,     """layernorm_before"""       )
  if "norm2" in name:
    _a						: List[Any]    =			name.replace("""norm2"""  ,     """layernorm_after"""       )
  if "mlp.fc1" in name:
    _a						: List[str]    =			name.replace("""mlp.fc1"""  ,     """intermediate.dense"""       )
  if "mlp.fc2" in name:
    _a						: Optional[int]    =			name.replace("""mlp.fc2"""  ,     """output.dense"""       )
  if "norm.weight" in name and "fc" not in name and "temporal" not in name:
    _a						: List[str]    =			name.replace("""norm.weight"""  ,     """timesformer.layernorm.weight"""       )
  if "norm.bias" in name and "fc" not in name and "temporal" not in name:
    _a						: str    =			name.replace("""norm.bias"""  ,     """timesformer.layernorm.bias"""       )
  if "head" in name:
    _a						: List[str]    =			name.replace("""head"""  ,     """classifier"""       )

  return name

def     lowerCAmelCase__  (  UpperCamelCase__  ,     UpperCamelCase__       ):



  '''simple docstring'''
  for key in orig_state_dict.copy().keys():
    _a						: str    =			orig_state_dict.pop(UpperCamelCase__       )

    if key.startswith("""model."""       ):
      _a						: Optional[Any]    =			key.replace("""model."""  ,     """"""       )

    if "qkv" in key:
      _a						: List[str]    =			key.split("""."""       )
      _a						: int    =			int(key_split[1]       )
      _a						: List[Any]    =			'''timesformer.encoder.layer.'''
      if "temporal" in key:
        _a						: int    =			'''.temporal_attention.attention.qkv.'''
      else:
        _a						: List[str]    =			'''.attention.attention.qkv.'''
      if "weight" in key:
        _a						: List[Any]    =			val
      else:
        _a						: Any    =			val
    else:
      _a						: Union[str, Any]    =			val

  return orig_state_dict

def     lowerCAmelCase__  (  ):



  '''simple docstring'''
  _a						: Dict    =			hf_hub_download(
      repo_id="""hf-internal-testing/spaghetti-video"""  ,     filename="""eating_spaghetti.npy"""  ,     repo_type="""dataset"""       )
  _a						: Tuple    =			np.load(UpperCamelCase__       )
  return list(UpperCamelCase__       )

def     lowerCAmelCase__  (  UpperCamelCase__  ,     UpperCamelCase__  ,     UpperCamelCase__  ,     UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Any    =			get_timesformer_config(UpperCamelCase__       )

  _a						: int    =			TimesformerForVideoClassification(UpperCamelCase__       )

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

  model.load_state_dict(UpperCamelCase__       )
  model.eval()

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

  _a						: int    =			model(**UpperCamelCase__       )
  _a						: Optional[int]    =			outputs.logits

  _a						: Union[str, Any]    =			[
      # 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":
    _a						: List[Any]    =			torch.Size([1, 4_0_0]       )
    _a						: Union[str, Any]    =			torch.tensor([-0.3_016, -0.7_713, -0.4_205]       )
  elif model_name == "timesformer-base-finetuned-k600":
    _a						: Tuple    =			torch.Size([1, 6_0_0]       )
    _a						: Optional[int]    =			torch.tensor([-0.7_267, -0.7_466, 3.2_404]       )
  elif model_name == "timesformer-base-finetuned-ssv2":
    _a						: int    =			torch.Size([1, 1_7_4]       )
    _a						: Optional[Any]    =			torch.tensor([-0.9_059, 0.6_433, -3.1_457]       )
  elif model_name == "timesformer-large-finetuned-k400":
    _a						: Any    =			torch.Size([1, 4_0_0]       )
    _a						: str    =			torch.tensor([0, 0, 0]       )
  elif model_name == "timesformer-large-finetuned-k600":
    _a						: Tuple    =			torch.Size([1, 6_0_0]       )
    _a						: Any    =			torch.tensor([0, 0, 0]       )
  elif model_name == "timesformer-large-finetuned-ssv2":
    _a						: List[Any]    =			torch.Size([1, 1_7_4]       )
    _a						: Optional[Any]    =			torch.tensor([0, 0, 0]       )
  elif model_name == "timesformer-hr-finetuned-k400":
    _a						: List[Any]    =			torch.Size([1, 4_0_0]       )
    _a						: Optional[int]    =			torch.tensor([-0.9_617, -3.7_311, -3.7_708]       )
  elif model_name == "timesformer-hr-finetuned-k600":
    _a						: List[Any]    =			torch.Size([1, 6_0_0]       )
    _a						: Tuple    =			torch.tensor([2.5_273, 0.7_127, 1.8_848]       )
  elif model_name == "timesformer-hr-finetuned-ssv2":
    _a						: List[str]    =			torch.Size([1, 1_7_4]       )
    _a						: Tuple    =			torch.tensor([-3.6_756, -0.7_513, 0.7_180]       )
  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__":
 _snake_case					   =     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.'
 )

 _snake_case					   =     parser.parse_args()
 convert_timesformer_checkpoint(
     args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
 )









"""simple docstring"""




from __future__ import annotations

import sys

def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  if n < 0:
    raise ValueError("""Negative arguments are not supported"""       )
  return _fib(UpperCamelCase__       )[0]

def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  if n == 0:  # (F(0), F(1))
    return (0, 1)

  # F(2n) = F(n)[2F(n+1) − F(n)]
  # F(2n+1) = F(n+1)^2+F(n)^2
  _a   ,						_a						: Dict    =			_fib(n // 2       )
  _a						: Dict    =			a * (b * 2 - a)
  _a						: Optional[Any]    =			a * a + b * b
  return (d, c + d) if n % 2 else (c, d)


if __name__ == "__main__":
 _snake_case					   =     int(sys.argv[1])
 print(F'''fibonacci({n}) is {fibonacci(n)}''')

