


import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    PNDMScheduler,
    StableDiffusionLDMaDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS


enable_full_determinism()

class     A__   (       unittest.TestCase      ):







    """simple docstring"""

    __magic_name__         =						StableDiffusionLDMaDPipeline
    __magic_name__         =						TEXT_TO_IMAGE_PARAMS
    __magic_name__         =						TEXT_TO_IMAGE_BATCH_PARAMS
    __magic_name__         =						TEXT_TO_IMAGE_IMAGE_PARAMS
    def 						a_     (			self       ):
         torch.manual_seed(0       )
         snake_case											=							UNetaDConditionModel(
             block_out_channels=(3_2, 6_4)     ,   layers_per_block=2     ,   sample_size=3_2     ,   in_channels=4     ,   out_channels=4     ,   down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,   up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')     ,   cross_attention_dim=3_2     ,   )
         snake_case											=							DDIMScheduler(
             beta_start=0.0_0085     ,   beta_end=0.012     ,   beta_schedule='''scaled_linear'''     ,   clip_sample=lowerCAmelCase__     ,   set_alpha_to_one=lowerCAmelCase__     ,   )
         torch.manual_seed(0       )
         snake_case											=							AutoencoderKL(
             block_out_channels=[3_2, 6_4]     ,   in_channels=6     ,   out_channels=6     ,   down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']     ,   up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']     ,   latent_channels=4     ,   )
         torch.manual_seed(0       )
         snake_case											=							CLIPTextConfig(
             bos_token_id=0     ,   eos_token_id=2     ,   hidden_size=3_2     ,   intermediate_size=3_7     ,   layer_norm_eps=1E-05     ,   num_attention_heads=4     ,   num_hidden_layers=5     ,   pad_token_id=1     ,   vocab_size=1_0_0_0     ,   )
         snake_case											=							CLIPTextModel(lowerCAmelCase__       )
         snake_case											=							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )

         snake_case											=							{
             '''unet''': unet,
             '''scheduler''': scheduler,
             '''vae''': vae,
             '''text_encoder''': text_encoder,
             '''tokenizer''': tokenizer,
             '''safety_checker''': None,
             '''feature_extractor''': None,
         }
         return components
    def 						a_     (			self     ,   __snake_case     ,   __snake_case=0       ):




         if str(lowerCAmelCase__       ).startswith('''mps'''       ):
              snake_case											=							torch.manual_seed(lowerCAmelCase__       )
         else:
              snake_case											=							torch.Generator(device=lowerCAmelCase__       ).manual_seed(lowerCAmelCase__       )
         snake_case											=							{
             '''prompt''': '''A painting of a squirrel eating a burger''',
             '''generator''': generator,
             '''num_inference_steps''': 2,
             '''guidance_scale''': 6.0,
             '''output_type''': '''numpy''',
         }
         return inputs
    def 						a_     (			self       ):
         snake_case											=							'''cpu'''  # ensure determinism for the device-dependent torch.Generator

         snake_case											=							self.get_dummy_components()
         snake_case											=							StableDiffusionLDMaDPipeline(**lowerCAmelCase__       )
         snake_case											=							ldmad_pipe.to(lowerCAmelCase__       )
         ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

         snake_case											=							self.get_dummy_inputs(lowerCAmelCase__       )
         snake_case											=							ldmad_pipe(**lowerCAmelCase__       )
         snake_case					,    snake_case											=							output.rgb, output.depth

         snake_case											=							rgb[0, -3:, -3:, -1]
         snake_case											=							depth[0, -3:, -1]

         assert rgb.shape == (1, 6_4, 6_4, 3)
         assert depth.shape == (1, 6_4, 6_4)

         snake_case											=							np.array(
             [0.3733_8176, 0.7_0247, 0.7420_3193, 0.5164_3604, 0.5825_6793, 0.6093_2136, 0.418_1095, 0.4835_5877, 0.4653_5262]       )
         snake_case											=							np.array([103.4_6727, 85.81_2004, 87.84_9236]       )

         assert np.abs(image_slice_rgb.flatten() - expected_slice_rgb       ).max() < 1E-2
         assert np.abs(image_slice_depth.flatten() - expected_slice_depth       ).max() < 1E-2
    def 						a_     (			self       ):
         snake_case											=							self.get_dummy_components()
         snake_case											=							StableDiffusionLDMaDPipeline(**lowerCAmelCase__       )
         snake_case											=							ldmad_pipe.to(lowerCAmelCase__       )
         ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

         snake_case											=							self.get_dummy_inputs(lowerCAmelCase__       )
         snake_case											=							3 * [inputs['''prompt''']]

         # forward
         snake_case											=							ldmad_pipe(**lowerCAmelCase__       )
         snake_case					,    snake_case											=							output.rgb, output.depth
         snake_case											=							rgb_slice_a[0, -3:, -3:, -1]
         snake_case											=							depth_slice_a[0, -3:, -1]

         snake_case											=							self.get_dummy_inputs(lowerCAmelCase__       )
         snake_case											=							3 * [inputs.pop('''prompt'''       )]

         snake_case											=							ldmad_pipe.tokenizer(
             lowerCAmelCase__     ,   padding='''max_length'''     ,   max_length=ldmad_pipe.tokenizer.model_max_length     ,   truncation=lowerCAmelCase__     ,   return_tensors='''pt'''     ,   )
         snake_case											=							text_inputs['''input_ids'''].to(lowerCAmelCase__       )

         snake_case											=							ldmad_pipe.text_encoder(lowerCAmelCase__       )[0]

         snake_case											=							prompt_embeds

         # forward
         snake_case											=							ldmad_pipe(**lowerCAmelCase__       )
         snake_case					,    snake_case											=							output.rgb, output.depth
         snake_case											=							rgb_slice_a[0, -3:, -3:, -1]
         snake_case											=							depth_slice_a[0, -3:, -1]

         assert np.abs(rgb_slice_a.flatten() - rgb_slice_a.flatten()       ).max() < 1E-4
         assert np.abs(depth_slice_a.flatten() - depth_slice_a.flatten()       ).max() < 1E-4




    def 						a_     (			self       ):
         snake_case											=							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
         snake_case											=							self.get_dummy_components()
         snake_case											=							PNDMScheduler(skip_prk_steps=lowerCAmelCase__       )
         snake_case											=							StableDiffusionLDMaDPipeline(**lowerCAmelCase__       )
         snake_case											=							ldmad_pipe.to(lowerCAmelCase__       )
         ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

         snake_case											=							self.get_dummy_inputs(lowerCAmelCase__       )
         snake_case											=							'''french fries'''
         snake_case											=							ldmad_pipe(**lowerCAmelCase__     ,   negative_prompt=lowerCAmelCase__       )

         snake_case					,    snake_case											=							output.rgb, output.depth
         snake_case											=							rgb[0, -3:, -3:, -1]
         snake_case											=							depth[0, -3:, -1]

         assert rgb.shape == (1, 6_4, 6_4, 3)
         assert depth.shape == (1, 6_4, 6_4)

         snake_case											=							np.array(
             [0.3_7044, 0.7181_1503, 0.722_3251, 0.4860_3675, 0.563_8391, 0.636_4948, 0.4283_3704, 0.490_1315, 0.4792_6217]       )
         snake_case											=							np.array([107.8_4738, 84.6_2802, 89.96_2135]       )
         assert np.abs(rgb_slice.flatten() - expected_slice_rgb       ).max() < 1E-2
         assert np.abs(depth_slice.flatten() - expected_slice_depth       ).max() < 1E-2






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







    """simple docstring"""

    def 						a_     (			self       ):
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()
    def 						a_     (			self     ,   __snake_case     ,   __snake_case="cpu"     ,   __snake_case=torch.floataa     ,   __snake_case=0       ):
         snake_case											=							torch.Generator(device=lowerCAmelCase__       ).manual_seed(lowerCAmelCase__       )
         snake_case											=							np.random.RandomState(lowerCAmelCase__       ).standard_normal((1, 4, 6_4, 6_4)       )
         snake_case											=							torch.from_numpy(lowerCAmelCase__       ).to(device=lowerCAmelCase__     ,   dtype=lowerCAmelCase__       )
         snake_case											=							{
             '''prompt''': '''a photograph of an astronaut riding a horse''',
             '''latents''': latents,
             '''generator''': generator,
             '''num_inference_steps''': 3,
             '''guidance_scale''': 7.5,
             '''output_type''': '''numpy''',
         }
         return inputs




    def 						a_     (			self       ):
         snake_case											=							StableDiffusionLDMaDPipeline.from_pretrained('''Intel/ldm3d'''       )
         snake_case											=							ldmad_pipe.to(lowerCAmelCase__       )
         ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

         snake_case											=							self.get_inputs(lowerCAmelCase__       )
         snake_case											=							ldmad_pipe(**lowerCAmelCase__       )
         snake_case					,    snake_case											=							output.rgb, output.depth
         snake_case											=							rgb[0, -3:, -3:, -1].flatten()
         snake_case											=							rgb[0, -3:, -1].flatten()

         assert rgb.shape == (1, 5_1_2, 5_1_2, 3)
         assert depth.shape == (1, 5_1_2, 5_1_2)

         snake_case											=							np.array(
             [0.5380_5465, 0.5670_7305, 0.548_6515, 0.5701_2236, 0.581_4511, 0.5625_3487, 0.5484_3014, 0.5509_2263, 0.645_9706]       )
         snake_case											=							np.array(
             [0.926_3781, 0.667_8672, 0.548_6515, 0.9220_2145, 0.6783_1135, 0.5625_3487, 0.924_1694, 0.755_1478, 0.645_9706]       )
         assert np.abs(rgb_slice - expected_slice_rgb       ).max() < 3E-3
         assert np.abs(depth_slice - expected_slice_depth       ).max() < 3E-3






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







    """simple docstring"""

    def 						a_     (			self       ):
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()
    def 						a_     (			self     ,   __snake_case     ,   __snake_case="cpu"     ,   __snake_case=torch.floataa     ,   __snake_case=0       ):
         snake_case											=							torch.Generator(device=lowerCAmelCase__       ).manual_seed(lowerCAmelCase__       )
         snake_case											=							np.random.RandomState(lowerCAmelCase__       ).standard_normal((1, 4, 6_4, 6_4)       )
         snake_case											=							torch.from_numpy(lowerCAmelCase__       ).to(device=lowerCAmelCase__     ,   dtype=lowerCAmelCase__       )
         snake_case											=							{
             '''prompt''': '''a photograph of an astronaut riding a horse''',
             '''latents''': latents,
             '''generator''': generator,
             '''num_inference_steps''': 5_0,
             '''guidance_scale''': 7.5,
             '''output_type''': '''numpy''',
         }
         return inputs
    def 						a_     (			self       ):
         snake_case											=							StableDiffusionLDMaDPipeline.from_pretrained('''Intel/ldm3d'''       ).to(lowerCAmelCase__       )
         ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

         snake_case											=							self.get_inputs(lowerCAmelCase__       )
         snake_case											=							ldmad_pipe(**lowerCAmelCase__       )
         snake_case					,    snake_case											=							output.rgb, output.depth

         snake_case											=							0.49_5586
         snake_case											=							0.3379_5515
         snake_case											=							112.4_8518
         snake_case											=							98.48_9746
         assert np.abs(expected_rgb_mean - rgb.mean()       ) < 1E-3
         assert np.abs(expected_rgb_std - rgb.std()       ) < 1E-3
         assert np.abs(expected_depth_mean - depth.mean()       ) < 1E-3
         assert np.abs(expected_depth_std - depth.std()       ) < 1E-3




    def 						a_     (			self       ):
         snake_case											=							StableDiffusionLDMaDPipeline.from_pretrained('''Intel/ldm3d-4c'''       ).to(lowerCAmelCase__       )
         ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

         snake_case											=							self.get_inputs(lowerCAmelCase__       )
         snake_case											=							ldmad_pipe(**lowerCAmelCase__       )
         snake_case					,    snake_case											=							output.rgb, output.depth

         snake_case											=							0.419_4127
         snake_case											=							0.3537_5586
         snake_case											=							0.563_8502
         snake_case											=							0.3468_6103

         assert rgb.shape == (1, 5_1_2, 5_1_2, 3)
         assert depth.shape == (1, 5_1_2, 5_1_2, 1)
         assert np.abs(expected_rgb_mean - rgb.mean()       ) < 1E-3
         assert np.abs(expected_rgb_std - rgb.std()       ) < 1E-3
         assert np.abs(expected_depth_mean - depth.mean()       ) < 1E-3
         assert np.abs(expected_depth_std - depth.std()       ) < 1E-3











