


"""simple docstring"""







import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class 				__A    (	_SCREAMING_SNAKE_CASE,   _SCREAMING_SNAKE_CASE,   unittest.TestCase      ):






 """simple docstring"""




 __lowerCAmelCase			 =  StableDiffusionXLImgaImgPipeline
 __lowerCAmelCase			 =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
 __lowerCAmelCase			 =  PipelineTesterMixin.required_optional_params - {"latents"}
 __lowerCAmelCase			 =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 __lowerCAmelCase			 =  IMAGE_TO_IMAGE_IMAGE_PARAMS
 __lowerCAmelCase			 =  IMAGE_TO_IMAGE_IMAGE_PARAMS


 def 				SCREAMING_SNAKE_CASE							(		self						) ->					Any:
     torch.manual_seed(0						)
     a					=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=__A			,   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			,   )
     a					=EulerDiscreteScheduler(
         beta_start=0.00_085			,   beta_end=0.012			,   steps_offset=1			,   beta_schedule='''scaled_linear'''			,   timestep_spacing='''leading'''			,   )
     torch.manual_seed(0						)
     a					=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					=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			,   )
     a					=CLIPTextModel(__A						)
     a					=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			,   local_files_only=__A						)

     a					=CLIPTextModelWithProjection(__A						)
     a					=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			,   local_files_only=__A						)

     a					={
         '''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 				SCREAMING_SNAKE_CASE							(		self			,   __A			,   __A=0						) ->					Tuple:
     a					=floats_tensor((1, 3, 32, 32)			,   rng=random.Random(__A						)						).to(__A						)
     a					=image / 2 + 0.5
     if str(__A						).startswith('''mps'''						):
         a					=torch.manual_seed(__A						)
     else:
         a					=torch.Generator(device=__A						).manual_seed(__A						)
     a					={
         '''prompt''': '''A painting of a squirrel eating a burger''',
         '''image''': image,
         '''generator''': generator,
         '''num_inference_steps''': 2,
         '''guidance_scale''': 5.0,
         '''output_type''': '''numpy''',
         '''strength''': 0.75,
     }
     return inputs


 def 				SCREAMING_SNAKE_CASE							(		self						) ->					List[str]:
     a					='''cpu'''  # ensure determinism for the device-dependent torch.Generator
     a					=self.get_dummy_components()
     a					=StableDiffusionXLImgaImgPipeline(**__A						)
     a					=sd_pipe.to(__A						)
     sd_pipe.set_progress_bar_config(disable=__A						)

     a					=self.get_dummy_inputs(__A						)
     a					=sd_pipe(**__A						).images
     a					=image[0, -3:, -3:, -1]

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

     a					=np.array([0.4_656, 0.4_840, 0.4_439, 0.6_698, 0.5_574, 0.4_524, 0.5_799, 0.5_943, 0.5_165]						)

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


 def 				SCREAMING_SNAKE_CASE							(		self						) ->					str:
     super().test_attention_slicing_forward_pass(expected_max_diff=3E-3						)


 def 				SCREAMING_SNAKE_CASE							(		self						) ->					List[Any]:
     super().test_inference_batch_single_identical(expected_max_diff=3E-3						)


 def 				SCREAMING_SNAKE_CASE							(		self						) ->					Optional[Any]:
     pass





 def 				SCREAMING_SNAKE_CASE							(		self						) ->					Union[str, Any]:
     a					=self.get_dummy_components()
     a					=StableDiffusionXLImgaImgPipeline(**__A						)
     a					=sd_pipe.to(__A						)
     a					=sd_pipe.to(__A						)
     sd_pipe.set_progress_bar_config(disable=__A						)

     # forward without prompt embeds
     a					=self.get_dummy_inputs(__A						)
     a					=3 * ['''this is a negative prompt''']
     a					=negative_prompt
     a					=3 * [inputs['''prompt''']]

     a					=sd_pipe(**__A						)
     a					=output.images[0, -3:, -3:, -1]

     # forward with prompt embeds
     a					=self.get_dummy_inputs(__A						)
     a					=3 * ['''this is a negative prompt''']
     a					=3 * [inputs.pop('''prompt'''						)]

     (
         (
         a
     )		,				(
         a
     )		,				(
         a
     )		,				(
         a
     )		,				
     )					=sd_pipe.encode_prompt(__A			,   negative_prompt=__A						)

     a					=sd_pipe(
         **__A			,   prompt_embeds=__A			,   negative_prompt_embeds=__A			,   pooled_prompt_embeds=__A			,   negative_pooled_prompt_embeds=__A			,   )
     a					=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






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






 """simple docstring"""




 def 				SCREAMING_SNAKE_CASE							(		self						) ->					Union[str, Any]:
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()


 def 				SCREAMING_SNAKE_CASE							(		self			,   __A			,   __A="cpu"			,   __A=torch.floataa			,   __A=0						) ->					Dict:
     a					=torch.Generator(device=__A						).manual_seed(__A						)
     a					=np.random.RandomState(__A						).standard_normal((1, 4, 64, 64)						)
     a					=torch.from_numpy(__A						).to(device=__A			,   dtype=__A						)
     a					={
         '''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 				SCREAMING_SNAKE_CASE							(		self						) ->					Tuple:
     a					=DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''						)
     pipe.to(__A						)
     pipe.set_progress_bar_config(disable=__A						)

     a					=self.get_inputs(__A						)
     a					=pipe(**__A						).images
     a					=image[0, -3:, -3:, -1].flatten()

     assert image.shape == (1, 512, 512, 3)
     a					=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



"""simple docstring"""







import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import CONFIG_MAPPING


lowerCamelCase_       :       int      						=  logging.get_logger(__name__)






class 				__A    (	_SCREAMING_SNAKE_CASE      ):






 """simple docstring"""




 __lowerCAmelCase			 =  "upernet"


 def __init__(		self			,   __A=None			,   __A=512			,   __A=0.02			,   __A=[1, 2, 3, 6]			,   __A=True			,   __A=0.4			,   __A=384			,   __A=256			,   __A=1			,   __A=False			,   __A=255			,   **__A			,   ) ->					Tuple:
     super().__init__(**__A						)

     if backbone_config is None:
         logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''						)
         a					=CONFIG_MAPPING['''resnet'''](out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']						)
     elif isinstance(__A			,   __A						):
         a					=backbone_config.get('''model_type'''						)
         a					=CONFIG_MAPPING[backbone_model_type]
         a					=config_class.from_dict(__A						)

     a					=backbone_config
     a					=hidden_size
     a					=initializer_range
     a					=pool_scales
     a					=use_auxiliary_head
     a					=auxiliary_loss_weight
     a					=auxiliary_in_channels
     a					=auxiliary_channels
     a					=auxiliary_num_convs
     a					=auxiliary_concat_input
     a					=loss_ignore_index





 def 				SCREAMING_SNAKE_CASE							(		self						) ->					Dict:
     a					=copy.deepcopy(self.__dict__						)
     a					=self.backbone_config.to_dict()
     a					=self.__class__.model_type
     return output