
import os
import time
from dataclasses import dataclass, field
from enum import Enum
from typing import Dict, List, Optional, Union

import torch
from filelock import FileLock
from torch.utils.data import Dataset

from ...models.auto.modeling_auto import MODEL_FOR_QUESTION_ANSWERING_MAPPING
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
from ..processors.squad import SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features


_lowerCamelCase	:    Tuple          =      logging.get_logger(__name__)

_lowerCamelCase	:    List[str]          =      list(MODEL_FOR_QUESTION_ANSWERING_MAPPING.keys())
_lowerCamelCase	:    Union[str, Any]          =      tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)




@dataclass
class        SCREAMING_SNAKE_CASE__					:





 '''simple docstring'''



 _UpperCAmelCase	:		str          = field(
     default=UpperCAmelCase							,metadata={"help": "Model type selected in the list: " + ", ".join(UpperCAmelCase )} )
 _UpperCAmelCase	:		str          = field(
     default=UpperCAmelCase							,metadata={"help": "The input data dir. Should contain the .json files for the SQuAD task."} )
 _UpperCAmelCase	:		int          = field(
     default=1_2_8							,metadata={
         "help": (
             "The maximum total input sequence length after tokenization. Sequences longer "
             "than this will be truncated, sequences shorter will be padded."
         )
     }							,)
 _UpperCAmelCase	:		int          = field(
     default=1_2_8							,metadata={"help": "When splitting up a long document into chunks, how much stride to take between chunks."}							,)
 _UpperCAmelCase	:		int          = field(
     default=6_4							,metadata={
         "help": (
             "The maximum number of tokens for the question. Questions longer than this will "
             "be truncated to this length."
         )
     }							,)
 _UpperCAmelCase	:		int          = field(
     default=3_0							,metadata={
         "help": (
             "The maximum length of an answer that can be generated. This is needed because the start "
             "and end predictions are not conditioned on one another."
         )
     }							,)
 _UpperCAmelCase	:		bool          = field(
     default=UpperCAmelCase							,metadata={"help": "Overwrite the cached training and evaluation sets"} )
 _UpperCAmelCase	:		bool          = field(
     default=UpperCAmelCase							,metadata={"help": "If true, the SQuAD examples contain some that do not have an answer."} )
 _UpperCAmelCase	:		float          = field(
     default=0.0							,metadata={"help": "If null_score - best_non_null is greater than the threshold predict null."} )
 _UpperCAmelCase	:		int          = field(
     default=2_0							,metadata={"help": "If null_score - best_non_null is greater than the threshold predict null."} )
 _UpperCAmelCase	:		int          = field(
     default=0							,metadata={
         "help": (
             "language id of input for language-specific xlm models (see"
             " tokenization_xlm.PRETRAINED_INIT_CONFIGURATION)"
         )
     }							,)
 _UpperCAmelCase	:		int          = field(default=1							,metadata={"help": "multiple threads for converting example to features"} )




class        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase ):





 '''simple docstring'''



 _UpperCAmelCase	:		List[Any]          = "train"
 _UpperCAmelCase	:		Any          = "dev"




