





"""simple docstring"""





import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
		    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
		    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
		    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
		    LayoutLMvaConfig,
		    LayoutLMvaForQuestionAnswering,
		    LayoutLMvaForSequenceClassification,
		    LayoutLMvaForTokenClassification,
		    LayoutLMvaModel,
		)
		from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
		from PIL import Image

		from transformers import LayoutLMvaImageProcessor





class        _lowerCamelCase      :


						def __init__(self   ,							__a   ,							__a=2   ,							__a=3   ,							__a=4   ,							__a=2   ,							__a=7   ,							__a=True   ,							__a=True   ,							__a=True   ,							__a=True   ,							__a=99   ,							__a=36   ,							__a=3   ,							__a=4   ,							__a=37   ,							__a="gelu"   ,							__a=0.1   ,							__a=0.1   ,							__a=5_12   ,							__a=16   ,							__a=2   ,							__a=0.02   ,							__a=6   ,							__a=6   ,							__a=3   ,							__a=4   ,							__a=None   ,							__a=10_00   ,							) ->   Dict:
								UpperCamelCase   =	parent
								UpperCamelCase   =	batch_size
								UpperCamelCase   =	num_channels
								UpperCamelCase   =	image_size
								UpperCamelCase   =	patch_size
								UpperCamelCase   =	text_seq_length
								UpperCamelCase   =	is_training
								UpperCamelCase   =	use_input_mask
								UpperCamelCase   =	use_token_type_ids
								UpperCamelCase   =	use_labels
								UpperCamelCase   =	vocab_size
								UpperCamelCase   =	hidden_size
								UpperCamelCase   =	num_hidden_layers
								UpperCamelCase   =	num_attention_heads
								UpperCamelCase   =	intermediate_size
								UpperCamelCase   =	hidden_act
								UpperCamelCase   =	hidden_dropout_prob
								UpperCamelCase   =	attention_probs_dropout_prob
								UpperCamelCase   =	max_position_embeddings
								UpperCamelCase   =	type_vocab_size
								UpperCamelCase   =	type_sequence_label_size
								UpperCamelCase   =	initializer_range
								UpperCamelCase   =	coordinate_size
								UpperCamelCase   =	shape_size
								UpperCamelCase   =	num_labels
								UpperCamelCase   =	num_choices
								UpperCamelCase   =	scope
								UpperCamelCase   =	range_bbox

								# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
								UpperCamelCase   =	text_seq_length
								UpperCamelCase   =	(image_size // patch_size) ** 2 + 1
								UpperCamelCase   =	self.text_seq_length + self.image_seq_length


						def     snake_case_   (self		) ->   Optional[Any]:
								UpperCamelCase   =	ids_tensor([self.batch_size, self.text_seq_length]   ,							self.vocab_size		)

								UpperCamelCase   =	ids_tensor([self.batch_size, self.text_seq_length, 4]   ,							self.range_bbox		)
								# Ensure that bbox is legal
								for i in range(bbox.shape[0]		):
										for j in range(bbox.shape[1]		):
												if bbox[i, j, 3] < bbox[i, j, 1]:
														UpperCamelCase   =	bbox[i, j, 3]
														UpperCamelCase   =	bbox[i, j, 1]
														UpperCamelCase   =	t
												if bbox[i, j, 2] < bbox[i, j, 0]:
														UpperCamelCase   =	bbox[i, j, 2]
														UpperCamelCase   =	bbox[i, j, 0]
														UpperCamelCase   =	t

								UpperCamelCase   =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

								UpperCamelCase   =	None
								if self.use_input_mask:
										UpperCamelCase   =	random_attention_mask([self.batch_size, self.text_seq_length]		)

								UpperCamelCase   =	None
								if self.use_token_type_ids:
										UpperCamelCase   =	ids_tensor([self.batch_size, self.text_seq_length]   ,							self.type_vocab_size		)

								UpperCamelCase   =	None
								UpperCamelCase   =	None
								if self.use_labels:
										UpperCamelCase   =	ids_tensor([self.batch_size]   ,							self.type_sequence_label_size		)
										UpperCamelCase   =	ids_tensor([self.batch_size, self.text_seq_length]   ,							self.num_labels		)

								UpperCamelCase   =	LayoutLMvaConfig(
								    vocab_size=self.vocab_size   ,							hidden_size=self.hidden_size   ,							num_hidden_layers=self.num_hidden_layers   ,							num_attention_heads=self.num_attention_heads   ,							intermediate_size=self.intermediate_size   ,							hidden_act=self.hidden_act   ,							hidden_dropout_prob=self.hidden_dropout_prob   ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,							max_position_embeddings=self.max_position_embeddings   ,							type_vocab_size=self.type_vocab_size   ,							initializer_range=self.initializer_range   ,							coordinate_size=self.coordinate_size   ,							shape_size=self.shape_size   ,							input_size=self.image_size   ,							patch_size=self.patch_size   ,							)

								return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a		) ->   int:
								UpperCamelCase   =	LayoutLMvaModel(config=__A		)
								model.to(__A		)
								model.eval()

								# text + image
								UpperCamelCase   =	model(__A   ,							pixel_values=__A		)
								UpperCamelCase   =	model(
								    __A   ,							bbox=__A   ,							pixel_values=__A   ,							attention_mask=__A   ,							token_type_ids=__A		)
								UpperCamelCase   =	model(__A   ,							bbox=__A   ,							pixel_values=__A   ,							token_type_ids=__A		)
								UpperCamelCase   =	model(__A   ,							bbox=__A   ,							pixel_values=__A		)

								self.parent.assertEqual(result.last_hidden_state.shape   ,							(self.batch_size, self.seq_length, self.hidden_size)		)

								# text only
								UpperCamelCase   =	model(__A		)
								self.parent.assertEqual(
								    result.last_hidden_state.shape   ,							(self.batch_size, self.text_seq_length, self.hidden_size)		)

								# image only
								UpperCamelCase   =	model(pixel_values=__A		)
								self.parent.assertEqual(
								    result.last_hidden_state.shape   ,							(self.batch_size, self.image_seq_length, self.hidden_size)		)


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a		) ->   Union[str, Any]:
								UpperCamelCase   =	self.num_labels
								UpperCamelCase   =	LayoutLMvaForSequenceClassification(__A		)
								model.to(__A		)
								model.eval()
								UpperCamelCase   =	model(
								    __A   ,							bbox=__A   ,							pixel_values=__A   ,							attention_mask=__A   ,							token_type_ids=__A   ,							labels=__A   ,							)
								self.parent.assertEqual(result.logits.shape   ,							(self.batch_size, self.num_labels)		)


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a		) ->   Any:
								UpperCamelCase   =	self.num_labels
								UpperCamelCase   =	LayoutLMvaForTokenClassification(config=__A		)
								model.to(__A		)
								model.eval()
								UpperCamelCase   =	model(
								    __A   ,							bbox=__A   ,							pixel_values=__A   ,							attention_mask=__A   ,							token_type_ids=__A   ,							labels=__A   ,							)
								self.parent.assertEqual(result.logits.shape   ,							(self.batch_size, self.text_seq_length, self.num_labels)		)


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a		) ->   str:
								UpperCamelCase   =	LayoutLMvaForQuestionAnswering(config=__A		)
								model.to(__A		)
								model.eval()
								UpperCamelCase   =	model(
								    __A   ,							bbox=__A   ,							pixel_values=__A   ,							attention_mask=__A   ,							token_type_ids=__A   ,							start_positions=__A   ,							end_positions=__A   ,							)
								self.parent.assertEqual(result.start_logits.shape   ,							(self.batch_size, self.seq_length)		)
								self.parent.assertEqual(result.end_logits.shape   ,							(self.batch_size, self.seq_length)		)




						def     snake_case_   (self		) ->   Any:
								UpperCamelCase   =	self.prepare_config_and_inputs()
								(
								    UpperCamelCase		
								)   =	config_and_inputs
								UpperCamelCase   =	{
								    "input_ids": input_ids,
								    "bbox": bbox,
								    "pixel_values": pixel_values,
								    "token_type_ids": token_type_ids,
								    "attention_mask": input_mask,
								}
								return config, inputs_dict





