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

SCREAMING_SNAKE_CASE_            = random.Random()

def 							__SCREAMING_SNAKE_CASE							(			lowerCAmelCase:					Optional[Any]					, lowerCAmelCase:					str=1.0					, lowerCAmelCase:					Optional[Any]=None					, lowerCAmelCase:					Tuple=None	)				->    Dict:





				if rng is None:
								_UpperCAmelCase    :						Dict							=      global_rng

				_UpperCAmelCase    :						Union[str, Any]							=      []
				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 			a					(		unittest.TestCase			):


						def __init__(    self  ,   A_  ,   A_=7  ,   A_=400  ,   A_=2000  ,   A_=24  ,   A_=24  ,   A_=0.0  ,   A_=16000  ,   A_=True  ,   A_=True  ,   ):







										'''simple docstring'''


										_UpperCAmelCase    :						List[Any]							=      parent
										_UpperCAmelCase    :						int							=      batch_size
										_UpperCAmelCase    :						Optional[Any]							=      min_seq_length
										_UpperCAmelCase    :						Tuple							=      max_seq_length
										_UpperCAmelCase    :						Dict							=      (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
										_UpperCAmelCase    :						Dict							=      feature_size
										_UpperCAmelCase    :						str							=      num_mel_bins
										_UpperCAmelCase    :						Union[str, Any]							=      padding_value
										_UpperCAmelCase    :						Optional[int]							=      sampling_rate
										_UpperCAmelCase    :						Optional[Any]							=      return_attention_mask
										_UpperCAmelCase    :						List[str]							=      do_normalize


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										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  ,   A_=False  ,   A_=False		):







										'''simple docstring'''


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

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







