




"""simple docstring"""

import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin

@skip_mps
class        lowercase      (    __UpperCAmelCase     ,	__UpperCAmelCase     ,	unittest.TestCase):
				__lowerCAmelCase    :    int         =   IFPipeline
				__lowerCAmelCase    :    List[Any]         =   TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
				__lowerCAmelCase    :    Optional[int]         =   TEXT_TO_IMAGE_BATCH_PARAMS
				__lowerCAmelCase    :    Union[str, Any]         =   PipelineTesterMixin.required_optional_params - {"""latents"""}







				def 					a_  (							self   :					int       ):



					"""simple docstring"""

					return self._get_dummy_components()







				def 					a_  (							self   :					List[Any]      ,     _lowerCamelCase   :					Optional[Any]      ,     _lowerCamelCase   :					Dict=0       ):



					"""simple docstring"""

					if str(_lowerCamelCase       ).startswith('''mps'''       ):
						A_  :				int	   =		torch.manual_seed(_lowerCamelCase       )
					else:
						A_  :				Union[str, Any]	   =		torch.Generator(device=_lowerCamelCase       ).manual_seed(_lowerCamelCase       )

					A_  :				Union[str, Any]	   =		{
					    '''prompt''': '''A painting of a squirrel eating a burger''',
					    '''generator''': generator,
					    '''num_inference_steps''': 2,
					    '''output_type''': '''numpy''',
					}

					return inputs







				def 					a_  (							self   :					List[Any]       ):



					"""simple docstring"""

					self._test_save_load_optional_components()







				@unittest.skipIf(torch_device != '''cuda'''      ,     reason='''float16 requires CUDA'''       )
				def 					a_  (							self   :					List[str]       ):



					"""simple docstring"""

					super().test_save_load_floataa(expected_max_diff=1E-1       )







				def 					a_  (							self   :					int       ):



					"""simple docstring"""

					self._test_attention_slicing_forward_pass(expected_max_diff=1E-2       )







				def 					a_  (							self   :					Tuple       ):



					"""simple docstring"""

					self._test_save_load_local()







				def 					a_  (							self   :					List[str]       ):



					"""simple docstring"""

					self._test_inference_batch_single_identical(
					    expected_max_diff=1E-2      ,     )







				@unittest.skipIf(
				    torch_device != '''cuda''' or not is_xformers_available()      ,     reason='''XFormers attention is only available with CUDA and `xformers` installed'''      ,     )
				def 					a_  (							self   :					Union[str, Any]       ):



					"""simple docstring"""

					self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3       )

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







				def 					a_  (							self   :					int       ):



					"""simple docstring"""

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







				def 					a_  (							self   :					Optional[int]       ):



					"""simple docstring"""

					A_  :				Optional[int]	   =		IFPipeline.from_pretrained('''DeepFloyd/IF-I-XL-v1.0'''      ,     variant='''fp16'''      ,     torch_dtype=torch.floataa       )

					A_  :				int	   =		IFSuperResolutionPipeline.from_pretrained(
					    '''DeepFloyd/IF-II-L-v1.0'''      ,     variant='''fp16'''      ,     torch_dtype=torch.floataa      ,     text_encoder=_lowerCamelCase      ,     tokenizer=_lowerCamelCase       )

					# pre compute text embeddings and remove T5 to save memory

					pipe_a.text_encoder.to('''cuda'''       )

					A_   , A_  :				List[str]	   =		pipe_a.encode_prompt('''anime turtle'''      ,     device='''cuda'''       )

					del pipe_a.tokenizer
					del pipe_a.text_encoder
					gc.collect()

					A_  :				List[Any]	   =		None
					A_  :				Tuple	   =		None

					pipe_a.enable_model_cpu_offload()
					pipe_a.enable_model_cpu_offload()

					pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )
					pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )

					self._test_if(_lowerCamelCase      ,     _lowerCamelCase      ,     _lowerCamelCase      ,     _lowerCamelCase       )

					pipe_a.remove_all_hooks()
					pipe_a.remove_all_hooks()

					# img2img

					A_  :				Union[str, Any]	   =		IFImgaImgPipeline(**pipe_a.components       )
					A_  :				Any	   =		IFImgaImgSuperResolutionPipeline(**pipe_a.components       )

					pipe_a.enable_model_cpu_offload()
					pipe_a.enable_model_cpu_offload()

					pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )
					pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )

					self._test_if_imgaimg(_lowerCamelCase      ,     _lowerCamelCase      ,     _lowerCamelCase      ,     _lowerCamelCase       )

					pipe_a.remove_all_hooks()
					pipe_a.remove_all_hooks()

					# inpainting

					A_  :				Any	   =		IFInpaintingPipeline(**pipe_a.components       )
					A_  :				List[str]	   =		IFInpaintingSuperResolutionPipeline(**pipe_a.components       )

					pipe_a.enable_model_cpu_offload()
					pipe_a.enable_model_cpu_offload()

					pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )
					pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()       )

					self._test_if_inpainting(_lowerCamelCase      ,     _lowerCamelCase      ,     _lowerCamelCase      ,     _lowerCamelCase       )







				def 					a_  (							self   :					List[str]      ,     _lowerCamelCase   :					Tuple      ,     _lowerCamelCase   :					str      ,     _lowerCamelCase   :					List[str]      ,     _lowerCamelCase   :					Optional[Any]       ):



					"""simple docstring"""

					_start_torch_memory_measurement()

					A_  :				Optional[int]	   =		torch.Generator(device='''cpu'''       ).manual_seed(0       )
					A_  :				Tuple	   =		pipe_a(
					    prompt_embeds=_lowerCamelCase      ,     negative_prompt_embeds=_lowerCamelCase      ,     num_inference_steps=2      ,     generator=_lowerCamelCase      ,     output_type='''np'''      ,     )

					A_  :				Optional[int]	   =		output.images[0]

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

					A_  :				Tuple	   =		torch.cuda.max_memory_allocated()
					assert mem_bytes < 13 * 10**9

					A_  :				int	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy'''       )
					assert_mean_pixel_difference(_lowerCamelCase      ,     _lowerCamelCase       )

					# pipeline 2

					_start_torch_memory_measurement()

					A_  :				int	   =		torch.Generator(device='''cpu'''       ).manual_seed(0       )

					A_  :				int	   =		floats_tensor((1, 3, 64, 64)      ,     rng=random.Random(0       )       ).to(_lowerCamelCase       )

					A_  :				int	   =		pipe_a(
					    prompt_embeds=_lowerCamelCase      ,     negative_prompt_embeds=_lowerCamelCase      ,     image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     num_inference_steps=2      ,     output_type='''np'''      ,     )

					A_  :				Union[str, Any]	   =		output.images[0]

					assert image.shape == (2_56, 2_56, 3)

					A_  :				List[str]	   =		torch.cuda.max_memory_allocated()
					assert mem_bytes < 4 * 10**9

					A_  :				Any	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'''       )
					assert_mean_pixel_difference(_lowerCamelCase      ,     _lowerCamelCase       )







				def 					a_  (							self   :					List[str]      ,     _lowerCamelCase   :					List[str]      ,     _lowerCamelCase   :					int      ,     _lowerCamelCase   :					Dict      ,     _lowerCamelCase   :					Any       ):



					"""simple docstring"""

					_start_torch_memory_measurement()

					A_  :				Optional[Any]	   =		floats_tensor((1, 3, 64, 64)      ,     rng=random.Random(0       )       ).to(_lowerCamelCase       )

					A_  :				Optional[Any]	   =		torch.Generator(device='''cpu'''       ).manual_seed(0       )

					A_  :				List[str]	   =		pipe_a(
					    prompt_embeds=_lowerCamelCase      ,     negative_prompt_embeds=_lowerCamelCase      ,     image=_lowerCamelCase      ,     num_inference_steps=2      ,     generator=_lowerCamelCase      ,     output_type='''np'''      ,     )

					A_  :				Any	   =		output.images[0]

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

					A_  :				int	   =		torch.cuda.max_memory_allocated()
					assert mem_bytes < 10 * 10**9

					A_  :				Any	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'''       )
					assert_mean_pixel_difference(_lowerCamelCase      ,     _lowerCamelCase       )

					# pipeline 2

					_start_torch_memory_measurement()

					A_  :				Optional[Any]	   =		torch.Generator(device='''cpu'''       ).manual_seed(0       )

					A_  :				List[Any]	   =		floats_tensor((1, 3, 2_56, 2_56)      ,     rng=random.Random(0       )       ).to(_lowerCamelCase       )
					A_  :				Optional[int]	   =		floats_tensor((1, 3, 64, 64)      ,     rng=random.Random(0       )       ).to(_lowerCamelCase       )

					A_  :				Optional[Any]	   =		pipe_a(
					    prompt_embeds=_lowerCamelCase      ,     negative_prompt_embeds=_lowerCamelCase      ,     image=_lowerCamelCase      ,     original_image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     num_inference_steps=2      ,     output_type='''np'''      ,     )

					A_  :				Union[str, Any]	   =		output.images[0]

					assert image.shape == (2_56, 2_56, 3)

					A_  :				Any	   =		torch.cuda.max_memory_allocated()
					assert mem_bytes < 4 * 10**9

					A_  :				Dict	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy'''       )
					assert_mean_pixel_difference(_lowerCamelCase      ,     _lowerCamelCase       )







				def 					a_  (							self   :					Union[str, Any]      ,     _lowerCamelCase   :					Union[str, Any]      ,     _lowerCamelCase   :					int      ,     _lowerCamelCase   :					Any      ,     _lowerCamelCase   :					int       ):



					"""simple docstring"""

					_start_torch_memory_measurement()

					A_  :				List[Any]	   =		floats_tensor((1, 3, 64, 64)      ,     rng=random.Random(0       )       ).to(_lowerCamelCase       )
					A_  :				Tuple	   =		floats_tensor((1, 3, 64, 64)      ,     rng=random.Random(1       )       ).to(_lowerCamelCase       )

					A_  :				int	   =		torch.Generator(device='''cpu'''       ).manual_seed(0       )
					A_  :				List[str]	   =		pipe_a(
					    prompt_embeds=_lowerCamelCase      ,     negative_prompt_embeds=_lowerCamelCase      ,     image=_lowerCamelCase      ,     mask_image=_lowerCamelCase      ,     num_inference_steps=2      ,     generator=_lowerCamelCase      ,     output_type='''np'''      ,     )

					A_  :				Optional[int]	   =		output.images[0]

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

					A_  :				Union[str, Any]	   =		torch.cuda.max_memory_allocated()
					assert mem_bytes < 10 * 10**9

					A_  :				str	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy'''       )
					assert_mean_pixel_difference(_lowerCamelCase      ,     _lowerCamelCase       )

					# pipeline 2

					_start_torch_memory_measurement()

					A_  :				str	   =		torch.Generator(device='''cpu'''       ).manual_seed(0       )

					A_  :				Tuple	   =		floats_tensor((1, 3, 64, 64)      ,     rng=random.Random(0       )       ).to(_lowerCamelCase       )
					A_  :				int	   =		floats_tensor((1, 3, 2_56, 2_56)      ,     rng=random.Random(0       )       ).to(_lowerCamelCase       )
					A_  :				Optional[Any]	   =		floats_tensor((1, 3, 2_56, 2_56)      ,     rng=random.Random(1       )       ).to(_lowerCamelCase       )

					A_  :				Dict	   =		pipe_a(
					    prompt_embeds=_lowerCamelCase      ,     negative_prompt_embeds=_lowerCamelCase      ,     image=_lowerCamelCase      ,     mask_image=_lowerCamelCase      ,     original_image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     num_inference_steps=2      ,     output_type='''np'''      ,     )

					A_  :				Optional[int]	   =		output.images[0]

					assert image.shape == (2_56, 2_56, 3)

					A_  :				int	   =		torch.cuda.max_memory_allocated()
					assert mem_bytes < 4 * 10**9

					A_  :				Tuple	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy'''       )
					assert_mean_pixel_difference(_lowerCamelCase      ,     _lowerCamelCase       )

