






"""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 						lowercase   (    __snake_case    :			int     ):
		lowercase_			:			Optional[Any]								=       TimesformerConfig()

		if "large" in model_name:
				lowercase_			:			Any								=       9_6

		if "hr" in model_name:
				lowercase_			:			Union[str, Any]								=       1_6
				lowercase_			:			Any								=       4_4_8

		lowercase_			:			Optional[int]								=       """huggingface/label-files"""
		if "k400" in model_name:
				lowercase_			:			Any								=       4_0_0
				lowercase_			:			Any								=       """kinetics400-id2label.json"""
		elif "k600" in model_name:
				lowercase_			:			Any								=       6_0_0
				lowercase_			:			str								=       """kinetics600-id2label.json"""
		elif "ssv2" in model_name:
				lowercase_			:			Dict								=       1_7_4
				lowercase_			:			Union[str, Any]								=       """something-something-v2-id2label.json"""
		else:
				raise ValueError('''Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'''     )
		lowercase_			:			str								=       json.load(open(hf_hub_download(_lowerCamelCase		, _lowerCamelCase		, repo_type='''dataset'''     )		, '''r'''     )     )
		lowercase_			:			List[Any]								=       {int(_lowerCamelCase     ): v for k, v in idalabel.items()}
		lowercase_			:			Any								=       idalabel
		lowercase_			:			Dict								=       {v: k for k, v in idalabel.items()}

		return config



def 						lowercase   (    __snake_case    :			List[Any]     ):
		if "encoder." in name:
				lowercase_			:			Tuple								=       name.replace('''encoder.'''		, ''''''     )
		if "cls_token" in name:
				lowercase_			:			Optional[int]								=       name.replace('''cls_token'''		, '''timesformer.embeddings.cls_token'''     )
		if "pos_embed" in name:
				lowercase_			:			Union[str, Any]								=       name.replace('''pos_embed'''		, '''timesformer.embeddings.position_embeddings'''     )
		if "time_embed" in name:
				lowercase_			:			int								=       name.replace('''time_embed'''		, '''timesformer.embeddings.time_embeddings'''     )
		if "patch_embed.proj" in name:
				lowercase_			:			Union[str, Any]								=       name.replace('''patch_embed.proj'''		, '''timesformer.embeddings.patch_embeddings.projection'''     )
		if "patch_embed.norm" in name:
				lowercase_			:			List[Any]								=       name.replace('''patch_embed.norm'''		, '''timesformer.embeddings.norm'''     )
		if "blocks" in name:
				lowercase_			:			List[Any]								=       name.replace('''blocks'''		, '''timesformer.encoder.layer'''     )
		if "attn.proj" in name:
				lowercase_			:			List[str]								=       name.replace('''attn.proj'''		, '''attention.output.dense'''     )
		if "attn" in name and "bias" not in name and "temporal" not in name:
				lowercase_			:			List[str]								=       name.replace('''attn'''		, '''attention.self'''     )
		if "attn" in name and "temporal" not in name:
				lowercase_			:			Optional[int]								=       name.replace('''attn'''		, '''attention.attention'''     )
		if "temporal_norm1" in name:
				lowercase_			:			str								=       name.replace('''temporal_norm1'''		, '''temporal_layernorm'''     )
		if "temporal_attn.proj" in name:
				lowercase_			:			List[Any]								=       name.replace('''temporal_attn'''		, '''temporal_attention.output.dense'''     )
		if "temporal_fc" in name:
				lowercase_			:			Optional[Any]								=       name.replace('''temporal_fc'''		, '''temporal_dense'''     )
		if "norm1" in name and "temporal" not in name:
				lowercase_			:			Optional[int]								=       name.replace('''norm1'''		, '''layernorm_before'''     )
		if "norm2" in name:
				lowercase_			:			List[Any]								=       name.replace('''norm2'''		, '''layernorm_after'''     )
		if "mlp.fc1" in name:
				lowercase_			:			Optional[int]								=       name.replace('''mlp.fc1'''		, '''intermediate.dense'''     )
		if "mlp.fc2" in name:
				lowercase_			:			int								=       name.replace('''mlp.fc2'''		, '''output.dense'''     )
		if "norm.weight" in name and "fc" not in name and "temporal" not in name:
				lowercase_			:			List[str]								=       name.replace('''norm.weight'''		, '''timesformer.layernorm.weight'''     )
		if "norm.bias" in name and "fc" not in name and "temporal" not in name:
				lowercase_			:			str								=       name.replace('''norm.bias'''		, '''timesformer.layernorm.bias'''     )
		if "head" in name:
				lowercase_			:			List[str]								=       name.replace('''head'''		, '''classifier'''     )

		return name



def 						lowercase   (    __snake_case    :			List[Any]		, __snake_case    :			Any     ):
		for key in orig_state_dict.copy().keys():
				lowercase_			:			List[str]								=       orig_state_dict.pop(_lowerCamelCase     )

				if key.startswith('''model.'''     ):
						lowercase_			:			Union[str, Any]								=       key.replace('''model.'''		, ''''''     )

				if "qkv" in key:
						lowercase_			:			Union[str, Any]								=       key.split('''.'''     )
						lowercase_			:			Union[str, Any]								=       int(key_split[1]     )
						lowercase_			:			List[str]								=       """timesformer.encoder.layer."""
						if "temporal" in key:
								lowercase_			:			Any								=       """.temporal_attention.attention.qkv."""
						else:
								lowercase_			:			Dict								=       """.attention.attention.qkv."""
						if "weight" in key:
								lowercase_			:			Any								=       val
						else:
								lowercase_			:			Dict								=       val
				else:
						lowercase_			:			List[str]								=       val

		return orig_state_dict



def 						lowercase   (    ):
		lowercase_			:			int								=       hf_hub_download(
		    repo_id='''hf-internal-testing/spaghetti-video'''		, filename='''eating_spaghetti.npy'''		, repo_type='''dataset'''     )
		lowercase_			:			int								=       np.load(_lowerCamelCase     )
		return list(_lowerCamelCase     )



def 						lowercase   (    __snake_case    :			Tuple		, __snake_case    :			Union[str, Any]		, __snake_case    :			Dict		, __snake_case    :			Dict     ):
		lowercase_			:			List[Any]								=       get_timesformer_config(_lowerCamelCase     )

		lowercase_			:			List[Any]								=       TimesformerForVideoClassification(_lowerCamelCase     )

		# download original checkpoint, hosted on Google Drive
		lowercase_			:			Optional[Any]								=       """pytorch_model.bin"""
		gdown.cached_download(_lowerCamelCase		, _lowerCamelCase		, quiet=_lowerCamelCase     )
		lowercase_			:			Dict								=       torch.load(_lowerCamelCase		, map_location='''cpu'''     )
		if "model" in files:
				lowercase_			:			int								=       files["""model"""]
		elif "module" in files:
				lowercase_			:			Optional[int]								=       files["""module"""]
		else:
				lowercase_			:			List[Any]								=       files["""model_state"""]
		lowercase_			:			Dict								=       convert_state_dict(_lowerCamelCase		, _lowerCamelCase     )

		model.load_state_dict(_lowerCamelCase     )
		model.eval()

		# verify model on basic input
		lowercase_			:			Tuple								=       VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]		, image_std=[0.5, 0.5, 0.5]     )
		lowercase_			:			int								=       prepare_video()
		lowercase_			:			Any								=       image_processor(video[:8]		, return_tensors='''pt'''     )

		lowercase_			:			str								=       model(**_lowerCamelCase     )
		lowercase_			:			int								=       outputs.logits

		lowercase_			:			int								=       [
		    # 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":
				lowercase_			:			Tuple								=       torch.Size([1, 4_0_0]     )
				lowercase_			:			Optional[int]								=       torch.tensor([-0.3016, -0.7713, -0.4205]     )
		elif model_name == "timesformer-base-finetuned-k600":
				lowercase_			:			Union[str, Any]								=       torch.Size([1, 6_0_0]     )
				lowercase_			:			int								=       torch.tensor([-0.7267, -0.7466, 3.2404]     )
		elif model_name == "timesformer-base-finetuned-ssv2":
				lowercase_			:			Any								=       torch.Size([1, 1_7_4]     )
				lowercase_			:			Dict								=       torch.tensor([-0.9059, 0.6433, -3.1457]     )
		elif model_name == "timesformer-large-finetuned-k400":
				lowercase_			:			List[str]								=       torch.Size([1, 4_0_0]     )
				lowercase_			:			List[str]								=       torch.tensor([0, 0, 0]     )
		elif model_name == "timesformer-large-finetuned-k600":
				lowercase_			:			Dict								=       torch.Size([1, 6_0_0]     )
				lowercase_			:			int								=       torch.tensor([0, 0, 0]     )
		elif model_name == "timesformer-large-finetuned-ssv2":
				lowercase_			:			Optional[int]								=       torch.Size([1, 1_7_4]     )
				lowercase_			:			int								=       torch.tensor([0, 0, 0]     )
		elif model_name == "timesformer-hr-finetuned-k400":
				lowercase_			:			Tuple								=       torch.Size([1, 4_0_0]     )
				lowercase_			:			Optional[Any]								=       torch.tensor([-0.9617, -3.7311, -3.7708]     )
		elif model_name == "timesformer-hr-finetuned-k600":
				lowercase_			:			List[Any]								=       torch.Size([1, 6_0_0]     )
				lowercase_			:			Tuple								=       torch.tensor([2.5273, 0.7127, 1.8848]     )
		elif model_name == "timesformer-hr-finetuned-ssv2":
				lowercase_			:			Union[str, Any]								=       torch.Size([1, 1_7_4]     )
				lowercase_			:			Tuple								=       torch.tensor([-3.6756, -0.7513, 0.7180]     )
		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__":
						__A		:	Optional[int]      =		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[Any]      =		parser.parse_args()
						convert_timesformer_checkpoint(
						    args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
						)








"""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


