



'''simple docstring'''



from typing import Callable, List, Optional, Union

import torch

from ...models import UNetaDModel
from ...schedulers import CMStochasticIterativeScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput


lowerCAmelCase						:		Optional[Any]						      = logging.get_logger(__name__)  # pylint: disable=invalid-name


lowerCAmelCase						:		Dict						      = '''
    Examples:
        ```py
        >>> import torch

        >>> from diffusers import ConsistencyModelPipeline

        >>> device = "cuda"
        >>> # Load the cd_imagenet64_l2 checkpoint.
        >>> model_id_or_path = "openai/diffusers-cd_imagenet64_l2"
        >>> pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)
        >>> pipe.to(device)

        >>> # Onestep Sampling
        >>> image = pipe(num_inference_steps=1).images[0]
        >>> image.save("cd_imagenet64_l2_onestep_sample.png")

        >>> # Onestep sampling, class-conditional image generation
        >>> # ImageNet-64 class label 145 corresponds to king penguins
        >>> image = pipe(num_inference_steps=1, class_labels=145).images[0]
        >>> image.save("cd_imagenet64_l2_onestep_sample_penguin.png")

        >>> # Multistep sampling, class-conditional image generation
        >>> # Timesteps can be explicitly specified; the particular timesteps below are from the original Github repo:
        >>> # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L77
        >>> image = pipe(num_inference_steps=None, timesteps=[22, 0], class_labels=145).images[0]
        >>> image.save("cd_imagenet64_l2_multistep_sample_penguin.png")
        ```
'''






