



import torch

from transformers import AutoModel






class 						lowercase		(					torch.nn.Module):






	"""simple docstring"""


	def __init__(      self      :		List[Any]		,    __UpperCAmelCase      :		List[str]="sayef/fsner-bert-base-uncased"	)     ->					Optional[int]:
							super(__UpperCAmelCase		,    self	).__init__()

							UpperCAmelCase_=  AutoModel.from_pretrained(__UpperCAmelCase		,    return_dict=__UpperCAmelCase	)
							UpperCAmelCase_=  torch.nn.CosineSimilarity(3		,    1E-08	)
							UpperCAmelCase_=  torch.nn.Softmax(dim=1	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		List[Any]		,    **__UpperCAmelCase      :		str	)     ->					str:
							return self.bert(**__UpperCAmelCase	).last_hidden_state




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]		,    __UpperCAmelCase      :		List[Any]	)     ->					Optional[Any]:
							return token_embeddings.sum(2		,    keepdim=__UpperCAmelCase	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Tuple		,    __UpperCAmelCase      :		str		,    __UpperCAmelCase      :		Tuple		,    __UpperCAmelCase      :		List[str]=1	)     ->					Optional[int]:
							return self.softmax(T * self.cos(__UpperCAmelCase		,    __UpperCAmelCase	)	)




	def     _SCREAMING_SNAKE_CASE						(      self      :		Optional[Any]		,    __UpperCAmelCase      :		List[Any]		,    __UpperCAmelCase      :		int	)     ->					Optional[int]:
							UpperCAmelCase_=  W_supports["""sizes"""].tolist()
							UpperCAmelCase_=  W_supports["""start_token_id"""].item()
							UpperCAmelCase_=  W_supports["""end_token_id"""].item()

							del W_supports["sizes"]
							del W_supports["start_token_id"]
							del W_supports["end_token_id"]

							UpperCAmelCase_=  self.BERT(**__UpperCAmelCase	)
							UpperCAmelCase_=  self.BERT(**__UpperCAmelCase	)

							UpperCAmelCase_=  None
							UpperCAmelCase_=  None

							UpperCAmelCase_=  W_supports["""input_ids"""] == start_token_id
							UpperCAmelCase_=  W_supports["""input_ids"""] == end_token_id

							for i, size in enumerate(__UpperCAmelCase	):
													if i == 0:
																			UpperCAmelCase_=  0
													else:
																			UpperCAmelCase_=  support_sizes[i - 1]

													UpperCAmelCase_=  S[s : s + size][start_token_masks[s : s + size]]
													UpperCAmelCase_=  S[s : s + size][end_token_masks[s : s + size]]

													UpperCAmelCase_=  torch.matmul(q[i]		,    s_start.T	).sum(1	).softmax(0	)
													UpperCAmelCase_=  torch.matmul(q[i]		,    s_end.T	).sum(1	).softmax(0	)

													if p_starts is not None:
																			UpperCAmelCase_=  torch.vstack((p_starts, p_start)	)
																			UpperCAmelCase_=  torch.vstack((p_ends, p_end)	)
													else:
																			UpperCAmelCase_=  p_start
																			UpperCAmelCase_=  p_end

							return p_starts, p_ends












from typing import Any, Callable, Dict, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


lowercase    				=   "CompVis/stable-diffusion-v1-1"
lowercase    				=   "CompVis/stable-diffusion-v1-2"
lowercase    				=   "CompVis/stable-diffusion-v1-3"
lowercase    				=   "CompVis/stable-diffusion-v1-4"




