






'''simple docstring'''





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    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 					a					(				_UpperCAmelCase							, _UpperCAmelCase							, unittest.TestCase     ):



      """simple docstring"""


      a						:				Optional[Any]							 =			StableDiffusionXLPipeline
      a						:				List[Any]							 =			TEXT_TO_IMAGE_PARAMS
      a						:				List[Any]							 =			TEXT_TO_IMAGE_BATCH_PARAMS
      a						:				Tuple							 =			TEXT_TO_IMAGE_IMAGE_PARAMS
      a						:				str							 =			TEXT_TO_IMAGE_IMAGE_PARAMS
      def 			UpperCAmelCase   (   self      :    List[Any]      )							->   str:
        torch.manual_seed(0      )
        __UpperCAmelCase							:			Union[str, Any]     =						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""")	,   attention_head_dim=(2, 4)	,   use_linear_projection=__lowercase	,   addition_embed_type="""text_time"""	,   addition_time_embed_dim=8	,   transformer_layers_per_block=(1, 2)	,   projection_class_embeddings_input_dim=80	,   cross_attention_dim=64	,   )
        __UpperCAmelCase							:			List[Any]     =						EulerDiscreteScheduler(
            beta_start=0.00_085	,   beta_end=0.012	,   steps_offset=1	,   beta_schedule="""scaled_linear"""	,   timestep_spacing="""leading"""	,   )
        torch.manual_seed(0      )
        __UpperCAmelCase							:			Union[str, Any]     =						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      )
        __UpperCAmelCase							:			Union[str, Any]     =						CLIPTextConfig(
            bos_token_id=0	,   eos_token_id=2	,   hidden_size=32	,   intermediate_size=37	,   layer_norm_eps=1e-0_5	,   num_attention_heads=4	,   num_hidden_layers=5	,   pad_token_id=1	,   vocab_size=1000	,   hidden_act="""gelu"""	,   projection_dim=32	,   )
        __UpperCAmelCase							:			Optional[int]     =						CLIPTextModel(__lowercase      )
        __UpperCAmelCase							:			int     =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	,   local_files_only=__lowercase      )

        __UpperCAmelCase							:			Union[str, Any]     =						CLIPTextModelWithProjection(__lowercase      )
        __UpperCAmelCase							:			Any     =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	,   local_files_only=__lowercase      )

        __UpperCAmelCase							:			Optional[Any]     =						{
            """unet""": unet,
            """scheduler""": scheduler,
            """vae""": vae,
            """text_encoder""": text_encoder,
            """tokenizer""": tokenizer,
            """text_encoder_2""": text_encoder_a,
            """tokenizer_2""": tokenizer_a,
            # "safety_checker": None,
            # "feature_extractor": None,
        }
        return components
      def 			UpperCAmelCase   (   self      :    List[Any]	,   __lowercase      :    List[str]	,   __lowercase      :    Optional[Any]=0      )							->   Dict:






        if str(__lowercase      ).startswith("""mps"""      ):
          __UpperCAmelCase							:			str     =						torch.manual_seed(__lowercase      )
        else:
          __UpperCAmelCase							:			Tuple     =						torch.Generator(device=__lowercase      ).manual_seed(__lowercase      )
        __UpperCAmelCase							:			Optional[Any]     =						{
            """prompt""": """A painting of a squirrel eating a burger""",
            """generator""": generator,
            """num_inference_steps""": 2,
            """guidance_scale""": 5.0,
            """output_type""": """numpy""",
        }
        return inputs
      def 			UpperCAmelCase   (   self      :    Union[str, Any]      )							->   Optional[Any]:
        __UpperCAmelCase							:			Union[str, Any]     =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator
        __UpperCAmelCase							:			List[Any]     =						self.get_dummy_components()
        __UpperCAmelCase							:			Optional[Any]     =						StableDiffusionXLPipeline(**__lowercase      )
        __UpperCAmelCase							:			int     =						sd_pipe.to(__lowercase      )
        sd_pipe.set_progress_bar_config(disable=__lowercase      )

        __UpperCAmelCase							:			List[Any]     =						self.get_dummy_inputs(__lowercase      )
        __UpperCAmelCase							:			Dict     =						sd_pipe(**__lowercase      ).images
        __UpperCAmelCase							:			int     =						image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        __UpperCAmelCase							:			Optional[int]     =						np.array([0.5_873, 0.6_128, 0.4_797, 0.5_122, 0.5_674, 0.4_639, 0.5_227, 0.5_149, 0.4_747]      )

        assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
      def 			UpperCAmelCase   (   self      :    Union[str, Any]      )							->   str:
        __UpperCAmelCase							:			Tuple     =						self.get_dummy_components()
        __UpperCAmelCase							:			Tuple     =						StableDiffusionXLPipeline(**__lowercase      )
        __UpperCAmelCase							:			Any     =						sd_pipe.to(__lowercase      )
        __UpperCAmelCase							:			Tuple     =						sd_pipe.to(__lowercase      )
        sd_pipe.set_progress_bar_config(disable=__lowercase      )

        # forward without prompt embeds
        __UpperCAmelCase							:			List[Any]     =						self.get_dummy_inputs(__lowercase      )
        __UpperCAmelCase							:			Any     =						3 * ["""this is a negative prompt"""]
        __UpperCAmelCase							:			Dict     =						negative_prompt
        __UpperCAmelCase							:			Optional[int]     =						3 * [inputs["""prompt"""]]

        __UpperCAmelCase							:			Optional[int]     =						sd_pipe(**__lowercase      )
        __UpperCAmelCase							:			Union[str, Any]     =						output.images[0, -3:, -3:, -1]

        # forward with prompt embeds
        __UpperCAmelCase							:			Any     =						self.get_dummy_inputs(__lowercase      )
        __UpperCAmelCase							:			int     =						3 * ["""this is a negative prompt"""]
        __UpperCAmelCase							:			List[str]     =						3 * [inputs.pop("""prompt"""      )]

        (
            (
            __UpperCAmelCase       
        )   ,				(
            __UpperCAmelCase       
        )   ,				(
            __UpperCAmelCase       
        )   ,				(
            __UpperCAmelCase       
        )   ,				       
        )							:			Optional[int]     =						sd_pipe.encode_prompt(__lowercase	,   negative_prompt=__lowercase      )

        __UpperCAmelCase							:			Tuple     =						sd_pipe(
            **__lowercase	,   prompt_embeds=__lowercase	,   negative_prompt_embeds=__lowercase	,   pooled_prompt_embeds=__lowercase	,   negative_pooled_prompt_embeds=__lowercase	,   )
        __UpperCAmelCase							:			List[str]     =						output.images[0, -3:, -3:, -1]

        # make sure that it's equal
        assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()      ).max() < 1e-4
      def 			UpperCAmelCase   (   self      :    Optional[Any]      )							->   List[str]:
        super().test_attention_slicing_forward_pass(expected_max_diff=3e-3      )




      def 			UpperCAmelCase   (   self      :    Any      )							->   Optional[int]:
        super().test_inference_batch_single_identical(expected_max_diff=3e-3      )


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



      """simple docstring"""


      def 			UpperCAmelCase   (   self      :    List[Any]      )							->   Tuple:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()
      def 			UpperCAmelCase   (   self      :    List[Any]	,   __lowercase      :    Any	,   __lowercase      :    Tuple="cpu"	,   __lowercase      :    Any=torch.floataa	,   __lowercase      :    List[str]=0      )							->   List[Any]:
        __UpperCAmelCase							:			List[Any]     =						torch.Generator(device=__lowercase      ).manual_seed(__lowercase      )
        __UpperCAmelCase							:			str     =						np.random.RandomState(__lowercase      ).standard_normal((1, 4, 64, 64)      )
        __UpperCAmelCase							:			Dict     =						torch.from_numpy(__lowercase      ).to(device=__lowercase	,   dtype=__lowercase      )
        __UpperCAmelCase							:			Optional[Any]     =						{
            """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 			UpperCAmelCase   (   self      :    Any      )							->   Optional[int]:
        __UpperCAmelCase							:			int     =						DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""      )
        pipe.to(__lowercase      )
        pipe.set_progress_bar_config(disable=__lowercase      )

        __UpperCAmelCase							:			int     =						self.get_inputs(__lowercase      )
        __UpperCAmelCase							:			Optional[int]     =						pipe(**__lowercase      ).images
        __UpperCAmelCase							:			Union[str, Any]     =						image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 512, 512, 3)
        __UpperCAmelCase							:			Any     =						np.array([0.49_493, 0.47_896, 0.40_798, 0.54_214, 0.53_212, 0.48_202, 0.47_656, 0.46_329, 0.48_506]      )
        assert np.abs(image_slice - expected_slice      ).max() < 7e-3










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


a	: Union[str, Any]      =				{
    "configuration_mobilenet_v1": [
        "MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "MobileNetV1Config",
        "MobileNetV1OnnxConfig",
    ],
}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: int      =				["MobileNetV1FeatureExtractor"]
       a	: int      =				["MobileNetV1ImageProcessor"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: int      =				[
           "MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST",
           "MobileNetV1ForImageClassification",
           "MobileNetV1Model",
           "MobileNetV1PreTrainedModel",
           "load_tf_weights_in_mobilenet_v1",
       ]


if TYPE_CHECKING:
       from .configuration_mobilenet_va import (
           MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP,
           MobileNetVaConfig,
           MobileNetVaOnnxConfig,
       )

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_mobilenet_va import MobileNetVaFeatureExtractor
              from .image_processing_mobilenet_va import MobileNetVaImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_mobilenet_va import (
                  MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST,
                  MobileNetVaForImageClassification,
                  MobileNetVaModel,
                  MobileNetVaPreTrainedModel,
                  load_tf_weights_in_mobilenet_va,
              )


else:
       import sys

       a	: str      =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


