






'''simple docstring'''







import colorsys
import io

import cva
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import torch
from matplotlib.backends.backend_agg import FigureCanvasAgg

from utils import img_tensorize


__A      :       List[Any]      =	1_0_0_0






class 					a__    :
     '''simple docstring'''







     def __init__(self    :	int				,				lowercase__    :	Union[str, Any]				,				lowercase__    :	List[Any]=1.2				,				lowercase__    :	Dict="g"				,				lowercase__    :	str=0.5				,				lowercase__    :	Tuple="-"				,				lowercase__    :	Optional[Any]="test_out.jpg"				,				lowercase__    :	Optional[Any]=True				,				lowercase__    :	str=False				,				lowercase__    :	List[str]=None				,				lowercase__    :	Dict=None				,				lowercase__    :	List[Any]=0.7				,				)  ->       Union[str, Any]:
           if isinstance(lowercase__				,				torch.Tensor					):
                 __A		   =      img.numpy().astype("np.uint8"					)
           if isinstance(lowercase__				,				lowercase__					):
                 __A		   =      img_tensorize(lowercase__					)
           assert isinstance(lowercase__				,				np.ndarray					)

           __A   ,				__A		   =      img.shape[1], img.shape[0]
           __A		   =      mplfigure.Figure(frameon=lowercase__					)
           __A		   =      fig.get_dpi()
           __A		   =      (width * scale + 1e-2) / dpi
           __A		   =      (height * scale + 1e-2) / dpi
           fig.set_size_inches(lowercase__				,				lowercase__					)
           __A		   =      fig.add_axes([0.0, 0.0, 1.0, 1.0]					)
           ax.axis("off"					)
           ax.set_xlim(0.0				,				lowercase__					)
           ax.set_ylim(lowercase__					)

           __A		   =      saveas
           __A		   =      rgb
           __A		   =      pynb
           __A		   =      img
           __A		   =      edgecolor
           __A		   =      0.5
           __A		   =      linestyle
           __A		   =      int(np.sqrt(min(lowercase__				,				lowercase__					)					) * scale // 3					)
           __A		   =      width
           __A		   =      height
           __A		   =      scale
           __A		   =      fig
           __A		   =      ax
           __A		   =      pad
           __A		   =      idaobj
           __A		   =      idaattr
           __A		   =      FigureCanvasAgg(lowercase__					)






     def     _UpperCamelCase   (self    :	Any				,				lowercase__    :	int				,				lowercase__    :	Any=None					)  ->       List[Any]:
           if color is None:
                 __A		   =      self.edgecolor
           ((__A)   ,				(__A)   ,				(__A)   ,				(__A))		   =      box
           __A		   =      xa - xa
           __A		   =      ya - ya
           self.ax.add_patch(
               mpl.patches.Rectangle(
                   (xa, ya)				,				lowercase__				,				lowercase__				,				fill=lowercase__				,				edgecolor=lowercase__				,				linewidth=self.font_size // 3				,				alpha=self.alpha				,				linestyle=self.linestyle				,				)					)






     def     _UpperCamelCase   (self    :	int				,				lowercase__    :	Union[str, Any]				,				lowercase__    :	List[Any]=None				,				lowercase__    :	Optional[int]=None				,				lowercase__    :	List[str]=None				,				lowercase__    :	Dict=None					)  ->       Any:
           if len(boxes.shape					) > 2:
                 __A		   =      boxes[0]
           if len(obj_ids.shape					) > 1:
                 __A		   =      obj_ids[0]
           if len(obj_scores.shape					) > 1:
                 __A		   =      obj_scores[0]
           if len(attr_ids.shape					) > 1:
                 __A		   =      attr_ids[0]
           if len(attr_scores.shape					) > 1:
                 __A		   =      attr_scores[0]
           if isinstance(lowercase__				,				torch.Tensor					):
                 __A		   =      boxes.numpy()
           if isinstance(lowercase__				,				lowercase__					):
                 __A		   =      np.array(lowercase__					)
           assert isinstance(lowercase__				,				np.ndarray					)
           __A		   =      np.prod(boxes[:, 2:] - boxes[:, :2]				,				axis=1					)
           __A		   =      np.argsort(-areas					).tolist()
           __A		   =      boxes[sorted_idxs] if boxes is not None else None
           __A		   =      obj_ids[sorted_idxs] if obj_ids is not None else None
           __A		   =      obj_scores[sorted_idxs] if obj_scores is not None else None
           __A		   =      attr_ids[sorted_idxs] if attr_ids is not None else None
           __A		   =      attr_scores[sorted_idxs] if attr_scores is not None else None

           __A		   =      [self._random_color(maximum=1					) for _ in range(len(lowercase__					)					)]
           __A		   =      [assigned_colors[idx] for idx in sorted_idxs]
           if obj_ids is not None:
                 __A		   =      self._create_text_labels_attr(lowercase__				,				lowercase__				,				lowercase__				,				lowercase__					)
                 for i in range(len(lowercase__					)					):
                       __A		   =      assigned_colors[i]
                       self.add_box(boxes[i]				,				lowercase__					)
                       self.draw_labels(labels[i]				,				boxes[i]				,				lowercase__					)






     def     _UpperCamelCase   (self    :	Optional[Any]				,				lowercase__    :	Any				,				lowercase__    :	str				,				lowercase__    :	List[Any]					)  ->       Optional[int]:
           __A   ,				__A   ,				__A   ,				__A		   =      box
           __A		   =      (xa, ya)
           __A		   =      (ya - ya) * (xa - xa)
           __A		   =      _SMALL_OBJ * self.scale
           if instance_area < small or ya - ya < 40 * self.scale:
                 if ya >= self.height - 5:
                       __A		   =      (xa, ya)
                 else:
                       __A		   =      (xa, ya)

           __A		   =      (ya - ya) / np.sqrt(self.height * self.width					)
           __A		   =      self._change_color_brightness(lowercase__				,				brightness_factor=0.7					)
           __A		   =      np.clip((height_ratio - 0.02) / 0.08 + 1				,				1.2				,				2					)
           font_size *= 0.75 * self.font_size

           self.draw_text(
               text=lowercase__				,				position=lowercase__				,				color=lowercase__				,				)






     def     _UpperCamelCase   (self    :	Tuple				,				lowercase__    :	Dict				,				lowercase__    :	int				,				lowercase__    :	List[str]="g"				,				lowercase__    :	Any="left"				,				)  ->       str:
           __A		   =      0
           __A		   =      self.font_size
           __A		   =      np.maximum(list(mplc.to_rgb(lowercase__					)					)				,				0.2					)
           __A		   =      max(0.8				,				np.max(lowercase__					)					)
           __A		   =      {
               "facecolor": "black",
               "alpha": self.alpha,
               "pad": self.pad,
               "edgecolor": "none",
           }
           __A   ,				__A		   =      position
           self.ax.text(
               lowercase__				,				lowercase__				,				lowercase__				,				size=font_size * self.scale				,				family="sans-serif"				,				bbox=lowercase__				,				verticalalignment="top"				,				horizontalalignment=lowercase__				,				color=lowercase__				,				zorder=10				,				rotation=lowercase__				,				)






     def     _UpperCamelCase   (self    :	int				,				lowercase__    :	Any=None					)  ->       Dict:
           if saveas is None:
                 __A		   =      self.saveas
           if saveas.lower().endswith(".jpg"					) or saveas.lower().endswith(".png"					):
                 cva.imwrite(
                     lowercase__				,				self._get_buffer()[:, :, ::-1]				,				)
           else:
                 self.fig.savefig(lowercase__					)






     def     _UpperCamelCase   (self    :	str				,				lowercase__    :	List[Any]				,				lowercase__    :	Any				,				lowercase__    :	Tuple				,				lowercase__    :	Union[str, Any]					)  ->       str:
           __A		   =      [self.idaobj[i] for i in classes]
           __A		   =      [self.idaattr[i] for i in attr_classes]
           __A		   =      [
               f"{label} {score:.2f} {attr} {attr_score:.2f}"
               for label, score, attr, attr_score in zip(lowercase__				,				lowercase__				,				lowercase__				,				lowercase__					)
           ]
           return labels






     def     _UpperCamelCase   (self    :	Optional[Any]				,				lowercase__    :	Optional[int]				,				lowercase__    :	Union[str, Any]					)  ->       Optional[Any]:
           __A		   =      [self.idaobj[i] for i in classes]
           if scores is not None:
                 if labels is None:
                       __A		   =      ["{:.0f}%".format(s * 100					) for s in scores]
                 else:
                       __A		   =      ["{} {:.0f}%".format(lowercase__				,				s * 100					) for li, s in zip(lowercase__				,				lowercase__					)]
           return labels






     def     _UpperCamelCase   (self    :	int				,				lowercase__    :	Dict=255					)  ->       int:
           __A		   =      np.random.randint(0				,				len(_COLORS					)					)
           __A		   =      _COLORS[idx] * maximum
           if not self.rgb:
                 __A		   =      ret[::-1]
           return ret






     def     _UpperCamelCase   (self    :	str					)  ->       List[Any]:
           if not self.pynb:
                 __A   ,				__A		   =      self.canvas.print_to_buffer()
                 if (width, height) != (self.width, self.height):
                       __A		   =      cva.resize(self.img				,				(width, height)					)
                 else:
                       __A		   =      self.img
           else:
                 __A		   =      io.BytesIO()  # works for cairo backend
                 self.canvas.print_rgba(lowercase__					)
                 __A   ,				__A		   =      self.width, self.height
                 __A		   =      buf.getvalue()
                 __A		   =      self.img

           __A		   =      np.frombuffer(lowercase__				,				dtype="uint8"					)
           __A		   =      buffer.reshape(lowercase__				,				lowercase__				,				4					)
           __A   ,				__A		   =      np.split(lowercase__				,				[3]				,				axis=2					)

           try:
                 import numexpr as ne  # fuse them with numexpr

                 __A		   =      ne.evaluate("img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"					)
           except ImportError:
                 __A		   =      alpha.astype("float32"					) / 2_55.0
                 __A		   =      img * (1 - alpha) + rgb * alpha

           return visualized_image.astype("uint8"					)






     def     _UpperCamelCase   (self    :	List[Any]				,				lowercase__    :	str				,				lowercase__    :	str					)  ->       Optional[int]:
           assert brightness_factor >= -1.0 and brightness_factor <= 1.0
           __A		   =      mplc.to_rgb(lowercase__					)
           __A		   =      colorsys.rgb_to_hls(*mplc.to_rgb(lowercase__					)					)
           __A		   =      polygon_color[1] + (brightness_factor * polygon_color[1])
           __A		   =      0.0 if modified_lightness < 0.0 else modified_lightness
           __A		   =      1.0 if modified_lightness > 1.0 else modified_lightness
           __A		   =      colorsys.hls_to_rgb(polygon_color[0]				,				lowercase__				,				polygon_color[2]					)
           return modified_color







__A      :       Optional[Any]      =	(
    np.array(
        [
            0.000,
            0.447,
            0.741,
            0.850,
            0.325,
            0.098,
            0.929,
            0.694,
            0.125,
            0.494,
            0.184,
            0.556,
            0.466,
            0.674,
            0.188,
            0.301,
            0.745,
            0.933,
            0.635,
            0.078,
            0.184,
            0.300,
            0.300,
            0.300,
            0.600,
            0.600,
            0.600,
            1.000,
            0.000,
            0.000,
            1.000,
            0.500,
            0.000,
            0.749,
            0.749,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.333,
            0.333,
            0.000,
            0.333,
            0.667,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            0.333,
            0.000,
            0.667,
            0.667,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            1.000,
            0.000,
            0.000,
            0.333,
            0.500,
            0.000,
            0.667,
            0.500,
            0.000,
            1.000,
            0.500,
            0.333,
            0.000,
            0.500,
            0.333,
            0.333,
            0.500,
            0.333,
            0.667,
            0.500,
            0.333,
            1.000,
            0.500,
            0.667,
            0.000,
            0.500,
            0.667,
            0.333,
            0.500,
            0.667,
            0.667,
            0.500,
            0.667,
            1.000,
            0.500,
            1.000,
            0.000,
            0.500,
            1.000,
            0.333,
            0.500,
            1.000,
            0.667,
            0.500,
            1.000,
            1.000,
            0.500,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.333,
            0.333,
            1.000,
            0.333,
            0.667,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.667,
            0.333,
            1.000,
            0.667,
            0.667,
            1.000,
            0.667,
            1.000,
            1.000,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            1.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.143,
            0.143,
            0.143,
            0.857,
            0.857,
            0.857,
            1.000,
            1.000,
            1.000,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)










'''simple docstring'''







import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import PriorTransformer, UnCLIPPipeline, UnCLIPScheduler, UNetaDConditionModel, UNetaDModel
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class 					a__    (			lowerCamelCase ,						unittest.TestCase						):
     '''simple docstring'''







     _snake_case             =  UnCLIPPipeline
     _snake_case             =  TEXT_TO_IMAGE_PARAMS - {
         'negative_prompt',
         'height',
         'width',
         'negative_prompt_embeds',
         'guidance_scale',
         'prompt_embeds',
         'cross_attention_kwargs',
     }
     _snake_case             =  TEXT_TO_IMAGE_BATCH_PARAMS
     _snake_case             =  [
         'generator',
         'return_dict',
         'prior_num_inference_steps',
         'decoder_num_inference_steps',
         'super_res_num_inference_steps',
     ]
     _snake_case             =  False






     @property
     def     _UpperCamelCase   (self    :	Dict					)  ->       Union[str, Any]:
           return 32






     @property
     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       Union[str, Any]:
           return 32






     @property
     def     _UpperCamelCase   (self    :	str					)  ->       Dict:
           return self.time_input_dim






     @property
     def     _UpperCamelCase   (self    :	List[Any]					)  ->       int:
           return self.time_input_dim * 4






     @property
     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       List[str]:
           return 100






     @property
     def     _UpperCamelCase   (self    :	Tuple					)  ->       Optional[Any]:
           __A		   =      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"					)
           return tokenizer






     @property
     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       Tuple:
           torch.manual_seed(0					)
           __A		   =      CLIPTextConfig(
               bos_token_id=0				,				eos_token_id=2				,				hidden_size=self.text_embedder_hidden_size				,				projection_dim=self.text_embedder_hidden_size				,				intermediate_size=37				,				layer_norm_eps=1e-05				,				num_attention_heads=4				,				num_hidden_layers=5				,				pad_token_id=1				,				vocab_size=1000				,				)
           return CLIPTextModelWithProjection(lowercase__					)






     @property
     def     _UpperCamelCase   (self    :	int					)  ->       Optional[Any]:
           torch.manual_seed(0					)

           __A		   =      {
               "num_attention_heads": 2,
               "attention_head_dim": 12,
               "embedding_dim": self.text_embedder_hidden_size,
               "num_layers": 1,
           }

           __A		   =      PriorTransformer(**lowercase__					)
           return model






     @property
     def     _UpperCamelCase   (self    :	Union[str, Any]					)  ->       Union[str, Any]:
           torch.manual_seed(0					)

           __A		   =      {
               "clip_embeddings_dim": self.text_embedder_hidden_size,
               "time_embed_dim": self.time_embed_dim,
               "cross_attention_dim": self.cross_attention_dim,
           }

           __A		   =      UnCLIPTextProjModel(**lowercase__					)
           return model






     @property
     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       Tuple:
           torch.manual_seed(0					)

           __A		   =      {
               "sample_size": 32,
               # RGB in channels
               "in_channels": 3,
               # Out channels is double in channels because predicts mean and variance
               "out_channels": 6,
               "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
               "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
               "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
               "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
               "layers_per_block": 1,
               "cross_attention_dim": self.cross_attention_dim,
               "attention_head_dim": 4,
               "resnet_time_scale_shift": "scale_shift",
               "class_embed_type": "identity",
           }

           __A		   =      UNetaDConditionModel(**lowercase__					)
           return model






     @property
     def     _UpperCamelCase   (self    :	Any					)  ->       str:
           return {
               "sample_size": 64,
               "layers_per_block": 1,
               "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
               "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
               "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
               "in_channels": 6,
               "out_channels": 3,
           }






     @property
     def     _UpperCamelCase   (self    :	List[str]					)  ->       List[str]:
           torch.manual_seed(0					)

           __A		   =      UNetaDModel(**self.dummy_super_res_kwargs					)
           return model






     @property
     def     _UpperCamelCase   (self    :	str					)  ->       Optional[Any]:
           # seeded differently to get different unet than `self.dummy_super_res_first`
           torch.manual_seed(1					)

           __A		   =      UNetaDModel(**self.dummy_super_res_kwargs					)
           return model






     def     _UpperCamelCase   (self    :	Any					)  ->       Any:
           __A		   =      self.dummy_prior
           __A		   =      self.dummy_decoder
           __A		   =      self.dummy_text_proj
           __A		   =      self.dummy_text_encoder
           __A		   =      self.dummy_tokenizer
           __A		   =      self.dummy_super_res_first
           __A		   =      self.dummy_super_res_last

           __A		   =      UnCLIPScheduler(
               variance_type="fixed_small_log"				,				prediction_type="sample"				,				num_train_timesteps=1000				,				clip_sample_range=5.0				,				)

           __A		   =      UnCLIPScheduler(
               variance_type="learned_range"				,				prediction_type="epsilon"				,				num_train_timesteps=1000				,				)

           __A		   =      UnCLIPScheduler(
               variance_type="fixed_small_log"				,				prediction_type="epsilon"				,				num_train_timesteps=1000				,				)

           __A		   =      {
               "prior": prior,
               "decoder": decoder,
               "text_proj": text_proj,
               "text_encoder": text_encoder,
               "tokenizer": tokenizer,
               "super_res_first": super_res_first,
               "super_res_last": super_res_last,
               "prior_scheduler": prior_scheduler,
               "decoder_scheduler": decoder_scheduler,
               "super_res_scheduler": super_res_scheduler,
           }

           return components






     def     _UpperCamelCase   (self    :	int				,				lowercase__    :	Union[str, Any]				,				lowercase__    :	Any=0					)  ->       str:
           if str(lowercase__					).startswith("mps"					):
                 __A		   =      torch.manual_seed(lowercase__					)
           else:
                 __A		   =      torch.Generator(device=lowercase__					).manual_seed(lowercase__					)
           __A		   =      {
               "prompt": "horse",
               "generator": generator,
               "prior_num_inference_steps": 2,
               "decoder_num_inference_steps": 2,
               "super_res_num_inference_steps": 2,
               "output_type": "numpy",
           }
           return inputs






     def     _UpperCamelCase   (self    :	str					)  ->       Tuple:
           __A		   =      "cpu"

           __A		   =      self.get_dummy_components()

           __A		   =      self.pipeline_class(**lowercase__					)
           __A		   =      pipe.to(lowercase__					)

           pipe.set_progress_bar_config(disable=lowercase__					)

           __A		   =      pipe(**self.get_dummy_inputs(lowercase__					)					)
           __A		   =      output.images

           __A		   =      pipe(
               **self.get_dummy_inputs(lowercase__					)				,				return_dict=lowercase__				,				)[0]

           __A		   =      image[0, -3:, -3:, -1]
           __A		   =      image_from_tuple[0, -3:, -3:, -1]

           assert image.shape == (1, 64, 64, 3)

           __A		   =      np.array(
               [
                   0.99_97,
                   0.99_88,
                   0.00_28,
                   0.99_97,
                   0.99_84,
                   0.99_65,
                   0.00_29,
                   0.99_86,
                   0.00_25,
               ]					)

           assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
           assert np.abs(image_from_tuple_slice.flatten() - expected_slice					).max() < 1e-2






     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       Optional[Any]:
           __A		   =      torch.device("cpu"					)






           class 					a__    :
                '''simple docstring'''







                _snake_case             =  1







           __A		   =      self.get_dummy_components()

           __A		   =      self.pipeline_class(**lowercase__					)
           __A		   =      pipe.to(lowercase__					)

           __A		   =      components["prior"]
           __A		   =      components["decoder"]
           __A		   =      components["super_res_first"]
           __A		   =      components["tokenizer"]
           __A		   =      components["text_encoder"]

           __A		   =      torch.Generator(device=lowercase__					).manual_seed(0					)
           __A		   =      prior.dtype
           __A		   =      1

           __A		   =      (batch_size, prior.config.embedding_dim)
           __A		   =      pipe.prepare_latents(
               lowercase__				,				dtype=lowercase__				,				device=lowercase__				,				generator=lowercase__				,				latents=lowercase__				,				scheduler=DummyScheduler()					)
           __A		   =      (batch_size, decoder.config.in_channels, decoder.config.sample_size, decoder.config.sample_size)
           __A		   =      pipe.prepare_latents(
               lowercase__				,				dtype=lowercase__				,				device=lowercase__				,				generator=lowercase__				,				latents=lowercase__				,				scheduler=DummyScheduler()					)

           __A		   =      (
               batch_size,
               super_res_first.config.in_channels // 2,
               super_res_first.config.sample_size,
               super_res_first.config.sample_size,
           )
           __A		   =      pipe.prepare_latents(
               lowercase__				,				dtype=lowercase__				,				device=lowercase__				,				generator=lowercase__				,				latents=lowercase__				,				scheduler=DummyScheduler()					)

           pipe.set_progress_bar_config(disable=lowercase__					)

           __A		   =      "this is a prompt example"

           __A		   =      torch.Generator(device=lowercase__					).manual_seed(0					)
           __A		   =      pipe(
               [prompt]				,				generator=lowercase__				,				prior_num_inference_steps=2				,				decoder_num_inference_steps=2				,				super_res_num_inference_steps=2				,				prior_latents=lowercase__				,				decoder_latents=lowercase__				,				super_res_latents=lowercase__				,				output_type="np"				,				)
           __A		   =      output.images

           __A		   =      tokenizer(
               lowercase__				,				padding="max_length"				,				max_length=tokenizer.model_max_length				,				return_tensors="pt"				,				)
           __A		   =      text_encoder(text_inputs.input_ids					)
           __A		   =      text_inputs.attention_mask

           __A		   =      torch.Generator(device=lowercase__					).manual_seed(0					)
           __A		   =      pipe(
               generator=lowercase__				,				prior_num_inference_steps=2				,				decoder_num_inference_steps=2				,				super_res_num_inference_steps=2				,				prior_latents=lowercase__				,				decoder_latents=lowercase__				,				super_res_latents=lowercase__				,				text_model_output=lowercase__				,				text_attention_mask=lowercase__				,				output_type="np"				,				)[0]

           # make sure passing text embeddings manually is identical
           assert np.abs(image - image_from_text					).max() < 1e-4






     @skip_mps
     def     _UpperCamelCase   (self    :	str					)  ->       str:
           __A		   =      torch_device == "cpu"

           self._test_attention_slicing_forward_pass(test_max_difference=lowercase__				,				expected_max_diff=0.01					)






     @skip_mps
     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       str:
           __A		   =      torch_device == "cpu"
           __A		   =      True
           __A		   =      [
               "prior_num_inference_steps",
               "decoder_num_inference_steps",
               "super_res_num_inference_steps",
           ]

           self._test_inference_batch_single_identical(
               test_max_difference=lowercase__				,				relax_max_difference=lowercase__				,				additional_params_copy_to_batched_inputs=lowercase__				,				)






     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       Optional[int]:
           __A		   =      [
               "prior_num_inference_steps",
               "decoder_num_inference_steps",
               "super_res_num_inference_steps",
           ]

           if torch_device == "mps":
                 # TODO: MPS errors with larger batch sizes
                 __A		   =      [2, 3]
                 self._test_inference_batch_consistent(
                     batch_sizes=lowercase__				,				additional_params_copy_to_batched_inputs=lowercase__				,				)
           else:
                 self._test_inference_batch_consistent(
                     additional_params_copy_to_batched_inputs=lowercase__					)






     @skip_mps
     def     _UpperCamelCase   (self    :	int					)  ->       int:
           return super().test_dict_tuple_outputs_equivalent()






     @skip_mps
     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       int:
           return super().test_save_load_local()






     @skip_mps
     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       Any:
           return super().test_save_load_optional_components()







@nightly
class 					a__    (			unittest.TestCase						):
     '''simple docstring'''







     def     _UpperCamelCase   (self    :	int					)  ->       int:
           # clean up the VRAM after each test
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()






     def     _UpperCamelCase   (self    :	Union[str, Any]					)  ->       Tuple:
           __A		   =      load_numpy(
               "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
               "/unclip/karlo_v1_alpha_horse_cpu.npy"					)

           __A		   =      UnCLIPPipeline.from_pretrained("kakaobrain/karlo-v1-alpha"					)
           pipeline.set_progress_bar_config(disable=lowercase__					)

           __A		   =      torch.manual_seed(0					)
           __A		   =      pipeline(
               "horse"				,				num_images_per_prompt=1				,				generator=lowercase__				,				output_type="np"				,				)

           __A		   =      output.images[0]

           assert image.shape == (256, 256, 3)
           assert np.abs(expected_image - image					).max() < 1e-1







@slow
@require_torch_gpu
class 					a__    (			unittest.TestCase						):
     '''simple docstring'''







     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       List[str]:
           # clean up the VRAM after each test
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()






     def     _UpperCamelCase   (self    :	List[Any]					)  ->       Dict:
           __A		   =      load_numpy(
               "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
               "/unclip/karlo_v1_alpha_horse_fp16.npy"					)

           __A		   =      UnCLIPPipeline.from_pretrained("kakaobrain/karlo-v1-alpha"				,				torch_dtype=torch.floataa					)
           __A		   =      pipeline.to(lowercase__					)
           pipeline.set_progress_bar_config(disable=lowercase__					)

           __A		   =      torch.Generator(device="cpu"					).manual_seed(0					)
           __A		   =      pipeline(
               "horse"				,				generator=lowercase__				,				output_type="np"				,				)

           __A		   =      output.images[0]

           assert image.shape == (256, 256, 3)

           assert_mean_pixel_difference(lowercase__				,				lowercase__					)






     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       Any:
           torch.cuda.empty_cache()
           torch.cuda.reset_max_memory_allocated()
           torch.cuda.reset_peak_memory_stats()

           __A		   =      UnCLIPPipeline.from_pretrained("kakaobrain/karlo-v1-alpha"				,				torch_dtype=torch.floataa					)
           __A		   =      pipe.to(lowercase__					)
           pipe.set_progress_bar_config(disable=lowercase__					)
           pipe.enable_attention_slicing()
           pipe.enable_sequential_cpu_offload()

           __A		   =      pipe(
               "horse"				,				num_images_per_prompt=1				,				prior_num_inference_steps=2				,				decoder_num_inference_steps=2				,				super_res_num_inference_steps=2				,				output_type="np"				,				)

           __A		   =      torch.cuda.max_memory_allocated()
           # make sure that less than 7 GB is allocated
           assert mem_bytes < 7 * 10**9


