



"""simple docstring"""


import torch

from diffusers import HeunDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest







class  A_     (	SCREAMING_SNAKE_CASE_							):



						"""simple docstring"""
						__UpperCamelCase													=				(HeunDiscreteScheduler,)
						__UpperCamelCase													=				10






						def       UpperCAmelCase__	(   self					:int  ,    **lowercase_					:str   )							->     Any:
												UpperCAmelCase			 =					{
												    'num_train_timesteps': 11_00,
												    'beta_start': 0.0001,
												    'beta_end': 0.02,
												    'beta_schedule': 'linear',
												}

												config.update(**lowercase_   )
												return config






						def       UpperCAmelCase__	(   self					:List[str]   )							->     int:
												for timesteps in [10, 50, 1_00, 10_00]:
																		self.check_over_configs(num_train_timesteps=lowercase_   )






						def       UpperCAmelCase__	(   self					:Any   )							->     Tuple:
												for beta_start, beta_end in zip([0.0_0001, 0.0001, 0.001]  ,    [0.0002, 0.002, 0.02]   ):
																		self.check_over_configs(beta_start=lowercase_  ,    beta_end=lowercase_   )






						def       UpperCAmelCase__	(   self					:List[Any]   )							->     List[str]:
												for schedule in ["linear", "scaled_linear", "exp"]:
																		self.check_over_configs(beta_schedule=lowercase_   )






						def       UpperCAmelCase__	(   self					:Tuple   )							->     str:
												for clip_sample_range in [1.0, 2.0, 3.0]:
																		self.check_over_configs(clip_sample_range=lowercase_  ,    clip_sample=lowercase_   )






						def       UpperCAmelCase__	(   self					:Tuple   )							->     Optional[Any]:
												for prediction_type in ["epsilon", "v_prediction", "sample"]:
																		self.check_over_configs(prediction_type=lowercase_   )






						def       UpperCAmelCase__	(   self					:int   )							->     Optional[Any]:
												UpperCAmelCase			 =					self.scheduler_classes[0]
												UpperCAmelCase			 =					self.get_scheduler_config()
												UpperCAmelCase			 =					scheduler_class(**lowercase_   )

												scheduler.set_timesteps(self.num_inference_steps   )

												UpperCAmelCase			 =					self.dummy_model()
												UpperCAmelCase			 =					self.dummy_sample_deter * scheduler.init_noise_sigma
												UpperCAmelCase			 =					sample.to(lowercase_   )

												for i, t in enumerate(scheduler.timesteps   ):
																		UpperCAmelCase			 =					scheduler.scale_model_input(lowercase_  ,    lowercase_   )

																		UpperCAmelCase			 =					model(lowercase_  ,    lowercase_   )

																		UpperCAmelCase			 =					scheduler.step(lowercase_  ,    lowercase_  ,    lowercase_   )
																		UpperCAmelCase			 =					output.prev_sample

												UpperCAmelCase			 =					torch.sum(torch.abs(lowercase_   )   )
												UpperCAmelCase			 =					torch.mean(torch.abs(lowercase_   )   )

												if torch_device in ["cpu", "mps"]:
																		assert abs(result_sum.item() - 0.1233   ) < 1E-2
																		assert abs(result_mean.item() - 0.0002   ) < 1E-3
												else:
																		# CUDA
																		assert abs(result_sum.item() - 0.1233   ) < 1E-2
																		assert abs(result_mean.item() - 0.0002   ) < 1E-3






						def       UpperCAmelCase__	(   self					:Tuple   )							->     int:
												UpperCAmelCase			 =					self.scheduler_classes[0]
												UpperCAmelCase			 =					self.get_scheduler_config(prediction_type='v_prediction'   )
												UpperCAmelCase			 =					scheduler_class(**lowercase_   )

												scheduler.set_timesteps(self.num_inference_steps   )

												UpperCAmelCase			 =					self.dummy_model()
												UpperCAmelCase			 =					self.dummy_sample_deter * scheduler.init_noise_sigma
												UpperCAmelCase			 =					sample.to(lowercase_   )

												for i, t in enumerate(scheduler.timesteps   ):
																		UpperCAmelCase			 =					scheduler.scale_model_input(lowercase_  ,    lowercase_   )

																		UpperCAmelCase			 =					model(lowercase_  ,    lowercase_   )

																		UpperCAmelCase			 =					scheduler.step(lowercase_  ,    lowercase_  ,    lowercase_   )
																		UpperCAmelCase			 =					output.prev_sample

												UpperCAmelCase			 =					torch.sum(torch.abs(lowercase_   )   )
												UpperCAmelCase			 =					torch.mean(torch.abs(lowercase_   )   )

												if torch_device in ["cpu", "mps"]:
																		assert abs(result_sum.item() - 4.6_934E-07   ) < 1E-2
																		assert abs(result_mean.item() - 6.1_112E-10   ) < 1E-3
												else:
																		# CUDA
																		assert abs(result_sum.item() - 4.693_428_650_170_972E-07   ) < 1E-2
																		assert abs(result_mean.item() - 0.0002   ) < 1E-3






						def       UpperCAmelCase__	(   self					:str   )							->     int:
												UpperCAmelCase			 =					self.scheduler_classes[0]
												UpperCAmelCase			 =					self.get_scheduler_config()
												UpperCAmelCase			 =					scheduler_class(**lowercase_   )

												scheduler.set_timesteps(self.num_inference_steps  ,    device=lowercase_   )

												UpperCAmelCase			 =					self.dummy_model()
												UpperCAmelCase			 =					self.dummy_sample_deter.to(lowercase_   ) * scheduler.init_noise_sigma

												for t in scheduler.timesteps:
																		UpperCAmelCase			 =					scheduler.scale_model_input(lowercase_  ,    lowercase_   )

																		UpperCAmelCase			 =					model(lowercase_  ,    lowercase_   )

																		UpperCAmelCase			 =					scheduler.step(lowercase_  ,    lowercase_  ,    lowercase_   )
																		UpperCAmelCase			 =					output.prev_sample

												UpperCAmelCase			 =					torch.sum(torch.abs(lowercase_   )   )
												UpperCAmelCase			 =					torch.mean(torch.abs(lowercase_   )   )

												if str(lowercase_   ).startswith('cpu'   ):
																		# The following sum varies between 148 and 156 on mps. Why?
																		assert abs(result_sum.item() - 0.1233   ) < 1E-2
																		assert abs(result_mean.item() - 0.0002   ) < 1E-3
												elif str(lowercase_   ).startswith('mps'   ):
																		# Larger tolerance on mps
																		assert abs(result_mean.item() - 0.0002   ) < 1E-2
												else:
																		# CUDA
																		assert abs(result_sum.item() - 0.1233   ) < 1E-2
																		assert abs(result_mean.item() - 0.0002   ) < 1E-3






						def       UpperCAmelCase__	(   self					:List[Any]   )							->     Optional[Any]:
												UpperCAmelCase			 =					self.scheduler_classes[0]
												UpperCAmelCase			 =					self.get_scheduler_config()
												UpperCAmelCase			 =					scheduler_class(**lowercase_  ,    use_karras_sigmas=lowercase_   )

												scheduler.set_timesteps(self.num_inference_steps  ,    device=lowercase_   )

												UpperCAmelCase			 =					self.dummy_model()
												UpperCAmelCase			 =					self.dummy_sample_deter.to(lowercase_   ) * scheduler.init_noise_sigma
												UpperCAmelCase			 =					sample.to(lowercase_   )

												for t in scheduler.timesteps:
																		UpperCAmelCase			 =					scheduler.scale_model_input(lowercase_  ,    lowercase_   )

																		UpperCAmelCase			 =					model(lowercase_  ,    lowercase_   )

																		UpperCAmelCase			 =					scheduler.step(lowercase_  ,    lowercase_  ,    lowercase_   )
																		UpperCAmelCase			 =					output.prev_sample

												UpperCAmelCase			 =					torch.sum(torch.abs(lowercase_   )   )
												UpperCAmelCase			 =					torch.mean(torch.abs(lowercase_   )   )

												assert abs(result_sum.item() - 0.0_0015   ) < 1E-2
												assert abs(result_mean.item() - 1.9_869_554_535_034_695E-07   ) < 1E-2









