



import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
	from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import PoolFormerImageProcessor


class    _lowercase (a_   ):
				'''simple docstring'''







				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= self.config_class(**self.inputs_dict     )
									self.parent.assertTrue(hasattr(snake_case__  ,			"hidden_sizes"     )     )
									self.parent.assertTrue(hasattr(snake_case__  ,			"num_encoder_blocks"     )     )




class    _lowercase :
				'''simple docstring'''







				def __init__(			self  ,			snake_case__  ,			snake_case__=13  ,			snake_case__=64  ,			snake_case__=3  ,			snake_case__=4  ,			snake_case__=[2, 2, 2, 2]  ,			snake_case__=[8, 4, 2, 1]  ,			snake_case__=[16, 32, 64, 128]  ,			snake_case__=[1, 4, 8, 16]  ,			snake_case__=False  ,			snake_case__=True  ,			snake_case__="gelu"  ,			snake_case__=0.1  ,			snake_case__=0.02  ,			snake_case__=3  ,			snake_case__=None  ,			):

									'''simple docstring'''


									UpperCamelCase_			= parent
									UpperCamelCase_			= batch_size
									UpperCamelCase_			= image_size
									UpperCamelCase_			= num_channels
									UpperCamelCase_			= num_encoder_blocks
									UpperCamelCase_			= sr_ratios
									UpperCamelCase_			= depths
									UpperCamelCase_			= hidden_sizes
									UpperCamelCase_			= downsampling_rates
									UpperCamelCase_			= is_training
									UpperCamelCase_			= use_labels
									UpperCamelCase_			= hidden_act
									UpperCamelCase_			= hidden_dropout_prob
									UpperCamelCase_			= initializer_range
									UpperCamelCase_			= num_labels
									UpperCamelCase_			= scope

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

									UpperCamelCase_			= None
									if self.use_labels:
														UpperCamelCase_			= ids_tensor([self.batch_size, self.image_size, self.image_size]  ,			self.num_labels     )

									UpperCamelCase_			= PoolFormerConfig(
									    image_size=self.image_size  ,			num_channels=self.num_channels  ,			num_encoder_blocks=self.num_encoder_blocks  ,			depths=self.depths  ,			hidden_sizes=self.hidden_sizes  ,			hidden_act=self.hidden_act  ,			hidden_dropout_prob=self.hidden_dropout_prob  ,			initializer_range=self.initializer_range  ,			)

									return config, pixel_values, labels

				def    _lowerCamelCase       (			self  ,			snake_case__  ,			snake_case__  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= PoolFormerModel(config=snake_case__     )
									model.to(snake_case__     )
									model.eval()
									UpperCamelCase_			= model(snake_case__     )
									UpperCamelCase_			= UpperCamelCase_			= self.image_size // 32.0
									self.parent.assertEqual(
									    result.last_hidden_state.shape  ,			(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)     )

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= self.prepare_config_and_inputs()
									UpperCamelCase_	,     UpperCamelCase_	,     UpperCamelCase_			= config_and_inputs
									UpperCamelCase_			= {"pixel_values": pixel_values}
									return config, inputs_dict




@require_torch
class    _lowercase (a_   , a_   , unittest.TestCase   ):
				'''simple docstring'''







				lowercase__     =    (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
				lowercase__     =    (
				    {"""feature-extraction""": PoolFormerModel, """image-classification""": PoolFormerForImageClassification}
				    if is_torch_available()
				    else {}
				)

				lowercase__     =    False
				lowercase__     =    False
				lowercase__     =    False
				lowercase__     =    False
				lowercase__     =    False

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= PoolFormerModelTester(self     )
									UpperCamelCase_			= PoolFormerConfigTester(self  ,			config_class=snake_case__     )

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									self.config_tester.run_common_tests()

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case__     )

				@unittest.skip("PoolFormer does not use inputs_embeds"     )
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									pass

				@unittest.skip("PoolFormer does not have get_input_embeddings method and get_output_embeddings methods"     )
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									pass

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									def check_hidden_states_output(snake_case__  ,			snake_case__  ,			snake_case__     ):
														UpperCamelCase_			= model_class(snake_case__     )
														model.to(snake_case__     )
														model.eval()

														with torch.no_grad():
																			UpperCamelCase_			= model(**self._prepare_for_class(snake_case__  ,			snake_case__     )     )

														UpperCamelCase_			= outputs.hidden_states

														UpperCamelCase_			= self.model_tester.num_encoder_blocks
														self.assertEqual(len(snake_case__     )  ,			snake_case__     )

														# verify the first hidden states (first block)
														self.assertListEqual(
														    list(hidden_states[0].shape[-3:]     )  ,			[
														        self.model_tester.hidden_sizes[0],
														        self.model_tester.image_size // 4,
														        self.model_tester.image_size // 4,
														    ]  ,			)

									UpperCamelCase_	,     UpperCamelCase_			= self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
														UpperCamelCase_			= True
														check_hidden_states_output(snake_case__  ,			snake_case__  ,			snake_case__     )

														# check that output_hidden_states also work using config
														del inputs_dict["output_hidden_states"]
														UpperCamelCase_			= True

														check_hidden_states_output(snake_case__  ,			snake_case__  ,			snake_case__     )

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									if not self.model_tester.is_training:
														return

									UpperCamelCase_	,     UpperCamelCase_			= self.model_tester.prepare_config_and_inputs_for_common()
									UpperCamelCase_			= True

									for model_class in self.all_model_classes:
														if model_class in get_values(snake_case__     ):
																			continue
														UpperCamelCase_			= model_class(snake_case__     )
														model.to(snake_case__     )
														model.train()
														UpperCamelCase_			= self._prepare_for_class(snake_case__  ,			snake_case__  ,			return_labels=snake_case__     )
														UpperCamelCase_			= model(**snake_case__     ).loss
														loss.backward()

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_	,     UpperCamelCase_			= self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
														UpperCamelCase_			= model_class(snake_case__     )
														UpperCamelCase_			= inspect.signature(model.forward     )
														# signature.parameters is an OrderedDict => so arg_names order is deterministic
														UpperCamelCase_			= [*signature.parameters.keys()]

														UpperCamelCase_			= ["pixel_values"]
														self.assertListEqual(arg_names[:1]  ,			snake_case__     )

				@slow
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														UpperCamelCase_			= PoolFormerModel.from_pretrained(snake_case__     )
														self.assertIsNotNone(snake_case__     )




def  _lowerCAmelCase     ():
					UpperCamelCase_			= Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
					return image






@require_torch
class    _lowercase (unittest.TestCase   ):
				'''simple docstring'''







				@slow
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= PoolFormerImageProcessor()
									UpperCamelCase_			= PoolFormerForImageClassification.from_pretrained("sail/poolformer_s12"     ).to(snake_case__     )

									UpperCamelCase_			= image_processor(images=prepare_img()  ,			return_tensors="pt"     ).to(snake_case__     )

									# forward pass
									with torch.no_grad():
														UpperCamelCase_			= model(**snake_case__     )

									# verify the logits
									UpperCamelCase_			= torch.Size((1, 1000)     )
									self.assertEqual(outputs.logits.shape  ,			snake_case__     )

									UpperCamelCase_			= torch.tensor([-0.6_113, 0.1_685, -0.0_492]     ).to(snake_case__     )
									self.assertTrue(torch.allclose(outputs.logits[0, :3]  ,			snake_case__  ,			atol=1e-4     )     )





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