@require_torch
class        _lowerCamelCase      (       _lowercase  ,			_lowercase  ,			unittest.TestCase ):
						UpperCAmelCase_ =			False
						UpperCAmelCase_ =			False
						UpperCAmelCase_ =			False

						UpperCAmelCase_ =			(
						    (
						        LayoutLMvaModel,
						        LayoutLMvaForSequenceClassification,
						        LayoutLMvaForTokenClassification,
						        LayoutLMvaForQuestionAnswering,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCAmelCase_ =			(
						    {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
						    if is_torch_available()
						    else {}
						)


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a		) ->   Optional[Any]:
								# `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
								# embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
								# the sequence dimension of the text embedding only.
								# (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
								return True


						def     snake_case_   (self		) ->   Dict:
								UpperCamelCase   =	LayoutLMvaModelTester(self		)
								UpperCamelCase   =	ConfigTester(self   ,							config_class=__A   ,							hidden_size=37		)


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a=False		) ->   List[Any]:
								UpperCamelCase   =	copy.deepcopy(__A		)
								if model_class in get_values(__A		):
										UpperCamelCase   =	{
										    k: v.unsqueeze(1		).expand(-1   ,							self.model_tester.num_choices   ,							-1		).contiguous()
										    if isinstance(__A   ,							torch.Tensor		) and v.ndim > 1
										    else v
										    for k, v in inputs_dict.items()
										}
								if return_labels:
										if model_class in get_values(__A		):
												UpperCamelCase   =	torch.ones(self.model_tester.batch_size   ,							dtype=torch.long   ,							device=__A		)
										elif model_class in get_values(__A		):
												UpperCamelCase   =	torch.zeros(
												    self.model_tester.batch_size   ,							dtype=torch.long   ,							device=__A		)
												UpperCamelCase   =	torch.zeros(
												    self.model_tester.batch_size   ,							dtype=torch.long   ,							device=__A		)
										elif model_class in [
										    *get_values(__A		),
										]:
												UpperCamelCase   =	torch.zeros(
												    self.model_tester.batch_size   ,							dtype=torch.long   ,							device=__A		)
										elif model_class in [
										    *get_values(__A		),
										]:
												UpperCamelCase   =	torch.zeros(
												    (self.model_tester.batch_size, self.model_tester.text_seq_length)   ,							dtype=torch.long   ,							device=__A   ,							)

								return inputs_dict


						def     snake_case_   (self		) ->   List[Any]:
								self.config_tester.run_common_tests()


						def     snake_case_   (self		) ->   Any:
								UpperCamelCase   =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__A		)


						def     snake_case_   (self		) ->   Optional[int]:
								UpperCamelCase   =	self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
										UpperCamelCase   =	type
										self.model_tester.create_and_check_model(*__A		)


						def     snake_case_   (self		) ->   Union[str, Any]:
								UpperCamelCase   =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*__A		)


						def     snake_case_   (self		) ->   int:
								UpperCamelCase   =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*__A		)


						def     snake_case_   (self		) ->   int:
								UpperCamelCase   =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*__A		)




						@slow
						def     snake_case_   (self		) ->   int:
								for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										UpperCamelCase   =	LayoutLMvaModel.from_pretrained(__A		)
										self.assertIsNotNone(__A		)



