




'''simple docstring'''




import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import 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
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class     UpperCamelCase_     (a__,      a__,      unittest.TestCase     ):







						"""simple docstring"""


						_lowerCAmelCase    						=					StableDiffusionParadigmsPipeline
						_lowerCAmelCase    						=					TEXT_TO_IMAGE_PARAMS
						_lowerCAmelCase    						=					TEXT_TO_IMAGE_BATCH_PARAMS
						_lowerCAmelCase    						=					TEXT_TO_IMAGE_IMAGE_PARAMS
						_lowerCAmelCase    						=					TEXT_TO_IMAGE_IMAGE_PARAMS







						def       _a    (     self      :       str    ):





											"""simple docstring"""







											torch.manual_seed(0    )
											A_ :     Optional[int] =							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							, attention_head_dim=(2, 4)							, use_linear_projection=_lowerCamelCase							, )
											A_ :     str =							DDIMParallelScheduler(
											    beta_start=0.0_00_85							, beta_end=0.0_12							, beta_schedule='''scaled_linear'''							, clip_sample=_lowerCamelCase							, set_alpha_to_one=_lowerCamelCase							, )
											torch.manual_seed(0    )
											A_ :     int =							AutoencoderKL(
											    block_out_channels=[32, 64]							, in_channels=3							, out_channels=3							, down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']							, up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']							, latent_channels=4							, sample_size=128							, )
											torch.manual_seed(0    )
											A_ :     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='''gelu'''							, projection_dim=512							, )
											A_ :     List[str] =							CLIPTextModel(_lowerCamelCase    )
											A_ :     Union[str, Any] =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )

											A_ :     Optional[int] =							{
											    '''unet''': unet,
											    '''scheduler''': scheduler,
											    '''vae''': vae,
											    '''text_encoder''': text_encoder,
											    '''tokenizer''': tokenizer,
											    '''safety_checker''': None,
											    '''feature_extractor''': None,
											}
											return components







						def       _a    (     self      :       str							, _lowerCamelCase      :       List[str]							, _lowerCamelCase      :       Optional[Any]=0    ):





											"""simple docstring"""







											if str(_lowerCamelCase    ).startswith('''mps'''    ):
																A_ :     str =							torch.manual_seed(_lowerCamelCase    )
											else:
																A_ :     List[Any] =							torch.Generator(device=_lowerCamelCase    ).manual_seed(_lowerCamelCase    )
											A_ :     Dict =							{
											    '''prompt''': '''a photograph of an astronaut riding a horse''',
											    '''generator''': generator,
											    '''num_inference_steps''': 10,
											    '''guidance_scale''': 6.0,
											    '''output_type''': '''numpy''',
											    '''parallel''': 3,
											    '''debug''': True,
											}
											return inputs







						def       _a    (     self      :       Tuple    ):





											"""simple docstring"""







											A_ :     int =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
											A_ :     int =							self.get_dummy_components()
											A_ :     List[Any] =							StableDiffusionParadigmsPipeline(**_lowerCamelCase    )
											A_ :     Union[str, Any] =							sd_pipe.to(_lowerCamelCase    )
											sd_pipe.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     List[str] =							self.get_dummy_inputs(_lowerCamelCase    )
											A_ :     Optional[int] =							sd_pipe(**_lowerCamelCase    ).images
											A_ :     str =							image[0, -3:, -3:, -1]
											assert image.shape == (1, 64, 64, 3)

											A_ :     List[Any] =							np.array([0.47_73, 0.54_17, 0.47_23, 0.49_25, 0.56_31, 0.47_52, 0.52_40, 0.49_35, 0.50_23]    )

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







						def       _a    (     self      :       str    ):





											"""simple docstring"""







											A_ :     Tuple =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
											A_ :     Union[str, Any] =							self.get_dummy_components()
											torch.manual_seed(0    )
											A_ :     Union[str, Any] =							DDPMParallelScheduler()
											torch.manual_seed(0    )
											A_ :     int =							StableDiffusionParadigmsPipeline(**_lowerCamelCase    )
											A_ :     Optional[Any] =							sd_pipe.to(_lowerCamelCase    )
											sd_pipe.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     Any =							self.get_dummy_inputs(_lowerCamelCase    )
											A_ :     int =							sd_pipe(**_lowerCamelCase    ).images
											A_ :     Optional[Any] =							image[0, -3:, -3:, -1]
											assert image.shape == (1, 64, 64, 3)

											A_ :     List[Any] =							np.array([0.35_73, 0.44_20, 0.49_60, 0.47_99, 0.37_96, 0.38_79, 0.48_19, 0.43_65, 0.44_68]    )

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







						def       _a    (     self      :       List[str]    ):





											"""simple docstring"""







											super().test_inference_batch_consistent(batch_sizes=[1, 2]    )







						def       _a    (     self      :       List[str]    ):





											"""simple docstring"""







											super().test_inference_batch_single_identical(batch_size=2							, expected_max_diff=3E-3    )







						def       _a    (     self      :       Dict    ):





											"""simple docstring"""







											A_ :     Dict =							'''cpu'''  # ensure determinism for the device-dependent torch.Generator
											A_ :     List[Any] =							self.get_dummy_components()
											A_ :     Optional[int] =							StableDiffusionParadigmsPipeline(**_lowerCamelCase    )
											A_ :     List[str] =							sd_pipe.to(_lowerCamelCase    )
											sd_pipe.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     Any =							self.get_dummy_inputs(_lowerCamelCase    )
											A_ :     List[str] =							'''french fries'''
											A_ :     Optional[Any] =							sd_pipe(**_lowerCamelCase							, negative_prompt=_lowerCamelCase    )
											A_ :     Optional[int] =							output.images
											A_ :     List[str] =							image[0, -3:, -3:, -1]

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

											A_ :     List[Any] =							np.array([0.47_71, 0.54_20, 0.46_83, 0.49_18, 0.56_36, 0.47_25, 0.52_30, 0.49_23, 0.50_15]    )

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






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







						"""simple docstring"""


						def       _a    (     self      :       List[Any]    ):





											"""simple docstring"""







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







						def       _a    (     self      :       str							, _lowerCamelCase      :       Tuple=0    ):





											"""simple docstring"""







											A_ :     List[Any] =							torch.Generator(device=_lowerCamelCase    ).manual_seed(_lowerCamelCase    )
											A_ :     Dict =							{
											    '''prompt''': '''a photograph of an astronaut riding a horse''',
											    '''generator''': generator,
											    '''num_inference_steps''': 10,
											    '''guidance_scale''': 7.5,
											    '''output_type''': '''numpy''',
											    '''parallel''': 3,
											    '''debug''': True,
											}
											return inputs







						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											A_ :     Optional[Any] =							'''stabilityai/stable-diffusion-2-base'''
											A_ :     Dict =							DDIMParallelScheduler.from_pretrained(_lowerCamelCase							, subfolder='''scheduler'''    )
											A_ :     List[str] =							StableDiffusionParadigmsPipeline.from_pretrained(_lowerCamelCase							, scheduler=_lowerCamelCase							, safety_checker=_lowerCamelCase    )
											pipe.to(_lowerCamelCase    )
											pipe.set_progress_bar_config(disable=_lowerCamelCase    )
											pipe.enable_attention_slicing()

											A_ :     Union[str, Any] =							self.get_inputs()
											A_ :     str =							pipe(**_lowerCamelCase    ).images
											A_ :     List[str] =							image[0, -3:, -3:, -1].flatten()

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

											A_ :     str =							np.array([0.96_22, 0.96_02, 0.97_48, 0.95_91, 0.96_30, 0.96_91, 0.96_61, 0.96_31, 0.97_41]    )

											assert np.abs(expected_slice - image_slice    ).max() < 1E-2









'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case__          =						{"""configuration_nat""": ["""NAT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """NatConfig"""]}


try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							snake_case__          =						[
							    """NAT_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """NatForImageClassification""",
							    """NatModel""",
							    """NatPreTrainedModel""",
							    """NatBackbone""",
							]

if TYPE_CHECKING:
							from .configuration_nat import NAT_PRETRAINED_CONFIG_ARCHIVE_MAP, NatConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_nat import (
														    NAT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    NatBackbone,
														    NatForImageClassification,
														    NatModel,
														    NatPreTrainedModel,
														)

else:
							import sys

							snake_case__          =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



