





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


lowerCAmelCase_						   =    False



@skip_mps
class        _lowerCAmelCase    (			UpperCAmelCase_							,    UpperCAmelCase_							,    UpperCAmelCase_							,    unittest.TestCase							):


  '''simple docstring'''
  a_							:       Optional[int]      					=StableDiffusionAttendAndExcitePipeline
  a_							:       Optional[Any]      					=False
  a_							:       Union[str, Any]      					=TEXT_TO_IMAGE_PARAMS
  a_							:       Dict      					=TEXT_TO_IMAGE_BATCH_PARAMS.union({"""token_indices"""}							)
  a_							:       Tuple      					=TEXT_TO_IMAGE_IMAGE_PARAMS
  a_							:       List[Any]      					=TEXT_TO_IMAGE_IMAGE_PARAMS







  @classmethod
  def UpperCamelCase_ (      cls      :					List[str]							):


    '''simple docstring'''





    super().setUpClass()
    torch.use_deterministic_algorithms(UpperCamelCase							)







  @classmethod
  def UpperCamelCase_ (      cls      :					List[str]							):


    '''simple docstring'''





    super().tearDownClass()
    torch.use_deterministic_algorithms(UpperCamelCase							)







  def UpperCamelCase_ (      self      :					List[Any]							):


    '''simple docstring'''





    torch.manual_seed(0							)
    _snake_case   :				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=UpperCamelCase      ,				)
    _snake_case   :				str														=      DDIMScheduler(
        beta_start=0.0_00_85      ,				beta_end=0.0_12      ,				beta_schedule='scaled_linear'      ,				clip_sample=UpperCamelCase      ,				set_alpha_to_one=UpperCamelCase      ,				)
    torch.manual_seed(0							)
    _snake_case   :				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=1_28      ,				)
    torch.manual_seed(0							)
    _snake_case   :				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=10_00      ,				hidden_act='gelu'      ,				projection_dim=5_12      ,				)
    _snake_case   :				Any														=      CLIPTextModel(UpperCamelCase							)
    _snake_case   :				List[str]														=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'							)

    _snake_case   :				int														=      {
        'unet': unet,
        'scheduler': scheduler,
        'vae': vae,
        'text_encoder': text_encoder,
        'tokenizer': tokenizer,
        'safety_checker': None,
        'feature_extractor': None,
    }

    return components







  def UpperCamelCase_ (      self      :					List[str]      ,				UpperCamelCase      :					Dict      ,				UpperCamelCase      :					List[Any]=0							):


    '''simple docstring'''





    if str(UpperCamelCase							).startswith('mps'							):
      _snake_case   :				Any														=      torch.manual_seed(UpperCamelCase							)
    else:
      _snake_case   :				List[str]														=      torch.Generator(device=UpperCamelCase							).manual_seed(UpperCamelCase							)
    _snake_case   :				Union[str, Any]														=      {
        '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      :					Dict							):


    '''simple docstring'''





    _snake_case   :				List[Any]														=      'cpu'

    _snake_case   :				List[Any]														=      self.get_dummy_components()
    _snake_case   :				Any														=      self.pipeline_class(**UpperCamelCase							)
    pipe.to(UpperCamelCase							)
    pipe.set_progress_bar_config(disable=UpperCamelCase							)

    _snake_case   :				Tuple														=      self.get_dummy_inputs(UpperCamelCase							)
    _snake_case   :				Optional[Any]														=      pipe(**UpperCamelCase							).images
    _snake_case   :				Optional[Any]														=      image[0, -3:, -3:, -1]

    self.assertEqual(image.shape      ,				(1, 64, 64, 3)							)
    _snake_case   :				List[str]														=      np.array(
        [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96]							)
    _snake_case   :				List[Any]														=      np.abs(image_slice.flatten() - expected_slice							).max()
    self.assertLessEqual(UpperCamelCase      ,				1e-3							)







  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    super().test_cpu_offload_forward_pass(expected_max_diff=5e-4							)







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





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







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





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







  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3							)







  def UpperCamelCase_ (      self      :					Union[str, Any]							):


    '''simple docstring'''





    super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4							)







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





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







  def UpperCamelCase_ (      self      :					Optional[Any]							):


    '''simple docstring'''





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




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


  '''simple docstring'''







  @classmethod
  def UpperCamelCase_ (      cls      :					Optional[Any]							):


    '''simple docstring'''





    super().setUpClass()
    torch.use_deterministic_algorithms(UpperCamelCase							)







  @classmethod
  def UpperCamelCase_ (      cls      :					List[str]							):


    '''simple docstring'''





    super().tearDownClass()
    torch.use_deterministic_algorithms(UpperCamelCase							)







  def UpperCamelCase_ (      self      :					Any							):


    '''simple docstring'''





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







  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    _snake_case   :				List[str]														=      torch.manual_seed(51							)

    _snake_case   :				Optional[Any]														=      StableDiffusionAttendAndExcitePipeline.from_pretrained(
        'CompVis/stable-diffusion-v1-4'      ,				safety_checker=UpperCamelCase      ,				torch_dtype=torch.floataa							)
    pipe.to('cuda'							)

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

    _snake_case   :				int														=      pipe(
        prompt=UpperCamelCase      ,				token_indices=UpperCamelCase      ,				guidance_scale=7.5      ,				generator=UpperCamelCase      ,				num_inference_steps=5      ,				max_iter_to_alter=5      ,				output_type='numpy'      ,				).images[0]

    _snake_case   :				Union[str, Any]														=      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











