


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 						_A						(						_lowercase				)			->				Optional[int]:


     """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(_lowercase			,       _lowercase			,       repo_type='dataset'				)			,       'r'				)				)
     __UpperCamelCase				=	{int(_lowercase				): v for k, v in idalabel.items()}
     __UpperCamelCase				=	idalabel
     __UpperCamelCase				=	{v: k for k, v in idalabel.items()}

     return config






def 						_A						(						_lowercase				)			->				Dict:


     """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 						_A						(						_lowercase			,       _lowercase				)			->				Dict:


     """simple docstring"""


     for key in orig_state_dict.copy().keys():
          __UpperCamelCase				=	orig_state_dict.pop(_lowercase				)

          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 						_A						(						)			->				Dict:


     """simple docstring"""


     __UpperCamelCase				=	hf_hub_download(
         repo_id='hf-internal-testing/spaghetti-video'			,       filename='eating_spaghetti.npy'			,       repo_type='dataset'				)
     __UpperCamelCase				=	np.load(_lowercase				)
     return list(_lowercase				)






def 						_A						(						_lowercase			,       _lowercase			,       _lowercase			,       _lowercase				)			->				Optional[Any]:


     """simple docstring"""


     __UpperCamelCase				=	get_timesformer_config(_lowercase				)

     __UpperCamelCase				=	TimesformerForVideoClassification(_lowercase				)

     # download original checkpoint, hosted on Google Drive
     __UpperCamelCase				=	'pytorch_model.bin'
     gdown.cached_download(_lowercase			,       _lowercase			,       quiet=_lowercase				)
     __UpperCamelCase				=	torch.load(_lowercase			,       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(_lowercase			,       _lowercase				)

     model.load_state_dict(_lowercase				)
     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(**_lowercase				)
     __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.30_16, -0.77_13, -0.42_05]				)
     elif model_name == "timesformer-base-finetuned-k600":
          __UpperCamelCase				=	torch.Size([1, 6_00]				)
          __UpperCamelCase				=	torch.tensor([-0.72_67, -0.74_66, 3.24_04]				)
     elif model_name == "timesformer-base-finetuned-ssv2":
          __UpperCamelCase				=	torch.Size([1, 1_74]				)
          __UpperCamelCase				=	torch.tensor([-0.90_59, 0.64_33, -3.14_57]				)
     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.96_17, -3.73_11, -3.77_08]				)
     elif model_name == "timesformer-hr-finetuned-k600":
          __UpperCamelCase				=	torch.Size([1, 6_00]				)
          __UpperCamelCase				=	torch.tensor([2.52_73, 0.71_27, 1.88_48]				)
     elif model_name == "timesformer-hr-finetuned-ssv2":
          __UpperCamelCase				=	torch.Size([1, 1_74]				)
          __UpperCamelCase				=	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]			,       _lowercase			,       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(_lowercase				)
          model.save_pretrained(_lowercase				)

     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
    )






import math






def 						_A						(						_lowercase				)			->				list:


     """simple docstring"""


     if n <= 0:
          raise ValueError('Only positive integers have prime factors'				)
     __UpperCamelCase				=	[]
     while n % 2 == 0:
          pf.append(2				)
          __UpperCamelCase				=	int(n / 2				)
     for i in range(3			,       int(math.sqrt(_lowercase				)				) + 1			,       2				):
          while n % i == 0:
               pf.append(_lowercase				)
               __UpperCamelCase				=	int(n / i				)
     if n > 2:
          pf.append(_lowercase				)
     return pf






def 						_A						(						_lowercase				)			->				int:


     """simple docstring"""


     if n <= 0:
          raise ValueError('Only positive numbers are accepted'				)
     __UpperCamelCase				=	1
     __UpperCamelCase				=	1
     while n % 2 == 0:
          temp += 1
          __UpperCamelCase				=	int(n / 2				)
     div *= temp
     for i in range(3			,       int(math.sqrt(_lowercase				)				) + 1			,       2				):
          __UpperCamelCase				=	1
          while n % i == 0:
               temp += 1
               __UpperCamelCase				=	int(n / i				)
          div *= temp
     if n > 1:
          div *= 2
     return div






def 						_A						(						_lowercase				)			->				int:


     """simple docstring"""


     if n <= 0:
          raise ValueError('Only positive numbers are accepted'				)
     __UpperCamelCase				=	1
     __UpperCamelCase				=	1
     while n % 2 == 0:
          temp += 1
          __UpperCamelCase				=	int(n / 2				)
     if temp > 1:
          s *= (2**temp - 1) / (2 - 1)
     for i in range(3			,       int(math.sqrt(_lowercase				)				) + 1			,       2				):
          __UpperCamelCase				=	1
          while n % i == 0:
               temp += 1
               __UpperCamelCase				=	int(n / i				)
          if temp > 1:
               s *= (i**temp - 1) / (i - 1)
     return int(_lowercase				)






def 						_A						(						_lowercase				)			->				int:


     """simple docstring"""


     __UpperCamelCase				=	n
     for x in set(prime_factors(_lowercase				)				):
          s *= (x - 1) / x
     return int(_lowercase				)


if __name__ == "__main__":
    import doctest

    doctest.testmod()


