





"""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   (  lowerCAmelCase__	,						lowerCAmelCase__	,						unittest.TestCase		):
     SCREAMING_SNAKE_CASE__ :      Dict       		=			UNetaDModel
     SCREAMING_SNAKE_CASE__ :      Optional[Any]       		=			"sample"



     @property
     def 						snake_case_			(       self   ):
            _lowerCamelCase    	=					4
            _lowerCamelCase    	=					14
            _lowerCamelCase    	=					16

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

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



     @property
     def 						snake_case_			(       self   ):
            return (4, 14, 16)



     @property
     def 						snake_case_			(       self   ):
            return (4, 14, 16)



     def 						snake_case_			(       self   ):
            pass



     def 						snake_case_			(       self   ):
            pass



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_determinism()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_outputs_equivalence()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_from_save_pretrained()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_from_save_pretrained_variant()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_model_from_pretrained()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_output()



     def 						snake_case_			(       self   ):
            _lowerCamelCase    	=					{
                'block_out_channels': (32, 64, 1_28, 2_56),
                '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 						snake_case_			(       self   ):
            _lowerCamelCase	,	_lowerCamelCase    	=					UNetaDModel.from_pretrained(
                'bglick13/hopper-medium-v2-value-function-hor32'					,     output_loading_info=a__					,     subfolder='unet'   )
            self.assertIsNotNone(a__   )
            self.assertEqual(len(loading_info['missing_keys']   )					,     0   )

            model.to(a__   )
            _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 						snake_case_			(       self   ):
            _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(a__					,     a__   ).sample.permute(0					,     2					,     1   )

            _lowerCamelCase    	=					output[0, -3:, -3:].flatten()
            # fmt: off
            _lowerCamelCase    	=					torch.tensor([-2.137172, 1.1426016, 0.3688687, -0.766922, 0.7303146, 0.11038864, -0.4760633, 0.13270172, 0.02591348]   )
            # fmt: on
            self.assertTrue(torch.allclose(a__					,     a__					,     rtol=1e-3   )   )



     def 						snake_case_			(       self   ):
            # Not implemented yet for this UNet
            pass



     @slow
     def 						snake_case_			(       self   ):
            _lowerCamelCase    	=					'harmonai/maestro-150k'
            _lowerCamelCase    	=					UNetaDModel.from_pretrained(a__					,     subfolder='unet'   )
            model.to(a__   )

            _lowerCamelCase    	=					6_55_36
            _lowerCamelCase    	=					torch.sin(torch.arange(a__   )[None, None, :].repeat(1					,     2					,     1   )   ).to(a__   )
            _lowerCamelCase    	=					torch.tensor([1]   ).to(a__   )

            with torch.no_grad():
                   _lowerCamelCase    	=					model(a__					,     a__   ).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   (  lowerCAmelCase__	,						lowerCAmelCase__	,						unittest.TestCase		):
     SCREAMING_SNAKE_CASE__ :      List[str]       		=			UNetaDModel
     SCREAMING_SNAKE_CASE__ :      Optional[Any]       		=			"sample"



     @property
     def 						snake_case_			(       self   ):
            _lowerCamelCase    	=					4
            _lowerCamelCase    	=					14
            _lowerCamelCase    	=					16

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

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



     @property
     def 						snake_case_			(       self   ):
            return (4, 14, 16)



     @property
     def 						snake_case_			(       self   ):
            return (4, 14, 1)



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_determinism()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_outputs_equivalence()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_from_save_pretrained()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_from_save_pretrained_variant()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            super().test_model_from_pretrained()



     @unittest.skipIf(torch_device == 'mps'					,     'mish op not supported in MPS'   )
     def 						snake_case_			(       self   ):
            # UNetRL is a value-function is different output shape
            _lowerCamelCase	,	_lowerCamelCase    	=					self.prepare_init_args_and_inputs_for_common()
            _lowerCamelCase    	=					self.model_class(**a__   )
            model.to(a__   )
            model.eval()

            with torch.no_grad():
                   _lowerCamelCase    	=					model(**a__   )

                   if isinstance(a__					,     a__   ):
                          _lowerCamelCase    	=					output.sample

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



     def 						snake_case_			(       self   ):
            pass



     def 						snake_case_			(       self   ):
            pass



     def 						snake_case_			(       self   ):
            _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, 1_28, 2_56],
                '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 						snake_case_			(       self   ):
            _lowerCamelCase	,	_lowerCamelCase    	=					UNetaDModel.from_pretrained(
                'bglick13/hopper-medium-v2-value-function-hor32'					,     output_loading_info=a__					,     subfolder='value_function'   )
            self.assertIsNotNone(a__   )
            self.assertEqual(len(vf_loading_info['missing_keys']   )					,     0   )

            value_function.to(a__   )
            _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 						snake_case_			(       self   ):
            _lowerCamelCase	,	_lowerCamelCase    	=					UNetaDModel.from_pretrained(
                'bglick13/hopper-medium-v2-value-function-hor32'					,     output_loading_info=a__					,     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(a__					,     a__   ).sample

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



     def 						snake_case_			(       self   ):
            # Not implemented yet for this UNet
            pass













"""simple docstring"""


def SCREAMING_SNAKE_CASE_   (       )->		Tuple:
       _lowerCamelCase    	=					1

       while True:
              if (
                  sorted(str(snake_case		)		)
                  == 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())






