




'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import XGLMConfig, XGLMTokenizer, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
						import tensorflow as tf

						from transformers.models.xglm.modeling_tf_xglm import (
						    TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFXGLMForCausalLM,
						    TFXGLMModel,
						)



@require_tf
class 		SCREAMING_SNAKE_CASE__  :
			__SCREAMING_SNAKE_CASE    =			XGLMConfig
			__SCREAMING_SNAKE_CASE    =			{}
			__SCREAMING_SNAKE_CASE    =			"""gelu"""





			def __init__(      self						:    int      ,		a_						:    List[Any]      ,		a_						:    Dict=14      ,		a_						:    int=7      ,		a_						:    List[Any]=True      ,		a_						:    Optional[int]=True      ,		a_						:    Optional[int]=True      ,		a_						:    int=99      ,		a_						:    Optional[int]=32      ,		a_						:    Tuple=2      ,		a_						:    Any=4      ,		a_						:    Union[str, Any]=37      ,		a_						:    Any="gelu"      ,		a_						:    str=0.1      ,		a_						:    Any=0.1      ,		a_						:    str=512      ,		a_						:    List[Any]=0.02      ,		):



						"""simple docstring"""




						__snake_case			=		parent
						__snake_case			=		batch_size
						__snake_case			=		seq_length
						__snake_case			=		is_training
						__snake_case			=		use_input_mask
						__snake_case			=		use_labels
						__snake_case			=		vocab_size
						__snake_case			=		d_model
						__snake_case			=		num_hidden_layers
						__snake_case			=		num_attention_heads
						__snake_case			=		ffn_dim
						__snake_case			=		activation_function
						__snake_case			=		activation_dropout
						__snake_case			=		attention_dropout
						__snake_case			=		max_position_embeddings
						__snake_case			=		initializer_range
						__snake_case			=		None
						__snake_case			=		0
						__snake_case			=		2
						__snake_case			=		1





			def 							A (      self						:    Union[str, Any]							):



						"""simple docstring"""




						return XGLMConfig.from_pretrained("facebook/xglm-564M"							)





			def 							A (      self						:    Optional[Any]							):



						"""simple docstring"""




						__snake_case			=		tf.clip_by_value(
						    ids_tensor([self.batch_size, self.seq_length]      ,		self.vocab_size							)      ,		clip_value_min=0      ,		clip_value_max=3							)

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

						__snake_case			=		self.get_config()

						__snake_case			=		floats_tensor([self.num_hidden_layers, self.num_attention_heads]      ,		2							)

						return (
						    config,
						    input_ids,
						    input_mask,
						    head_mask,
						)





			def 							A (      self						:    str							):



						"""simple docstring"""




						return XGLMConfig(
						    vocab_size=self.vocab_size      ,		d_model=self.hidden_size      ,		num_layers=self.num_hidden_layers      ,		attention_heads=self.num_attention_heads      ,		ffn_dim=self.ffn_dim      ,		activation_function=self.activation_function      ,		activation_dropout=self.activation_dropout      ,		attention_dropout=self.attention_dropout      ,		max_position_embeddings=self.max_position_embeddings      ,		initializer_range=self.initializer_range      ,		use_cache=a_      ,		bos_token_id=self.bos_token_id      ,		eos_token_id=self.eos_token_id      ,		pad_token_id=self.pad_token_id      ,		return_dict=a_      ,		)






			def 							A (      self						:    List[str]							):



						"""simple docstring"""




						__snake_case			=		self.prepare_config_and_inputs()

						(
						    (
						    __snake_case
						)		,     (
						    __snake_case
						)		,     (
						    __snake_case
						)		,     (
						    __snake_case
						)		,     
						)			=		config_and_inputs

						__snake_case			=		{
						    "input_ids": input_ids,
						    "head_mask": head_mask,
						}

						return config, inputs_dict