"""simple docstring"""
import argparse
import json
import os.path
from collections import OrderedDict

import numpy as np
import requests
import torch
from flax.training.checkpoints import restore_checkpoint
from huggingface_hub import hf_hub_download

from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
from transformers.image_utils import PILImageResampling






def 						lowercase				(	_snake_case		: Optional[Any]	)	->Union[str, Any]:
	"""simple docstring"""





	__snake_case      :		str         =							'''https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint'''

	with open(_snake_case	,  '''wb'''	) as f:
		with requests.get(_snake_case	,  stream=_snake_case	) as req:
			for chunk in req.iter_content(chunk_size=2_048	):
				f.write(_snake_case	)






def 						lowercase				(	)	->VivitConfig:
	"""simple docstring"""





	__snake_case      :		int         =							VivitConfig()

	__snake_case      :		Tuple         =							400
	__snake_case      :		Tuple         =							'''huggingface/label-files'''
	__snake_case      :		List[str]         =							'''kinetics400-id2label.json'''

	__snake_case      :		Dict         =							json.load(open(hf_hub_download(_snake_case	,  _snake_case	,  repo_type='''dataset'''	)	,  '''r'''	)	)
	__snake_case      :		List[str]         =							{int(_snake_case	): v for k, v in idalabel.items()}
	__snake_case      :		Tuple         =							idalabel
	__snake_case      :		Optional[int]         =							{v: k for k, v in idalabel.items()}
	return config






