


'''simple docstring'''






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import 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


__UpperCAmelCase       =							False




@skip_mps
class 		a__    (							a__    ,    a__    ,    a__    ,    unittest.TestCase  ):





							'''simple docstring'''






							lowercase__      :       List[Any]     						=				StableDiffusionAttendAndExcitePipeline
							lowercase__      :       Optional[int]     						=				False
							lowercase__      :       Dict     						=				TEXT_TO_IMAGE_PARAMS
							lowercase__      :       Optional[Any]     						=				TEXT_TO_IMAGE_BATCH_PARAMS.union({"token_indices"}  )
							lowercase__      :       Any     						=				TEXT_TO_IMAGE_IMAGE_PARAMS
							lowercase__      :       Union[str, Any]     						=				TEXT_TO_IMAGE_IMAGE_PARAMS







							@classmethod
							def   __SCREAMING_SNAKE_CASE							(		cls       )	->							Dict:
														super().setUpClass()
														torch.use_deterministic_algorithms(lowerCamelCase_       )







							@classmethod
							def   __SCREAMING_SNAKE_CASE							(		cls       )	->							Optional[Any]:
														super().tearDownClass()
														torch.use_deterministic_algorithms(lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Tuple:
														torch.manual_seed(0       )
														lowerCAmelCase__	       =     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 ,   attention_head_dim=(2, 4) ,   use_linear_projection=lowerCamelCase_ ,   )
														lowerCAmelCase__	       =     DDIMScheduler(
														    beta_start=0.00_085 ,   beta_end=0.012 ,   beta_schedule='''scaled_linear''' ,   clip_sample=lowerCamelCase_ ,   set_alpha_to_one=lowerCamelCase_ ,   )
														torch.manual_seed(0       )
														lowerCAmelCase__	       =     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 ,   sample_size=1_28 ,   )
														torch.manual_seed(0       )
														lowerCAmelCase__	       =     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=10_00 ,   hidden_act='''gelu''' ,   projection_dim=5_12 ,   )
														lowerCAmelCase__	       =     CLIPTextModel(lowerCamelCase_       )
														lowerCAmelCase__	       =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )

														lowerCAmelCase__	       =     {
														    '''unet''': unet,
														    '''scheduler''': scheduler,
														    '''vae''': vae,
														    '''text_encoder''': text_encoder,
														    '''tokenizer''': tokenizer,
														    '''safety_checker''': None,
														    '''feature_extractor''': None,
														}

														return components







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_=0       )	->							List[Any]:
														if str(lowerCamelCase_       ).startswith('''mps'''       ):
																					lowerCAmelCase__	       =     torch.manual_seed(lowerCamelCase_       )
														else:
																					lowerCAmelCase__	       =     torch.Generator(device=lowerCamelCase_       ).manual_seed(lowerCamelCase_       )
														lowerCAmelCase__	       =     lowerCAmelCase__	       =     {
														    '''prompt''': '''a cat and a frog''',
														    '''token_indices''': [2, 5],
														    '''generator''': generator,
														    '''num_inference_steps''': 1,
														    '''guidance_scale''': 6.0,
														    '''output_type''': '''numpy''',
														    '''max_iter_to_alter''': 2,
														    '''thresholds''': {0: 0.7},
														}
														return inputs







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														lowerCAmelCase__	       =     '''cpu'''

														lowerCAmelCase__	       =     self.get_dummy_components()
														lowerCAmelCase__	       =     self.pipeline_class(**lowerCamelCase_       )
														pipe.to(lowerCamelCase_       )
														pipe.set_progress_bar_config(disable=lowerCamelCase_       )

														lowerCAmelCase__	       =     self.get_dummy_inputs(lowerCamelCase_       )
														lowerCAmelCase__	       =     pipe(**lowerCamelCase_       ).images
														lowerCAmelCase__	       =     image[0, -3:, -3:, -1]

														self.assertEqual(image.shape ,   (1, 64, 64, 3)       )
														lowerCAmelCase__	       =     np.array(
														    [0.63_905_364, 0.62_897_307, 0.48_599_017, 0.5_133_624, 0.5_550_048, 0.45_769_516, 0.50_326_973, 0.5_023_139, 0.45_384_496]       )
														lowerCAmelCase__	       =     np.abs(image_slice.flatten() - expected_slice       ).max()
														self.assertLessEqual(lowerCamelCase_ ,   1e-3       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														super().test_cpu_offload_forward_pass(expected_max_diff=5e-4       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[Any]:
														# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
														self._test_inference_batch_consistent(batch_sizes=[1, 2]       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														self._test_inference_batch_single_identical(batch_size=2 ,   expected_max_diff=7e-4       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Any:
														super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Any:
														super().test_save_load_local(expected_max_difference=5e-4       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Union[str, Any]:
														super().test_save_load_optional_components(expected_max_difference=4e-4       )




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





							'''simple docstring'''






							@classmethod
							def   __SCREAMING_SNAKE_CASE							(		cls       )	->							List[Any]:
														super().setUpClass()
														torch.use_deterministic_algorithms(lowerCamelCase_       )







							@classmethod
							def   __SCREAMING_SNAKE_CASE							(		cls       )	->							Tuple:
														super().tearDownClass()
														torch.use_deterministic_algorithms(lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														lowerCAmelCase__	       =     torch.manual_seed(51       )

														lowerCAmelCase__	       =     StableDiffusionAttendAndExcitePipeline.from_pretrained(
														    '''CompVis/stable-diffusion-v1-4''' ,   safety_checker=lowerCamelCase_ ,   torch_dtype=torch.floataa       )
														pipe.to('''cuda'''       )

														lowerCAmelCase__	       =     '''a painting of an elephant with glasses'''
														lowerCAmelCase__	       =     [5, 7]

														lowerCAmelCase__	       =     pipe(
														    prompt=lowerCamelCase_ ,   token_indices=lowerCamelCase_ ,   guidance_scale=7.5 ,   generator=lowerCamelCase_ ,   num_inference_steps=5 ,   max_iter_to_alter=5 ,   output_type='''numpy''' ,   ).images[0]

														lowerCAmelCase__	       =     load_numpy(
														    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy'''       )
														assert np.abs((expected_image - image).max()       ) < 5e-1



'''simple docstring'''






from __future__ import annotations




class 		a__    :





							'''simple docstring'''






							def __init__(		self ,   lowerCamelCase_       )	->							None:
														lowerCAmelCase__	       =     order

														# a_{0} ... a_{k}
														lowerCAmelCase__	       =     [1.0] + [0.0] * order
														# b_{0} ... b_{k}
														lowerCAmelCase__	       =     [1.0] + [0.0] * order

														# x[n-1] ... x[n-k]
														lowerCAmelCase__	       =     [0.0] * self.order
														# y[n-1] ... y[n-k]
														lowerCAmelCase__	       =     [0.0] * self.order







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_       )	->							None:
														if len(lowerCamelCase_       ) < self.order:
																					lowerCAmelCase__	       =     [1.0, *a_coeffs]

														if len(lowerCamelCase_       ) != self.order + 1:
																					lowerCAmelCase__	       =     (
																					    F"""Expected a_coeffs to have {self.order + 1} elements """
																					    F"""for {self.order}-order filter, got {len(lowerCamelCase_       )}"""
																					)
																					raise ValueError(lowerCamelCase_       )

														if len(lowerCamelCase_       ) != self.order + 1:
																					lowerCAmelCase__	       =     (
																					    F"""Expected b_coeffs to have {self.order + 1} elements """
																					    F"""for {self.order}-order filter, got {len(lowerCamelCase_       )}"""
																					)
																					raise ValueError(lowerCamelCase_       )

														lowerCAmelCase__	       =     a_coeffs
														lowerCAmelCase__	       =     b_coeffs







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_       )	->							float:
														lowerCAmelCase__	       =     0.0

														# Start at index 1 and do index 0 at the end.
														for i in range(1 ,   self.order + 1       ):
																					result += (
																					    self.b_coeffs[i] * self.input_history[i - 1]
																					    - self.a_coeffs[i] * self.output_history[i - 1]
																					)

														lowerCAmelCase__	       =     (result + self.b_coeffs[0] * sample) / self.a_coeffs[0]

														lowerCAmelCase__	       =     self.input_history[:-1]
														lowerCAmelCase__	       =     self.output_history[:-1]

														lowerCAmelCase__	       =     sample
														lowerCAmelCase__	       =     result

														return result