

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   __lowercase				(_UpperCAmelCase		,       _UpperCAmelCase		,       unittest.TestCase			):
 _UpperCamelCase        =  UNetaDModel
 _UpperCamelCase        =  """sample"""
 @property
 def      UpperCamelCase__  (							self ) ->Any:



       '''simple docstring'''





       __lowerCAmelCase :						Optional[Any] = 4
       __lowerCAmelCase :						List[str] = 14
       __lowerCAmelCase :						Dict = 16

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

       return {"sample": noise, "timestep": time_step}
 @property
 def      UpperCamelCase__  (							self ) ->Any:



       '''simple docstring'''





       return (4, 14, 16)
 @property
 def      UpperCamelCase__  (							self ) ->str:



       '''simple docstring'''





       return (4, 14, 16)
 def      UpperCamelCase__  (							self ) ->Dict:



       '''simple docstring'''





       pass
 def      UpperCamelCase__  (							self ) ->Dict:



       '''simple docstring'''





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



       '''simple docstring'''





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



       '''simple docstring'''





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



       '''simple docstring'''





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



       '''simple docstring'''





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



       '''simple docstring'''





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



       '''simple docstring'''





       super().test_output()
 def      UpperCamelCase__  (							self ) ->int:



       '''simple docstring'''





       __lowerCAmelCase :						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''',
       }
       __lowerCAmelCase :						int = self.dummy_input
       return init_dict, inputs_dict
 @unittest.skipIf(torch_device == '''mps'''				,							'''mish op not supported in MPS''' )
 def      UpperCamelCase__  (							self ) ->Optional[Any]:



       '''simple docstring'''





       __lowerCAmelCase,							__lowerCAmelCase :						Union[str, Any] = 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 :						List[str] = 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      UpperCamelCase__  (							self ) ->Optional[int]:



       '''simple docstring'''





       __lowerCAmelCase :						Dict = 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 :						Optional[Any] = model.config.in_channels
       __lowerCAmelCase :						List[str] = 16
       __lowerCAmelCase :						Any = torch.randn((1, seq_len, num_features) ).permute(
           0				,							2				,							1 )  # match original, we can update values and remove
       __lowerCAmelCase :						Union[str, Any] = torch.full((num_features,)				,							0 )

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

       __lowerCAmelCase :						Optional[int] = output[0, -3:, -3:].flatten()
       # fmt: off
       __lowerCAmelCase :						Optional[int] = torch.tensor([-2.137_172, 1.1_426_016, 0.3_688_687, -0.766_922, 0.7_303_146, 0.11_038_864, -0.4_760_633, 0.13_270_172, 0.02_591_348] )
       # fmt: on
       self.assertTrue(torch.allclose(A_				,							A_				,							rtol=1e-3 ) )
 def      UpperCamelCase__  (							self ) ->Tuple:



       '''simple docstring'''





       pass





 @slow
 def      UpperCamelCase__  (							self ) ->List[str]:



       '''simple docstring'''





       __lowerCAmelCase :						int = '''harmonai/maestro-150k'''
       __lowerCAmelCase :						List[Any] = UNetaDModel.from_pretrained(A_				,							subfolder='''unet''' )
       model.to(A_ )

       __lowerCAmelCase :						List[Any] = 6_5536
       __lowerCAmelCase :						Tuple = torch.sin(torch.arange(A_ )[None, None, :].repeat(1				,							2				,							1 ) ).to(A_ )
       __lowerCAmelCase :						Any = torch.tensor([1] ).to(A_ )

       with torch.no_grad():
             __lowerCAmelCase :						int = model(A_				,							A_ ).sample

       __lowerCAmelCase :						Optional[int] = output.abs().sum()
       __lowerCAmelCase :						Optional[Any] = output.abs().max()

       assert (output_sum - 224.0_896).abs() < 0.5
       assert (output_max - 0.0_607).abs() < 4e-4







class   __lowercase				(_UpperCAmelCase		,       _UpperCAmelCase		,       unittest.TestCase			):
 _UpperCamelCase        =  UNetaDModel
 _UpperCamelCase        =  """sample"""
 @property
 def      UpperCamelCase__  (							self ) ->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase :						List[Any] = 4
       __lowerCAmelCase :						List[Any] = 14
       __lowerCAmelCase :						Optional[Any] = 16

       __lowerCAmelCase :						int = floats_tensor((batch_size, num_features, seq_len) ).to(A_ )
       __lowerCAmelCase :						int = torch.tensor([10] * batch_size ).to(A_ )

       return {"sample": noise, "timestep": time_step}
 @property
 def      UpperCamelCase__  (							self ) ->Optional[int]:



       '''simple docstring'''





       return (4, 14, 16)
 @property
 def      UpperCamelCase__  (							self ) ->str:



       '''simple docstring'''





       return (4, 14, 1)
 @unittest.skipIf(torch_device == '''mps'''				,							'''mish op not supported in MPS''' )
 def      UpperCamelCase__  (							self ) ->Dict:



       '''simple docstring'''





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



       '''simple docstring'''





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



       '''simple docstring'''





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



       '''simple docstring'''





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



       '''simple docstring'''





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



       '''simple docstring'''





       __lowerCAmelCase,							__lowerCAmelCase :						str = self.prepare_init_args_and_inputs_for_common()
       __lowerCAmelCase :						Union[str, Any] = self.model_class(**A_ )
       model.to(A_ )
       model.eval()

       with torch.no_grad():
             __lowerCAmelCase :						Any = model(**A_ )

             if isinstance(A_				,							A_ ):
                   __lowerCAmelCase :						Dict = output.sample

       self.assertIsNotNone(A_ )
       __lowerCAmelCase :						Dict = torch.Size((inputs_dict['''sample'''].shape[0], 1) )
       self.assertEqual(output.shape				,							A_				,							'''Input and output shapes do not match''' )
 def      UpperCamelCase__  (							self ) ->Tuple:



       '''simple docstring'''





       pass
 def      UpperCamelCase__  (							self ) ->Tuple:



       '''simple docstring'''





       pass
 def      UpperCamelCase__  (							self ) ->List[str]:



       '''simple docstring'''





       __lowerCAmelCase :						Dict = {
           '''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 :						Any = self.dummy_input
       return init_dict, inputs_dict
 @unittest.skipIf(torch_device == '''mps'''				,							'''mish op not supported in MPS''' )
 def      UpperCamelCase__  (							self ) ->Optional[int]:



       '''simple docstring'''





       __lowerCAmelCase,							__lowerCAmelCase :						Optional[Any] = 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 :						Tuple = 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      UpperCamelCase__  (							self ) ->int:



       '''simple docstring'''





       __lowerCAmelCase,							__lowerCAmelCase :						Any = 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 :						Optional[int] = value_function.config.in_channels
       __lowerCAmelCase :						Union[str, Any] = 14
       __lowerCAmelCase :						List[Any] = torch.randn((1, seq_len, num_features) ).permute(
           0				,							2				,							1 )  # match original, we can update values and remove
       __lowerCAmelCase :						Optional[Any] = torch.full((num_features,)				,							0 )

       with torch.no_grad():
             __lowerCAmelCase :						List[str] = value_function(A_				,							A_ ).sample

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





 def      UpperCamelCase__  (							self ) ->Dict:



       '''simple docstring'''





       pass





def 		_lowercase			(					lowercase__       ,     lowercase__						):
      if len(str(lowercase__						)						) == 1 or len(str(lowercase__						)						) == 1:
            return a * b

      __lowerCAmelCase :						Any = max(len(str(lowercase__						)						)       ,     len(str(lowercase__						)						)						)
      __lowerCAmelCase :						Optional[int] = ma // 2

      __lowerCAmelCase,							__lowerCAmelCase :						Tuple = divmod(lowercase__       ,     1_0**ma						)
      __lowerCAmelCase,							__lowerCAmelCase :						Any = divmod(lowercase__       ,     1_0**ma						)

      __lowerCAmelCase :						str = karatsuba(lowercase__       ,     lowercase__						)
      __lowerCAmelCase :						Optional[int] = karatsuba((aa + aa)       ,     (ba + ba)						)
      __lowerCAmelCase :						List[Any] = karatsuba(lowercase__       ,     lowercase__						)

      return (z * 1_0 ** (2 * ma)) + ((y - z - x) * 1_0 ** (ma)) + (x)







def 		_lowercase			(					):
      print(karatsuba(1_5_4_6_3       ,     2_3_4_8_9						)						)


if __name__ == "__main__":
 main()


