






import math
from collections import defaultdict
from typing import List, Optional, Tuple, Union

import numpy as np
import torch

from ..configuration_utils import ConfigMixin, register_to_config
from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput






def 							A     (       a_							,a_=0.999							,a_="cosine"							,)     ->						Optional[Any]:
					if alpha_transform_type == "cosine":

										def alpha_bar_fn(a_					):
															return math.cos((t + 0.008) / 1.008 * math.pi / 2					) ** 2

					elif alpha_transform_type == "exp":

										def alpha_bar_fn(a_					):
															return math.exp(t * -12.0					)

					else:
										raise ValueError(F'Unsupported alpha_tranform_type: {alpha_transform_type}'					)

					__UpperCamelCase      :					str       		=[]
					for i in range(a_					):
										__UpperCamelCase      :					Optional[int]       		=i / num_diffusion_timesteps
										__UpperCamelCase      :					Optional[Any]       		=(i + 1) / num_diffusion_timesteps
										betas.append(min(1 - alpha_bar_fn(a_					) / alpha_bar_fn(a_					)							,a_					)					)
					return torch.tensor(a_							,dtype=torch.floataa					)




class 				__A     (			a      ,     a ):





				"""simple docstring"""







				UpperCamelCase__ :      Tuple			 =[e.name for e in KarrasDiffusionSchedulers]
				UpperCamelCase__ :      Optional[Any]			 =2


				@register_to_config
				def __init__( self							,  lowerCamelCase__ = 1000							,  lowerCamelCase__ = 0.00_085							,  lowerCamelCase__ = 0.012							,  lowerCamelCase__ = "linear"							,  lowerCamelCase__ = None							,  lowerCamelCase__ = "epsilon"							,  lowerCamelCase__ = "linspace"							,  lowerCamelCase__ = 0							,  ):




									"""simple docstring"""

									if trained_betas is not None:
														__UpperCamelCase      :					Optional[int]       		=torch.tensor(lowerCamelCase__							,  dtype=torch.floataa    )
									elif beta_schedule == "linear":
														__UpperCamelCase      :					Tuple       		=torch.linspace(lowerCamelCase__							,  lowerCamelCase__							,  lowerCamelCase__							,  dtype=torch.floataa    )
									elif beta_schedule == "scaled_linear":
														# this schedule is very specific to the latent diffusion model.
														__UpperCamelCase      :					int       		=(
														    torch.linspace(beta_start**0.5							,  beta_end**0.5							,  lowerCamelCase__							,  dtype=torch.floataa    ) ** 2
														)
									elif beta_schedule == "squaredcos_cap_v2":
														# Glide cosine schedule
														__UpperCamelCase      :					Dict       		=betas_for_alpha_bar(lowerCamelCase__    )
									else:
														raise NotImplementedError(f'{beta_schedule} does is not implemented for {self.__class__}'    )

									__UpperCamelCase      :					Dict       		=1.0 - self.betas
									__UpperCamelCase      :					List[Any]       		=torch.cumprod(self.alphas							,  dim=0    )

									#  set all values
									self.set_timesteps(lowerCamelCase__							,  lowerCamelCase__							,  lowerCamelCase__    )


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__=None    ):




									"""simple docstring"""

									if schedule_timesteps is None:
														__UpperCamelCase      :					Dict       		=self.timesteps

									__UpperCamelCase      :					List[Any]       		=(schedule_timesteps == timestep).nonzero()

									# The sigma index that is taken for the **very** first `step`
									# is always the second index (or the last index if there is only 1)
									# This way we can ensure we don't accidentally skip a sigma in
									# case we start in the middle of the denoising schedule (e.g. for image-to-image)
									if len(self._index_counter    ) == 0:
														__UpperCamelCase      :					List[str]       		=1 if len(lowerCamelCase__    ) > 1 else 0
									else:
														__UpperCamelCase      :					int       		=timestep.cpu().item() if torch.is_tensor(lowerCamelCase__    ) else timestep
														__UpperCamelCase      :					Optional[Any]       		=self._index_counter[timestep_int]

									return indices[pos].item()


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									if self.config.timestep_spacing in ["linspace", "trailing"]:
														return self.sigmas.max()

									return (self.sigmas.max() ** 2 + 1) ** 0.5


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__							,  ):




									"""simple docstring"""

									__UpperCamelCase      :					Union[str, Any]       		=self.index_for_timestep(lowerCamelCase__    )

									if self.state_in_first_order:
														__UpperCamelCase      :					str       		=self.sigmas[step_index]
									else:
														__UpperCamelCase      :					Optional[int]       		=self.sigmas_interpol[step_index]

									__UpperCamelCase      :					Any       		=sample / ((sigma**2 + 1) ** 0.5)
									return sample


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__ = None							,  lowerCamelCase__ = None							,  ):




									"""simple docstring"""

									__UpperCamelCase      :					Dict       		=num_inference_steps

									__UpperCamelCase      :					Optional[int]       		=num_train_timesteps or self.config.num_train_timesteps

									# "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
									if self.config.timestep_spacing == "linspace":
														__UpperCamelCase      :					Optional[int]       		=np.linspace(0							,  num_train_timesteps - 1							,  lowerCamelCase__							,  dtype=lowerCamelCase__    )[::-1].copy()
									elif self.config.timestep_spacing == "leading":
														__UpperCamelCase      :					int       		=num_train_timesteps // self.num_inference_steps
														# creates integer timesteps by multiplying by ratio
														# casting to int to avoid issues when num_inference_step is power of 3
														__UpperCamelCase      :					List[Any]       		=(np.arange(0							,  lowerCamelCase__    ) * step_ratio).round()[::-1].copy().astype(lowerCamelCase__    )
														timesteps += self.config.steps_offset
									elif self.config.timestep_spacing == "trailing":
														__UpperCamelCase      :					List[str]       		=num_train_timesteps / self.num_inference_steps
														# creates integer timesteps by multiplying by ratio
														# casting to int to avoid issues when num_inference_step is power of 3
														__UpperCamelCase      :					Optional[int]       		=(np.arange(lowerCamelCase__							,  0							,  -step_ratio    )).round().copy().astype(lowerCamelCase__    )
														timesteps -= 1
									else:
														raise ValueError(
														    f'{self.config.timestep_spacing} is not supported. Please make sure to choose one of \'linspace\', \'leading\' or \'trailing\'.'    )

									__UpperCamelCase      :					Any       		=np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5    )
									__UpperCamelCase      :					Optional[Any]       		=torch.from_numpy(np.log(lowerCamelCase__    )    ).to(lowerCamelCase__    )

									__UpperCamelCase      :					Any       		=np.interp(lowerCamelCase__							,  np.arange(0							,  len(lowerCamelCase__    )    )							,  lowerCamelCase__    )
									__UpperCamelCase      :					List[Any]       		=np.concatenate([sigmas, [0.0]]    ).astype(np.floataa    )
									__UpperCamelCase      :					Dict       		=torch.from_numpy(lowerCamelCase__    ).to(device=lowerCamelCase__    )

									# interpolate sigmas
									__UpperCamelCase      :					Tuple       		=sigmas.log().lerp(sigmas.roll(1    ).log()							,  0.5    ).exp()

									__UpperCamelCase      :					int       		=torch.cat([sigmas[:1], sigmas[1:].repeat_interleave(2    ), sigmas[-1:]]    )
									__UpperCamelCase      :					Optional[Any]       		=torch.cat(
									    [sigmas_interpol[:1], sigmas_interpol[1:].repeat_interleave(2    ), sigmas_interpol[-1:]]    )

									if str(lowerCamelCase__    ).startswith('mps'    ):
														# mps does not support float64
														__UpperCamelCase      :					Tuple       		=torch.from_numpy(lowerCamelCase__    ).to(lowerCamelCase__							,  dtype=torch.floataa    )
									else:
														__UpperCamelCase      :					List[str]       		=torch.from_numpy(lowerCamelCase__    ).to(lowerCamelCase__    )

									# interpolate timesteps
									__UpperCamelCase      :					Union[str, Any]       		=self.sigma_to_t(lowerCamelCase__    ).to(lowerCamelCase__							,  dtype=timesteps.dtype    )
									__UpperCamelCase      :					List[Any]       		=torch.stack((timesteps_interpol[1:-1, None], timesteps[1:, None])							,  dim=-1    ).flatten()

									__UpperCamelCase      :					List[Any]       		=torch.cat([timesteps[:1], interleaved_timesteps]    )

									__UpperCamelCase      :					Optional[int]       		=None

									# for exp beta schedules, such as the one for `pipeline_shap_e.py`
									# we need an index counter
									__UpperCamelCase      :					List[Any]       		=defaultdict(lowerCamelCase__    )


				def       __lowercase							( self							,  lowerCamelCase__    ):




									"""simple docstring"""

									__UpperCamelCase      :					Dict       		=sigma.log()

									# get distribution
									__UpperCamelCase      :					Optional[int]       		=log_sigma - self.log_sigmas[:, None]

									# get sigmas range
									__UpperCamelCase      :					List[str]       		=dists.ge(0    ).cumsum(dim=0    ).argmax(dim=0    ).clamp(max=self.log_sigmas.shape[0] - 2    )
									__UpperCamelCase      :					List[Any]       		=low_idx + 1

									__UpperCamelCase      :					int       		=self.log_sigmas[low_idx]
									__UpperCamelCase      :					Tuple       		=self.log_sigmas[high_idx]

									# interpolate sigmas
									__UpperCamelCase      :					str       		=(low - log_sigma) / (low - high)
									__UpperCamelCase      :					List[Any]       		=w.clamp(0							,  1    )

									# transform interpolation to time range
									__UpperCamelCase      :					List[str]       		=(1 - w) * low_idx + w * high_idx
									__UpperCamelCase      :					Dict       		=t.view(sigma.shape    )
									return t


				@property
				def       __lowercase							( self    ):




									"""simple docstring"""

									return self.sample is None


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__							,  lowerCamelCase__							,  lowerCamelCase__ = True							,  ):




									"""simple docstring"""

									__UpperCamelCase      :					int       		=self.index_for_timestep(lowerCamelCase__    )

									# advance index counter by 1
									__UpperCamelCase      :					str       		=timestep.cpu().item() if torch.is_tensor(lowerCamelCase__    ) else timestep
									self._index_counter[timestep_int] += 1

									if self.state_in_first_order:
														__UpperCamelCase      :					List[str]       		=self.sigmas[step_index]
														__UpperCamelCase      :					str       		=self.sigmas_interpol[step_index + 1]
														__UpperCamelCase      :					Any       		=self.sigmas[step_index + 1]
									else:
														# 2nd order / KDPM2's method
														__UpperCamelCase      :					int       		=self.sigmas[step_index - 1]
														__UpperCamelCase      :					Tuple       		=self.sigmas_interpol[step_index]
														__UpperCamelCase      :					List[Any]       		=self.sigmas[step_index]

									# currently only gamma=0 is supported. This usually works best anyways.
									# We can support gamma in the future but then need to scale the timestep before
									# passing it to the model which requires a change in API
									__UpperCamelCase      :					Any       		=0
									__UpperCamelCase      :					Tuple       		=sigma * (gamma + 1)  # Note: sigma_hat == sigma for now

									# 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
									if self.config.prediction_type == "epsilon":
														__UpperCamelCase      :					List[str]       		=sigma_hat if self.state_in_first_order else sigma_interpol
														__UpperCamelCase      :					Union[str, Any]       		=sample - sigma_input * model_output
									elif self.config.prediction_type == "v_prediction":
														__UpperCamelCase      :					Any       		=sigma_hat if self.state_in_first_order else sigma_interpol
														__UpperCamelCase      :					Optional[int]       		=model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + (
														    sample / (sigma_input**2 + 1)
														)
									elif self.config.prediction_type == "sample":
														raise NotImplementedError('prediction_type not implemented yet: sample'    )
									else:
														raise ValueError(
														    f'prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`'    )

									if self.state_in_first_order:
														# 2. Convert to an ODE derivative for 1st order
														__UpperCamelCase      :					List[Any]       		=(sample - pred_original_sample) / sigma_hat
														# 3. delta timestep
														__UpperCamelCase      :					List[str]       		=sigma_interpol - sigma_hat

														# store for 2nd order step
														__UpperCamelCase      :					Tuple       		=sample
									else:
														# DPM-Solver-2
														# 2. Convert to an ODE derivative for 2nd order
														__UpperCamelCase      :					Optional[Any]       		=(sample - pred_original_sample) / sigma_interpol

														# 3. delta timestep
														__UpperCamelCase      :					Optional[Any]       		=sigma_next - sigma_hat

														__UpperCamelCase      :					List[Any]       		=self.sample
														__UpperCamelCase      :					int       		=None

									__UpperCamelCase      :					Union[str, Any]       		=sample + derivative * dt

									if not return_dict:
														return (prev_sample,)

									return SchedulerOutput(prev_sample=lowerCamelCase__    )


				def       __lowercase							( self							,  lowerCamelCase__							,  lowerCamelCase__							,  lowerCamelCase__							,  ):




									"""simple docstring"""

									__UpperCamelCase      :					int       		=self.sigmas.to(device=original_samples.device							,  dtype=original_samples.dtype    )
									if original_samples.device.type == "mps" and torch.is_floating_point(lowerCamelCase__    ):
														# mps does not support float64
														__UpperCamelCase      :					int       		=self.timesteps.to(original_samples.device							,  dtype=torch.floataa    )
														__UpperCamelCase      :					Union[str, Any]       		=timesteps.to(original_samples.device							,  dtype=torch.floataa    )
									else:
														__UpperCamelCase      :					Optional[Any]       		=self.timesteps.to(original_samples.device    )
														__UpperCamelCase      :					Tuple       		=timesteps.to(original_samples.device    )

									__UpperCamelCase      :					Any       		=[self.index_for_timestep(lowerCamelCase__							,  lowerCamelCase__    ) for t in timesteps]

									__UpperCamelCase      :					List[Any]       		=sigmas[step_indices].flatten()
									while len(sigma.shape    ) < len(original_samples.shape    ):
														__UpperCamelCase      :					int       		=sigma.unsqueeze(-1    )

									__UpperCamelCase      :					Dict       		=original_samples + noise * sigma
									return noisy_samples







				def __len__( self    ):




									"""simple docstring"""

									return self.config.num_train_timesteps






