



'''simple docstring'''







import os
import pickle
import unittest
from collections import UserDict, namedtuple

import torch

from accelerate.test_utils.testing import require_cuda, require_torch_min_version
from accelerate.test_utils.training import RegressionModel
from accelerate.utils import (
    convert_outputs_to_fpaa,
    extract_model_from_parallel,
    find_device,
    listify,
    patch_environment,
    recursively_apply,
    send_to_device,
)


SCREAMING_SNAKE_CASE__     : List[str]				=   namedtuple("""ExampleNamedTuple""", """a b c""")




class 				__lowerCAmelCase(							unittest.TestCase      ):






			def 				_lowercase	(   self  :							Optional[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Tuple										=      torch.randn(5      ,       2	)
					SCREAMING_SNAKE_CASE_						:int										=      torch.device('cuda'	) if torch.cuda.is_available() else torch.device('cpu'	)

					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      send_to_device(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta.cpu()      ,       SCREAMING_SNAKE_CASE	)	)

					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      send_to_device((tensor, [tensor, tensor], 1)      ,       SCREAMING_SNAKE_CASE	)
					self.assertIsInstance(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta[0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertIsInstance(resulta[1]      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta[1][0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertTrue(torch.equal(resulta[1][1].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertEqual(resulta[2]      ,       1	)

					SCREAMING_SNAKE_CASE_						:Tuple										=      send_to_device({'a': tensor, 'b': [tensor, tensor], 'c': 1}      ,       SCREAMING_SNAKE_CASE	)
					self.assertIsInstance(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta['a'].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertIsInstance(resulta['b']      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta['b'][0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertTrue(torch.equal(resulta['b'][1].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertEqual(resulta['c']      ,       1	)

					SCREAMING_SNAKE_CASE_						:List[Any]										=      send_to_device(ExampleNamedTuple(a=SCREAMING_SNAKE_CASE      ,       b=[tensor, tensor]      ,       c=1	)      ,       SCREAMING_SNAKE_CASE	)
					self.assertIsInstance(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta.a.cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertIsInstance(resulta.b      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta.b[0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertTrue(torch.equal(resulta.b[1].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertEqual(resulta.c      ,       1	)

					SCREAMING_SNAKE_CASE_						:Tuple										=      send_to_device(UserDict({'a': tensor, 'b': [tensor, tensor], 'c': 1}	)      ,       SCREAMING_SNAKE_CASE	)
					self.assertIsInstance(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta['a'].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertIsInstance(resulta['b']      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta['b'][0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertTrue(torch.equal(resulta['b'][1].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertEqual(resulta['c']      ,       1	)






			def 				_lowercase	(   self  :							List[str]	):




					"""simple docstring"""







					with self.assertRaises(SCREAMING_SNAKE_CASE	) as cm:
							SCREAMING_SNAKE_CASE_						:Tuple										=      recursively_apply(torch.tensor      ,       (torch.tensor(1	), 1)      ,       error_on_other_type=SCREAMING_SNAKE_CASE	)
					self.assertEqual(
					    str(cm.exception	)      ,       'Unsupported types (<class \'int\'>) passed to `tensor`. Only nested list/tuple/dicts of objects that are valid for `is_torch_tensor` should be passed.'      ,       )






			def 				_lowercase	(   self  :							str	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[str]										=      torch.tensor([1, 2, 3, 4, 5]	)
					self.assertEqual(listify(SCREAMING_SNAKE_CASE	)      ,       [1, 2, 3, 4, 5]	)

					SCREAMING_SNAKE_CASE_						:Any										=      torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]	)
					self.assertEqual(listify(SCREAMING_SNAKE_CASE	)      ,       [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]	)

					SCREAMING_SNAKE_CASE_						:List[Any]										=      torch.tensor([[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]	)
					self.assertEqual(
					    listify(SCREAMING_SNAKE_CASE	)      ,       [[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]	)






			def 				_lowercase	(   self  :							Tuple	):




					"""simple docstring"""







					with patch_environment(aa=1      ,       BB=2	):
							self.assertEqual(os.environ.get('AA'	)      ,       '1'	)
							self.assertEqual(os.environ.get('BB'	)      ,       '2'	)

					self.assertNotIn('AA'      ,       os.environ	)
					self.assertNotIn('BB'      ,       os.environ	)






			def 				_lowercase	(   self  :							Optional[int]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:str										=      RegressionModel()
					SCREAMING_SNAKE_CASE_						:Tuple										=      model.forward
					SCREAMING_SNAKE_CASE_						:Any										=      convert_outputs_to_fpaa(model.forward	)
					SCREAMING_SNAKE_CASE_						:Tuple										=      extract_model_from_parallel(SCREAMING_SNAKE_CASE      ,       keep_fpaa_wrapper=SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:List[str]										=      pickle.dumps(SCREAMING_SNAKE_CASE	)






			@require_cuda
			def 				_lowercase	(   self  :							List[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[str]										=      RegressionModel()
					SCREAMING_SNAKE_CASE_						:Tuple										=      model.forward
					SCREAMING_SNAKE_CASE_						:Tuple										=      torch.cuda.amp.autocast(dtype=torch.floataa	)(model.forward	)
					SCREAMING_SNAKE_CASE_						:Any										=      convert_outputs_to_fpaa(model.forward	)
					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      extract_model_from_parallel(SCREAMING_SNAKE_CASE      ,       keep_fpaa_wrapper=SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:List[Any]										=      pickle.dumps(SCREAMING_SNAKE_CASE	)






			@require_cuda
			@require_torch_min_version(version='2.0'	)
			def 				_lowercase	(   self  :							Dict	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Dict										=      RegressionModel()
					SCREAMING_SNAKE_CASE_						:Tuple										=      model.forward
					SCREAMING_SNAKE_CASE_						:int										=      torch.cuda.amp.autocast(dtype=torch.floataa	)(model.forward	)
					SCREAMING_SNAKE_CASE_						:int										=      convert_outputs_to_fpaa(model.forward	)
					SCREAMING_SNAKE_CASE_						:List[Any]										=      torch.compile(model.forward      ,       backend='inductor'	)
					SCREAMING_SNAKE_CASE_						:str										=      torch.randn(4      ,       10	).cuda()
					SCREAMING_SNAKE_CASE_						:int										=      model(SCREAMING_SNAKE_CASE	)






			def 				_lowercase	(   self  :							Union[str, Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[str]										=      RegressionModel()
					# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      torch.nn.parallel.DataParallel(SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:int										=      extract_model_from_parallel(SCREAMING_SNAKE_CASE	)

					self.assertEqual(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)






			@require_torch_min_version(version='2.0'	)
			def 				_lowercase	(   self  :							Optional[int]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[Any]										=      RegressionModel()
					SCREAMING_SNAKE_CASE_						:int										=      torch.compile(SCREAMING_SNAKE_CASE	)

					# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
					SCREAMING_SNAKE_CASE_						:Tuple										=      torch.nn.parallel.DataParallel(SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:Tuple										=      torch.compile(SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      extract_model_from_parallel(SCREAMING_SNAKE_CASE	)

					self.assertEqual(compiled_model._orig_mod      ,       compiled_model_unwrapped._orig_mod	)






			def 				_lowercase	(   self  :							Optional[Any]	):




					"""simple docstring"""







					self.assertEqual(find_device([1, 'a', torch.tensor([1, 2, 3]	)]	)      ,       torch.device('cpu'	)	)
					self.assertEqual(find_device({'a': 1, 'b': torch.tensor([1, 2, 3]	)}	)      ,       torch.device('cpu'	)	)
					self.assertIsNone(find_device([1, 'a']	)	)





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