


"""simple docstring"""



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 _lowerCAmelCase       (   unittest.TestCase			):
   __UpperCAmelCase				: List[Any]													=						StableDiffusionLDMaDPipeline
   __UpperCAmelCase				: Any													=						TEXT_TO_IMAGE_PARAMS
   __UpperCAmelCase				: List[str]													=						TEXT_TO_IMAGE_BATCH_PARAMS
   __UpperCAmelCase				: Tuple													=						TEXT_TO_IMAGE_IMAGE_PARAMS







   def 				lowerCamelCase	(			self		)			->	Union[str, Any]:

       '''simple docstring'''




       torch.manual_seed(0		)
       snake_case					:   Dict         =					UNetaDConditionModel(
           block_out_channels=(32, 64)		,			layers_per_block=2		,			sample_size=32		,			in_channels=4		,			out_channels=4		,			down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")		,			up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")		,			cross_attention_dim=32		,			)
       snake_case					:   Dict         =					DDIMScheduler(
           beta_start=0.00085		,			beta_end=0.012		,			beta_schedule="scaled_linear"		,			clip_sample=_UpperCAmelCase		,			set_alpha_to_one=_UpperCAmelCase		,			)
       torch.manual_seed(0		)
       snake_case					:   Optional[Any]         =					AutoencoderKL(
           block_out_channels=[32, 64]		,			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					:   Union[str, Any]         =					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		,			)
       snake_case					:   Dict         =					CLIPTextModel(_UpperCAmelCase		)
       snake_case					:   Optional[Any]         =					CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

       snake_case					:   List[str]         =					{
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''safety_checker''': None,
           '''feature_extractor''': None,
       }
       return components







   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__=0		)			->	Optional[int]:

       '''simple docstring'''




       if str(_UpperCAmelCase		).startswith("mps"		):
           snake_case					:   List[Any]         =					torch.manual_seed(_UpperCAmelCase		)
       else:
           snake_case					:   Tuple         =					torch.Generator(device=_UpperCAmelCase		).manual_seed(_UpperCAmelCase		)
       snake_case					:   Any         =					{
           '''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 				lowerCamelCase	(			self		)			->	Union[str, Any]:

       '''simple docstring'''




       snake_case					:   Dict         =					'''cpu'''  # ensure determinism for the device-dependent torch.Generator

       snake_case					:   Union[str, Any]         =					self.get_dummy_components()
       snake_case					:   Tuple         =					StableDiffusionLDMaDPipeline(**_UpperCAmelCase		)
       snake_case					:   int         =					ldmad_pipe.to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       snake_case					:   str         =					self.get_dummy_inputs(_UpperCAmelCase		)
       snake_case					:   Tuple         =					ldmad_pipe(**_UpperCAmelCase		)
       snake_case					:   Any         =					output.rgb, output.depth

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

       assert rgb.shape == (1, 64, 64, 3)
       assert depth.shape == (1, 64, 64)

       snake_case					:   Optional[Any]         =					np.array(
           [0.37338176, 0.70247, 0.74203193, 0.51643604, 0.58256793, 0.60932136, 0.4181095, 0.48355877, 0.46535262]		)
       snake_case					:   Union[str, Any]         =					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 				lowerCamelCase	(			self		)			->	Optional[Any]:

       '''simple docstring'''




       snake_case					:   List[Any]         =					self.get_dummy_components()
       snake_case					:   int         =					StableDiffusionLDMaDPipeline(**_UpperCAmelCase		)
       snake_case					:   Optional[Any]         =					ldmad_pipe.to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       snake_case					:   Optional[int]         =					self.get_dummy_inputs(_UpperCAmelCase		)
       snake_case					:   Dict         =					3 * [inputs['''prompt''']]

       # forward
       snake_case					:   List[Any]         =					ldmad_pipe(**_UpperCAmelCase		)
       snake_case					:   Optional[Any]         =					output.rgb, output.depth
       snake_case					:   Optional[Any]         =					rgb_slice_a[0, -3:, -3:, -1]
       snake_case					:   Tuple         =					depth_slice_a[0, -3:, -1]

       snake_case					:   Any         =					self.get_dummy_inputs(_UpperCAmelCase		)
       snake_case					:   List[Any]         =					3 * [inputs.pop("prompt"		)]

       snake_case					:   Union[str, Any]         =					ldmad_pipe.tokenizer(
           _UpperCAmelCase		,			padding="max_length"		,			max_length=ldmad_pipe.tokenizer.model_max_length		,			truncation=_UpperCAmelCase		,			return_tensors="pt"		,			)
       snake_case					:   List[Any]         =					text_inputs['''input_ids'''].to(_UpperCAmelCase		)

       snake_case					:   List[str]         =					ldmad_pipe.text_encoder(_UpperCAmelCase		)[0]

       snake_case					:   Optional[Any]         =					prompt_embeds

       # forward
       snake_case					:   List[Any]         =					ldmad_pipe(**_UpperCAmelCase		)
       snake_case					:   Union[str, Any]         =					output.rgb, output.depth
       snake_case					:   List[str]         =					rgb_slice_a[0, -3:, -3:, -1]
       snake_case					:   Tuple         =					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 				lowerCamelCase	(			self		)			->	Union[str, Any]:

       '''simple docstring'''




       snake_case					:   Any         =					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       snake_case					:   List[Any]         =					self.get_dummy_components()
       snake_case					:   Tuple         =					PNDMScheduler(skip_prk_steps=_UpperCAmelCase		)
       snake_case					:   Optional[int]         =					StableDiffusionLDMaDPipeline(**_UpperCAmelCase		)
       snake_case					:   Dict         =					ldmad_pipe.to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       snake_case					:   Tuple         =					self.get_dummy_inputs(_UpperCAmelCase		)
       snake_case					:   Optional[Any]         =					'''french fries'''
       snake_case					:   Optional[Any]         =					ldmad_pipe(**_UpperCAmelCase		,			negative_prompt=_UpperCAmelCase		)

       snake_case					:   Any         =					output.rgb, output.depth
       snake_case					:   Optional[Any]         =					rgb[0, -3:, -3:, -1]
       snake_case					:   List[str]         =					depth[0, -3:, -1]

       assert rgb.shape == (1, 64, 64, 3)
       assert depth.shape == (1, 64, 64)

       snake_case					:   str         =					np.array(
           [0.37044, 0.71811503, 0.7223251, 0.48603675, 0.5638391, 0.6364948, 0.42833704, 0.4901315, 0.47926217]		)
       snake_case					:   Union[str, Any]         =					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 _lowerCAmelCase       (   unittest.TestCase			):







   def 				lowerCamelCase	(			self		)			->	List[str]:

       '''simple docstring'''




       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__="cpu"		,			UpperCamelCase__=torch.floataa		,			UpperCamelCase__=0		)			->	List[str]:

       '''simple docstring'''




       snake_case					:   List[Any]         =					torch.Generator(device=_UpperCAmelCase		).manual_seed(_UpperCAmelCase		)
       snake_case					:   Tuple         =					np.random.RandomState(_UpperCAmelCase		).standard_normal((1, 4, 64, 64)		)
       snake_case					:   int         =					torch.from_numpy(_UpperCAmelCase		).to(device=_UpperCAmelCase		,			dtype=_UpperCAmelCase		)
       snake_case					:   str         =					{
           '''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 				lowerCamelCase	(			self		)			->	Any:

       '''simple docstring'''




       snake_case					:   List[str]         =					StableDiffusionLDMaDPipeline.from_pretrained("Intel/ldm3d"		)
       snake_case					:   Tuple         =					ldmad_pipe.to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       snake_case					:   Any         =					self.get_inputs(_UpperCAmelCase		)
       snake_case					:   Optional[Any]         =					ldmad_pipe(**_UpperCAmelCase		)
       snake_case					:   List[str]         =					output.rgb, output.depth
       snake_case					:   List[str]         =					rgb[0, -3:, -3:, -1].flatten()
       snake_case					:   str         =					rgb[0, -3:, -1].flatten()

       assert rgb.shape == (1, 512, 512, 3)
       assert depth.shape == (1, 512, 512)

       snake_case					:   Dict         =					np.array(
           [0.53805465, 0.56707305, 0.5486515, 0.57012236, 0.5814511, 0.56253487, 0.54843014, 0.55092263, 0.6459706]		)
       snake_case					:   List[str]         =					np.array(
           [0.9263781, 0.6678672, 0.5486515, 0.92202145, 0.67831135, 0.56253487, 0.9241694, 0.7551478, 0.6459706]		)
       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 _lowerCAmelCase       (   unittest.TestCase			):







   def 				lowerCamelCase	(			self		)			->	Union[str, Any]:

       '''simple docstring'''




       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__="cpu"		,			UpperCamelCase__=torch.floataa		,			UpperCamelCase__=0		)			->	Optional[Any]:

       '''simple docstring'''




       snake_case					:   Tuple         =					torch.Generator(device=_UpperCAmelCase		).manual_seed(_UpperCAmelCase		)
       snake_case					:   List[Any]         =					np.random.RandomState(_UpperCAmelCase		).standard_normal((1, 4, 64, 64)		)
       snake_case					:   List[str]         =					torch.from_numpy(_UpperCAmelCase		).to(device=_UpperCAmelCase		,			dtype=_UpperCAmelCase		)
       snake_case					:   Union[str, Any]         =					{
           '''prompt''': '''a photograph of an astronaut riding a horse''',
           '''latents''': latents,
           '''generator''': generator,
           '''num_inference_steps''': 50,
           '''guidance_scale''': 7.5,
           '''output_type''': '''numpy''',
       }
       return inputs







   def 				lowerCamelCase	(			self		)			->	int:

       '''simple docstring'''




       snake_case					:   Any         =					StableDiffusionLDMaDPipeline.from_pretrained("Intel/ldm3d"		).to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       snake_case					:   str         =					self.get_inputs(_UpperCAmelCase		)
       snake_case					:   Optional[int]         =					ldmad_pipe(**_UpperCAmelCase		)
       snake_case					:   Tuple         =					output.rgb, output.depth

       snake_case					:   Dict         =					0.495586
       snake_case					:   Union[str, Any]         =					0.33795515
       snake_case					:   int         =					112.4_8518
       snake_case					:   int         =					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 				lowerCamelCase	(			self		)			->	Union[str, Any]:

       '''simple docstring'''




       snake_case					:   List[str]         =					StableDiffusionLDMaDPipeline.from_pretrained("Intel/ldm3d-4c"		).to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       snake_case					:   List[str]         =					self.get_inputs(_UpperCAmelCase		)
       snake_case					:   int         =					ldmad_pipe(**_UpperCAmelCase		)
       snake_case					:   str         =					output.rgb, output.depth

       snake_case					:   Union[str, Any]         =					0.4194127
       snake_case					:   Union[str, Any]         =					0.35375586
       snake_case					:   List[str]         =					0.5638502
       snake_case					:   Dict         =					0.34686103

       assert rgb.shape == (1, 512, 512, 3)
       assert depth.shape == (1, 512, 512, 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 baseaa







def 						__lowerCAmelCase		(		lowercase						:						str				)			->		bytes:


    """simple docstring"""





    return baseaa.aaaencode(string.encode("utf-8"				)				)







def 						__lowerCAmelCase		(		lowercase						:						bytes				)			->		str:


    """simple docstring"""





    return baseaa.aaadecode(lowercase				).decode("utf-8"				)


if __name__ == "__main__":
  import doctest

  doctest.testmod()