def 						lowercase				(	)	->Optional[int]:
	"""simple docstring"""





	__snake_case      :		List[Any]         =							hf_hub_download(
	    repo_id='''hf-internal-testing/spaghetti-video'''	,  filename='''eating_spaghetti_32_frames.npy'''	,  repo_type='''dataset'''	)
	__snake_case      :		str         =							np.load(_snake_case	)
	return list(_snake_case	)






def 						lowercase				(	_snake_case		: np.ndarray	)	->str:
	"""simple docstring"""





	if np.ndim(_snake_case	) == 2:
		return transform_attention_bias(_snake_case	)

	elif np.ndim(_snake_case	) == 3:
		return transform_attention_kernel(_snake_case	)

	else:
		raise Exception(f"""Invalid number of dimesions: {np.ndim(_snake_case	)}"""	)






def 						lowercase				(	_snake_case		: np.ndarray	)	->Tuple:
	"""simple docstring"""





	return current.flatten()






def 						lowercase				(	_snake_case		: np.ndarray	)	->List[str]:
	"""simple docstring"""





	return np.reshape(_snake_case	,  (current.shape[0], current.shape[1] * current.shape[2])	).T






def 						lowercase				(	_snake_case		: np.ndarray	)	->Optional[Any]:
	"""simple docstring"""





	return np.reshape(_snake_case	,  (current.shape[0] * current.shape[1], current.shape[2])	).T






def 						lowercase				(	_snake_case		: Dict	,  _snake_case		: Tuple	)	->Tuple:
	"""simple docstring"""





	__snake_case      :		int         =							state_dict['''optimizer''']['''target''']['''Transformer'''][f"""encoderblock_{i}"""]

	__snake_case      :		Optional[int]         =							f"""encoder.layer.{i}."""
	__snake_case      :		Dict         =							{
	    prefix + '''intermediate.dense.bias''': state['''MlpBlock_0''']['''Dense_0''']['''bias'''],
	    prefix + '''intermediate.dense.weight''': np.transpose(state['''MlpBlock_0''']['''Dense_0''']['''kernel''']	),
	    prefix + '''output.dense.bias''': state['''MlpBlock_0''']['''Dense_1''']['''bias'''],
	    prefix + '''output.dense.weight''': np.transpose(state['''MlpBlock_0''']['''Dense_1''']['''kernel''']	),
	    prefix + '''layernorm_before.bias''': state['''LayerNorm_0''']['''bias'''],
	    prefix + '''layernorm_before.weight''': state['''LayerNorm_0''']['''scale'''],
	    prefix + '''layernorm_after.bias''': state['''LayerNorm_1''']['''bias'''],
	    prefix + '''layernorm_after.weight''': state['''LayerNorm_1''']['''scale'''],
	    prefix
	    + '''attention.attention.query.bias''': transform_attention(
	        state['''MultiHeadDotProductAttention_0''']['''query''']['''bias''']	),
	    prefix
	    + '''attention.attention.query.weight''': transform_attention(
	        state['''MultiHeadDotProductAttention_0''']['''query''']['''kernel''']	),
	    prefix
	    + '''attention.attention.key.bias''': transform_attention(state['''MultiHeadDotProductAttention_0''']['''key''']['''bias''']	),
	    prefix
	    + '''attention.attention.key.weight''': transform_attention(
	        state['''MultiHeadDotProductAttention_0''']['''key''']['''kernel''']	),
	    prefix
	    + '''attention.attention.value.bias''': transform_attention(
	        state['''MultiHeadDotProductAttention_0''']['''value''']['''bias''']	),
	    prefix
	    + '''attention.attention.value.weight''': transform_attention(
	        state['''MultiHeadDotProductAttention_0''']['''value''']['''kernel''']	),
	    prefix + '''attention.output.dense.bias''': state['''MultiHeadDotProductAttention_0''']['''out''']['''bias'''],
	    prefix
	    + '''attention.output.dense.weight''': transform_attention_output_weight(
	        state['''MultiHeadDotProductAttention_0''']['''out''']['''kernel''']	),
	}

	return new_state






