


"""simple docstring"""



import inspect
from typing import List, Optional, Union

import torch
from torch import nn
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPImageProcessor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput







class       __a	(   nn.Module       ):







				def __init__(   self			,  UpperCAmelCase			,  UpperCAmelCase=1.0      ):

					'''simple docstring'''






					super().__init__()

					lowerCAmelCase_			       = cut_size
					lowerCAmelCase_			       = cut_power







				def     lowerCamelCase_    (   self			,  UpperCAmelCase			,  UpperCAmelCase      ):

					'''simple docstring'''






					lowerCAmelCase_       ,  lowerCAmelCase_			       = pixel_values.shape[2:4]
					lowerCAmelCase_			       = min(UpperCAmelCase			,  UpperCAmelCase      )
					lowerCAmelCase_			       = min(UpperCAmelCase			,  UpperCAmelCase			,  self.cut_size      )
					lowerCAmelCase_			       = []
					for _ in range(UpperCAmelCase      ):
						lowerCAmelCase_			       = int(torch.rand([]      ) ** self.cut_power * (max_size - min_size) + min_size      )
						lowerCAmelCase_			       = torch.randint(0			,  sideX - size + 1			,  ()      )
						lowerCAmelCase_			       = torch.randint(0			,  sideY - size + 1			,  ()      )
						lowerCAmelCase_			       = pixel_values[:, :, offsety : offsety + size, offsetx : offsetx + size]
						cutouts.append(F.adaptive_avg_poolad(UpperCAmelCase			,  self.cut_size      )      )
					return torch.cat(UpperCAmelCase      )




def     UpperCAmelCase    (					_lowercase   :      Tuple ,      _lowercase   :      Optional[Any]  )	->   Optional[Any]:


	"""simple docstring"""




	lowerCAmelCase_			       = F.normalize(_lowercase ,      dim=-1  )
	lowerCAmelCase_			       = F.normalize(_lowercase ,      dim=-1  )
	return (x - y).norm(dim=-1  ).div(2  ).arcsin().pow(2  ).mul(2  )
def     UpperCAmelCase    (					_lowercase   :      List[str] ,      _lowercase   :      Any  )	->   List[str]:


	"""simple docstring"""




	for param in model.parameters():
		lowerCAmelCase_			       = value







