






"""simple docstring"""







from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
     TFTransfoXLForSequenceClassification,
     TFTransfoXLLMHeadModel,
     TFTransfoXLModel,
 )





class   UpperCamelCase_ :



  def __init__(      self ,		snake_case__ ,		)			->			List[str]:



         """simple docstring"""





         UpperCAmelCase	    =			parent
         UpperCAmelCase	    =			13
         UpperCAmelCase	    =			7
         UpperCAmelCase	    =			30
         UpperCAmelCase	    =			self.seq_length + self.mem_len
         UpperCAmelCase	    =			15
         UpperCAmelCase	    =			True
         UpperCAmelCase	    =			True
         UpperCAmelCase	    =			99
         UpperCAmelCase	    =			[10, 50, 80]
         UpperCAmelCase	    =			32
         UpperCAmelCase	    =			32
         UpperCAmelCase	    =			4
         UpperCAmelCase	    =			8
         UpperCAmelCase	    =			1_28
         UpperCAmelCase	    =			2
         UpperCAmelCase	    =			2
         UpperCAmelCase	    =			None
         UpperCAmelCase	    =			1
         UpperCAmelCase	    =			0
         UpperCAmelCase	    =			3
         UpperCAmelCase	    =			self.vocab_size - 1
         UpperCAmelCase	    =			0.01



  def 		UpperCamelCase_				(      self				)			->			int:



         """simple docstring"""





         UpperCAmelCase	    =			ids_tensor([self.batch_size, self.seq_length] ,		self.vocab_size				)
         UpperCAmelCase	    =			ids_tensor([self.batch_size, self.seq_length] ,		self.vocab_size				)

         UpperCAmelCase	    =			None
         if self.use_labels:
                UpperCAmelCase	    =			ids_tensor([self.batch_size, self.seq_length] ,		self.vocab_size				)

         UpperCAmelCase	    =			TransfoXLConfig(
             vocab_size=self.vocab_size ,		mem_len=self.mem_len ,		clamp_len=self.clamp_len ,		cutoffs=self.cutoffs ,		d_model=self.hidden_size ,		d_embed=self.d_embed ,		n_head=self.num_attention_heads ,		d_head=self.d_head ,		d_inner=self.d_inner ,		div_val=self.div_val ,		n_layer=self.num_hidden_layers ,		eos_token_id=self.eos_token_id ,		pad_token_id=self.vocab_size - 1 ,		init_range=self.init_range ,		num_labels=self.num_labels ,		)

         return (config, input_ids_a, input_ids_a, lm_labels)



  def 		UpperCamelCase_				(      self				)			->			int:



         """simple docstring"""





         random.seed(self.seed				)
         tf.random.set_seed(self.seed				)



  def 		UpperCamelCase_				(      self ,		snake_case__ ,		snake_case__ ,		snake_case__ ,		snake_case__				)			->			List[Any]:



         """simple docstring"""





         UpperCAmelCase	    =			TFTransfoXLModel(snake_case__				)

         UpperCAmelCase    ,       UpperCAmelCase	    =			model(snake_case__				).to_tuple()

         UpperCAmelCase	    =			{"""input_ids""": input_ids_a, """mems""": mems_a}

         UpperCAmelCase    ,       UpperCAmelCase	    =			model(snake_case__				).to_tuple()

         self.parent.assertEqual(hidden_states_a.shape ,		(self.batch_size, self.seq_length, self.hidden_size)				)
         self.parent.assertEqual(hidden_states_a.shape ,		(self.batch_size, self.seq_length, self.hidden_size)				)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a] ,		[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,		)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a] ,		[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,		)



  def 		UpperCamelCase_				(      self ,		snake_case__ ,		snake_case__ ,		snake_case__ ,		snake_case__				)			->			Dict:



         """simple docstring"""





         UpperCAmelCase	    =			TFTransfoXLLMHeadModel(snake_case__				)

         UpperCAmelCase    ,       UpperCAmelCase	    =			model(snake_case__				).to_tuple()

         UpperCAmelCase	    =			{"""input_ids""": input_ids_a, """labels""": lm_labels}
         UpperCAmelCase    ,       UpperCAmelCase	    =			model(snake_case__				).to_tuple()

         UpperCAmelCase    ,       UpperCAmelCase	    =			model([input_ids_a, mems_a]				).to_tuple()

         UpperCAmelCase	    =			{"""input_ids""": input_ids_a, """mems""": mems_a, """labels""": lm_labels}

         UpperCAmelCase    ,       UpperCAmelCase	    =			model(snake_case__				).to_tuple()

         self.parent.assertEqual(lm_logits_a.shape ,		(self.batch_size, self.seq_length, self.vocab_size)				)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a] ,		[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,		)

         self.parent.assertEqual(lm_logits_a.shape ,		(self.batch_size, self.seq_length, self.vocab_size)				)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a] ,		[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,		)



  def 		UpperCamelCase_				(      self ,		snake_case__ ,		snake_case__ ,		snake_case__ ,		snake_case__				)			->			Optional[int]:



         """simple docstring"""





         UpperCAmelCase	    =			TFTransfoXLForSequenceClassification(snake_case__				)
         UpperCAmelCase	    =			model(snake_case__				)
         self.parent.assertEqual(result.logits.shape ,		(self.batch_size, self.num_labels)				)



  def 		UpperCamelCase_				(      self				)			->			str:



         """simple docstring"""





         UpperCAmelCase	    =			self.prepare_config_and_inputs()
         ((UpperCAmelCase)    ,       (UpperCAmelCase)    ,       (UpperCAmelCase)    ,       (UpperCAmelCase))	    =			config_and_inputs
         UpperCAmelCase	    =			{"""input_ids""": input_ids_a}
         return config, inputs_dict





