





from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import (
						    AutoTokenizer,
						    TFAutoModelForCausalLM,
						    TFAutoModelForSeqaSeqLM,
						    TFAutoModelForSpeechSeqaSeq,
						    TFAutoModelForVisionaSeq,
						    TFBartForConditionalGeneration,
						    TFLogitsProcessorList,
						    TFMinLengthLogitsProcessor,
						    tf_top_k_top_p_filtering,
						)

if is_tensorflow_text_available():
						import tensorflow_text as text




@require_tf
class 			_a						(				unittest.TestCase    ):






				def     snake_case     (			self		:   List[Any]							)     ->				List[str]:




										'''simple docstring'''



										_UpperCamelCase      : Tuple         =   tf.convert_to_tensor(
										    [
										        [
										            8.2_220_991,  # 3rd highest value; idx. 0
										            -0.5_620_044,
										            5.23_229_752,
										            4.0_386_393,
										            -6.8_798_378,
										            -0.54_785_802,
										            -3.2_012_153,
										            2.92_777_176,
										            1.88_171_953,
										            7.35_341_276,  # 5th highest value; idx. 9
										            8.43_207_833,  # 2nd highest value; idx. 10
										            -9.85_711_836,
										            -5.96_209_236,
										            -1.13_039_161,
										            -7.1_115_294,
										            -0.8_369_633,
										            -5.3_186_408,
										            7.06_427_407,
										            0.81_369_344,
										            -0.82_023_817,
										            -5.9_179_796,
										            0.58_813_443,
										            -6.99_778_438,
										            4.71_551_189,
										            -0.18_771_637,
										            7.44_020_759,  # 4th highest value; idx. 25
										            9.38_450_987,  # 1st highest value; idx. 26
										            2.12_662_941,
										            -9.32_562_038,
										            2.35_652_522,
										        ],  # cummulative prob of 5 highest values <= 0.6
										        [
										            0.58_425_518,
										            4.53_139_238,
										            -5.57_510_464,
										            -6.28_030_699,
										            -7.19_529_503,
										            -4.02_122_551,
										            1.39_337_037,
										            -6.06_707_057,
										            1.59_480_517,
										            -9.643_119,
										            0.03_907_799,
										            0.67_231_762,
										            -8.88_206_726,
										            6.27_115_922,  # 4th highest value; idx. 13
										            2.28_520_723,
										            4.82_767_506,
										            4.30_421_368,
										            8.8_275_313,  # 2nd highest value; idx. 17
										            5.44_029_958,  # 5th highest value; idx. 18
										            -4.4_735_794,
										            7.38_579_536,  # 3rd highest value; idx. 20
										            -2.91_051_663,
										            2.61_946_077,
										            -2.5_674_762,
										            -9.48_959_302,
										            -4.02_922_645,
										            -1.35_416_918,
										            9.67_702_323,  # 1st highest value; idx. 27
										            -5.89_478_553,
										            1.85_370_467,
										        ],  # cummulative prob of 5 highest values <= 0.6
										    ],			dtype=tf.floataa,			)

										_UpperCamelCase      : Optional[int]         =   tf.convert_to_tensor(
										    [[0, 0], [0, 9], [0, 1_0], [0, 2_5], [0, 2_6], [1, 1_3], [1, 1_7], [1, 1_8], [1, 2_0], [1, 2_7]],			dtype=tf.intaa,			)  # expected non filtered idx as noted above

										_UpperCamelCase      : Any         =   tf.convert_to_tensor(
										    [8.222_099, 7.3_534_126, 8.432_078, 7.4_402_075, 9.38_451, 6.271_159, 8.827_531, 5.4_402_995, 7.3_857_956, 9.677_023],			dtype=tf.floataa,			)  # expected non filtered values as noted above

										_UpperCamelCase      : List[Any]         =   tf_top_k_top_p_filtering(_SCREAMING_SNAKE_CASE,			top_k=1_0,			top_p=0.6,			min_tokens_to_keep=4							)

										_UpperCamelCase      : Any         =   output[output != -float('''inf'''							)]
										_UpperCamelCase      : Any         =   tf.cast(
										    tf.where(tf.not_equal(_SCREAMING_SNAKE_CASE,			tf.constant(-float('''inf'''							),			dtype=tf.floataa							)							)							),			dtype=tf.intaa,			)

										tf.debugging.assert_near(_SCREAMING_SNAKE_CASE,			_SCREAMING_SNAKE_CASE,			rtol=1e-1_2							)
										tf.debugging.assert_equal(_SCREAMING_SNAKE_CASE,			_SCREAMING_SNAKE_CASE							)




