
'''simple docstring'''

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       (		lowercase_					, lowercase_					, unittest.TestCase      ):
	snake_case__ :Optional[int]				       =       UNetaDModel
	snake_case__ :Dict				       =       'sample'





	@property
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Tuple							):


				"""simple docstring"""

				lowerCAmelCase__									=							4
				lowerCAmelCase__									=							14
				lowerCAmelCase__									=							16

				lowerCAmelCase__									=							floats_tensor((batch_size, num_features, seq_len)							).to(__UpperCamelCase							)
				lowerCAmelCase__									=							torch.tensor([10] * batch_size							).to(__UpperCamelCase							)

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





	@property
	def 							__SCREAMING_SNAKE_CASE					(   self     :    List[Any]							):


				"""simple docstring"""

				return (4, 14, 16)





	@property
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[Any]							):


				"""simple docstring"""

				return (4, 14, 16)





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Union[str, Any]							):


				"""simple docstring"""

				pass





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[int]							):


				"""simple docstring"""

				pass





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Any							):


				"""simple docstring"""

				super().test_determinism()





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


				"""simple docstring"""

				super().test_outputs_equivalence()





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[int]							):


				"""simple docstring"""

				super().test_from_save_pretrained()





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[int]							):


				"""simple docstring"""

				super().test_from_save_pretrained_variant()





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


				"""simple docstring"""

				super().test_model_from_pretrained()





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    List[Any]							):


				"""simple docstring"""

				super().test_output()





	def 							__SCREAMING_SNAKE_CASE					(   self     :    List[str]							):


				"""simple docstring"""

				lowerCAmelCase__									=							{
				    "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",
				}
				lowerCAmelCase__									=							self.dummy_input
				return init_dict, inputs_dict





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    int							):


				"""simple docstring"""

				lowerCAmelCase__		,lowerCAmelCase__									=							UNetaDModel.from_pretrained(
				    "bglick13/hopper-medium-v2-value-function-hor32" ,							output_loading_info=__UpperCamelCase ,							subfolder="unet"							)
				self.assertIsNotNone(__UpperCamelCase							)
				self.assertEqual(len(loading_info["missing_keys"]							) ,							0							)

				model.to(__UpperCamelCase							)
				lowerCAmelCase__									=							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 							__SCREAMING_SNAKE_CASE					(   self     :    List[str]							):


				"""simple docstring"""

				lowerCAmelCase__									=							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							)

				lowerCAmelCase__									=							model.config.in_channels
				lowerCAmelCase__									=							16
				lowerCAmelCase__									=							torch.randn((1, seq_len, num_features)							).permute(
				    0 ,							2 ,							1							)  # match original, we can update values and remove
				lowerCAmelCase__									=							torch.full((num_features,) ,							0							)

				with torch.no_grad():
							lowerCAmelCase__									=							model(__UpperCamelCase ,							__UpperCamelCase							).sample.permute(0 ,							2 ,							1							)

				lowerCAmelCase__									=							output[0, -3:, -3:].flatten()
				# fmt: off
				lowerCAmelCase__									=							torch.tensor([-2.13_7172, 1.142_6016, 0.368_8687, -0.76_6922, 0.730_3146, 0.1103_8864, -0.476_0633, 0.1327_0172, 0.0259_1348]							)
				# fmt: on
				self.assertTrue(torch.allclose(__UpperCamelCase ,							__UpperCamelCase ,							rtol=1E-3							)							)





	def 							__SCREAMING_SNAKE_CASE					(   self     :    int							):


				"""simple docstring"""

				pass







	@slow
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[Any]							):


				"""simple docstring"""

				lowerCAmelCase__									=							"harmonai/maestro-150k"
				lowerCAmelCase__									=							UNetaDModel.from_pretrained(__UpperCamelCase ,							subfolder="unet"							)
				model.to(__UpperCamelCase							)

				lowerCAmelCase__									=							65536
				lowerCAmelCase__									=							torch.sin(torch.arange(__UpperCamelCase							)[None, None, :].repeat(1 ,							2 ,							1							)							).to(__UpperCamelCase							)
				lowerCAmelCase__									=							torch.tensor([1]							).to(__UpperCamelCase							)

				with torch.no_grad():
							lowerCAmelCase__									=							model(__UpperCamelCase ,							__UpperCamelCase							).sample

				lowerCAmelCase__									=							output.abs().sum()
				lowerCAmelCase__									=							output.abs().max()

				assert (output_sum - 224.0896).abs() < 0.5
				assert (output_max - 0.0607).abs() < 4E-4






