



'''simple docstring'''


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      __UpperCamelCase       (unittest.TestCase			):







	def   _a   (    self						)    ->    Optional[int]:
							'''simple docstring'''






							lowercase        =							tf.convert_to_tensor(
							    [
							        [
							            8.222_0991,  # 3rd highest value; idx. 0
							            -0.562_0044,
							            5.2322_9752,
							            4.038_6393,
							            -6.879_8378,
							            -0.5478_5802,
							            -3.201_2153,
							            2.9277_7176,
							            1.8817_1953,
							            7.3534_1276,  # 5th highest value; idx. 9
							            8.4320_7833,  # 2nd highest value; idx. 10
							            -9.8571_1836,
							            -5.9620_9236,
							            -1.1303_9161,
							            -7.111_5294,
							            -0.836_9633,
							            -5.318_6408,
							            7.0642_7407,
							            0.8136_9344,
							            -0.8202_3817,
							            -5.917_9796,
							            0.5881_3443,
							            -6.9977_8438,
							            4.7155_1189,
							            -0.1877_1637,
							            7.4402_0759,  # 4th highest value; idx. 25
							            9.3845_0987,  # 1st highest value; idx. 26
							            2.1266_2941,
							            -9.3256_2038,
							            2.3565_2522,
							        ],  # cummulative prob of 5 highest values <= 0.6
							        [
							            0.5842_5518,
							            4.5313_9238,
							            -5.5751_0464,
							            -6.2803_0699,
							            -7.1952_9503,
							            -4.0212_2551,
							            1.3933_7037,
							            -6.0670_7057,
							            1.5948_0517,
							            -9.64_3119,
							            0.0390_7799,
							            0.6723_1762,
							            -8.8820_6726,
							            6.2711_5922,  # 4th highest value; idx. 13
							            2.2852_0723,
							            4.8276_7506,
							            4.3042_1368,
							            8.827_5313,  # 2nd highest value; idx. 17
							            5.4402_9958,  # 5th highest value; idx. 18
							            -4.473_5794,
							            7.3857_9536,  # 3rd highest value; idx. 20
							            -2.9105_1663,
							            2.6194_6077,
							            -2.567_4762,
							            -9.4895_9302,
							            -4.0292_2645,
							            -1.3541_6918,
							            9.6770_2323,  # 1st highest value; idx. 27
							            -5.8947_8553,
							            1.8537_0467,
							        ],  # cummulative prob of 5 highest values <= 0.6
							    ] ,				dtype=tf.floataa ,				)

							lowercase        =							tf.convert_to_tensor(
							    [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]] ,				dtype=tf.intaa ,				)  # expected non filtered idx as noted above

							lowercase        =							tf.convert_to_tensor(
							    [8.22_2099, 7.353_4126, 8.43_2078, 7.440_2075, 9.3_8451, 6.27_1159, 8.82_7531, 5.440_2995, 7.385_7956, 9.67_7023] ,				dtype=tf.floataa ,				)  # expected non filtered values as noted above

							lowercase        =							tf_top_k_top_p_filtering(_lowerCAmelCase ,				top_k=10 ,				top_p=0.6 ,				min_tokens_to_keep=4						)

							lowercase        =							output[output != -float("""inf"""						)]
							lowercase        =							tf.cast(
							    tf.where(tf.not_equal(_lowerCAmelCase ,				tf.constant(-float("""inf"""						) ,				dtype=tf.floataa						)						)						) ,				dtype=tf.intaa ,				)

							tf.debugging.assert_near(_lowerCAmelCase ,				_lowerCAmelCase ,				rtol=1E-12						)
							tf.debugging.assert_equal(_lowerCAmelCase ,				_lowerCAmelCase						)




