
'''simple docstring'''

import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

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


if is_torch_available():
     import torch

     from transformers import EsmForMaskedLM, EsmForSequenceClassification, EsmForTokenClassification, EsmModel
     from transformers.models.esm.modeling_esm import (
         ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
         EsmEmbeddings,
         create_position_ids_from_input_ids,
     )


class      a_     :




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




       def 							__UpperCamelCase				(   self     ):
         _lowerCAmelCase				:     Optional[Any]       =    ids_tensor([self.batch_size, self.seq_length]      ,      self.vocab_size     )

         _lowerCAmelCase				:     Tuple       =    None
         if self.use_input_mask:
           _lowerCAmelCase				:     str       =    random_attention_mask([self.batch_size, self.seq_length]     )

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

         _lowerCAmelCase				:     Dict       =    self.get_config()

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




       def 							__UpperCamelCase				(   self     ):
         return EsmConfig(
             vocab_size=self.vocab_size      ,      hidden_size=self.hidden_size      ,      pad_token_id=1      ,      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      ,      )




       def 							__UpperCamelCase				(   self      ,      snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_     ):
         _lowerCAmelCase				:     Dict       =    EsmModel(config=UpperCamelCase_     )
         model.to(UpperCamelCase_     )
         model.eval()
         _lowerCAmelCase				:     List[str]       =    model(UpperCamelCase_      ,      attention_mask=UpperCamelCase_     )
         _lowerCAmelCase				:     Optional[int]       =    model(UpperCamelCase_     )
         _lowerCAmelCase				:     int       =    model(UpperCamelCase_     )

         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      ,      snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_     ):
         _lowerCAmelCase				:     Dict       =    EsmForMaskedLM(config=UpperCamelCase_     )
         model.to(UpperCamelCase_     )
         model.eval()
         _lowerCAmelCase				:     Union[str, Any]       =    model(UpperCamelCase_      ,      attention_mask=UpperCamelCase_      ,      labels=UpperCamelCase_     )
         self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.seq_length, self.vocab_size)     )




       def 							__UpperCamelCase				(   self      ,      snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_      ,      snake_case_     ):
         _lowerCAmelCase				:     Optional[Any]       =    self.num_labels
         _lowerCAmelCase				:     Union[str, Any]       =    EsmForTokenClassification(config=UpperCamelCase_     )
         model.to(UpperCamelCase_     )
         model.eval()
         _lowerCAmelCase				:     int       =    model(UpperCamelCase_      ,      attention_mask=UpperCamelCase_      ,      labels=UpperCamelCase_     )
         self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.seq_length, self.num_labels)     )







       def 							__UpperCamelCase				(   self     ):
         _lowerCAmelCase				:     str       =    self.prepare_config_and_inputs()
         (
             (
             _lowerCAmelCase   
         ) ,    (
             _lowerCAmelCase   
         ) ,    (
             _lowerCAmelCase   
         ) ,    (
             _lowerCAmelCase   
         ) ,    (
             _lowerCAmelCase   
         ) ,    (
             _lowerCAmelCase   
         ) ,       
         )				:     str       =    config_and_inputs
         _lowerCAmelCase				:     Union[str, Any]       =    {"""input_ids""": input_ids, """attention_mask""": input_mask}
         return config, inputs_dict