def       a__					(					):




		"""simple docstring"""


		UpperCamelCase   =	Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
		return image






@require_torch
class        _lowerCamelCase      (       unittest.TestCase ):


						@cached_property
						def     snake_case_   (self		) ->   Union[str, Any]:
								return LayoutLMvaImageProcessor(apply_ocr=__A		) if is_vision_available() else None




						@slow
						def     snake_case_   (self		) ->   int:
								UpperCamelCase   =	LayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base"		).to(__A		)

								UpperCamelCase   =	self.default_image_processor
								UpperCamelCase   =	prepare_img()
								UpperCamelCase   =	image_processor(images=__A   ,							return_tensors="pt"		).pixel_values.to(__A		)

								UpperCamelCase   =	torch.tensor([[1, 2]]		)
								UpperCamelCase   =	torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]		).unsqueeze(0		)

								# forward pass
								UpperCamelCase   =	model(
								    input_ids=input_ids.to(__A		)   ,							bbox=bbox.to(__A		)   ,							pixel_values=pixel_values.to(__A		)   ,							)

								# verify the logits
								UpperCamelCase   =	torch.Size((1, 1_99, 7_68)		)
								self.assertEqual(outputs.last_hidden_state.shape   ,							__A		)

								UpperCamelCase   =	torch.tensor(
								    [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]		).to(__A		)

								self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]   ,							__A   ,							atol=1e-4		)		)













"""simple docstring"""





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

import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextModel,
    CLIPTokenizer,
    WhisperForConditionalGeneration,
    WhisperProcessor,
)

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


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