'''simple docstring'''

import argparse

import intel_extension_for_pytorch as ipex
import torch

from diffusers import DPMSolverMultistepScheduler, StableDiffusionPipeline


lowercase__		:     int			=							argparse.ArgumentParser('Stable Diffusion script with intel optimization', add_help=False)
parser.add_argument('--dpm', action='store_true', help='Enable DPMSolver or not')
parser.add_argument('--steps', default=None, type=int, help='Num inference steps')
lowercase__		:     Union[str, Any]			=							parser.parse_args()


lowercase__		:     Union[str, Any]			=							'cpu'
lowercase__		:     Tuple			=							'a lovely <dicoo> in red dress and hat, in the snowly and brightly night, with many brighly buildings'

lowercase__		:     List[Any]			=							'path-to-your-trained-model'
lowercase__		:     Optional[Any]			=							StableDiffusionPipeline.from_pretrained(model_id)
if args.dpm:
   lowercase__		:     Union[str, Any]			=							DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
lowercase__		:     Dict			=							pipe.to(device)

# to channels last
lowercase__		:     Any			=							pipe.unet.to(memory_format=torch.channels_last)
lowercase__		:     Dict			=							pipe.vae.to(memory_format=torch.channels_last)
lowercase__		:     Any			=							pipe.text_encoder.to(memory_format=torch.channels_last)
if pipe.requires_safety_checker:
   lowercase__		:     Union[str, Any]			=							pipe.safety_checker.to(memory_format=torch.channels_last)

