





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

			return config





def    _lowerCAmelCase						(						lowercase	)					->					Union[str, 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						(						lowercase					,	lowercase	)					->					List[Any]:
			for key in orig_state_dict.copy().keys():
						__lowerCAmelCase											=				orig_state_dict.pop(lowercase	)

						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						(						)					->					List[Any]:
			__lowerCAmelCase											=				hf_hub_download(
			    repo_id="""hf-internal-testing/spaghetti-video"""					,	filename="""eating_spaghetti.npy"""					,	repo_type="""dataset"""	)
			__lowerCAmelCase											=				np.load(lowercase	)
			return list(lowercase	)





def    _lowerCAmelCase						(						lowercase					,	lowercase					,	lowercase					,	lowercase	)					->					Tuple:
			__lowerCAmelCase											=				get_timesformer_config(lowercase	)

			__lowerCAmelCase											=				TimesformerForVideoClassification(lowercase	)

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

			model.load_state_dict(lowercase	)
			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(**lowercase	)
			__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]					,	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__":
	_a					: 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."""
	)

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








'''simple docstring'''







import json
import os
import tempfile

import datasets
from datasets.arrow_writer import ArrowWriter
from datasets.features import ArrayaD
from utils import generate_examples, get_duration


_a					: Dict      =    (3_0, 4_8_7)
_a					: int      =    (3_6, 1_0_2_4)
_a					: str      =    (1_0_0, 1_0_0)
_a					: Tuple      =    1_0_0

_a					: List[str]      =    datasets.Features(
    {"""text""": ArrayaD(SHAPE_TEST_1, dtype="""float32"""), """image""": ArrayaD(SHAPE_TEST_2, dtype="""float32""")}
)

_a    ,_a					: Optional[int]      =    os.path.split(__file__)
_a					: List[Any]      =    os.path.join(RESULTS_BASEPATH, """results""", RESULTS_FILENAME.replace(""".py""", """.json"""))





@get_duration
def    _lowerCAmelCase						(						lowercase					,	lowercase					,	lowercase	)					->					Optional[Any]:
			with ArrowWriter(features=lowercase					,	path=os.path.join(lowercase					,	"""beta.arrow"""	)	) as writer:
						for key, record in dummy_data:
									__lowerCAmelCase											=				my_features.encode_example(lowercase	)
									writer.write(lowercase	)
						__lowerCAmelCase						,       __lowerCAmelCase											=				writer.finalize()





@get_duration
def    _lowerCAmelCase						(						lowercase					,	lowercase	)					->					List[str]:
			__lowerCAmelCase											=				datasets.Dataset.from_file(
			    filename=os.path.join(lowercase					,	"""beta.arrow"""	)					,	info=datasets.DatasetInfo(features=lowercase	)	)
			for _ in dataset:
						pass





@get_duration
def    _lowerCAmelCase						(						lowercase					,	lowercase	)					->					Any:
			__lowerCAmelCase											=				datasets.Dataset.from_file(
			    filename=os.path.join(lowercase					,	"""beta.arrow"""	)					,	info=datasets.DatasetInfo(features=lowercase	)	)
			dataset.set_format("""numpy"""	)
			for _ in dataset:
						pass





@get_duration
def    _lowerCAmelCase						(						lowercase					,	lowercase	)					->					List[str]:
			__lowerCAmelCase											=				10
			__lowerCAmelCase											=				datasets.Dataset.from_file(
			    filename=os.path.join(lowercase					,	"""beta.arrow"""	)					,	info=datasets.DatasetInfo(features=lowercase	)	)
			for i in range(0					,	len(lowercase	)					,	lowercase	):
						__lowerCAmelCase											=				dataset[i : i + batch_size]





@get_duration
def    _lowerCAmelCase						(						lowercase					,	lowercase	)					->					List[str]:
			__lowerCAmelCase											=				10
			__lowerCAmelCase											=				datasets.Dataset.from_file(
			    filename=os.path.join(lowercase					,	"""beta.arrow"""	)					,	info=datasets.DatasetInfo(features=lowercase	)	)
			dataset.set_format("""numpy"""	)
			for i in range(0					,	len(lowercase	)					,	lowercase	):
						__lowerCAmelCase											=				dataset[i : i + batch_size]





@get_duration
def    _lowerCAmelCase						(						lowercase					,	lowercase	)					->					Union[str, Any]:
			__lowerCAmelCase											=				datasets.Dataset.from_file(
			    filename=os.path.join(lowercase					,	"""beta.arrow"""	)					,	info=datasets.DatasetInfo(features=lowercase	)	)
			for col in feats:
						__lowerCAmelCase											=				dataset[col]





@get_duration
def    _lowerCAmelCase						(						lowercase					,	lowercase	)					->					Optional[int]:
			__lowerCAmelCase											=				datasets.Dataset.from_file(
			    filename=os.path.join(lowercase					,	"""beta.arrow"""	)					,	info=datasets.DatasetInfo(features=lowercase	)	)
			dataset.set_format("""numpy"""	)
			for col in feats:
						__lowerCAmelCase											=				dataset[col]





def    _lowerCAmelCase						(						)					->					Optional[Any]:
			__lowerCAmelCase											=				{}
			__lowerCAmelCase											=				(
			    read_unformated,
			    read_formatted_as_numpy,
			    read_batch_unformated,
			    read_batch_formatted_as_numpy,
			    read_col_unformated,
			    read_col_formatted_as_numpy,
			)
			with tempfile.TemporaryDirectory() as tmp_dir:
						__lowerCAmelCase											=				datasets.Features({"""image""": ArrayaD(lowercase					,	dtype="""float32"""	)}	)
						__lowerCAmelCase											=				generate_examples(features=lowercase					,	num_examples=lowercase	)
						__lowerCAmelCase											=				write(lowercase					,	lowercase					,	lowercase	)
						for read_func in read_functions:
									__lowerCAmelCase											=				read_func(lowercase					,	lowercase	)

			with tempfile.TemporaryDirectory() as tmp_dir:
						# don't use fixed length for fair comparison
						# feats = datasets.Features(
						#     {"image": datasets.Sequence(datasets.Sequence(datasets.Value("float32"), SPEED_TEST_SHAPE[1]), SPEED_TEST_SHAPE[0])}
						# )
						__lowerCAmelCase											=				datasets.Features({"""image""": datasets.Sequence(datasets.Sequence(datasets.Value("""float32"""	)	)	)}	)
						__lowerCAmelCase											=				generate_examples(
						    features=lowercase					,	num_examples=lowercase					,	seq_shapes={"""image""": SPEED_TEST_SHAPE}	)
						__lowerCAmelCase											=				write(lowercase					,	lowercase					,	lowercase	)
						for read_func in read_functions:
									__lowerCAmelCase											=				read_func(lowercase					,	lowercase	)

			with tempfile.TemporaryDirectory() as tmp_dir:
						# don't use fixed length for fair comparison
						# feats = datasets.Features(
						#     {"image": datasets.Sequence(datasets.Value("float32"), SPEED_TEST_SHAPE[0] * SPEED_TEST_SHAPE[1])}
						# )
						__lowerCAmelCase											=				datasets.Features({"""image""": datasets.Sequence(datasets.Value("""float32"""	)	)}	)
						__lowerCAmelCase											=				generate_examples(
						    features=lowercase					,	num_examples=lowercase					,	seq_shapes={"""image""": [SPEED_TEST_SHAPE[0] * SPEED_TEST_SHAPE[1]]}					,	)
						__lowerCAmelCase											=				write(lowercase					,	lowercase					,	lowercase	)
						for read_func in read_functions:
									__lowerCAmelCase											=				read_func(lowercase					,	lowercase	)

			with open(lowercase					,	"""wb"""	) as f:
						f.write(json.dumps(lowercase	).encode("""utf-8"""	)	)


if __name__ == "__main__":  # useful to run the profiler
	benchmark_array_xd()

