
"""simple docstring"""
import collections
import gzip
import os
import urllib

import numpy
from tensorflow.python.framework import dtypes, random_seed
from tensorflow.python.platform import gfile
from tensorflow.python.util.deprecation import deprecated

lowercase_       :						Dict     					=	collections.namedtuple('''_Datasets''', ['''train''', '''validation''', '''test'''])

# CVDF mirror of http://yann.lecun.com/exdb/mnist/
lowercase_       :						Any     					=	'''https://storage.googleapis.com/cvdf-datasets/mnist/'''





def    _lowerCAmelCase    (     lowerCamelCase__							:							List[str]				)  ->    List[Any]:
  _SCREAMING_SNAKE_CASE   :				List[str]							    = numpy.dtype(numpy.uintaa				).newbyteorder(">"				)
  return numpy.frombuffer(bytestream.read(4				),						dtype=lowerCamelCase__				)[0]





@deprecated(lowerCamelCase__,						"Please use tf.data to implement this functionality."				)
def    _lowerCAmelCase    (     lowerCamelCase__							:							List[Any]				)  ->    Dict:
  print("Extracting",						f.name				)
  with gzip.GzipFile(fileobj=lowerCamelCase__				) as bytestream:
    _SCREAMING_SNAKE_CASE   :				Any							    = _readaa(lowerCamelCase__				)
    if magic != 2_0_5_1:
      raise ValueError(
          "Invalid magic number %d in MNIST image file: %s" % (magic, f.name)				)
    _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = _readaa(lowerCamelCase__				)
    _SCREAMING_SNAKE_CASE   :				List[Any]							    = _readaa(lowerCamelCase__				)
    _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = _readaa(lowerCamelCase__				)
    _SCREAMING_SNAKE_CASE   :				Any							    = bytestream.read(rows * cols * num_images				)
    _SCREAMING_SNAKE_CASE   :				Any							    = numpy.frombuffer(lowerCamelCase__,						dtype=numpy.uinta				)
    _SCREAMING_SNAKE_CASE   :				Any							    = data.reshape(lowerCamelCase__,						lowerCamelCase__,						lowerCamelCase__,						1				)
    return data





@deprecated(lowerCamelCase__,						"Please use tf.one_hot on tensors."				)
def    _lowerCAmelCase    (     lowerCamelCase__							:							Any,						lowerCamelCase__							:							Optional[Any]				)  ->    Optional[Any]:
  _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = labels_dense.shape[0]
  _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = numpy.arange(lowerCamelCase__				) * num_classes
  _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = numpy.zeros((num_labels, num_classes)				)
  _SCREAMING_SNAKE_CASE   :				str							    = 1
  return labels_one_hot





@deprecated(lowerCamelCase__,						"Please use tf.data to implement this functionality."				)
def    _lowerCAmelCase    (     lowerCamelCase__							:							int,						lowerCamelCase__							:							Union[str, Any]=False,						lowerCamelCase__							:							Optional[Any]=1_0				)  ->    Dict:
  print("Extracting",						f.name				)
  with gzip.GzipFile(fileobj=lowerCamelCase__				) as bytestream:
    _SCREAMING_SNAKE_CASE   :				Optional[int]							    = _readaa(lowerCamelCase__				)
    if magic != 2_0_4_9:
      raise ValueError(
          "Invalid magic number %d in MNIST label file: %s" % (magic, f.name)				)
    _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = _readaa(lowerCamelCase__				)
    _SCREAMING_SNAKE_CASE   :				Optional[int]							    = bytestream.read(lowerCamelCase__				)
    _SCREAMING_SNAKE_CASE   :				Dict							    = numpy.frombuffer(lowerCamelCase__,						dtype=numpy.uinta				)
    if one_hot:
      return _dense_to_one_hot(lowerCamelCase__,						lowerCamelCase__				)
    return labels
