import unittest

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

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()





class      lowerCAmelCase						(					unittest.TestCase			):



     @property
     def 			a__  (					self       ):
            torch.manual_seed(0       )
            _A=	UNetaDModel(
                block_out_channels=(32, 64)				,      layers_per_block=2				,      sample_size=32				,      in_channels=3				,      out_channels=3				,      down_block_types=('DownBlock2D', 'AttnDownBlock2D')				,      up_block_types=('AttnUpBlock2D', 'UpBlock2D')				,      )
            return model



     @property
     def 			a__  (					self       ):
            torch.manual_seed(0       )
            _A=	VQModel(
                block_out_channels=[32, 64]				,      in_channels=3				,      out_channels=3				,      down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']				,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']				,      latent_channels=3				,      )
            return model



     @property
     def 			a__  (					self       ):
            torch.manual_seed(0       )
            _A=	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				,      )
            return CLIPTextModel(lowerCAmelCase__       )





     def 			a__  (					self       ):
            _A=	self.dummy_uncond_unet
            _A=	DDIMScheduler()
            _A=	self.dummy_vq_model

            _A=	LDMPipeline(unet=lowerCAmelCase__				,      vqvae=lowerCAmelCase__				,      scheduler=lowerCAmelCase__       )
            ldm.to(lowerCAmelCase__       )
            ldm.set_progress_bar_config(disable=lowerCAmelCase__       )

            _A=	torch.manual_seed(0       )
            _A=	ldm(generator=lowerCAmelCase__				,      num_inference_steps=2				,      output_type='numpy'       ).images

            _A=	torch.manual_seed(0       )
            _A=	ldm(generator=lowerCAmelCase__				,      num_inference_steps=2				,      output_type='numpy'				,      return_dict=lowerCAmelCase__       )[0]

            _A=	image[0, -3:, -3:, -1]
            _A=	image_from_tuple[0, -3:, -3:, -1]

            assert image.shape == (1, 64, 64, 3)
            _A=	np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172]       )
            _A=	1E-2 if torch_device != 'mps' else 3E-2

            assert np.abs(image_slice.flatten() - expected_slice       ).max() < tolerance
            assert np.abs(image_from_tuple_slice.flatten() - expected_slice       ).max() < tolerance





@slow
@require_torch
class      lowerCAmelCase						(					unittest.TestCase			):



     def 			a__  (					self       ):
            _A=	LDMPipeline.from_pretrained('CompVis/ldm-celebahq-256'       )
            ldm.to(lowerCAmelCase__       )
            ldm.set_progress_bar_config(disable=lowerCAmelCase__       )

            _A=	torch.manual_seed(0       )
            _A=	ldm(generator=lowerCAmelCase__				,      num_inference_steps=5				,      output_type='numpy'       ).images

            _A=	image[0, -3:, -3:, -1]

            assert image.shape == (1, 256, 256, 3)
            _A=	np.array([0.4399, 0.44975, 0.46825, 0.474, 0.4359, 0.4581, 0.45095, 0.4341, 0.4447]       )
            _A=	1E-2 if torch_device != 'mps' else 3E-2

            assert np.abs(image_slice.flatten() - expected_slice       ).max() < tolerance
from typing import TYPE_CHECKING

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


UpperCAmelCase_								=							{
    '''configuration_ernie''': ['''ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ErnieConfig''', '''ErnieOnnxConfig'''],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCAmelCase_								=							[
          '''ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''ErnieForCausalLM''',
          '''ErnieForMaskedLM''',
          '''ErnieForMultipleChoice''',
          '''ErnieForNextSentencePrediction''',
          '''ErnieForPreTraining''',
          '''ErnieForQuestionAnswering''',
          '''ErnieForSequenceClassification''',
          '''ErnieForTokenClassification''',
          '''ErnieModel''',
          '''ErniePreTrainedModel''',
      ]

if TYPE_CHECKING:
      from .configuration_ernie import ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieConfig, ErnieOnnxConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_ernie import (
                ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST,
                ErnieForCausalLM,
                ErnieForMaskedLM,
                ErnieForMultipleChoice,
                ErnieForNextSentencePrediction,
                ErnieForPreTraining,
                ErnieForQuestionAnswering,
                ErnieForSequenceClassification,
                ErnieForTokenClassification,
                ErnieModel,
                ErniePreTrainedModel,
            )

else:
      import sys

      UpperCAmelCase_								=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)