

"""simple docstring"""




import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
     import torch

if is_vision_available():
     from PIL import Image

     from transformers import ChineseCLIPImageProcessor


class 		_A       (			unittest.TestCase					):





      def __init__(  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__=7    ,						SCREAMING_SNAKE_CASE__=3    ,						SCREAMING_SNAKE_CASE__=18    ,						SCREAMING_SNAKE_CASE__=30    ,						SCREAMING_SNAKE_CASE__=400    ,						SCREAMING_SNAKE_CASE__=True    ,						SCREAMING_SNAKE_CASE__=None    ,						SCREAMING_SNAKE_CASE__=True    ,						SCREAMING_SNAKE_CASE__=None    ,						SCREAMING_SNAKE_CASE__=True    ,						SCREAMING_SNAKE_CASE__=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]    ,						SCREAMING_SNAKE_CASE__=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]    ,						SCREAMING_SNAKE_CASE__=True    ,						)   ->					Dict:
         lowerCamelCase__						=			size if size is not None else {"height": 224, "width": 224}
         lowerCamelCase__						=			crop_size if crop_size is not None else {"height": 18, "width": 18}
         lowerCamelCase__						=			parent
         lowerCamelCase__						=			batch_size
         lowerCamelCase__						=			num_channels
         lowerCamelCase__						=			image_size
         lowerCamelCase__						=			min_resolution
         lowerCamelCase__						=			max_resolution
         lowerCamelCase__						=			do_resize
         lowerCamelCase__						=			size
         lowerCamelCase__						=			do_center_crop
         lowerCamelCase__						=			crop_size
         lowerCamelCase__						=			do_normalize
         lowerCamelCase__						=			image_mean
         lowerCamelCase__						=			image_std
         lowerCamelCase__						=			do_convert_rgb





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         return {
             "do_resize": self.do_resize,
             "size": self.size,
             "do_center_crop": self.do_center_crop,
             "crop_size": self.crop_size,
             "do_normalize": self.do_normalize,
             "image_mean": self.image_mean,
             "image_std": self.image_std,
             "do_convert_rgb": self.do_convert_rgb,
         }





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__=False    ,						SCREAMING_SNAKE_CASE__=False    ,						SCREAMING_SNAKE_CASE__=False		)   ->					Tuple:
         assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

         if equal_resolution:
            lowerCamelCase__						=			[]
            for i in range(self.batch_size		):
               image_inputs.append(
                   np.random.randint(
                       255    ,						size=(self.num_channels, self.max_resolution, self.max_resolution)    ,						dtype=np.uinta		)		)
         else:
            lowerCamelCase__						=			[]
            for i in range(self.batch_size		):
               lowerCamelCase__					,       lowerCamelCase__						=			np.random.choice(np.arange(self.min_resolution    ,						self.max_resolution		)    ,						2		)
               image_inputs.append(np.random.randint(255    ,						size=(self.num_channels, width, height)    ,						dtype=np.uinta		)		)

         if not numpify and not torchify:
            # PIL expects the channel dimension as last dimension
            lowerCamelCase__						=			[Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE__    ,						0    ,						-1		)		) for x in image_inputs]

         if torchify:
            lowerCamelCase__						=			[torch.from_numpy(SCREAMING_SNAKE_CASE__		) for x in image_inputs]

         return image_inputs