@require_torch
class      a_     (__lowerCamelCase							,	__lowerCamelCase							,	unittest.TestCase			):
       __lowerCAmelCase			: Union[str, Any]			=					False

       __lowerCAmelCase			: Tuple			=					(
           (
               EsmForMaskedLM,
               EsmModel,
               EsmForSequenceClassification,
               EsmForTokenClassification,
           )
           if is_torch_available()
           else ()
       )
       __lowerCAmelCase			: Optional[int]			=					()
       __lowerCAmelCase			: str			=					(
           {
               'feature-extraction': EsmModel,
               'fill-mask': EsmForMaskedLM,
               'text-classification': EsmForSequenceClassification,
               'token-classification': EsmForTokenClassification,
               'zero-shot': EsmForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       __lowerCAmelCase			: Any			=					True




       def 							__UpperCamelCase				(   self     ):
         _lowerCAmelCase				:     Dict       =    EsmModelTester(self     )
         _lowerCAmelCase				:     List[str]       =    ConfigTester(self      ,      config_class=UpperCamelCase_      ,      hidden_size=3_7     )




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




       def 							__UpperCamelCase				(   self     ):
         _lowerCAmelCase				:     Optional[int]       =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase_     )




       def 							__UpperCamelCase				(   self     ):
         _lowerCAmelCase				:     Any       =    self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
           _lowerCAmelCase				:     List[Any]       =    type
           self.model_tester.create_and_check_model(*UpperCamelCase_     )




       def 							__UpperCamelCase				(   self     ):
         _lowerCAmelCase				:     Any       =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase_     )




       def 							__UpperCamelCase				(   self     ):
         _lowerCAmelCase				:     Tuple       =    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*UpperCamelCase_     )




       @slow
       def 							__UpperCamelCase				(   self     ):
         for model_name in ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowerCAmelCase				:     List[str]       =    EsmModel.from_pretrained(UpperCamelCase_     )
           self.assertIsNotNone(UpperCamelCase_     )




       def 							__UpperCamelCase				(   self     ):
         _lowerCAmelCase				:     Tuple       =    self.model_tester.prepare_config_and_inputs()[0]
         _lowerCAmelCase				:     int       =    EsmEmbeddings(config=UpperCamelCase_     )

         _lowerCAmelCase				:     Optional[Any]       =    torch.as_tensor([[1_2, 3_1, 1_3, model.padding_idx]]     )
         _lowerCAmelCase				:     Optional[int]       =    torch.as_tensor(
             [
                 [
                     0 + model.padding_idx + 1,
                     1 + model.padding_idx + 1,
                     2 + model.padding_idx + 1,
                     model.padding_idx,
                 ]
             ]     )
         _lowerCAmelCase				:     Union[str, Any]       =    create_position_ids_from_input_ids(UpperCamelCase_      ,      model.padding_idx     )
         self.assertEqual(position_ids.shape      ,      expected_positions.shape     )
         self.assertTrue(torch.all(torch.eq(UpperCamelCase_      ,      UpperCamelCase_     )     )     )




       def 							__UpperCamelCase				(   self     ):
         _lowerCAmelCase				:     List[Any]       =    self.model_tester.prepare_config_and_inputs()[0]
         _lowerCAmelCase				:     List[Any]       =    EsmEmbeddings(config=UpperCamelCase_     )

         _lowerCAmelCase				:     str       =    torch.empty(2      ,      4      ,      3_0     )
         _lowerCAmelCase				:     int       =    [
             0 + embeddings.padding_idx + 1,
             1 + embeddings.padding_idx + 1,
             2 + embeddings.padding_idx + 1,
             3 + embeddings.padding_idx + 1,
         ]
         _lowerCAmelCase				:     Optional[int]       =    torch.as_tensor([expected_single_positions, expected_single_positions]     )
         _lowerCAmelCase				:     List[str]       =    embeddings.create_position_ids_from_inputs_embeds(UpperCamelCase_     )
         self.assertEqual(position_ids.shape      ,      expected_positions.shape     )
         self.assertTrue(torch.all(torch.eq(UpperCamelCase_      ,      UpperCamelCase_     )     )     )




       @unittest.skip("""Esm does not support embedding resizing"""     )
       def 							__UpperCamelCase				(   self     ):
         pass




       @unittest.skip("""Esm does not support embedding resizing"""     )
       def 							__UpperCamelCase				(   self     ):
         pass







       @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""     )
       def 							__UpperCamelCase				(   self     ):
         pass