class        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase ):





 '''simple docstring'''



 _UpperCAmelCase	:		SquadDataTrainingArguments
 _UpperCAmelCase	:		List[SquadFeatures]
 _UpperCAmelCase	:		Split
 _UpperCAmelCase	:		bool



 def __init__(  self     :   List[Any]      ,  lowercase     :   SquadDataTrainingArguments      ,  lowercase     :   PreTrainedTokenizer      ,  lowercase     :   Optional[int] = None      ,  lowercase     :   Union[str, Split] = Split.train      ,  lowercase     :   Optional[bool] = False      ,  lowercase     :   Optional[str] = None      ,  lowercase     :   Optional[str] = "pt"      ,  ):


    '''simple docstring'''


    _snake_case          =      args
    _snake_case          =      is_language_sensitive
    _snake_case          =      SquadVaProcessor() if args.version_2_with_negative else SquadVaProcessor()
    if isinstance(lowercase      ,  lowercase     ):
       try:
          _snake_case          =      Split[mode]
       except KeyError:
          raise KeyError('mode is not a valid split name'     )
    _snake_case          =      mode
    # Load data features from cache or dataset file
    _snake_case          =      'v2' if args.version_2_with_negative else 'v1'
    _snake_case          =      os.path.join(
        cache_dir if cache_dir is not None else args.data_dir      ,  f'''cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{version_tag}'''      ,  )

    # Make sure only the first process in distributed training processes the dataset,
    # and the others will use the cache.
    _snake_case          =      cached_features_file + '.lock'
    with FileLock(lowercase     ):
       if os.path.exists(lowercase     ) and not args.overwrite_cache:
          _snake_case          =      time.time()
          _snake_case          =      torch.load(lowercase     )

          # Legacy cache files have only features, while new cache files
          # will have dataset and examples also.
          _snake_case          =      self.old_features['features']
          _snake_case          =      self.old_features.get('dataset'      ,  lowercase     )
          _snake_case          =      self.old_features.get('examples'      ,  lowercase     )
          logger.info(
              f'''Loading features from cached file {cached_features_file} [took %.3f s]'''      ,  time.time() - start     )

          if self.dataset is None or self.examples is None:
             logger.warning(
                 f'''Deleting cached file {cached_features_file} will allow dataset and examples to be cached in'''
                 ' future run'     )
       else:
          if mode == Split.dev:
             _snake_case          =      self.processor.get_dev_examples(args.data_dir     )
          else:
             _snake_case          =      self.processor.get_train_examples(args.data_dir     )

          _snake_case     , _snake_case          =      squad_convert_examples_to_features(
              examples=self.examples      ,  tokenizer=lowercase      ,  max_seq_length=args.max_seq_length      ,  doc_stride=args.doc_stride      ,  max_query_length=args.max_query_length      ,  is_training=mode == Split.train      ,  threads=args.threads      ,  return_dataset=lowercase      ,  )

          _snake_case          =      time.time()
          torch.save(
              {'features': self.features, 'dataset': self.dataset, 'examples': self.examples}      ,  lowercase      ,  )
          # ^ This seems to take a lot of time so I want to investigate why and how we can improve.
          logger.info(
              f'''Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]'''     )



 def __len__(  self     :   Optional[Any]     ):


    '''simple docstring'''


    return len(self.features     )





 def __getitem__(  self     :   Union[str, Any]      ,  lowercase     :   Optional[int]     ):


    '''simple docstring'''


    _snake_case          =      self.features[i]

    _snake_case          =      torch.tensor(feature.input_ids      ,  dtype=torch.long     )
    _snake_case          =      torch.tensor(feature.attention_mask      ,  dtype=torch.long     )
    _snake_case          =      torch.tensor(feature.token_type_ids      ,  dtype=torch.long     )
    _snake_case          =      torch.tensor(feature.cls_index      ,  dtype=torch.long     )
    _snake_case          =      torch.tensor(feature.p_mask      ,  dtype=torch.float     )
    _snake_case          =      torch.tensor(feature.is_impossible      ,  dtype=torch.float     )

    _snake_case          =      {
        'input_ids': input_ids,
        'attention_mask': attention_mask,
        'token_type_ids': token_type_ids,
    }

    if self.args.model_type in ["xlm", "roberta", "distilbert", "camembert"]:
       del inputs["token_type_ids"]

    if self.args.model_type in ["xlnet", "xlm"]:
       inputs.update({'cls_index': cls_index, 'p_mask': p_mask}     )
       if self.args.version_2_with_negative:
          inputs.update({'is_impossible': is_impossible}     )
       if self.is_language_sensitive:
          inputs.update({'langs': (torch.ones(input_ids.shape      ,  dtype=torch.intaa     ) * self.args.lang_id)}     )

    if self.mode == Split.train:
       _snake_case          =      torch.tensor(feature.start_position      ,  dtype=torch.long     )
       _snake_case          =      torch.tensor(feature.end_position      ,  dtype=torch.long     )
       inputs.update({'start_positions': start_positions, 'end_positions': end_positions}     )

    return inputs

import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

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






