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 					__lowercase					(       a_ ,       a_ ,       unittest.TestCase     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				List[str] 					=		UNetaDModel
  		UpperCamelCase    :				Union[str, Any] 					=		"sample"
  
  
  
  
  
  
  
  		@property
  		def 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					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 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return (4, 14, 16)
  
  
  
  
  
  
  
  		@property
  		def 				__A      (   self  )     ->   int:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return (4, 14, 16)
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   str:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   Any:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_determinism()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_outputs_equivalence()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   Tuple:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_from_save_pretrained()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   List[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_from_save_pretrained_variant()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   str:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_model_from_pretrained()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_output()
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Tuple:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					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 				__A      (   self  )     ->   str:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					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 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''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(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 				__A      (   self  )     ->   str:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  		@slow
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					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 					__lowercase					(       a_ ,       a_ ,       unittest.TestCase     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				Tuple 					=		UNetaDModel
  		UpperCamelCase    :				Dict 					=		"sample"
  
  
  
  
  
  
  
  		@property
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					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 				__A      (   self  )     ->   List[str]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return (4, 14, 16)
  
  
  
  
  
  
  
  		@property
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return (4, 14, 1)
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   Tuple:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_determinism()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_outputs_equivalence()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   int:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_from_save_pretrained()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_from_save_pretrained_variant()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					super().test_model_from_pretrained()
  
  
  
  
  
  
  
  		@unittest.skipIf(torch_device == """mps"""		,			"""mish op not supported in MPS"""  )
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					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 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''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, 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 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					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 				__A      (   self  )     ->   Any:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					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 				__A      (   self  )     ->   int:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					pass
  
  
style_context: 
  
  
  import math
  
  import qiskit
  from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	int = 1     ,       lowerCamelCase__		:	int = 1			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			if isinstance(lowerCamelCase__     ,       lowerCamelCase__			) or isinstance(lowerCamelCase__     ,       lowerCamelCase__			):
  						raise TypeError("""inputs must be integers."""			)
  			if (bit_a < 0) or (bit_a < 0):
  						raise ValueError("""inputs must be positive."""			)
  			if (math.floor(lowerCamelCase__			) != bit_a) or (math.floor(lowerCamelCase__			) != bit_a):
  						raise ValueError("""inputs must be exact integers."""			)
  			if (bit_a > 1) or (bit_a > 1):
  						raise ValueError("""inputs must be less or equal to 1."""			)
  
  			# build registers
  			lowerCamelCase								=     QuantumRegister(2     ,       """qr"""			)
  			lowerCamelCase								=     ClassicalRegister(2     ,       """cr"""			)
  
  			lowerCamelCase								=     QuantumCircuit(lowerCamelCase__     ,       lowerCamelCase__			)
  
  			# entanglement the qubits
  			quantum_circuit.h(1			)
  			quantum_circuit.cx(1     ,       0			)
  
  			# send the information
  			lowerCamelCase								=     str(lowerCamelCase__			) + str(lowerCamelCase__			)
  
  			if c_information == "11":
  						quantum_circuit.x(1			)
  						quantum_circuit.z(1			)
  			elif c_information == "10":
  						quantum_circuit.z(1			)
  			elif c_information == "01":
  						quantum_circuit.x(1			)
  			else:
  						quantum_circuit.i(1			)
  
  			# unentangled the circuit
  			quantum_circuit.cx(1     ,       0			)
  			quantum_circuit.h(1			)
  
  			# measure the circuit
  			quantum_circuit.measure(lowerCamelCase__     ,       lowerCamelCase__			)
  
  			lowerCamelCase								=     Aer.get_backend("""aer_simulator"""			)
  			lowerCamelCase								=     execute(lowerCamelCase__     ,       lowerCamelCase__     ,       shots=1000			)
  
  			return job.result().get_counts(lowerCamelCase__			)
  
  
  if __name__ == "__main__":
  		print(f"""Counts for classical state send: {superdense_coding(1,1)}""")
  
  