@require_torch
class      a_     (__lowerCamelCase			):




       @slow
       def 							__UpperCamelCase				(   self     ):
         with torch.no_grad():
           _lowerCAmelCase				:     Optional[Any]       =    EsmForMaskedLM.from_pretrained("""facebook/esm2_t6_8M_UR50D"""     )
           model.eval()
           _lowerCAmelCase				:     int       =    torch.tensor([[0, 1, 2, 3, 4, 5]]     )
           _lowerCAmelCase				:     Union[str, Any]       =    model(UpperCamelCase_     )[0]

           _lowerCAmelCase				:     List[str]       =    3_3

           _lowerCAmelCase				:     Tuple       =    torch.Size((1, 6, vocab_size)     )
           self.assertEqual(output.shape      ,      UpperCamelCase_     )

           _lowerCAmelCase				:     str       =    torch.tensor(
               [[[8.9215, -10.5898, -6.4671], [-6.3967, -13.9114, -1.1212], [-7.7812, -13.9516, -3.7406]]]     )
           self.assertTrue(torch.allclose(output[:, :3, :3]      ,      UpperCamelCase_      ,      atol=1E-4     )     )







       @slow
       def 							__UpperCamelCase				(   self     ):
         with torch.no_grad():
           _lowerCAmelCase				:     Union[str, Any]       =    EsmModel.from_pretrained("""facebook/esm2_t6_8M_UR50D"""     )
           model.eval()

           _lowerCAmelCase				:     List[Any]       =    torch.tensor([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]     )
           _lowerCAmelCase				:     Dict       =    model(UpperCamelCase_     )[0]
           # compare the actual values for a slice.
           _lowerCAmelCase				:     Union[str, Any]       =    torch.tensor(
               [[[0.1444, 0.5413, 0.3248], [0.3034, 0.0053, 0.3108], [0.3228, -0.2499, 0.3415]]]     )
           self.assertTrue(torch.allclose(output[:, :3, :3]      ,      UpperCamelCase_      ,      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,
)


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

UpperCAmelCase_									=	'\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 					lowerCamelCase__       (						A__       :					Optional[int]  ,			A__       :					Dict  ,			A__       :					Optional[int]=8	):





       '''simple docstring'''



       __lowerCamelCase   =						height // scale_factor**2
       if height % scale_factor**2 != 0:
              new_height += 1
       __lowerCamelCase   =						width // scale_factor**2
       if width % scale_factor**2 != 0:
              new_width += 1
       return new_height * scale_factor, new_width * scale_factor





class     lowerCamelCase__(					__lowerCamelCase):
      def __init__(				self: List[Any]    ,       UpperCamelCase_: UNetaDConditionModel    ,       UpperCamelCase_: DDPMScheduler    ,       UpperCamelCase_: VQModel    ,       ):
             super().__init__()

             self.register_modules(
                 unet=UpperCamelCase_    ,       scheduler=UpperCamelCase_    ,       movq=UpperCamelCase_    ,       )
             __lowerCamelCase   =						2 ** (len(self.movq.config.block_out_channels   ) - 1)
      def 			lowerCAmelCase__						(				self: int    ,       UpperCamelCase_: Any    ,       UpperCamelCase_: Tuple    ,       UpperCamelCase_: int    ,       UpperCamelCase_: Dict    ,       UpperCamelCase_: Dict    ,       UpperCamelCase_: int   ):
             if latents is None:
                    __lowerCamelCase   =						randn_tensor(UpperCamelCase_    ,       generator=UpperCamelCase_    ,       device=UpperCamelCase_    ,       dtype=UpperCamelCase_   )
             else:
                    if latents.shape != shape:
                           raise ValueError(F'Unexpected latents shape, got {latents.shape}, expected {shape}'   )
                    __lowerCamelCase   =						latents.to(UpperCamelCase_   )

             __lowerCamelCase   =						latents * scheduler.init_noise_sigma
             return latents
      def 			lowerCAmelCase__						(				self: Dict    ,       UpperCamelCase_: str=0   ):
             if is_accelerate_available():
                    from accelerate import cpu_offload
             else:
                    raise ImportError("""Please install accelerate via `pip install accelerate`"""   )

             __lowerCamelCase   =						torch.device(F'cuda:{gpu_id}'   )

             __lowerCamelCase   =						[
                 self.unet,
                 self.movq,
             ]
             for cpu_offloaded_model in models:
                    if cpu_offloaded_model is not None:
                           cpu_offload(UpperCamelCase_    ,       UpperCamelCase_   )
      def 			lowerCAmelCase__						(				self: List[str]    ,       UpperCamelCase_: Optional[int]=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."""   )

             __lowerCamelCase   =						torch.device(F'cuda:{gpu_id}'   )

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

             __lowerCamelCase   =						None
             for cpu_offloaded_model in [self.unet, self.movq]:
                    __lowerCamelCase,   __lowerCamelCase   =						cpu_offload_with_hook(UpperCamelCase_    ,       UpperCamelCase_    ,       prev_module_hook=UpperCamelCase_   )

             # We'll offload the last model manually.
             __lowerCamelCase   =						hook
      @property
      # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
      def 			lowerCAmelCase__						(				self: int   ):
             if not hasattr(self.unet    ,       """_hf_hook"""   ):
                    return self.device
             for module in self.unet.modules():
                    if (
                        hasattr(UpperCamelCase_    ,       """_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(UpperCamelCase_   )
      def __call__(				self: Tuple    ,       UpperCamelCase_: Union[torch.FloatTensor, List[torch.FloatTensor]]    ,       UpperCamelCase_: Union[torch.FloatTensor, List[torch.FloatTensor]]    ,       UpperCamelCase_: torch.FloatTensor    ,       UpperCamelCase_: int = 5_12    ,       UpperCamelCase_: int = 5_12    ,       UpperCamelCase_: int = 1_00    ,       UpperCamelCase_: float = 4.0    ,       UpperCamelCase_: int = 1    ,       UpperCamelCase_: Optional[Union[torch.Generator, List[torch.Generator]]] = None    ,       UpperCamelCase_: Optional[torch.FloatTensor] = None    ,       UpperCamelCase_: Optional[str] = "pil"    ,       UpperCamelCase_: bool = True    ,       ):
             __lowerCamelCase   =						self._execution_device

             __lowerCamelCase   =						guidance_scale > 1.0

             if isinstance(UpperCamelCase_    ,       UpperCamelCase_   ):
                    __lowerCamelCase   =						torch.cat(UpperCamelCase_    ,       dim=0   )
             if isinstance(UpperCamelCase_    ,       UpperCamelCase_   ):
                    __lowerCamelCase   =						torch.cat(UpperCamelCase_    ,       dim=0   )
             if isinstance(UpperCamelCase_    ,       UpperCamelCase_   ):
                    __lowerCamelCase   =						torch.cat(UpperCamelCase_    ,       dim=0   )

             __lowerCamelCase   =						image_embeds.shape[0] * num_images_per_prompt

             if do_classifier_free_guidance:
                    __lowerCamelCase   =						image_embeds.repeat_interleave(UpperCamelCase_    ,       dim=0   )
                    __lowerCamelCase   =						negative_image_embeds.repeat_interleave(UpperCamelCase_    ,       dim=0   )
                    __lowerCamelCase   =						hint.repeat_interleave(UpperCamelCase_    ,       dim=0   )

             __lowerCamelCase   =						torch.cat([negative_image_embeds, image_embeds]    ,       dim=0   ).to(dtype=self.unet.dtype    ,       device=UpperCamelCase_   )
             __lowerCamelCase   =						torch.cat([hint, hint]    ,       dim=0   ).to(dtype=self.unet.dtype    ,       device=UpperCamelCase_   )
             self.scheduler.set_timesteps(UpperCamelCase_    ,       device=UpperCamelCase_   )
             __lowerCamelCase   =						self.scheduler.timesteps

             __lowerCamelCase   =						self.movq.config.latent_channels

             __lowerCamelCase,   __lowerCamelCase   =						downscale_height_and_width(UpperCamelCase_    ,       UpperCamelCase_    ,       self.movq_scale_factor   )

             # create initial latent
             __lowerCamelCase   =						self.prepare_latents(
                 (batch_size, num_channels_latents, height, width)    ,       image_embeds.dtype    ,       UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_    ,       self.scheduler    ,       )

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

                    __lowerCamelCase   =						{"""image_embeds""": image_embeds, """hint""": hint}
                    __lowerCamelCase   =						self.unet(
                        sample=UpperCamelCase_    ,       timestep=UpperCamelCase_    ,       encoder_hidden_states=UpperCamelCase_    ,       added_cond_kwargs=UpperCamelCase_    ,       return_dict=UpperCamelCase_    ,       )[0]

                    if do_classifier_free_guidance:
                           __lowerCamelCase,   __lowerCamelCase   =						noise_pred.split(latents.shape[1]    ,       dim=1   )
                           __lowerCamelCase,   __lowerCamelCase   =						noise_pred.chunk(2   )
                           __lowerCamelCase,   __lowerCamelCase   =						variance_pred.chunk(2   )
                           __lowerCamelCase   =						noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
                           __lowerCamelCase   =						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"]
                    ):
                           __lowerCamelCase,   __lowerCamelCase   =						noise_pred.split(latents.shape[1]    ,       dim=1   )

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

             if output_type == "pil":
                    __lowerCamelCase   =						self.numpy_to_pil(UpperCamelCase_   )

             if not return_dict:
                    return (image,)

             return ImagePipelineOutput(images=UpperCamelCase_   )

