


'''simple docstring'''
import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizer

from diffusers import (
    AltDiffusionImgaImgPipeline,
    AutoencoderKL,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()
class      lowercase			(							unittest.TestCase      ):

		"""simple docstring"""

		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()




		@property
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Any							      =				1
							UpperCamelCase__     :Dict							      =				3
							UpperCamelCase__     :Union[str, Any]							      =				(32, 32)

							UpperCamelCase__     :List[Any]							      =				floats_tensor((batch_size, num_channels) + sizes					,     rng=random.Random(0							)							).to(UpperCamelCase_							)
							return image




		@property
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							torch.manual_seed(0							)
							UpperCamelCase__     :List[str]							      =				UNetaDConditionModel(
							    block_out_channels=(32, 64)					,     layers_per_block=2					,     sample_size=32					,     in_channels=4					,     out_channels=4					,     down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')					,     up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')					,     cross_attention_dim=32					,     )
							return model




		@property
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							torch.manual_seed(0							)
							UpperCamelCase__     :Tuple							      =				AutoencoderKL(
							    block_out_channels=[32, 64]					,     in_channels=3					,     out_channels=3					,     down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']					,     up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']					,     latent_channels=4					,     )
							return model




		@property
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							torch.manual_seed(0							)
							UpperCamelCase__     :List[Any]							      =				RobertaSeriesConfig(
							    hidden_size=32					,     project_dim=32					,     intermediate_size=37					,     layer_norm_eps=1e-05					,     num_attention_heads=4					,     num_hidden_layers=5					,     pad_token_id=1					,     vocab_size=5006					,     )
							return RobertaSeriesModelWithTransformation(UpperCamelCase_							)




		@property
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							def extract(*UpperCamelCase_					,     **UpperCamelCase_							):
												class      lowercase			:

														"""simple docstring"""

														def __init__(	self							):

																			'''simple docstring'''


																			UpperCamelCase__     :List[Any]							      =				torch.ones([0]							)




														def 					lowerCAmelCase__       (	self					,     UpperCamelCase_							):

																			'''simple docstring'''


																			self.pixel_values.to(UpperCamelCase_							)
																			return self



												return Out()

							return extract




		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Union[str, Any]							      =				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
							UpperCamelCase__     :List[Any]							      =				self.dummy_cond_unet
							UpperCamelCase__     :List[Any]							      =				PNDMScheduler(skip_prk_steps=UpperCamelCase_							)
							UpperCamelCase__     :int							      =				self.dummy_vae
							UpperCamelCase__     :Optional[Any]							      =				self.dummy_text_encoder
							UpperCamelCase__     :int							      =				XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''							)
							UpperCamelCase__     :Tuple							      =				77

							UpperCamelCase__     :str							      =				self.dummy_image.to(UpperCamelCase_							)
							UpperCamelCase__     :int							      =				init_image / 2 + 0.5

							# make sure here that pndm scheduler skips prk
							UpperCamelCase__     :Dict							      =				AltDiffusionImgaImgPipeline(
							    unet=UpperCamelCase_					,     scheduler=UpperCamelCase_					,     vae=UpperCamelCase_					,     text_encoder=UpperCamelCase_					,     tokenizer=UpperCamelCase_					,     safety_checker=UpperCamelCase_					,     feature_extractor=self.dummy_extractor					,     )
							UpperCamelCase__     :Optional[int]							      =				VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor					,     do_normalize=UpperCamelCase_							)
							UpperCamelCase__     :Any							      =				alt_pipe.to(UpperCamelCase_							)
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__     :List[str]							      =				'''A painting of a squirrel eating a burger'''
							UpperCamelCase__     :Union[str, Any]							      =				torch.Generator(device=UpperCamelCase_							).manual_seed(0							)
							UpperCamelCase__     :Any							      =				alt_pipe(
							    [prompt]					,     generator=UpperCamelCase_					,     guidance_scale=6.0					,     num_inference_steps=2					,     output_type='''np'''					,     image=UpperCamelCase_					,     )

							UpperCamelCase__     :str							      =				output.images

							UpperCamelCase__     :int							      =				torch.Generator(device=UpperCamelCase_							).manual_seed(0							)
							UpperCamelCase__     :Dict							      =				alt_pipe(
							    [prompt]					,     generator=UpperCamelCase_					,     guidance_scale=6.0					,     num_inference_steps=2					,     output_type='''np'''					,     image=UpperCamelCase_					,     return_dict=UpperCamelCase_					,     )[0]

							UpperCamelCase__     :List[Any]							      =				image[0, -3:, -3:, -1]
							UpperCamelCase__     :Union[str, Any]							      =				image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 32, 32, 3)
							UpperCamelCase__     :Union[str, Any]							      =				np.array([0.4427, 0.3731, 0.4249, 0.4941, 0.4546, 0.4148, 0.4193, 0.4666, 0.4499]							)

							assert np.abs(image_slice.flatten() - expected_slice							).max() < 5e-3
							assert np.abs(image_from_tuple_slice.flatten() - expected_slice							).max() < 5e-3




		@unittest.skipIf(torch_device != '''cuda'''					,     '''This test requires a GPU'''							)
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Tuple							      =				self.dummy_cond_unet
							UpperCamelCase__     :int							      =				PNDMScheduler(skip_prk_steps=UpperCamelCase_							)
							UpperCamelCase__     :int							      =				self.dummy_vae
							UpperCamelCase__     :Tuple							      =				self.dummy_text_encoder
							UpperCamelCase__     :Union[str, Any]							      =				XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''							)
							UpperCamelCase__     :Any							      =				77

							UpperCamelCase__     :Optional[int]							      =				self.dummy_image.to(UpperCamelCase_							)

							# put models in fp16
							UpperCamelCase__     :List[str]							      =				unet.half()
							UpperCamelCase__     :Union[str, Any]							      =				vae.half()
							UpperCamelCase__     :Any							      =				bert.half()

							# make sure here that pndm scheduler skips prk
							UpperCamelCase__     :str							      =				AltDiffusionImgaImgPipeline(
							    unet=UpperCamelCase_					,     scheduler=UpperCamelCase_					,     vae=UpperCamelCase_					,     text_encoder=UpperCamelCase_					,     tokenizer=UpperCamelCase_					,     safety_checker=UpperCamelCase_					,     feature_extractor=self.dummy_extractor					,     )
							UpperCamelCase__     :Union[str, Any]							      =				VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor					,     do_normalize=UpperCamelCase_							)
							UpperCamelCase__     :List[str]							      =				alt_pipe.to(UpperCamelCase_							)
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__     :Optional[int]							      =				'''A painting of a squirrel eating a burger'''
							UpperCamelCase__     :Tuple							      =				torch.manual_seed(0							)
							UpperCamelCase__     :Dict							      =				alt_pipe(
							    [prompt]					,     generator=UpperCamelCase_					,     num_inference_steps=2					,     output_type='''np'''					,     image=UpperCamelCase_					,     ).images

							assert image.shape == (1, 32, 32, 3)




		@unittest.skipIf(torch_device != '''cuda'''					,     '''This test requires a GPU'''							)
		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :Dict							      =				load_image(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
							    '''/img2img/sketch-mountains-input.jpg'''							)
							# resize to resolution that is divisible by 8 but not 16 or 32
							UpperCamelCase__     :Optional[Any]							      =				init_image.resize((760, 504)							)

							UpperCamelCase__     :Tuple							      =				'''BAAI/AltDiffusion'''
							UpperCamelCase__     :Dict							      =				AltDiffusionImgaImgPipeline.from_pretrained(
							    UpperCamelCase_					,     safety_checker=UpperCamelCase_					,     )
							pipe.to(UpperCamelCase_							)
							pipe.set_progress_bar_config(disable=UpperCamelCase_							)
							pipe.enable_attention_slicing()

							UpperCamelCase__     :Any							      =				'''A fantasy landscape, trending on artstation'''

							UpperCamelCase__     :Any							      =				torch.manual_seed(0							)
							UpperCamelCase__     :Optional[Any]							      =				pipe(
							    prompt=UpperCamelCase_					,     image=UpperCamelCase_					,     strength=0.75					,     guidance_scale=7.5					,     generator=UpperCamelCase_					,     output_type='''np'''					,     )
							UpperCamelCase__     :Tuple							      =				output.images[0]

							UpperCamelCase__     :str							      =				image[255:258, 383:386, -1]

							assert image.shape == (504, 760, 3)
							UpperCamelCase__     :Optional[int]							      =				np.array([0.9358, 0.9397, 0.9599, 0.9901, 1.0000, 1.0000, 0.9882, 1.0000, 1.0000]							)

							assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2