@require_torch
@require_vision
class 		_A       (			__a				,       unittest.TestCase					):
      __a								=	ChineseCLIPImageProcessor if is_vision_available() else None





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         lowerCamelCase__						=			ChineseCLIPImageProcessingTester(self    ,						do_center_crop=SCREAMING_SNAKE_CASE__		)





      @property
      def 					_lowerCamelCase  (  self		)   ->					Optional[int]:
         return self.image_processor_tester.prepare_image_processor_dict()





      def 					_lowerCamelCase  (  self		)   ->					List[str]:
         lowerCamelCase__						=			self.image_processing_class(**self.image_processor_dict		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"do_resize"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"size"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"do_center_crop"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"center_crop"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"do_normalize"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"image_mean"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"image_std"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"do_convert_rgb"		)		)





      def 					_lowerCamelCase  (  self		)   ->					str:
         lowerCamelCase__						=			self.image_processing_class.from_dict(self.image_processor_dict		)
         self.assertEqual(image_processor.size    ,						{"height": 224, "width": 224}		)
         self.assertEqual(image_processor.crop_size    ,						{"height": 18, "width": 18}		)

         lowerCamelCase__						=			self.image_processing_class.from_dict(self.image_processor_dict    ,						size=42    ,						crop_size=84		)
         self.assertEqual(image_processor.size    ,						{"shortest_edge": 42}		)
         self.assertEqual(image_processor.crop_size    ,						{"height": 84, "width": 84}		)





      def 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         pass





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         # Initialize image_processing
         lowerCamelCase__						=			self.image_processing_class(**self.image_processor_dict		)
         # create random PIL images
         lowerCamelCase__						=			self.image_processor_tester.prepare_inputs(equal_resolution=SCREAMING_SNAKE_CASE__		)
         for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE__    ,						Image.Image		)

         # Test not batched input
         lowerCamelCase__						=			image_processing(image_inputs[0]    ,						return_tensors="pt"		).pixel_values
         self.assertEqual(
             encoded_images.shape    ,						(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )    ,						)

         # Test batched
         lowerCamelCase__						=			image_processing(SCREAMING_SNAKE_CASE__    ,						return_tensors="pt"		).pixel_values
         self.assertEqual(
             encoded_images.shape    ,						(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )    ,						)





      def 					_lowerCamelCase  (  self		)   ->					int:
         # Initialize image_processing
         lowerCamelCase__						=			self.image_processing_class(**self.image_processor_dict		)
         # create random numpy tensors
         lowerCamelCase__						=			self.image_processor_tester.prepare_inputs(equal_resolution=SCREAMING_SNAKE_CASE__    ,						numpify=SCREAMING_SNAKE_CASE__		)
         for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE__    ,						np.ndarray		)

         # Test not batched input
         lowerCamelCase__						=			image_processing(image_inputs[0]    ,						return_tensors="pt"		).pixel_values
         self.assertEqual(
             encoded_images.shape    ,						(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )    ,						)

         # Test batched
         lowerCamelCase__						=			image_processing(SCREAMING_SNAKE_CASE__    ,						return_tensors="pt"		).pixel_values
         self.assertEqual(
             encoded_images.shape    ,						(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )    ,						)





      def 					_lowerCamelCase  (  self		)   ->					List[str]:
         # Initialize image_processing
         lowerCamelCase__						=			self.image_processing_class(**self.image_processor_dict		)
         # create random PyTorch tensors
         lowerCamelCase__						=			self.image_processor_tester.prepare_inputs(equal_resolution=SCREAMING_SNAKE_CASE__    ,						torchify=SCREAMING_SNAKE_CASE__		)
         for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE__    ,						torch.Tensor		)

         # Test not batched input
         lowerCamelCase__						=			image_processing(image_inputs[0]    ,						return_tensors="pt"		).pixel_values
         self.assertEqual(
             encoded_images.shape    ,						(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )    ,						)

         # Test batched
         lowerCamelCase__						=			image_processing(SCREAMING_SNAKE_CASE__    ,						return_tensors="pt"		).pixel_values
         self.assertEqual(
             encoded_images.shape    ,						(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )    ,						)






@require_torch
@require_vision
class 		_A       (			__a				,       unittest.TestCase					):
      __a								=	ChineseCLIPImageProcessor if is_vision_available() else None





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         lowerCamelCase__						=			ChineseCLIPImageProcessingTester(self    ,						num_channels=4    ,						do_center_crop=SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			3





      @property
      def 					_lowerCamelCase  (  self		)   ->					str:
         return self.image_processor_tester.prepare_image_processor_dict()





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         lowerCamelCase__						=			self.image_processing_class(**self.image_processor_dict		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"do_resize"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"size"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"do_center_crop"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"center_crop"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"do_normalize"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"image_mean"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"image_std"		)		)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__    ,						"do_convert_rgb"		)		)





      def 					_lowerCamelCase  (  self		)   ->					List[Any]:
         pass





      def 					_lowerCamelCase  (  self		)   ->					Optional[int]:
         # Initialize image_processing
         lowerCamelCase__						=			self.image_processing_class(**self.image_processor_dict		)
         # create random PIL images
         lowerCamelCase__						=			self.image_processor_tester.prepare_inputs(equal_resolution=SCREAMING_SNAKE_CASE__		)
         for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE__    ,						Image.Image		)

         # Test not batched input
         lowerCamelCase__						=			image_processing(image_inputs[0]    ,						return_tensors="pt"		).pixel_values
         self.assertEqual(
             encoded_images.shape    ,						(
                 1,
                 self.expected_encoded_image_num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )    ,						)

         # Test batched
         lowerCamelCase__						=			image_processing(SCREAMING_SNAKE_CASE__    ,						return_tensors="pt"		).pixel_values
         self.assertEqual(
             encoded_images.shape    ,						(
                 self.image_processor_tester.batch_size,
                 self.expected_encoded_image_num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )    ,						)