class 					UpperCamelCase_ (     snake_case_							):



	'''simple docstring'''




	def __init__(			self			,     a			,     a			,     a			,     a			,     a			,     a			,     a			,     a = True			,     )			->       int:
								super()._init_()

								snake_case_           =				StableDiffusionPipeline.from_pretrained(a   )
								snake_case_           =				StableDiffusionPipeline.from_pretrained(a   )
								snake_case_           =				StableDiffusionPipeline.from_pretrained(a   )
								snake_case_           =				StableDiffusionPipeline(
								    vae=a			,     text_encoder=a			,     tokenizer=a			,     unet=a			,     scheduler=a			,     safety_checker=a			,     feature_extractor=a			,     requires_safety_checker=a			,     )

								self.register_modules(pipelinea=self.pipea			,     pipelinea=self.pipea			,     pipelinea=self.pipea			,     pipelinea=self.pipea   )




	@property
	def 				_UpperCamelCase     (			self   )			->       Dict[str, Any]:
								return {k: getattr(self			,     a   ) for k in self.config.keys() if not k.startswith('_'   )}




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




	def 				_UpperCamelCase     (			self   )			->       List[Any]:
								self.enable_attention_slicing(a   )




	@torch.no_grad()
	def 				_UpperCamelCase     (			self			,     a			,     a = 5_12			,     a = 5_12			,     a = 50			,     a = 7.5			,     a = None			,     a = 1			,     a = 0.0			,     a = None			,     a = None			,     a = "pil"			,     a = True			,     a = None			,     a = 1			,     **a			,     )			->       Optional[Any]:
								return self.pipea(
								    prompt=a			,     height=a			,     width=a			,     num_inference_steps=a			,     guidance_scale=a			,     negative_prompt=a			,     num_images_per_prompt=a			,     eta=a			,     generator=a			,     latents=a			,     output_type=a			,     return_dict=a			,     callback=a			,     callback_steps=a			,     **a			,     )




	@torch.no_grad()
	def 				_UpperCamelCase     (			self			,     a			,     a = 5_12			,     a = 5_12			,     a = 50			,     a = 7.5			,     a = None			,     a = 1			,     a = 0.0			,     a = None			,     a = None			,     a = "pil"			,     a = True			,     a = None			,     a = 1			,     **a			,     )			->       int:
								return self.pipea(
								    prompt=a			,     height=a			,     width=a			,     num_inference_steps=a			,     guidance_scale=a			,     negative_prompt=a			,     num_images_per_prompt=a			,     eta=a			,     generator=a			,     latents=a			,     output_type=a			,     return_dict=a			,     callback=a			,     callback_steps=a			,     **a			,     )




	@torch.no_grad()
	def 				_UpperCamelCase     (			self			,     a			,     a = 5_12			,     a = 5_12			,     a = 50			,     a = 7.5			,     a = None			,     a = 1			,     a = 0.0			,     a = None			,     a = None			,     a = "pil"			,     a = True			,     a = None			,     a = 1			,     **a			,     )			->       Optional[int]:
								return self.pipea(
								    prompt=a			,     height=a			,     width=a			,     num_inference_steps=a			,     guidance_scale=a			,     negative_prompt=a			,     num_images_per_prompt=a			,     eta=a			,     generator=a			,     latents=a			,     output_type=a			,     return_dict=a			,     callback=a			,     callback_steps=a			,     **a			,     )




	@torch.no_grad()
	def 				_UpperCamelCase     (			self			,     a			,     a = 5_12			,     a = 5_12			,     a = 50			,     a = 7.5			,     a = None			,     a = 1			,     a = 0.0			,     a = None			,     a = None			,     a = "pil"			,     a = True			,     a = None			,     a = 1			,     **a			,     )			->       Any:
								return self.pipea(
								    prompt=a			,     height=a			,     width=a			,     num_inference_steps=a			,     guidance_scale=a			,     negative_prompt=a			,     num_images_per_prompt=a			,     eta=a			,     generator=a			,     latents=a			,     output_type=a			,     return_dict=a			,     callback=a			,     callback_steps=a			,     **a			,     )






	@torch.no_grad()
	def 				_UpperCamelCase     (			self			,     a			,     a = 5_12			,     a = 5_12			,     a = 50			,     a = 7.5			,     a = None			,     a = 1			,     a = 0.0			,     a = None			,     a = None			,     a = "pil"			,     a = True			,     a = None			,     a = 1			,     **a			,     )			->       Optional[Any]:
								snake_case_           =				'cuda' if torch.cuda.is_available() else 'cpu'
								self.to(a   )

								# Checks if the height and width are divisible by 8 or not
								if height % 8 != 0 or width % 8 != 0:
															raise ValueError(F'''`height` and `width` must be divisible by 8 but are {height} and {width}.'''   )

								# Get first result from Stable Diffusion Checkpoint v1.1
								snake_case_           =				self.textaimg_sda_a(
								    prompt=a			,     height=a			,     width=a			,     num_inference_steps=a			,     guidance_scale=a			,     negative_prompt=a			,     num_images_per_prompt=a			,     eta=a			,     generator=a			,     latents=a			,     output_type=a			,     return_dict=a			,     callback=a			,     callback_steps=a			,     **a			,     )

								# Get first result from Stable Diffusion Checkpoint v1.2
								snake_case_           =				self.textaimg_sda_a(
								    prompt=a			,     height=a			,     width=a			,     num_inference_steps=a			,     guidance_scale=a			,     negative_prompt=a			,     num_images_per_prompt=a			,     eta=a			,     generator=a			,     latents=a			,     output_type=a			,     return_dict=a			,     callback=a			,     callback_steps=a			,     **a			,     )

								# Get first result from Stable Diffusion Checkpoint v1.3
								snake_case_           =				self.textaimg_sda_a(
								    prompt=a			,     height=a			,     width=a			,     num_inference_steps=a			,     guidance_scale=a			,     negative_prompt=a			,     num_images_per_prompt=a			,     eta=a			,     generator=a			,     latents=a			,     output_type=a			,     return_dict=a			,     callback=a			,     callback_steps=a			,     **a			,     )

								# Get first result from Stable Diffusion Checkpoint v1.4
								snake_case_           =				self.textaimg_sda_a(
								    prompt=a			,     height=a			,     width=a			,     num_inference_steps=a			,     guidance_scale=a			,     negative_prompt=a			,     num_images_per_prompt=a			,     eta=a			,     generator=a			,     latents=a			,     output_type=a			,     return_dict=a			,     callback=a			,     callback_steps=a			,     **a			,     )

								# Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
								return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]   )





