

import timeit







class 			__magic_name__					:





			def __init__(	self      ,						__snake_case      )     ->				Optional[Any]:




						'''simple docstring'''




						if isinstance(lowerCAmelCase__      ,						lowerCAmelCase__      ):  # Initializes a matrix identical to the one provided.
									__a						   =arg
									__a						   =len(lowerCAmelCase__      )
						else:  # Initializes a square matrix of the given size and set values to zero.
									__a						   =arg
									__a						   =[[0 for _ in range(self.n      )] for _ in range(self.n      )]





			def __mul__(	self      ,						__snake_case      )     ->				Optional[int]:




						'''simple docstring'''
						__a						   =Matrix(self.n      )
						for i in range(self.n      ):
									for j in range(self.n      ):
												for k in range(self.n      ):
															matrix.t[i][j] += self.t[i][k] * b.t[k][j]
						return matrix






def  UpperCamelCase_(							_snake_case     :						Any ,  _snake_case     :						Any			):




			"""simple docstring"""






			__a						   =Matrix([[1, 0], [0, 1]]			)
			while b > 0:
						if b & 1:
									matrix *= a
						a *= a
						b >>= 1
			return matrix






def  UpperCamelCase_(							_snake_case     :						Any ,  _snake_case     :						Dict ,  _snake_case     :						List[Any]			):




			"""simple docstring"""






			if n == 1:
						return fa
			elif n == 2:
						return fa
			__a						   =Matrix([[1, 1], [1, 0]]			)
			__a						   =modular_exponentiation(_snake_case ,  n - 2			)
			return fa * matrix.t[0][0] + fa * matrix.t[0][1]






def  UpperCamelCase_(							_snake_case     :						List[str] ,  _snake_case     :						List[str] ,  _snake_case     :						Any			):




			"""simple docstring"""






			if n == 1:
						return fa
			elif n == 2:
						return fa

			__a						   =fa
			__a						   =fa
			n -= 2

			while n > 0:
						__a						   =fn_a + fn_a, fn_a
						n -= 1

			return fn_a






def  UpperCamelCase_(							):




			"""simple docstring"""






			__a						   ="\nfrom random import randint\nfrom __main__ import fibonacci_with_matrix_exponentiation\n"
			__a						   ="fibonacci_with_matrix_exponentiation(randint(1,70000), 1, 1)"
			__a						   =timeit.timeit(setup=_snake_case ,  stmt=_snake_case ,  number=100			)
			print('With matrix exponentiation the average execution time is ' ,  exec_time / 100			)
			return exec_time






def  UpperCamelCase_(							):




			"""simple docstring"""






			__a						   ="\nfrom random import randint\nfrom __main__ import simple_fibonacci\n"
			__a						   ="simple_fibonacci(randint(1,70000), 1, 1)"
			__a						   =timeit.timeit(setup=_snake_case ,  stmt=_snake_case ,  number=100			)
			print(
			    'Without matrix exponentiation the average execution time is ' ,  exec_time / 100			)
			return exec_time






def  UpperCamelCase_(							):




			"""simple docstring"""






			matrix_exponentiation_time()
			simple_fibonacci_time()


if __name__ == "__main__":
						main()









from logging import getLogger
from typing import Any, Callable, List, Optional, Union

import numpy as np
import PIL
import torch

from ...schedulers import DDPMScheduler
from ..onnx_utils import ORT_TO_NP_TYPE, OnnxRuntimeModel
from ..pipeline_utils import ImagePipelineOutput
from . import StableDiffusionUpscalePipeline


_lowerCAmelCase      :    str						       =    getLogger(__name__)


_lowerCAmelCase      :    int						       =    4
_lowerCAmelCase      :    Union[str, Any]						       =    7

_lowerCAmelCase      :    Optional[Any]						       =    {
    "float16": torch.floataa,
    "float32": torch.floataa,
}






def  UpperCamelCase_(							_snake_case     :						Union[str, Any]			):




			"""simple docstring"""






			if isinstance(_snake_case ,  torch.Tensor			):
						return image
			elif isinstance(_snake_case ,  PIL.Image.Image			):
						__a						   =[image]

			if isinstance(image[0] ,  PIL.Image.Image			):
						__a   ,					__a						   =image[0].size
						__a   ,					__a						   =(x - x % 64 for x in (w, h))  # resize to integer multiple of 32

						__a						   =[np.array(i.resize((w, h)			)			)[None, :] for i in image]
						__a						   =np.concatenate(_snake_case ,  axis=0			)
						__a						   =np.array(_snake_case			).astype(np.floataa			) / 255.0
						__a						   =image.transpose(0 ,  3 ,  1 ,  2			)
						__a						   =2.0 * image - 1.0
						__a						   =torch.from_numpy(_snake_case			)
			elif isinstance(image[0] ,  torch.Tensor			):
						__a						   =torch.cat(_snake_case ,  dim=0			)

			return image