class 			UpperCamelCase      :
     @deprecated(
         snake_case__  ,     "Please use alternatives such as official/mnist/_DataSet.py"
         " from tensorflow/models."  ,     )
     def __init__(     self  ,     snake_case__  ,     snake_case__  ,     snake_case__=False  ,     snake_case__=False  ,     snake_case__=dtypes.floataa  ,     snake_case__=True  ,     snake_case__=None  ,     ):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				int							    = random_seed.get_seed(snake_case__				)
       # If op level seed is not set, use whatever graph level seed is returned
       numpy.random.seed(seeda if seed is None else seeda				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = dtypes.as_dtype(snake_case__				).base_dtype
       if dtype not in (dtypes.uinta, dtypes.floataa):
         raise TypeError("Invalid image dtype %r, expected uint8 or float32" % dtype				)
       if fake_data:
         _SCREAMING_SNAKE_CASE   :				str							    = 10000
         _SCREAMING_SNAKE_CASE   :				List[str]							    = one_hot
       else:
         assert (
             images.shape[0] == labels.shape[0]
         ), F'''images.shape: {images.shape} labels.shape: {labels.shape}'''
         _SCREAMING_SNAKE_CASE   :				Tuple							    = images.shape[0]

         # Convert shape from [num examples, rows, columns, depth]
         # to [num examples, rows*columns] (assuming depth == 1)
         if reshape:
           assert images.shape[3] == 1
           _SCREAMING_SNAKE_CASE   :				Dict							    = images.reshape(
               images.shape[0]  ,     images.shape[1] * images.shape[2]				)
         if dtype == dtypes.floataa:
           # Convert from [0, 255] -> [0.0, 1.0].
           _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = images.astype(numpy.floataa				)
           _SCREAMING_SNAKE_CASE   :				int							    = numpy.multiply(snake_case__  ,     1.0 / 255.0				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = images
       _SCREAMING_SNAKE_CASE   :				Any							    = labels
       _SCREAMING_SNAKE_CASE   :				Any							    = 0
       _SCREAMING_SNAKE_CASE   :				Any							    = 0
     @property
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       return self._images
     @property
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       return self._labels
     @property
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       return self._num_examples
     @property
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       return self._epochs_completed




     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__=False  ,     snake_case__=True				):




       """simple docstring"""


       if fake_data:
         _SCREAMING_SNAKE_CASE   :				Tuple							    = [1] * 784
         _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = [1] + [0] * 9 if self.one_hot else 0
         return (
             [fake_image for _ in range(snake_case__				)],
             [fake_label for _ in range(snake_case__				)],
         )
       _SCREAMING_SNAKE_CASE   :				Dict							    = self._index_in_epoch
       # Shuffle for the first epoch
       if self._epochs_completed == 0 and start == 0 and shuffle:
         _SCREAMING_SNAKE_CASE   :				Dict							    = numpy.arange(self._num_examples				)
         numpy.random.shuffle(snake_case__				)
         _SCREAMING_SNAKE_CASE   :				Dict							    = self.images[perma]
         _SCREAMING_SNAKE_CASE   :				Any							    = self.labels[perma]
       # Go to the next epoch
       if start + batch_size > self._num_examples:
         # Finished epoch
         self._epochs_completed += 1
         # Get the rest examples in this epoch
         _SCREAMING_SNAKE_CASE   :				Any							    = self._num_examples - start
         _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = self._images[start : self._num_examples]
         _SCREAMING_SNAKE_CASE   :				List[str]							    = self._labels[start : self._num_examples]
         # Shuffle the data
         if shuffle:
           _SCREAMING_SNAKE_CASE   :				Any							    = numpy.arange(self._num_examples				)
           numpy.random.shuffle(snake_case__				)
           _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = self.images[perm]
           _SCREAMING_SNAKE_CASE   :				List[str]							    = self.labels[perm]
         # Start next epoch
         _SCREAMING_SNAKE_CASE   :				List[Any]							    = 0
         _SCREAMING_SNAKE_CASE   :				Tuple							    = batch_size - rest_num_examples
         _SCREAMING_SNAKE_CASE   :				Tuple							    = self._index_in_epoch
         _SCREAMING_SNAKE_CASE   :				Optional[int]							    = self._images[start:end]
         _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = self._labels[start:end]
         return (
             numpy.concatenate((images_rest_part, images_new_part)  ,     axis=0				),
             numpy.concatenate((labels_rest_part, labels_new_part)  ,     axis=0				),
         )
       else:
         self._index_in_epoch += batch_size
         _SCREAMING_SNAKE_CASE   :				str							    = self._index_in_epoch
         return self._images[start:end], self._labels[start:end]





@deprecated(lowerCamelCase__,						"Please write your own downloading logic."				)
def    _lowerCAmelCase    (     lowerCamelCase__							:							int,						lowerCamelCase__							:							Optional[int],						lowerCamelCase__							:							List[str]				)  ->    Optional[int]:
  if not gfile.Exists(lowerCamelCase__				):
    gfile.MakeDirs(lowerCamelCase__				)
  _SCREAMING_SNAKE_CASE   :				str							    = os.path.join(lowerCamelCase__,						lowerCamelCase__				)
  if not gfile.Exists(lowerCamelCase__				):
    urllib.request.urlretrieve(lowerCamelCase__,						lowerCamelCase__				)  # noqa: S310
    with gfile.GFile(lowerCamelCase__				) as f:
      _SCREAMING_SNAKE_CASE   :				Optional[int]							    = f.size()
    print("Successfully downloaded",						lowerCamelCase__,						lowerCamelCase__,						"bytes."				)
  return filepath





@deprecated(
    lowerCamelCase__,						"Please use alternatives such as:" " tensorflow_datasets.load('mnist')"				)
def    _lowerCAmelCase    (     lowerCamelCase__							:							Tuple,						lowerCamelCase__							:							Optional[int]=False,						lowerCamelCase__							:							int=False,						lowerCamelCase__							:							Optional[int]=dtypes.floataa,						lowerCamelCase__							:							Optional[int]=True,						lowerCamelCase__							:							Dict=5_0_0_0,						lowerCamelCase__							:							Optional[int]=None,						lowerCamelCase__							:							Tuple=DEFAULT_SOURCE_URL,						)  ->    Tuple:
  if fake_data:

    def fake():
      return _DataSet(
          [],						[],						fake_data=lowerCamelCase__,						one_hot=lowerCamelCase__,						dtype=lowerCamelCase__,						seed=lowerCamelCase__				)

    _SCREAMING_SNAKE_CASE   :				List[str]							    = fake()
    _SCREAMING_SNAKE_CASE   :				Dict							    = fake()
    _SCREAMING_SNAKE_CASE   :				str							    = fake()
    return _Datasets(train=lowerCamelCase__,						validation=lowerCamelCase__,						test=lowerCamelCase__				)

  if not source_url:  # empty string check
    _SCREAMING_SNAKE_CASE   :				Tuple							    = DEFAULT_SOURCE_URL

  _SCREAMING_SNAKE_CASE   :				Any							    = "train-images-idx3-ubyte.gz"
  _SCREAMING_SNAKE_CASE   :				int							    = "train-labels-idx1-ubyte.gz"
  _SCREAMING_SNAKE_CASE   :				str							    = "t10k-images-idx3-ubyte.gz"
  _SCREAMING_SNAKE_CASE   :				Tuple							    = "t10k-labels-idx1-ubyte.gz"

  _SCREAMING_SNAKE_CASE   :				str							    = _maybe_download(
      lowerCamelCase__,						lowerCamelCase__,						source_url + train_images_file				)
  with gfile.Open(lowerCamelCase__,						"rb"				) as f:
    _SCREAMING_SNAKE_CASE   :				Dict							    = _extract_images(lowerCamelCase__				)

  _SCREAMING_SNAKE_CASE   :				List[str]							    = _maybe_download(
      lowerCamelCase__,						lowerCamelCase__,						source_url + train_labels_file				)
  with gfile.Open(lowerCamelCase__,						"rb"				) as f:
    _SCREAMING_SNAKE_CASE   :				Tuple							    = _extract_labels(lowerCamelCase__,						one_hot=lowerCamelCase__				)

  _SCREAMING_SNAKE_CASE   :				Any							    = _maybe_download(
      lowerCamelCase__,						lowerCamelCase__,						source_url + test_images_file				)
  with gfile.Open(lowerCamelCase__,						"rb"				) as f:
    _SCREAMING_SNAKE_CASE   :				Dict							    = _extract_images(lowerCamelCase__				)

  _SCREAMING_SNAKE_CASE   :				str							    = _maybe_download(
      lowerCamelCase__,						lowerCamelCase__,						source_url + test_labels_file				)
  with gfile.Open(lowerCamelCase__,						"rb"				) as f:
    _SCREAMING_SNAKE_CASE   :				Any							    = _extract_labels(lowerCamelCase__,						one_hot=lowerCamelCase__				)

  if not 0 <= validation_size <= len(lowerCamelCase__				):
    _SCREAMING_SNAKE_CASE   :				str							    = (
        "Validation size should be between 0 and "
        f'''{len(lowerCamelCase__				)}. Received: {validation_size}.'''
    )
    raise ValueError(lowerCamelCase__				)

  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = train_images[:validation_size]
  _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = train_labels[:validation_size]
  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = train_images[validation_size:]
  _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = train_labels[validation_size:]

  _SCREAMING_SNAKE_CASE   :				str							    = {"dtype": dtype, "reshape": reshape, "seed": seed}

  _SCREAMING_SNAKE_CASE   :				int							    = _DataSet(lowerCamelCase__,						lowerCamelCase__,						**lowerCamelCase__				)
  _SCREAMING_SNAKE_CASE   :				List[Any]							    = _DataSet(lowerCamelCase__,						lowerCamelCase__,						**lowerCamelCase__				)
  _SCREAMING_SNAKE_CASE   :				Tuple							    = _DataSet(lowerCamelCase__,						lowerCamelCase__,						**lowerCamelCase__				)

  return _Datasets(train=lowerCamelCase__,						validation=lowerCamelCase__,						test=lowerCamelCase__				)





"""simple docstring"""
import gc
import random
import unittest

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

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





def    _lowerCAmelCase    (     lowerCamelCase__							:							Optional[Any]				)  ->    Optional[Any]:
  _SCREAMING_SNAKE_CASE   :				Any							    = [tensor.shape for tensor in tensor_list]
  return all(shape == shapes[0] for shape in shapes[1:]				)
class 			UpperCamelCase      (							__SCREAMING_SNAKE_CASE      ,       __SCREAMING_SNAKE_CASE      ,       __SCREAMING_SNAKE_CASE      ,       unittest.TestCase  ):
     A__      =			StableDiffusionLatentUpscalePipeline
     A__      =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
         """height""",
         """width""",
         """cross_attention_kwargs""",
         """negative_prompt_embeds""",
         """prompt_embeds""",
     }
     A__      =			PipelineTesterMixin.required_optional_params - {"""num_images_per_prompt"""}
     A__      =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     A__      =			frozenset(
         []  )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
     A__      =			frozenset([]  )

     A__      =			True
     @property
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				List[str]							    = 1
       _SCREAMING_SNAKE_CASE   :				int							    = 4
       _SCREAMING_SNAKE_CASE   :				str							    = (16, 16)

       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = floats_tensor((batch_size, num_channels) + sizes  ,     rng=random.Random(0				)				).to(snake_case__				)
       return image
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       torch.manual_seed(0				)
       _SCREAMING_SNAKE_CASE   :				List[str]							    = UNetaDConditionModel(
           act_fn="gelu"  ,     attention_head_dim=8  ,     norm_num_groups=snake_case__  ,     block_out_channels=[32, 32, 64, 64]  ,     time_cond_proj_dim=160  ,     conv_in_kernel=1  ,     conv_out_kernel=1  ,     cross_attention_dim=32  ,     down_block_types=(
               "KDownBlock2D",
               "KCrossAttnDownBlock2D",
               "KCrossAttnDownBlock2D",
               "KCrossAttnDownBlock2D",
           )  ,     in_channels=8  ,     mid_block_type=snake_case__  ,     only_cross_attention=snake_case__  ,     out_channels=5  ,     resnet_time_scale_shift="scale_shift"  ,     time_embedding_type="fourier"  ,     timestep_post_act="gelu"  ,     up_block_types=("KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KUpBlock2D")  ,     )
       _SCREAMING_SNAKE_CASE   :				Any							    = AutoencoderKL(
           block_out_channels=[32, 32, 64, 64]  ,     in_channels=3  ,     out_channels=3  ,     down_block_types=[
               "DownEncoderBlock2D",
               "DownEncoderBlock2D",
               "DownEncoderBlock2D",
               "DownEncoderBlock2D",
           ]  ,     up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"]  ,     latent_channels=4  ,     )
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = EulerDiscreteScheduler(prediction_type="sample"				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = CLIPTextConfig(
           bos_token_id=0  ,     eos_token_id=2  ,     hidden_size=32  ,     intermediate_size=37  ,     layer_norm_eps=1E-05  ,     num_attention_heads=4  ,     num_hidden_layers=5  ,     pad_token_id=1  ,     vocab_size=1000  ,     hidden_act="quick_gelu"  ,     projection_dim=512  ,     )
       _SCREAMING_SNAKE_CASE   :				List[Any]							    = CLIPTextModel(snake_case__				)
       _SCREAMING_SNAKE_CASE   :				str							    = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)

       _SCREAMING_SNAKE_CASE   :				int							    = {
           "unet": model.eval(),
           "vae": vae.eval(),
           "scheduler": scheduler,
           "text_encoder": text_encoder,
           "tokenizer": tokenizer,
       }

       return components
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__=0				):




       """simple docstring"""


       if str(snake_case__				).startswith("mps"				):
         _SCREAMING_SNAKE_CASE   :				Optional[int]							    = torch.manual_seed(snake_case__				)
       else:
         _SCREAMING_SNAKE_CASE   :				Dict							    = torch.Generator(device=snake_case__				).manual_seed(snake_case__				)
       _SCREAMING_SNAKE_CASE   :				int							    = {
           "prompt": "A painting of a squirrel eating a burger",
           "image": self.dummy_image.cpu(),
           "generator": generator,
           "num_inference_steps": 2,
           "output_type": "numpy",
       }
       return inputs
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				str							    = "cpu"

       _SCREAMING_SNAKE_CASE   :				Any							    = self.get_dummy_components()
       _SCREAMING_SNAKE_CASE   :				str							    = self.pipeline_class(**snake_case__				)
       pipe.to(snake_case__				)
       pipe.set_progress_bar_config(disable=snake_case__				)

       _SCREAMING_SNAKE_CASE   :				str							    = self.get_dummy_inputs(snake_case__				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = pipe(**snake_case__				).images
       _SCREAMING_SNAKE_CASE   :				str							    = image[0, -3:, -3:, -1]

       self.assertEqual(image.shape  ,     (1, 256, 256, 3)				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = np.array(
           [0.47_222_412, 0.41_921_633, 0.44_717_434, 0.46_874_192, 0.42_588_258, 0.46_150_726, 0.4_677_534, 0.45_583_832, 0.48_579_055]				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = np.abs(image_slice.flatten() - expected_slice				).max()
       self.assertLessEqual(snake_case__  ,     1E-3				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().test_attention_slicing_forward_pass(expected_max_diff=7E-3				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().test_cpu_offload_forward_pass(expected_max_diff=3E-3				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().test_inference_batch_single_identical(expected_max_diff=7E-3				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3E-3				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().test_save_load_local(expected_max_difference=3E-3				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().test_save_load_optional_components(expected_max_difference=3E-3				)




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Any							    = [
           "DDIMScheduler",
           "DDPMScheduler",
           "PNDMScheduler",
           "HeunDiscreteScheduler",
           "EulerAncestralDiscreteScheduler",
           "KDPM2DiscreteScheduler",
           "KDPM2AncestralDiscreteScheduler",
           "DPMSolverSDEScheduler",
       ]
       _SCREAMING_SNAKE_CASE   :				Any							    = self.get_dummy_components()
       _SCREAMING_SNAKE_CASE   :				Dict							    = self.pipeline_class(**snake_case__				)

       # make sure that PNDM does not need warm-up
       pipe.scheduler.register_to_config(skip_prk_steps=snake_case__				)

       pipe.to(snake_case__				)
       pipe.set_progress_bar_config(disable=snake_case__				)
       _SCREAMING_SNAKE_CASE   :				str							    = self.get_dummy_inputs(snake_case__				)
       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = 2

       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = []
       for scheduler_enum in KarrasDiffusionSchedulers:
         if scheduler_enum.name in skip_schedulers:
           # no sigma schedulers are not supported
           # no schedulers
           continue

         _SCREAMING_SNAKE_CASE   :				List[str]							    = getattr(snake_case__  ,     scheduler_enum.name				)
         _SCREAMING_SNAKE_CASE   :				Dict							    = scheduler_cls.from_config(pipe.scheduler.config				)
         _SCREAMING_SNAKE_CASE   :				int							    = pipe(**snake_case__				)[0]
         outputs.append(snake_case__				)

       assert check_same_shape(snake_case__				)
@require_torch_gpu
@slow
class 			UpperCamelCase      (							unittest.TestCase  ):
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Tuple							    = torch.manual_seed(33				)

       _SCREAMING_SNAKE_CASE   :				str							    = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"  ,     torch_dtype=torch.floataa				)
       pipe.to("cuda"				)

       _SCREAMING_SNAKE_CASE   :				int							    = StableDiffusionLatentUpscalePipeline.from_pretrained(
           "stabilityai/sd-x2-latent-upscaler"  ,     torch_dtype=torch.floataa				)
       upscaler.to("cuda"				)

       _SCREAMING_SNAKE_CASE   :				str							    = "a photo of an astronaut high resolution, unreal engine, ultra realistic"

       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = pipe(snake_case__  ,     generator=snake_case__  ,     output_type="latent"				).images

       _SCREAMING_SNAKE_CASE   :				Tuple							    = upscaler(
           prompt=snake_case__  ,     image=snake_case__  ,     num_inference_steps=20  ,     guidance_scale=0  ,     generator=snake_case__  ,     output_type="np"  ,     ).images[0]

       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy"				)
       assert np.abs((expected_image - image).mean()				) < 5E-2




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				int							    = torch.manual_seed(33				)

       _SCREAMING_SNAKE_CASE   :				str							    = StableDiffusionLatentUpscalePipeline.from_pretrained(
           "stabilityai/sd-x2-latent-upscaler"  ,     torch_dtype=torch.floataa				)
       upscaler.to("cuda"				)

       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = "the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas"

       _SCREAMING_SNAKE_CASE   :				List[str]							    = load_image(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png"				)

       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = upscaler(
           prompt=snake_case__  ,     image=snake_case__  ,     num_inference_steps=20  ,     guidance_scale=0  ,     generator=snake_case__  ,     output_type="np"  ,     ).images[0]

       _SCREAMING_SNAKE_CASE   :				int							    = load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy"				)
       assert np.abs((expected_image - image).max()				) < 5E-2