def 		lowercase_      (		):




	"""simple docstring"""






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











"""simple docstring"""

from typing import Any

import numpy as np

def 		lowercase_      (		_UpperCAmelCase	):




	"""simple docstring"""






	return np.array_equal(_UpperCAmelCase  ,      matrix.conjugate().T	)

def 		lowercase_      (		_UpperCAmelCase  ,      _UpperCAmelCase	):




	"""simple docstring"""






	A_  :				Tuple	   =		v.conjugate().T
	A_  :				Tuple	   =		v_star.dot(_UpperCAmelCase	)
	assert isinstance(_UpperCAmelCase  ,      np.ndarray	)
	return (v_star_dot.dot(_UpperCAmelCase	)) / (v_star.dot(_UpperCAmelCase	))

def 		lowercase_      (		):




	"""simple docstring"""






	A_  :				Optional[Any]	   =		np.array([[2, 2 + 1J, 4], [2 - 1J, 3, 1J], [4, -1J, 1]]	)
	A_  :				str	   =		np.array([[1], [2], [3]]	)
	assert is_hermitian(_UpperCAmelCase	), f"""{a} is not hermitian."""
	print(rayleigh_quotient(_UpperCAmelCase  ,      _UpperCAmelCase	)	)

	A_  :				int	   =		np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]	)
	assert is_hermitian(_UpperCAmelCase	), f"""{a} is not hermitian."""
	assert rayleigh_quotient(_UpperCAmelCase  ,      _UpperCAmelCase	) == float(3	)


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		tests()