def 	a_		(	__lowercase       :     str	, __lowercase       :     List[str]	, __lowercase       :     Dict			)			->  List[str]:
			if isinstance(__lowercase	, torch.Tensor			):
						return image
			elif isinstance(__lowercase	, PIL.Image.Image			):
						_snake_case          =      [image]

			if isinstance(image[0]	, PIL.Image.Image			):
						_snake_case          =      [np.array(i.resize((w, h)	, resample=PIL_INTERPOLATION['lanczos']			)			)[None, :] for i in image]
						_snake_case          =      np.concatenate(__lowercase	, axis=0			)
						_snake_case          =      np.array(__lowercase			).astype(np.floataa			) / 2_5_5.0
						_snake_case          =      image.transpose(0	, 3	, 1	, 2			)
						_snake_case          =      2.0 * image - 1.0
						_snake_case          =      torch.from_numpy(__lowercase			)
			elif isinstance(image[0]	, torch.Tensor			):
						_snake_case          =      torch.cat(__lowercase	, dim=0			)
			return image






def 	a_		(	__lowercase       :     int	, __lowercase       :     Any	, __lowercase       :     List[Any]	, __lowercase       :     Tuple=0.9_9_9_5			)			->  List[str]:
			if not isinstance(__lowercase	, np.ndarray			):
						_snake_case          =      True
						_snake_case          =      va.device
						_snake_case          =      va.cpu().numpy()
						_snake_case          =      va.cpu().numpy()

			_snake_case          =      np.sum(va * va / (np.linalg.norm(__lowercase			) * np.linalg.norm(__lowercase			))			)
			if np.abs(__lowercase			) > DOT_THRESHOLD:
						_snake_case          =      (1 - t) * va + t * va
			else:
						_snake_case          =      np.arccos(__lowercase			)
						_snake_case          =      np.sin(__lowercase			)
						_snake_case          =      theta_a * t
						_snake_case          =      np.sin(__lowercase			)
						_snake_case          =      np.sin(theta_a - theta_t			) / sin_theta_a
						_snake_case          =      sin_theta_t / sin_theta_a
						_snake_case          =      sa * va + sa * va

			if inputs_are_torch:
						_snake_case          =      torch.from_numpy(__lowercase			).to(__lowercase			)

			return va






def 	a_		(	__lowercase       :     int	, __lowercase       :     Optional[int]			)			->  List[Any]:
			_snake_case          =      F.normalize(__lowercase	, dim=-1			)
			_snake_case          =      F.normalize(__lowercase	, dim=-1			)
			return (x - y).norm(dim=-1			).div(2			).arcsin().pow(2			).mul(2			)






def 	a_		(	__lowercase       :     int	, __lowercase       :     Any			)			->  Optional[Any]:
			for param in model.parameters():
						_snake_case          =      value




