




'''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 				_snake_case	(			lowercase_		,		lowercase_		,		unittest.TestCase							):
   lowerCAmelCase_  :   str		 =					UNetaDModel
   lowerCAmelCase_  :   List[str]		 =					"sample"




   @property
   def      lowerCAmelCase__       (      self							)       ->       int:

          '''simple docstring'''




          snake_case_			      =   4
          snake_case_			      =   14
          snake_case_			      =   16

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

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




   @property
   def      lowerCAmelCase__       (      self							)       ->       Dict:

          '''simple docstring'''




          return (4, 14, 16)




   @property
   def      lowerCAmelCase__       (      self							)       ->       Dict:

          '''simple docstring'''




          return (4, 14, 16)




   def      lowerCAmelCase__       (      self							)       ->       Optional[int]:

          '''simple docstring'''




          pass




   def      lowerCAmelCase__       (      self							)       ->       str:

          '''simple docstring'''




          pass




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

          '''simple docstring'''




          super().test_determinism()




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

          '''simple docstring'''




          super().test_outputs_equivalence()




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

          '''simple docstring'''




          super().test_from_save_pretrained()




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

          '''simple docstring'''




          super().test_from_save_pretrained_variant()




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

          '''simple docstring'''




          super().test_model_from_pretrained()




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

          '''simple docstring'''




          super().test_output()




   def      lowerCAmelCase__       (      self							)       ->       str:

          '''simple docstring'''




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




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

          '''simple docstring'''




          snake_case_      ,   snake_case_			      =   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__							)
          snake_case_			      =   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      lowerCAmelCase__       (      self							)       ->       Any:

          '''simple docstring'''




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

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

          with torch.no_grad():
                 snake_case_			      =   model(a__       ,							a__							).sample.permute(0       ,							2       ,							1							)

          snake_case_			      =   output[0, -3:, -3:].flatten()
          # fmt: off
          snake_case_			      =   torch.tensor([-2.1_3_7_1_7_2, 1.1_4_2_6_0_1_6, 0.3_6_8_8_6_8_7, -0.7_6_6_9_2_2, 0.7_3_0_3_1_4_6, 0.1_1_0_3_8_8_6_4, -0.4_7_6_0_6_3_3, 0.1_3_2_7_0_1_7_2, 0.0_2_5_9_1_3_4_8]							)
          # fmt: on
          self.assertTrue(torch.allclose(a__       ,							a__       ,							rtol=1e-3							)							)




   def      lowerCAmelCase__       (      self							)       ->       Dict:

          '''simple docstring'''




          pass




   @slow
   def      lowerCAmelCase__       (      self							)       ->       int:

          '''simple docstring'''




          snake_case_			      =   "harmonai/maestro-150k"
          snake_case_			      =   UNetaDModel.from_pretrained(a__       ,							subfolder="unet"							)
          model.to(a__							)

          snake_case_			      =   65_536
          snake_case_			      =   torch.sin(torch.arange(a__							)[None, None, :].repeat(1       ,							2       ,							1							)							).to(a__							)
          snake_case_			      =   torch.tensor([1]							).to(a__							)

          with torch.no_grad():
                 snake_case_			      =   model(a__       ,							a__							).sample

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

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




class 				_snake_case	(			lowercase_		,		lowercase_		,		unittest.TestCase							):
   lowerCAmelCase_  :   Union[str, Any]		 =					UNetaDModel
   lowerCAmelCase_  :   Union[str, Any]		 =					"sample"




   @property
   def      lowerCAmelCase__       (      self							)       ->       str:

          '''simple docstring'''




          snake_case_			      =   4
          snake_case_			      =   14
          snake_case_			      =   16

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

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




   @property
   def      lowerCAmelCase__       (      self							)       ->       Any:

          '''simple docstring'''




          return (4, 14, 16)




   @property
   def      lowerCAmelCase__       (      self							)       ->       Dict:

          '''simple docstring'''




          return (4, 14, 1)




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

          '''simple docstring'''




          super().test_determinism()




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

          '''simple docstring'''




          super().test_outputs_equivalence()




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

          '''simple docstring'''




          super().test_from_save_pretrained()




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

          '''simple docstring'''




          super().test_from_save_pretrained_variant()




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

          '''simple docstring'''




          super().test_model_from_pretrained()




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

          '''simple docstring'''




          snake_case_      ,   snake_case_			      =   self.prepare_init_args_and_inputs_for_common()
          snake_case_			      =   self.model_class(**a__							)
          model.to(a__							)
          model.eval()

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

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

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




   def      lowerCAmelCase__       (      self							)       ->       int:

          '''simple docstring'''




          pass




   def      lowerCAmelCase__       (      self							)       ->       List[Any]:

          '''simple docstring'''




          pass




   def      lowerCAmelCase__       (      self							)       ->       Union[str, Any]:

          '''simple docstring'''




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




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

          '''simple docstring'''




          snake_case_      ,   snake_case_			      =   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__							)
          snake_case_			      =   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      lowerCAmelCase__       (      self							)       ->       Tuple:

          '''simple docstring'''




          snake_case_      ,   snake_case_			      =   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							)

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

          with torch.no_grad():
                 snake_case_			      =   value_function(a__       ,							a__							).sample

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




   def      lowerCAmelCase__       (      self							)       ->       Union[str, Any]:

          '''simple docstring'''




          pass










'''simple docstring'''





import qiskit
from qiskit.providers import Backend


def   UpperCamelCase_(			snake_case							: int							,       snake_case							: int  ):

							'''simple docstring'''






							snake_case_      ,   snake_case_			      =   bin(snake_case  )[2:], bin(snake_case  )[2:]  # Remove leading '0b'

							# Ensure that both strings are of the same length
							if len(snake_case  ) > len(snake_case  ):
														snake_case_			      =   y.zfill(len(snake_case  )  )
							else:
														snake_case_			      =   x.zfill(len(snake_case  )  )

							# We need (3 * number of bits in the larger number)+1 qBits
							# The second parameter is the number of classical registers, to measure the result
							snake_case_			      =   qiskit.QuantumCircuit((len(snake_case  ) * 3) + 1							,       len(snake_case  ) + 1  )

							# We are essentially "not-ing" the bits that are 1
							# Reversed because it's easier to perform ops on more significant bits
							for i in range(len(snake_case  )  ):
														if x[::-1][i] == "1":
																					circuit.x(snake_case  )
							for j in range(len(snake_case  )  ):
														if y[::-1][j] == "1":
																					circuit.x(len(snake_case  ) + j  )

							return circuit, x, y


def   UpperCamelCase_(			snake_case							: qiskit.QuantumCircuit							,       snake_case							: int							,       snake_case							: int							,       snake_case							: int							,       snake_case							: int							,       ):

							'''simple docstring'''






							circuit.ccx(snake_case							,       snake_case							,       snake_case  )
							circuit.cx(snake_case							,       snake_case  )
							circuit.ccx(snake_case							,       snake_case							,       snake_case  )
							circuit.cx(snake_case							,       snake_case  )
							circuit.cx(snake_case							,       snake_case  )


def   UpperCamelCase_(			snake_case							: int							,       snake_case							: int							,       snake_case							: Backend = qiskit.Aer.get_backend("aer_simulator"  )							,       ):

							'''simple docstring'''






							if vala < 0 or vala < 0:
														raise ValueError("Both Integers must be positive!"  )

							# Store the Integers
							snake_case_      ,   snake_case_      ,   snake_case_			      =   store_two_classics(snake_case							,       snake_case  )
							for i in range(len(snake_case  )  ):
														full_adder(snake_case							,       snake_case							,       len(snake_case  ) + i							,       len(snake_case  ) + len(snake_case  ) + i							,       len(snake_case  ) + len(snake_case  ) + i + 1  )
														circuit.barrier()  # Optional, just for aesthetics

							# Measure the resultant qBits
							for i in range(len(snake_case  ) + 1  ):
														circuit.measure([(len(snake_case  ) * 2) + i]							,       [i]  )

							snake_case_			      =   qiskit.execute(snake_case							,       snake_case							,       shots=1  ).result()

							# The result is in binary. Convert it back to int
							return int(list(res.get_counts()  )[0]							,       2  )


if __name__ == "__main__":
		import doctest

		doctest.testmod()