@slow
@require_torch_gpu
class      lowercase			(							unittest.TestCase      ):

		"""simple docstring"""

		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()




		def 					lowerCAmelCase__       (	self							):

							'''simple docstring'''


							UpperCamelCase__     :List[str]							      =				load_image(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
							    '''/img2img/sketch-mountains-input.jpg'''							)
							UpperCamelCase__     :Tuple							      =				init_image.resize((768, 512)							)
							UpperCamelCase__     :Any							      =				load_numpy(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy'''							)

							UpperCamelCase__     :List[str]							      =				'''BAAI/AltDiffusion'''
							UpperCamelCase__     :int							      =				AltDiffusionImgaImgPipeline.from_pretrained(
							    UpperCamelCase_					,     safety_checker=UpperCamelCase_					,     )
							pipe.to(UpperCamelCase_							)
							pipe.set_progress_bar_config(disable=UpperCamelCase_							)
							pipe.enable_attention_slicing()

							UpperCamelCase__     :Tuple							      =				'''A fantasy landscape, trending on artstation'''

							UpperCamelCase__     :Dict							      =				torch.manual_seed(0							)
							UpperCamelCase__     :int							      =				pipe(
							    prompt=UpperCamelCase_					,     image=UpperCamelCase_					,     strength=0.75					,     guidance_scale=7.5					,     generator=UpperCamelCase_					,     output_type='''np'''					,     )
							UpperCamelCase__     :str							      =				output.images[0]

							assert image.shape == (512, 768, 3)
							# img2img is flaky across GPUs even in fp32, so using MAE here
							assert np.abs(expected_image - image							).max() < 1e-2



'''simple docstring'''
import qiskit


def     a   (    __a				,      __a     )						->			qiskit.result.counts.Counts:



					'''simple docstring'''






					UpperCamelCase__     :int							      =				qiskit.Aer.get_backend('''aer_simulator'''     )

					# Create a Quantum Circuit acting on the q register
					UpperCamelCase__     :Any							      =				qiskit.QuantumCircuit(__a				,      __a     )

					# Map the quantum measurement to the classical bits
					circuit.measure([0]				,      [0]     )

					# Execute the circuit on the simulator
					UpperCamelCase__     :Optional[int]							      =				qiskit.execute(__a				,      __a				,      shots=1000     )

					# Return the histogram data of the results of the experiment.
					return job.result().get_counts(__a     )


if __name__ == "__main__":
		print(F"""Total count for various states are: {single_qubit_measure(1, 1)}""")