class        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase ):





	'''simple docstring'''



	def __init__(  self     :   List[Any]      ,  lowercase     :   AutoencoderKL      ,  lowercase     :   CLIPTextModel      ,  lowercase     :   CLIPModel      ,  lowercase     :   CLIPTokenizer      ,  lowercase     :   UNetaDConditionModel      ,  lowercase     :   Union[PNDMScheduler, LMSDiscreteScheduler, DDIMScheduler, DPMSolverMultistepScheduler]      ,  lowercase     :   CLIPFeatureExtractor      ,  lowercase     :   Any=None      ,  lowercase     :   List[str]=None      ,  lowercase     :   List[str]=None      ,  ):


				'''simple docstring'''


				super().__init__()
				self.register_modules(
				    vae=lowercase      ,  text_encoder=lowercase      ,  clip_model=lowercase      ,  tokenizer=lowercase      ,  unet=lowercase      ,  scheduler=lowercase      ,  feature_extractor=lowercase      ,  coca_model=lowercase      ,  coca_tokenizer=lowercase      ,  coca_transform=lowercase      ,  )
				_snake_case          =      (
				    feature_extractor.size
				    if isinstance(feature_extractor.size      ,  lowercase     )
				    else feature_extractor.size['shortest_edge']
				)
				_snake_case          =      transforms.Normalize(mean=feature_extractor.image_mean      ,  std=feature_extractor.image_std     )
				set_requires_grad(self.text_encoder      ,  lowercase     )
				set_requires_grad(self.clip_model      ,  lowercase     )



	def 			A							(  self     :   Optional[int]      ,  lowercase     :   Optional[Union[str, int]] = "auto"     ):


				'''simple docstring'''


				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(lowercase     )



	def 			A							(  self     :   Dict     ):


				'''simple docstring'''


				self.enable_attention_slicing(lowercase     )



	def 			A							(  self     :   int     ):


				'''simple docstring'''


				set_requires_grad(self.vae      ,  lowercase     )



	def 			A							(  self     :   Union[str, Any]     ):


				'''simple docstring'''


				set_requires_grad(self.vae      ,  lowercase     )



	def 			A							(  self     :   str     ):


				'''simple docstring'''


				set_requires_grad(self.unet      ,  lowercase     )



	def 			A							(  self     :   Dict     ):


				'''simple docstring'''


				set_requires_grad(self.unet      ,  lowercase     )



	def 			A							(  self     :   str      ,  lowercase     :   Optional[Any]      ,  lowercase     :   Optional[int]      ,  lowercase     :   Union[str, Any]     ):


				'''simple docstring'''


				_snake_case          =      min(int(num_inference_steps * strength     )      ,  lowercase     )

				_snake_case          =      max(num_inference_steps - init_timestep      ,  0     )
				_snake_case          =      self.scheduler.timesteps[t_start:]

				return timesteps, num_inference_steps - t_start



	def 			A							(  self     :   Optional[Any]      ,  lowercase     :   List[str]      ,  lowercase     :   Optional[Any]      ,  lowercase     :   str      ,  lowercase     :   Union[str, Any]      ,  lowercase     :   List[str]      ,  lowercase     :   List[Any]=None     ):


				'''simple docstring'''


				if not isinstance(lowercase      ,  torch.Tensor     ):
							raise ValueError(f'''`image` has to be of type `torch.Tensor` but is {type(lowercase     )}'''     )

				_snake_case          =      image.to(device=lowercase      ,  dtype=lowercase     )

				if isinstance(lowercase      ,  lowercase     ):
							_snake_case          =      [
							    self.vae.encode(image[i : i + 1]     ).latent_dist.sample(generator[i]     ) for i in range(lowercase     )
							]
							_snake_case          =      torch.cat(lowercase      ,  dim=0     )
				else:
							_snake_case          =      self.vae.encode(lowercase     ).latent_dist.sample(lowercase     )

				# Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
				_snake_case          =      0.18215 * init_latents
				_snake_case          =      init_latents.repeat_interleave(lowercase      ,  dim=0     )

				_snake_case          =      randn_tensor(init_latents.shape      ,  generator=lowercase      ,  device=lowercase      ,  dtype=lowercase     )

				# get latents
				_snake_case          =      self.scheduler.add_noise(lowercase      ,  lowercase      ,  lowercase     )
				_snake_case          =      init_latents

				return latents



	def 			A							(  self     :   int      ,  lowercase     :   int     ):


				'''simple docstring'''


				_snake_case          =      self.coca_transform(lowercase     ).unsqueeze(0     )
				with torch.no_grad(), torch.cuda.amp.autocast():
							_snake_case          =      self.coca_model.generate(transformed_image.to(device=self.device      ,  dtype=self.coca_model.dtype     )     )
				_snake_case          =      self.coca_tokenizer.decode(generated[0].cpu().numpy()     )
				return generated.split('<end_of_text>'     )[0].replace('<start_of_text>'      ,  ''     ).rstrip(' .,'     )



	def 			A							(  self     :   List[Any]      ,  lowercase     :   Dict      ,  lowercase     :   Any     ):


				'''simple docstring'''


				_snake_case          =      self.feature_extractor.preprocess(lowercase     )
				_snake_case          =      torch.from_numpy(clip_image_input['pixel_values'][0]     ).unsqueeze(0     ).to(self.device     ).half()
				_snake_case          =      self.clip_model.get_image_features(lowercase     )
				_snake_case          =      image_embeddings_clip / image_embeddings_clip.norm(p=2      ,  dim=-1      ,  keepdim=lowercase     )
				_snake_case          =      image_embeddings_clip.repeat_interleave(lowercase      ,  dim=0     )
				return image_embeddings_clip



	@torch.enable_grad()
	def 			A							(  self     :   int      ,  lowercase     :   Optional[int]      ,  lowercase     :   Optional[int]      ,  lowercase     :   Optional[int]      ,  lowercase     :   int      ,  lowercase     :   Any      ,  lowercase     :   Union[str, Any]      ,  lowercase     :   Optional[int]      ,  ):


				'''simple docstring'''


				_snake_case          =      latents.detach().requires_grad_()

				_snake_case          =      self.scheduler.scale_model_input(lowercase      ,  lowercase     )

				# predict the noise residual
				_snake_case          =      self.unet(lowercase      ,  lowercase      ,  encoder_hidden_states=lowercase     ).sample

				if isinstance(self.scheduler      ,  (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)     ):
							_snake_case          =      self.scheduler.alphas_cumprod[timestep]
							_snake_case          =      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
							_snake_case          =      (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

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

				# Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
				_snake_case          =      1 / 0.18215 * sample
				_snake_case          =      self.vae.decode(lowercase     ).sample
				_snake_case          =      (image / 2 + 0.5).clamp(0      ,  1     )

				_snake_case          =      transforms.Resize(self.feature_extractor_size     )(lowercase     )
				_snake_case          =      self.normalize(lowercase     ).to(latents.dtype     )

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

				_snake_case          =      spherical_dist_loss(lowercase      ,  lowercase     ).mean() * clip_guidance_scale

				_snake_case          =      -torch.autograd.grad(lowercase      ,  lowercase     )[0]

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





	@torch.no_grad()
	def __call__(  self     :   int      ,  lowercase     :   Union[torch.FloatTensor, PIL.Image.Image]      ,  lowercase     :   Union[torch.FloatTensor, PIL.Image.Image]      ,  lowercase     :   Optional[str] = None      ,  lowercase     :   Optional[str] = None      ,  lowercase     :   Optional[int] = 512      ,  lowercase     :   Optional[int] = 512      ,  lowercase     :   float = 0.6      ,  lowercase     :   Optional[int] = 50      ,  lowercase     :   Optional[float] = 7.5      ,  lowercase     :   Optional[int] = 1      ,  lowercase     :   float = 0.0      ,  lowercase     :   Optional[float] = 100      ,  lowercase     :   Optional[torch.Generator] = None      ,  lowercase     :   Optional[str] = "pil"      ,  lowercase     :   bool = True      ,  lowercase     :   float = 0.8      ,  lowercase     :   float = 0.1      ,  lowercase     :   float = 0.1      ,  ):


				'''simple docstring'''


				if isinstance(lowercase      ,  lowercase     ) and len(lowercase     ) != batch_size:
							raise ValueError(f'''You have passed {batch_size} batch_size, but only {len(lowercase     )} generators.'''     )

				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}.'''     )

				if isinstance(lowercase      ,  torch.Generator     ) and batch_size > 1:
							_snake_case          =      [generator] + [None] * (batch_size - 1)

				_snake_case          =      [
				    ('model', self.coca_model is None),
				    ('tokenizer', self.coca_tokenizer is None),
				    ('transform', self.coca_transform is None),
				]
				_snake_case          =      [x[0] for x in coca_is_none if x[1]]
				_snake_case          =      ', '.join(lowercase     )
				# generate prompts with coca model if prompt is None
				if content_prompt is None:
							if len(lowercase     ):
										raise ValueError(
										    f'''Content prompt is None and CoCa [{coca_is_none_str}] is None.'''
										    f'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'''     )
							_snake_case          =      self.get_image_description(lowercase     )
				if style_prompt is None:
							if len(lowercase     ):
										raise ValueError(
										    f'''Style prompt is None and CoCa [{coca_is_none_str}] is None.'''
										    f''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'''     )
							_snake_case          =      self.get_image_description(lowercase     )

				# get prompt text embeddings for content and style
				_snake_case          =      self.tokenizer(
				    lowercase      ,  padding='max_length'      ,  max_length=self.tokenizer.model_max_length      ,  truncation=lowercase      ,  return_tensors='pt'      ,  )
				_snake_case          =      self.text_encoder(content_text_input.input_ids.to(self.device     )     )[0]

				_snake_case          =      self.tokenizer(
				    lowercase      ,  padding='max_length'      ,  max_length=self.tokenizer.model_max_length      ,  truncation=lowercase      ,  return_tensors='pt'      ,  )
				_snake_case          =      self.text_encoder(style_text_input.input_ids.to(self.device     )     )[0]

				_snake_case          =      slerp(lowercase      ,  lowercase      ,  lowercase     )

				# duplicate text embeddings for each generation per prompt
				_snake_case          =      text_embeddings.repeat_interleave(lowercase      ,  dim=0     )

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

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

				_snake_case     , _snake_case          =      self.get_timesteps(lowercase      ,  lowercase      ,  self.device     )
				_snake_case          =      timesteps[:1].repeat(lowercase     )

				# Preprocess image
				_snake_case          =      preprocess(lowercase      ,  lowercase      ,  lowercase     )
				_snake_case          =      self.prepare_latents(
				    lowercase      ,  lowercase      ,  lowercase      ,  text_embeddings.dtype      ,  self.device      ,  lowercase     )

				_snake_case          =      preprocess(lowercase      ,  lowercase      ,  lowercase     )
				_snake_case          =      self.prepare_latents(
				    lowercase      ,  lowercase      ,  lowercase      ,  text_embeddings.dtype      ,  self.device      ,  lowercase     )

				_snake_case          =      slerp(lowercase      ,  lowercase      ,  lowercase     )

				if clip_guidance_scale > 0:
							_snake_case          =      self.get_clip_image_embeddings(lowercase      ,  lowercase     )
							_snake_case          =      self.get_clip_image_embeddings(lowercase      ,  lowercase     )
							_snake_case          =      slerp(
							    lowercase      ,  lowercase      ,  lowercase     )

				# 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.
				_snake_case          =      guidance_scale > 1.0
				# get unconditional embeddings for classifier free guidance
				if do_classifier_free_guidance:
							_snake_case          =      content_text_input.input_ids.shape[-1]
							_snake_case          =      self.tokenizer(['']      ,  padding='max_length'      ,  max_length=lowercase      ,  return_tensors='pt'     )
							_snake_case          =      self.text_encoder(uncond_input.input_ids.to(self.device     )     )[0]
							# duplicate unconditional embeddings for each generation per prompt
							_snake_case          =      uncond_embeddings.repeat_interleave(lowercase      ,  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
							_snake_case          =      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`.
				_snake_case          =      (batch_size, self.unet.config.in_channels, height // 8, width // 8)
				_snake_case          =      text_embeddings.dtype
				if latents is None:
							if self.device.type == "mps":
										# randn does not work reproducibly on mps
										_snake_case          =      torch.randn(lowercase      ,  generator=lowercase      ,  device='cpu'      ,  dtype=lowercase     ).to(
										    self.device     )
							else:
										_snake_case          =      torch.randn(lowercase      ,  generator=lowercase      ,  device=self.device      ,  dtype=lowercase     )
				else:
							if latents.shape != latents_shape:
										raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''     )
							_snake_case          =      latents.to(self.device     )

				# scale the initial noise by the standard deviation required by the scheduler
				_snake_case          =      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]
				_snake_case          =      'eta' in set(inspect.signature(self.scheduler.step     ).parameters.keys()     )
				_snake_case          =      {}
				if accepts_eta:
							_snake_case          =      eta

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

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

										# predict the noise residual
										_snake_case          =      self.unet(lowercase      ,  lowercase      ,  encoder_hidden_states=lowercase     ).sample

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

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

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

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
				_snake_case          =      1 / 0.18215 * latents
				_snake_case          =      self.vae.decode(lowercase     ).sample

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

				if output_type == "pil":
							_snake_case          =      self.numpy_to_pil(lowercase     )

				if not return_dict:
							return (image, None)

				return StableDiffusionPipelineOutput(images=lowercase      ,  nsfw_content_detected=lowercase     )