class 			__magic_name__					(    lowerCAmelCase_   ):





			def __init__(	self      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case = 350      ,						)     ->				List[str]:




						'''simple docstring'''
						super().__init__(
						    vae=__snake_case      ,						text_encoder=__snake_case      ,						tokenizer=__snake_case      ,						unet=__snake_case      ,						low_res_scheduler=__snake_case      ,						scheduler=__snake_case      ,						safety_checker=__snake_case      ,						feature_extractor=__snake_case      ,						watermarker=__snake_case      ,						max_noise_level=__snake_case      ,						)





			def __call__(	self      ,						__snake_case      ,						__snake_case      ,						__snake_case = 75      ,						__snake_case = 9.0      ,						__snake_case = 20      ,						__snake_case = None      ,						__snake_case = 1      ,						__snake_case = 0.0      ,						__snake_case = None      ,						__snake_case = None      ,						__snake_case = None      ,						__snake_case = None      ,						__snake_case = "pil"      ,						__snake_case = True      ,						__snake_case = None      ,						__snake_case = 1      ,						)     ->				str:




						'''simple docstring'''
						self.check_inputs(__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      )

						# 2. Define call parameters
						if prompt is not None and isinstance(__snake_case      ,						__snake_case      ):
									__a						   =1
						elif prompt is not None and isinstance(__snake_case      ,						__snake_case      ):
									__a						   =len(__snake_case      )
						else:
									__a						   =prompt_embeds.shape[0]

						__a						   =self._execution_device
						# 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.
						__a						   =guidance_scale > 1.0

						# 3. Encode input prompt
						__a						   =self._encode_prompt(
						    __snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						prompt_embeds=__snake_case      ,						negative_prompt_embeds=__snake_case      ,						)

						__a						   =ORT_TO_PT_TYPE[str(text_embeddings.dtype      )]

						# 4. Preprocess image
						__a						   =preprocess(__snake_case      )
						__a						   =image.cpu()

						# 5. set timesteps
						self.scheduler.set_timesteps(__snake_case      ,						device=__snake_case      )
						__a						   =self.scheduler.timesteps

						# 5. Add noise to image
						__a						   =torch.tensor([noise_level]      ,						dtype=torch.long      ,						device=__snake_case      )
						__a						   =torch.randn(image.shape      ,						generator=__snake_case      ,						device=__snake_case      ,						dtype=__snake_case      )
						__a						   =self.low_res_scheduler.add_noise(__snake_case      ,						__snake_case      ,						__snake_case      )

						__a						   =2 if do_classifier_free_guidance else 1
						__a						   =np.concatenate([image] * batch_multiplier * num_images_per_prompt      )
						__a						   =np.concatenate([noise_level] * image.shape[0]      )

						# 6. Prepare latent variables
						__a   ,					__a						   =image.shape[2:]
						__a						   =self.prepare_latents(
						    batch_size * num_images_per_prompt      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						)

						# 7. Check that sizes of image and latents match
						__a						   =image.shape[1]
						if NUM_LATENT_CHANNELS + num_channels_image != NUM_UNET_INPUT_CHANNELS:
									raise ValueError(
									    'Incorrect configuration settings! The config of `pipeline.unet` expects'
									    f' {NUM_UNET_INPUT_CHANNELS} but received `num_channels_latents`: {NUM_LATENT_CHANNELS} +'
									    f' `num_channels_image`: {num_channels_image} '
									    f' = {NUM_LATENT_CHANNELS+num_channels_image}. Please verify the config of'
									    ' `pipeline.unet` or your `image` input.'      )

						# 8. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
						__a						   =self.prepare_extra_step_kwargs(__snake_case      ,						__snake_case      )

						__a						   =next(
						    (input.type for input in self.unet.model.get_inputs() if input.name == 'timestep')      ,						'tensor(float)'      )
						__a						   =ORT_TO_NP_TYPE[timestep_dtype]

						# 9. Denoising loop
						__a						   =len(__snake_case      ) - num_inference_steps * self.scheduler.order
						with self.progress_bar(total=__snake_case      ) as progress_bar:
									for i, t in enumerate(__snake_case      ):
												# expand the latents if we are doing classifier free guidance
												__a						   =np.concatenate([latents] * 2      ) if do_classifier_free_guidance else latents

												# concat latents, mask, masked_image_latents in the channel dimension
												__a						   =self.scheduler.scale_model_input(__snake_case      ,						__snake_case      )
												__a						   =np.concatenate([latent_model_input, image]      ,						axis=1      )

												# timestep to tensor
												__a						   =np.array([t]      ,						dtype=__snake_case      )

												# predict the noise residual
												__a						   =self.unet(
												    sample=__snake_case      ,						timestep=__snake_case      ,						encoder_hidden_states=__snake_case      ,						class_labels=noise_level.astype(np.intaa      )      ,						)[0]

												# perform guidance
												if do_classifier_free_guidance:
															__a   ,					__a						   =np.split(__snake_case      ,						2      )
												__a						   =noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

												# compute the previous noisy sample x_t -> x_t-1
												__a						   =self.scheduler.step(
												    torch.from_numpy(__snake_case      )      ,						__snake_case      ,						__snake_case      ,						**__snake_case      ).prev_sample

												# call the callback, if provided
												if i == len(__snake_case      ) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
															progress_bar.update()
															if callback is not None and i % callback_steps == 0:
																		callback(__snake_case      ,						__snake_case      ,						__snake_case      )

        # 10. Post-processing
						__a						   =self.decode_latents(latents.float()      )

						# 11. Convert to PIL
						if output_type == "pil":
									__a						   =self.numpy_to_pil(__snake_case      )

						if not return_dict:
									return (image,)

						return ImagePipelineOutput(images=__snake_case      )





			def 	__magic_name__					(	self      ,						__snake_case      )     ->				int:




						'''simple docstring'''
						__a						   =1 / 0.0_8333 * latents
						__a						   =self.vae(latent_sample=__snake_case      )[0]
						__a						   =np.clip(image / 2 + 0.5      ,						0      ,						1      )
						__a						   =image.transpose((0, 2, 3, 1)      )
						return image





			def 	__magic_name__					(	self      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case      ,						__snake_case = None      ,						__snake_case = None      ,						)     ->				List[str]:




						'''simple docstring'''
						if prompt is not None and isinstance(__snake_case      ,						__snake_case      ):
									__a						   =1
						elif prompt is not None and isinstance(__snake_case      ,						__snake_case      ):
									__a						   =len(__snake_case      )
						else:
									__a						   =prompt_embeds.shape[0]

						if prompt_embeds is None:
									__a						   =self.tokenizer(
									    __snake_case      ,						padding='max_length'      ,						max_length=self.tokenizer.model_max_length      ,						truncation=__snake_case      ,						return_tensors='pt'      ,						)
									__a						   =text_inputs.input_ids
									__a						   =self.tokenizer(__snake_case      ,						padding='longest'      ,						return_tensors='pt'      ).input_ids

									if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
									    __snake_case      ,						__snake_case      ):
												__a						   =self.tokenizer.batch_decode(
												    untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]      )
												logger.warning(
												    'The following part of your input was truncated because CLIP can only handle sequences up to'
												    f' {self.tokenizer.model_max_length} tokens: {removed_text}'      )

									# no positional arguments to text_encoder
									__a						   =self.text_encoder(
									    input_ids=text_input_ids.int().to(__snake_case      )      ,						)
									__a						   =prompt_embeds[0]

						__a   ,					__a   ,					__a						   =prompt_embeds.shape
						# duplicate text embeddings for each generation per prompt, using mps friendly method
						__a						   =prompt_embeds.repeat(1      ,						__snake_case      )
						__a						   =prompt_embeds.reshape(bs_embed * num_images_per_prompt      ,						__snake_case      ,						-1      )

						# get unconditional embeddings for classifier free guidance
						if do_classifier_free_guidance and negative_prompt_embeds is None:
									__a						   =42
									if negative_prompt is None:
												__a						   =[''] * batch_size
									elif type(__snake_case      ) is not type(__snake_case      ):
												raise TypeError(
												    f'`negative_prompt` should be the same type to `prompt`, but got {type(__snake_case      )} !='
												    f' {type(__snake_case      )}.'      )
									elif isinstance(__snake_case      ,						__snake_case      ):
												__a						   =[negative_prompt]
									elif batch_size != len(__snake_case      ):
												raise ValueError(
												    f'`negative_prompt`: {negative_prompt} has batch size {len(__snake_case      )}, but `prompt`:'
												    f' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'
												    ' the batch size of `prompt`.'      )
									else:
												__a						   =negative_prompt

									__a						   =text_input_ids.shape[-1]
									__a						   =self.tokenizer(
									    __snake_case      ,						padding='max_length'      ,						max_length=__snake_case      ,						truncation=__snake_case      ,						return_tensors='pt'      ,						)

									# if hasattr(uncond_input, "attention_mask"):
									#     attention_mask = uncond_input.attention_mask.to(device)
									# else:
									#     attention_mask = None

									__a						   =self.text_encoder(
									    input_ids=uncond_input.input_ids.int().to(__snake_case      )      ,						)
									__a						   =uncond_embeddings[0]

						if do_classifier_free_guidance:
									__a						   =uncond_embeddings.shape[1]
									# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
									__a						   =uncond_embeddings.repeat(1      ,						__snake_case      )
									__a						   =uncond_embeddings.reshape(batch_size * num_images_per_prompt      ,						__snake_case      ,						-1      )

									# 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
									__a						   =np.concatenate([uncond_embeddings, prompt_embeds]      )

						return prompt_embeds