from collections import OrderedDict
from typing import Mapping

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


lowerCAmelCase_						   =    logging.get_logger(__name__)

lowerCAmelCase_						   =    {
    """roberta-base""": """https://huggingface.co/roberta-base/resolve/main/config.json""",
    """roberta-large""": """https://huggingface.co/roberta-large/resolve/main/config.json""",
    """roberta-large-mnli""": """https://huggingface.co/roberta-large-mnli/resolve/main/config.json""",
    """distilroberta-base""": """https://huggingface.co/distilroberta-base/resolve/main/config.json""",
    """roberta-base-openai-detector""": """https://huggingface.co/roberta-base-openai-detector/resolve/main/config.json""",
    """roberta-large-openai-detector""": """https://huggingface.co/roberta-large-openai-detector/resolve/main/config.json""",
}



class        _lowerCAmelCase    (			UpperCAmelCase_							):


  '''simple docstring'''
  a_							:       int      					="""roberta"""







  def __init__(      self      :					int      ,				UpperCamelCase      :					Tuple=5_02_65      ,				UpperCamelCase      :					Any=7_68      ,				UpperCamelCase      :					List[Any]=12      ,				UpperCamelCase      :					str=12      ,				UpperCamelCase      :					Dict=30_72      ,				UpperCamelCase      :					Any="gelu"      ,				UpperCamelCase      :					List[Any]=0.1      ,				UpperCamelCase      :					Optional[Any]=0.1      ,				UpperCamelCase      :					Optional[Any]=5_12      ,				UpperCamelCase      :					List[str]=2      ,				UpperCamelCase      :					Optional[Any]=0.02      ,				UpperCamelCase      :					Tuple=1e-1_2      ,				UpperCamelCase      :					str=1      ,				UpperCamelCase      :					int=0      ,				UpperCamelCase      :					Any=2      ,				UpperCamelCase      :					int="absolute"      ,				UpperCamelCase      :					int=True      ,				UpperCamelCase      :					List[Any]=None      ,				**UpperCamelCase      :					Any      ,				):


    '''simple docstring'''





    super().__init__(pad_token_id=UpperCamelCase      ,				bos_token_id=UpperCamelCase      ,				eos_token_id=UpperCamelCase      ,				**UpperCamelCase							)

    _snake_case   :				Any														=	vocab_size
    _snake_case   :				List[str]														=	hidden_size
    _snake_case   :				List[str]														=	num_hidden_layers
    _snake_case   :				Dict														=	num_attention_heads
    _snake_case   :				List[str]														=	hidden_act
    _snake_case   :				Union[str, Any]														=	intermediate_size
    _snake_case   :				Union[str, Any]														=	hidden_dropout_prob
    _snake_case   :				Optional[int]														=	attention_probs_dropout_prob
    _snake_case   :				Dict														=	max_position_embeddings
    _snake_case   :				Optional[int]														=	type_vocab_size
    _snake_case   :				Tuple														=	initializer_range
    _snake_case   :				int														=	layer_norm_eps
    _snake_case   :				Dict														=	position_embedding_type
    _snake_case   :				Union[str, Any]														=	use_cache
    _snake_case   :				str														=	classifier_dropout




class        _lowerCAmelCase    (			UpperCAmelCase_							):


  '''simple docstring'''







  @property
  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    if self.task == "multiple-choice":
      _snake_case   :				Optional[Any]														=	{0: 'batch', 1: 'choice', 2: 'sequence'}
    else:
      _snake_case   :				Dict														=	{0: 'batch', 1: 'sequence'}
    return OrderedDict(
        [
            ('input_ids', dynamic_axis),
            ('attention_mask', dynamic_axis),
        ]							)




