


import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()



class A__     ( _UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		unittest.TestCase  ):



  """simple docstring"""



  _lowercase									=		StableUnCLIPPipeline
  _lowercase									=		TEXT_TO_IMAGE_PARAMS
  _lowercase									=		TEXT_TO_IMAGE_BATCH_PARAMS
  _lowercase									=		TEXT_TO_IMAGE_IMAGE_PARAMS
  _lowercase									=		TEXT_TO_IMAGE_IMAGE_PARAMS

  # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
  _lowercase									=		False

  def    _UpperCamelCase( self			:  Optional[Any]       ):
        a__	:  Tuple     =   32
        a__	:  Dict     =   embedder_hidden_size

        # prior components

        torch.manual_seed(0       )
        a__	:  Tuple     =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

        torch.manual_seed(0       )
        a__	:  str     =   CLIPTextModelWithProjection(
            CLIPTextConfig(
                bos_token_id=0				,				eos_token_id=2				,				hidden_size=lowerCamelCase__				,				projection_dim=lowerCamelCase__				,				intermediate_size=37				,				layer_norm_eps=1E-05				,				num_attention_heads=4				,				num_hidden_layers=5				,				pad_token_id=1				,				vocab_size=1_000				,				)       )

        torch.manual_seed(0       )
        a__	:  List[str]     =   PriorTransformer(
            num_attention_heads=2				,				attention_head_dim=12				,				embedding_dim=lowerCamelCase__				,				num_layers=1				,				)

        torch.manual_seed(0       )
        a__	:  Dict     =   DDPMScheduler(
            variance_type="fixed_small_log"				,				prediction_type="sample"				,				num_train_timesteps=1_000				,				clip_sample=lowerCamelCase__				,				clip_sample_range=5.0				,				beta_schedule="squaredcos_cap_v2"				,				)

        # regular denoising components

        torch.manual_seed(0       )
        a__	:  Union[str, Any]     =   StableUnCLIPImageNormalizer(embedding_dim=lowerCamelCase__       )
        a__	:  List[Any]     =   DDPMScheduler(beta_schedule="squaredcos_cap_v2"       )

        torch.manual_seed(0       )
        a__	:  List[str]     =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

        torch.manual_seed(0       )
        a__	:  Any     =   CLIPTextModel(
            CLIPTextConfig(
                bos_token_id=0				,				eos_token_id=2				,				hidden_size=lowerCamelCase__				,				projection_dim=32				,				intermediate_size=37				,				layer_norm_eps=1E-05				,				num_attention_heads=4				,				num_hidden_layers=5				,				pad_token_id=1				,				vocab_size=1_000				,				)       )

        torch.manual_seed(0       )
        a__	:  Optional[Any]     =   UNetaDConditionModel(
            sample_size=32				,				in_channels=4				,				out_channels=4				,				down_block_types=("CrossAttnDownBlock2D", "DownBlock2D")				,				up_block_types=("UpBlock2D", "CrossAttnUpBlock2D")				,				block_out_channels=(32, 64)				,				attention_head_dim=(2, 4)				,				class_embed_type="projection"				,				projection_class_embeddings_input_dim=embedder_projection_dim * 2				,				cross_attention_dim=lowerCamelCase__				,				layers_per_block=1				,				upcast_attention=lowerCamelCase__				,				use_linear_projection=lowerCamelCase__				,				)

        torch.manual_seed(0       )
        a__	:  Optional[int]     =   DDIMScheduler(
            beta_schedule="scaled_linear"				,				beta_start=0.0_0085				,				beta_end=0.012				,				prediction_type="v_prediction"				,				set_alpha_to_one=lowerCamelCase__				,				steps_offset=1				,				)

        torch.manual_seed(0       )
        a__	:  Optional[int]     =   AutoencoderKL()

        a__	:  List[str]     =   {
            # prior components
            """prior_tokenizer""": prior_tokenizer,
            """prior_text_encoder""": prior_text_encoder,
            """prior""": prior,
            """prior_scheduler""": prior_scheduler,
            # image noising components
            """image_normalizer""": image_normalizer,
            """image_noising_scheduler""": image_noising_scheduler,
            # regular denoising components
            """tokenizer""": tokenizer,
            """text_encoder""": text_encoder,
            """unet""": unet,
            """scheduler""": scheduler,
            """vae""": vae,
        }

        return components

  def    _UpperCamelCase( self			:  str				,				lowerCamelCase__			:  List[str]				,				lowerCamelCase__			:  Dict=0       ):







        if str(lowerCamelCase__       ).startswith("mps"       ):
              a__	:  Tuple     =   torch.manual_seed(lowerCamelCase__       )
        else:
              a__	:  List[str]     =   torch.Generator(device=lowerCamelCase__       ).manual_seed(lowerCamelCase__       )
        a__	:  Dict     =   {
            """prompt""": """A painting of a squirrel eating a burger""",
            """generator""": generator,
            """num_inference_steps""": 2,
            """prior_num_inference_steps""": 2,
            """output_type""": """numpy""",
        }
        return inputs

  def    _UpperCamelCase( self			:  List[str]       ):
        a__	:  Optional[int]     =   torch_device == """cpu"""

        self._test_attention_slicing_forward_pass(test_max_difference=lowerCamelCase__       )

  def    _UpperCamelCase( self			:  Optional[int]       ):
        a__	:  int     =   torch_device in ["""cpu""", """mps"""]

        self._test_inference_batch_single_identical(test_max_difference=lowerCamelCase__       )




@slow
@require_torch_gpu
class A__     ( unittest.TestCase  ):



  """simple docstring"""



  def    _UpperCamelCase( self			:  Optional[Any]       ):
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()

  def    _UpperCamelCase( self			:  Tuple       ):
        a__	:  List[Any]     =   load_numpy(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"       )

        a__	:  Tuple     =   StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l"				,				torch_dtype=torch.floataa       )
        pipe.to(lowerCamelCase__       )
        pipe.set_progress_bar_config(disable=lowerCamelCase__       )
        # stable unclip will oom when integration tests are run on a V100,
        # so turn on memory savings
        pipe.enable_attention_slicing()
        pipe.enable_sequential_cpu_offload()

        a__	:  List[str]     =   torch.Generator(device="cpu"       ).manual_seed(0       )
        a__	:  str     =   pipe("anime turle"				,				generator=lowerCamelCase__				,				output_type="np"       )

        a__	:  Any     =   output.images[0]

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

        assert_mean_pixel_difference(lowerCamelCase__				,				lowerCamelCase__       )

  def    _UpperCamelCase( self			:  Tuple       ):
        torch.cuda.empty_cache()
        torch.cuda.reset_max_memory_allocated()
        torch.cuda.reset_peak_memory_stats()

        a__	:  Any     =   StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l"				,				torch_dtype=torch.floataa       )
        a__	:  Optional[int]     =   pipe.to(lowerCamelCase__       )
        pipe.set_progress_bar_config(disable=lowerCamelCase__       )
        pipe.enable_attention_slicing()
        pipe.enable_sequential_cpu_offload()

        a__	:  int     =   pipe(
            "anime turtle"				,				prior_num_inference_steps=2				,				num_inference_steps=2				,				output_type="np"				,				)

        a__	:  Optional[Any]     =   torch.cuda.max_memory_allocated()
        # make sure that less than 7 GB is allocated
        assert mem_bytes < 7 * 10**9







def 				A__ (snake_case   :		int				)     ->						bool:
					if number < 0:
										raise ValueError("""number must not be negative"""				)
					return number & (number - 1) == 0


if __name__ == "__main__":
	import doctest

	doctest.testmod()