class 				A       (		lowercase_					, lowercase_					, unittest.TestCase      ):
	snake_case__ :Dict				       =       UNetaDModel
	snake_case__ :Optional[Any]				       =       'sample'





	@property
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Union[str, Any]							):


				"""simple docstring"""

				lowerCAmelCase__									=							4
				lowerCAmelCase__									=							14
				lowerCAmelCase__									=							16

				lowerCAmelCase__									=							floats_tensor((batch_size, num_features, seq_len)							).to(__UpperCamelCase							)
				lowerCAmelCase__									=							torch.tensor([10] * batch_size							).to(__UpperCamelCase							)

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





	@property
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Tuple							):


				"""simple docstring"""

				return (4, 14, 16)





	@property
	def 							__SCREAMING_SNAKE_CASE					(   self     :    List[Any]							):


				"""simple docstring"""

				return (4, 14, 1)





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Dict							):


				"""simple docstring"""

				super().test_determinism()





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    List[str]							):


				"""simple docstring"""

				super().test_outputs_equivalence()





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    List[Any]							):


				"""simple docstring"""

				super().test_from_save_pretrained()





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


				"""simple docstring"""

				super().test_from_save_pretrained_variant()





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Dict							):


				"""simple docstring"""

				super().test_model_from_pretrained()





	@unittest.skipIf(torch_device == "mps" ,							"mish op not supported in MPS"							)
	def 							__SCREAMING_SNAKE_CASE					(   self     :    Optional[Any]							):


				"""simple docstring"""

				lowerCAmelCase__		,lowerCAmelCase__									=							self.prepare_init_args_and_inputs_for_common()
				lowerCAmelCase__									=							self.model_class(**__UpperCamelCase							)
				model.to(__UpperCamelCase							)
				model.eval()

				with torch.no_grad():
							lowerCAmelCase__									=							model(**__UpperCamelCase							)

							if isinstance(__UpperCamelCase ,							__UpperCamelCase							):
										lowerCAmelCase__									=							output.sample

				self.assertIsNotNone(__UpperCamelCase							)
				lowerCAmelCase__									=							torch.Size((inputs_dict["sample"].shape[0], 1)							)
				self.assertEqual(output.shape ,							__UpperCamelCase ,							"Input and output shapes do not match"							)





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Union[str, Any]							):


				"""simple docstring"""

				pass





	def 							__SCREAMING_SNAKE_CASE					(   self     :    List[str]							):


				"""simple docstring"""

				pass





	def 							__SCREAMING_SNAKE_CASE					(   self     :    Any							):


				"""simple docstring"""

				lowerCAmelCase__									=							{
				    "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",
				}
				lowerCAmelCase__									=							self.dummy_input
				return init_dict, inputs_dict





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


				"""simple docstring"""

				lowerCAmelCase__		,lowerCAmelCase__									=							UNetaDModel.from_pretrained(
				    "bglick13/hopper-medium-v2-value-function-hor32" ,							output_loading_info=__UpperCamelCase ,							subfolder="value_function"							)
				self.assertIsNotNone(__UpperCamelCase							)
				self.assertEqual(len(vf_loading_info["missing_keys"]							) ,							0							)

				value_function.to(__UpperCamelCase							)
				lowerCAmelCase__									=							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 							__SCREAMING_SNAKE_CASE					(   self     :    Tuple							):


				"""simple docstring"""

				lowerCAmelCase__		,lowerCAmelCase__									=							UNetaDModel.from_pretrained(
				    "bglick13/hopper-medium-v2-value-function-hor32" ,							output_loading_info=__UpperCamelCase ,							subfolder="value_function"							)
				torch.manual_seed(0							)
				if torch.cuda.is_available():
							torch.cuda.manual_seed_all(0							)

				lowerCAmelCase__									=							value_function.config.in_channels
				lowerCAmelCase__									=							14
				lowerCAmelCase__									=							torch.randn((1, seq_len, num_features)							).permute(
				    0 ,							2 ,							1							)  # match original, we can update values and remove
				lowerCAmelCase__									=							torch.full((num_features,) ,							0							)

				with torch.no_grad():
							lowerCAmelCase__									=							value_function(__UpperCamelCase ,							__UpperCamelCase							).sample

				# fmt: off
				lowerCAmelCase__									=							torch.tensor([165.25] * seq_len							)
				# fmt: on
				self.assertTrue(torch.allclose(__UpperCamelCase ,							__UpperCamelCase ,							rtol=1E-3							)							)







	def 							__SCREAMING_SNAKE_CASE					(   self     :    Any							):


				"""simple docstring"""

				pass







'''simple docstring'''

def 					A       ( )   ->    str:







			'''simple docstring'''



			lowerCAmelCase__									=							1

			while True:
						if (
						    sorted(str(UpperCamelCase_ ) )
						    == sorted(str(2 * i ) )
						    == sorted(str(3 * i ) )
						    == sorted(str(4 * i ) )
						    == sorted(str(5 * i ) )
						    == sorted(str(6 * i ) )
						):
									return i

						i += 1


if __name__ == "__main__":
		print(solution())





