




import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, slow, torch_device

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin





class 		A__				(   __SCREAMING_SNAKE_CASE		,     __SCREAMING_SNAKE_CASE		,     unittest.TestCase ):
	lowerCamelCase__		: Optional[Any]				    =UNetaDModel
	lowerCamelCase__		: Optional[Any]				    ="sample"






	@property
	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						__magic_name__					:							List[Any]		   =							4
						__magic_name__					:							Optional[int]		   =							14
						__magic_name__					:							Optional[Any]		   =							16

						__magic_name__					:							Optional[int]		   =							floats_tensor((batch_size, num_features, seq_len)						).to(lowerCamelCase						)
						__magic_name__					:							int		   =							torch.tensor([10] * batch_size						).to(lowerCamelCase						)

						return {"sample": noise, "timestep": time_step}






	@property
	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						return (4, 14, 16)






	@property
	def  lowercase      (	self						)      ->   List[Any]:




						"""simple docstring"""






						return (4, 14, 16)






	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						pass






	def  lowercase      (	self						)      ->   List[str]:




						"""simple docstring"""






						pass






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Optional[int]:




						"""simple docstring"""






						super().test_determinism()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Union[str, Any]:




						"""simple docstring"""






						super().test_outputs_equivalence()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   List[str]:




						"""simple docstring"""






						super().test_from_save_pretrained()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Optional[int]:




						"""simple docstring"""






						super().test_from_save_pretrained_variant()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						super().test_model_from_pretrained()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						super().test_output()






	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							Any		   =							{
						    '''block_out_channels''': (32, 64, 128, 256),
						    '''in_channels''': 14,
						    '''out_channels''': 14,
						    '''time_embedding_type''': '''positional''',
						    '''use_timestep_embedding''': True,
						    '''flip_sin_to_cos''': False,
						    '''freq_shift''': 1.0,
						    '''out_block_type''': '''OutConv1DBlock''',
						    '''mid_block_type''': '''MidResTemporalBlock1D''',
						    '''down_block_types''': ('''DownResnetBlock1D''', '''DownResnetBlock1D''', '''DownResnetBlock1D''', '''DownResnetBlock1D'''),
						    '''up_block_types''': ('''UpResnetBlock1D''', '''UpResnetBlock1D''', '''UpResnetBlock1D'''),
						    '''act_fn''': '''mish''',
						}
						__magic_name__					:							Union[str, Any]		   =							self.dummy_input
						return init_dict, inputs_dict






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__   , __magic_name__					:							int		   =							UNetaDModel.from_pretrained(
						    '''bglick13/hopper-medium-v2-value-function-hor32'''				,     output_loading_info=lowerCamelCase				,     subfolder='''unet'''						)
						self.assertIsNotNone(lowerCamelCase						)
						self.assertEqual(len(loading_info['''missing_keys''']						)				,     0						)

						model.to(lowerCamelCase						)
						__magic_name__					:							int		   =							model(**self.dummy_input						)

						assert image is not None, "Make sure output is not None"






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   List[str]:




						"""simple docstring"""






						__magic_name__					:							Union[str, Any]		   =							UNetaDModel.from_pretrained('''bglick13/hopper-medium-v2-value-function-hor32'''				,     subfolder='''unet'''						)
						torch.manual_seed(0						)
						if torch.cuda.is_available():
											torch.cuda.manual_seed_all(0						)

						__magic_name__					:							int		   =							model.config.in_channels
						__magic_name__					:							List[str]		   =							16
						__magic_name__					:							List[str]		   =							torch.randn((1, seq_len, num_features)						).permute(
						    0				,     2				,     1						)  # match original, we can update values and remove
						__magic_name__					:							Dict		   =							torch.full((num_features,)				,     0						)

						with torch.no_grad():
											__magic_name__					:							Union[str, Any]		   =							model(lowerCamelCase				,     lowerCamelCase						).sample.permute(0				,     2				,     1						)

						__magic_name__					:							Dict		   =							output[0, -3:, -3:].flatten()
						# fmt: off
						__magic_name__					:							Union[str, Any]		   =							torch.tensor([-2.1_3_7_1_7_2, 1.1_4_2_6_0_1_6, 0.3_6_8_8_6_8_7, -0.7_6_6_9_2_2, 0.7_3_0_3_1_4_6, 0.1_1_0_3_8_8_6_4, -0.4_7_6_0_6_3_3, 0.1_3_2_7_0_1_7_2, 0.0_2_5_9_1_3_4_8]						)
						# fmt: on
						self.assertTrue(torch.allclose(lowerCamelCase				,     lowerCamelCase				,     rtol=1e-3						)						)






	def  lowercase      (	self						)      ->   List[Any]:




						"""simple docstring"""






						pass






	@slow
	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							Any		   =							'''harmonai/maestro-150k'''
						__magic_name__					:							Optional[Any]		   =							UNetaDModel.from_pretrained(lowerCamelCase				,     subfolder='''unet'''						)
						model.to(lowerCamelCase						)

						__magic_name__					:							int		   =							65536
						__magic_name__					:							Optional[int]		   =							torch.sin(torch.arange(lowerCamelCase						)[None, None, :].repeat(1				,     2				,     1						)						).to(lowerCamelCase						)
						__magic_name__					:							Optional[Any]		   =							torch.tensor([1]						).to(lowerCamelCase						)

						with torch.no_grad():
											__magic_name__					:							List[Any]		   =							model(lowerCamelCase				,     lowerCamelCase						).sample

						__magic_name__					:							List[Any]		   =							output.abs().sum()
						__magic_name__					:							Union[str, Any]		   =							output.abs().max()

						assert (output_sum - 2_2_4.0_8_9_6).abs() < 0.5
						assert (output_max - 0.0_6_0_7).abs() < 4e-4





