




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



					'''simple docstring'''





					_UpperCamelCase							=		IFPipeline
					_UpperCamelCase							=		TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
					_UpperCamelCase							=		TEXT_TO_IMAGE_BATCH_PARAMS
					_UpperCamelCase							=		PipelineTesterMixin.required_optional_params - {"""latents"""}



					def     __snake_case						(	self     :						Any)    ->							Any:
								return self._get_dummy_components()



					def     __snake_case						(	self     :						Union[str, Any]      ,       _lowercase     :						Tuple      ,       _lowercase     :						List[Any]=0)    ->							Any:
								if str(_lowercase).startswith('mps'):
											A_									= torch.manual_seed(_lowercase)
								else:
											A_									= torch.Generator(device=_lowercase).manual_seed(_lowercase)

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

								return inputs



					def     __snake_case						(	self     :						List[Any])    ->							Optional[Any]:
								self._test_save_load_optional_components()



					@unittest.skipIf(torch_device != 'cuda'      ,       reason='float16 requires CUDA')
					def     __snake_case						(	self     :						Dict)    ->							int:
								# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
								super().test_save_load_floataa(expected_max_diff=1E-1)



					def     __snake_case						(	self     :						Dict)    ->							Optional[int]:
								self._test_attention_slicing_forward_pass(expected_max_diff=1E-2)



					def     __snake_case						(	self     :						Optional[int])    ->							Union[str, Any]:
								self._test_save_load_local()



					def     __snake_case						(	self     :						Any)    ->							Optional[int]:
								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     __snake_case						(	self     :						Any)    ->							Optional[int]:
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3)





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



					'''simple docstring'''





					def     __snake_case						(	self     :						Dict)    ->							int:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()



					def     __snake_case						(	self     :						Optional[int])    ->							Optional[int]:
								# if

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

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

								# pre compute text embeddings and remove T5 to save memory

								pipe_a.text_encoder.to('cuda')

								A_		, A_									= pipe_a.encode_prompt('anime turtle'      ,       device='cuda')

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

								A_									= None
								A_									= 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(_lowercase      ,       _lowercase      ,       _lowercase      ,       _lowercase)

								pipe_a.remove_all_hooks()
								pipe_a.remove_all_hooks()

								# img2img

								A_									= IFImgaImgPipeline(**pipe_a.components)
								A_									= 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(_lowercase      ,       _lowercase      ,       _lowercase      ,       _lowercase)

								pipe_a.remove_all_hooks()
								pipe_a.remove_all_hooks()

								# inpainting

								A_									= IFInpaintingPipeline(**pipe_a.components)
								A_									= 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(_lowercase      ,       _lowercase      ,       _lowercase      ,       _lowercase)



					def     __snake_case						(	self     :						int      ,       _lowercase     :						List[Any]      ,       _lowercase     :						Tuple      ,       _lowercase     :						int      ,       _lowercase     :						Optional[int])    ->							Tuple:
								# pipeline 1

								_start_torch_memory_measurement()

								A_									= torch.Generator(device='cpu').manual_seed(0)
								A_									= pipe_a(
								    prompt_embeds=_lowercase      ,       negative_prompt_embeds=_lowercase      ,       num_inference_steps=2      ,       generator=_lowercase      ,       output_type='np'      ,       )

								A_									= output.images[0]

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

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

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

								# pipeline 2

								_start_torch_memory_measurement()

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

								A_									= floats_tensor((1, 3, 64, 64)      ,       rng=random.Random(0)).to(_lowercase)

								A_									= pipe_a(
								    prompt_embeds=_lowercase      ,       negative_prompt_embeds=_lowercase      ,       image=_lowercase      ,       generator=_lowercase      ,       num_inference_steps=2      ,       output_type='np'      ,       )

								A_									= output.images[0]

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

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

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



					def     __snake_case						(	self     :						List[str]      ,       _lowercase     :						Optional[Any]      ,       _lowercase     :						Dict      ,       _lowercase     :						Tuple      ,       _lowercase     :						Any)    ->							Dict:
								# pipeline 1

								_start_torch_memory_measurement()

								A_									= floats_tensor((1, 3, 64, 64)      ,       rng=random.Random(0)).to(_lowercase)

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

								A_									= pipe_a(
								    prompt_embeds=_lowercase      ,       negative_prompt_embeds=_lowercase      ,       image=_lowercase      ,       num_inference_steps=2      ,       generator=_lowercase      ,       output_type='np'      ,       )

								A_									= output.images[0]

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

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

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

								# pipeline 2

								_start_torch_memory_measurement()

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

								A_									= floats_tensor((1, 3, 256, 256)      ,       rng=random.Random(0)).to(_lowercase)
								A_									= floats_tensor((1, 3, 64, 64)      ,       rng=random.Random(0)).to(_lowercase)

								A_									= pipe_a(
								    prompt_embeds=_lowercase      ,       negative_prompt_embeds=_lowercase      ,       image=_lowercase      ,       original_image=_lowercase      ,       generator=_lowercase      ,       num_inference_steps=2      ,       output_type='np'      ,       )

								A_									= output.images[0]

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

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

								A_									= 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(_lowercase      ,       _lowercase)



					def     __snake_case						(	self     :						List[Any]      ,       _lowercase     :						str      ,       _lowercase     :						Tuple      ,       _lowercase     :						Optional[int]      ,       _lowercase     :						int)    ->							Any:
								# pipeline 1

								_start_torch_memory_measurement()

								A_									= floats_tensor((1, 3, 64, 64)      ,       rng=random.Random(0)).to(_lowercase)
								A_									= floats_tensor((1, 3, 64, 64)      ,       rng=random.Random(1)).to(_lowercase)

								A_									= torch.Generator(device='cpu').manual_seed(0)
								A_									= pipe_a(
								    prompt_embeds=_lowercase      ,       negative_prompt_embeds=_lowercase      ,       image=_lowercase      ,       mask_image=_lowercase      ,       num_inference_steps=2      ,       generator=_lowercase      ,       output_type='np'      ,       )

								A_									= output.images[0]

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

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

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

								# pipeline 2

								_start_torch_memory_measurement()

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

								A_									= floats_tensor((1, 3, 64, 64)      ,       rng=random.Random(0)).to(_lowercase)
								A_									= floats_tensor((1, 3, 256, 256)      ,       rng=random.Random(0)).to(_lowercase)
								A_									= floats_tensor((1, 3, 256, 256)      ,       rng=random.Random(1)).to(_lowercase)

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

								A_									= output.images[0]

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

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

								A_									= 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(_lowercase      ,       _lowercase)





def 			lowerCamelCase(							)		->		Tuple:
			torch.cuda.empty_cache()
			torch.cuda.reset_max_memory_allocated()
			torch.cuda.reset_peak_memory_stats()










'''simple docstring'''
import numpy as np





def 			lowerCamelCase(							SCREAMING_SNAKE_CASE_     )		->		np.array:
			return 1 / (1 + np.exp(-vector     ))





def 			lowerCamelCase(							SCREAMING_SNAKE_CASE_     )		->		np.array:
			return vector * sigmoid(1.702 * vector     )


if __name__ == "__main__":
							import doctest

							doctest.testmod()