def 						lowercase				(	_snake_case		: int	)	->List[str]:
	"""simple docstring"""





	return sum([1 if '''encoderblock_''' in k else 0 for k in state_dict['''optimizer''']['''target''']['''Transformer'''].keys()]	)






def 						lowercase				(	_snake_case		: Optional[Any]	,  _snake_case		: Optional[int]=False	)	->Union[str, Any]:
	"""simple docstring"""





	__snake_case      :		Tuple         =							get_n_layers(_snake_case	)

	__snake_case      :		str         =							OrderedDict()

	__snake_case      :		List[Any]         =							state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''bias''']
	__snake_case      :		List[str]         =							state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''scale''']

	__snake_case      :		Optional[Any]         =							np.transpose(
	    state_dict['''optimizer''']['''target''']['''embedding''']['''kernel''']	,  (4, 3, 0, 1, 2)	)
	__snake_case      :		Optional[Any]         =							state_dict['''optimizer''']['''target''']['''embedding''']['''bias''']

	__snake_case      :		Union[str, Any]         =							state_dict['''optimizer''']['''target''']['''cls''']
	__snake_case      :		List[str]         =							state_dict['''optimizer''']['''target''']['''Transformer''']['''posembed_input'''][
	    '''pos_embedding'''
	]

	for i in range(_snake_case	):
		new_state.update(transform_state_encoder_block(_snake_case	,  _snake_case	)	)

	if classification_head:
		__snake_case      :		List[Any]         =							{'''vivit.''' + k: v for k, v in new_state.items()}
		__snake_case      :		str         =							np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''kernel''']	)
		__snake_case      :		int         =							np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''bias''']	)

	return {k: torch.tensor(_snake_case	) for k, v in new_state.items()}






def 						lowercase				(	)	->VivitImageProcessor:
	"""simple docstring"""





	__snake_case      :		List[str]         =							VivitImageProcessor()

	assert extractor.do_resize is True
	assert extractor.size == {"shortest_edge": 256}
	assert extractor.do_center_crop is True
	assert extractor.crop_size == {"width": 224, "height": 224}
	assert extractor.resample == PILImageResampling.BILINEAR

	# here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
	# one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
	# which effectively means no normalization (and ViViT does not overwrite those when calling this func)
	assert extractor.do_normalize is False
	assert extractor.do_rescale is True
	assert extractor.rescale_factor == 1 / 255

	# zero-centering = True in original implementation
	assert extractor.do_zero_centering is True

	return extractor






def 						lowercase				(	_snake_case		: str	)	->Optional[Any]:
	"""simple docstring"""





	__snake_case      :		Tuple         =							'''checkpoint'''

	if not os.path.exists(_snake_case	):
		download_checkpoint(_snake_case	)

	__snake_case      :		List[Any]         =							restore_checkpoint(_snake_case	,  _snake_case	)
	__snake_case      :		Union[str, Any]         =							transform_state(_snake_case	,  classification_head=_snake_case	)

	__snake_case      :		Optional[Any]         =							get_vivit_config()

	assert config.image_size == 224
	assert config.num_frames == 32

	__snake_case      :		List[str]         =							VivitForVideoClassification(_snake_case	)
	model.load_state_dict(_snake_case	)
	model.eval()

	__snake_case      :		Tuple         =							get_processor()

	__snake_case      :		Any         =							prepare_video()
	__snake_case      :		List[str]         =							extractor(_snake_case	,  return_tensors='''pt'''	)

	__snake_case      :		Union[str, Any]         =							model(**_snake_case	)

	__snake_case      :		List[str]         =							torch.Size([1, 400]	)
	__snake_case      :		Optional[int]         =							torch.tensor([-1.0543, 2.0764, -0.2104, 0.4439, -0.9658]	)

	assert outputs.logits.shape == expected_shape
	assert torch.allclose(outputs.logits[0, :5]	,  _snake_case	,  atol=1e-4	), outputs.logits[0, :5]

	model.save_pretrained(_snake_case	)
	extractor.save_pretrained(_snake_case	)


if __name__ == "__main__":
			SCREAMING_SNAKE_CASE					:       Optional[Any]							   =							argparse.ArgumentParser()

			parser.add_argument("""--output_model_name""", """-o""", type=str, help="""Output path for the converted HuggingFace model""")

			SCREAMING_SNAKE_CASE					:       List[str]							   =							parser.parse_args()
			convert(args.output_model_name)





