





import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


class 						lowerCamelCase       (unittest.TestCase      ):







							"""simple docstring"""




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





														"""simple docstring"""
														# clean up the VRAM after each test
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()






							@property
							def  A_     ( self     :					Optional[Any]						)				->			str:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						1
														SCREAMING_SNAKE_CASE__       :      int     =						3
														SCREAMING_SNAKE_CASE__       :      Any     =						(3_2, 3_2)

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






							@property
							def  A_     ( self     :					Tuple						)				->			Optional[int]:





														"""simple docstring"""
														torch.manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      int     =						UNetaDConditionModel(
														    block_out_channels=(3_2, 6_4),			layers_per_block=2,			sample_size=3_2,			in_channels=4,			out_channels=4,			down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),			up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),			cross_attention_dim=3_2,			)
														return model






							@property
							def  A_     ( self     :					int						)				->			Any:





														"""simple docstring"""
														torch.manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						AutoencoderKL(
														    block_out_channels=[3_2, 6_4],			in_channels=3,			out_channels=3,			down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],			up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],			latent_channels=4,			)
														return model






							@property
							def  A_     ( self     :					List[str]						)				->			Dict:





														"""simple docstring"""
														torch.manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      Dict     =						CLIPTextConfig(
														    bos_token_id=0,			eos_token_id=2,			hidden_size=3_2,			intermediate_size=3_7,			layer_norm_eps=1E-05,			num_attention_heads=4,			num_hidden_layers=5,			pad_token_id=1,			vocab_size=1_0_0_0,			)
														return CLIPTextModel(_UpperCAmelCase						)






							@property
							def  A_     ( self     :					str						)				->			Optional[int]:





														"""simple docstring"""
														def extract(*_UpperCAmelCase     :					Dict,			**_UpperCAmelCase     :					Optional[int]						):


																					class 						lowerCamelCase       :







																												"""simple docstring"""




																												def __init__( self     :					Optional[Any]						)				->			List[str]:





																																			"""simple docstring"""
																																			SCREAMING_SNAKE_CASE__       :      str     =						torch.ones([0]						)






																												def  A_     ( self     :					int,			_UpperCAmelCase     :					List[Any]						)				->			Any:





																																			"""simple docstring"""
																																			self.pixel_values.to(_UpperCAmelCase						)
																																			return self


																					return Out()

														return extract






							def  A_     ( self     :					str						)				->			str:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						"cpu"  # ensure determinism for the device-dependent torch.Generator
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						self.dummy_cond_unet
														SCREAMING_SNAKE_CASE__       :      Dict     =						DDIMScheduler(
														    beta_start=0.00085,			beta_end=0.012,			beta_schedule="scaled_linear",			clip_sample=_UpperCAmelCase,			set_alpha_to_one=_UpperCAmelCase,			)

														SCREAMING_SNAKE_CASE__       :      str     =						self.dummy_vae
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						self.dummy_text_encoder
														SCREAMING_SNAKE_CASE__       :      Dict     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

														# make sure here that pndm scheduler skips prk
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						StableDiffusionPipeline(
														    unet=_UpperCAmelCase,			scheduler=_UpperCAmelCase,			vae=_UpperCAmelCase,			text_encoder=_UpperCAmelCase,			tokenizer=_UpperCAmelCase,			safety_checker=_UpperCAmelCase,			feature_extractor=self.dummy_extractor,			)
														SCREAMING_SNAKE_CASE__       :      int     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      List[Any]     =						"A painting of a squirrel eating a burger"

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						torch.Generator(device=_UpperCAmelCase						).manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      int     =						sd_pipe([prompt],			generator=_UpperCAmelCase,			guidance_scale=6.0,			num_inference_steps=2,			output_type="np"						)
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						output.images

														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						torch.Generator(device=_UpperCAmelCase						).manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      str     =						sd_pipe(
														    [prompt],			generator=_UpperCAmelCase,			guidance_scale=6.0,			num_inference_steps=2,			output_type="np",			return_dict=_UpperCAmelCase,			)[0]

														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						image[0, -3:, -3:, -1]
														SCREAMING_SNAKE_CASE__       :      List[str]     =						image_from_tuple[0, -3:, -3:, -1]

														assert image.shape == (1, 6_4, 6_4, 3)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						np.array([0.5756, 0.6118, 0.5005, 0.5041, 0.5471, 0.4726, 0.4976, 0.4865, 0.4864]						)

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






							def  A_     ( self     :					Any						)				->			Dict:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						"cpu"  # ensure determinism for the device-dependent torch.Generator
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.dummy_cond_unet
														SCREAMING_SNAKE_CASE__       :      List[str]     =						PNDMScheduler(skip_prk_steps=_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.dummy_vae
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						self.dummy_text_encoder
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

														# make sure here that pndm scheduler skips prk
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						StableDiffusionPipeline(
														    unet=_UpperCAmelCase,			scheduler=_UpperCAmelCase,			vae=_UpperCAmelCase,			text_encoder=_UpperCAmelCase,			tokenizer=_UpperCAmelCase,			safety_checker=_UpperCAmelCase,			feature_extractor=self.dummy_extractor,			)
														SCREAMING_SNAKE_CASE__       :      Any     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      Dict     =						"A painting of a squirrel eating a burger"
														SCREAMING_SNAKE_CASE__       :      int     =						torch.Generator(device=_UpperCAmelCase						).manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      Dict     =						sd_pipe([prompt],			generator=_UpperCAmelCase,			guidance_scale=6.0,			num_inference_steps=2,			output_type="np"						)

														SCREAMING_SNAKE_CASE__       :      List[str]     =						output.images

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						torch.Generator(device=_UpperCAmelCase						).manual_seed(0						)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						sd_pipe(
														    [prompt],			generator=_UpperCAmelCase,			guidance_scale=6.0,			num_inference_steps=2,			output_type="np",			return_dict=_UpperCAmelCase,			)[0]

														SCREAMING_SNAKE_CASE__       :      Any     =						image[0, -3:, -3:, -1]
														SCREAMING_SNAKE_CASE__       :      Any     =						image_from_tuple[0, -3:, -3:, -1]

														assert image.shape == (1, 6_4, 6_4, 3)
														SCREAMING_SNAKE_CASE__       :      Dict     =						np.array([0.5125, 0.5716, 0.4828, 0.5060, 0.5650, 0.4768, 0.5185, 0.4895, 0.4993]						)

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






							def  A_     ( self     :					List[str]						)				->			Tuple:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Tuple     =						StableDiffusionPipeline.from_pretrained(
														    "hf-internal-testing/tiny-stable-diffusion-lms-pipe",			safety_checker=_UpperCAmelCase						)
														assert isinstance(_UpperCAmelCase,			_UpperCAmelCase						)
														assert isinstance(pipe.scheduler,			_UpperCAmelCase						)
														assert pipe.safety_checker is None

														SCREAMING_SNAKE_CASE__       :      Any     =						pipe("example prompt",			num_inference_steps=2						).images[0]
														assert image is not None

														# check that there's no error when saving a pipeline with one of the models being None
														with tempfile.TemporaryDirectory() as tmpdirname:
																					pipe.save_pretrained(_UpperCAmelCase						)
																					SCREAMING_SNAKE_CASE__       :      Any     =						StableDiffusionPipeline.from_pretrained(_UpperCAmelCase						)

														# sanity check that the pipeline still works
														assert pipe.safety_checker is None
														SCREAMING_SNAKE_CASE__       :      int     =						pipe("example prompt",			num_inference_steps=2						).images[0]
														assert image is not None






							@unittest.skipIf(torch_device != "cuda",			"This test requires a GPU"						)
							def  A_     ( self     :					Dict						)				->			str:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Dict     =						self.dummy_cond_unet
														SCREAMING_SNAKE_CASE__       :      Dict     =						PNDMScheduler(skip_prk_steps=_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.dummy_vae
														SCREAMING_SNAKE_CASE__       :      str     =						self.dummy_text_encoder
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

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

														# make sure here that pndm scheduler skips prk
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						StableDiffusionPipeline(
														    unet=_UpperCAmelCase,			scheduler=_UpperCAmelCase,			vae=_UpperCAmelCase,			text_encoder=_UpperCAmelCase,			tokenizer=_UpperCAmelCase,			safety_checker=_UpperCAmelCase,			feature_extractor=self.dummy_extractor,			)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      int     =						"A painting of a squirrel eating a burger"
														SCREAMING_SNAKE_CASE__       :      Tuple     =						sd_pipe([prompt],			num_inference_steps=2,			output_type="np"						).images

														assert image.shape == (1, 6_4, 6_4, 3)


@nightly
@require_torch_gpu
class 						lowerCamelCase       (unittest.TestCase      ):







							"""simple docstring"""




							def  A_     ( self     :					Dict						)				->			Any:





														"""simple docstring"""
														# clean up the VRAM after each test
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[str]     =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5",			safety_checker=_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      int     =						LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config						)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						(
														    "portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle"
														    " coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with"
														    " anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and"
														    " children from bahnhof zoo, detailed "
														)
														SCREAMING_SNAKE_CASE__       :      Any     =						4_0_0_3_6_6_0_3_4_6
														SCREAMING_SNAKE_CASE__       :      Tuple     =						7

														# without safety guidance (sld_guidance_scale = 0)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						torch.manual_seed(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						sd_pipe(
														    [prompt],			generator=_UpperCAmelCase,			guidance_scale=_UpperCAmelCase,			num_inference_steps=5_0,			output_type="np",			width=5_1_2,			height=5_1_2,			sld_guidance_scale=0,			)

														SCREAMING_SNAKE_CASE__       :      List[Any]     =						output.images
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						image[0, -3:, -3:, -1]
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						[0.2278, 0.2231, 0.2249, 0.2333, 0.2303, 0.1885, 0.2273, 0.2144, 0.2176]

														assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

														# without safety guidance (strong configuration)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						torch.manual_seed(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      int     =						sd_pipe(
														    [prompt],			generator=_UpperCAmelCase,			guidance_scale=_UpperCAmelCase,			num_inference_steps=5_0,			output_type="np",			width=5_1_2,			height=5_1_2,			sld_guidance_scale=2_0_0_0,			sld_warmup_steps=7,			sld_threshold=0.025,			sld_momentum_scale=0.5,			sld_mom_beta=0.7,			)

														SCREAMING_SNAKE_CASE__       :      str     =						output.images
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						image[0, -3:, -3:, -1]
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						[0.2383, 0.2276, 0.236, 0.2192, 0.2186, 0.2053, 0.1971, 0.1901, 0.1719]

														assert image.shape == (1, 5_1_2, 5_1_2, 3)

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






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[str]     =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5",			safety_checker=_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config						)
														SCREAMING_SNAKE_CASE__       :      int     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      str     =						"padme amidala taking a bath artwork, safe for work, no nudity"
														SCREAMING_SNAKE_CASE__       :      List[str]     =						2_7_3_4_9_7_1_7_5_5
														SCREAMING_SNAKE_CASE__       :      str     =						7

														SCREAMING_SNAKE_CASE__       :      List[str]     =						torch.manual_seed(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Dict     =						sd_pipe(
														    [prompt],			generator=_UpperCAmelCase,			guidance_scale=_UpperCAmelCase,			num_inference_steps=5_0,			output_type="np",			width=5_1_2,			height=5_1_2,			sld_guidance_scale=0,			)

														SCREAMING_SNAKE_CASE__       :      Dict     =						output.images
														SCREAMING_SNAKE_CASE__       :      int     =						image[0, -3:, -3:, -1]
														SCREAMING_SNAKE_CASE__       :      int     =						[0.3502, 0.3622, 0.3396, 0.3642, 0.3478, 0.3318, 0.35, 0.3348, 0.3297]

														assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

														SCREAMING_SNAKE_CASE__       :      List[Any]     =						torch.manual_seed(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Any     =						sd_pipe(
														    [prompt],			generator=_UpperCAmelCase,			guidance_scale=_UpperCAmelCase,			num_inference_steps=5_0,			output_type="np",			width=5_1_2,			height=5_1_2,			sld_guidance_scale=2_0_0_0,			sld_warmup_steps=7,			sld_threshold=0.025,			sld_momentum_scale=0.5,			sld_mom_beta=0.7,			)

														SCREAMING_SNAKE_CASE__       :      List[Any]     =						output.images
														SCREAMING_SNAKE_CASE__       :      Dict     =						image[0, -3:, -3:, -1]
														SCREAMING_SNAKE_CASE__       :      Dict     =						[0.5531, 0.5206, 0.4895, 0.5156, 0.5182, 0.4751, 0.4802, 0.4803, 0.4443]

														assert image.shape == (1, 5_1_2, 5_1_2, 3)

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






							def  A_     ( self     :					List[Any]						)				->			Optional[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"						)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						sd_pipe.to(_UpperCAmelCase						)
														sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

														SCREAMING_SNAKE_CASE__       :      Tuple     =						(
														    "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
														    " leyendecker"
														)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						1_0_4_4_3_5_5_2_3_4
														SCREAMING_SNAKE_CASE__       :      str     =						1_2

														SCREAMING_SNAKE_CASE__       :      Any     =						torch.manual_seed(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      List[str]     =						sd_pipe(
														    [prompt],			generator=_UpperCAmelCase,			guidance_scale=_UpperCAmelCase,			num_inference_steps=5_0,			output_type="np",			width=5_1_2,			height=5_1_2,			sld_guidance_scale=0,			)

														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						output.images
														SCREAMING_SNAKE_CASE__       :      List[str]     =						image[0, -3:, -3:, -1]
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]						)

														assert image.shape == (1, 5_1_2, 5_1_2, 3)

														assert np.abs(image_slice.flatten() - expected_slice						).max() < 1E-7

														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						torch.manual_seed(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Dict     =						sd_pipe(
														    [prompt],			generator=_UpperCAmelCase,			guidance_scale=_UpperCAmelCase,			num_inference_steps=5_0,			output_type="np",			width=5_1_2,			height=5_1_2,			sld_guidance_scale=2_0_0_0,			sld_warmup_steps=7,			sld_threshold=0.025,			sld_momentum_scale=0.5,			sld_mom_beta=0.7,			)

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						output.images
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						image[0, -3:, -3:, -1]
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						np.array([0.5818, 0.6285, 0.6835, 0.6019, 0.625, 0.6754, 0.6096, 0.6334, 0.6561]						)
														assert image.shape == (1, 5_1_2, 5_1_2, 3)

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













import qiskit




def _a (  SCREAMING_SNAKE_CASE__      :  int			,				SCREAMING_SNAKE_CASE__      :  int       )	->    qiskit.result.counts.Counts:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						qiskit.Aer.get_backend("aer_simulator"       )

							# Create a Quantum Circuit acting on the q register
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						qiskit.QuantumCircuit(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       )

							# Apply X (NOT) Gate to Qubits 0 & 1
							circuit.x(0       )
							circuit.x(1       )

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

							# Execute the circuit on the qasm simulator
							SCREAMING_SNAKE_CASE__       :      int     =						qiskit.execute(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				shots=10_00       )

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


if __name__ == "__main__":
		_lowerCamelCase :    List[str]  							= single_qubit_measure(2, 2)
		print(f"Total count for various states are: {counts}")






