





"""simple docstring"""




import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class  _UpperCAmelCase  (   UpperCAmelCase__			,   UpperCAmelCase__			,   UpperCAmelCase__			,   unittest.TestCase		):



      '''simple docstring'''
      lowercase_      : Union[str, Any]	    =   AltDiffusionPipeline
      lowercase_      : Optional[Any]	    =   TEXT_TO_IMAGE_PARAMS
      lowercase_      : Optional[Any]	    =   TEXT_TO_IMAGE_BATCH_PARAMS
      lowercase_      : Optional[Any]	    =   TEXT_TO_IMAGE_IMAGE_PARAMS
      lowercase_      : List[Any]	    =   TEXT_TO_IMAGE_IMAGE_PARAMS

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        torch.manual_seed(0  )
        A_  :       List[Any]										=  UNetaDConditionModel(
            block_out_channels=(3_2, 6_4)					,      layers_per_block=2					,      sample_size=3_2					,      in_channels=4					,      out_channels=4					,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')					,      up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')					,      cross_attention_dim=3_2					,      )
        A_  :       Union[str, Any]										=  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  )
        A_  :       Optional[int]										=  AutoencoderKL(
            block_out_channels=[3_2, 6_4]					,      in_channels=3					,      out_channels=3					,      down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']					,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']					,      latent_channels=4					,      )

        # TODO: address the non-deterministic text encoder (fails for save-load tests)
        # torch.manual_seed(0)
        # text_encoder_config = RobertaSeriesConfig(
        #     hidden_size=32,
        #     project_dim=32,
        #     intermediate_size=37,
        #     layer_norm_eps=1e-05,
        #     num_attention_heads=4,
        #     num_hidden_layers=5,
        #     vocab_size=5002,
        # )
        # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

        torch.manual_seed(0  )
        A_  :       str										=  CLIPTextConfig(
            bos_token_id=0					,      eos_token_id=2					,      hidden_size=3_2					,      projection_dim=3_2					,      intermediate_size=3_7					,      layer_norm_eps=1E-05					,      num_attention_heads=4					,      num_hidden_layers=5					,      pad_token_id=1					,      vocab_size=5_0_0_2					,      )
        A_  :       List[Any]										=  CLIPTextModel(snake_case_  )

        A_  :       List[str]										=  XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta'  )
        A_  :       List[str]										=  7_7

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

      def 					lowerCamelCase_			(     self					,      snake_case_					,      snake_case_=0  ):

        """simple docstring"""

        if str(snake_case_  ).startswith('mps'  ):
          A_  :       Optional[Any]										=  torch.manual_seed(snake_case_  )
        else:
          A_  :       Union[str, Any]										=  torch.Generator(device=snake_case_  ).manual_seed(snake_case_  )
        A_  :       int										=  {
            'prompt': 'A painting of a squirrel eating a burger',
            'generator': generator,
            'num_inference_steps': 2,
            'guidance_scale': 6.0,
            'output_type': 'numpy',
        }
        return inputs

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        super().test_attention_slicing_forward_pass(expected_max_diff=3E-3  )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        super().test_inference_batch_single_identical(expected_max_diff=3E-3  )

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       List[Any]										=  'cpu'  # ensure determinism for the device-dependent torch.Generator

        A_  :       List[str]										=  self.get_dummy_components()
        torch.manual_seed(0  )
        A_  :       str										=  RobertaSeriesConfig(
            hidden_size=3_2					,      project_dim=3_2					,      intermediate_size=3_7					,      layer_norm_eps=1E-05					,      num_attention_heads=4					,      num_hidden_layers=5					,      vocab_size=5_0_0_2					,      )
        # TODO: remove after fixing the non-deterministic text encoder
        A_  :       Tuple										=  RobertaSeriesModelWithTransformation(snake_case_  )
        A_  :       str										=  text_encoder

        A_  :       Tuple										=  AltDiffusionPipeline(**snake_case_  )
        A_  :       Union[str, Any]										=  alt_pipe.to(snake_case_  )
        alt_pipe.set_progress_bar_config(disable=snake_case_  )

        A_  :       str										=  self.get_dummy_inputs(snake_case_  )
        A_  :       Optional[int]										=  'A photo of an astronaut'
        A_  :       Optional[int]										=  alt_pipe(**snake_case_  )
        A_  :       Dict										=  output.images
        A_  :       Dict										=  image[0, -3:, -3:, -1]

        assert image.shape == (1, 6_4, 6_4, 3)
        A_  :       Optional[int]										=  np.array(
            [0.5_74_81_62, 0.60_44_71_45, 0.48_82_12_17, 0.50_10_06_36, 0.5_43_11_85, 0.45_76_36_83, 0.49_65_76_96, 0.48_13_27_33, 0.47_57_30_93]  )

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

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       str										=  'cpu'  # ensure determinism for the device-dependent torch.Generator

        A_  :       str										=  self.get_dummy_components()
        A_  :       Union[str, Any]										=  PNDMScheduler(skip_prk_steps=snake_case_  )
        torch.manual_seed(0  )
        A_  :       Any										=  RobertaSeriesConfig(
            hidden_size=3_2					,      project_dim=3_2					,      intermediate_size=3_7					,      layer_norm_eps=1E-05					,      num_attention_heads=4					,      num_hidden_layers=5					,      vocab_size=5_0_0_2					,      )
        # TODO: remove after fixing the non-deterministic text encoder
        A_  :       Optional[Any]										=  RobertaSeriesModelWithTransformation(snake_case_  )
        A_  :       int										=  text_encoder
        A_  :       Union[str, Any]										=  AltDiffusionPipeline(**snake_case_  )
        A_  :       Any										=  alt_pipe.to(snake_case_  )
        alt_pipe.set_progress_bar_config(disable=snake_case_  )

        A_  :       Any										=  self.get_dummy_inputs(snake_case_  )
        A_  :       List[str]										=  alt_pipe(**snake_case_  )
        A_  :       Tuple										=  output.images
        A_  :       int										=  image[0, -3:, -3:, -1]

        assert image.shape == (1, 6_4, 6_4, 3)
        A_  :       Any										=  np.array(
            [0.51_60_50_93, 0.5_70_72_41, 0.47_36_55_07, 0.50_57_88_86, 0.5_63_38_77, 0.4_64_25_03, 0.5_18_20_81, 0.48_76_34_84, 0.49_08_42_37]  )

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


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



      '''simple docstring'''

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

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

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       List[str]										=  AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'					,      safety_checker=snake_case_  )
        A_  :       List[str]										=  alt_pipe.to(snake_case_  )
        alt_pipe.set_progress_bar_config(disable=snake_case_  )

        A_  :       Optional[Any]										=  'A painting of a squirrel eating a burger'
        A_  :       List[str]										=  torch.manual_seed(0  )
        A_  :       Tuple										=  alt_pipe([prompt]					,      generator=snake_case_					,      guidance_scale=6.0					,      num_inference_steps=2_0					,      output_type='np'  )

        A_  :       List[Any]										=  output.images

        A_  :       Optional[int]										=  image[0, -3:, -3:, -1]

        assert image.shape == (1, 5_1_2, 5_1_2, 3)
        A_  :       Union[str, Any]										=  np.array([0.10_10, 0.08_00, 0.07_94, 0.08_85, 0.08_43, 0.07_62, 0.07_69, 0.07_29, 0.05_86]  )

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

      def 					lowerCamelCase_			(     self  ):

        """simple docstring"""

        A_  :       List[str]										=  DDIMScheduler.from_pretrained('BAAI/AltDiffusion'					,      subfolder='scheduler'  )

        A_  :       Union[str, Any]										=  AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'					,      scheduler=snake_case_					,      safety_checker=snake_case_  )
        A_  :       List[Any]										=  alt_pipe.to(snake_case_  )
        alt_pipe.set_progress_bar_config(disable=snake_case_  )

        A_  :       List[Any]										=  'A painting of a squirrel eating a burger'
        A_  :       Optional[Any]										=  torch.manual_seed(0  )

        A_  :       Optional[int]										=  alt_pipe([prompt]					,      generator=snake_case_					,      num_inference_steps=2					,      output_type='numpy'  )
        A_  :       List[Any]										=  output.images

        A_  :       int										=  image[0, -3:, -3:, -1]

        assert image.shape == (1, 5_1_2, 5_1_2, 3)
        A_  :       Union[str, Any]										=  np.array([0.40_19, 0.40_52, 0.38_10, 0.41_19, 0.39_16, 0.39_82, 0.46_51, 0.41_95, 0.53_23]  )

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






