


'''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        UpperCAmelCase       (				__SCREAMING_SNAKE_CASE						,	__SCREAMING_SNAKE_CASE						,	unittest.TestCase):
 _lowerCamelCase       :    Optional[Any]			    =    UNetaDModel
 _lowerCamelCase       :    Optional[Any]			    =    "sample"

 @property
 def 						lowercase_  (       self       :		Any    ):





    """simple docstring"""



    UpperCamelCase__         =  4
    UpperCamelCase__         =  14
    UpperCamelCase__         =  16

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

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

 @property
 def 						lowercase_  (       self       :		int    ):





    """simple docstring"""



    return (4, 14, 16)

 @property
 def 						lowercase_  (       self       :		int    ):





    """simple docstring"""



    return (4, 14, 16)

 def 						lowercase_  (       self       :		List[str]    ):





    """simple docstring"""



    pass

 def 						lowercase_  (       self       :		List[Any]    ):





    """simple docstring"""



    pass

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





    """simple docstring"""



    super().test_determinism()

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





    """simple docstring"""



    super().test_outputs_equivalence()

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





    """simple docstring"""



    super().test_from_save_pretrained()

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





    """simple docstring"""



    super().test_from_save_pretrained_variant()

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





    """simple docstring"""



    super().test_model_from_pretrained()

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





    """simple docstring"""



    super().test_output()

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





    """simple docstring"""



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

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





    """simple docstring"""



    UpperCamelCase__         =  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_    )
    UpperCamelCase__         =  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"""



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

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

    with torch.no_grad():
       UpperCamelCase__         =  model(a_,    a_    ).sample.permute(0,    2,    1    )

    UpperCamelCase__         =  output[0, -3:, -3:].flatten()
    # fmt: off
    UpperCamelCase__         =  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 						lowercase_  (       self       :		Union[str, Any]    ):





    """simple docstring"""



    pass

 @slow
 def 						lowercase_  (       self       :		List[str]    ):





    """simple docstring"""



    UpperCamelCase__         =  '''harmonai/maestro-150k'''
    UpperCamelCase__         =  UNetaDModel.from_pretrained(a_,    subfolder="unet"    )
    model.to(a_    )

    UpperCamelCase__         =  6_5536
    UpperCamelCase__         =  torch.sin(torch.arange(a_    )[None, None, :].repeat(1,    2,    1    )    ).to(a_    )
    UpperCamelCase__         =  torch.tensor([1]    ).to(a_    )

    with torch.no_grad():
       UpperCamelCase__         =  model(a_,    a_    ).sample

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

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







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

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





    """simple docstring"""



    UpperCamelCase__         =  4
    UpperCamelCase__         =  14
    UpperCamelCase__         =  16

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

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

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





    """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       :		Optional[Any]    ):





    """simple docstring"""



    super().test_determinism()

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





    """simple docstring"""



    super().test_outputs_equivalence()

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





    """simple docstring"""



    super().test_from_save_pretrained()

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





    """simple docstring"""



    super().test_from_save_pretrained_variant()

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





    """simple docstring"""



    super().test_model_from_pretrained()

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





    """simple docstring"""



    UpperCamelCase__         =  self.prepare_init_args_and_inputs_for_common()
    UpperCamelCase__         =  self.model_class(**a_    )
    model.to(a_    )
    model.eval()

    with torch.no_grad():
       UpperCamelCase__         =  model(**a_    )

       if isinstance(a_,    a_    ):
          UpperCamelCase__         =  output.sample

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

 def 						lowercase_  (       self       :		Optional[int]    ):





    """simple docstring"""



    pass

 def 						lowercase_  (       self       :		List[Any]    ):





    """simple docstring"""



    pass

 def 						lowercase_  (       self       :		str    ):





    """simple docstring"""



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

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





    """simple docstring"""



    UpperCamelCase__         =  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_    )
    UpperCamelCase__         =  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       :		List[Any]    ):





    """simple docstring"""



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

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

    with torch.no_grad():
       UpperCamelCase__         =  value_function(a_,    a_    ).sample

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

 def 						lowercase_  (       self       :		Any    ):





    """simple docstring"""



    pass





import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
				import tensorflow as tf

				from transformers.activations_tf import get_tf_activation





@require_tf
class 		A__				(   unittest.TestCase ):






	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						__magic_name__					:							int		   =							tf.constant([-100, -1.0, -0.1, 0, 0.1, 1.0, 1_0_0.0]						)
						__magic_name__					:							List[str]		   =							get_tf_activation('''gelu'''						)
						__magic_name__					:							str		   =							get_tf_activation('''gelu_10'''						)

						__magic_name__					:							List[str]		   =							gelu(lowerCamelCase						)
						__magic_name__					:							Optional[Any]		   =							geluaa(lowerCamelCase						)

						__magic_name__					:							Optional[int]		   =							tf.where(y_gelu_aa < 1_0.0				,     1.0				,     0.0						)

						self.assertEqual(tf.math.reduce_max(lowerCamelCase						).numpy().item()				,     1_0.0						)
						self.assertTrue(np.allclose(y_gelu * clipped_mask				,     y_gelu_aa * clipped_mask						)						)






	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						get_tf_activation('''gelu'''						)
						get_tf_activation('''gelu_10'''						)
						get_tf_activation('''gelu_fast'''						)
						get_tf_activation('''gelu_new'''						)
						get_tf_activation('''glu'''						)
						get_tf_activation('''mish'''						)
						get_tf_activation('''quick_gelu'''						)
						get_tf_activation('''relu'''						)
						get_tf_activation('''sigmoid'''						)
						get_tf_activation('''silu'''						)
						get_tf_activation('''swish'''						)
						get_tf_activation('''tanh'''						)
						with self.assertRaises(lowerCamelCase						):
											get_tf_activation('''bogus'''						)
						with self.assertRaises(lowerCamelCase						):
											get_tf_activation(lowerCamelCase						)



