

from __future__ import annotations

import unittest

from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TF_MODEL_FOR_PRETRAINING_MAPPING,
					    TFMobileBertForMaskedLM,
					    TFMobileBertForMultipleChoice,
					    TFMobileBertForNextSentencePrediction,
					    TFMobileBertForPreTraining,
					    TFMobileBertForQuestionAnswering,
					    TFMobileBertForSequenceClassification,
					    TFMobileBertForTokenClassification,
					    TFMobileBertModel,
					)

@require_tf
class __UpperCamelCase     (				_a					,_a					,unittest.TestCase		):






					'''simple docstring'''



					__magic_name__        =   (
					    (
					        TFMobileBertModel,
					        TFMobileBertForMaskedLM,
					        TFMobileBertForNextSentencePrediction,
					        TFMobileBertForPreTraining,
					        TFMobileBertForQuestionAnswering,
					        TFMobileBertForSequenceClassification,
					        TFMobileBertForTokenClassification,
					        TFMobileBertForMultipleChoice,
					    )
					    if is_tf_available()
					    else ()
					)
					__magic_name__        =   (
					    {
					        "feature-extraction": TFMobileBertModel,
					        "fill-mask": TFMobileBertForMaskedLM,
					        "question-answering": TFMobileBertForQuestionAnswering,
					        "text-classification": TFMobileBertForSequenceClassification,
					        "token-classification": TFMobileBertForTokenClassification,
					        "zero-shot": TFMobileBertForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)
					__magic_name__        =   False
					__magic_name__        =   False





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__=False						):
						UpperCAmelCase__:	Tuple									= super()._prepare_for_class(lowerCamelCase__				,      lowerCamelCase__				,      return_labels=lowerCamelCase__						)

						if return_labels:
							if model_class in get_values(lowerCamelCase__						):
								UpperCAmelCase__:	Union[str, Any]									= tf.zeros(self.model_tester.batch_size				,      dtype=tf.intaa						)

						return inputs_dict

					class __UpperCamelCase     (				_a		):






										'''simple docstring'''



										def __init__(				self				,      lowerCamelCase__				,      lowerCamelCase__=1_3				,      lowerCamelCase__=7				,      lowerCamelCase__=True				,      lowerCamelCase__=True				,      lowerCamelCase__=True				,      lowerCamelCase__=True				,      lowerCamelCase__=9_9				,      lowerCamelCase__=3_2				,      lowerCamelCase__=3_2				,      lowerCamelCase__=2				,      lowerCamelCase__=4				,      lowerCamelCase__=3_7				,      lowerCamelCase__="gelu"				,      lowerCamelCase__=0.1				,      lowerCamelCase__=0.1				,      lowerCamelCase__=5_1_2				,      lowerCamelCase__=1_6				,      lowerCamelCase__=2				,      lowerCamelCase__=0.02				,      lowerCamelCase__=3				,      lowerCamelCase__=4				,      lowerCamelCase__=None				,      ):
											UpperCAmelCase__:	int									= parent
											UpperCAmelCase__:	Any									= batch_size
											UpperCAmelCase__:	Union[str, Any]									= seq_length
											UpperCAmelCase__:	Optional[Any]									= is_training
											UpperCAmelCase__:	Optional[int]									= use_input_mask
											UpperCAmelCase__:	Dict									= use_token_type_ids
											UpperCAmelCase__:	List[Any]									= use_labels
											UpperCAmelCase__:	List[Any]									= vocab_size
											UpperCAmelCase__:	Tuple									= hidden_size
											UpperCAmelCase__:	Any									= num_hidden_layers
											UpperCAmelCase__:	int									= num_attention_heads
											UpperCAmelCase__:	Optional[Any]									= intermediate_size
											UpperCAmelCase__:	int									= hidden_act
											UpperCAmelCase__:	Any									= hidden_dropout_prob
											UpperCAmelCase__:	str									= attention_probs_dropout_prob
											UpperCAmelCase__:	str									= max_position_embeddings
											UpperCAmelCase__:	int									= type_vocab_size
											UpperCAmelCase__:	Dict									= type_sequence_label_size
											UpperCAmelCase__:	Dict									= initializer_range
											UpperCAmelCase__:	Dict									= num_labels
											UpperCAmelCase__:	int									= num_choices
											UpperCAmelCase__:	List[str]									= scope
											UpperCAmelCase__:	List[str]									= embedding_size





										def    _UpperCAmelCase    (				self						):
											UpperCAmelCase__:	Any									= ids_tensor([self.batch_size, self.seq_length]				,      self.vocab_size						)

											UpperCAmelCase__:	Union[str, Any]									= None
											if self.use_input_mask:
												UpperCAmelCase__:	Any									= random_attention_mask([self.batch_size, self.seq_length]						)

											UpperCAmelCase__:	List[str]									= None
											if self.use_token_type_ids:
												UpperCAmelCase__:	int									= ids_tensor([self.batch_size, self.seq_length]				,      self.type_vocab_size						)

											UpperCAmelCase__:	Union[str, Any]									= None
											UpperCAmelCase__:	Optional[Any]									= None
											UpperCAmelCase__:	Union[str, Any]									= None
											if self.use_labels:
												UpperCAmelCase__:	List[str]									= ids_tensor([self.batch_size]				,      self.type_sequence_label_size						)
												UpperCAmelCase__:	int									= ids_tensor([self.batch_size, self.seq_length]				,      self.num_labels						)
												UpperCAmelCase__:	Optional[int]									= ids_tensor([self.batch_size]				,      self.num_choices						)

											UpperCAmelCase__:	int									= MobileBertConfig(
											    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				,      embedding_size=self.embedding_size				,      )

											return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





										def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
											UpperCAmelCase__:	Union[str, Any]									= TFMobileBertModel(config=lowerCamelCase__						)
											UpperCAmelCase__:	Optional[int]									= {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
											UpperCAmelCase__:	Any									= model(lowerCamelCase__						)

											UpperCAmelCase__:	Tuple									= [input_ids, input_mask]
											UpperCAmelCase__:	int									= model(lowerCamelCase__						)

											UpperCAmelCase__:	str									= model(lowerCamelCase__						)

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





										def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
											UpperCAmelCase__:	Optional[Any]									= TFMobileBertForMaskedLM(config=lowerCamelCase__						)
											UpperCAmelCase__:	str									= {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
											UpperCAmelCase__:	List[Any]									= model(lowerCamelCase__						)
											self.parent.assertEqual(result.logits.shape				,      (self.batch_size, self.seq_length, self.vocab_size)						)





										def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
											UpperCAmelCase__:	Dict									= TFMobileBertForNextSentencePrediction(config=lowerCamelCase__						)
											UpperCAmelCase__:	str									= {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
											UpperCAmelCase__:	List[str]									= model(lowerCamelCase__						)
											self.parent.assertEqual(result.logits.shape				,      (self.batch_size, 2)						)





										def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
											UpperCAmelCase__:	Tuple									= TFMobileBertForPreTraining(config=lowerCamelCase__						)
											UpperCAmelCase__:	List[str]									= {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
											UpperCAmelCase__:	List[str]									= model(lowerCamelCase__						)
											self.parent.assertEqual(
											    result.prediction_logits.shape				,      (self.batch_size, self.seq_length, self.vocab_size)						)
											self.parent.assertEqual(result.seq_relationship_logits.shape				,      (self.batch_size, 2)						)





										def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
											UpperCAmelCase__:	Optional[int]									= self.num_labels
											UpperCAmelCase__:	int									= TFMobileBertForSequenceClassification(config=lowerCamelCase__						)
											UpperCAmelCase__:	Optional[int]									= {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
											UpperCAmelCase__:	List[Any]									= model(lowerCamelCase__						)
											self.parent.assertEqual(result.logits.shape				,      (self.batch_size, self.num_labels)						)





										def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
											UpperCAmelCase__:	Any									= self.num_choices
											UpperCAmelCase__:	Optional[int]									= TFMobileBertForMultipleChoice(config=lowerCamelCase__						)
											UpperCAmelCase__:	Optional[Any]									= tf.tile(tf.expand_dims(lowerCamelCase__				,      1						)				,      (1, self.num_choices, 1)						)
											UpperCAmelCase__:	Any									= tf.tile(tf.expand_dims(lowerCamelCase__				,      1						)				,      (1, self.num_choices, 1)						)
											UpperCAmelCase__:	List[str]									= tf.tile(tf.expand_dims(lowerCamelCase__				,      1						)				,      (1, self.num_choices, 1)						)
											UpperCAmelCase__:	Optional[Any]									= {
											    "input_ids": multiple_choice_inputs_ids,
											    "attention_mask": multiple_choice_input_mask,
											    "token_type_ids": multiple_choice_token_type_ids,
											}
											UpperCAmelCase__:	Dict									= model(lowerCamelCase__						)
											self.parent.assertEqual(result.logits.shape				,      (self.batch_size, self.num_choices)						)





										def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
											UpperCAmelCase__:	Dict									= self.num_labels
											UpperCAmelCase__:	Tuple									= TFMobileBertForTokenClassification(config=lowerCamelCase__						)
											UpperCAmelCase__:	Tuple									= {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
											UpperCAmelCase__:	Optional[Any]									= model(lowerCamelCase__						)
											self.parent.assertEqual(result.logits.shape				,      (self.batch_size, self.seq_length, self.num_labels)						)





										def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
											UpperCAmelCase__:	int									= TFMobileBertForQuestionAnswering(config=lowerCamelCase__						)
											UpperCAmelCase__:	int									= {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
											UpperCAmelCase__:	Optional[int]									= model(lowerCamelCase__						)
											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    _UpperCAmelCase    (				self						):
											UpperCAmelCase__:	Tuple									= self.prepare_config_and_inputs()
											(
											    (
											    UpperCAmelCase__
											)							,						(
											    UpperCAmelCase__
											)							,						(
											    UpperCAmelCase__
											)							,						(
											    UpperCAmelCase__
											)							,						(
											    UpperCAmelCase__
											)							,						(
											    UpperCAmelCase__
											)							,						(
											    UpperCAmelCase__
											)							,						
											):	str									= config_and_inputs
											UpperCAmelCase__:	str									= {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
											return config, inputs_dict





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	List[Any]									= TFMobileBertModelTest.TFMobileBertModelTester(self						)
						UpperCAmelCase__:	Union[str, Any]									= ConfigTester(self				,      config_class=lowerCamelCase__				,      hidden_size=3_7						)





					def    _UpperCAmelCase    (				self						):
						self.config_tester.run_common_tests()





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Any									= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_mobilebert_model(*lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	int									= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_mobilebert_for_masked_lm(*lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Any									= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_mobilebert_for_multiple_choice(*lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	int									= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	str									= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_mobilebert_for_pretraining(*lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Dict									= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_mobilebert_for_question_answering(*lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	List[Any]									= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_mobilebert_for_sequence_classification(*lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Any									= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_mobilebert_for_token_classification(*lowerCamelCase__						)





					@slow
					def    _UpperCAmelCase    (				self						):
						# for model_name in TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						for model_name in ["google/mobilebert-uncased"]:
							UpperCAmelCase__:	List[Any]									= TFMobileBertModel.from_pretrained(lowerCamelCase__						)
							self.assertIsNotNone(lowerCamelCase__						)

@require_tf
class __UpperCamelCase     (				unittest.TestCase		):






					'''simple docstring'''



					@slow
					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	List[Any]									= TFMobileBertForPreTraining.from_pretrained("google/mobilebert-uncased"						)
						UpperCAmelCase__:	Optional[Any]									= tf.constant([[0, 1, 2, 3, 4, 5]]						)
						UpperCAmelCase__:	Optional[Any]									= model(lowerCamelCase__						)[0]

						UpperCAmelCase__:	int									= [1, 6, 3_0_5_2_2]
						self.assertEqual(output.shape				,      lowerCamelCase__						)

						UpperCAmelCase__:	Dict									= tf.constant(
						    [
						        [
						            [-4.5_919_547, -9.248_295, -9.645_256],
						            [-6.7_306_175, -6.440_284, -6.6_052_837],
						            [-7.2_743_506, -6.7_847_915, -6.024_673],
						        ]
						    ]						)
						tf.debugging.assert_near(output[:, :3, :3]				,      lowerCamelCase__				,      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,
)


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

_lowerCAmelCase  :      Any			 ="""
    Examples:
        ```py
        >>> import torch
        >>> import numpy as np

        >>> from diffusers import KandinskyV22PriorPipeline, KandinskyV22ControlnetPipeline
        >>> from transformers import pipeline
        >>> from diffusers.utils import load_image


        >>> def make_hint(image, depth_estimator):
        ...     image = depth_estimator(image)[\"depth\"]
        ...     image = np.array(image)
        ...     image = image[:, :, None]
        ...     image = np.concatenate([image, image, image], axis=2)
        ...     detected_map = torch.from_numpy(image).float() / 255.0
        ...     hint = detected_map.permute(2, 0, 1)
        ...     return hint


        >>> depth_estimator = pipeline(\"depth-estimation\")

        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(
        ...     \"kandinsky-community/kandinsky-2-2-prior\", torch_dtype=torch.float16
        ... )
        >>> pipe_prior = pipe_prior.to(\"cuda\")

        >>> pipe = KandinskyV22ControlnetPipeline.from_pretrained(
        ...     \"kandinsky-community/kandinsky-2-2-controlnet-depth\", torch_dtype=torch.float16
        ... )
        >>> pipe = pipe.to(\"cuda\")


        >>> img = load_image(
        ...     \"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main\"
        ...     \"/kandinsky/cat.png\"
        ... ).resize((768, 768))

        >>> hint = make_hint(img, depth_estimator).unsqueeze(0).half().to(\"cuda\")

        >>> prompt = \"A robot, 4k photo\"
        >>> 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\"

        >>> generator = torch.Generator(device=\"cuda\").manual_seed(43)

        >>> image_emb, zero_image_emb = pipe_prior(
        ...     prompt=prompt, negative_prompt=negative_prior_prompt, generator=generator
        ... ).to_tuple()

        >>> images = pipe(
        ...     image_embeds=image_emb,
        ...     negative_image_embeds=zero_image_emb,
        ...     hint=hint,
        ...     num_inference_steps=50,
        ...     generator=generator,
        ...     height=768,
        ...     width=768,
        ... ).images

        >>> images[0].save(\"robot_cat.png\")
        ```
"""



def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE=8      ):
	UpperCAmelCase__:	int									= height // scale_factor**2
	if height % scale_factor**2 != 0:
		new_height += 1
	UpperCAmelCase__:	Optional[Any]									= width // scale_factor**2
	if width % scale_factor**2 != 0:
		new_width += 1
	return new_height * scale_factor, new_width * scale_factor

class __UpperCamelCase     (				_a		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      ):
						super().__init__()

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





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
						if latents is None:
							UpperCAmelCase__:	Any									= randn_tensor(lowerCamelCase__				,      generator=lowerCamelCase__				,      device=lowerCamelCase__				,      dtype=lowerCamelCase__						)
						else:
							if latents.shape != shape:
								raise ValueError(F"Unexpected latents shape, got {latents.shape}, expected {shape}"						)
							UpperCAmelCase__:	Tuple									= latents.to(lowerCamelCase__						)

						UpperCAmelCase__:	Union[str, Any]									= latents * scheduler.init_noise_sigma
						return latents





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__=0						):
						if is_accelerate_available():
							from accelerate import cpu_offload
						else:
							raise ImportError("Please install accelerate via `pip install accelerate`"						)

						UpperCAmelCase__:	Any									= torch.device(F"cuda:{gpu_id}"						)

						UpperCAmelCase__:	int									= [
						    self.unet,
						    self.movq,
						]
						for cpu_offloaded_model in models:
							if cpu_offloaded_model is not None:
								cpu_offload(lowerCamelCase__				,      lowerCamelCase__						)





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__=0						):
						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__:	Union[str, Any]									= torch.device(F"cuda:{gpu_id}"						)

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

						UpperCAmelCase__:	int									= None
						for cpu_offloaded_model in [self.unet, self.movq]:
							UpperCAmelCase__							,						UpperCAmelCase__:	Tuple									= cpu_offload_with_hook(lowerCamelCase__				,      lowerCamelCase__				,      prev_module_hook=lowerCamelCase__						)

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





					@property
					# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
					def    _UpperCAmelCase    (				self						):
						if not hasattr(self.unet				,      "_hf_hook"						):
							return self.device
						for module in self.unet.modules():
							if (
							    hasattr(lowerCamelCase__				,      "_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(lowerCamelCase__						)
					def __call__(				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__ = 5_1_2				,      lowerCamelCase__ = 5_1_2				,      lowerCamelCase__ = 1_0_0				,      lowerCamelCase__ = 4.0				,      lowerCamelCase__ = 1				,      lowerCamelCase__ = None				,      lowerCamelCase__ = None				,      lowerCamelCase__ = "pil"				,      lowerCamelCase__ = True				,      ):
						UpperCAmelCase__:	str									= self._execution_device

						UpperCAmelCase__:	List[Any]									= guidance_scale > 1.0

						if isinstance(lowerCamelCase__				,      lowerCamelCase__						):
							UpperCAmelCase__:	List[Any]									= torch.cat(lowerCamelCase__				,      dim=0						)
						if isinstance(lowerCamelCase__				,      lowerCamelCase__						):
							UpperCAmelCase__:	List[Any]									= torch.cat(lowerCamelCase__				,      dim=0						)
						if isinstance(lowerCamelCase__				,      lowerCamelCase__						):
							UpperCAmelCase__:	Any									= torch.cat(lowerCamelCase__				,      dim=0						)

						UpperCAmelCase__:	Dict									= image_embeds.shape[0] * num_images_per_prompt

						if do_classifier_free_guidance:
							UpperCAmelCase__:	Tuple									= image_embeds.repeat_interleave(lowerCamelCase__				,      dim=0						)
							UpperCAmelCase__:	Union[str, Any]									= negative_image_embeds.repeat_interleave(lowerCamelCase__				,      dim=0						)
							UpperCAmelCase__:	Any									= hint.repeat_interleave(lowerCamelCase__				,      dim=0						)

						UpperCAmelCase__:	Union[str, Any]									= torch.cat([negative_image_embeds, image_embeds]				,      dim=0						).to(dtype=self.unet.dtype				,      device=lowerCamelCase__						)
						UpperCAmelCase__:	Dict									= torch.cat([hint, hint]				,      dim=0						).to(dtype=self.unet.dtype				,      device=lowerCamelCase__						)
						self.scheduler.set_timesteps(lowerCamelCase__				,      device=lowerCamelCase__						)
						UpperCAmelCase__:	Optional[Any]									= self.scheduler.timesteps

						UpperCAmelCase__:	Optional[int]									= self.movq.config.latent_channels

						UpperCAmelCase__							,						UpperCAmelCase__:	Tuple									= downscale_height_and_width(lowerCamelCase__				,      lowerCamelCase__				,      self.movq_scale_factor						)

						# create initial latent
						UpperCAmelCase__:	Any									= self.prepare_latents(
						    (batch_size, num_channels_latents, height, width)				,      image_embeds.dtype				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      self.scheduler				,      )

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

							UpperCAmelCase__:	List[str]									= {"image_embeds": image_embeds, "hint": hint}
							UpperCAmelCase__:	Any									= self.unet(
							    sample=lowerCamelCase__				,      timestep=lowerCamelCase__				,      encoder_hidden_states=lowerCamelCase__				,      added_cond_kwargs=lowerCamelCase__				,      return_dict=lowerCamelCase__				,      )[0]

							if do_classifier_free_guidance:
								UpperCAmelCase__							,						UpperCAmelCase__:	str									= noise_pred.split(latents.shape[1]				,      dim=1						)
								UpperCAmelCase__							,						UpperCAmelCase__:	Any									= noise_pred.chunk(2						)
								UpperCAmelCase__							,						UpperCAmelCase__:	Any									= variance_pred.chunk(2						)
								UpperCAmelCase__:	List[str]									= noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
								UpperCAmelCase__:	Dict									= 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__:	int									= noise_pred.split(latents.shape[1]				,      dim=1						)

							# compute the previous noisy sample x_t -> x_t-1
							UpperCAmelCase__:	List[Any]									= self.scheduler.step(
							    lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      generator=lowerCamelCase__				,      )[0]
						# post-processing
						UpperCAmelCase__:	Union[str, Any]									= self.movq.decode(lowerCamelCase__				,      force_not_quantize=lowerCamelCase__						)["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__:	List[str]									= image * 0.5 + 0.5
							UpperCAmelCase__:	int									= image.clamp(0				,      1						)
							UpperCAmelCase__:	Tuple									= image.cpu().permute(0				,      2				,      3				,      1						).float().numpy()

						if output_type == "pil":
							UpperCAmelCase__:	List[str]									= self.numpy_to_pil(lowerCamelCase__						)

						if not return_dict:
							return (image,)

						return ImagePipelineOutput(images=lowerCamelCase__						)