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

import torch
from torch import nn
from torch.utils.data import DistributedSampler, RandomSampler

from transformers import PreTrainedModel, Trainer, logging
from transformers.integrations import is_fairscale_available
from transformers.models.fsmt.configuration_fsmt import FSMTConfig
from transformers.optimization import (
    Adafactor,
    AdamW,
    get_constant_schedule,
    get_constant_schedule_with_warmup,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.trainer_pt_utils import get_tpu_sampler
from transformers.training_args import ParallelMode
from transformers.utils import is_torch_tpu_available


if is_fairscale_available():
      from fairscale.optim import OSS


UpperCamelCase__    							=			logging.get_logger(__name__)

UpperCamelCase__    							=			{
    "linear": get_linear_schedule_with_warmup,
    "cosine": get_cosine_schedule_with_warmup,
    "cosine_w_restarts": get_cosine_with_hard_restarts_schedule_with_warmup,
    "polynomial": get_polynomial_decay_schedule_with_warmup,
    "constant": get_constant_schedule,
    "constant_w_warmup": get_constant_schedule_with_warmup,
}





class 					A							(    __lowerCAmelCase					):


   def __init__(self					:						Dict	,  __UpperCAmelCase					:						str=None	,  __UpperCAmelCase					:						List[str]=None	,  *__UpperCAmelCase					:						Union[str, Any]	,  **__UpperCAmelCase					:						Tuple		)						->    Optional[Any]:
         """simple docstring"""



         super().__init__(*lowerCamelCase__	,  **lowerCamelCase__		)

         if config is None:
               assert isinstance(self.model	,  lowerCamelCase__		), (
                   "If no `config` is passed the model to be trained has to be of type `PreTrainedModel`, but is"
                   f""" {self.model.__class__}"""
               )
               UpperCAmelCase__								=  self.model.config
         else:
               UpperCAmelCase__								=  config

         UpperCAmelCase__								=  data_args
         UpperCAmelCase__								=  self.config.tgt_vocab_size if isinstance(self.config	,  lowerCamelCase__		) else self.config.vocab_size

         if self.args.label_smoothing != 0 or (self.data_args is not None and self.data_args.ignore_pad_token_for_loss):
               assert self.config.pad_token_id is not None, (
                   "Make sure that `config.pad_token_id` is correcly defined when ignoring `pad_token` for loss"
                   " calculation or doing label smoothing."
               )

         if self.config.pad_token_id is None and self.config.eos_token_id is not None:
               logger.warning(
                   f"""The `config.pad_token_id` is `None`. Using `config.eos_token_id` = {self.config.eos_token_id} for"""
                   " padding.."		)

         if self.args.label_smoothing == 0:
               UpperCAmelCase__								=  torch.nn.CrossEntropyLoss(ignore_index=self.config.pad_token_id		)
         else:
               # dynamically import label_smoothed_nll_loss
               from utils import label_smoothed_nll_loss

               UpperCAmelCase__								=  label_smoothed_nll_loss


   def       lowercase_				(self					:						List[Any]	,  __UpperCAmelCase					:						int		)						->    Optional[Any]:
         """simple docstring"""



         if self.optimizer is None:
               UpperCAmelCase__								=  ['''bias''', '''LayerNorm.weight''']
               UpperCAmelCase__								=  [
                   {
                       '''params''': [p for n, p in self.model.named_parameters() if not any(nd in n for nd in no_decay		)],
                       '''weight_decay''': self.args.weight_decay,
                   },
                   {
                       '''params''': [p for n, p in self.model.named_parameters() if any(nd in n for nd in no_decay		)],
                       '''weight_decay''': 0.0,
                   },
               ]
               UpperCAmelCase__								=  Adafactor if self.args.adafactor else AdamW
               if self.args.adafactor:
                     UpperCAmelCase__								=  Adafactor
                     UpperCAmelCase__								=  {'''scale_parameter''': False, '''relative_step''': False}
               else:
                     UpperCAmelCase__								=  AdamW
                     UpperCAmelCase__								=  {
                         '''betas''': (self.args.adam_betaa, self.args.adam_betaa),
                         '''eps''': self.args.adam_epsilon,
                     }
               UpperCAmelCase__								=  self.args.learning_rate
               if self.sharded_ddp:
                     UpperCAmelCase__								=  OSS(
                         params=lowerCamelCase__	,  optim=lowerCamelCase__	,  **lowerCamelCase__	,  )
               else:
                     UpperCAmelCase__								=  optimizer_cls(lowerCamelCase__	,  **lowerCamelCase__		)

         if self.lr_scheduler is None:
               UpperCAmelCase__								=  self._get_lr_scheduler(lowerCamelCase__		)
         else:  # ignoring --lr_scheduler
               logger.warning("scheduler is passed to `Seq2SeqTrainer`, `--lr_scheduler` arg is ignored."		)


   def       lowercase_				(self					:						List[Any]	,  __UpperCAmelCase					:						Union[str, Any]		)						->    str:
         """simple docstring"""



         UpperCAmelCase__								=  arg_to_scheduler[self.args.lr_scheduler]
         if self.args.lr_scheduler == "constant":
               UpperCAmelCase__								=  schedule_func(self.optimizer		)
         elif self.args.lr_scheduler == "constant_w_warmup":
               UpperCAmelCase__								=  schedule_func(self.optimizer	,  num_warmup_steps=self.args.warmup_steps		)
         else:
               UpperCAmelCase__								=  schedule_func(
                   self.optimizer	,  num_warmup_steps=self.args.warmup_steps	,  num_training_steps=lowerCamelCase__		)
         return scheduler


   def       lowercase_				(self					:						Any		)						->    Optional[torch.utils.data.Sampler]:
         """simple docstring"""



         if isinstance(self.train_dataset	,  torch.utils.data.IterableDataset		):
               return None
         elif is_torch_tpu_available():
               return get_tpu_sampler(self.train_dataset		)
         else:
               if self.args.sortish_sampler:
                     self.train_dataset.make_sortish_sampler(
                         self.args.per_device_train_batch_size	,  distributed=(self.args.parallel_mode == ParallelMode.DISTRIBUTED)	,  )

               return (
                   RandomSampler(self.train_dataset		)
                   if self.args.local_rank == -1
                   else DistributedSampler(self.train_dataset		)
               )


   def       lowercase_				(self					:						Optional[Any]	,  __UpperCAmelCase					:						str	,  __UpperCAmelCase					:						List[str]	,  __UpperCAmelCase					:						int		)						->    int:
         """simple docstring"""



         if self.args.label_smoothing == 0:
               if self.data_args is not None and self.data_args.ignore_pad_token_for_loss:
                     # force training to ignore pad token
                     UpperCAmelCase__								=  model(**lowerCamelCase__	,  use_cache=lowerCamelCase__		)[0]
                     UpperCAmelCase__								=  self.loss_fn(logits.view(-1	,  logits.shape[-1]		)	,  labels.view(-1		)		)
               else:
                     # compute usual loss via models
                     UpperCAmelCase__								=  model(**lowerCamelCase__	,  labels=lowerCamelCase__	,  use_cache=lowerCamelCase__		)[:2]
         else:
               # compute label smoothed loss
               UpperCAmelCase__								=  model(**lowerCamelCase__	,  use_cache=lowerCamelCase__		)[0]
               UpperCAmelCase__								=  torch.nn.functional.log_softmax(lowerCamelCase__	,  dim=-1		)
               UpperCAmelCase__								=  self.loss_fn(lowerCamelCase__	,  lowerCamelCase__	,  self.args.label_smoothing	,  ignore_index=self.config.pad_token_id		)
         return loss, logits


   def       lowercase_				(self					:						Optional[int]	,  __UpperCAmelCase					:						Optional[Any]	,  __UpperCAmelCase					:						List[str]		)						->    Dict:
         """simple docstring"""



         UpperCAmelCase__								=  inputs.pop("labels"		)
         UpperCAmelCase__								=  self._compute_loss(lowerCamelCase__	,  lowerCamelCase__	,  lowerCamelCase__		)
         return loss


   def       lowercase_				(self					:						List[Any]	,  __UpperCAmelCase					:						nn.Module	,  __UpperCAmelCase					:						Dict[str, Union[torch.Tensor, Any]]	,  __UpperCAmelCase					:						bool	,  __UpperCAmelCase					:						Optional[List[str]] = None	,  )						->    Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:
         """simple docstring"""



         UpperCAmelCase__								=  self._prepare_inputs(lowerCamelCase__		)

         UpperCAmelCase__								=  {
             '''max_length''': self.data_args.val_max_target_length
             if self.data_args is not None
             else self.config.max_length,
             '''num_beams''': self.data_args.eval_beams if self.data_args is not None else self.config.num_beams,
         }

         if self.args.predict_with_generate and not self.args.prediction_loss_only:
               UpperCAmelCase__								=  self.model.generate(
                   inputs["input_ids"]	,  attention_mask=inputs["attention_mask"]	,  **lowerCamelCase__	,  )
               # in case the batch is shorter than max length, the output should be padded
               if generated_tokens.shape[-1] < gen_kwargs["max_length"]:
                     UpperCAmelCase__								=  self._pad_tensors_to_max_len(lowerCamelCase__	,  gen_kwargs["max_length"]		)

         UpperCAmelCase__								=  inputs.pop("labels"		)
         with torch.no_grad():
               # compute loss on predict data
               UpperCAmelCase__								=  self._compute_loss(lowerCamelCase__	,  lowerCamelCase__	,  lowerCamelCase__		)

         UpperCAmelCase__								=  loss.mean().detach()
         if self.args.prediction_loss_only:
               return (loss, None, None)

         UpperCAmelCase__								=  generated_tokens if self.args.predict_with_generate else logits

         if labels.shape[-1] < gen_kwargs["max_length"]:
               UpperCAmelCase__								=  self._pad_tensors_to_max_len(lowerCamelCase__	,  gen_kwargs["max_length"]		)

         return (loss, logits, labels)





   def       lowercase_				(self					:						int	,  __UpperCAmelCase					:						Tuple	,  __UpperCAmelCase					:						str		)						->    Tuple:
         """simple docstring"""



         UpperCAmelCase__								=  self.config.pad_token_id if self.config.pad_token_id is not None else self.config.eos_token_id

         if pad_token_id is None:
               raise ValueError(
                   "Make sure that either `config.pad_token_id` or `config.eos_token_id` is defined if tensor has to be"
                   f""" padded to `max_length`={max_length}"""		)

         UpperCAmelCase__								=  pad_token_id * torch.ones(
             (tensor.shape[0], max_length)	,  dtype=tensor.dtype	,  device=tensor.device		)
         UpperCAmelCase__								=  tensor
         return padded_tensor




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


UpperCamelCase__    							= 'CompVis/stable-diffusion-v1-1'
UpperCamelCase__    							= 'CompVis/stable-diffusion-v1-2'
UpperCamelCase__    							= 'CompVis/stable-diffusion-v1-3'
UpperCamelCase__    							= 'CompVis/stable-diffusion-v1-4'





class 					A							(    UpperCAmelCase_					):


   def __init__(self					:						Union[str, Any]	,  __UpperCAmelCase					:						AutoencoderKL	,  __UpperCAmelCase					:						CLIPTextModel	,  __UpperCAmelCase					:						CLIPTokenizer	,  __UpperCAmelCase					:						UNetaDConditionModel	,  __UpperCAmelCase					:						Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]	,  __UpperCAmelCase					:						StableDiffusionSafetyChecker	,  __UpperCAmelCase					:						CLIPImageProcessor	,  __UpperCAmelCase					:						bool = True	,  )						->    Tuple:
         """simple docstring"""



         super()._init_()

         UpperCAmelCase__								=  StableDiffusionPipeline.from_pretrained(__UpperCAmelCase		)
         UpperCAmelCase__								=  StableDiffusionPipeline.from_pretrained(__UpperCAmelCase		)
         UpperCAmelCase__								=  StableDiffusionPipeline.from_pretrained(__UpperCAmelCase		)
         UpperCAmelCase__								=  StableDiffusionPipeline(
             vae=__UpperCAmelCase	,  text_encoder=__UpperCAmelCase	,  tokenizer=__UpperCAmelCase	,  unet=__UpperCAmelCase	,  scheduler=__UpperCAmelCase	,  safety_checker=__UpperCAmelCase	,  feature_extractor=__UpperCAmelCase	,  requires_safety_checker=__UpperCAmelCase	,  )

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


   @property
   def       lowercase_				(self					:						int		)						->    Dict[str, Any]:
         """simple docstring"""



         return {k: getattr(self	,  __UpperCAmelCase		) for k in self.config.keys() if not k.startswith("_"		)}


   def       lowercase_				(self					:						Union[str, Any]	,  __UpperCAmelCase					:						Optional[Union[str, int]] = "auto"		)						->    Optional[int]:
         """simple docstring"""



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


   def       lowercase_				(self					:						int		)						->    Optional[int]:
         """simple docstring"""



         self.enable_attention_slicing(__UpperCAmelCase		)


   @torch.no_grad()
   def       lowercase_				(self					:						Optional[int]	,  __UpperCAmelCase					:						Union[str, List[str]]	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_0	,  __UpperCAmelCase					:						float = 7.5	,  __UpperCAmelCase					:						Optional[Union[str, List[str]]] = None	,  __UpperCAmelCase					:						Optional[int] = 1	,  __UpperCAmelCase					:						float = 0.0	,  __UpperCAmelCase					:						Optional[torch.Generator] = None	,  __UpperCAmelCase					:						Optional[torch.FloatTensor] = None	,  __UpperCAmelCase					:						Optional[str] = "pil"	,  __UpperCAmelCase					:						bool = True	,  __UpperCAmelCase					:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,  __UpperCAmelCase					:						int = 1	,  **__UpperCAmelCase					:						Any	,  )						->    Dict:
         """simple docstring"""



         return self.pipea(
             prompt=__UpperCAmelCase	,  height=__UpperCAmelCase	,  width=__UpperCAmelCase	,  num_inference_steps=__UpperCAmelCase	,  guidance_scale=__UpperCAmelCase	,  negative_prompt=__UpperCAmelCase	,  num_images_per_prompt=__UpperCAmelCase	,  eta=__UpperCAmelCase	,  generator=__UpperCAmelCase	,  latents=__UpperCAmelCase	,  output_type=__UpperCAmelCase	,  return_dict=__UpperCAmelCase	,  callback=__UpperCAmelCase	,  callback_steps=__UpperCAmelCase	,  **__UpperCAmelCase	,  )


   @torch.no_grad()
   def       lowercase_				(self					:						List[str]	,  __UpperCAmelCase					:						Union[str, List[str]]	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_0	,  __UpperCAmelCase					:						float = 7.5	,  __UpperCAmelCase					:						Optional[Union[str, List[str]]] = None	,  __UpperCAmelCase					:						Optional[int] = 1	,  __UpperCAmelCase					:						float = 0.0	,  __UpperCAmelCase					:						Optional[torch.Generator] = None	,  __UpperCAmelCase					:						Optional[torch.FloatTensor] = None	,  __UpperCAmelCase					:						Optional[str] = "pil"	,  __UpperCAmelCase					:						bool = True	,  __UpperCAmelCase					:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,  __UpperCAmelCase					:						int = 1	,  **__UpperCAmelCase					:						Optional[Any]	,  )						->    Any:
         """simple docstring"""



         return self.pipea(
             prompt=__UpperCAmelCase	,  height=__UpperCAmelCase	,  width=__UpperCAmelCase	,  num_inference_steps=__UpperCAmelCase	,  guidance_scale=__UpperCAmelCase	,  negative_prompt=__UpperCAmelCase	,  num_images_per_prompt=__UpperCAmelCase	,  eta=__UpperCAmelCase	,  generator=__UpperCAmelCase	,  latents=__UpperCAmelCase	,  output_type=__UpperCAmelCase	,  return_dict=__UpperCAmelCase	,  callback=__UpperCAmelCase	,  callback_steps=__UpperCAmelCase	,  **__UpperCAmelCase	,  )


   @torch.no_grad()
   def       lowercase_				(self					:						List[str]	,  __UpperCAmelCase					:						Union[str, List[str]]	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_0	,  __UpperCAmelCase					:						float = 7.5	,  __UpperCAmelCase					:						Optional[Union[str, List[str]]] = None	,  __UpperCAmelCase					:						Optional[int] = 1	,  __UpperCAmelCase					:						float = 0.0	,  __UpperCAmelCase					:						Optional[torch.Generator] = None	,  __UpperCAmelCase					:						Optional[torch.FloatTensor] = None	,  __UpperCAmelCase					:						Optional[str] = "pil"	,  __UpperCAmelCase					:						bool = True	,  __UpperCAmelCase					:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,  __UpperCAmelCase					:						int = 1	,  **__UpperCAmelCase					:						Any	,  )						->    Dict:
         """simple docstring"""



         return self.pipea(
             prompt=__UpperCAmelCase	,  height=__UpperCAmelCase	,  width=__UpperCAmelCase	,  num_inference_steps=__UpperCAmelCase	,  guidance_scale=__UpperCAmelCase	,  negative_prompt=__UpperCAmelCase	,  num_images_per_prompt=__UpperCAmelCase	,  eta=__UpperCAmelCase	,  generator=__UpperCAmelCase	,  latents=__UpperCAmelCase	,  output_type=__UpperCAmelCase	,  return_dict=__UpperCAmelCase	,  callback=__UpperCAmelCase	,  callback_steps=__UpperCAmelCase	,  **__UpperCAmelCase	,  )


   @torch.no_grad()
   def       lowercase_				(self					:						Union[str, Any]	,  __UpperCAmelCase					:						Union[str, List[str]]	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_0	,  __UpperCAmelCase					:						float = 7.5	,  __UpperCAmelCase					:						Optional[Union[str, List[str]]] = None	,  __UpperCAmelCase					:						Optional[int] = 1	,  __UpperCAmelCase					:						float = 0.0	,  __UpperCAmelCase					:						Optional[torch.Generator] = None	,  __UpperCAmelCase					:						Optional[torch.FloatTensor] = None	,  __UpperCAmelCase					:						Optional[str] = "pil"	,  __UpperCAmelCase					:						bool = True	,  __UpperCAmelCase					:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,  __UpperCAmelCase					:						int = 1	,  **__UpperCAmelCase					:						Union[str, Any]	,  )						->    List[str]:
         """simple docstring"""



         return self.pipea(
             prompt=__UpperCAmelCase	,  height=__UpperCAmelCase	,  width=__UpperCAmelCase	,  num_inference_steps=__UpperCAmelCase	,  guidance_scale=__UpperCAmelCase	,  negative_prompt=__UpperCAmelCase	,  num_images_per_prompt=__UpperCAmelCase	,  eta=__UpperCAmelCase	,  generator=__UpperCAmelCase	,  latents=__UpperCAmelCase	,  output_type=__UpperCAmelCase	,  return_dict=__UpperCAmelCase	,  callback=__UpperCAmelCase	,  callback_steps=__UpperCAmelCase	,  **__UpperCAmelCase	,  )





   @torch.no_grad()
   def       lowercase_				(self					:						int	,  __UpperCAmelCase					:						Union[str, List[str]]	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_1_2	,  __UpperCAmelCase					:						int = 5_0	,  __UpperCAmelCase					:						float = 7.5	,  __UpperCAmelCase					:						Optional[Union[str, List[str]]] = None	,  __UpperCAmelCase					:						Optional[int] = 1	,  __UpperCAmelCase					:						float = 0.0	,  __UpperCAmelCase					:						Optional[torch.Generator] = None	,  __UpperCAmelCase					:						Optional[torch.FloatTensor] = None	,  __UpperCAmelCase					:						Optional[str] = "pil"	,  __UpperCAmelCase					:						bool = True	,  __UpperCAmelCase					:						Optional[Callable[[int, int, torch.FloatTensor], None]] = None	,  __UpperCAmelCase					:						int = 1	,  **__UpperCAmelCase					:						Any	,  )						->    Union[str, Any]:
         """simple docstring"""



         UpperCAmelCase__								=  "cuda" if torch.cuda.is_available() else "cpu"
         self.to(__UpperCAmelCase		)

         # 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
         UpperCAmelCase__								=  self.textaimg_sda_a(
             prompt=__UpperCAmelCase	,  height=__UpperCAmelCase	,  width=__UpperCAmelCase	,  num_inference_steps=__UpperCAmelCase	,  guidance_scale=__UpperCAmelCase	,  negative_prompt=__UpperCAmelCase	,  num_images_per_prompt=__UpperCAmelCase	,  eta=__UpperCAmelCase	,  generator=__UpperCAmelCase	,  latents=__UpperCAmelCase	,  output_type=__UpperCAmelCase	,  return_dict=__UpperCAmelCase	,  callback=__UpperCAmelCase	,  callback_steps=__UpperCAmelCase	,  **__UpperCAmelCase	,  )

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

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

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

         # 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]]		)



