
from __future__ import annotations

from typing import Dict

from ...configuration_utils import PretrainedConfig


__lowerCAmelCase					:			str			      =		{
    "susnato/ernie-m-base_pytorch": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/config.json",
    "susnato/ernie-m-large_pytorch": "https://huggingface.co/susnato/ernie-m-large_pytorch/blob/main/config.json",
}


class 						__lowerCAmelCase	(	lowerCAmelCase_      ):



      """simple docstring"""







      A__	:			str        =    '''ernie_m'''
      A__	:			Dict[str, str]        =    {"dropout": "classifier_dropout", "num_classes": "num_labels"}




      def __init__(      self		:       Optional[Any]				,       _snake_case		:       int = 25_0002				,       _snake_case		:       int = 768				,       _snake_case		:       int = 12				,       _snake_case		:       int = 12				,       _snake_case		:       int = 3072				,       _snake_case		:       str = "gelu"				,       _snake_case		:       float = 0.1				,       _snake_case		:       float = 0.1				,       _snake_case		:       int = 514				,       _snake_case		:       float = 0.02				,       _snake_case		:       int = 1				,       _snake_case		:       float = 1E-0_5				,       _snake_case		:       int=None				,       _snake_case		:       Dict=False				,       _snake_case		:       List[str]=0.0				,       **_snake_case		:       List[Any]				,       ):
          super().__init__(pad_token_id=_snake_case				,       **_snake_case				)
          __lowercase		:			Any	    =       vocab_size
          __lowercase		:			Optional[Any]	    =       hidden_size
          __lowercase		:			List[str]	    =       num_hidden_layers
          __lowercase		:			Any	    =       num_attention_heads
          __lowercase		:			List[Any]	    =       intermediate_size
          __lowercase		:			Optional[int]	    =       hidden_act
          __lowercase		:			str	    =       hidden_dropout_prob
          __lowercase		:			str	    =       attention_probs_dropout_prob
          __lowercase		:			Any	    =       max_position_embeddings
          __lowercase		:			Optional[int]	    =       initializer_range
          __lowercase		:			int	    =       layer_norm_eps
          __lowercase		:			Optional[Any]	    =       classifier_dropout
          __lowercase		:			Any	    =       is_decoder
          __lowercase		:			List[str]	    =       act_dropout




import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    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 						__lowerCAmelCase	(	lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase      ):



      """simple docstring"""







      A__	:			int        =    StableDiffusionSAGPipeline
      A__	:			Union[str, Any]        =    TEXT_TO_IMAGE_PARAMS
      A__	:			Dict        =    TEXT_TO_IMAGE_BATCH_PARAMS
      A__	:			List[str]        =    TEXT_TO_IMAGE_IMAGE_PARAMS
      A__	:			int        =    TEXT_TO_IMAGE_IMAGE_PARAMS
      A__	:			List[str]        =    False




      def 		snake_case_			(      self		:       Optional[Any]				):
          torch.manual_seed(0				)
          __lowercase		:			Optional[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''')				,       cross_attention_dim=32				,       )
          __lowercase		:			int	    =       DDIMScheduler(
              beta_start=0.0_00_85				,       beta_end=0.0_12				,       beta_schedule='''scaled_linear'''				,       clip_sample=_snake_case				,       set_alpha_to_one=_snake_case				,       )
          torch.manual_seed(0				)
          __lowercase		:			List[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				,       )
          torch.manual_seed(0				)
          __lowercase		:			Tuple	    =       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				,       )
          __lowercase		:			List[Any]	    =       CLIPTextModel(_snake_case				)
          __lowercase		:			List[Any]	    =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

          __lowercase		:			int	    =       {
              '''unet''': unet,
              '''scheduler''': scheduler,
              '''vae''': vae,
              '''text_encoder''': text_encoder,
              '''tokenizer''': tokenizer,
              '''safety_checker''': None,
              '''feature_extractor''': None,
          }
          return components




      def 		snake_case_			(      self		:       Tuple				,       _snake_case		:       List[str]				,       _snake_case		:       List[str]=0				):
          if str(_snake_case				).startswith('''mps'''				):
              __lowercase		:			Optional[int]	    =       torch.manual_seed(_snake_case				)
          else:
              __lowercase		:			Tuple	    =       torch.Generator(device=_snake_case				).manual_seed(_snake_case				)
          __lowercase		:			Tuple	    =       {
              '''prompt''': '''.''',
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''guidance_scale''': 1.0,
              '''sag_scale''': 1.0,
              '''output_type''': '''numpy''',
          }
          return inputs




      def 		snake_case_			(      self		:       Any				):
          super().test_inference_batch_single_identical(expected_max_diff=3E-3				)






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



      """simple docstring"""







      def 		snake_case_			(      self		:       int				):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()




      def 		snake_case_			(      self		:       Dict				):
          __lowercase		:			Optional[int]	    =       StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''				)
          __lowercase		:			Optional[int]	    =       sag_pipe.to(_snake_case				)
          sag_pipe.set_progress_bar_config(disable=_snake_case				)

          __lowercase		:			List[str]	    =       '''.'''
          __lowercase		:			List[str]	    =       torch.manual_seed(0				)
          __lowercase		:			List[str]	    =       sag_pipe(
              [prompt]				,       generator=_snake_case				,       guidance_scale=7.5				,       sag_scale=1.0				,       num_inference_steps=20				,       output_type='''np'''				)

          __lowercase		:			Optional[Any]	    =       output.images

          __lowercase		:			Dict	    =       image[0, -3:, -3:, -1]

          assert image.shape == (1, 512, 512, 3)
          __lowercase		:			int	    =       np.array([0.15_68, 0.17_38, 0.16_95, 0.16_93, 0.15_07, 0.17_05, 0.15_47, 0.17_51, 0.19_49]				)

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




      def 		snake_case_			(      self		:       Optional[int]				):
          __lowercase		:			Dict	    =       StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''				)
          __lowercase		:			Any	    =       sag_pipe.to(_snake_case				)
          sag_pipe.set_progress_bar_config(disable=_snake_case				)

          __lowercase		:			List[str]	    =       '''.'''
          __lowercase		:			List[str]	    =       torch.manual_seed(0				)
          __lowercase		:			int	    =       sag_pipe(
              [prompt]				,       generator=_snake_case				,       guidance_scale=7.5				,       sag_scale=1.0				,       num_inference_steps=20				,       output_type='''np'''				)

          __lowercase		:			str	    =       output.images

          __lowercase		:			Tuple	    =       image[0, -3:, -3:, -1]

          assert image.shape == (1, 512, 512, 3)
          __lowercase		:			Any	    =       np.array([0.34_59, 0.28_76, 0.25_37, 0.30_02, 0.26_71, 0.21_60, 0.30_26, 0.22_62, 0.23_71]				)

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




      def 		snake_case_			(      self		:       int				):
          __lowercase		:			List[str]	    =       StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''				)
          __lowercase		:			Tuple	    =       sag_pipe.to(_snake_case				)
          sag_pipe.set_progress_bar_config(disable=_snake_case				)

          __lowercase		:			Union[str, Any]	    =       '''.'''
          __lowercase		:			Tuple	    =       torch.manual_seed(0				)
          __lowercase		:			Optional[int]	    =       sag_pipe(
              [prompt]				,       width=768				,       height=512				,       generator=_snake_case				,       guidance_scale=7.5				,       sag_scale=1.0				,       num_inference_steps=20				,       output_type='''np'''				,       )

          __lowercase		:			Dict	    =       output.images

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


