


"""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      (						UpperCAmelCase     :							Optional[Any]				):


					'''simple docstring'''






					UpperCamelCase__		:    Any         =TimesformerConfig()

					if "large" in model_name:
										UpperCamelCase__		:    Union[str, Any]         =96

					if "hr" in model_name:
										UpperCamelCase__		:    Union[str, Any]         =16
										UpperCamelCase__		:    Union[str, Any]         =448

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

					return config



def        _lowerCAmelCase      (						UpperCAmelCase     :							Tuple				):


					'''simple docstring'''






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

					return name



def        _lowerCAmelCase      (						UpperCAmelCase     :							Optional[int]      ,							UpperCAmelCase     :							Optional[int]				):


					'''simple docstring'''






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

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

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

					return orig_state_dict



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					UpperCamelCase__		:    Optional[Any]         =hf_hub_download(
					    repo_id='''hf-internal-testing/spaghetti-video'''      ,							filename='''eating_spaghetti.npy'''      ,							repo_type='''dataset'''				)
					UpperCamelCase__		:    str         =np.load(UpperCAmelCase				)
					return list(UpperCAmelCase				)



def        _lowerCAmelCase      (						UpperCAmelCase     :							str      ,							UpperCAmelCase     :							Union[str, Any]      ,							UpperCAmelCase     :							Union[str, Any]      ,							UpperCAmelCase     :							Any				):


					'''simple docstring'''






					UpperCamelCase__		:    List[str]         =get_timesformer_config(UpperCAmelCase				)

					UpperCamelCase__		:    Dict         =TimesformerForVideoClassification(UpperCAmelCase				)

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

					model.load_state_dict(UpperCAmelCase				)
					model.eval()

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

					UpperCamelCase__		:    List[Any]         =model(**UpperCAmelCase				)
					UpperCamelCase__		:    Optional[Any]         =outputs.logits

					UpperCamelCase__		:    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":
										UpperCamelCase__		:    Any         =torch.Size([1, 400]				)
										UpperCamelCase__		:    str         =torch.tensor([-0.3016, -0.7713, -0.4205]				)
					elif model_name == "timesformer-base-finetuned-k600":
										UpperCamelCase__		:    List[str]         =torch.Size([1, 600]				)
										UpperCamelCase__		:    Tuple         =torch.tensor([-0.7267, -0.7466, 3.2404]				)
					elif model_name == "timesformer-base-finetuned-ssv2":
										UpperCamelCase__		:    str         =torch.Size([1, 174]				)
										UpperCamelCase__		:    List[Any]         =torch.tensor([-0.9059, 0.6433, -3.1457]				)
					elif model_name == "timesformer-large-finetuned-k400":
										UpperCamelCase__		:    Union[str, Any]         =torch.Size([1, 400]				)
										UpperCamelCase__		:    Dict         =torch.tensor([0, 0, 0]				)
					elif model_name == "timesformer-large-finetuned-k600":
										UpperCamelCase__		:    Tuple         =torch.Size([1, 600]				)
										UpperCamelCase__		:    List[str]         =torch.tensor([0, 0, 0]				)
					elif model_name == "timesformer-large-finetuned-ssv2":
										UpperCamelCase__		:    Union[str, Any]         =torch.Size([1, 174]				)
										UpperCamelCase__		:    Union[str, Any]         =torch.tensor([0, 0, 0]				)
					elif model_name == "timesformer-hr-finetuned-k400":
										UpperCamelCase__		:    Union[str, Any]         =torch.Size([1, 400]				)
										UpperCamelCase__		:    str         =torch.tensor([-0.9617, -3.7311, -3.7708]				)
					elif model_name == "timesformer-hr-finetuned-k600":
										UpperCamelCase__		:    Dict         =torch.Size([1, 600]				)
										UpperCamelCase__		:    Union[str, Any]         =torch.tensor([2.5273, 0.7127, 1.8848]				)
					elif model_name == "timesformer-hr-finetuned-ssv2":
										UpperCamelCase__		:    int         =torch.Size([1, 174]				)
										UpperCamelCase__		:    List[Any]         =torch.tensor([-3.6756, -0.7513, 0.7180]				)
					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__":
				_SCREAMING_SNAKE_CASE       :  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."""
				)

				_SCREAMING_SNAKE_CASE       :  Any        = parser.parse_args()
				convert_timesformer_checkpoint(
				    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
				)





"""simple docstring"""





import math as m



def        _lowerCAmelCase      (						UpperCAmelCase     :							Optional[int]      ,							UpperCAmelCase     :							Optional[Any]      ,							UpperCAmelCase     :							Optional[Any]=0.001				):


					'''simple docstring'''






					return (f(a + h				) - f(a - h				)) / (2 * h)



def        _lowerCAmelCase      (						UpperCAmelCase     :							List[str]      ,							UpperCAmelCase     :							Optional[Any]=0      ,							UpperCAmelCase     :							Optional[int]=100      ,							UpperCAmelCase     :							Union[str, Any]=0.0001      ,							UpperCAmelCase     :							Dict=1E-6      ,							UpperCAmelCase     :							Any=False				):


					'''simple docstring'''






					UpperCamelCase__		:    Optional[Any]         =xa  # set the initial guess
					UpperCamelCase__		:    List[Any]         =[a]
					UpperCamelCase__		:    Optional[Any]         =abs(f(UpperCAmelCase				)				)
					UpperCamelCase__		:    List[str]         =lambda UpperCAmelCase				: calc_derivative(UpperCAmelCase      ,							UpperCAmelCase      ,							h=UpperCAmelCase				)  # noqa: E731  Derivative of f(x)
					for _ in range(UpperCAmelCase				):
										if fa(UpperCAmelCase				) == 0:
															raise ValueError('''No converging solution found'''				)
										UpperCamelCase__		:    Any         =a - f(UpperCAmelCase				) / fa(UpperCAmelCase				)  # Calculate the next estimate
										if logsteps:
															steps.append(UpperCAmelCase				)
										if error < maxerror:
															break
					else:
										raise ValueError('''Iteration limit reached, no converging solution found'''				)
					if logsteps:
										# If logstep is true, then log intermediate steps
										return a, error, steps
					return a, error


if __name__ == "__main__":
				from matplotlib import pyplot as plt

				_SCREAMING_SNAKE_CASE       :  str        = lambda x: m.tanh(x) ** 2 - m.exp(3 * x)  # noqa: E731
				_SCREAMING_SNAKE_CASE       ,       _SCREAMING_SNAKE_CASE       ,       _SCREAMING_SNAKE_CASE       :  Any        = newton_raphson(
				    f, xa=1_0, maxiter=1_0_0_0, step=1e-6, logsteps=True
				)
				plt.plot([abs(f(x)) for x in steps])
				plt.xlabel("""step""")
				plt.ylabel("""error""")
				plt.show()
				print(F'''solution = {{{solution:f}}}, error = {{{error:f}}}''')