@require_torch
@require_torchaudio
class 			a					(		UpperCAmelCase							,	unittest.TestCase			):
						_lowercase        =     SpeechaTextFeatureExtractor if is_speech_available() else None


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										_UpperCAmelCase    :						Dict							=      SpeechaTextFeatureExtractionTester(self		)


						def     _UpperCAmelCase			(    self  ,   A_		):







										'''simple docstring'''


										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		):







										'''simple docstring'''


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

										# Test feature size
										_UpperCAmelCase    :						Optional[int]							=      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
										_UpperCAmelCase    :						int							=      feature_extractor(speech_inputs[0]  ,   return_tensors="np"		).input_features
										_UpperCAmelCase    :						Any							=      feature_extractor(np_speech_inputs[0]  ,   return_tensors="np"		).input_features
										self.assertTrue(np.allclose(_A  ,   _A  ,   atol=1e-3		)		)

										# Test batched
										_UpperCAmelCase    :						Optional[int]							=      feature_extractor(_A  ,   return_tensors="np"		).input_features
										_UpperCAmelCase    :						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.
										_UpperCAmelCase    :						Dict							=      [floats_list((1, x)		)[0] for x in (800, 800, 800)]
										_UpperCAmelCase    :						Union[str, Any]							=      np.asarray(_A		)
										_UpperCAmelCase    :						Optional[Any]							=      feature_extractor(_A  ,   return_tensors="np"		).input_features
										_UpperCAmelCase    :						Tuple							=      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		):







										'''simple docstring'''


										_UpperCAmelCase    :						Optional[Any]							=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
										_UpperCAmelCase    :						List[Any]							=      [floats_list((1, x)		)[0] for x in range(800  ,   1400  ,   200		)]

										_UpperCAmelCase    :						Union[str, Any]							=      ['longest', 'max_length', 'do_not_pad']
										_UpperCAmelCase    :						Union[str, Any]							=      [None, 16, None]
										for max_length, padding in zip(_A  ,   _A		):
														_UpperCAmelCase    :						str							=      feature_extractor(
														    _A  ,   padding=_A  ,   max_length=_A  ,   return_attention_mask=_A		)
														_UpperCAmelCase    :						Dict							=      inputs.input_features
														_UpperCAmelCase    :						Dict							=      inputs.attention_mask
														_UpperCAmelCase    :						List[Any]							=      [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		):







										'''simple docstring'''


										_UpperCAmelCase    :						Union[str, Any]							=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
										_UpperCAmelCase    :						Optional[Any]							=      [floats_list((1, x)		)[0] for x in range(800  ,   1400  ,   200		)]

										_UpperCAmelCase    :						List[Any]							=      ['longest', 'max_length', 'do_not_pad']
										_UpperCAmelCase    :						List[str]							=      [None, 16, None]
										for max_length, padding in zip(_A  ,   _A		):
														_UpperCAmelCase    :						Dict							=      feature_extractor(
														    _A  ,   max_length=_A  ,   padding=_A  ,   return_tensors="np"  ,   return_attention_mask=_A		)
														_UpperCAmelCase    :						Dict							=      inputs.input_features
														_UpperCAmelCase    :						Optional[Any]							=      inputs.attention_mask
														_UpperCAmelCase    :						List[str]							=      [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		):







										'''simple docstring'''


										_UpperCAmelCase    :						Tuple							=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
										_UpperCAmelCase    :						Any							=      [floats_list((1, x)		)[0] for x in range(800  ,   1400  ,   200		)]
										_UpperCAmelCase    :						str							=      feature_extractor(
										    _A  ,   padding="max_length"  ,   max_length=4  ,   truncation=_A  ,   return_tensors="np"  ,   return_attention_mask=_A  ,   )
										_UpperCAmelCase    :						Union[str, Any]							=      inputs.input_features
										_UpperCAmelCase    :						str							=      inputs.attention_mask
										_UpperCAmelCase    :						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]		)
										self._check_zero_mean_unit_variance(input_features[2]		)


						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										_UpperCAmelCase    :						Union[str, Any]							=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
										_UpperCAmelCase    :						List[Any]							=      [floats_list((1, x)		)[0] for x in range(800  ,   1400  ,   200		)]
										_UpperCAmelCase    :						Optional[Any]							=      feature_extractor(
										    _A  ,   padding="longest"  ,   max_length=4  ,   truncation=_A  ,   return_tensors="np"  ,   return_attention_mask=_A  ,   )
										_UpperCAmelCase    :						Union[str, Any]							=      inputs.input_features
										_UpperCAmelCase    :						Optional[Any]							=      inputs.attention_mask
										_UpperCAmelCase    :						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, : 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)		)

										_UpperCAmelCase    :						Optional[Any]							=      [floats_list((1, x)		)[0] for x in range(800  ,   1400  ,   200		)]
										_UpperCAmelCase    :						Tuple							=      feature_extractor(
										    _A  ,   padding="longest"  ,   max_length=16  ,   truncation=_A  ,   return_tensors="np"  ,   return_attention_mask=_A  ,   )
										_UpperCAmelCase    :						Tuple							=      inputs.input_features
										_UpperCAmelCase    :						Union[str, Any]							=      inputs.attention_mask
										_UpperCAmelCase    :						int							=      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		):







										'''simple docstring'''


										import torch

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

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


						def     _UpperCAmelCase			(    self  ,   A_		):







										'''simple docstring'''


										from datasets import load_dataset

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

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





						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										_UpperCAmelCase    :						Any							=      np.array([
										    -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
										    -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
										    -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
										]		)
										# fmt: on

										_UpperCAmelCase    :						Optional[int]							=      self._load_datasamples(1		)
										_UpperCAmelCase    :						List[str]							=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
										_UpperCAmelCase    :						str							=      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		)		)





from typing import List, Optional, Union

import torch

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


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

SCREAMING_SNAKE_CASE_            = '\n    Examples:\n        ```py\n        >>> import torch\n        >>> import numpy as np\n\n        >>> from diffusers import KandinskyV22PriorPipeline, KandinskyV22ControlnetPipeline\n        >>> from transformers import pipeline\n        >>> from diffusers.utils import load_image\n\n\n        >>> def make_hint(image, depth_estimator):\n        ...     image = depth_estimator(image)["depth"]\n        ...     image = np.array(image)\n        ...     image = image[:, :, None]\n        ...     image = np.concatenate([image, image, image], axis=2)\n        ...     detected_map = torch.from_numpy(image).float() / 255.0\n        ...     hint = detected_map.permute(2, 0, 1)\n        ...     return hint\n\n\n        >>> depth_estimator = pipeline("depth-estimation")\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n        ...     "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16\n        ... )\n        >>> pipe_prior = pipe_prior.to("cuda")\n\n        >>> pipe = KandinskyV22ControlnetPipeline.from_pretrained(\n        ...     "kandinsky-community/kandinsky-2-2-controlnet-depth", torch_dtype=torch.float16\n        ... )\n        >>> pipe = pipe.to("cuda")\n\n\n        >>> img = load_image(\n        ...     "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"\n        ...     "/kandinsky/cat.png"\n        ... ).resize((768, 768))\n\n        >>> hint = make_hint(img, depth_estimator).unsqueeze(0).half().to("cuda")\n\n        >>> prompt = "A robot, 4k photo"\n        >>> negative_prior_prompt = "lowres, text, error, cropped, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, out of frame, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck, username, watermark, signature"\n\n        >>> generator = torch.Generator(device="cuda").manual_seed(43)\n\n        >>> image_emb, zero_image_emb = pipe_prior(\n        ...     prompt=prompt, negative_prompt=negative_prior_prompt, generator=generator\n        ... ).to_tuple()\n\n        >>> images = pipe(\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     hint=hint,\n        ...     num_inference_steps=50,\n        ...     generator=generator,\n        ...     height=768,\n        ...     width=768,\n        ... ).images\n\n        >>> images[0].save("robot_cat.png")\n        ```\n'

