





"""simple docstring"""




import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
      from transformers import SpeechaTextFeatureExtractor

__UpperCAmelCase	:       Optional[Any]    	=							random.Random()







def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=1.0 , SCREAMING_SNAKE_CASE__=None , SCREAMING_SNAKE_CASE__=None)       ->   Any:
  if rng is None:
    __snake_case:						str			  =						global_rng

  __snake_case:						Dict			  =						[]
  for batch_idx in range(shape[0]):
    values.append([])
    for _ in range(shape[1]):
      values[-1].append(rng.random() * scale)

  return values







@require_torch
@require_torchaudio
class    __snake_case	(							unittest.TestCase      ):





       '''simple docstring'''







       def __init__(  self			:   Optional[int]							,    A			:   Any							,    A			:   Dict=7							,    A			:   Optional[Any]=400							,    A			:   Optional[Any]=2_000							,    A			:   Dict=24							,    A			:   Dict=24							,    A			:   int=0.0							,    A			:   List[str]=16_000							,    A			:   Optional[Any]=True							,    A			:   Union[str, Any]=True							,    ):
         __snake_case:						List[Any]			  =						parent
         __snake_case:						int			  =						batch_size
         __snake_case:						Dict			  =						min_seq_length
         __snake_case:						int			  =						max_seq_length
         __snake_case:						int			  =						(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
         __snake_case:						Optional[int]			  =						feature_size
         __snake_case:						Optional[Any]			  =						num_mel_bins
         __snake_case:						Dict			  =						padding_value
         __snake_case:						Union[str, Any]			  =						sampling_rate
         __snake_case:						List[str]			  =						return_attention_mask
         __snake_case:						List[str]			  =						do_normalize




       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         return {
             "feature_size": self.feature_size,
             "num_mel_bins": self.num_mel_bins,
             "padding_value": self.padding_value,
             "sampling_rate": self.sampling_rate,
             "return_attention_mask": self.return_attention_mask,
             "do_normalize": self.do_normalize,
         }






       def 							UpperCAmelCase__			(  self			:   Optional[int]							,    A			:   Union[str, Any]=False							,    A			:   List[Any]=False		):



         def _flatten(A			:   int		):
           return list(itertools.chain(*_A		)		)

         if equal_length:
           __snake_case:						Any			  =						[floats_list((self.max_seq_length, self.feature_size)		) for _ in range(self.batch_size		)]
         else:
           # make sure that inputs increase in size
           __snake_case:						Tuple			  =						[
               floats_list((x, self.feature_size)		)
               for x in range(self.min_seq_length							,    self.max_seq_length							,    self.seq_length_diff		)
           ]
         if numpify:
           __snake_case:						Union[str, Any]			  =						[np.asarray(_A		) for x in speech_inputs]
         return speech_inputs







@require_torch
@require_torchaudio
class    __snake_case	(							snake_case__       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					SpeechaTextFeatureExtractor if is_speech_available() else None




       def 							UpperCAmelCase__			(  self			:   Tuple		):
         __snake_case:						Optional[Any]			  =						SpeechaTextFeatureExtractionTester(self		)




       def 							UpperCAmelCase__			(  self			:   Dict							,    A			:   Union[str, Any]		):
         self.assertTrue(np.all(np.mean(_A							,    axis=0		) < 1E-3		)		)
         self.assertTrue(np.all(np.abs(np.var(_A							,    axis=0		) - 1		) < 1E-3		)		)




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						Tuple			  =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
         # create three inputs of length 800, 1000, and 1200
         __snake_case:						Any			  =						[floats_list((1, x)		)[0] for x in range(800							,    1_400							,    200		)]
         __snake_case:						Union[str, Any]			  =						[np.asarray(_A		) for speech_input in speech_inputs]

         # Test feature size
         __snake_case:						List[str]			  =						feature_extractor(_A							,    padding=_A							,    return_tensors="""np"""		).input_features
         self.assertTrue(input_features.ndim == 3		)
         self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size		)

         # Test not batched input
         __snake_case:						Optional[Any]			  =						feature_extractor(speech_inputs[0]							,    return_tensors="""np"""		).input_features
         __snake_case:						Any			  =						feature_extractor(np_speech_inputs[0]							,    return_tensors="""np"""		).input_features
         self.assertTrue(np.allclose(_A							,    _A							,    atol=1E-3		)		)

         # Test batched
         __snake_case:						List[Any]			  =						feature_extractor(_A							,    return_tensors="""np"""		).input_features
         __snake_case:						int			  =						feature_extractor(_A							,    return_tensors="""np"""		).input_features
         for enc_seq_a, enc_seq_a in zip(_A							,    _A		):
           self.assertTrue(np.allclose(_A							,    _A							,    atol=1E-3		)		)

         # Test 2-D numpy arrays are batched.
         __snake_case:						List[Any]			  =						[floats_list((1, x)		)[0] for x in (800, 800, 800)]
         __snake_case:						List[str]			  =						np.asarray(_A		)
         __snake_case:						List[Any]			  =						feature_extractor(_A							,    return_tensors="""np"""		).input_features
         __snake_case:						Union[str, Any]			  =						feature_extractor(_A							,    return_tensors="""np"""		).input_features
         for enc_seq_a, enc_seq_a in zip(_A							,    _A		):
           self.assertTrue(np.allclose(_A							,    _A							,    atol=1E-3		)		)




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						int			  =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
         __snake_case:						Optional[int]			  =						[floats_list((1, x)		)[0] for x in range(800							,    1_400							,    200		)]

         __snake_case:						List[Any]			  =						["""longest""", """max_length""", """do_not_pad"""]
         __snake_case:						str			  =						[None, 16, None]
         for max_length, padding in zip(_A							,    _A		):
           __snake_case:						Optional[Any]			  =						feature_extractor(
               _A							,    padding=_A							,    max_length=_A							,    return_attention_mask=_A		)
           __snake_case:						Dict			  =						inputs.input_features
           __snake_case:						Tuple			  =						inputs.attention_mask
           __snake_case:						List[str]			  =						[np.sum(_A		) for x in attention_mask]

           self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]		)
           self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]		)
           self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]		)




       def 							UpperCAmelCase__			(  self			:   Optional[Any]		):
         __snake_case:						int			  =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
         __snake_case:						int			  =						[floats_list((1, x)		)[0] for x in range(800							,    1_400							,    200		)]

         __snake_case:						int			  =						["""longest""", """max_length""", """do_not_pad"""]
         __snake_case:						Optional[Any]			  =						[None, 16, None]
         for max_length, padding in zip(_A							,    _A		):
           __snake_case:						str			  =						feature_extractor(
               _A							,    max_length=_A							,    padding=_A							,    return_tensors="""np"""							,    return_attention_mask=_A		)
           __snake_case:						Optional[Any]			  =						inputs.input_features
           __snake_case:						Optional[Any]			  =						inputs.attention_mask
           __snake_case:						Union[str, Any]			  =						[np.sum(_A		) for x in attention_mask]

           self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]		)
           self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6		)
           self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]		)
           self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6		)
           self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]		)




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						Any			  =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
         __snake_case:						Tuple			  =						[floats_list((1, x)		)[0] for x in range(800							,    1_400							,    200		)]
         __snake_case:						int			  =						feature_extractor(
             _A							,    padding="""max_length"""							,    max_length=4							,    truncation=_A							,    return_tensors="""np"""							,    return_attention_mask=_A							,    )
         __snake_case:						Dict			  =						inputs.input_features
         __snake_case:						List[Any]			  =						inputs.attention_mask
         __snake_case:						Union[str, Any]			  =						np.sum(attention_mask == 1							,    axis=1		)

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]		)
         self._check_zero_mean_unit_variance(input_features[1]		)
         self._check_zero_mean_unit_variance(input_features[2]		)




       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						Any			  =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
         __snake_case:						List[str]			  =						[floats_list((1, x)		)[0] for x in range(800							,    1_400							,    200		)]
         __snake_case:						Dict			  =						feature_extractor(
             _A							,    padding="""longest"""							,    max_length=4							,    truncation=_A							,    return_tensors="""np"""							,    return_attention_mask=_A							,    )
         __snake_case:						Optional[int]			  =						inputs.input_features
         __snake_case:						int			  =						inputs.attention_mask
         __snake_case:						str			  =						np.sum(attention_mask == 1							,    axis=1		)

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]		)
         self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]		)
         self._check_zero_mean_unit_variance(input_features[2]		)

         # make sure that if max_length < longest -> then pad to max_length
         self.assertEqual(input_features.shape							,    (3, 4, 24)		)

         __snake_case:						Optional[Any]			  =						[floats_list((1, x)		)[0] for x in range(800							,    1_400							,    200		)]
         __snake_case:						List[Any]			  =						feature_extractor(
             _A							,    padding="""longest"""							,    max_length=16							,    truncation=_A							,    return_tensors="""np"""							,    return_attention_mask=_A							,    )
         __snake_case:						Any			  =						inputs.input_features
         __snake_case:						List[Any]			  =						inputs.attention_mask
         __snake_case:						Any			  =						np.sum(attention_mask == 1							,    axis=1		)

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]		)
         self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]		)
         self._check_zero_mean_unit_variance(input_features[2]		)

         # make sure that if max_length < longest -> then pad to max_length
         self.assertEqual(input_features.shape							,    (3, 6, 24)		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         import torch

         __snake_case:						Optional[Any]			  =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
         __snake_case:						Optional[int]			  =						np.random.rand(100							,    32		).astype(np.floataa		)
         __snake_case:						str			  =						np_speech_inputs.tolist()

         for inputs in [py_speech_inputs, np_speech_inputs]:
           __snake_case:						str			  =						feature_extractor.pad([{"""input_features""": inputs}]							,    return_tensors="""np"""		)
           self.assertTrue(np_processed.input_features.dtype == np.floataa		)
           __snake_case:						Any			  =						feature_extractor.pad([{"""input_features""": inputs}]							,    return_tensors="""pt"""		)
           self.assertTrue(pt_processed.input_features.dtype == torch.floataa		)




       def 							UpperCAmelCase__			(  self			:   Tuple							,    A			:   Tuple		):
         from datasets import load_dataset

         __snake_case:						List[Any]			  =						load_dataset("""hf-internal-testing/librispeech_asr_dummy"""							,    """clean"""							,    split="""validation"""		)
         # automatic decoding with librispeech
         __snake_case:						List[str]			  =						ds.sort("""id"""		).select(range(_A		)		)[:num_samples]["""audio"""]

         return [x["array"] for x in speech_samples]






       def 							UpperCAmelCase__			(  self			:   List[str]		):
         __snake_case:						str			  =						np.array([
             -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
             -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
             -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
         ]		)
         # fmt: on

         __snake_case:						Dict			  =						self._load_datasamples(1		)
         __snake_case:						Union[str, Any]			  =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
         __snake_case:						List[Any]			  =						feature_extractor(_A							,    return_tensors="""pt"""		).input_features
         self.assertEquals(input_features.shape							,    (1, 584, 24)		)
         self.assertTrue(np.allclose(input_features[0, 0, :30]							,    _A							,    atol=1E-4		)		)













import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


__UpperCAmelCase	:       Dict    	=							logging.get_logger(__name__)  # pylint: disable=invalid-name







class    __snake_case	(							__lowerCamelCase      ):





       '''simple docstring'''







       def __init__(  self			:   List[Any]							,    A			:   AutoencoderKL							,    A			:   CLIPTextModel							,    A			:   CLIPTokenizer							,    A			:   UNetaDConditionModel							,    A			:   Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]							,    A			:   StableDiffusionSafetyChecker							,    A			:   CLIPImageProcessor							,    ):
         super().__init__()
         self.register_modules(
             vae=A							,    text_encoder=A							,    tokenizer=A							,    unet=A							,    scheduler=A							,    safety_checker=A							,    feature_extractor=A							,    )




       def 							UpperCAmelCase__			(  self			:   Optional[Any]							,    A			:   Optional[Union[str, int]] = "auto"		):
         if slice_size == "auto":
           # half the attention head size is usually a good trade-off between
           # speed and memory
           __snake_case:						Tuple			  =						self.unet.config.attention_head_dim // 2
         self.unet.set_attention_slice(A		)




       def 							UpperCAmelCase__			(  self			:   str		):
         self.enable_attention_slicing(A		)






       @torch.no_grad()
       def __call__(  self			:   List[str]							,    A			:   Union[str, List[str]]							,    A			:   int = 512							,    A			:   int = 512							,    A			:   int = 50							,    A			:   float = 7.5							,    A			:   Optional[Union[str, List[str]]] = None							,    A			:   Optional[int] = 1							,    A			:   float = 0.0							,    A			:   Optional[torch.Generator] = None							,    A			:   Optional[torch.FloatTensor] = None							,    A			:   Optional[str] = "pil"							,    A			:   bool = True							,    A			:   Optional[Callable[[int, int, torch.FloatTensor], None]] = None							,    A			:   int = 1							,    A			:   Optional[torch.FloatTensor] = None							,    **A			:   Optional[Any]							,    ):

         if isinstance(A							,    A		):
           __snake_case:						int			  =						1
         elif isinstance(A							,    A		):
           __snake_case:						Optional[Any]			  =						len(A		)
         else:
           raise ValueError(f'''`prompt` has to be of type `str` or `list` but is {type(A		)}'''		)

         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 (callback_steps is None) or (
             callback_steps is not None and (not isinstance(A							,    A		) or callback_steps <= 0)
         ):
           raise ValueError(
               f'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
               f''' {type(A		)}.'''		)

         # get prompt text embeddings
         __snake_case:						Tuple			  =						self.tokenizer(
             A							,    padding="""max_length"""							,    max_length=self.tokenizer.model_max_length							,    return_tensors="""pt"""							,    )
         __snake_case:						Any			  =						text_inputs.input_ids

         if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
           __snake_case:						List[str]			  =						self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]		)
           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}'''		)
           __snake_case:						Dict			  =						text_input_ids[:, : self.tokenizer.model_max_length]

         if text_embeddings is None:
           __snake_case:						Union[str, Any]			  =						self.text_encoder(text_input_ids.to(self.device		)		)[0]

         # duplicate text embeddings for each generation per prompt, using mps friendly method
         __snake_case  ,       __snake_case  ,       __snake_case:						List[Any]			  =						text_embeddings.shape
         __snake_case:						Tuple			  =						text_embeddings.repeat(1							,    A							,    1		)
         __snake_case:						Dict			  =						text_embeddings.view(bs_embed * num_images_per_prompt							,    A							,    -1		)

         # 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:						List[str]			  =						guidance_scale > 1.0
         # get unconditional embeddings for classifier free guidance
         if do_classifier_free_guidance:
           __snake_case:						List[str]
           if negative_prompt is None:
             __snake_case:						Any			  =						[""""""]
           elif type(A		) is not type(A		):
             raise TypeError(
                 f'''`negative_prompt` should be the same type to `prompt`, but got {type(A		)} !='''
                 f''' {type(A		)}.'''		)
           elif isinstance(A							,    A		):
             __snake_case:						List[str]			  =						[negative_prompt]
           elif batch_size != len(A		):
             raise ValueError(
                 f'''`negative_prompt`: {negative_prompt} has batch size {len(A		)}, but `prompt`:'''
                 f''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'''
                 """ the batch size of `prompt`."""		)
           else:
             __snake_case:						str			  =						negative_prompt

           __snake_case:						Any			  =						text_input_ids.shape[-1]
           __snake_case:						Dict			  =						self.tokenizer(
               A							,    padding="""max_length"""							,    max_length=A							,    truncation=A							,    return_tensors="""pt"""							,    )
           __snake_case:						Tuple			  =						self.text_encoder(uncond_input.input_ids.to(self.device		)		)[0]

           # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
           __snake_case:						Optional[Any]			  =						uncond_embeddings.shape[1]
           __snake_case:						str			  =						uncond_embeddings.repeat(A							,    A							,    1		)
           __snake_case:						List[Any]			  =						uncond_embeddings.view(batch_size * num_images_per_prompt							,    A							,    -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
           __snake_case:						Any			  =						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:						Tuple			  =						(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
         __snake_case:						List[Any]			  =						(batch_size * num_images_per_prompt, self.unet.config.in_channels, 64, 64)
         __snake_case:						Optional[Any]			  =						text_embeddings.dtype
         if latents is None:
           if self.device.type == "mps":
             # randn does not exist on mps
             __snake_case:						Any			  =						torch.randn(
                 A							,    generator=A							,    device="""cpu"""							,    dtype=A		).to(self.device		)
             __snake_case:						Tuple			  =						torch.randn(A							,    generator=A							,    device="""cpu"""							,    dtype=A		).to(
                 self.device		)
           else:
             __snake_case:						Dict			  =						torch.randn(
                 A							,    generator=A							,    device=self.device							,    dtype=A		)
             __snake_case:						Optional[int]			  =						torch.randn(A							,    generator=A							,    device=self.device							,    dtype=A		)
         else:
           if latents_reference.shape != latents_shape:
             raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''		)
           __snake_case:						Optional[int]			  =						latents_reference.to(self.device		)
           __snake_case:						List[str]			  =						latents.to(self.device		)

         # This is the key part of the pipeline where we
         # try to ensure that the generated images w/ the same seed
         # but different sizes actually result in similar images
         __snake_case:						int			  =						(latents_shape[3] - latents_shape_reference[3]) // 2
         __snake_case:						Optional[int]			  =						(latents_shape[2] - latents_shape_reference[2]) // 2
         __snake_case:						int			  =						latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
         __snake_case:						Dict			  =						latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
         __snake_case:						List[Any]			  =						0 if dx < 0 else dx
         __snake_case:						Dict			  =						0 if dy < 0 else dy
         __snake_case:						List[str]			  =						max(-dx							,    0		)
         __snake_case:						int			  =						max(-dy							,    0		)
         # import pdb
         # pdb.set_trace()
         __snake_case:						List[Any]			  =						latents_reference[:, :, dy : dy + h, dx : dx + w]

         # set timesteps
         self.scheduler.set_timesteps(A		)

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

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

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

           # predict the noise residual
           __snake_case:						List[Any]			  =						self.unet(A							,    A							,    encoder_hidden_states=A		).sample

           # perform guidance
           if do_classifier_free_guidance:
             __snake_case  ,       __snake_case:						Any			  =						noise_pred.chunk(2		)
             __snake_case:						Optional[int]			  =						noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

           # compute the previous noisy sample x_t -> x_t-1
           __snake_case:						str			  =						self.scheduler.step(A							,    A							,    A							,    **A		).prev_sample

           # call the callback, if provided
           if callback is not None and i % callback_steps == 0:
             callback(A							,    A							,    A		)

         __snake_case:						Optional[int]			  =						1 / 0.1_8215 * latents
         __snake_case:						List[Any]			  =						self.vae.decode(A		).sample

         __snake_case:						str			  =						(image / 2 + 0.5).clamp(0							,    1		)

         # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
         __snake_case:						Any			  =						image.cpu().permute(0							,    2							,    3							,    1		).float().numpy()

         if self.safety_checker is not None:
           __snake_case:						List[Any]			  =						self.feature_extractor(self.numpy_to_pil(A		)							,    return_tensors="""pt"""		).to(
               self.device		)
           __snake_case  ,       __snake_case:						List[str]			  =						self.safety_checker(
               images=A							,    clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype		)		)
         else:
           __snake_case:						Optional[int]			  =						None

         if output_type == "pil":
           __snake_case:						Tuple			  =						self.numpy_to_pil(A		)

         if not return_dict:
           return (image, has_nsfw_concept)

         return StableDiffusionPipelineOutput(images=A							,    nsfw_content_detected=A		)