@require_tf
class      __UpperCamelCase       (unittest.TestCase			,   _UpperCAmelCase			):
	# setting framework_dependent_parameters needs to be gated, just like its contents' imports
	if is_tf_available():
		__A			  =					{
		    '''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   _a   (    self						)    ->    List[str]:
							'''simple docstring'''






							lowercase        =							TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""						)
							lowercase        =							2
							lowercase        =							2




							class      __UpperCamelCase       (tf.Module			):







								def __init__(    self ,				_lowerCAmelCase						)    ->    Union[str, Any]:
														'''simple docstring'''






														super(_lowerCAmelCase ,				self						).__init__()
														lowercase        =							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=_lowerCAmelCase ,				)
								def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    int:
														'''simple docstring'''






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




							lowercase        =							[[2, 0], [102, 103]]
							lowercase        =							[[1, 0], [1, 1]]
							lowercase        =							DummyModel(model=_lowerCAmelCase						)
							with tempfile.TemporaryDirectory() as tmp_dir:
													tf.saved_model.save(_lowerCAmelCase ,				_lowerCAmelCase ,				signatures={"""serving_default""": dummy_model.serving}						)
													lowercase        =							tf.saved_model.load(_lowerCAmelCase						).signatures["""serving_default"""]
													for batch_size in range(1 ,				len(_lowerCAmelCase						) + 1						):
																			lowercase        =							{
																			    """input_ids""": tf.constant(dummy_input_ids[:batch_size]						),
																			    """attention_mask""": tf.constant(dummy_attention_masks[:batch_size]						),
																			}
																			lowercase        =							serving_func(**_lowerCAmelCase						)["""sequences"""]
																			lowercase        =							test_model.generate(**_lowerCAmelCase ,				max_new_tokens=_lowerCAmelCase						)
																			tf.debugging.assert_equal(_lowerCAmelCase ,				_lowerCAmelCase						)







	@slow
	def   _a   (    self						)    ->    List[str]:
							'''simple docstring'''






							lowercase        =							TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""						)
							lowercase        =							1
							lowercase        =							2




							class      __UpperCamelCase       (tf.Module			):







								def __init__(    self ,				_lowerCAmelCase						)    ->    Optional[int]:
														'''simple docstring'''






														super(_lowerCAmelCase ,				self						).__init__()
														lowercase        =							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=_lowerCAmelCase ,				)
								def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    Tuple:
														'''simple docstring'''






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




							lowercase        =							[[2], [102, 103]]
							lowercase        =							[[1], [1, 1]]
							lowercase        =							DummyModel(model=_lowerCAmelCase						)
							with tempfile.TemporaryDirectory() as tmp_dir:
													tf.saved_model.save(_lowerCAmelCase ,				_lowerCAmelCase ,				signatures={"""serving_default""": dummy_model.serving}						)
													lowercase        =							tf.saved_model.load(_lowerCAmelCase						).signatures["""serving_default"""]
													for input_row in range(len(_lowerCAmelCase						)						):
																			lowercase        =							{
																			    """input_ids""": tf.constant([dummy_input_ids[input_row]]						),
																			    """attention_mask""": tf.constant([dummy_attention_masks[input_row]]						),
																			}
																			lowercase        =							serving_func(**_lowerCAmelCase						)["""sequences"""]
																			lowercase        =							test_model.generate(**_lowerCAmelCase ,				max_new_tokens=_lowerCAmelCase						)
																			tf.debugging.assert_equal(_lowerCAmelCase ,				_lowerCAmelCase						)







	@slow
	@require_tensorflow_text
	def   _a   (    self						)    ->    Union[str, Any]:
							'''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=_lowerCAmelCase						)




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







														def __init__(    self						)    ->    int:
																				'''simple docstring'''






																				super().__init__()
																				lowercase        =							text.SentencepieceTokenizer(
																				    model=tf.io.gfile.GFile(os.path.join(_lowerCAmelCase ,				"""spiece.model"""						) ,				"""rb"""						).read()						)
																				lowercase        =							TFAutoModelForSeqaSeqLM.from_pretrained("""hf-internal-testing/tiny-random-t5"""						)







														def   _a   (    self ,				_lowerCAmelCase ,				*_lowerCAmelCase ,				**_lowerCAmelCase						)    ->    List[Any]:
																				'''simple docstring'''






																				lowercase        =							self.tokenizer.tokenize(_lowerCAmelCase						)
																				lowercase     ,   lowercase        =							text.pad_model_inputs(
																				    _lowerCAmelCase ,				max_seq_length=64 ,				pad_value=self.model.config.pad_token_id						)
																				lowercase        =							self.model.generate(input_ids=_lowerCAmelCase ,				attention_mask=_lowerCAmelCase						)
																				return self.tokenizer.detokenize(_lowerCAmelCase						)




													lowercase        =							CompleteSentenceTransformer()
													lowercase        =							tf.keras.layers.Input(shape=(1,) ,				dtype=tf.string ,				name="""inputs"""						)
													lowercase        =							complete_model(_lowerCAmelCase						)
													lowercase        =							tf.keras.Model(_lowerCAmelCase ,				_lowerCAmelCase						)
													keras_model.save(_lowerCAmelCase						)







	def   _a   (    self						)    ->    List[str]:
							'''simple docstring'''






							lowercase        =							{
							    """do_sample""": True,
							    """num_beams""": 1,
							    """top_p""": 0.7,
							    """top_k""": 10,
							    """temperature""": 0.7,
							}
							lowercase        =							14

							lowercase        =							AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""						)
							lowercase        =							"""Hello, my dog is cute and"""
							lowercase        =							tokenizer(_lowerCAmelCase ,				return_tensors="""tf"""						)
							lowercase        =							TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""						)

							lowercase        =							638
							# forces the generation to happen on CPU, to avoid GPU-related quirks
							with tf.device(""":/CPU:0"""						):
													tf.random.set_seed(0						)
													lowercase        =							model.generate(**_lowerCAmelCase ,				eos_token_id=_lowerCAmelCase ,				**_lowerCAmelCase						)
							self.assertTrue(expectation == len(generated_tokens[0]						)						)

							lowercase        =							[638, 198]
							with tf.device(""":/CPU:0"""						):
													tf.random.set_seed(0						)
													lowercase        =							model.generate(**_lowerCAmelCase ,				eos_token_id=_lowerCAmelCase ,				**_lowerCAmelCase						)
							self.assertTrue(expectation == len(generated_tokens[0]						)						)







	def   _a   (    self						)    ->    Optional[int]:
							'''simple docstring'''






							lowercase        =							AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bart"""						)
							lowercase        =							"""Hugging Face is a technology company based in New York and Paris."""
							lowercase        =							bart_tokenizer(_lowerCAmelCase ,				return_tensors="""tf"""						).input_ids
							lowercase        =							TFBartForConditionalGeneration.from_pretrained("""hf-internal-testing/tiny-random-bart"""						)
							lowercase        =							bart_model.generate(_lowerCAmelCase						).numpy()




							class      __UpperCamelCase       (_UpperCAmelCase			):







								def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase=None ,				**_lowerCAmelCase						)    ->    Any:
														'''simple docstring'''






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




							lowercase        =							FakeBart.from_pretrained("""hf-internal-testing/tiny-random-bart"""						)
							lowercase        =							bart_model.generate(_lowerCAmelCase ,				foo="""bar"""						).numpy()
							self.assertTrue(np.array_equal(_lowerCAmelCase ,				_lowerCAmelCase						)						)




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







								def   _a   (    self ,				_lowerCAmelCase ,				**_lowerCAmelCase						)    ->    List[Any]:
														'''simple docstring'''






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




							lowercase        =							FakeEncoder(bart_model.config ,				bart_model.model.shared						)
							lowercase        =							fake_encoder

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







'''simple docstring'''


import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()




@skip_mps
class      __UpperCamelCase       (_UpperCAmelCase			,   _UpperCAmelCase			,   unittest.TestCase			):
	__A			  =					StableDiffusionPanoramaPipeline
	__A			  =					TEXT_TO_IMAGE_PARAMS
	__A			  =					TEXT_TO_IMAGE_BATCH_PARAMS
	__A			  =					TEXT_TO_IMAGE_IMAGE_PARAMS
	__A			  =					TEXT_TO_IMAGE_IMAGE_PARAMS







	def   _a   (    self						)    ->    Dict:
							'''simple docstring'''






							torch.manual_seed(0						)
							lowercase        =							UNetaDConditionModel(
							    block_out_channels=(32, 64) ,				layers_per_block=1 ,				sample_size=32 ,				in_channels=4 ,				out_channels=4 ,				down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") ,				up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") ,				cross_attention_dim=32 ,				)
							lowercase        =							DDIMScheduler()
							torch.manual_seed(0						)
							lowercase        =							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 ,				)
							torch.manual_seed(0						)
							lowercase        =							CLIPTextConfig(
							    bos_token_id=0 ,				eos_token_id=2 ,				hidden_size=32 ,				intermediate_size=37 ,				layer_norm_eps=1E-05 ,				num_attention_heads=4 ,				num_hidden_layers=5 ,				pad_token_id=1 ,				vocab_size=1000 ,				)
							lowercase        =							CLIPTextModel(_lowerCAmelCase						)
							lowercase        =							CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

							lowercase        =							{
							    """unet""": unet,
							    """scheduler""": scheduler,
							    """vae""": vae,
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """safety_checker""": None,
							    """feature_extractor""": None,
							}
							return components







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase=0						)    ->    Optional[int]:
							'''simple docstring'''






							lowercase        =							torch.manual_seed(_lowerCAmelCase						)
							lowercase        =							{
							    """prompt""": """a photo of the dolomites""",
							    """generator""": generator,
							    # Setting height and width to None to prevent OOMs on CPU.
							    """height""": None,
							    """width""": None,
							    """num_inference_steps""": 1,
							    """guidance_scale""": 6.0,
							    """output_type""": """numpy""",
							}
							return inputs







	def   _a   (    self						)    ->    int:
							'''simple docstring'''






							lowercase        =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowercase        =							self.get_dummy_components()
							lowercase        =							StableDiffusionPanoramaPipeline(**_lowerCAmelCase						)
							lowercase        =							sd_pipe.to(_lowerCAmelCase						)
							sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)

							lowercase        =							self.get_dummy_inputs(_lowerCAmelCase						)
							lowercase        =							sd_pipe(**_lowerCAmelCase						).images
							lowercase        =							image[0, -3:, -3:, -1]
							assert image.shape == (1, 64, 64, 3)

							lowercase        =							np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757]						)

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







	def   _a   (    self						)    ->    Union[str, Any]:
							'''simple docstring'''






							super().test_inference_batch_consistent(batch_sizes=[1, 2]						)







	def   _a   (    self						)    ->    str:
							'''simple docstring'''






							super().test_inference_batch_single_identical(batch_size=2 ,				expected_max_diff=3.25E-3						)







	def   _a   (    self						)    ->    List[Any]:
							'''simple docstring'''






							lowercase        =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowercase        =							self.get_dummy_components()
							lowercase        =							StableDiffusionPanoramaPipeline(**_lowerCAmelCase						)
							lowercase        =							sd_pipe.to(_lowerCAmelCase						)
							sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)

							lowercase        =							self.get_dummy_inputs(_lowerCAmelCase						)
							lowercase        =							"""french fries"""
							lowercase        =							sd_pipe(**_lowerCAmelCase ,				negative_prompt=_lowerCAmelCase						)
							lowercase        =							output.images
							lowercase        =							image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							lowercase        =							np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]						)

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







	def   _a   (    self						)    ->    Tuple:
							'''simple docstring'''






							lowercase        =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowercase        =							self.get_dummy_components()
							lowercase        =							StableDiffusionPanoramaPipeline(**_lowerCAmelCase						)
							lowercase        =							sd_pipe.to(_lowerCAmelCase						)
							sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)

							lowercase        =							self.get_dummy_inputs(_lowerCAmelCase						)
							lowercase        =							sd_pipe(**_lowerCAmelCase ,				view_batch_size=2						)
							lowercase        =							output.images
							lowercase        =							image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							lowercase        =							np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]						)

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







	def   _a   (    self						)    ->    Any:
							'''simple docstring'''






							lowercase        =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowercase        =							self.get_dummy_components()
							lowercase        =							EulerAncestralDiscreteScheduler(
							    beta_start=0.0_0085 ,				beta_end=0.012 ,				beta_schedule="""scaled_linear"""						)
							lowercase        =							StableDiffusionPanoramaPipeline(**_lowerCAmelCase						)
							lowercase        =							sd_pipe.to(_lowerCAmelCase						)
							sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)

							lowercase        =							self.get_dummy_inputs(_lowerCAmelCase						)
							lowercase        =							sd_pipe(**_lowerCAmelCase						).images
							lowercase        =							image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							lowercase        =							np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952]						)

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







	def   _a   (    self						)    ->    Dict:
							'''simple docstring'''






							lowercase        =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowercase        =							self.get_dummy_components()
							lowercase        =							PNDMScheduler(
							    beta_start=0.0_0085 ,				beta_end=0.012 ,				beta_schedule="""scaled_linear""" ,				skip_prk_steps=_lowerCAmelCase						)
							lowercase        =							StableDiffusionPanoramaPipeline(**_lowerCAmelCase						)
							lowercase        =							sd_pipe.to(_lowerCAmelCase						)
							sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase						)

							lowercase        =							self.get_dummy_inputs(_lowerCAmelCase						)
							lowercase        =							sd_pipe(**_lowerCAmelCase						).images
							lowercase        =							image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							lowercase        =							np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539]						)

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




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







	def   _a   (    self						)    ->    List[Any]:
							'''simple docstring'''






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







	def   _a   (    self ,				_lowerCAmelCase=0						)    ->    Optional[int]:
							'''simple docstring'''






							lowercase        =							torch.manual_seed(_lowerCAmelCase						)
							lowercase        =							{
							    """prompt""": """a photo of the dolomites""",
							    """generator""": generator,
							    """num_inference_steps""": 3,
							    """guidance_scale""": 7.5,
							    """output_type""": """numpy""",
							}
							return inputs







	def   _a   (    self						)    ->    Union[str, Any]:
							'''simple docstring'''






							lowercase        =							"""stabilityai/stable-diffusion-2-base"""
							lowercase        =							DDIMScheduler.from_pretrained(_lowerCAmelCase ,				subfolder="""scheduler"""						)
							lowercase        =							StableDiffusionPanoramaPipeline.from_pretrained(_lowerCAmelCase ,				scheduler=_lowerCAmelCase ,				safety_checker=_lowerCAmelCase						)
							pipe.to(_lowerCAmelCase						)
							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
							pipe.enable_attention_slicing()

							lowercase        =							self.get_inputs()
							lowercase        =							pipe(**_lowerCAmelCase						).images
							lowercase        =							image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 512, 2048, 3)

							lowercase        =							np.array(
							    [
							        0.3696_8392,
							        0.2702_5372,
							        0.3244_6766,
							        0.2837_9387,
							        0.3636_3274,
							        0.3073_3347,
							        0.2710_0027,
							        0.2705_4125,
							        0.2553_6096,
							    ]						)

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







	def   _a   (    self						)    ->    str:
							'''simple docstring'''






							lowercase        =							StableDiffusionPanoramaPipeline.from_pretrained(
							    """stabilityai/stable-diffusion-2-base""" ,				safety_checker=_lowerCAmelCase						)
							lowercase        =							LMSDiscreteScheduler.from_config(pipe.scheduler.config						)
							pipe.to(_lowerCAmelCase						)
							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
							pipe.enable_attention_slicing()

							lowercase        =							self.get_inputs()
							lowercase        =							pipe(**_lowerCAmelCase						).images
							lowercase        =							image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 512, 2048, 3)

							lowercase        =							np.array(
							    [
							        [
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							        ]
							    ]						)

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







	def   _a   (    self						)    ->    Any:
							'''simple docstring'''






							lowercase        =							0

							def callback_fn(_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						) -> None:
													lowercase        =							True
													nonlocal number_of_steps
													number_of_steps += 1
													if step == 1:
																			lowercase        =							latents.detach().cpu().numpy()
																			assert latents.shape == (1, 4, 64, 256)
																			lowercase        =							latents[0, -3:, -3:, -1]

																			lowercase        =							np.array(
																			    [
																			        0.1868_1869,
																			        0.3390_7816,
																			        0.536_1276,
																			        0.1443_2865,
																			        -0.0285_6611,
																			        -0.7394_1123,
																			        0.2339_7987,
																			        0.4732_2682,
																			        -0.3782_3164,
																			    ]						)
																			assert np.abs(latents_slice.flatten() - expected_slice						).max() < 5E-2
													elif step == 2:
																			lowercase        =							latents.detach().cpu().numpy()
																			assert latents.shape == (1, 4, 64, 256)
																			lowercase        =							latents[0, -3:, -3:, -1]

																			lowercase        =							np.array(
																			    [
																			        0.1853_9645,
																			        0.3398_7248,
																			        0.537_8559,
																			        0.1443_7142,
																			        -0.0245_5261,
																			        -0.733_8317,
																			        0.2399_0755,
																			        0.4735_6272,
																			        -0.378_6505,
																			    ]						)

																			assert np.abs(latents_slice.flatten() - expected_slice						).max() < 5E-2

							lowercase        =							False

							lowercase        =							"""stabilityai/stable-diffusion-2-base"""
							lowercase        =							DDIMScheduler.from_pretrained(_lowerCAmelCase ,				subfolder="""scheduler"""						)
							lowercase        =							StableDiffusionPanoramaPipeline.from_pretrained(_lowerCAmelCase ,				scheduler=_lowerCAmelCase ,				safety_checker=_lowerCAmelCase						)
							lowercase        =							pipe.to(_lowerCAmelCase						)
							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
							pipe.enable_attention_slicing()

							lowercase        =							self.get_inputs()
							pipe(**_lowerCAmelCase ,				callback=_lowerCAmelCase ,				callback_steps=1						)
							assert callback_fn.has_been_called
							assert number_of_steps == 3







	def   _a   (    self						)    ->    int:
							'''simple docstring'''






							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()
							torch.cuda.reset_peak_memory_stats()

							lowercase        =							"""stabilityai/stable-diffusion-2-base"""
							lowercase        =							DDIMScheduler.from_pretrained(_lowerCAmelCase ,				subfolder="""scheduler"""						)
							lowercase        =							StableDiffusionPanoramaPipeline.from_pretrained(_lowerCAmelCase ,				scheduler=_lowerCAmelCase ,				safety_checker=_lowerCAmelCase						)
							lowercase        =							pipe.to(_lowerCAmelCase						)
							pipe.set_progress_bar_config(disable=_lowerCAmelCase						)
							pipe.enable_attention_slicing(1						)
							pipe.enable_sequential_cpu_offload()

							lowercase        =							self.get_inputs()
							lowercase        =							pipe(**_lowerCAmelCase						)

							lowercase        =							torch.cuda.max_memory_allocated()
							# make sure that less than 5.2 GB is allocated
							assert mem_bytes < 5.5 * 10**9