class        UpperCAmelCase__						(		UpperCamelCase__			):



					def __init__(     self      ,					UpperCamelCase      ,					UpperCamelCase  )  ->      None:
						super().__init__()

						self.register_modules(
						    unet=UpperCamelCase      ,					scheduler=UpperCamelCase      ,					)

						__lowerCAmelCase       				=	None



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase=0  )  ->      Tuple:
						if is_accelerate_available() and is_accelerate_version(">="      ,					"0.14.0"  ):
							from accelerate import cpu_offload
						else:
							raise ImportError("`enable_sequential_cpu_offload` requires `accelerate v0.14.0` or higher"  )

						__lowerCAmelCase       				=	torch.device(F'''cuda:{gpu_id}'''  )

						if self.device.type != "cpu":
							self.to("cpu"      ,					silence_dtype_warnings=UpperCamelCase  )
							torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

						for cpu_offloaded_model in [self.unet]:
							cpu_offload(UpperCamelCase      ,					UpperCamelCase  )

						if self.safety_checker is not None:
							cpu_offload(self.safety_checker      ,					execution_device=UpperCamelCase      ,					offload_buffers=UpperCamelCase  )



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase=0  )  ->      List[Any]:
						if is_accelerate_available() and is_accelerate_version(">="      ,					"0.17.0.dev0"  ):
							from accelerate import cpu_offload_with_hook
						else:
							raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher."  )

						__lowerCAmelCase       				=	torch.device(F'''cuda:{gpu_id}'''  )

						if self.device.type != "cpu":
							self.to("cpu"      ,					silence_dtype_warnings=UpperCamelCase  )
							torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

						__lowerCAmelCase       				=	None
						for cpu_offloaded_model in [self.unet]:
							__lowerCAmelCase				,							__lowerCAmelCase       				=	cpu_offload_with_hook(UpperCamelCase      ,					UpperCamelCase      ,					prev_module_hook=UpperCamelCase  )

						if self.safety_checker is not None:
							__lowerCAmelCase				,							__lowerCAmelCase       				=	cpu_offload_with_hook(self.safety_checker      ,					UpperCamelCase      ,					prev_module_hook=UpperCamelCase  )

						# We'll offload the last model manually.
						__lowerCAmelCase       				=	hook



					@property
					# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
					def 							UpperCAmelCase_			(     self  )  ->      Any:
						if not hasattr(self.unet      ,					"_hf_hook"  ):
							return self.device
						for module in self.unet.modules():
							if (
							    hasattr(UpperCamelCase      ,					"_hf_hook"  )
							    and hasattr(module._hf_hook      ,					"execution_device"  )
							    and module._hf_hook.execution_device is not None
							):
								return torch.device(module._hf_hook.execution_device  )
						return self.device



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase=None  )  ->      int:
						__lowerCAmelCase       				=	(batch_size, num_channels, height, width)
						if isinstance(UpperCamelCase      ,					UpperCamelCase  ) and len(UpperCamelCase  ) != batch_size:
							raise ValueError(
							    F'''You have passed a list of generators of length {len(UpperCamelCase  )}, but requested an effective batch'''
							    F''' size of {batch_size}. Make sure the batch size matches the length of the generators.'''  )

						if latents is None:
							__lowerCAmelCase       				=	randn_tensor(UpperCamelCase      ,					generator=UpperCamelCase      ,					device=UpperCamelCase      ,					dtype=UpperCamelCase  )
						else:
							__lowerCAmelCase       				=	latents.to(device=UpperCamelCase      ,					dtype=UpperCamelCase  )

						# scale the initial noise by the standard deviation required by the scheduler
						__lowerCAmelCase       				=	latents * self.scheduler.init_noise_sigma
						return latents



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase      ,					UpperCamelCase = "pil"  )  ->      List[str]:
						if output_type not in ["pt", "np", "pil"]:
							raise ValueError(
							    F'''output_type={output_type} is not supported. Make sure to choose one of [\'pt\', \'np\', or \'pil\']'''  )

						# Equivalent to diffusers.VaeImageProcessor.denormalize
						__lowerCAmelCase       				=	(sample / 2 + 0.5).clamp(0      ,					1  )
						if output_type == "pt":
							return sample

						# Equivalent to diffusers.VaeImageProcessor.pt_to_numpy
						__lowerCAmelCase       				=	sample.cpu().permute(0      ,					2      ,					3      ,					1  ).numpy()
						if output_type == "np":
							return sample

						# Output_type must be 'pil'
						__lowerCAmelCase       				=	self.numpy_to_pil(UpperCamelCase  )
						return sample



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase=None  )  ->      int:
						if self.unet.config.num_class_embeds is not None:
							if isinstance(UpperCamelCase      ,					UpperCamelCase  ):
								__lowerCAmelCase       				=	torch.tensor(UpperCamelCase      ,					dtype=torch.int  )
							elif isinstance(UpperCamelCase      ,					UpperCamelCase  ):
								assert batch_size == 1, "Batch size must be 1 if classes is an int"
								__lowerCAmelCase       				=	torch.tensor([class_labels]      ,					dtype=torch.int  )
							elif class_labels is None:
								# Randomly generate batch_size class labels
								# TODO: should use generator here? int analogue of randn_tensor is not exposed in ...utils
								__lowerCAmelCase       				=	torch.randint(0      ,					self.unet.config.num_class_embeds      ,					size=(batch_size,)  )
							__lowerCAmelCase       				=	class_labels.to(UpperCamelCase  )
						else:
							__lowerCAmelCase       				=	None
						return class_labels



					def 							UpperCAmelCase_			(     self      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase  )  ->      List[str]:
						if num_inference_steps is None and timesteps is None:
							raise ValueError("Exactly one of `num_inference_steps` or `timesteps` must be supplied."  )

						if num_inference_steps is not None and timesteps is not None:
							logger.warning(
							    F'''Both `num_inference_steps`: {num_inference_steps} and `timesteps`: {timesteps} are supplied;'''
							    " `timesteps` will be used over `num_inference_steps`."  )

						if latents is not None:
							__lowerCAmelCase       				=	(batch_size, 3, img_size, img_size)
							if latents.shape != expected_shape:
								raise ValueError(F'''The shape of latents is {latents.shape} but is expected to be {expected_shape}.'''  )

						if (callback_steps is None) or (
						    callback_steps is not None and (not isinstance(UpperCamelCase      ,					UpperCamelCase  ) or callback_steps <= 0)
						):
							raise ValueError(
							    F'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
							    F''' {type(UpperCamelCase  )}.'''  )



					@torch.no_grad()
					@replace_example_docstring(UpperCamelCase  )
					def __call__(     self      ,					UpperCamelCase = 1      ,					UpperCamelCase = None      ,					UpperCamelCase = 1      ,					UpperCamelCase = None      ,					UpperCamelCase = None      ,					UpperCamelCase = None      ,					UpperCamelCase = "pil"      ,					UpperCamelCase = True      ,					UpperCamelCase = None      ,					UpperCamelCase = 1      ,					)  ->      Optional[Any]:
						__lowerCAmelCase       				=	self.unet.config.sample_size
						__lowerCAmelCase       				=	self._execution_device

						# 1. Check inputs
						self.check_inputs(UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase  )

						# 2. Prepare image latents
						# Sample image latents x_0 ~ N(0, sigma_0^2 * I)
						__lowerCAmelCase       				=	self.prepare_latents(
						    batch_size=UpperCamelCase      ,					num_channels=self.unet.config.in_channels      ,					height=UpperCamelCase      ,					width=UpperCamelCase      ,					dtype=self.unet.dtype      ,					device=UpperCamelCase      ,					generator=UpperCamelCase      ,					latents=UpperCamelCase      ,					)

						# 3. Handle class_labels for class-conditional models
						__lowerCAmelCase       				=	self.prepare_class_labels(UpperCamelCase      ,					UpperCamelCase      ,					class_labels=UpperCamelCase  )

						# 4. Prepare timesteps
						if timesteps is not None:
							self.scheduler.set_timesteps(timesteps=UpperCamelCase      ,					device=UpperCamelCase  )
							__lowerCAmelCase       				=	self.scheduler.timesteps
							__lowerCAmelCase       				=	len(UpperCamelCase  )
						else:
							self.scheduler.set_timesteps(UpperCamelCase  )
							__lowerCAmelCase       				=	self.scheduler.timesteps

						# 5. Denoising loop
						# Multistep sampling: implements Algorithm 1 in the paper
						with self.progress_bar(total=UpperCamelCase  ) as progress_bar:
							for i, t in enumerate(UpperCamelCase  ):
								__lowerCAmelCase       				=	self.scheduler.scale_model_input(UpperCamelCase      ,					UpperCamelCase  )
								__lowerCAmelCase       				=	self.unet(UpperCamelCase      ,					UpperCamelCase      ,					class_labels=UpperCamelCase      ,					return_dict=UpperCamelCase  )[0]

								__lowerCAmelCase       				=	self.scheduler.step(UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase      ,					generator=UpperCamelCase  )[0]

								# call the callback, if provided
								progress_bar.update()
								if callback is not None and i % callback_steps == 0:
									callback(UpperCamelCase      ,					UpperCamelCase      ,					UpperCamelCase  )

        # 6. Post-process image sample
						__lowerCAmelCase       				=	self.postprocess_image(UpperCamelCase      ,					output_type=UpperCamelCase  )

						# Offload last model to CPU
						if hasattr(self      ,					"final_offload_hook"  ) and self.final_offload_hook is not None:
							self.final_offload_hook.offload()

						if not return_dict:
							return (image,)

						return ImagePipelineOutput(images=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
	)