






"""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 					lowerCamelCase__	(							_lowerCamelCase	:		Dict			)				->    Optional[Any]:
  lowerCamelCase_   					=						TimesformerConfig()

  if "large" in model_name:
    lowerCamelCase_   					=						96

  if "hr" in model_name:
    lowerCamelCase_   					=						16
    lowerCamelCase_   					=						448

  lowerCamelCase_   					=						'huggingface/label-files'
  if "k400" in model_name:
    lowerCamelCase_   					=						400
    lowerCamelCase_   					=						'kinetics400-id2label.json'
  elif "k600" in model_name:
    lowerCamelCase_   					=						600
    lowerCamelCase_   					=						'kinetics600-id2label.json'
  elif "ssv2" in model_name:
    lowerCamelCase_   					=						174
    lowerCamelCase_   					=						'something-something-v2-id2label.json'
  else:
    raise ValueError('Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'			)
  lowerCamelCase_   					=						json.load(open(hf_hub_download(_lowerCamelCase		,    _lowerCamelCase		,    repo_type='dataset'			)		,    'r'			)			)
  lowerCamelCase_   					=						{int(_lowerCamelCase			): v for k, v in idalabel.items()}
  lowerCamelCase_   					=						idalabel
  lowerCamelCase_   					=						{v: k for k, v in idalabel.items()}

  return config







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

  return name







def 					lowerCamelCase__	(							_lowerCamelCase	:		Union[str, Any]		,    _lowerCamelCase	:		Union[str, Any]			)				->    Dict:
  for key in orig_state_dict.copy().keys():
    lowerCamelCase_   					=						orig_state_dict.pop(_lowerCamelCase			)

    if key.startswith('model.'			):
      lowerCamelCase_   					=						key.replace('model.'		,    ''			)

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

  return orig_state_dict







def 					lowerCamelCase__	(							)				->    Tuple:
  lowerCamelCase_   					=						hf_hub_download(
      repo_id='hf-internal-testing/spaghetti-video'		,    filename='eating_spaghetti.npy'		,    repo_type='dataset'			)
  lowerCamelCase_   					=						np.load(_lowerCamelCase			)
  return list(_lowerCamelCase			)







def 					lowerCamelCase__	(							_lowerCamelCase	:		Dict		,    _lowerCamelCase	:		str		,    _lowerCamelCase	:		Any		,    _lowerCamelCase	:		Any			)				->    List[Any]:
  lowerCamelCase_   					=						get_timesformer_config(_lowerCamelCase			)

  lowerCamelCase_   					=						TimesformerForVideoClassification(_lowerCamelCase			)

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

  model.load_state_dict(_lowerCamelCase			)
  model.eval()

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

  lowerCamelCase_   					=						model(**_lowerCamelCase			)
  lowerCamelCase_   					=						outputs.logits

  lowerCamelCase_   					=						[
      # 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":
    lowerCamelCase_   					=						torch.Size([1, 400]			)
    lowerCamelCase_   					=						torch.tensor([-0.30_16, -0.77_13, -0.42_05]			)
  elif model_name == "timesformer-base-finetuned-k600":
    lowerCamelCase_   					=						torch.Size([1, 600]			)
    lowerCamelCase_   					=						torch.tensor([-0.72_67, -0.74_66, 3.24_04]			)
  elif model_name == "timesformer-base-finetuned-ssv2":
    lowerCamelCase_   					=						torch.Size([1, 174]			)
    lowerCamelCase_   					=						torch.tensor([-0.90_59, 0.64_33, -3.14_57]			)
  elif model_name == "timesformer-large-finetuned-k400":
    lowerCamelCase_   					=						torch.Size([1, 400]			)
    lowerCamelCase_   					=						torch.tensor([0, 0, 0]			)
  elif model_name == "timesformer-large-finetuned-k600":
    lowerCamelCase_   					=						torch.Size([1, 600]			)
    lowerCamelCase_   					=						torch.tensor([0, 0, 0]			)
  elif model_name == "timesformer-large-finetuned-ssv2":
    lowerCamelCase_   					=						torch.Size([1, 174]			)
    lowerCamelCase_   					=						torch.tensor([0, 0, 0]			)
  elif model_name == "timesformer-hr-finetuned-k400":
    lowerCamelCase_   					=						torch.Size([1, 400]			)
    lowerCamelCase_   					=						torch.tensor([-0.96_17, -3.73_11, -3.77_08]			)
  elif model_name == "timesformer-hr-finetuned-k600":
    lowerCamelCase_   					=						torch.Size([1, 600]			)
    lowerCamelCase_   					=						torch.tensor([2.52_73, 0.71_27, 1.88_48]			)
  elif model_name == "timesformer-hr-finetuned-ssv2":
    lowerCamelCase_   					=						torch.Size([1, 174]			)
    lowerCamelCase_   					=						torch.tensor([-3.67_56, -0.75_13, 0.71_80]			)
  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]		,    _lowerCamelCase		,    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(_lowerCamelCase			)
    model.save_pretrained(_lowerCamelCase			)

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


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

  _SCREAMING_SNAKE_CASE :    int    =						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







def 					lowerCamelCase__	(							_lowerCamelCase	:		list[int]		,    _lowerCamelCase	:		int			)				->    int:
  lowerCamelCase_					,     lowerCamelCase_   					=						0, len(_lowerCamelCase			) - 1
  while start_ind <= end_ind:
    if array[start_ind] == search_item:
      return start_ind
    elif array[end_ind] == search_item:
      return end_ind
    else:
      start_ind += 1
      end_ind -= 1
    # returns -1 if search_item is not found in array
  return -1


if __name__ == "__main__":
  print(double_linear_search(list(range(100)), 40))