@require_tf
class 			_a						(				unittest.TestCase     ,    SCREAMING_SNAKE_CASE__    ):




				if is_tf_available():
								UpperCamelCase								=   {
								    'AutoModelForCausalLM': TFAutoModelForCausalLM,
								    'AutoModelForSpeechSeq2Seq': TFAutoModelForSpeechSeqaSeq,
								    'AutoModelForSeq2SeqLM': TFAutoModelForSeqaSeqLM,
								    'AutoModelForVision2Seq': TFAutoModelForVisionaSeq,
								    'LogitsProcessorList': TFLogitsProcessorList,
								    'MinLengthLogitsProcessor': TFMinLengthLogitsProcessor,
								    'create_tensor_fn': tf.convert_to_tensor,
								    'floats_tensor': floats_tensor,
								    'return_tensors': 'tf',
								}






				@slow
				def     snake_case     (			self		:   str							)     ->				Dict:




										'''simple docstring'''



										_UpperCamelCase      : List[Any]         =   TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''							)
										_UpperCamelCase      : List[str]         =   2
										_UpperCamelCase      : int         =   2




										class 			_a						(				tf.Module    ):






														def __init__(			self		:   Dict,			lowerCAmelCase__		:   Union[str, Any]							)     ->				Union[str, Any]:




																				'''simple docstring'''



																				super(_SCREAMING_SNAKE_CASE,			self							).__init__()
																				_UpperCamelCase      : Tuple         =   model






														@tf.function(
														    input_signature=(
														        tf.TensorSpec((None, input_length),			tf.intaa,			name='''input_ids'''							),
														        tf.TensorSpec((None, input_length),			tf.intaa,			name='''attention_mask'''							),
														    ),			jit_compile=_SCREAMING_SNAKE_CASE,			)
														def     snake_case     (			self		:   Tuple,			lowerCAmelCase__		:   Optional[int],			lowerCAmelCase__		:   Dict							)     ->				int:




																				'''simple docstring'''



																				_UpperCamelCase      : Tuple         =   self.model.generate(
																				    input_ids=_SCREAMING_SNAKE_CASE,			attention_mask=_SCREAMING_SNAKE_CASE,			max_new_tokens=_SCREAMING_SNAKE_CASE,			return_dict_in_generate=_SCREAMING_SNAKE_CASE,			)
																				return {"sequences": outputs["sequences"]}

										_UpperCamelCase      : Any         =   [[2, 0], [1_0_2, 1_0_3]]
										_UpperCamelCase      : List[Any]         =   [[1, 0], [1, 1]]
										_UpperCamelCase      : List[Any]         =   DummyModel(model=_SCREAMING_SNAKE_CASE							)
										with tempfile.TemporaryDirectory() as tmp_dir:
																tf.saved_model.save(_SCREAMING_SNAKE_CASE,			_SCREAMING_SNAKE_CASE,			signatures={'''serving_default''': dummy_model.serving}							)
																_UpperCamelCase      : Tuple         =   tf.saved_model.load(_SCREAMING_SNAKE_CASE							).signatures["serving_default"]
																for batch_size in range(1,			len(_SCREAMING_SNAKE_CASE							) + 1							):
																						_UpperCamelCase      : str         =   {
																						    "input_ids": tf.constant(dummy_input_ids[:batch_size]							),
																						    "attention_mask": tf.constant(dummy_attention_masks[:batch_size]							),
																						}
																						_UpperCamelCase      : Union[str, Any]         =   serving_func(**_SCREAMING_SNAKE_CASE							)["sequences"]
																						_UpperCamelCase      : List[str]         =   test_model.generate(**_SCREAMING_SNAKE_CASE,			max_new_tokens=_SCREAMING_SNAKE_CASE							)
																						tf.debugging.assert_equal(_SCREAMING_SNAKE_CASE,			_SCREAMING_SNAKE_CASE							)






				@slow
				def     snake_case     (			self		:   Optional[Any]							)     ->				str:




										'''simple docstring'''



										_UpperCamelCase      : Optional[Any]         =   TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''							)
										_UpperCamelCase      : List[str]         =   1
										_UpperCamelCase      : Union[str, Any]         =   2




										class 			_a						(				tf.Module    ):






														def __init__(			self		:   Dict,			lowerCAmelCase__		:   int							)     ->				List[Any]:




																				'''simple docstring'''



																				super(_SCREAMING_SNAKE_CASE,			self							).__init__()
																				_UpperCamelCase      : Dict         =   model






														@tf.function(
														    input_signature=(
														        tf.TensorSpec((batch_size, None),			tf.intaa,			name='''input_ids'''							),
														        tf.TensorSpec((batch_size, None),			tf.intaa,			name='''attention_mask'''							),
														    ),			jit_compile=_SCREAMING_SNAKE_CASE,			)
														def     snake_case     (			self		:   Any,			lowerCAmelCase__		:   Any,			lowerCAmelCase__		:   List[Any]							)     ->				Optional[int]:




																				'''simple docstring'''



																				_UpperCamelCase      : int         =   self.model.generate(
																				    input_ids=_SCREAMING_SNAKE_CASE,			attention_mask=_SCREAMING_SNAKE_CASE,			max_new_tokens=_SCREAMING_SNAKE_CASE,			return_dict_in_generate=_SCREAMING_SNAKE_CASE,			)
																				return {"sequences": outputs["sequences"]}

										_UpperCamelCase      : Union[str, Any]         =   [[2], [1_0_2, 1_0_3]]
										_UpperCamelCase      : int         =   [[1], [1, 1]]
										_UpperCamelCase      : List[str]         =   DummyModel(model=_SCREAMING_SNAKE_CASE							)
										with tempfile.TemporaryDirectory() as tmp_dir:
																tf.saved_model.save(_SCREAMING_SNAKE_CASE,			_SCREAMING_SNAKE_CASE,			signatures={'''serving_default''': dummy_model.serving}							)
																_UpperCamelCase      : Any         =   tf.saved_model.load(_SCREAMING_SNAKE_CASE							).signatures["serving_default"]
																for input_row in range(len(_SCREAMING_SNAKE_CASE							)							):
																						_UpperCamelCase      : int         =   {
																						    "input_ids": tf.constant([dummy_input_ids[input_row]]							),
																						    "attention_mask": tf.constant([dummy_attention_masks[input_row]]							),
																						}
																						_UpperCamelCase      : Optional[int]         =   serving_func(**_SCREAMING_SNAKE_CASE							)["sequences"]
																						_UpperCamelCase      : Tuple         =   test_model.generate(**_SCREAMING_SNAKE_CASE,			max_new_tokens=_SCREAMING_SNAKE_CASE							)
																						tf.debugging.assert_equal(_SCREAMING_SNAKE_CASE,			_SCREAMING_SNAKE_CASE							)






				@slow
				@require_tensorflow_text
				def     snake_case     (			self		:   Union[str, Any]							)     ->				int:




										'''simple docstring'''



										with tempfile.TemporaryDirectory() as tmp_dir:
																# file needed to load the TF tokenizer
																hf_hub_download(repo_id='''google/flan-t5-small''',			filename='''spiece.model''',			local_dir=_SCREAMING_SNAKE_CASE							)




																class 			_a						(				tf.keras.layers.Layer    ):






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




																										'''simple docstring'''



																										super().__init__()
																										_UpperCamelCase      : List[str]         =   text.SentencepieceTokenizer(
																										    model=tf.io.gfile.GFile(os.path.join(_SCREAMING_SNAKE_CASE,			'''spiece.model'''							),			'''rb'''							).read()							)
																										_UpperCamelCase      : List[str]         =   TFAutoModelForSeqaSeqLM.from_pretrained('''hf-internal-testing/tiny-random-t5'''							)






																				def     snake_case     (			self		:   str,			lowerCAmelCase__		:   Optional[Any],			*lowerCAmelCase__		:   Optional[Any],			**lowerCAmelCase__		:   List[Any]							)     ->				List[str]:




																										'''simple docstring'''



																										_UpperCamelCase      : int         =   self.tokenizer.tokenize(_SCREAMING_SNAKE_CASE							)
																										_UpperCamelCase      : Union[str, Any]         =   text.pad_model_inputs(
																										    _SCREAMING_SNAKE_CASE,			max_seq_length=6_4,			pad_value=self.model.config.pad_token_id							)
																										_UpperCamelCase      : Optional[Any]         =   self.model.generate(input_ids=_SCREAMING_SNAKE_CASE,			attention_mask=_SCREAMING_SNAKE_CASE							)
																										return self.tokenizer.detokenize(_SCREAMING_SNAKE_CASE							)

																_UpperCamelCase      : int         =   CompleteSentenceTransformer()
																_UpperCamelCase      : Dict         =   tf.keras.layers.Input(shape=(1,),			dtype=tf.string,			name='''inputs'''							)
																_UpperCamelCase      : Any         =   complete_model(_SCREAMING_SNAKE_CASE							)
																_UpperCamelCase      : Optional[int]         =   tf.keras.Model(_SCREAMING_SNAKE_CASE,			_SCREAMING_SNAKE_CASE							)
																keras_model.save(_SCREAMING_SNAKE_CASE							)






				def     snake_case     (			self		:   List[Any]							)     ->				str:




										'''simple docstring'''



										_UpperCamelCase      : int         =   {
										    "do_sample": True,
										    "num_beams": 1,
										    "top_p": 0.7,
										    "top_k": 1_0,
										    "temperature": 0.7,
										}
										_UpperCamelCase      : List[Any]         =   1_4

										_UpperCamelCase      : Optional[int]         =   AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''							)
										_UpperCamelCase      : int         =   "Hello, my dog is cute and"
										_UpperCamelCase      : Dict         =   tokenizer(_SCREAMING_SNAKE_CASE,			return_tensors='''tf'''							)
										_UpperCamelCase      : List[str]         =   TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''							)

										_UpperCamelCase      : List[Any]         =   6_3_8
										# forces the generation to happen on CPU, to avoid GPU-related quirks
										with tf.device(''':/CPU:0'''							):
																tf.random.set_seed(0							)
																_UpperCamelCase      : Union[str, Any]         =   model.generate(**_SCREAMING_SNAKE_CASE,			eos_token_id=_SCREAMING_SNAKE_CASE,			**_SCREAMING_SNAKE_CASE							)
										self.assertTrue(expectation == len(generated_tokens[0]							)							)

										_UpperCamelCase      : List[str]         =   [6_3_8, 1_9_8]
										with tf.device(''':/CPU:0'''							):
																tf.random.set_seed(0							)
																_UpperCamelCase      : Dict         =   model.generate(**_SCREAMING_SNAKE_CASE,			eos_token_id=_SCREAMING_SNAKE_CASE,			**_SCREAMING_SNAKE_CASE							)
										self.assertTrue(expectation == len(generated_tokens[0]							)							)






				def     snake_case     (			self		:   List[str]							)     ->				List[Any]:




										'''simple docstring'''



										_UpperCamelCase      : Optional[int]         =   AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bart'''							)
										_UpperCamelCase      : List[str]         =   "Hugging Face is a technology company based in New York and Paris."
										_UpperCamelCase      : List[Any]         =   bart_tokenizer(_SCREAMING_SNAKE_CASE,			return_tensors='''tf'''							).input_ids
										_UpperCamelCase      : List[Any]         =   TFBartForConditionalGeneration.from_pretrained('''hf-internal-testing/tiny-random-bart'''							)
										_UpperCamelCase      : int         =   bart_model.generate(_SCREAMING_SNAKE_CASE							).numpy()




										class 			_a						(				SCREAMING_SNAKE_CASE__    ):






														def     snake_case     (			self		:   List[Any],			lowerCAmelCase__		:   Tuple,			lowerCAmelCase__		:   List[Any]=None,			**lowerCAmelCase__		:   List[Any]							)     ->				Any:




																				'''simple docstring'''



																				return super().call(_SCREAMING_SNAKE_CASE,			**_SCREAMING_SNAKE_CASE							)

										_UpperCamelCase      : Dict         =   FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart'''							)
										_UpperCamelCase      : Tuple         =   bart_model.generate(_SCREAMING_SNAKE_CASE,			foo='''bar'''							).numpy()
										self.assertTrue(np.array_equal(_SCREAMING_SNAKE_CASE,			_SCREAMING_SNAKE_CASE							)							)




										class 			_a						(				bart_model.model.encoder.__class__    ):






														def     snake_case     (			self		:   Dict,			lowerCAmelCase__		:   int,			**lowerCAmelCase__		:   List[str]							)     ->				List[Any]:




																				'''simple docstring'''



																				return super().call(_SCREAMING_SNAKE_CASE,			**_SCREAMING_SNAKE_CASE							)

										_UpperCamelCase      : List[str]         =   FakeEncoder(bart_model.config,			bart_model.model.shared							)
										_UpperCamelCase      : List[Any]         =   fake_encoder

										# Normal generation still works (the output will be different because the encoder weights are different)
										_UpperCamelCase      : Optional[Any]         =   bart_model.generate(_SCREAMING_SNAKE_CASE							).numpy()
										with self.assertRaises(_SCREAMING_SNAKE_CASE							):
																# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
																bart_model.generate(_SCREAMING_SNAKE_CASE,			foo='''bar'''							)