"""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 		_A       (			__a				,       __a				,       unittest.TestCase					):
      __a								=	IFPipeline
      __a								=	TEXT_TO_IMAGE_PARAMS - {'width', 'height', 'latents'}
      __a								=	TEXT_TO_IMAGE_BATCH_PARAMS
      __a								=	PipelineTesterMixin.required_optional_params - {'latents'}





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         return self._get_dummy_components()





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__=0		)   ->					Union[str, Any]:
         if str(SCREAMING_SNAKE_CASE__		).startswith("mps"		):
            lowerCamelCase__						=			torch.manual_seed(SCREAMING_SNAKE_CASE__		)
         else:
            lowerCamelCase__						=			torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(SCREAMING_SNAKE_CASE__		)

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

         return inputs





      def 					_lowerCamelCase  (  self		)   ->					str:
         self._test_save_load_optional_components()





      @unittest.skipIf(torch_device != "cuda"    ,						reason="float16 requires CUDA"		)
      def 					_lowerCamelCase  (  self		)   ->					Optional[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 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         self._test_attention_slicing_forward_pass(expected_max_diff=1e-2		)





      def 					_lowerCamelCase  (  self		)   ->					int:
         self._test_save_load_local()





      def 					_lowerCamelCase  (  self		)   ->					List[Any]:
         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 					_lowerCamelCase  (  self		)   ->					List[str]:
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3		)






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





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





      def 					_lowerCamelCase  (  self		)   ->					str:
         # if

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

         lowerCamelCase__						=			IFSuperResolutionPipeline.from_pretrained(
             "DeepFloyd/IF-II-L-v1.0"    ,						variant="fp16"    ,						torch_dtype=torch.floataa    ,						text_encoder=SCREAMING_SNAKE_CASE__    ,						tokenizer=SCREAMING_SNAKE_CASE__		)

         # pre compute text embeddings and remove T5 to save memory

         pipe_a.text_encoder.to("cuda"		)

         lowerCamelCase__					,       lowerCamelCase__						=			pipe_a.encode_prompt("anime turtle"    ,						device="cuda"		)

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

         lowerCamelCase__						=			None
         lowerCamelCase__						=			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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)

         pipe_a.remove_all_hooks()
         pipe_a.remove_all_hooks()

         # img2img

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

         pipe_a.remove_all_hooks()
         pipe_a.remove_all_hooks()

         # inpainting

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





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					int:
         # pipeline 1

         _start_torch_memory_measurement()

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)
         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						generator=SCREAMING_SNAKE_CASE__    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

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

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

         # pipeline 2

         _start_torch_memory_measurement()

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

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

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





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					Tuple:
         # pipeline 1

         _start_torch_memory_measurement()

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						generator=SCREAMING_SNAKE_CASE__    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

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

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

         # pipeline 2

         _start_torch_memory_measurement()

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)

         lowerCamelCase__						=			floats_tensor((1, 3, 256, 256)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						original_image=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

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

         lowerCamelCase__						=			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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)   ->					List[Any]:
         # pipeline 1

         _start_torch_memory_measurement()

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(1		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)
         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						mask_image=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						generator=SCREAMING_SNAKE_CASE__    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

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

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

         # pipeline 2

         _start_torch_memory_measurement()

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)

         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 256, 256)    ,						rng=random.Random(0		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, 3, 256, 256)    ,						rng=random.Random(1		)		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe_a(
             prompt_embeds=SCREAMING_SNAKE_CASE__    ,						negative_prompt_embeds=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						mask_image=SCREAMING_SNAKE_CASE__    ,						original_image=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=2    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

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

         lowerCamelCase__						=			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(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)






def 	UpperCAmelCase__   (				)      ->      Union[str, Any]:




   """simple docstring"""
   torch.cuda.empty_cache()
   torch.cuda.reset_max_memory_allocated()
   torch.cuda.reset_peak_memory_stats()