__A		:	Union[str, Any]      =		logging.get_logger(__name__)  # pylint: disable=invalid-name


__A		:	str      =		'''
    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	(			_A							):




					def __init__(    self					:						Union[str, Any]   ,						A					:						UNetaDModel   ,						A					:						CMStochasticIterativeScheduler       )  ->  None:
							super().__init__()

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

							lowercase_			:			Any								=       None




					def   A  (    self					:						Tuple   ,						A					:						Union[str, Any]=0       )  ->  Optional[Any]:
							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'''       )

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

							if self.device.type != "cpu":
									self.to('''cpu'''   ,						silence_dtype_warnings=A       )
									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(A   ,						A       )

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




					def   A  (    self					:						List[Any]   ,						A					:						Optional[Any]=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.'''       )

							lowercase_			:			List[str]								=       torch.device(F'''cuda:{gpu_id}'''       )

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

							lowercase_			:			Union[str, Any]								=       None
							for cpu_offloaded_model in [self.unet]:
									lowercase_	, lowercase_			:			Optional[int]								=       cpu_offload_with_hook(A   ,						A   ,						prev_module_hook=A       )

							if self.safety_checker is not None:
									lowercase_	, lowercase_			:			Any								=       cpu_offload_with_hook(self.safety_checker   ,						A   ,						prev_module_hook=A       )

							# We'll offload the last model manually.
							lowercase_			:			str								=       hook




					@property
					# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
					def   A  (    self					:						Any       )  ->  List[str]:
							if not hasattr(self.unet   ,						'''_hf_hook'''       ):
									return self.device
							for module in self.unet.modules():
									if (
									    hasattr(A   ,						'''_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   A  (    self					:						List[str]   ,						A					:						int   ,						A					:						Union[str, Any]   ,						A					:						List[str]   ,						A					:						str   ,						A					:						int   ,						A					:						List[Any]   ,						A					:						Optional[Any]   ,						A					:						Optional[Any]=None       )  ->  Tuple:
							lowercase_			:			List[Any]								=       (batch_size, num_channels, height, width)
							if isinstance(A   ,						A       ) and len(A       ) != batch_size:
									raise ValueError(
									    F'''You have passed a list of generators of length {len(A       )}, 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:
									lowercase_			:			Dict								=       randn_tensor(A   ,						generator=A   ,						device=A   ,						dtype=A       )
							else:
									lowercase_			:			Tuple								=       latents.to(device=A   ,						dtype=A       )

							# scale the initial noise by the standard deviation required by the scheduler
							lowercase_			:			List[str]								=       latents * self.scheduler.init_noise_sigma
							return latents




					def   A  (    self					:						Tuple   ,						A					:						torch.FloatTensor   ,						A					:						str = "pil"       )  ->  Optional[int]:
							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
							lowercase_			:			Dict								=       (sample / 2 + 0.5).clamp(0   ,						1       )
							if output_type == "pt":
									return sample

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

							# Output_type must be 'pil'
							lowercase_			:			List[Any]								=       self.numpy_to_pil(A       )
							return sample




					def   A  (    self					:						Optional[int]   ,						A					:						Any   ,						A					:						Union[str, Any]   ,						A					:						Optional[int]=None       )  ->  List[Any]:
							if self.unet.config.num_class_embeds is not None:
									if isinstance(A   ,						A       ):
											lowercase_			:			Optional[int]								=       torch.tensor(A   ,						dtype=torch.int       )
									elif isinstance(A   ,						A       ):
											assert batch_size == 1, "Batch size must be 1 if classes is an int"
											lowercase_			:			int								=       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
											lowercase_			:			Any								=       torch.randint(0   ,						self.unet.config.num_class_embeds   ,						size=(batch_size,)       )
									lowercase_			:			List[str]								=       class_labels.to(A       )
							else:
									lowercase_			:			Union[str, Any]								=       None
							return class_labels




					def   A  (    self					:						Dict   ,						A					:						Union[str, Any]   ,						A					:						Any   ,						A					:						Optional[int]   ,						A					:						Union[str, Any]   ,						A					:						Any   ,						A					:						int       )  ->  Union[str, Any]:
							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:
									lowercase_			:			List[Any]								=       (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(A   ,						A       ) or callback_steps <= 0)
							):
									raise ValueError(
									    F'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
									    F''' {type(A       )}.'''       )






					@torch.no_grad()
					@replace_example_docstring(A       )
					def __call__(    self					:						Optional[Any]   ,						A					:						int = 1   ,						A					:						Optional[Union[torch.Tensor, List[int], int]] = None   ,						A					:						int = 1   ,						A					:						List[int] = None   ,						A					:						Optional[Union[torch.Generator, List[torch.Generator]]] = None   ,						A					:						Optional[torch.FloatTensor] = None   ,						A					:						Optional[str] = "pil"   ,						A					:						bool = True   ,						A					:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None   ,						A					:						int = 1   ,						)  ->  Tuple:
							lowercase_			:			Dict								=       self.unet.config.sample_size
							lowercase_			:			Union[str, Any]								=       self._execution_device

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

							# 2. Prepare image latents
							# Sample image latents x_0 ~ N(0, sigma_0^2 * I)
							lowercase_			:			Optional[int]								=       self.prepare_latents(
							    batch_size=A   ,						num_channels=self.unet.config.in_channels   ,						height=A   ,						width=A   ,						dtype=self.unet.dtype   ,						device=A   ,						generator=A   ,						latents=A   ,						)

							# 3. Handle class_labels for class-conditional models
							lowercase_			:			List[str]								=       self.prepare_class_labels(A   ,						A   ,						class_labels=A       )

							# 4. Prepare timesteps
							if timesteps is not None:
									self.scheduler.set_timesteps(timesteps=A   ,						device=A       )
									lowercase_			:			Optional[int]								=       self.scheduler.timesteps
									lowercase_			:			List[Any]								=       len(A       )
							else:
									self.scheduler.set_timesteps(A       )
									lowercase_			:			Any								=       self.scheduler.timesteps

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

											lowercase_			:			Tuple								=       self.scheduler.step(A   ,						A   ,						A   ,						generator=A       )[0]

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

        # 6. Post-process image sample
							lowercase_			:			Union[str, Any]								=       self.postprocess_image(A   ,						output_type=A       )

							# 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=A       )