'''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 				SCREAMING_SNAKE_CASE(							A__							,		A__							,		A__							,		unittest.TestCase			):







	"""simple docstring"""






	lowerCamelCase__			 =       AltDiffusionPipeline
	lowerCamelCase__			 =       TEXT_TO_IMAGE_PARAMS
	lowerCamelCase__			 =       TEXT_TO_IMAGE_BATCH_PARAMS
	lowerCamelCase__			 =       TEXT_TO_IMAGE_IMAGE_PARAMS
	lowerCamelCase__			 =       TEXT_TO_IMAGE_IMAGE_PARAMS







	def      A	(						self			:     Dict		)			->		int:
								torch.manual_seed(0		)
								UpperCAmelCase :       str 							=		UNetaDConditionModel(
								    block_out_channels=(32, 64)		,			layers_per_block=2		,			sample_size=32		,			in_channels=4		,			out_channels=4		,			down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')		,			up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')		,			cross_attention_dim=32		,			)
								UpperCAmelCase :       Dict 							=		DDIMScheduler(
								    beta_start=0.0_00_85		,			beta_end=0.0_12		,			beta_schedule='''scaled_linear'''		,			clip_sample=__snake_case		,			set_alpha_to_one=__snake_case		,			)
								torch.manual_seed(0		)
								UpperCAmelCase :       Union[str, 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		,			)

								# 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 :       Dict 							=		CLIPTextConfig(
								    bos_token_id=0		,			eos_token_id=2		,			hidden_size=32		,			projection_dim=32		,			intermediate_size=37		,			layer_norm_eps=1E-05		,			num_attention_heads=4		,			num_hidden_layers=5		,			pad_token_id=1		,			vocab_size=5002		,			)
								UpperCAmelCase :       List[Any] 							=		CLIPTextModel(__snake_case		)

								UpperCAmelCase :       Optional[Any] 							=		XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''		)
								UpperCAmelCase :       Optional[int] 							=		77

								UpperCAmelCase :       Optional[int] 							=		{
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''vae''': vae,
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								    '''safety_checker''': None,
								    '''feature_extractor''': None,
								}
								return components







	def      A	(						self			:     Optional[Any]		,			__snake_case			:     Dict		,			__snake_case			:     List[str]=0		)			->		Union[str, Any]:
								if str(__snake_case		).startswith('''mps'''		):
															UpperCAmelCase :       str 							=		torch.manual_seed(__snake_case		)
								else:
															UpperCAmelCase :       Tuple 							=		torch.Generator(device=__snake_case		).manual_seed(__snake_case		)
								UpperCAmelCase :       Dict 							=		{
								    '''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      A	(						self			:     Union[str, Any]		)			->		List[str]:
								super().test_attention_slicing_forward_pass(expected_max_diff=3E-3		)







	def      A	(						self			:     Tuple		)			->		List[str]:
								super().test_inference_batch_single_identical(expected_max_diff=3E-3		)







	def      A	(						self			:     Tuple		)			->		Optional[int]:
								UpperCAmelCase :       List[str] 							=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator

								UpperCAmelCase :       Any 							=		self.get_dummy_components()
								torch.manual_seed(0		)
								UpperCAmelCase :       Optional[int] 							=		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		,			)
								# TODO: remove after fixing the non-deterministic text encoder
								UpperCAmelCase :       List[str] 							=		RobertaSeriesModelWithTransformation(__snake_case		)
								UpperCAmelCase :       str 							=		text_encoder

								UpperCAmelCase :       Optional[int] 							=		AltDiffusionPipeline(**__snake_case		)
								UpperCAmelCase :       str 							=		alt_pipe.to(__snake_case		)
								alt_pipe.set_progress_bar_config(disable=__snake_case		)

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

								assert image.shape == (1, 64, 64, 3)
								UpperCAmelCase :       List[str] 							=		np.array(
								    [0.5_74_81_62, 0.60_44_71_45, 0.48_82_12_17, 0.50_10_06_36, 0.5_43_11_85, 0.45_76_36_83, 0.49_65_76_96, 0.48_13_27_33, 0.47_57_30_93]		)

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







	def      A	(						self			:     int		)			->		Union[str, Any]:
								UpperCAmelCase :       Optional[int] 							=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator

								UpperCAmelCase :       int 							=		self.get_dummy_components()
								UpperCAmelCase :       int 							=		PNDMScheduler(skip_prk_steps=__snake_case		)
								torch.manual_seed(0		)
								UpperCAmelCase :       int 							=		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		,			)
								# TODO: remove after fixing the non-deterministic text encoder
								UpperCAmelCase :       Union[str, Any] 							=		RobertaSeriesModelWithTransformation(__snake_case		)
								UpperCAmelCase :       Union[str, Any] 							=		text_encoder
								UpperCAmelCase :       Optional[int] 							=		AltDiffusionPipeline(**__snake_case		)
								UpperCAmelCase :       Dict 							=		alt_pipe.to(__snake_case		)
								alt_pipe.set_progress_bar_config(disable=__snake_case		)

								UpperCAmelCase :       int 							=		self.get_dummy_inputs(__snake_case		)
								UpperCAmelCase :       Optional[int] 							=		alt_pipe(**__snake_case		)
								UpperCAmelCase :       Optional[int] 							=		output.images
								UpperCAmelCase :       int 							=		image[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)
								UpperCAmelCase :       Optional[int] 							=		np.array(
								    [0.51_60_50_93, 0.5_70_72_41, 0.47_36_55_07, 0.50_57_88_86, 0.5_63_38_77, 0.4_64_25_03, 0.5_18_20_81, 0.48_76_34_84, 0.49_08_42_37]		)

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

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







	"""simple docstring"""






	def      A	(						self			:     str		)			->		Any:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()







	def      A	(						self			:     List[Any]		)			->		Any:
								# make sure here that pndm scheduler skips prk
								UpperCAmelCase :       List[Any] 							=		AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''		,			safety_checker=__snake_case		)
								UpperCAmelCase :       Tuple 							=		alt_pipe.to(__snake_case		)
								alt_pipe.set_progress_bar_config(disable=__snake_case		)

								UpperCAmelCase :       List[Any] 							=		'''A painting of a squirrel eating a burger'''
								UpperCAmelCase :       Any 							=		torch.manual_seed(0		)
								UpperCAmelCase :       Optional[int] 							=		alt_pipe([prompt]		,			generator=__snake_case		,			guidance_scale=6.0		,			num_inference_steps=20		,			output_type='''np'''		)

								UpperCAmelCase :       Dict 							=		output.images

								UpperCAmelCase :       Optional[Any] 							=		image[0, -3:, -3:, -1]

								assert image.shape == (1, 512, 512, 3)
								UpperCAmelCase :       List[str] 							=		np.array([0.10_10, 0.08_00, 0.07_94, 0.08_85, 0.08_43, 0.07_62, 0.07_69, 0.07_29, 0.05_86]		)

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







	def      A	(						self			:     Tuple		)			->		int:
								UpperCAmelCase :       int 							=		DDIMScheduler.from_pretrained('''BAAI/AltDiffusion'''		,			subfolder='''scheduler'''		)

								UpperCAmelCase :       Tuple 							=		AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''		,			scheduler=__snake_case		,			safety_checker=__snake_case		)
								UpperCAmelCase :       Dict 							=		alt_pipe.to(__snake_case		)
								alt_pipe.set_progress_bar_config(disable=__snake_case		)

								UpperCAmelCase :       Tuple 							=		'''A painting of a squirrel eating a burger'''
								UpperCAmelCase :       Optional[int] 							=		torch.manual_seed(0		)

								UpperCAmelCase :       List[Any] 							=		alt_pipe([prompt]		,			generator=__snake_case		,			num_inference_steps=2		,			output_type='''numpy'''		)
								UpperCAmelCase :       Dict 							=		output.images

								UpperCAmelCase :       Optional[Any] 							=		image[0, -3:, -3:, -1]

								assert image.shape == (1, 512, 512, 3)
								UpperCAmelCase :       Union[str, Any] 							=		np.array([0.40_19, 0.40_52, 0.38_10, 0.41_19, 0.39_16, 0.39_82, 0.46_51, 0.41_95, 0.53_23]		)

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