class        _lowerCamelCase      (       _lowercase ):


						def __init__(self   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							__a   ,							) ->   Dict:
								super().__init__()

								if safety_checker is None:
										logger.warning(
										    F"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
										    " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
										    " results in services or applications open to the public. Both the diffusers team and Hugging Face"
										    " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
										    " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
										    " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."		)

								self.register_modules(
								    speech_model=__a   ,							speech_processor=__a   ,							vae=__a   ,							text_encoder=__a   ,							tokenizer=__a   ,							unet=__a   ,							scheduler=__a   ,							feature_extractor=__a   ,							)


						def     snake_case_   (self   ,							__a = "auto"		) ->   str:
								if slice_size == "auto":
										UpperCamelCase   =	self.unet.config.attention_head_dim // 2
								self.unet.set_attention_slice(__a		)


						def     snake_case_   (self		) ->   List[Any]:
								self.enable_attention_slicing(__a		)




						@torch.no_grad()
						def __call__(self   ,							__a   ,							__a=1_60_00   ,							__a = 5_12   ,							__a = 5_12   ,							__a = 50   ,							__a = 7.5   ,							__a = None   ,							__a = 1   ,							__a = 0.0   ,							__a = None   ,							__a = None   ,							__a = "pil"   ,							__a = True   ,							__a = None   ,							__a = 1   ,							**__a   ,							) ->   List[str]:
								UpperCamelCase   =	self.speech_processor.feature_extractor(
								    __a   ,							return_tensors="pt"   ,							sampling_rate=__a		).input_features.to(self.device		)
								UpperCamelCase   =	self.speech_model.generate(__a   ,							max_length=48_00_00		)

								UpperCamelCase   =	self.speech_processor.tokenizer.batch_decode(__a   ,							skip_special_tokens=__a   ,							normalize=__a		)[
								    0
								]

								if isinstance(__a   ,							__a		):
										UpperCamelCase   =	1
								elif isinstance(__a   ,							__a		):
										UpperCamelCase   =	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
								UpperCamelCase   =	self.tokenizer(
								    __a   ,							padding="max_length"   ,							max_length=self.tokenizer.model_max_length   ,							return_tensors="pt"   ,							)
								UpperCamelCase   =	text_inputs.input_ids

								if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
										UpperCamelCase   =	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}"		)
										UpperCamelCase   =	text_input_ids[:, : self.tokenizer.model_max_length]
								UpperCamelCase   =	self.text_encoder(text_input_ids.to(self.device		)		)[0]

								# duplicate text embeddings for each generation per prompt, using mps friendly method
								UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   =	text_embeddings.shape
								UpperCamelCase   =	text_embeddings.repeat(1   ,							__a   ,							1		)
								UpperCamelCase   =	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.
								UpperCamelCase   =	guidance_scale > 1.0
								# get unconditional embeddings for classifier free guidance
								if do_classifier_free_guidance:
										UpperCamelCase   =	42
										if negative_prompt is None:
												UpperCamelCase   =	[""] * batch_size
										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		):
												UpperCamelCase   =	[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:
												UpperCamelCase   =	negative_prompt

										UpperCamelCase   =	text_input_ids.shape[-1]
										UpperCamelCase   =	self.tokenizer(
										    __a   ,							padding="max_length"   ,							max_length=__a   ,							truncation=__a   ,							return_tensors="pt"   ,							)
										UpperCamelCase   =	self.text_encoder(uncond_input.input_ids.to(self.device		)		)[0]

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

								# 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
								UpperCamelCase   =	self.scheduler.timesteps.to(self.device		)

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

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

										# predict the noise residual
										UpperCamelCase   =	self.unet(__a   ,							__a   ,							encoder_hidden_states=__a		).sample

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

										# compute the previous noisy sample x_t -> x_t-1
										UpperCamelCase   =	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		)

								UpperCamelCase   =	1 / 0.18215 * latents
								UpperCamelCase   =	self.vae.decode(__a		).sample

								UpperCamelCase   =	(image / 2 + 0.5).clamp(0   ,							1		)

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

								if output_type == "pil":
										UpperCamelCase   =	self.numpy_to_pil(__a		)

								if not return_dict:
										return image

								return StableDiffusionPipelineOutput(images=__a   ,							nsfw_content_detected=__a		)