def 							__SCREAMING_SNAKE_CASE							(			lowerCAmelCase:					Any					, lowerCAmelCase:					List[str]					, lowerCAmelCase:					int=8	)				->    int:
				_UpperCAmelCase    :						int							=      height // scale_factor**2
				if height % scale_factor**2 != 0:
								new_height += 1
				_UpperCAmelCase    :						List[str]							=      width // scale_factor**2
				if width % scale_factor**2 != 0:
								new_width += 1
				return new_height * scale_factor, new_width * scale_factor





class 			a					(		UpperCAmelCase			):


						def __init__(    self  ,   A_  ,   A_  ,   A_  ,   ):







										'''simple docstring'''


										super().__init__()

										self.register_modules(
										    unet=A_  ,   scheduler=A_  ,   movq=A_  ,   )
										_UpperCAmelCase    :						Optional[int]							=      2 ** (len(self.movq.config.block_out_channels		) - 1)


						def     _UpperCAmelCase			(    self  ,   A_  ,   A_  ,   A_  ,   A_  ,   A_  ,   A_		):







										'''simple docstring'''


										if latents is None:
														_UpperCAmelCase    :						Any							=      randn_tensor(A_  ,   generator=A_  ,   device=A_  ,   dtype=A_		)
										else:
														if latents.shape != shape:
																		raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {shape}'		)
														_UpperCAmelCase    :						Optional[int]							=      latents.to(A_		)

										_UpperCAmelCase    :						Tuple							=      latents * scheduler.init_noise_sigma
										return latents


						def     _UpperCAmelCase			(    self  ,   A_=0		):







										'''simple docstring'''


										if is_accelerate_available():
														from accelerate import cpu_offload
										else:
														raise ImportError("Please install accelerate via `pip install accelerate`"		)

										_UpperCAmelCase    :						Union[str, Any]							=      torch.device(f'cuda:{gpu_id}'		)

										_UpperCAmelCase    :						Any							=      [
										    self.unet,
										    self.movq,
										]
										for cpu_offloaded_model in models:
														if cpu_offloaded_model is not None:
																		cpu_offload(A_  ,   A_		)


						def     _UpperCAmelCase			(    self  ,   A_=0		):







										'''simple docstring'''


										if is_accelerate_available() and is_accelerate_version(">="  ,   "0.17.0.dev0"		):
														from accelerate import cpu_offload_with_hook
										else:
														raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher."		)

										_UpperCAmelCase    :						str							=      torch.device(f'cuda:{gpu_id}'		)

										if self.device.type != "cpu":
														self.to("cpu"  ,   silence_dtype_warnings=A_		)
														torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

										_UpperCAmelCase    :						Optional[int]							=      None
										for cpu_offloaded_model in [self.unet, self.movq]:
														_UpperCAmelCase						,							_UpperCAmelCase    :						Dict							=      cpu_offload_with_hook(A_  ,   A_  ,   prev_module_hook=A_		)

										# We'll offload the last model manually.
										_UpperCAmelCase    :						Optional[Any]							=      hook


						@property
						# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
						def     _UpperCAmelCase			(    self		):







										'''simple docstring'''


										if not hasattr(self.unet  ,   "_hf_hook"		):
														return self.device
										for module in self.unet.modules():
														if (
														    hasattr(A_  ,   "_hf_hook"		)
														    and hasattr(module._hf_hook  ,   "execution_device"		)
														    and module._hf_hook.execution_device is not None
														):
																		return torch.device(module._hf_hook.execution_device		)
										return self.device





						@torch.no_grad()
						@replace_example_docstring(A_		)
						def __call__(    self  ,   A_  ,   A_  ,   A_  ,   A_ = 512  ,   A_ = 512  ,   A_ = 100  ,   A_ = 4.0  ,   A_ = 1  ,   A_ = None  ,   A_ = None  ,   A_ = "pil"  ,   A_ = True  ,   ):







										'''simple docstring'''


										_UpperCAmelCase    :						str							=      self._execution_device

										_UpperCAmelCase    :						Tuple							=      guidance_scale > 1.0

										if isinstance(A_  ,   A_		):
														_UpperCAmelCase    :						Union[str, Any]							=      torch.cat(A_  ,   dim=0		)
										if isinstance(A_  ,   A_		):
														_UpperCAmelCase    :						Dict							=      torch.cat(A_  ,   dim=0		)
										if isinstance(A_  ,   A_		):
														_UpperCAmelCase    :						Any							=      torch.cat(A_  ,   dim=0		)

										_UpperCAmelCase    :						Optional[Any]							=      image_embeds.shape[0] * num_images_per_prompt

										if do_classifier_free_guidance:
														_UpperCAmelCase    :						Optional[int]							=      image_embeds.repeat_interleave(A_  ,   dim=0		)
														_UpperCAmelCase    :						Union[str, Any]							=      negative_image_embeds.repeat_interleave(A_  ,   dim=0		)
														_UpperCAmelCase    :						Tuple							=      hint.repeat_interleave(A_  ,   dim=0		)

										_UpperCAmelCase    :						List[Any]							=      torch.cat([negative_image_embeds, image_embeds]  ,   dim=0		).to(dtype=self.unet.dtype  ,   device=A_		)
										_UpperCAmelCase    :						List[Any]							=      torch.cat([hint, hint]  ,   dim=0		).to(dtype=self.unet.dtype  ,   device=A_		)
										self.scheduler.set_timesteps(A_  ,   device=A_		)
										_UpperCAmelCase    :						Dict							=      self.scheduler.timesteps

										_UpperCAmelCase    :						Union[str, Any]							=      self.movq.config.latent_channels

										_UpperCAmelCase						,							_UpperCAmelCase    :						Optional[int]							=      downscale_height_and_width(A_  ,   A_  ,   self.movq_scale_factor		)

										# create initial latent
										_UpperCAmelCase    :						Tuple							=      self.prepare_latents(
										    (batch_size, num_channels_latents, height, width)  ,   image_embeds.dtype  ,   A_  ,   A_  ,   A_  ,   self.scheduler  ,   )

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

														_UpperCAmelCase    :						Optional[Any]							=      {"image_embeds": image_embeds, "hint": hint}
														_UpperCAmelCase    :						Optional[int]							=      self.unet(
														    sample=A_  ,   timestep=A_  ,   encoder_hidden_states=A_  ,   added_cond_kwargs=A_  ,   return_dict=A_  ,   )[0]

														if do_classifier_free_guidance:
																		_UpperCAmelCase						,							_UpperCAmelCase    :						Any							=      noise_pred.split(latents.shape[1]  ,   dim=1		)
																		_UpperCAmelCase						,							_UpperCAmelCase    :						Tuple							=      noise_pred.chunk(2		)
																		_UpperCAmelCase						,							_UpperCAmelCase    :						List[Any]							=      variance_pred.chunk(2		)
																		_UpperCAmelCase    :						Optional[Any]							=      noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																		_UpperCAmelCase    :						int							=      torch.cat([noise_pred, variance_pred_text]  ,   dim=1		)

														if not (
														    hasattr(self.scheduler.config  ,   "variance_type"		)
														    and self.scheduler.config.variance_type in ["learned", "learned_range"]
														):
																		_UpperCAmelCase						,							_UpperCAmelCase    :						Optional[Any]							=      noise_pred.split(latents.shape[1]  ,   dim=1		)

														# compute the previous noisy sample x_t -> x_t-1
														_UpperCAmelCase    :						int							=      self.scheduler.step(
														    A_  ,   A_  ,   A_  ,   generator=A_  ,   )[0]
										# post-processing
										_UpperCAmelCase    :						Optional[Any]							=      self.movq.decode(A_  ,   force_not_quantize=A_		)["sample"]

										if output_type not in ["pt", "np", "pil"]:
														raise ValueError(f'Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}'		)

										if output_type in ["np", "pil"]:
														_UpperCAmelCase    :						Union[str, Any]							=      image * 0.5 + 0.5
														_UpperCAmelCase    :						Dict							=      image.clamp(0  ,   1		)
														_UpperCAmelCase    :						List[str]							=      image.cpu().permute(0  ,   2  ,   3  ,   1		).float().numpy()

										if output_type == "pil":
														_UpperCAmelCase    :						str							=      self.numpy_to_pil(A_		)

										if not return_dict:
														return (image,)

										return ImagePipelineOutput(images=A_		)