class 		A__				(   __SCREAMING_SNAKE_CASE		,     __SCREAMING_SNAKE_CASE		,     unittest.TestCase ):
	lowerCamelCase__		: Union[str, Any]				    =UNetaDModel
	lowerCamelCase__		: List[Any]				    ="sample"






	@property
	def  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






						__magic_name__					:							List[Any]		   =							4
						__magic_name__					:							List[str]		   =							14
						__magic_name__					:							int		   =							16

						__magic_name__					:							List[Any]		   =							floats_tensor((batch_size, num_features, seq_len)						).to(lowerCamelCase						)
						__magic_name__					:							List[str]		   =							torch.tensor([10] * batch_size						).to(lowerCamelCase						)

						return {"sample": noise, "timestep": time_step}






	@property
	def  lowercase      (	self						)      ->   int:




						"""simple docstring"""






						return (4, 14, 16)






	@property
	def  lowercase      (	self						)      ->   Optional[int]:




						"""simple docstring"""






						return (4, 14, 1)






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						super().test_determinism()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						super().test_outputs_equivalence()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   List[str]:




						"""simple docstring"""






						super().test_from_save_pretrained()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Optional[Any]:




						"""simple docstring"""






						super().test_from_save_pretrained_variant()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   int:




						"""simple docstring"""






						super().test_model_from_pretrained()






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Optional[Any]:




						"""simple docstring"""






						__magic_name__   , __magic_name__					:							Optional[int]		   =							self.prepare_init_args_and_inputs_for_common()
						__magic_name__					:							int		   =							self.model_class(**lowerCamelCase						)
						model.to(lowerCamelCase						)
						model.eval()

						with torch.no_grad():
											__magic_name__					:							int		   =							model(**lowerCamelCase						)

											if isinstance(lowerCamelCase				,     lowerCamelCase						):
																__magic_name__					:							Optional[int]		   =							output.sample

						self.assertIsNotNone(lowerCamelCase						)
						__magic_name__					:							int		   =							torch.Size((inputs_dict['''sample'''].shape[0], 1)						)
						self.assertEqual(output.shape				,     lowerCamelCase				,     '''Input and output shapes do not match'''						)






	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						pass






	def  lowercase      (	self						)      ->   Union[str, Any]:




						"""simple docstring"""






						pass






	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							Any		   =							{
						    '''in_channels''': 14,
						    '''out_channels''': 14,
						    '''down_block_types''': ['''DownResnetBlock1D''', '''DownResnetBlock1D''', '''DownResnetBlock1D''', '''DownResnetBlock1D'''],
						    '''up_block_types''': [],
						    '''out_block_type''': '''ValueFunction''',
						    '''mid_block_type''': '''ValueFunctionMidBlock1D''',
						    '''block_out_channels''': [32, 64, 128, 256],
						    '''layers_per_block''': 1,
						    '''downsample_each_block''': True,
						    '''use_timestep_embedding''': True,
						    '''freq_shift''': 1.0,
						    '''flip_sin_to_cos''': False,
						    '''time_embedding_type''': '''positional''',
						    '''act_fn''': '''mish''',
						}
						__magic_name__					:							Optional[Any]		   =							self.dummy_input
						return init_dict, inputs_dict






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   List[str]:




						"""simple docstring"""






						__magic_name__   , __magic_name__					:							Any		   =							UNetaDModel.from_pretrained(
						    '''bglick13/hopper-medium-v2-value-function-hor32'''				,     output_loading_info=lowerCamelCase				,     subfolder='''value_function'''						)
						self.assertIsNotNone(lowerCamelCase						)
						self.assertEqual(len(vf_loading_info['''missing_keys''']						)				,     0						)

						value_function.to(lowerCamelCase						)
						__magic_name__					:							List[str]		   =							value_function(**self.dummy_input						)

						assert image is not None, "Make sure output is not None"






	@unittest.skipIf(torch_device == '''mps'''				,     '''mish op not supported in MPS'''						)
	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__   , __magic_name__					:							Tuple		   =							UNetaDModel.from_pretrained(
						    '''bglick13/hopper-medium-v2-value-function-hor32'''				,     output_loading_info=lowerCamelCase				,     subfolder='''value_function'''						)
						torch.manual_seed(0						)
						if torch.cuda.is_available():
											torch.cuda.manual_seed_all(0						)

						__magic_name__					:							str		   =							value_function.config.in_channels
						__magic_name__					:							Optional[int]		   =							14
						__magic_name__					:							Tuple		   =							torch.randn((1, seq_len, num_features)						).permute(
						    0				,     2				,     1						)  # match original, we can update values and remove
						__magic_name__					:							Tuple		   =							torch.full((num_features,)				,     0						)

						with torch.no_grad():
											__magic_name__					:							Optional[int]		   =							value_function(lowerCamelCase				,     lowerCamelCase						).sample

						# fmt: off
						__magic_name__					:							Dict		   =							torch.tensor([1_6_5.2_5] * seq_len						)
						# fmt: on
						self.assertTrue(torch.allclose(lowerCamelCase				,     lowerCamelCase				,     rtol=1e-3						)						)






	def  lowercase      (	self						)      ->   Optional[Any]:




						"""simple docstring"""






						pass









def  lowerCAmelCase  (	UpperCAmelCase       )  ->int:






					"""simple docstring"""






					return n * (2 * n - 1)







def  lowerCAmelCase  (	UpperCAmelCase       )  ->bool:






					"""simple docstring"""






					__magic_name__					:							Any		   =							(1 + 24 * n) ** 0.5
					return ((1 + root) / 6) % 1 == 0







def  lowerCAmelCase  (	UpperCAmelCase = 144       )  ->int:






					"""simple docstring"""






					__magic_name__					:							Optional[int]		   =							start
					__magic_name__					:							int		   =							hexagonal_num(UpperCAmelCase       )
					while not is_pentagonal(UpperCAmelCase       ):
										n += 1
										__magic_name__					:							Optional[int]		   =							hexagonal_num(UpperCAmelCase       )
					return num


if __name__ == "__main__":
				print(f"{solution()} = ")