@require_tf
class   UpperCamelCase_ (       a_   ,					a_   ,					unittest.TestCase  ):
  _A       :					Optional[Any]				=	(
      (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
  )
  _A       :					int				=	() if is_tf_available() else ()
  _A       :					Tuple				=	(
      {
          'feature-extraction': TFTransfoXLModel,
          'text-classification': TFTransfoXLForSequenceClassification,
          'text-generation': TFTransfoXLLMHeadModel,
          'zero-shot': TFTransfoXLForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
  _A       :					Union[str, Any]				=	False
  _A       :					str				=	False
  _A       :					Dict				=	False
  _A       :					Any				=	False



  def 		UpperCamelCase_				(      self ,		snake_case__ ,		snake_case__ ,		snake_case__ ,		snake_case__ ,		snake_case__				)			->			List[str]:



         """simple docstring"""





         if pipeline_test_casse_name == "TextGenerationPipelineTests":
                # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
                # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
                # tokenizer.
                return True

         return False



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



         """simple docstring"""





         UpperCAmelCase	    =			TFTransfoXLModelTester(self				)
         UpperCAmelCase	    =			ConfigTester(self ,		config_class=snake_case__ ,		d_embed=37				)



  def 		UpperCamelCase_				(      self				)			->			List[str]:



         """simple docstring"""





         self.config_tester.run_common_tests()



  def 		UpperCamelCase_				(      self				)			->			int:



         """simple docstring"""





         self.model_tester.set_seed()
         UpperCAmelCase	    =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*snake_case__				)



  def 		UpperCamelCase_				(      self				)			->			Optional[int]:



         """simple docstring"""





         self.model_tester.set_seed()
         UpperCAmelCase	    =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*snake_case__				)



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



         """simple docstring"""





         UpperCAmelCase	    =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*snake_case__				)



  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         UpperCAmelCase    ,       UpperCAmelCase	    =			self.model_tester.prepare_config_and_inputs_for_common()
         UpperCAmelCase	    =			[TFTransfoXLForSequenceClassification]

         for model_class in self.all_model_classes:
                UpperCAmelCase	    =			model_class(snake_case__				)
                assert isinstance(model.get_input_embeddings() ,		tf.keras.layers.Layer				)
                if model_class in list_other_models_with_output_ebd:
                       UpperCAmelCase	    =			model.get_output_embeddings()
                       assert isinstance(snake_case__ ,		tf.keras.layers.Layer				)
                       UpperCAmelCase	    =			model.get_bias()
                       assert name is None
                else:
                       UpperCAmelCase	    =			model.get_output_embeddings()
                       assert x is None
                       UpperCAmelCase	    =			model.get_bias()
                       assert name is None



  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         pass



  @slow
  def 		UpperCamelCase_				(      self				)			->			Union[str, Any]:



         """simple docstring"""





         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                UpperCAmelCase	    =			TFTransfoXLModel.from_pretrained(snake_case__				)
                self.assertIsNotNone(snake_case__				)



  @unittest.skip(reason="""This model doesn't play well with fit() due to not returning a single loss."""				)
  def 		UpperCamelCase_				(      self				)			->			Optional[Any]:



         """simple docstring"""





         pass





