



'''simple docstring'''



import inspect
import warnings

import torch

from .state import AcceleratorState, GradientState
from .utils import DistributedType, honor_type, is_tpu_available


if is_tpu_available(check_device=False):
	import torch_xla.core.xla_model as xm



def 	__lowerCAmelCase       (				lowerCamelCase :    Optional[Any]					,		lowerCamelCase :    Tuple       ):






	'''simple docstring'''




	if isinstance(lowerCamelCase					,		(list, tuple)       ):
		return honor_type(lowerCamelCase					,		(move_to_device(lowerCamelCase					,		lowerCamelCase       ) for t in state)       )
	elif isinstance(lowerCamelCase					,		lowerCamelCase       ):
		return type(lowerCamelCase       )({k: move_to_device(lowerCamelCase					,		lowerCamelCase       ) for k, v in state.items()}       )
	elif isinstance(lowerCamelCase					,		torch.Tensor       ):
		return state.to(lowerCamelCase       )
	return state






class        UpperCAmelCase__						(		torch.optim.Optimizer			):



					def __init__(     self      ,					UpperCamelCase      ,					UpperCamelCase=True      ,					UpperCamelCase=None  )  ->      Union[str, Any]:
						__lowerCAmelCase       				=	optimizer
						__lowerCAmelCase       				=	scaler
						__lowerCAmelCase       				=	AcceleratorState()
						__lowerCAmelCase       				=	GradientState()
						__lowerCAmelCase       				=	device_placement
						__lowerCAmelCase       				=	False
						__lowerCAmelCase       				=	None

						# Handle device placement
						if device_placement:
							__lowerCAmelCase       				=	self.optimizer.state_dict()
							if self.accelerator_state.distributed_type == DistributedType.TPU:
								xm.send_cpu_data_to_device(UpperCamelCase      ,					self.accelerator_state.device  )
							else:
								__lowerCAmelCase       				=	move_to_device(UpperCamelCase      ,					self.accelerator_state.device  )
							self.optimizer.load_state_dict(UpperCamelCase  )



					@property
					def 							UpperCAmelCase_			(     self  )  ->      List[str]:
						return self.optimizer.state



					@state.setter
					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase  )  ->      str:
						__lowerCAmelCase       				=	state



					@property
					def 							UpperCAmelCase_			(     self  )  ->      int:
						return self.optimizer.param_groups



					@param_groups.setter
					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase  )  ->      Any:
						__lowerCAmelCase       				=	param_groups



					@property
					def 							UpperCAmelCase_			(     self  )  ->      Optional[int]:
						return self.optimizer.defaults



					@defaults.setter
					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase  )  ->      List[Any]:
						__lowerCAmelCase       				=	defaults



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase  )  ->      int:
						self.optimizer.add_param_group(UpperCamelCase  )



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase  )  ->      Tuple:
						if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
							xm.send_cpu_data_to_device(UpperCamelCase      ,					self.accelerator_state.device  )
						self.optimizer.load_state_dict(UpperCamelCase  )



					def 							UpperCAmelCase_			(     self  )  ->      List[str]:
						return self.optimizer.state_dict()



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase=None  )  ->      int:
						if self.gradient_state.sync_gradients:
							__lowerCAmelCase       				=	"set_to_none" in inspect.signature(self.optimizer.zero_grad  ).parameters
							if accept_arg:
								if set_to_none is None:
									__lowerCAmelCase       				=	False
								self.optimizer.zero_grad(set_to_none=UpperCamelCase  )
							else:
								if set_to_none is not None:
									raise ValueError("`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer."  )
								self.optimizer.zero_grad()



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase=None  )  ->      str:
						if self.gradient_state.sync_gradients:
							if self.accelerator_state.distributed_type == DistributedType.TPU:
								__lowerCAmelCase       				=	{"closure": closure} if closure is not None else {}
								xm.optimizer_step(self.optimizer      ,					optimizer_args=UpperCamelCase  )
							elif self.scaler is not None:
								__lowerCAmelCase       				=	False
								if self._last_scale is None:
									# `get_scale` is an async operation requiring full synchronization
									# on CPU and GPUs before finishing. As a result, we store away
									# the prior one to reduce the call overhead
									__lowerCAmelCase       				=	self.scaler.get_scale()
									__lowerCAmelCase       				=	True
								self.scaler.step(self.optimizer      ,					UpperCamelCase  )
								self.scaler.update()
								__lowerCAmelCase       				=	self.scaler.get_scale()
								if not new_scale:
									# If we reduced the loss scale, it means the optimizer step was skipped because of gradient overflow.
									__lowerCAmelCase       				=	scale_after < self._last_scale
								__lowerCAmelCase       				=	scale_after

							else:
								self.optimizer.step(UpperCamelCase  )



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase  )  ->      List[Any]:
						for param_group in self.optimizer.param_groups:
							__lowerCAmelCase       				=	[parameters_map.get(UpperCamelCase      ,					UpperCamelCase  ) for p in param_group["params"]]



					@property
					def 							UpperCAmelCase_			(     self  )  ->      Dict:
						warnings.warn(
						    "The `is_overflow` property is deprecated and will be removed in version 1.0 of Accelerate use "
						    "`optimizer.step_was_skipped` instead."      ,					UpperCamelCase      ,					)
						return self._is_overflow



					@property
					def 							UpperCAmelCase_			(     self  )  ->      Tuple:
						return self._is_overflow



					def __getstate__(     self  )  ->      str:
						return self.__dict__.copy()



					def __setstate__(     self      ,					UpperCamelCase  )  ->      str:
						self.__dict__.update(UpperCamelCase  )




'''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 :    str       ):






	'''simple docstring'''




	__lowerCAmelCase       				=	TimesformerConfig()

	if "large" in model_name:
		__lowerCAmelCase       				=	96

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

	__lowerCAmelCase       				=	"huggingface/label-files"
	if "k400" in model_name:
		__lowerCAmelCase       				=	4_00
		__lowerCAmelCase       				=	"kinetics400-id2label.json"
	elif "k600" in model_name:
		__lowerCAmelCase       				=	6_00
		__lowerCAmelCase       				=	"kinetics600-id2label.json"
	elif "ssv2" in model_name:
		__lowerCAmelCase       				=	1_74
		__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 :    int       ):






	'''simple docstring'''




	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 :    int					,		lowerCamelCase :    List[str]       ):






	'''simple docstring'''




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






	'''simple docstring'''




	__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 :    Union[str, Any]					,		lowerCamelCase :    Dict					,		lowerCamelCase :    List[Any]					,		lowerCamelCase :    Optional[Any]       ):






	'''simple docstring'''




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

	lowerCAmelCase						:		Optional[int]						      = parser.parse_args()
	convert_timesformer_checkpoint(
	    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
	)