"""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						(				_lowerCAmelCase     ,    _lowerCAmelCase     ,    _lowerCAmelCase     ,    unittest.TestCase    ):
				UpperCamelCase								=   AltDiffusionPipeline
				UpperCamelCase								=   TEXT_TO_IMAGE_PARAMS
				UpperCamelCase								=   TEXT_TO_IMAGE_BATCH_PARAMS
				UpperCamelCase								=   TEXT_TO_IMAGE_IMAGE_PARAMS
				UpperCamelCase								=   TEXT_TO_IMAGE_IMAGE_PARAMS






				def     snake_case     (			self		:   int							)     ->				int:




										'''simple docstring'''



										torch.manual_seed(0							)
										_UpperCamelCase      : Dict         =   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,			)
										_UpperCamelCase      : Union[str, Any]         =   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							)
										_UpperCamelCase      : List[str]         =   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							)
										_UpperCamelCase      : 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-0_5,			num_attention_heads=4,			num_hidden_layers=5,			pad_token_id=1,			vocab_size=5_0_0_2,			)
										_UpperCamelCase      : List[Any]         =   CLIPTextModel(lowerCAmelCase__							)

										_UpperCamelCase      : Dict         =   XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''							)
										_UpperCamelCase      : str         =   7_7

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






				def     snake_case     (			self		:   Dict,			lowerCAmelCase__		:   Any,			lowerCAmelCase__		:   int=0							)     ->				Optional[int]:




										'''simple docstring'''



										if str(lowerCAmelCase__							).startswith('''mps'''							):
																_UpperCamelCase      : Any         =   torch.manual_seed(lowerCAmelCase__							)
										else:
																_UpperCamelCase      : Dict         =   torch.Generator(device=lowerCAmelCase__							).manual_seed(lowerCAmelCase__							)
										_UpperCamelCase      : str         =   {
										    '''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     snake_case     (			self		:   List[Any]							)     ->				List[str]:




										'''simple docstring'''



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






				def     snake_case     (			self		:   List[Any]							)     ->				Tuple:




										'''simple docstring'''



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






				def     snake_case     (			self		:   List[str]							)     ->				List[Any]:




										'''simple docstring'''



										_UpperCamelCase      : Any         =   '''cpu'''  # ensure determinism for the device-dependent torch.Generator

										_UpperCamelCase      : int         =   self.get_dummy_components()
										torch.manual_seed(0							)
										_UpperCamelCase      : Any         =   RobertaSeriesConfig(
										    hidden_size=3_2,			project_dim=3_2,			intermediate_size=3_7,			layer_norm_eps=1e-0_5,			num_attention_heads=4,			num_hidden_layers=5,			vocab_size=5_0_0_2,			)
										# TODO: remove after fixing the non-deterministic text encoder
										_UpperCamelCase      : Tuple         =   RobertaSeriesModelWithTransformation(lowerCAmelCase__							)
										_UpperCamelCase      : str         =   text_encoder

										_UpperCamelCase      : List[Any]         =   AltDiffusionPipeline(**lowerCAmelCase__							)
										_UpperCamelCase      : List[Any]         =   alt_pipe.to(lowerCAmelCase__							)
										alt_pipe.set_progress_bar_config(disable=lowerCAmelCase__							)

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

										assert image.shape == (1, 6_4, 6_4, 3)
										_UpperCamelCase      : List[Any]         =   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     snake_case     (			self		:   int							)     ->				Optional[Any]:




										'''simple docstring'''



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

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

										_UpperCamelCase      : Union[str, Any]         =   self.get_dummy_inputs(lowerCAmelCase__							)
										_UpperCamelCase      : Optional[int]         =   alt_pipe(**lowerCAmelCase__							)
										_UpperCamelCase      : List[str]         =   output.images
										_UpperCamelCase      : Optional[int]         =   image[0, -3:, -3:, -1]

										assert image.shape == (1, 6_4, 6_4, 3)
										_UpperCamelCase      : List[Any]         =   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    ):






				def     snake_case     (			self		:   List[str]							)     ->				Any:




										'''simple docstring'''



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






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




										'''simple docstring'''



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

										_UpperCamelCase      : int         =   '''A painting of a squirrel eating a burger'''
										_UpperCamelCase      : int         =   torch.manual_seed(0							)
										_UpperCamelCase      : Dict         =   alt_pipe([prompt],			generator=lowerCAmelCase__,			guidance_scale=6.0,			num_inference_steps=2_0,			output_type='''np'''							)

										_UpperCamelCase      : Optional[int]         =   output.images

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

										assert image.shape == (1, 5_1_2, 5_1_2, 3)
										_UpperCamelCase      : List[str]         =   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     snake_case     (			self		:   str							)     ->				str:




										'''simple docstring'''



										_UpperCamelCase      : Any         =   DDIMScheduler.from_pretrained('''BAAI/AltDiffusion''',			subfolder='''scheduler'''							)

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

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

										_UpperCamelCase      : Union[str, Any]         =   alt_pipe([prompt],			generator=lowerCAmelCase__,			num_inference_steps=2,			output_type='''numpy'''							)
										_UpperCamelCase      : Tuple         =   output.images

										_UpperCamelCase      : Dict         =   image[0, -3:, -3:, -1]

										assert image.shape == (1, 5_1_2, 5_1_2, 3)
										_UpperCamelCase      : str         =   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



