

import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
lowerCamelCase_    :		Tuple							=	{'LayoutLMv2Config', 'LayoutLMv3Config'}


@is_pipeline_test
class 						a__							(       unittest.TestCase		):
			A__    :       Tuple        =      MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
			A__    :       Any        =      TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

			if model_mapping is not None:
						A__    :       Union[str, Any]        =      {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
			if tf_model_mapping is not None:
						A__    :       Optional[Any]        =      {
						    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
						}



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Dict:
								__a		 =       ZeroShotClassificationPipeline(
								    model=SCREAMING_SNAKE_CASE_				,						tokenizer=SCREAMING_SNAKE_CASE_				,						candidate_labels=['polics', 'health']   )
								return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Dict:
								__a		 =       classifier('Who are you voting for in 2020?'				,						candidate_labels='politics'   )
								self.assertEqual(SCREAMING_SNAKE_CASE_				,						{'sequence': ANY(SCREAMING_SNAKE_CASE_   ), 'labels': [ANY(SCREAMING_SNAKE_CASE_   )], 'scores': [ANY(SCREAMING_SNAKE_CASE_   )]}   )

								# No kwarg
								__a		 =       classifier('Who are you voting for in 2020?'				,						['politics']   )
								self.assertEqual(SCREAMING_SNAKE_CASE_				,						{'sequence': ANY(SCREAMING_SNAKE_CASE_   ), 'labels': [ANY(SCREAMING_SNAKE_CASE_   )], 'scores': [ANY(SCREAMING_SNAKE_CASE_   )]}   )

								__a		 =       classifier('Who are you voting for in 2020?'				,						candidate_labels=['politics']   )
								self.assertEqual(SCREAMING_SNAKE_CASE_				,						{'sequence': ANY(SCREAMING_SNAKE_CASE_   ), 'labels': [ANY(SCREAMING_SNAKE_CASE_   )], 'scores': [ANY(SCREAMING_SNAKE_CASE_   )]}   )

								__a		 =       classifier('Who are you voting for in 2020?'				,						candidate_labels='politics, public health'   )
								self.assertEqual(
								    SCREAMING_SNAKE_CASE_				,						{'sequence': ANY(SCREAMING_SNAKE_CASE_   ), 'labels': [ANY(SCREAMING_SNAKE_CASE_   ), ANY(SCREAMING_SNAKE_CASE_   )], 'scores': [ANY(SCREAMING_SNAKE_CASE_   ), ANY(SCREAMING_SNAKE_CASE_   )]}   )
								self.assertAlmostEqual(sum(nested_simplify(outputs['scores']   )   )				,						1.0   )

								__a		 =       classifier('Who are you voting for in 2020?'				,						candidate_labels=['politics', 'public health']   )
								self.assertEqual(
								    SCREAMING_SNAKE_CASE_				,						{'sequence': ANY(SCREAMING_SNAKE_CASE_   ), 'labels': [ANY(SCREAMING_SNAKE_CASE_   ), ANY(SCREAMING_SNAKE_CASE_   )], 'scores': [ANY(SCREAMING_SNAKE_CASE_   ), ANY(SCREAMING_SNAKE_CASE_   )]}   )
								self.assertAlmostEqual(sum(nested_simplify(outputs['scores']   )   )				,						1.0   )

								__a		 =       classifier(
								    'Who are you voting for in 2020?'				,						candidate_labels='politics'				,						hypothesis_template='This text is about {}'   )
								self.assertEqual(SCREAMING_SNAKE_CASE_				,						{'sequence': ANY(SCREAMING_SNAKE_CASE_   ), 'labels': [ANY(SCREAMING_SNAKE_CASE_   )], 'scores': [ANY(SCREAMING_SNAKE_CASE_   )]}   )

								# https://github.com/huggingface/transformers/issues/13846
								__a		 =       classifier(['I am happy']				,						['positive', 'negative']   )
								self.assertEqual(
								    SCREAMING_SNAKE_CASE_				,						[
								        {'sequence': ANY(SCREAMING_SNAKE_CASE_   ), 'labels': [ANY(SCREAMING_SNAKE_CASE_   ), ANY(SCREAMING_SNAKE_CASE_   )], 'scores': [ANY(SCREAMING_SNAKE_CASE_   ), ANY(SCREAMING_SNAKE_CASE_   )]}
								        for i in range(1   )
								    ]				,						)
								__a		 =       classifier(['I am happy', 'I am sad']				,						['positive', 'negative']   )
								self.assertEqual(
								    SCREAMING_SNAKE_CASE_				,						[
								        {'sequence': ANY(SCREAMING_SNAKE_CASE_   ), 'labels': [ANY(SCREAMING_SNAKE_CASE_   ), ANY(SCREAMING_SNAKE_CASE_   )], 'scores': [ANY(SCREAMING_SNAKE_CASE_   ), ANY(SCREAMING_SNAKE_CASE_   )]}
								        for i in range(2   )
								    ]				,						)

								with self.assertRaises(SCREAMING_SNAKE_CASE_   ):
													classifier(''				,						candidate_labels='politics'   )

								with self.assertRaises(SCREAMING_SNAKE_CASE_   ):
													classifier(SCREAMING_SNAKE_CASE_				,						candidate_labels='politics'   )

								with self.assertRaises(SCREAMING_SNAKE_CASE_   ):
													classifier('Who are you voting for in 2020?'				,						candidate_labels=''   )

								with self.assertRaises(SCREAMING_SNAKE_CASE_   ):
													classifier('Who are you voting for in 2020?'				,						candidate_labels=SCREAMING_SNAKE_CASE_   )

								with self.assertRaises(SCREAMING_SNAKE_CASE_   ):
													classifier(
													    'Who are you voting for in 2020?'				,						candidate_labels='politics'				,						hypothesis_template='Not formatting template'				,						)

								with self.assertRaises(SCREAMING_SNAKE_CASE_   ):
													classifier(
													    'Who are you voting for in 2020?'				,						candidate_labels='politics'				,						hypothesis_template=SCREAMING_SNAKE_CASE_				,						)

								self.run_entailment_id(SCREAMING_SNAKE_CASE_   )



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase   )			->   Union[str, Any]:
								__a		 =       zero_shot_classifier.model.config
								__a		 =       config.labelaid
								__a		 =       zero_shot_classifier.entailment_id

								__a		 =       {"""LABEL_0""": 0, """LABEL_1""": 1, """LABEL_2""": 2}
								self.assertEqual(zero_shot_classifier.entailment_id				,						-1   )

								__a		 =       {"""entailment""": 0, """neutral""": 1, """contradiction""": 2}
								self.assertEqual(zero_shot_classifier.entailment_id				,						0   )

								__a		 =       {"""ENTAIL""": 0, """NON-ENTAIL""": 1}
								self.assertEqual(zero_shot_classifier.entailment_id				,						0   )

								__a		 =       {"""ENTAIL""": 2, """NEUTRAL""": 1, """CONTR""": 0}
								self.assertEqual(zero_shot_classifier.entailment_id				,						2   )

								__a		 =       original_labelaid
								self.assertEqual(SCREAMING_SNAKE_CASE_				,						zero_shot_classifier.entailment_id   )



			@require_torch
			def __SCREAMING_SNAKE_CASE							(						self   )			->   str:
								__a		 =       pipeline(
								    'zero-shot-classification'				,						model='sshleifer/tiny-distilbert-base-cased-distilled-squad'				,						framework='pt'				,						)
								# There was a regression in 4.10 for this
								# Adding a test so we don't make the mistake again.
								# https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
								zero_shot_classifier(
								    'Who are you voting for in 2020?' * 1_0_0				,						candidate_labels=['politics', 'public health', 'science']   )



			@require_torch
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Union[str, Any]:
								__a		 =       pipeline(
								    'zero-shot-classification'				,						model='sshleifer/tiny-distilbert-base-cased-distilled-squad'				,						framework='pt'				,						)
								__a		 =       zero_shot_classifier(
								    'Who are you voting for in 2020?'				,						candidate_labels=['politics', 'public health', 'science']   )

								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE_   )				,						{
								        'sequence': 'Who are you voting for in 2020?',
								        'labels': ['science', 'public health', 'politics'],
								        'scores': [0.333, 0.333, 0.333],
								    }				,						)



			@require_tf
			def __SCREAMING_SNAKE_CASE							(						self   )			->   int:
								__a		 =       pipeline(
								    'zero-shot-classification'				,						model='sshleifer/tiny-distilbert-base-cased-distilled-squad'				,						framework='tf'				,						)
								__a		 =       zero_shot_classifier(
								    'Who are you voting for in 2020?'				,						candidate_labels=['politics', 'public health', 'science']   )

								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE_   )				,						{
								        'sequence': 'Who are you voting for in 2020?',
								        'labels': ['science', 'public health', 'politics'],
								        'scores': [0.333, 0.333, 0.333],
								    }				,						)



			@slow
			@require_torch
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       pipeline('zero-shot-classification'				,						model='roberta-large-mnli'				,						framework='pt'   )
								__a		 =       zero_shot_classifier(
								    'Who are you voting for in 2020?'				,						candidate_labels=['politics', 'public health', 'science']   )

								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE_   )				,						{
								        'sequence': 'Who are you voting for in 2020?',
								        'labels': ['politics', 'public health', 'science'],
								        'scores': [0.976, 0.015, 0.009],
								    }				,						)
								__a		 =       zero_shot_classifier(
								    'The dominant sequence transduction models are based on complex recurrent or convolutional neural networks'
								    ' in an encoder-decoder configuration. The best performing models also connect the encoder and decoder'
								    ' through an attention mechanism. We propose a new simple network architecture, the Transformer, based'
								    ' solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two'
								    ' machine translation tasks show these models to be superior in quality while being more parallelizable'
								    ' and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014'
								    ' English-to-German translation task, improving over the existing best results, including ensembles by'
								    ' over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new'
								    ' single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small'
								    ' fraction of the training costs of the best models from the literature. We show that the Transformer'
								    ' generalizes well to other tasks by applying it successfully to English constituency parsing both with'
								    ' large and limited training data.'				,						candidate_labels=['machine learning', 'statistics', 'translation', 'vision']				,						multi_label=SCREAMING_SNAKE_CASE_				,						)
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE_   )				,						{
								        'sequence': (
								            'The dominant sequence transduction models are based on complex recurrent or convolutional neural'
								            ' networks in an encoder-decoder configuration. The best performing models also connect the'
								            ' encoder and decoder through an attention mechanism. We propose a new simple network'
								            ' architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence'
								            ' and convolutions entirely. Experiments on two machine translation tasks show these models to be'
								            ' superior in quality while being more parallelizable and requiring significantly less time to'
								            ' train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,'
								            ' improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014'
								            ' English-to-French translation task, our model establishes a new single-model state-of-the-art'
								            ' BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training'
								            ' costs of the best models from the literature. We show that the Transformer generalizes well to'
								            ' other tasks by applying it successfully to English constituency parsing both with large and'
								            ' limited training data.'
								        ),
								        'labels': ['translation', 'machine learning', 'vision', 'statistics'],
								        'scores': [0.817, 0.713, 0.018, 0.018],
								    }				,						)







			@slow
			@require_tf
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       pipeline('zero-shot-classification'				,						model='roberta-large-mnli'				,						framework='tf'   )
								__a		 =       zero_shot_classifier(
								    'Who are you voting for in 2020?'				,						candidate_labels=['politics', 'public health', 'science']   )

								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE_   )				,						{
								        'sequence': 'Who are you voting for in 2020?',
								        'labels': ['politics', 'public health', 'science'],
								        'scores': [0.976, 0.015, 0.009],
								    }				,						)
								__a		 =       zero_shot_classifier(
								    'The dominant sequence transduction models are based on complex recurrent or convolutional neural networks'
								    ' in an encoder-decoder configuration. The best performing models also connect the encoder and decoder'
								    ' through an attention mechanism. We propose a new simple network architecture, the Transformer, based'
								    ' solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two'
								    ' machine translation tasks show these models to be superior in quality while being more parallelizable'
								    ' and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014'
								    ' English-to-German translation task, improving over the existing best results, including ensembles by'
								    ' over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new'
								    ' single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small'
								    ' fraction of the training costs of the best models from the literature. We show that the Transformer'
								    ' generalizes well to other tasks by applying it successfully to English constituency parsing both with'
								    ' large and limited training data.'				,						candidate_labels=['machine learning', 'statistics', 'translation', 'vision']				,						multi_label=SCREAMING_SNAKE_CASE_				,						)
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE_   )				,						{
								        'sequence': (
								            'The dominant sequence transduction models are based on complex recurrent or convolutional neural'
								            ' networks in an encoder-decoder configuration. The best performing models also connect the'
								            ' encoder and decoder through an attention mechanism. We propose a new simple network'
								            ' architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence'
								            ' and convolutions entirely. Experiments on two machine translation tasks show these models to be'
								            ' superior in quality while being more parallelizable and requiring significantly less time to'
								            ' train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,'
								            ' improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014'
								            ' English-to-French translation task, our model establishes a new single-model state-of-the-art'
								            ' BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training'
								            ' costs of the best models from the literature. We show that the Transformer generalizes well to'
								            ' other tasks by applying it successfully to English constituency parsing both with large and'
								            ' limited training data.'
								        ),
								        'labels': ['translation', 'machine learning', 'vision', 'statistics'],
								        'scores': [0.817, 0.713, 0.018, 0.018],
								    }				,						)





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 						a__							:



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[Any]:
								torch.manual_seed(0   )
								__a		 =       TaEncoderModel.from_pretrained('hf-internal-testing/tiny-random-t5'   )

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

								torch.manual_seed(0   )
								__a		 =       UNetaDConditionModel(
								    sample_size=3_2				,						layers_per_block=1				,						block_out_channels=[3_2, 6_4]				,						down_block_types=[
								        'ResnetDownsampleBlock2D',
								        'SimpleCrossAttnDownBlock2D',
								    ]				,						mid_block_type='UNetMidBlock2DSimpleCrossAttn'				,						up_block_types=['SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D']				,						in_channels=3				,						out_channels=6				,						cross_attention_dim=3_2				,						encoder_hid_dim=3_2				,						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   )
								__a		 =       DDPMScheduler(
								    num_train_timesteps=1_0_0_0				,						beta_schedule='squaredcos_cap_v2'				,						beta_start=0.0_001				,						beta_end=0.02				,						thresholding=UpperCAmelCase				,						dynamic_thresholding_ratio=0.95				,						sample_max_value=1.0				,						prediction_type='epsilon'				,						variance_type='learned_range'				,						)

								torch.manual_seed(0   )
								__a		 =       IFWatermarker()

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



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								torch.manual_seed(0   )
								__a		 =       TaEncoderModel.from_pretrained('hf-internal-testing/tiny-random-t5'   )

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

								torch.manual_seed(0   )
								__a		 =       UNetaDConditionModel(
								    sample_size=3_2				,						layers_per_block=[1, 2]				,						block_out_channels=[3_2, 6_4]				,						down_block_types=[
								        'ResnetDownsampleBlock2D',
								        'SimpleCrossAttnDownBlock2D',
								    ]				,						mid_block_type='UNetMidBlock2DSimpleCrossAttn'				,						up_block_types=['SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D']				,						in_channels=6				,						out_channels=6				,						cross_attention_dim=3_2				,						encoder_hid_dim=3_2				,						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=3_2				,						)
								unet.set_attn_processor(AttnAddedKVProcessor()   )  # For reproducibility tests

								torch.manual_seed(0   )
								__a		 =       DDPMScheduler(
								    num_train_timesteps=1_0_0_0				,						beta_schedule='squaredcos_cap_v2'				,						beta_start=0.0_001				,						beta_end=0.02				,						thresholding=UpperCAmelCase				,						dynamic_thresholding_ratio=0.95				,						sample_max_value=1.0				,						prediction_type='epsilon'				,						variance_type='learned_range'				,						)

								torch.manual_seed(0   )
								__a		 =       DDPMScheduler(
								    num_train_timesteps=1_0_0_0				,						beta_schedule='squaredcos_cap_v2'				,						beta_start=0.0_001				,						beta_end=0.02				,						)

								torch.manual_seed(0   )
								__a		 =       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 __SCREAMING_SNAKE_CASE							(						self   )			->   str:
								__a		 =       self.get_dummy_components()
								__a		 =       self.pipeline_class(**UpperCAmelCase   )
								pipe.to(UpperCAmelCase   )
								pipe.set_progress_bar_config(disable=UpperCAmelCase   )

								__a		 =       self.get_dummy_inputs(UpperCAmelCase   )

								__a		 =       inputs['prompt']
								__a		 =       inputs['generator']
								__a		 =       inputs['num_inference_steps']
								__a		 =       inputs['output_type']

								if "image" in inputs:
													__a		 =       inputs['image']
								else:
													__a		 =       None

								if "mask_image" in inputs:
													__a		 =       inputs['mask_image']
								else:
													__a		 =       None

								if "original_image" in inputs:
													__a		 =       inputs['original_image']
								else:
													__a		 =       None

								__a ,				__a		 =       pipe.encode_prompt(UpperCAmelCase   )

								# inputs with prompt converted to embeddings
								__a		 =       {
								    '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:
													__a		 =       image

								if mask_image is not None:
													__a		 =       mask_image

								if original_image is not None:
													__a		 =       original_image

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

								__a		 =       pipe(**UpperCAmelCase   )[0]

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

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

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

								__a		 =       self.get_dummy_inputs(UpperCAmelCase   )

								__a		 =       inputs['generator']
								__a		 =       inputs['num_inference_steps']
								__a		 =       inputs['output_type']

								# inputs with prompt converted to embeddings
								__a		 =       {
								    '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:
													__a		 =       image

								if mask_image is not None:
													__a		 =       mask_image

								if original_image is not None:
													__a		 =       original_image

								__a		 =       pipe_loaded(**UpperCAmelCase   )[0]

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







			def __SCREAMING_SNAKE_CASE							(						self   )			->   int:
								__a		 =       self.get_dummy_components()
								__a		 =       self.pipeline_class(**UpperCAmelCase   )
								pipe.to(UpperCAmelCase   )
								pipe.set_progress_bar_config(disable=UpperCAmelCase   )

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

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

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

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

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




