
'''simple docstring'''






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import 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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


A			      =      False




@skip_mps
class     __snake_case		(   a__    ,   a__    ,   a__    ,   unittest.TestCase):
					_lowerCAmelCase			     =	StableDiffusionAttendAndExcitePipeline
					_lowerCAmelCase			     =	False
					_lowerCAmelCase			     =	TEXT_TO_IMAGE_PARAMS
					_lowerCAmelCase			     =	TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''})
					_lowerCAmelCase			     =	TEXT_TO_IMAGE_IMAGE_PARAMS
					_lowerCAmelCase			     =	TEXT_TO_IMAGE_IMAGE_PARAMS
					@classmethod
					def     UpperCAmelCase_							(     cls      ):

									"""simple docstring"""


									super().setUpClass()
									torch.use_deterministic_algorithms(A      )
					@classmethod
					def     UpperCAmelCase_							(     cls      ):

									"""simple docstring"""


									super().tearDownClass()
									torch.use_deterministic_algorithms(A      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									torch.manual_seed(0      )
									lowerCamelCase					:			List[str]									= UNetaDConditionModel(
									    block_out_channels=(32, 64),    layers_per_block=1,    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=A,    )
									lowerCamelCase					:			str									= DDIMScheduler(
									    beta_start=0.0_0085,    beta_end=0.012,    beta_schedule='scaled_linear',    clip_sample=A,    set_alpha_to_one=A,    )
									torch.manual_seed(0      )
									lowerCamelCase					:			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      )
									lowerCamelCase					:			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,    hidden_act='gelu',    projection_dim=512,    )
									lowerCamelCase					:			int									= CLIPTextModel(A      )
									lowerCamelCase					:			List[str]									= CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

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

									return components
					def     UpperCAmelCase_							(     self,    A,    A=0      ):

									"""simple docstring"""


									if str(A      ).startswith('mps'      ):
													lowerCamelCase					:			Dict									= torch.manual_seed(A      )
									else:
													lowerCamelCase					:			Optional[Any]									= torch.Generator(device=A      ).manual_seed(A      )
									lowerCamelCase					:			str									= {
									    'prompt': 'a cat and a frog',
									    'token_indices': [2, 5],
									    'generator': generator,
									    'num_inference_steps': 1,
									    'guidance_scale': 6.0,
									    'output_type': 'numpy',
									    'max_iter_to_alter': 2,
									    'thresholds': {0: 0.7},
									}
									return inputs
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			int									= 'cpu'

									lowerCamelCase					:			Union[str, Any]									= self.get_dummy_components()
									lowerCamelCase					:			List[Any]									= self.pipeline_class(**A      )
									pipe.to(A      )
									pipe.set_progress_bar_config(disable=A      )

									lowerCamelCase					:			Optional[int]									= self.get_dummy_inputs(A      )
									lowerCamelCase					:			List[Any]									= pipe(**A      ).images
									lowerCamelCase					:			str									= image[0, -3:, -3:, -1]

									self.assertEqual(image.shape,    (1, 64, 64, 3)      )
									lowerCamelCase					:			Tuple									= np.array(
									    [0.6390_5364, 0.6289_7307, 0.4859_9017, 0.513_3624, 0.555_0048, 0.4576_9516, 0.5032_6973, 0.502_3139, 0.4538_4496]      )
									lowerCamelCase					:			Dict									= np.abs(image_slice.flatten() - expected_slice      ).max()
									self.assertLessEqual(A,    1e-3      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									super().test_cpu_offload_forward_pass(expected_max_diff=5e-4      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									self._test_inference_batch_consistent(batch_sizes=[1, 2]      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									self._test_inference_batch_single_identical(batch_size=2,    expected_max_diff=7e-4      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									super().test_save_load_local(expected_max_difference=5e-4      )




					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									super().test_save_load_optional_components(expected_max_difference=4e-4      )





@require_torch_gpu
@slow
class     __snake_case		(   unittest.TestCase):
					@classmethod
					def     UpperCAmelCase_							(     cls      ):

									"""simple docstring"""


									super().setUpClass()
									torch.use_deterministic_algorithms(A      )
					@classmethod
					def     UpperCAmelCase_							(     cls      ):

									"""simple docstring"""


									super().tearDownClass()
									torch.use_deterministic_algorithms(A      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


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




					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			Optional[int]									= torch.manual_seed(51      )

									lowerCamelCase					:			Any									= StableDiffusionAttendAndExcitePipeline.from_pretrained(
									    'CompVis/stable-diffusion-v1-4',    safety_checker=A,    torch_dtype=torch.floataa      )
									pipe.to('cuda'      )

									lowerCamelCase					:			List[Any]									= 'a painting of an elephant with glasses'
									lowerCamelCase					:			List[Any]									= [5, 7]

									lowerCamelCase					:			Any									= pipe(
									    prompt=A,    token_indices=A,    guidance_scale=7.5,    generator=A,    num_inference_steps=5,    max_iter_to_alter=5,    output_type='numpy',    ).images[0]

									lowerCamelCase					:			Dict									= load_numpy(
									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy'      )
									assert np.abs((expected_image - image).max()      ) < 5e-1


'''simple docstring'''






import warnings
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A			      =      logging.get_logger(__name__)

A			      =      {
    'nvidia/segformer-b0-finetuned-ade-512-512': (
        'https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512/resolve/main/config.json'
    ),
    # See all SegFormer models at https://huggingface.co/models?filter=segformer
}




class     __snake_case		(   a__):
					_lowerCAmelCase			     =	'''segformer'''
					def __init__(     self,    A=3,    A=4,    A=[2, 2, 2, 2],    A=[8, 4, 2, 1],    A=[32, 64, 160, 256],    A=[7, 3, 3, 3],    A=[4, 2, 2, 2],    A=[1, 2, 5, 8],    A=[4, 4, 4, 4],    A="gelu",    A=0.0,    A=0.0,    A=0.1,    A=0.02,    A=0.1,    A=1e-6,    A=256,    A=255,    **A,    ):

									"""simple docstring"""


									super().__init__(**A      )

									if "reshape_last_stage" in kwargs and kwargs["reshape_last_stage"] is False:
													warnings.warn(
													    'Reshape_last_stage is set to False in this config. This argument is deprecated and will soon be'
													    ' removed, as the behaviour will default to that of reshape_last_stage = True.',    A,    )

									lowerCamelCase					:			Tuple									= num_channels
									lowerCamelCase					:			Dict									= num_encoder_blocks
									lowerCamelCase					:			Dict									= depths
									lowerCamelCase					:			Any									= sr_ratios
									lowerCamelCase					:			List[Any]									= hidden_sizes
									lowerCamelCase					:			List[Any]									= patch_sizes
									lowerCamelCase					:			Tuple									= strides
									lowerCamelCase					:			int									= mlp_ratios
									lowerCamelCase					:			Dict									= num_attention_heads
									lowerCamelCase					:			Union[str, Any]									= hidden_act
									lowerCamelCase					:			Tuple									= hidden_dropout_prob
									lowerCamelCase					:			Optional[int]									= attention_probs_dropout_prob
									lowerCamelCase					:			List[str]									= classifier_dropout_prob
									lowerCamelCase					:			Union[str, Any]									= initializer_range
									lowerCamelCase					:			Union[str, Any]									= drop_path_rate
									lowerCamelCase					:			int									= layer_norm_eps
									lowerCamelCase					:			Any									= decoder_hidden_size
									lowerCamelCase					:			Optional[int]									= kwargs.get('reshape_last_stage',    A      )
									lowerCamelCase					:			Any									= semantic_loss_ignore_index





class     __snake_case		(   a__):
					_lowerCAmelCase			     =	version.parse('''1.11''')
					@property
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									return OrderedDict(
									    [
									        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
									    ]      )
					@property
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									return 1e-4




					@property
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									return 12