@require_tf
class   UpperCamelCase_ (       unittest.TestCase  ):



  @unittest.skip("""Skip test until #12651 is resolved."""				)
  @slow
  def 		UpperCamelCase_				(      self				)			->			List[Any]:



         """simple docstring"""





         UpperCAmelCase	    =			TFTransfoXLLMHeadModel.from_pretrained("""transfo-xl-wt103"""				)
         # fmt: off
         UpperCAmelCase	    =			tf.convert_to_tensor([[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0]] ,		dtype=tf.intaa				)  # noqa: E231
         # fmt: on
         #  In 1991 , the remains of Russian Tsar Nicholas II and his family
         #  ( except for Alexei and Maria ) are discovered .
         #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
         #  remainder of the story . 1883 Western Siberia ,
         #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
         #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
         #  father initially slaps him for making such an accusation , Rasputin watches as the
         #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
         #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
         #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

         # fmt: off
         UpperCAmelCase	    =			[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0,33,1,18_57,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,28,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,0]  # noqa: E231
         # fmt: on
         #  In 1991, the remains of Russian Tsar Nicholas II and his family (
         #  except for Alexei and Maria ) are discovered. The voice of young son,
         #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
         #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
         #  and a group of men to perform magic. Rasputin has a vision and
         #  denounces one of the men as a horse thief. Although his father initially
         #  slaps him for making such an accusation, Rasputin watches as the man
         #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
         #  of the Virgin Mary, prompting him to become a priest.
         #  Rasputin quickly becomes famous, with people, even a bishop, begging for
         #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
         # Nicholas II and his family were discovered. The voice of <unk> young son,
         # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

         UpperCAmelCase	    =			model.generate(snake_case__ ,		max_length=2_00 ,		do_sample=snake_case__				)
         self.assertListEqual(output_ids[0].numpy().tolist() ,		snake_case__				)








"""simple docstring"""







import tempfile

import numpy as np
import torch
from transformers import AutoTokenizer, TaEncoderModel

from diffusers import DDPMScheduler, UNetaDConditionModel
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.pipelines.deepfloyd_if import IFWatermarker
from diffusers.utils.testing_utils import torch_device

from ..test_pipelines_common import to_np





