

'''simple docstring'''






import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     MODEL_FOR_PRETRAINING_MAPPING,
     NezhaForMaskedLM,
     NezhaForMultipleChoice,
     NezhaForNextSentencePrediction,
     NezhaForPreTraining,
     NezhaForQuestionAnswering,
     NezhaForSequenceClassification,
     NezhaForTokenClassification,
     NezhaModel,
 )
 from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST






class      lowercase_      :




  """simple docstring"""




  def __init__( self  :	Dict   ,lowercase__  :	Dict   ,lowercase__  :	int=1_3   ,lowercase__  :	List[str]=7   ,lowercase__  :	int=True   ,lowercase__  :	int=True   ,lowercase__  :	Union[str, Any]=True   ,lowercase__  :	List[Any]=True   ,lowercase__  :	str=9_9   ,lowercase__  :	Optional[Any]=3_2   ,lowercase__  :	Union[str, Any]=5   ,lowercase__  :	List[Any]=4   ,lowercase__  :	str=3_7   ,lowercase__  :	Tuple="gelu"   ,lowercase__  :	List[Any]=0.1   ,lowercase__  :	Dict=0.1   ,lowercase__  :	int=1_2_8   ,lowercase__  :	Dict=3_2   ,lowercase__  :	Dict=1_6   ,lowercase__  :	Any=2   ,lowercase__  :	int=0.0_2   ,lowercase__  :	List[str]=3   ,lowercase__  :	Dict=4   ,lowercase__  :	Optional[int]=None   ,):
   __lowercase				    =					parent
   __lowercase				    =					batch_size
   __lowercase				    =					seq_length
   __lowercase				    =					is_training
   __lowercase				    =					use_input_mask
   __lowercase				    =					use_token_type_ids
   __lowercase				    =					use_labels
   __lowercase				    =					vocab_size
   __lowercase				    =					hidden_size
   __lowercase				    =					num_hidden_layers
   __lowercase				    =					num_attention_heads
   __lowercase				    =					intermediate_size
   __lowercase				    =					hidden_act
   __lowercase				    =					hidden_dropout_prob
   __lowercase				    =					attention_probs_dropout_prob
   __lowercase				    =					max_position_embeddings
   __lowercase				    =					type_vocab_size
   __lowercase				    =					type_sequence_label_size
   __lowercase				    =					initializer_range
   __lowercase				    =					num_labels
   __lowercase				    =					num_choices
   __lowercase				    =					scope






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]     ):
   __lowercase				    =					ids_tensor([self.batch_size, self.seq_length]   ,self.vocab_size     )

   __lowercase				    =					None
   if self.use_input_mask:
    __lowercase				    =					random_attention_mask([self.batch_size, self.seq_length]     )

   __lowercase				    =					None
   if self.use_token_type_ids:
    __lowercase				    =					ids_tensor([self.batch_size, self.seq_length]   ,self.type_vocab_size     )

   __lowercase				    =					None
   __lowercase				    =					None
   __lowercase				    =					None
   if self.use_labels:
    __lowercase				    =					ids_tensor([self.batch_size]   ,self.type_sequence_label_size     )
    __lowercase				    =					ids_tensor([self.batch_size, self.seq_length]   ,self.num_labels     )
    __lowercase				    =					ids_tensor([self.batch_size]   ,self.num_choices     )

   __lowercase				    =					self.get_config()

   return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






  def    SCREAMING_SNAKE_CASE ( self  :	Union[str, Any]     ):
   return NezhaConfig(
       vocab_size=self.vocab_size   ,hidden_size=self.hidden_size   ,num_hidden_layers=self.num_hidden_layers   ,num_attention_heads=self.num_attention_heads   ,intermediate_size=self.intermediate_size   ,hidden_act=self.hidden_act   ,hidden_dropout_prob=self.hidden_dropout_prob   ,attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,max_position_embeddings=self.max_position_embeddings   ,type_vocab_size=self.type_vocab_size   ,is_decoder=lowercase__   ,initializer_range=self.initializer_range   ,)






  def    SCREAMING_SNAKE_CASE ( self  :	Union[str, Any]     ):
   (
       (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      
   )				    =					self.prepare_config_and_inputs()

   __lowercase				    =					True
   __lowercase				    =					floats_tensor([self.batch_size, self.seq_length, self.hidden_size]     )
   __lowercase				    =					ids_tensor([self.batch_size, self.seq_length]   ,vocab_size=2     )

   return (
       config,
       input_ids,
       token_type_ids,
       input_mask,
       sequence_labels,
       token_labels,
       choice_labels,
       encoder_hidden_states,
       encoder_attention_mask,
   )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]   ,lowercase__  :	Union[str, Any]   ,lowercase__  :	List[str]   ,lowercase__  :	List[str]   ,lowercase__  :	List[str]   ,lowercase__  :	Tuple   ,lowercase__  :	Tuple   ,lowercase__  :	str     ):
   __lowercase				    =					NezhaModel(config=lowercase__     )
   model.to(lowercase__     )
   model.eval()
   __lowercase				    =					model(lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__     )
   __lowercase				    =					model(lowercase__   ,token_type_ids=lowercase__     )
   __lowercase				    =					model(lowercase__     )
   self.parent.assertEqual(result.last_hidden_state.shape   ,(self.batch_size, self.seq_length, self.hidden_size)     )
   self.parent.assertEqual(result.pooler_output.shape   ,(self.batch_size, self.hidden_size)     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]   ,lowercase__  :	Dict   ,lowercase__  :	str   ,lowercase__  :	Optional[Any]   ,lowercase__  :	Optional[Any]   ,lowercase__  :	List[str]   ,lowercase__  :	Tuple   ,lowercase__  :	Tuple   ,lowercase__  :	Optional[int]   ,lowercase__  :	List[Any]   ,):
   __lowercase				    =					True
   __lowercase				    =					NezhaModel(lowercase__     )
   model.to(lowercase__     )
   model.eval()
   __lowercase				    =					model(
       lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__   ,encoder_hidden_states=lowercase__   ,encoder_attention_mask=lowercase__   ,)
   __lowercase				    =					model(
       lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__   ,encoder_hidden_states=lowercase__   ,)
   __lowercase				    =					model(lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__     )
   self.parent.assertEqual(result.last_hidden_state.shape   ,(self.batch_size, self.seq_length, self.hidden_size)     )
   self.parent.assertEqual(result.pooler_output.shape   ,(self.batch_size, self.hidden_size)     )






  def    SCREAMING_SNAKE_CASE ( self  :	Any   ,lowercase__  :	List[str]   ,lowercase__  :	Dict   ,lowercase__  :	Tuple   ,lowercase__  :	Optional[Any]   ,lowercase__  :	List[Any]   ,lowercase__  :	List[Any]   ,lowercase__  :	Optional[Any]     ):
   __lowercase				    =					NezhaForMaskedLM(config=lowercase__     )
   model.to(lowercase__     )
   model.eval()
   __lowercase				    =					model(lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__   ,labels=lowercase__     )
   self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.seq_length, self.vocab_size)     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[Any]   ,lowercase__  :	List[str]   ,lowercase__  :	Dict   ,lowercase__  :	Any   ,lowercase__  :	int   ,lowercase__  :	Union[str, Any]   ,lowercase__  :	Optional[int]   ,lowercase__  :	Any     ):
   __lowercase				    =					NezhaForNextSentencePrediction(config=lowercase__     )
   model.to(lowercase__     )
   model.eval()
   __lowercase				    =					model(
       lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__   ,labels=lowercase__   ,)
   self.parent.assertEqual(result.logits.shape   ,(self.batch_size, 2)     )






  def    SCREAMING_SNAKE_CASE ( self  :	Dict   ,lowercase__  :	str   ,lowercase__  :	Dict   ,lowercase__  :	Tuple   ,lowercase__  :	Dict   ,lowercase__  :	Tuple   ,lowercase__  :	int   ,lowercase__  :	int     ):
   __lowercase				    =					NezhaForPreTraining(config=lowercase__     )
   model.to(lowercase__     )
   model.eval()
   __lowercase				    =					model(
       lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__   ,labels=lowercase__   ,next_sentence_label=lowercase__   ,)
   self.parent.assertEqual(result.prediction_logits.shape   ,(self.batch_size, self.seq_length, self.vocab_size)     )
   self.parent.assertEqual(result.seq_relationship_logits.shape   ,(self.batch_size, 2)     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]   ,lowercase__  :	Union[str, Any]   ,lowercase__  :	Optional[Any]   ,lowercase__  :	Tuple   ,lowercase__  :	List[str]   ,lowercase__  :	Dict   ,lowercase__  :	Optional[int]   ,lowercase__  :	Union[str, Any]     ):
   __lowercase				    =					NezhaForQuestionAnswering(config=lowercase__     )
   model.to(lowercase__     )
   model.eval()
   __lowercase				    =					model(
       lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__   ,start_positions=lowercase__   ,end_positions=lowercase__   ,)
   self.parent.assertEqual(result.start_logits.shape   ,(self.batch_size, self.seq_length)     )
   self.parent.assertEqual(result.end_logits.shape   ,(self.batch_size, self.seq_length)     )






  def    SCREAMING_SNAKE_CASE ( self  :	Dict   ,lowercase__  :	Tuple   ,lowercase__  :	str   ,lowercase__  :	List[str]   ,lowercase__  :	Dict   ,lowercase__  :	Any   ,lowercase__  :	Optional[int]   ,lowercase__  :	int     ):
   __lowercase				    =					self.num_labels
   __lowercase				    =					NezhaForSequenceClassification(lowercase__     )
   model.to(lowercase__     )
   model.eval()
   __lowercase				    =					model(lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__   ,labels=lowercase__     )
   self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_labels)     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[Any]   ,lowercase__  :	Union[str, Any]   ,lowercase__  :	List[str]   ,lowercase__  :	int   ,lowercase__  :	List[Any]   ,lowercase__  :	List[Any]   ,lowercase__  :	Any   ,lowercase__  :	Optional[Any]     ):
   __lowercase				    =					self.num_labels
   __lowercase				    =					NezhaForTokenClassification(config=lowercase__     )
   model.to(lowercase__     )
   model.eval()
   __lowercase				    =					model(lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__   ,labels=lowercase__     )
   self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.seq_length, self.num_labels)     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[Any]   ,lowercase__  :	List[Any]   ,lowercase__  :	List[Any]   ,lowercase__  :	Optional[Any]   ,lowercase__  :	List[str]   ,lowercase__  :	Dict   ,lowercase__  :	List[Any]   ,lowercase__  :	str     ):
   __lowercase				    =					self.num_choices
   __lowercase				    =					NezhaForMultipleChoice(config=lowercase__     )
   model.to(lowercase__     )
   model.eval()
   __lowercase				    =					input_ids.unsqueeze(1     ).expand(-1   ,self.num_choices   ,-1     ).contiguous()
   __lowercase				    =					token_type_ids.unsqueeze(1     ).expand(-1   ,self.num_choices   ,-1     ).contiguous()
   __lowercase				    =					input_mask.unsqueeze(1     ).expand(-1   ,self.num_choices   ,-1     ).contiguous()
   __lowercase				    =					model(
       lowercase__   ,attention_mask=lowercase__   ,token_type_ids=lowercase__   ,labels=lowercase__   ,)
   self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_choices)     )






  def    SCREAMING_SNAKE_CASE ( self  :	Union[str, Any]     ):
   __lowercase				    =					self.prepare_config_and_inputs()
   (
       (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      
   )				    =					config_and_inputs
   __lowercase				    =					{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
   return config, inputs_dict






@require_torch
class      lowercase_      (lowerCamelCase__							,			lowerCamelCase__							,			lowerCamelCase__							,			unittest.TestCase ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE       :    Dict							     =     (
      (
          NezhaModel,
          NezhaForMaskedLM,
          NezhaForMultipleChoice,
          NezhaForNextSentencePrediction,
          NezhaForPreTraining,
          NezhaForQuestionAnswering,
          NezhaForSequenceClassification,
          NezhaForTokenClassification,
      )
      if is_torch_available()
      else ()
  )
  SCREAMING_SNAKE_CASE       :    Tuple							     =     (
      {
          'feature-extraction': NezhaModel,
          'fill-mask': NezhaForMaskedLM,
          'question-answering': NezhaForQuestionAnswering,
          'text-classification': NezhaForSequenceClassification,
          'token-classification': NezhaForTokenClassification,
          'zero-shot': NezhaForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  SCREAMING_SNAKE_CASE       :    List[str]							     =     True






  def    SCREAMING_SNAKE_CASE ( self  :	Dict   ,lowercase__  :	List[str]   ,lowercase__  :	str   ,lowercase__  :	Any=False     ):
   __lowercase				    =					super()._prepare_for_class(lowercase__   ,lowercase__   ,return_labels=lowercase__     )

   if return_labels:
    if model_class in get_values(lowercase__     ):
     __lowercase				    =					torch.zeros(
         (self.model_tester.batch_size, self.model_tester.seq_length)   ,dtype=torch.long   ,device=lowercase__     )
     __lowercase				    =					torch.zeros(
         self.model_tester.batch_size   ,dtype=torch.long   ,device=lowercase__     )
   return inputs_dict






  def    SCREAMING_SNAKE_CASE ( self  :	Tuple     ):
   __lowercase				    =					NezhaModelTester(self     )
   __lowercase				    =					ConfigTester(self   ,config_class=lowercase__   ,hidden_size=3_7     )






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   self.config_tester.run_common_tests()






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*lowercase__     )






  def    SCREAMING_SNAKE_CASE ( self  :	Any     ):
   __lowercase				    =					self.model_tester.prepare_config_and_inputs_for_decoder()
   self.model_tester.create_and_check_model_as_decoder(*lowercase__     )






  def    SCREAMING_SNAKE_CASE ( self  :	Any     ):
   # This regression test was failing with PyTorch < 1.3
   (
       (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      (
       __lowercase
   )    ,      
   )				    =					self.model_tester.prepare_config_and_inputs_for_decoder()

   __lowercase				    =					None

   self.model_tester.create_and_check_model_as_decoder(
       lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,lowercase__   ,)






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_lm(*lowercase__     )






  def    SCREAMING_SNAKE_CASE ( self  :	Union[str, Any]     ):
   __lowercase				    =					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_multiple_choice(*lowercase__     )






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_next_sequence_prediction(*lowercase__     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[Any]     ):
   __lowercase				    =					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_pretraining(*lowercase__     )






  def    SCREAMING_SNAKE_CASE ( self  :	str     ):
   __lowercase				    =					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_question_answering(*lowercase__     )






  def    SCREAMING_SNAKE_CASE ( self  :	str     ):
   __lowercase				    =					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_sequence_classification(*lowercase__     )






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_token_classification(*lowercase__     )






  @slow
  def    SCREAMING_SNAKE_CASE ( self  :	Union[str, Any]     ):
   for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    __lowercase				    =					NezhaModel.from_pretrained(lowercase__     )
    self.assertIsNotNone(lowercase__     )






  @slow
  @require_torch_gpu
  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]     ):
   __lowercase    ,      __lowercase				    =					self.model_tester.prepare_config_and_inputs_for_common()
   for model_class in self.all_model_classes:
    # NezhaForMultipleChoice behaves incorrectly in JIT environments.
    if model_class == NezhaForMultipleChoice:
     return

    __lowercase				    =					True
    __lowercase				    =					model_class(config=lowercase__     )

    __lowercase				    =					self._prepare_for_class(lowercase__   ,lowercase__     )
    __lowercase				    =					torch.jit.trace(
        lowercase__   ,(inputs_dict['''input_ids'''].to('''cpu'''     ), inputs_dict['''attention_mask'''].to('''cpu'''     ))     )

    with tempfile.TemporaryDirectory() as tmp:
     torch.jit.save(lowercase__   ,os.path.join(lowercase__   ,'''bert.pt'''     )     )
     __lowercase				    =					torch.jit.load(os.path.join(lowercase__   ,'''bert.pt'''     )   ,map_location=lowercase__     )
     loaded(inputs_dict['''input_ids'''].to(lowercase__     )   ,inputs_dict['''attention_mask'''].to(lowercase__     )     )






@require_torch
class      lowercase_      (unittest.TestCase ):




  """simple docstring"""




  @slow
  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					NezhaModel.from_pretrained('''sijunhe/nezha-cn-base'''     )
   __lowercase				    =					torch.tensor([[0, 1, 2, 3, 4, 5]]     )
   __lowercase				    =					torch.tensor([[0, 1, 1, 1, 1, 1]]     )
   with torch.no_grad():
    __lowercase				    =					model(lowercase__   ,attention_mask=lowercase__     )[0]
   __lowercase				    =					torch.Size((1, 6, 7_6_8)     )
   self.assertEqual(output.shape   ,lowercase__     )
   __lowercase				    =					torch.tensor([[[0.0_6_8_5, 0.2_4_4_1, 0.1_1_0_2], [0.0_6_0_0, 0.1_9_0_6, 0.1_3_4_9], [0.0_2_2_1, 0.0_8_1_9, 0.0_5_8_6]]]     )

   self.assertTrue(torch.allclose(output[:, 1:4, 1:4]   ,lowercase__   ,atol=1e-4     )     )






  @slow
  def    SCREAMING_SNAKE_CASE ( self  :	Dict     ):
   __lowercase				    =					NezhaForMaskedLM.from_pretrained('''sijunhe/nezha-cn-base'''     )
   __lowercase				    =					torch.tensor([[0, 1, 2, 3, 4, 5]]     )
   __lowercase				    =					torch.tensor([[1, 1, 1, 1, 1, 1]]     )
   with torch.no_grad():
    __lowercase				    =					model(lowercase__   ,attention_mask=lowercase__     )[0]
   __lowercase				    =					torch.Size((1, 6, 2_1_1_2_8)     )
   self.assertEqual(output.shape   ,lowercase__     )
   __lowercase				    =					torch.tensor(
       [[-2.7_9_3_9, -1.7_9_0_2, -2.2_1_8_9], [-2.8_5_8_5, -1.8_9_0_8, -2.3_7_2_3], [-2.6_4_9_9, -1.7_7_5_0, -2.2_5_5_8]]     )

   self.assertTrue(torch.allclose(output[:, 1:4, 1:4]   ,lowercase__   ,atol=1e-4     )     )





'''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 						a__							(				a__							,							a__							,							a__							,							unittest.TestCase    ):





							'''simple docstring'''






							lowercase__     :  Optional[Any]      		= AltDiffusionPipeline
							lowercase__     :  Dict      		= TEXT_TO_IMAGE_PARAMS
							lowercase__     :  str      		= TEXT_TO_IMAGE_BATCH_PARAMS
							lowercase__     :  Any      		= TEXT_TO_IMAGE_IMAGE_PARAMS
							lowercase__     :  List[str]      		= TEXT_TO_IMAGE_IMAGE_PARAMS







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														torch.manual_seed(0  )
														lowerCAmelCase__			  =      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   ,       )
														lowerCAmelCase__			  =      DDIMScheduler(
														    beta_start=0.00_085   ,       beta_end=0.012   ,       beta_schedule='''scaled_linear'''   ,       clip_sample=lowerCamelCase_   ,       set_alpha_to_one=lowerCamelCase_   ,       )
														torch.manual_seed(0  )
														lowerCAmelCase__			  =      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   ,       )

														# 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  )
														lowerCAmelCase__			  =      CLIPTextConfig(
														    bos_token_id=0   ,       eos_token_id=2   ,       hidden_size=32   ,       projection_dim=32   ,       intermediate_size=37   ,       layer_norm_eps=1e-05   ,       num_attention_heads=4   ,       num_hidden_layers=5   ,       pad_token_id=1   ,       vocab_size=50_02   ,       )
														lowerCAmelCase__			  =      CLIPTextModel(lowerCamelCase_  )

														lowerCAmelCase__			  =      XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''  )
														lowerCAmelCase__			  =      77

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







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_=0  )			->				List[str]:
														if str(lowerCamelCase_  ).startswith('''mps'''  ):
																					lowerCAmelCase__			  =      torch.manual_seed(lowerCamelCase_  )
														else:
																					lowerCAmelCase__			  =      torch.Generator(device=lowerCamelCase_  ).manual_seed(lowerCamelCase_  )
														lowerCAmelCase__			  =      {
														    '''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     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														super().test_attention_slicing_forward_pass(expected_max_diff=3e-3  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														super().test_inference_batch_single_identical(expected_max_diff=3e-3  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														lowerCAmelCase__			  =      '''cpu'''  # ensure determinism for the device-dependent torch.Generator

														lowerCAmelCase__			  =      self.get_dummy_components()
														torch.manual_seed(0  )
														lowerCAmelCase__			  =      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=50_02   ,       )
														# TODO: remove after fixing the non-deterministic text encoder
														lowerCAmelCase__			  =      RobertaSeriesModelWithTransformation(lowerCamelCase_  )
														lowerCAmelCase__			  =      text_encoder

														lowerCAmelCase__			  =      AltDiffusionPipeline(**lowerCamelCase_  )
														lowerCAmelCase__			  =      alt_pipe.to(lowerCamelCase_  )
														alt_pipe.set_progress_bar_config(disable=lowerCamelCase_  )

														lowerCAmelCase__			  =      self.get_dummy_inputs(lowerCamelCase_  )
														lowerCAmelCase__			  =      '''A photo of an astronaut'''
														lowerCAmelCase__			  =      alt_pipe(**lowerCamelCase_  )
														lowerCAmelCase__			  =      output.images
														lowerCAmelCase__			  =      image[0, -3:, -3:, -1]

														assert image.shape == (1, 64, 64, 3)
														lowerCAmelCase__			  =      np.array(
														    [0.5_748_162, 0.60_447_145, 0.48_821_217, 0.50_100_636, 0.5_431_185, 0.45_763_683, 0.49_657_696, 0.48_132_733, 0.47_573_093]  )

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







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      '''cpu'''  # ensure determinism for the device-dependent torch.Generator

														lowerCAmelCase__			  =      self.get_dummy_components()
														lowerCAmelCase__			  =      PNDMScheduler(skip_prk_steps=lowerCamelCase_  )
														torch.manual_seed(0  )
														lowerCAmelCase__			  =      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=50_02   ,       )
														# TODO: remove after fixing the non-deterministic text encoder
														lowerCAmelCase__			  =      RobertaSeriesModelWithTransformation(lowerCamelCase_  )
														lowerCAmelCase__			  =      text_encoder
														lowerCAmelCase__			  =      AltDiffusionPipeline(**lowerCamelCase_  )
														lowerCAmelCase__			  =      alt_pipe.to(lowerCamelCase_  )
														alt_pipe.set_progress_bar_config(disable=lowerCamelCase_  )

														lowerCAmelCase__			  =      self.get_dummy_inputs(lowerCamelCase_  )
														lowerCAmelCase__			  =      alt_pipe(**lowerCamelCase_  )
														lowerCAmelCase__			  =      output.images
														lowerCAmelCase__			  =      image[0, -3:, -3:, -1]

														assert image.shape == (1, 64, 64, 3)
														lowerCAmelCase__			  =      np.array(
														    [0.51_605_093, 0.5_707_241, 0.47_365_507, 0.50_578_886, 0.5_633_877, 0.4_642_503, 0.5_182_081, 0.48_763_484, 0.49_084_237]  )

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




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





							'''simple docstring'''






							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														# clean up the VRAM after each test
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														# make sure here that pndm scheduler skips prk
														lowerCAmelCase__			  =      AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''   ,       safety_checker=lowerCamelCase_  )
														lowerCAmelCase__			  =      alt_pipe.to(lowerCamelCase_  )
														alt_pipe.set_progress_bar_config(disable=lowerCamelCase_  )

														lowerCAmelCase__			  =      '''A painting of a squirrel eating a burger'''
														lowerCAmelCase__			  =      torch.manual_seed(0  )
														lowerCAmelCase__			  =      alt_pipe([prompt]   ,       generator=lowerCamelCase_   ,       guidance_scale=6.0   ,       num_inference_steps=20   ,       output_type='''np'''  )

														lowerCAmelCase__			  =      output.images

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

														assert image.shape == (1, 5_12, 5_12, 3)
														lowerCAmelCase__			  =      np.array([0.1_010, 0.0_800, 0.0_794, 0.0_885, 0.0_843, 0.0_762, 0.0_769, 0.0_729, 0.0_586]  )

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







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														lowerCAmelCase__			  =      DDIMScheduler.from_pretrained('''BAAI/AltDiffusion'''   ,       subfolder='''scheduler'''  )

														lowerCAmelCase__			  =      AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''   ,       scheduler=lowerCamelCase_   ,       safety_checker=lowerCamelCase_  )
														lowerCAmelCase__			  =      alt_pipe.to(lowerCamelCase_  )
														alt_pipe.set_progress_bar_config(disable=lowerCamelCase_  )

														lowerCAmelCase__			  =      '''A painting of a squirrel eating a burger'''
														lowerCAmelCase__			  =      torch.manual_seed(0  )

														lowerCAmelCase__			  =      alt_pipe([prompt]   ,       generator=lowerCamelCase_   ,       num_inference_steps=2   ,       output_type='''numpy'''  )
														lowerCAmelCase__			  =      output.images

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

														assert image.shape == (1, 5_12, 5_12, 3)
														lowerCAmelCase__			  =      np.array([0.4_019, 0.4_052, 0.3_810, 0.4_119, 0.3_916, 0.3_982, 0.4_651, 0.4_195, 0.5_323]  )

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