@require_tf
class 		SCREAMING_SNAKE_CASE__  (			_UpperCamelCase				,     _UpperCamelCase				,     unittest.TestCase	):
			__SCREAMING_SNAKE_CASE    =			(TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else ()
			__SCREAMING_SNAKE_CASE    =			(TFXGLMForCausalLM,) if is_tf_available() else ()
			__SCREAMING_SNAKE_CASE    =			(
			    {"""feature-extraction""": TFXGLMModel, """text-generation""": TFXGLMForCausalLM} if is_tf_available() else {}
			)
			__SCREAMING_SNAKE_CASE    =			False
			__SCREAMING_SNAKE_CASE    =			False
			__SCREAMING_SNAKE_CASE    =			False





			def 							A (      self						:    Optional[int]							):



						"""simple docstring"""




						__snake_case			=		TFXGLMModelTester(self							)
						__snake_case			=		ConfigTester(self      ,		config_class=a_      ,		n_embd=37							)





			def 							A (      self						:    str							):



						"""simple docstring"""




						self.config_tester.run_common_tests()





			@slow
			def 							A (      self						:    Tuple							):



						"""simple docstring"""




						for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__snake_case			=		TFXGLMModel.from_pretrained(a_							)
									self.assertIsNotNone(a_							)






			@unittest.skip(reason="Currently, model embeddings are going to undergo a major refactor."							)
			def 							A (      self						:    Dict							):



						"""simple docstring"""




						super().test_resize_token_embeddings()







@require_tf
class 		SCREAMING_SNAKE_CASE__  (			unittest.TestCase	):





			@slow
			def 							A (      self						:    List[Any]      ,		a_						:    Dict=True							):



						"""simple docstring"""




						__snake_case			=		TFXGLMForCausalLM.from_pretrained("facebook/xglm-564M"							)
						__snake_case			=		tf.convert_to_tensor([[2, 268, 9_865]]      ,		dtype=tf.intaa							)  # The dog
						# </s> The dog is a very friendly dog. He is very affectionate and loves to play with other
						# fmt: off
						__snake_case			=		[2, 268, 9_865, 67, 11, 1_988, 57_252, 9_865, 5, 984, 67, 1_988, 213_838, 1_658, 53, 70_446, 33, 6_657, 278, 1_581]
						# fmt: on
						__snake_case			=		model.generate(a_      ,		do_sample=a_      ,		num_beams=1							)
						if verify_outputs:
									self.assertListEqual(output_ids[0].numpy().tolist()      ,		a_							)





			@slow
			def 							A (      self						:    Any							):



						"""simple docstring"""




						__snake_case			=		XGLMTokenizer.from_pretrained("facebook/xglm-564M"							)
						__snake_case			=		TFXGLMForCausalLM.from_pretrained("facebook/xglm-564M"							)

						tf.random.set_seed(0							)
						__snake_case			=		tokenizer("Today is a nice day and"      ,		return_tensors="tf"							)
						__snake_case			=		tokenized.input_ids
						# forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices)
						with tf.device(":/CPU:0"							):
									__snake_case			=		model.generate(a_      ,		do_sample=a_      ,		seed=[7, 0]							)
						__snake_case			=		tokenizer.decode(output_ids[0]      ,		skip_special_tokens=a_							)

						__snake_case			=		(
						    "Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due"
						)
						self.assertEqual(a_      ,		a_							)






			@slow
			def 							A (      self						:    List[str]							):



						"""simple docstring"""




						__snake_case			=		TFXGLMForCausalLM.from_pretrained("facebook/xglm-564M"							)
						__snake_case			=		XGLMTokenizer.from_pretrained("facebook/xglm-564M"							)

						__snake_case			=		"left"

						# use different length sentences to test batching
						__snake_case			=		[
						    "This is an extremelly long sentence that only exists to test the ability of the model to cope with "
						    "left-padding, such as in batched generation. The output for the sequence below should be the same "
						    "regardless of whether left padding is applied or not. When",
						    "Hello, my dog is a little",
						]

						__snake_case			=		tokenizer(a_      ,		return_tensors="tf"      ,		padding=a_							)
						__snake_case			=		inputs["input_ids"]

						__snake_case			=		model.generate(input_ids=a_      ,		attention_mask=inputs["attention_mask"]      ,		max_new_tokens=12							)

						__snake_case			=		tokenizer(sentences[0]      ,		return_tensors="tf"							).input_ids
						__snake_case			=		model.generate(input_ids=a_      ,		max_new_tokens=12							)

						__snake_case			=		tokenizer(sentences[1]      ,		return_tensors="tf"							).input_ids
						__snake_case			=		model.generate(input_ids=a_      ,		max_new_tokens=12							)

						__snake_case			=		tokenizer.batch_decode(a_      ,		skip_special_tokens=a_							)
						__snake_case			=		tokenizer.decode(output_non_padded[0]      ,		skip_special_tokens=a_							)
						__snake_case			=		tokenizer.decode(output_padded[0]      ,		skip_special_tokens=a_							)

						__snake_case			=		[
						    "This is an extremelly long sentence that only exists to test the ability of the model to cope with "
						    "left-padding, such as in batched generation. The output for the sequence below should be the same "
						    "regardless of whether left padding is applied or not. When left padding is applied, the sequence will be "
						    "a single",
						    "Hello, my dog is a little bit of a shy one, but he is very friendly",
						]
						self.assertListEqual(a_      ,		a_							)
						self.assertListEqual(a_      ,		[non_padded_sentence, padded_sentence]							)










"""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       _a  ( SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__     ,	unittest.TestCase):
			__magic_name__     					=     StableDiffusionPanoramaPipeline
			__magic_name__     					=     TEXT_TO_IMAGE_PARAMS
			__magic_name__     					=     TEXT_TO_IMAGE_BATCH_PARAMS
			__magic_name__     					=     TEXT_TO_IMAGE_IMAGE_PARAMS
			__magic_name__     					=     TEXT_TO_IMAGE_IMAGE_PARAMS



			def 				__lowercase					(			self							:				Optional[int]		)							->					int:
									torch.manual_seed(0		)
									snake_case   :			Optional[Any]						    = 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   ,	)
									snake_case   :			Tuple						    = DDIMScheduler()
									torch.manual_seed(0		)
									snake_case   :			List[Any]						    = 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		)
									snake_case   :			str						    = 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   ,	)
									snake_case   :			int						    = CLIPTextModel(_lowercase		)
									snake_case   :			Union[str, Any]						    = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

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



			def 				__lowercase					(			self							:				List[str]   ,	_lowercase							:				int   ,	_lowercase							:				Dict=0		)							->					Optional[int]:
									snake_case   :			Union[str, Any]						    = torch.manual_seed(_lowercase		)
									snake_case   :			str						    = {
									    "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 				__lowercase					(			self							:				str		)							->					List[str]:
									snake_case   :			Any						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			Dict						    = self.get_dummy_components()
									snake_case   :			Any						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			List[Any]						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			Optional[Any]						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			Union[str, Any]						    = sd_pipe(**_lowercase		).images
									snake_case   :			List[Any]						    = image[0, -3:, -3:, -1]
									assert image.shape == (1, 64, 64, 3)

									snake_case   :			List[Any]						    = 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 				__lowercase					(			self							:				int		)							->					Union[str, Any]:
									super().test_inference_batch_consistent(batch_sizes=[1, 2]		)



			def 				__lowercase					(			self							:				Tuple		)							->					Tuple:
									super().test_inference_batch_single_identical(batch_size=2   ,	expected_max_diff=3.25E-3		)



			def 				__lowercase					(			self							:				Any		)							->					List[Any]:
									snake_case   :			Any						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			Union[str, Any]						    = self.get_dummy_components()
									snake_case   :			Tuple						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			Tuple						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			List[str]						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			int						    = "french fries"
									snake_case   :			Union[str, Any]						    = sd_pipe(**_lowercase   ,	negative_prompt=_lowercase		)
									snake_case   :			str						    = output.images
									snake_case   :			Optional[Any]						    = image[0, -3:, -3:, -1]

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

									snake_case   :			Union[str, Any]						    = 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 				__lowercase					(			self							:				str		)							->					Any:
									snake_case   :			Optional[Any]						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			List[Any]						    = self.get_dummy_components()
									snake_case   :			List[Any]						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			int						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			Tuple						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			str						    = sd_pipe(**_lowercase   ,	view_batch_size=2		)
									snake_case   :			Optional[Any]						    = output.images
									snake_case   :			int						    = image[0, -3:, -3:, -1]

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

									snake_case   :			str						    = 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 				__lowercase					(			self							:				int		)							->					Optional[Any]:
									snake_case   :			Dict						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			List[str]						    = self.get_dummy_components()
									snake_case   :			Any						    = EulerAncestralDiscreteScheduler(
									    beta_start=0.00085   ,	beta_end=0.012   ,	beta_schedule="scaled_linear"		)
									snake_case   :			List[str]						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			List[str]						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			List[Any]						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			Optional[Any]						    = sd_pipe(**_lowercase		).images
									snake_case   :			int						    = image[0, -3:, -3:, -1]

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

									snake_case   :			Tuple						    = 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 				__lowercase					(			self							:				Tuple		)							->					Union[str, Any]:
									snake_case   :			str						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			str						    = self.get_dummy_components()
									snake_case   :			Optional[int]						    = PNDMScheduler(
									    beta_start=0.00085   ,	beta_end=0.012   ,	beta_schedule="scaled_linear"   ,	skip_prk_steps=_lowercase		)
									snake_case   :			Dict						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			Dict						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			Dict						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			Optional[int]						    = sd_pipe(**_lowercase		).images
									snake_case   :			str						    = image[0, -3:, -3:, -1]

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

									snake_case   :			Optional[int]						    = 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       _a  ( unittest.TestCase):



			def 				__lowercase					(			self							:				Union[str, Any]		)							->					str:
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()



			def 				__lowercase					(			self							:				Dict   ,	_lowercase							:				Any=0		)							->					Optional[Any]:
									snake_case   :			Any						    = torch.manual_seed(_lowercase		)
									snake_case   :			Any						    = {
									    "prompt": "a photo of the dolomites",
									    "generator": generator,
									    "num_inference_steps": 3,
									    "guidance_scale": 7.5,
									    "output_type": "numpy",
									}
									return inputs



			def 				__lowercase					(			self							:				Optional[Any]		)							->					Union[str, Any]:
									snake_case   :			List[Any]						    = "stabilityai/stable-diffusion-2-base"
									snake_case   :			Dict						    = DDIMScheduler.from_pretrained(_lowercase   ,	subfolder="scheduler"		)
									snake_case   :			Any						    = StableDiffusionPanoramaPipeline.from_pretrained(_lowercase   ,	scheduler=_lowercase   ,	safety_checker=_lowercase		)
									pipe.to(_lowercase		)
									pipe.set_progress_bar_config(disable=_lowercase		)
									pipe.enable_attention_slicing()

									snake_case   :			str						    = self.get_inputs()
									snake_case   :			List[Any]						    = pipe(**_lowercase		).images
									snake_case   :			Optional[int]						    = image[0, -3:, -3:, -1].flatten()

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

									snake_case   :			List[str]						    = np.array(
									    [
									        0.36968392,
									        0.27025372,
									        0.32446766,
									        0.28379387,
									        0.36363274,
									        0.30733347,
									        0.27100027,
									        0.27054125,
									        0.25536096,
									    ]		)

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



			def 				__lowercase					(			self							:				Tuple		)							->					List[str]:
									snake_case   :			List[str]						    = StableDiffusionPanoramaPipeline.from_pretrained(
									    "stabilityai/stable-diffusion-2-base"   ,	safety_checker=_lowercase		)
									snake_case   :			int						    = LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
									pipe.to(_lowercase		)
									pipe.set_progress_bar_config(disable=_lowercase		)
									pipe.enable_attention_slicing()

									snake_case   :			Dict						    = self.get_inputs()
									snake_case   :			int						    = pipe(**_lowercase		).images
									snake_case   :			Optional[Any]						    = image[0, -3:, -3:, -1].flatten()

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

									snake_case   :			List[str]						    = 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 				__lowercase					(			self							:				str		)							->					Any:
									snake_case   :			Any						    = 0

									def callback_fn(_lowercase							:				int   ,	_lowercase							:				int   ,	_lowercase							:				torch.FloatTensor		) -> None:
															snake_case   :			List[Any]						    = True
															nonlocal number_of_steps
															number_of_steps += 1
															if step == 1:
																					snake_case   :			List[Any]						    = latents.detach().cpu().numpy()
																					assert latents.shape == (1, 4, 64, 256)
																					snake_case   :			int						    = latents[0, -3:, -3:, -1]

																					snake_case   :			Tuple						    = np.array(
																					    [
																					        0.18681869,
																					        0.33907816,
																					        0.5361276,
																					        0.14432865,
																					        -0.02856611,
																					        -0.73941123,
																					        0.23397987,
																					        0.47322682,
																					        -0.37823164,
																					    ]		)
																					assert np.abs(latents_slice.flatten() - expected_slice		).max() < 5E-2
															elif step == 2:
																					snake_case   :			Union[str, Any]						    = latents.detach().cpu().numpy()
																					assert latents.shape == (1, 4, 64, 256)
																					snake_case   :			Tuple						    = latents[0, -3:, -3:, -1]

																					snake_case   :			Tuple						    = np.array(
																					    [
																					        0.18539645,
																					        0.33987248,
																					        0.5378559,
																					        0.14437142,
																					        -0.02455261,
																					        -0.7338317,
																					        0.23990755,
																					        0.47356272,
																					        -0.3786505,
																					    ]		)

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

									snake_case   :			Dict						    = False

									snake_case   :			List[Any]						    = "stabilityai/stable-diffusion-2-base"
									snake_case   :			List[str]						    = DDIMScheduler.from_pretrained(_lowercase   ,	subfolder="scheduler"		)
									snake_case   :			Optional[Any]						    = StableDiffusionPanoramaPipeline.from_pretrained(_lowercase   ,	scheduler=_lowercase   ,	safety_checker=_lowercase		)
									snake_case   :			Any						    = pipe.to(_lowercase		)
									pipe.set_progress_bar_config(disable=_lowercase		)
									pipe.enable_attention_slicing()

									snake_case   :			Tuple						    = self.get_inputs()
									pipe(**_lowercase   ,	callback=_lowercase   ,	callback_steps=1		)
									assert callback_fn.has_been_called
									assert number_of_steps == 3



			def 				__lowercase					(			self							:				Any		)							->					Tuple:
									torch.cuda.empty_cache()
									torch.cuda.reset_max_memory_allocated()
									torch.cuda.reset_peak_memory_stats()

									snake_case   :			Optional[int]						    = "stabilityai/stable-diffusion-2-base"
									snake_case   :			Tuple						    = DDIMScheduler.from_pretrained(_lowercase   ,	subfolder="scheduler"		)
									snake_case   :			Any						    = StableDiffusionPanoramaPipeline.from_pretrained(_lowercase   ,	scheduler=_lowercase   ,	safety_checker=_lowercase		)
									snake_case   :			Tuple						    = pipe.to(_lowercase		)
									pipe.set_progress_bar_config(disable=_lowercase		)
									pipe.enable_attention_slicing(1		)
									pipe.enable_sequential_cpu_offload()

									snake_case   :			Any						    = self.get_inputs()
									snake_case   :			Optional[int]						    = pipe(**_lowercase		)

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



