code: 
  
  
  
  
  
  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_     (     snake_case__     ,    snake_case__     ,    unittest.TestCase       ):
  					_a			:	Tuple							=				UNetaDModel
  					_a			:	Dict							=				'sample'
  
  
  
  					@property
  					def      __a    (		self    :    Optional[int]	):
  							lowerCamelCase_  :    str   	=			4
  							lowerCamelCase_  :    Tuple   	=			14
  							lowerCamelCase_  :    int   	=			16
  
  							lowerCamelCase_  :    Optional[Any]   	=			floats_tensor((batch_size, num_features, seq_len)	).to(lowerCamelCase	)
  							lowerCamelCase_  :    List[Any]   	=			torch.tensor([10] * batch_size	).to(lowerCamelCase	)
  
  							return {"sample": noise, "timestep": time_step}
  
  
  
  					@property
  					def      __a    (		self    :    Any	):
  							return (4, 14, 16)
  
  
  
  					@property
  					def      __a    (		self    :    str	):
  							return (4, 14, 16)
  
  
  
  					def      __a    (		self    :    Tuple	):
  							pass
  
  
  
  					def      __a    (		self    :    Union[str, Any]	):
  							pass
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Optional[int]	):
  							super().test_determinism()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Dict	):
  							super().test_outputs_equivalence()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    List[Any]	):
  							super().test_from_save_pretrained()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Optional[Any]	):
  							super().test_from_save_pretrained_variant()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Dict	):
  							super().test_model_from_pretrained()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Dict	):
  							super().test_output()
  
  
  
  					def      __a    (		self    :    List[Any]	):
  							lowerCamelCase_  :    List[Any]   	=			{
  							    '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_  :    Tuple   	=			self.dummy_input
  							return init_dict, inputs_dict
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    int	):
  							lowerCamelCase_	,			lowerCamelCase_  :    Tuple   	=			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	)
  							lowerCamelCase_  :    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      __a    (		self    :    int	):
  							lowerCamelCase_  :    Optional[int]   	=			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_  :    Tuple   	=			model.config.in_channels
  							lowerCamelCase_  :    Tuple   	=			16
  							lowerCamelCase_  :    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_  :    Optional[int]   	=			model(lowerCamelCase					,			lowerCamelCase	).sample.permute(0					,			2					,			1	)
  
  							lowerCamelCase_  :    List[Any]   	=			output[0, -3:, -3:].flatten()
  							# fmt: off
  							lowerCamelCase_  :    Tuple   	=			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(lowerCamelCase					,			lowerCamelCase					,			rtol=1E-3	)	)
  
  
  
  					def      __a    (		self    :    Dict	):
  							# Not implemented yet for this UNet
  							pass
  
  
  
  
  
  					@slow
  					def      __a    (		self    :    int	):
  							lowerCamelCase_  :    Optional[int]   	=			'harmonai/maestro-150k'
  							lowerCamelCase_  :    int   	=			UNetaDModel.from_pretrained(lowerCamelCase					,			subfolder='unet'	)
  							model.to(lowerCamelCase	)
  
  							lowerCamelCase_  :    Any   	=			6_55_36
  							lowerCamelCase_  :    Dict   	=			torch.sin(torch.arange(lowerCamelCase	)[None, None, :].repeat(1					,			2					,			1	)	).to(lowerCamelCase	)
  							lowerCamelCase_  :    Union[str, Any]   	=			torch.tensor([1]	).to(lowerCamelCase	)
  
  							with torch.no_grad():
  									lowerCamelCase_  :    Dict   	=			model(lowerCamelCase					,			lowerCamelCase	).sample
  
  							lowerCamelCase_  :    Optional[int]   	=			output.abs().sum()
  							lowerCamelCase_  :    Union[str, Any]   	=			output.abs().max()
  
  							assert (output_sum - 224.0_896).abs() < 0.5
  							assert (output_max - 0.0_607).abs() < 4E-4
  
  
  
  
  
  
  class 	UpperCamelCase_     (     snake_case__     ,    snake_case__     ,    unittest.TestCase       ):
  					_a			:	Tuple							=				UNetaDModel
  					_a			:	Dict							=				'sample'
  
  
  
  					@property
  					def      __a    (		self    :    Optional[Any]	):
  							lowerCamelCase_  :    Optional[Any]   	=			4
  							lowerCamelCase_  :    Dict   	=			14
  							lowerCamelCase_  :    List[Any]   	=			16
  
  							lowerCamelCase_  :    List[Any]   	=			floats_tensor((batch_size, num_features, seq_len)	).to(lowerCamelCase	)
  							lowerCamelCase_  :    List[Any]   	=			torch.tensor([10] * batch_size	).to(lowerCamelCase	)
  
  							return {"sample": noise, "timestep": time_step}
  
  
  
  					@property
  					def      __a    (		self    :    int	):
  							return (4, 14, 16)
  
  
  
  					@property
  					def      __a    (		self    :    List[Any]	):
  							return (4, 14, 1)
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Any	):
  							super().test_determinism()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Any	):
  							super().test_outputs_equivalence()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    List[str]	):
  							super().test_from_save_pretrained()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Optional[int]	):
  							super().test_from_save_pretrained_variant()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Dict	):
  							super().test_model_from_pretrained()
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    Optional[int]	):
  							# UNetRL is a value-function is different output shape
  							lowerCamelCase_	,			lowerCamelCase_  :    Union[str, Any]   	=			self.prepare_init_args_and_inputs_for_common()
  							lowerCamelCase_  :    Dict   	=			self.model_class(**lowerCamelCase	)
  							model.to(lowerCamelCase	)
  							model.eval()
  
  							with torch.no_grad():
  									lowerCamelCase_  :    int   	=			model(**lowerCamelCase	)
  
  									if isinstance(lowerCamelCase					,			lowerCamelCase	):
  											lowerCamelCase_  :    List[str]   	=			output.sample
  
  							self.assertIsNotNone(lowerCamelCase	)
  							lowerCamelCase_  :    Any   	=			torch.Size((inputs_dict['sample'].shape[0], 1)	)
  							self.assertEqual(output.shape					,			lowerCamelCase					,			'Input and output shapes do not match'	)
  
  
  
  					def      __a    (		self    :    Tuple	):
  							pass
  
  
  
  					def      __a    (		self    :    List[Any]	):
  							pass
  
  
  
  					def      __a    (		self    :    Dict	):
  							lowerCamelCase_  :    Optional[int]   	=			{
  							    '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_  :    Optional[int]   	=			self.dummy_input
  							return init_dict, inputs_dict
  
  
  
  					@unittest.skipIf(torch_device == 'mps'					,			'mish op not supported in MPS'	)
  					def      __a    (		self    :    List[Any]	):
  							lowerCamelCase_	,			lowerCamelCase_  :    List[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	)
  							lowerCamelCase_  :    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      __a    (		self    :    Optional[Any]	):
  							lowerCamelCase_	,			lowerCamelCase_  :    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	)
  
  							lowerCamelCase_  :    Optional[Any]   	=			value_function.config.in_channels
  							lowerCamelCase_  :    Any   	=			14
  							lowerCamelCase_  :    Dict   	=			torch.randn((1, seq_len, num_features)	).permute(
  							    0					,			2					,			1	)  # match original, we can update values and remove
  							lowerCamelCase_  :    Tuple   	=			torch.full((num_features,)					,			0	)
  
  							with torch.no_grad():
  									lowerCamelCase_  :    int   	=			value_function(lowerCamelCase					,			lowerCamelCase	).sample
  
  							# fmt: off
  							lowerCamelCase_  :    str   	=			torch.tensor([165.25] * seq_len	)
  							# fmt: on
  							self.assertTrue(torch.allclose(lowerCamelCase					,			lowerCamelCase					,			rtol=1E-3	)	)
  
  
  
  
  
  					def      __a    (		self    :    Dict	):
  							# Not implemented yet for this UNet
  							pass
  
style_context: 
  
  
  
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
  		return (input_a, input_a).count(0	) % 2
  
  
  def 		_SCREAMING_SNAKE_CASE    (   ):
  		assert xor_gate(0       ,0	) == 0
  		assert xor_gate(0       ,1	) == 1
  		assert xor_gate(1       ,0	) == 1
  		assert xor_gate(1       ,1	) == 0
  
  
  if __name__ == "__main__":
  		print(xor_gate(0, 0))
  		print(xor_gate(0, 1))
  