# optimize with ipex
lowercase__		:     List[str]			=							torch.randn(2, 4, 64, 64)
lowercase__		:     int			=							torch.rand(1) * 9_99
lowercase__		:     Optional[int]			=							torch.randn(2, 77, 7_68)
lowercase__		:     List[str]			=							(sample, timestep, encoder_hidden_status)
try:
   lowercase__		:     Optional[Any]			=							ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True, sample_input=input_example)
except Exception:
   lowercase__		:     Any			=							ipex.optimize(pipe.unet.eval(), dtype=torch.bfloataa, inplace=True)
lowercase__		:     Tuple			=							ipex.optimize(pipe.vae.eval(), dtype=torch.bfloataa, inplace=True)
lowercase__		:     Any			=							ipex.optimize(pipe.text_encoder.eval(), dtype=torch.bfloataa, inplace=True)
if pipe.requires_safety_checker:
   lowercase__		:     Union[str, Any]			=							ipex.optimize(pipe.safety_checker.eval(), dtype=torch.bfloataa, inplace=True)

# compute
lowercase__		:     Optional[Any]			=							6_66
lowercase__		:     Tuple			=							torch.Generator(device).manual_seed(seed)
lowercase__		:     Dict			=							{'generator': generator}
if args.steps is not None:
   lowercase__		:     int			=							args.steps

with torch.cpu.amp.autocast(enabled=True, dtype=torch.bfloataa):
   lowercase__		:     Dict			=							pipe(prompt, **generate_kwargs).images[0]

# save image
image.save('generated.png')