class       __a	(   __snake_case       ):







				def __init__(   self			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  ):

					'''simple docstring'''






					super().__init__()
					self.register_modules(
					    vae=UpperCAmelCase			,  text_encoder=UpperCAmelCase			,  clip_model=UpperCAmelCase			,  tokenizer=UpperCAmelCase			,  unet=UpperCAmelCase			,  scheduler=UpperCAmelCase			,  feature_extractor=UpperCAmelCase			,  )

					lowerCAmelCase_			       = transforms.Normalize(mean=feature_extractor.image_mean			,  std=feature_extractor.image_std      )
					lowerCAmelCase_			       = (
					    feature_extractor.size
					    if isinstance(feature_extractor.size			,  UpperCAmelCase      )
					    else feature_extractor.size['''shortest_edge''']
					)
					lowerCAmelCase_			       = MakeCutouts(self.cut_out_size      )

					set_requires_grad(self.text_encoder			,  UpperCAmelCase      )
					set_requires_grad(self.clip_model			,  UpperCAmelCase      )







				def     lowerCamelCase_    (   self			,  UpperCAmelCase = "auto"      ):

					'''simple docstring'''






					if slice_size == "auto":
						# half the attention head size is usually a good trade-off between
						# speed and memory
						lowerCAmelCase_			       = self.unet.config.attention_head_dim // 2
					self.unet.set_attention_slice(UpperCAmelCase      )







				def     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					self.enable_attention_slicing(UpperCAmelCase      )







				def     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					set_requires_grad(self.vae			,  UpperCAmelCase      )







				def     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					set_requires_grad(self.vae			,  UpperCAmelCase      )







				def     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					set_requires_grad(self.unet			,  UpperCAmelCase      )







				def     lowerCamelCase_    (   self      ):

					'''simple docstring'''






					set_requires_grad(self.unet			,  UpperCAmelCase      )







				@torch.enable_grad()
				def     lowerCamelCase_    (   self			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase=True			,  ):

					'''simple docstring'''






					lowerCAmelCase_			       = latents.detach().requires_grad_()

					lowerCAmelCase_			       = self.scheduler.scale_model_input(UpperCAmelCase			,  UpperCAmelCase      )

					# predict the noise residual
					lowerCAmelCase_			       = self.unet(UpperCAmelCase			,  UpperCAmelCase			,  encoder_hidden_states=UpperCAmelCase      ).sample

					if isinstance(self.scheduler			,  (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)      ):
						lowerCAmelCase_			       = self.scheduler.alphas_cumprod[timestep]
						lowerCAmelCase_			       = 1 - alpha_prod_t
						# compute predicted original sample from predicted noise also called
						# "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
						lowerCAmelCase_			       = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

						lowerCAmelCase_			       = torch.sqrt(UpperCAmelCase      )
						lowerCAmelCase_			       = pred_original_sample * (fac) + latents * (1 - fac)
					elif isinstance(self.scheduler			,  UpperCAmelCase      ):
						lowerCAmelCase_			       = self.scheduler.sigmas[index]
						lowerCAmelCase_			       = latents - sigma * noise_pred
					else:
						raise ValueError(F"""scheduler type {type(self.scheduler      )} not supported"""      )

					lowerCAmelCase_			       = 1 / self.vae.config.scaling_factor * sample
					lowerCAmelCase_			       = self.vae.decode(UpperCAmelCase      ).sample
					lowerCAmelCase_			       = (image / 2 + 0.5).clamp(0			,  1      )

					if use_cutouts:
						lowerCAmelCase_			       = self.make_cutouts(UpperCAmelCase			,  UpperCAmelCase      )
					else:
						lowerCAmelCase_			       = transforms.Resize(self.cut_out_size      )(UpperCAmelCase      )
					lowerCAmelCase_			       = self.normalize(UpperCAmelCase      ).to(latents.dtype      )

					lowerCAmelCase_			       = self.clip_model.get_image_features(UpperCAmelCase      )
					lowerCAmelCase_			       = image_embeddings_clip / image_embeddings_clip.norm(p=2			,  dim=-1			,  keepdim=UpperCAmelCase      )

					if use_cutouts:
						lowerCAmelCase_			       = spherical_dist_loss(UpperCAmelCase			,  UpperCAmelCase      )
						lowerCAmelCase_			       = dists.view([num_cutouts, sample.shape[0], -1]      )
						lowerCAmelCase_			       = dists.sum(2      ).mean(0      ).sum() * clip_guidance_scale
					else:
						lowerCAmelCase_			       = spherical_dist_loss(UpperCAmelCase			,  UpperCAmelCase      ).mean() * clip_guidance_scale

					lowerCAmelCase_			       = -torch.autograd.grad(UpperCAmelCase			,  UpperCAmelCase      )[0]

					if isinstance(self.scheduler			,  UpperCAmelCase      ):
						lowerCAmelCase_			       = latents.detach() + grads * (sigma**2)
						lowerCAmelCase_			       = noise_pred_original
					else:
						lowerCAmelCase_			       = noise_pred_original - torch.sqrt(UpperCAmelCase      ) * grads
					return noise_pred, latents







				@torch.no_grad()
				def __call__(   self			,  UpperCAmelCase			,  UpperCAmelCase = 512			,  UpperCAmelCase = 512			,  UpperCAmelCase = 50			,  UpperCAmelCase = 7.5			,  UpperCAmelCase = 1			,  UpperCAmelCase = 0.0			,  UpperCAmelCase = 100			,  UpperCAmelCase = None			,  UpperCAmelCase = 4			,  UpperCAmelCase = True			,  UpperCAmelCase = None			,  UpperCAmelCase = None			,  UpperCAmelCase = "pil"			,  UpperCAmelCase = True			,  ):

					'''simple docstring'''






					if isinstance(UpperCAmelCase			,  UpperCAmelCase      ):
						lowerCAmelCase_			       = 1
					elif isinstance(UpperCAmelCase			,  UpperCAmelCase      ):
						lowerCAmelCase_			       = len(UpperCAmelCase      )
					else:
						raise ValueError(F"""`prompt` has to be of type `str` or `list` but is {type(UpperCAmelCase      )}"""      )

					if height % 8 != 0 or width % 8 != 0:
						raise ValueError(F"""`height` and `width` have to be divisible by 8 but are {height} and {width}."""      )

					# get prompt text embeddings
					lowerCAmelCase_			       = self.tokenizer(
					    UpperCAmelCase			,  padding='''max_length'''			,  max_length=self.tokenizer.model_max_length			,  truncation=UpperCAmelCase			,  return_tensors='''pt'''			,  )
					lowerCAmelCase_			       = self.text_encoder(text_input.input_ids.to(self.device      )      )[0]
					# duplicate text embeddings for each generation per prompt
					lowerCAmelCase_			       = text_embeddings.repeat_interleave(UpperCAmelCase			,  dim=0      )

					if clip_guidance_scale > 0:
						if clip_prompt is not None:
							lowerCAmelCase_			       = self.tokenizer(
							    UpperCAmelCase			,  padding='''max_length'''			,  max_length=self.tokenizer.model_max_length			,  truncation=UpperCAmelCase			,  return_tensors='''pt'''			,  ).input_ids.to(self.device      )
						else:
							lowerCAmelCase_			       = text_input.input_ids.to(self.device      )
						lowerCAmelCase_			       = self.clip_model.get_text_features(UpperCAmelCase      )
						lowerCAmelCase_			       = text_embeddings_clip / text_embeddings_clip.norm(p=2			,  dim=-1			,  keepdim=UpperCAmelCase      )
						# duplicate text embeddings clip for each generation per prompt
						lowerCAmelCase_			       = text_embeddings_clip.repeat_interleave(UpperCAmelCase			,  dim=0      )

					# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
					# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
					# corresponds to doing no classifier free guidance.
					lowerCAmelCase_			       = guidance_scale > 1.0
					# get unconditional embeddings for classifier free guidance
					if do_classifier_free_guidance:
						lowerCAmelCase_			       = text_input.input_ids.shape[-1]
						lowerCAmelCase_			       = self.tokenizer(['''''']			,  padding='''max_length'''			,  max_length=UpperCAmelCase			,  return_tensors='''pt'''      )
						lowerCAmelCase_			       = self.text_encoder(uncond_input.input_ids.to(self.device      )      )[0]
						# duplicate unconditional embeddings for each generation per prompt
						lowerCAmelCase_			       = uncond_embeddings.repeat_interleave(UpperCAmelCase			,  dim=0      )

						# For classifier free guidance, we need to do two forward passes.
						# Here we concatenate the unconditional and text embeddings into a single batch
						# to avoid doing two forward passes
						lowerCAmelCase_			       = torch.cat([uncond_embeddings, text_embeddings]      )

					# get the initial random noise unless the user supplied it

					# Unlike in other pipelines, latents need to be generated in the target device
					# for 1-to-1 results reproducibility with the CompVis implementation.
					# However this currently doesn't work in `mps`.
					lowerCAmelCase_			       = (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
					lowerCAmelCase_			       = text_embeddings.dtype
					if latents is None:
						if self.device.type == "mps":
							# randn does not work reproducibly on mps
							lowerCAmelCase_			       = torch.randn(UpperCAmelCase			,  generator=UpperCAmelCase			,  device='''cpu'''			,  dtype=UpperCAmelCase      ).to(
							    self.device      )
						else:
							lowerCAmelCase_			       = torch.randn(UpperCAmelCase			,  generator=UpperCAmelCase			,  device=self.device			,  dtype=UpperCAmelCase      )
					else:
						if latents.shape != latents_shape:
							raise ValueError(F"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}"""      )
						lowerCAmelCase_			       = latents.to(self.device      )

					# set timesteps
					lowerCAmelCase_			       = '''offset''' in set(inspect.signature(self.scheduler.set_timesteps      ).parameters.keys()      )
					lowerCAmelCase_			       = {}
					if accepts_offset:
						lowerCAmelCase_			       = 1

					self.scheduler.set_timesteps(UpperCAmelCase			,  **UpperCAmelCase      )

					# Some schedulers like PNDM have timesteps as arrays
					# It's more optimized to move all timesteps to correct device beforehand
					lowerCAmelCase_			       = self.scheduler.timesteps.to(self.device      )

					# scale the initial noise by the standard deviation required by the scheduler
					lowerCAmelCase_			       = latents * self.scheduler.init_noise_sigma

					# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
					# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
					# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
					# and should be between [0, 1]
					lowerCAmelCase_			       = '''eta''' in set(inspect.signature(self.scheduler.step      ).parameters.keys()      )
					lowerCAmelCase_			       = {}
					if accepts_eta:
						lowerCAmelCase_			       = eta

					# check if the scheduler accepts generator
					lowerCAmelCase_			       = '''generator''' in set(inspect.signature(self.scheduler.step      ).parameters.keys()      )
					if accepts_generator:
						lowerCAmelCase_			       = generator

					for i, t in enumerate(self.progress_bar(UpperCAmelCase      )      ):
						# expand the latents if we are doing classifier free guidance
						lowerCAmelCase_			       = torch.cat([latents] * 2      ) if do_classifier_free_guidance else latents
						lowerCAmelCase_			       = self.scheduler.scale_model_input(UpperCAmelCase			,  UpperCAmelCase      )

						# predict the noise residual
						lowerCAmelCase_			       = self.unet(UpperCAmelCase			,  UpperCAmelCase			,  encoder_hidden_states=UpperCAmelCase      ).sample

						# perform classifier free guidance
						if do_classifier_free_guidance:
							lowerCAmelCase_       ,  lowerCAmelCase_			       = noise_pred.chunk(2      )
							lowerCAmelCase_			       = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

						# perform clip guidance
						if clip_guidance_scale > 0:
							lowerCAmelCase_			       = (
							    text_embeddings.chunk(2      )[1] if do_classifier_free_guidance else text_embeddings
							)
							lowerCAmelCase_       ,  lowerCAmelCase_			       = self.cond_fn(
							    UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  )

						# compute the previous noisy sample x_t -> x_t-1
						lowerCAmelCase_			       = self.scheduler.step(UpperCAmelCase			,  UpperCAmelCase			,  UpperCAmelCase			,  **UpperCAmelCase      ).prev_sample

					# scale and decode the image latents with vae
					lowerCAmelCase_			       = 1 / self.vae.config.scaling_factor * latents
					lowerCAmelCase_			       = self.vae.decode(UpperCAmelCase      ).sample

					lowerCAmelCase_			       = (image / 2 + 0.5).clamp(0			,  1      )
					lowerCAmelCase_			       = image.cpu().permute(0			,  2			,  3			,  1      ).numpy()

					if output_type == "pil":
						lowerCAmelCase_			       = self.numpy_to_pil(UpperCAmelCase      )

					if not return_dict:
						return (image, None)

					return StableDiffusionPipelineOutput(images=UpperCAmelCase			,  nsfw_content_detected=UpperCAmelCase      )



"""simple docstring"""



import doctest

import projectq
from projectq.ops import H, Measure
def     UpperCAmelCase    (					_lowercase   :      projectq.cengines._main.MainEngine  )	->   int:


	"""simple docstring"""




	lowerCAmelCase_			       = quantum_engine.allocate_qubit()
	H | qubit
	Measure | qubit
	return int(_lowercase  )


if __name__ == "__main__":
		doctest.testmod()

		# initialises a new quantum backend
		lowercase_							 =       projectq.MainEngine()

		# Generate a list of 10 random numbers
		lowercase_							 =       [get_random_number(quantum_engine) for _ in range(10)]

		# Flushes the quantum engine from memory
		quantum_engine.flush()

		print('Random numbers', random_numbers_list)