class   UpperCamelCase_ :



  def 		UpperCamelCase_				(      self				)			->			Any:



         """simple docstring"""





         torch.manual_seed(0				)
         UpperCAmelCase	    =			TaEncoderModel.from_pretrained("""hf-internal-testing/tiny-random-t5"""				)

         torch.manual_seed(0				)
         UpperCAmelCase	    =			AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-t5"""				)

         torch.manual_seed(0				)
         UpperCAmelCase	    =			UNetaDConditionModel(
             sample_size=32 ,		layers_per_block=1 ,		block_out_channels=[32, 64] ,		down_block_types=[
                 """ResnetDownsampleBlock2D""",
                 """SimpleCrossAttnDownBlock2D""",
             ] ,		mid_block_type="""UNetMidBlock2DSimpleCrossAttn""" ,		up_block_types=["""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""] ,		in_channels=3 ,		out_channels=6 ,		cross_attention_dim=32 ,		encoder_hid_dim=32 ,		attention_head_dim=8 ,		addition_embed_type="""text""" ,		addition_embed_type_num_heads=2 ,		cross_attention_norm="""group_norm""" ,		resnet_time_scale_shift="""scale_shift""" ,		act_fn="""gelu""" ,		)
         unet.set_attn_processor(AttnAddedKVProcessor()				)  # For reproducibility tests

         torch.manual_seed(0				)
         UpperCAmelCase	    =			DDPMScheduler(
             num_train_timesteps=10_00 ,		beta_schedule="""squaredcos_cap_v2""" ,		beta_start=0.0_001 ,		beta_end=0.02 ,		thresholding=snake_case__ ,		dynamic_thresholding_ratio=0.95 ,		sample_max_value=1.0 ,		prediction_type="""epsilon""" ,		variance_type="""learned_range""" ,		)

         torch.manual_seed(0				)
         UpperCAmelCase	    =			IFWatermarker()

         return {
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "unet": unet,
             "scheduler": scheduler,
             "watermarker": watermarker,
             "safety_checker": None,
             "feature_extractor": None,
         }



  def 		UpperCamelCase_				(      self				)			->			int:



         """simple docstring"""





         torch.manual_seed(0				)
         UpperCAmelCase	    =			TaEncoderModel.from_pretrained("""hf-internal-testing/tiny-random-t5"""				)

         torch.manual_seed(0				)
         UpperCAmelCase	    =			AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-t5"""				)

         torch.manual_seed(0				)
         UpperCAmelCase	    =			UNetaDConditionModel(
             sample_size=32 ,		layers_per_block=[1, 2] ,		block_out_channels=[32, 64] ,		down_block_types=[
                 """ResnetDownsampleBlock2D""",
                 """SimpleCrossAttnDownBlock2D""",
             ] ,		mid_block_type="""UNetMidBlock2DSimpleCrossAttn""" ,		up_block_types=["""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""] ,		in_channels=6 ,		out_channels=6 ,		cross_attention_dim=32 ,		encoder_hid_dim=32 ,		attention_head_dim=8 ,		addition_embed_type="""text""" ,		addition_embed_type_num_heads=2 ,		cross_attention_norm="""group_norm""" ,		resnet_time_scale_shift="""scale_shift""" ,		act_fn="""gelu""" ,		class_embed_type="""timestep""" ,		mid_block_scale_factor=1.414 ,		time_embedding_act_fn="""gelu""" ,		time_embedding_dim=32 ,		)
         unet.set_attn_processor(AttnAddedKVProcessor()				)  # For reproducibility tests

         torch.manual_seed(0				)
         UpperCAmelCase	    =			DDPMScheduler(
             num_train_timesteps=10_00 ,		beta_schedule="""squaredcos_cap_v2""" ,		beta_start=0.0_001 ,		beta_end=0.02 ,		thresholding=snake_case__ ,		dynamic_thresholding_ratio=0.95 ,		sample_max_value=1.0 ,		prediction_type="""epsilon""" ,		variance_type="""learned_range""" ,		)

         torch.manual_seed(0				)
         UpperCAmelCase	    =			DDPMScheduler(
             num_train_timesteps=10_00 ,		beta_schedule="""squaredcos_cap_v2""" ,		beta_start=0.0_001 ,		beta_end=0.02 ,		)

         torch.manual_seed(0				)
         UpperCAmelCase	    =			IFWatermarker()

         return {
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "unet": unet,
             "scheduler": scheduler,
             "image_noising_scheduler": image_noising_scheduler,
             "watermarker": watermarker,
             "safety_checker": None,
             "feature_extractor": None,
         }



  def 		UpperCamelCase_				(      self				)			->			Tuple:



         """simple docstring"""





         UpperCAmelCase	    =			self.get_dummy_components()
         UpperCAmelCase	    =			self.pipeline_class(**snake_case__				)
         pipe.to(snake_case__				)
         pipe.set_progress_bar_config(disable=snake_case__				)

         UpperCAmelCase	    =			self.get_dummy_inputs(snake_case__				)

         UpperCAmelCase	    =			inputs["""prompt"""]
         UpperCAmelCase	    =			inputs["""generator"""]
         UpperCAmelCase	    =			inputs["""num_inference_steps"""]
         UpperCAmelCase	    =			inputs["""output_type"""]

         if "image" in inputs:
                UpperCAmelCase	    =			inputs["""image"""]
         else:
                UpperCAmelCase	    =			None

         if "mask_image" in inputs:
                UpperCAmelCase	    =			inputs["""mask_image"""]
         else:
                UpperCAmelCase	    =			None

         if "original_image" in inputs:
                UpperCAmelCase	    =			inputs["""original_image"""]
         else:
                UpperCAmelCase	    =			None

         UpperCAmelCase    ,       UpperCAmelCase	    =			pipe.encode_prompt(snake_case__				)

         # inputs with prompt converted to embeddings
         UpperCAmelCase	    =			{
             """prompt_embeds""": prompt_embeds,
             """negative_prompt_embeds""": negative_prompt_embeds,
             """generator""": generator,
             """num_inference_steps""": num_inference_steps,
             """output_type""": output_type,
         }

         if image is not None:
                UpperCAmelCase	    =			image

         if mask_image is not None:
                UpperCAmelCase	    =			mask_image

         if original_image is not None:
                UpperCAmelCase	    =			original_image

         # set all optional components to None
         for optional_component in pipe._optional_components:
                setattr(snake_case__ ,		snake_case__ ,		snake_case__				)

         UpperCAmelCase	    =			pipe(**snake_case__				)[0]

         with tempfile.TemporaryDirectory() as tmpdir:
                pipe.save_pretrained(snake_case__				)
                UpperCAmelCase	    =			self.pipeline_class.from_pretrained(snake_case__				)
                pipe_loaded.to(snake_case__				)
                pipe_loaded.set_progress_bar_config(disable=snake_case__				)

         pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()				)  # For reproducibility tests

         for optional_component in pipe._optional_components:
                self.assertTrue(
                    getattr(snake_case__ ,		snake_case__				) is None ,		f'''`{optional_component}` did not stay set to None after loading.''' ,		)

         UpperCAmelCase	    =			self.get_dummy_inputs(snake_case__				)

         UpperCAmelCase	    =			inputs["""generator"""]
         UpperCAmelCase	    =			inputs["""num_inference_steps"""]
         UpperCAmelCase	    =			inputs["""output_type"""]

         # inputs with prompt converted to embeddings
         UpperCAmelCase	    =			{
             """prompt_embeds""": prompt_embeds,
             """negative_prompt_embeds""": negative_prompt_embeds,
             """generator""": generator,
             """num_inference_steps""": num_inference_steps,
             """output_type""": output_type,
         }

         if image is not None:
                UpperCAmelCase	    =			image

         if mask_image is not None:
                UpperCAmelCase	    =			mask_image

         if original_image is not None:
                UpperCAmelCase	    =			original_image

         UpperCAmelCase	    =			pipe_loaded(**snake_case__				)[0]

         UpperCAmelCase	    =			np.abs(to_np(snake_case__				) - to_np(snake_case__				)				).max()
         self.assertLess(snake_case__ ,		1e-4				)



  def 		UpperCamelCase_				(      self				)			->			int:



         """simple docstring"""





         UpperCAmelCase	    =			self.get_dummy_components()
         UpperCAmelCase	    =			self.pipeline_class(**snake_case__				)
         pipe.to(snake_case__				)
         pipe.set_progress_bar_config(disable=snake_case__				)

         UpperCAmelCase	    =			self.get_dummy_inputs(snake_case__				)
         UpperCAmelCase	    =			pipe(**snake_case__				)[0]

         with tempfile.TemporaryDirectory() as tmpdir:
                pipe.save_pretrained(snake_case__				)
                UpperCAmelCase	    =			self.pipeline_class.from_pretrained(snake_case__				)
                pipe_loaded.to(snake_case__				)
                pipe_loaded.set_progress_bar_config(disable=snake_case__				)

         pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()				)  # For reproducibility tests

         UpperCAmelCase	    =			self.get_dummy_inputs(snake_case__				)
         UpperCAmelCase	    =			pipe_loaded(**snake_case__				)[0]

         UpperCAmelCase	    =			np.abs(to_np(snake_case__				) - to_np(snake_case__				)				).max()
         self.assertLess(snake_case__ ,		1e-4				)