"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase_     :						List[str]						=					{'configuration_xlnet': ['XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'XLNetConfig']}

try:
   if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase_     :						str						=					['XLNetTokenizer']

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase_     :						List[str]						=					['XLNetTokenizerFast']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase_     :						int						=					[
       'XLNET_PRETRAINED_MODEL_ARCHIVE_LIST',
       'XLNetForMultipleChoice',
       'XLNetForQuestionAnswering',
       'XLNetForQuestionAnsweringSimple',
       'XLNetForSequenceClassification',
       'XLNetForTokenClassification',
       'XLNetLMHeadModel',
       'XLNetModel',
       'XLNetPreTrainedModel',
       'load_tf_weights_in_xlnet',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase_     :						Union[str, Any]						=					[
       'TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFXLNetForMultipleChoice',
       'TFXLNetForQuestionAnsweringSimple',
       'TFXLNetForSequenceClassification',
       'TFXLNetForTokenClassification',
       'TFXLNetLMHeadModel',
       'TFXLNetMainLayer',
       'TFXLNetModel',
       'TFXLNetPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig

   try:
      if not is_sentencepiece_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_xlnet import XLNetTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_xlnet_fast import XLNetTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_xlnet import (
          XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
          XLNetForMultipleChoice,
          XLNetForQuestionAnswering,
          XLNetForQuestionAnsweringSimple,
          XLNetForSequenceClassification,
          XLNetForTokenClassification,
          XLNetLMHeadModel,
          XLNetModel,
          XLNetPreTrainedModel,
          load_tf_weights_in_xlnet,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_xlnet import (
          TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFXLNetForMultipleChoice,
          TFXLNetForQuestionAnsweringSimple,
          TFXLNetForSequenceClassification,
          TFXLNetForTokenClassification,
          TFXLNetLMHeadModel,
          TFXLNetMainLayer,
          TFXLNetModel,
          TFXLNetPreTrainedModel,
      )

else:
   import sys

   lowerCamelCase_     :						List[Any]						=					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)