



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 	lowerCamelCase      (						lowercase__,     lowercase__,     lowercase__,     unittest.TestCase  ):







					'''simple docstring'''







					lowerCAmelCase_				:    Optional[int]									=  AltDiffusionPipeline
					lowerCAmelCase_				:    Optional[int]									=  TEXT_TO_IMAGE_PARAMS
					lowerCAmelCase_				:    Tuple									=  TEXT_TO_IMAGE_BATCH_PARAMS
					lowerCAmelCase_				:    Dict									=  TEXT_TO_IMAGE_IMAGE_PARAMS
					lowerCAmelCase_				:    Dict									=  TEXT_TO_IMAGE_IMAGE_PARAMS



					def    A__		(			self     ):
							torch.manual_seed(0     )
							UpperCAmelCase_						=				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_						=				DDIMScheduler(
							    beta_start=0.00085    ,	beta_end=0.012    ,	beta_schedule="scaled_linear"    ,	clip_sample=lowerCAmelCase    ,	set_alpha_to_one=lowerCAmelCase    ,	)
							torch.manual_seed(0     )
							UpperCAmelCase_						=				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_						=				CLIPTextConfig(
							    bos_token_id=0    ,	eos_token_id=2    ,	hidden_size=32    ,	projection_dim=32    ,	intermediate_size=37    ,	layer_norm_eps=1e-0_5    ,	num_attention_heads=4    ,	num_hidden_layers=5    ,	pad_token_id=1    ,	vocab_size=5002    ,	)
							UpperCAmelCase_						=				CLIPTextModel(lowerCAmelCase     )

							UpperCAmelCase_						=				XLMRobertaTokenizer.from_pretrained("hf-internal-testing/tiny-xlm-roberta"     )
							UpperCAmelCase_						=				77

							UpperCAmelCase_						=				{
							    "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     ):
							if str(lowerCAmelCase     ).startswith("mps"     ):
									UpperCAmelCase_						=				torch.manual_seed(lowerCAmelCase     )
							else:
									UpperCAmelCase_						=				torch.Generator(device=lowerCAmelCase     ).manual_seed(lowerCAmelCase     )
							UpperCAmelCase_						=				{
							    "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     ):
							super().test_attention_slicing_forward_pass(expected_max_diff=3e-3     )



					def    A__		(			self     ):
							super().test_inference_batch_single_identical(expected_max_diff=3e-3     )



					def    A__		(			self     ):
							UpperCAmelCase_						=				"cpu"  # ensure determinism for the device-dependent torch.Generator

							UpperCAmelCase_						=				self.get_dummy_components()
							torch.manual_seed(0     )
							UpperCAmelCase_						=				RobertaSeriesConfig(
							    hidden_size=32    ,	project_dim=32    ,	intermediate_size=37    ,	layer_norm_eps=1e-0_5    ,	num_attention_heads=4    ,	num_hidden_layers=5    ,	vocab_size=5002    ,	)
							# TODO: remove after fixing the non-deterministic text encoder
							UpperCAmelCase_						=				RobertaSeriesModelWithTransformation(lowerCAmelCase     )
							UpperCAmelCase_						=				text_encoder

							UpperCAmelCase_						=				AltDiffusionPipeline(**lowerCAmelCase     )
							UpperCAmelCase_						=				alt_pipe.to(lowerCAmelCase     )
							alt_pipe.set_progress_bar_config(disable=lowerCAmelCase     )

							UpperCAmelCase_						=				self.get_dummy_inputs(lowerCAmelCase     )
							UpperCAmelCase_						=				"A photo of an astronaut"
							UpperCAmelCase_						=				alt_pipe(**lowerCAmelCase     )
							UpperCAmelCase_						=				output.images
							UpperCAmelCase_						=				image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							UpperCAmelCase_						=				np.array(
							    [0.5748162, 0.60447145, 0.48821217, 0.50100636, 0.5431185, 0.45763683, 0.49657696, 0.48132733, 0.47573093]     )

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



					def    A__		(			self     ):
							UpperCAmelCase_						=				"cpu"  # ensure determinism for the device-dependent torch.Generator

							UpperCAmelCase_						=				self.get_dummy_components()
							UpperCAmelCase_						=				PNDMScheduler(skip_prk_steps=lowerCAmelCase     )
							torch.manual_seed(0     )
							UpperCAmelCase_						=				RobertaSeriesConfig(
							    hidden_size=32    ,	project_dim=32    ,	intermediate_size=37    ,	layer_norm_eps=1e-0_5    ,	num_attention_heads=4    ,	num_hidden_layers=5    ,	vocab_size=5002    ,	)
							# TODO: remove after fixing the non-deterministic text encoder
							UpperCAmelCase_						=				RobertaSeriesModelWithTransformation(lowerCAmelCase     )
							UpperCAmelCase_						=				text_encoder
							UpperCAmelCase_						=				AltDiffusionPipeline(**lowerCAmelCase     )
							UpperCAmelCase_						=				alt_pipe.to(lowerCAmelCase     )
							alt_pipe.set_progress_bar_config(disable=lowerCAmelCase     )

							UpperCAmelCase_						=				self.get_dummy_inputs(lowerCAmelCase     )
							UpperCAmelCase_						=				alt_pipe(**lowerCAmelCase     )
							UpperCAmelCase_						=				output.images
							UpperCAmelCase_						=				image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							UpperCAmelCase_						=				np.array(
							    [0.51605093, 0.5707241, 0.47365507, 0.50578886, 0.5633877, 0.4642503, 0.5182081, 0.48763484, 0.49084237]     )

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





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







					'''simple docstring'''







					def    A__		(			self     ):
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



					def    A__		(			self     ):
							# make sure here that pndm scheduler skips prk
							UpperCAmelCase_						=				AltDiffusionPipeline.from_pretrained("BAAI/AltDiffusion"    ,	safety_checker=lowerCAmelCase     )
							UpperCAmelCase_						=				alt_pipe.to(lowerCAmelCase     )
							alt_pipe.set_progress_bar_config(disable=lowerCAmelCase     )

							UpperCAmelCase_						=				"A painting of a squirrel eating a burger"
							UpperCAmelCase_						=				torch.manual_seed(0     )
							UpperCAmelCase_						=				alt_pipe([prompt]    ,	generator=lowerCAmelCase    ,	guidance_scale=6.0    ,	num_inference_steps=20    ,	output_type="np"     )

							UpperCAmelCase_						=				output.images

							UpperCAmelCase_						=				image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							UpperCAmelCase_						=				np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586]     )

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



					def    A__		(			self     ):
							UpperCAmelCase_						=				DDIMScheduler.from_pretrained("BAAI/AltDiffusion"    ,	subfolder="scheduler"     )

							UpperCAmelCase_						=				AltDiffusionPipeline.from_pretrained("BAAI/AltDiffusion"    ,	scheduler=lowerCAmelCase    ,	safety_checker=lowerCAmelCase     )
							UpperCAmelCase_						=				alt_pipe.to(lowerCAmelCase     )
							alt_pipe.set_progress_bar_config(disable=lowerCAmelCase     )

							UpperCAmelCase_						=				"A painting of a squirrel eating a burger"
							UpperCAmelCase_						=				torch.manual_seed(0     )

							UpperCAmelCase_						=				alt_pipe([prompt]    ,	generator=lowerCAmelCase    ,	num_inference_steps=2    ,	output_type="numpy"     )
							UpperCAmelCase_						=				output.images

							UpperCAmelCase_						=				image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							UpperCAmelCase_						=				np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323]     )

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






def snake_case__  (			__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )		->							Union[str, Any]:
		UpperCAmelCase_						=				0
		while b > 0:
				if b & 1:
						res += a

				a += a
				b >>= 1

		return res







def snake_case__  (			__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )		->							Tuple:
		UpperCAmelCase_						=				0
		while b > 0:
				if b & 1:
						UpperCAmelCase_						=				((res % c) + (a % c)) % c

				a += a
				b >>= 1

		return res

