




"""simple docstring"""




import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()






class        __magic_name__				(			unittest.TestCase							):






				'''simple docstring'''





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()





				@property
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   1
							lowerCamelCase      =   3
							lowerCamelCase      =   (32, 32)

							lowerCamelCase      =   floats_tensor((batch_size, num_channels) + sizes						,					rng=random.Random(0					)					).to(_a					)
							return image





				@property
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							torch.manual_seed(0					)
							lowerCamelCase      =   UNetaDConditionModel(
							    block_out_channels=(32, 32, 64)						,					layers_per_block=2						,					sample_size=32						,					in_channels=7						,					out_channels=4						,					down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""", """CrossAttnDownBlock2D""")						,					up_block_types=("""CrossAttnUpBlock2D""", """CrossAttnUpBlock2D""", """UpBlock2D""")						,					cross_attention_dim=32						,					attention_head_dim=8						,					use_linear_projection=_a						,					only_cross_attention=(True, True, False)						,					num_class_embeds=100						,					)
							return model





				@property
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							torch.manual_seed(0					)
							lowerCamelCase      =   AutoencoderKL(
							    block_out_channels=[32, 32, 64]						,					in_channels=3						,					out_channels=3						,					down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D""", """DownEncoderBlock2D"""]						,					up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D""", """UpDecoderBlock2D"""]						,					latent_channels=4						,					)
							return model





				@property
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							torch.manual_seed(0					)
							lowerCamelCase      =   CLIPTextConfig(
							    bos_token_id=0						,					eos_token_id=2						,					hidden_size=32						,					intermediate_size=37						,					layer_norm_eps=1e-0_5						,					num_attention_heads=4						,					num_hidden_layers=5						,					pad_token_id=1						,					vocab_size=1_000						,					hidden_act="""gelu"""						,					projection_dim=512						,					)
							return CLIPTextModel(_a					)





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   """cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowerCamelCase      =   self.dummy_cond_unet_upscale
							lowerCamelCase      =   DDPMScheduler()
							lowerCamelCase      =   DDIMScheduler(prediction_type="""v_prediction"""					)
							lowerCamelCase      =   self.dummy_vae
							lowerCamelCase      =   self.dummy_text_encoder
							lowerCamelCase      =   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

							lowerCamelCase      =   self.dummy_image.cpu().permute(0						,					2						,					3						,					1					)[0]
							lowerCamelCase      =   Image.fromarray(np.uinta(_a					)					).convert("""RGB"""					).resize((64, 64)					)

							# make sure here that pndm scheduler skips prk
							lowerCamelCase      =   StableDiffusionUpscalePipeline(
							    unet=_a						,					low_res_scheduler=_a						,					scheduler=_a						,					vae=_a						,					text_encoder=_a						,					tokenizer=_a						,					max_noise_level=350						,					)
							lowerCamelCase      =   sd_pipe.to(_a					)
							sd_pipe.set_progress_bar_config(disable=_a					)

							lowerCamelCase      =   """A painting of a squirrel eating a burger"""
							lowerCamelCase      =   torch.Generator(device=_a					).manual_seed(0					)
							lowerCamelCase      =   sd_pipe(
							    [prompt]						,					image=_a						,					generator=_a						,					guidance_scale=6.0						,					noise_level=20						,					num_inference_steps=2						,					output_type="""np"""						,					)

							lowerCamelCase      =   output.images

							lowerCamelCase      =   torch.Generator(device=_a					).manual_seed(0					)
							lowerCamelCase      =   sd_pipe(
							    [prompt]						,					image=_a						,					generator=_a						,					guidance_scale=6.0						,					noise_level=20						,					num_inference_steps=2						,					output_type="""np"""						,					return_dict=_a						,					)[0]

							lowerCamelCase      =   image[0, -3:, -3:, -1]
							lowerCamelCase      =   image_from_tuple[0, -3:, -3:, -1]

							lowerCamelCase      =   low_res_image.size[0] * 4
							assert image.shape == (1, expected_height_width, expected_height_width, 3)
							lowerCamelCase      =   np.array([0.3_113, 0.3_910, 0.4_272, 0.4_859, 0.5_061, 0.4_652, 0.5_362, 0.5_715, 0.5_661]					)

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





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   """cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowerCamelCase      =   self.dummy_cond_unet_upscale
							lowerCamelCase      =   DDPMScheduler()
							lowerCamelCase      =   DDIMScheduler(prediction_type="""v_prediction"""					)
							lowerCamelCase      =   self.dummy_vae
							lowerCamelCase      =   self.dummy_text_encoder
							lowerCamelCase      =   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

							lowerCamelCase      =   self.dummy_image.cpu().permute(0						,					2						,					3						,					1					)[0]
							lowerCamelCase      =   Image.fromarray(np.uinta(_a					)					).convert("""RGB"""					).resize((64, 64)					)

							# make sure here that pndm scheduler skips prk
							lowerCamelCase      =   StableDiffusionUpscalePipeline(
							    unet=_a						,					low_res_scheduler=_a						,					scheduler=_a						,					vae=_a						,					text_encoder=_a						,					tokenizer=_a						,					max_noise_level=350						,					)
							lowerCamelCase      =   sd_pipe.to(_a					)
							sd_pipe.set_progress_bar_config(disable=_a					)

							lowerCamelCase      =   """A painting of a squirrel eating a burger"""
							lowerCamelCase      =   sd_pipe(
							    2 * [prompt]						,					image=2 * [low_res_image]						,					guidance_scale=6.0						,					noise_level=20						,					num_inference_steps=2						,					output_type="""np"""						,					)
							lowerCamelCase      =   output.images
							assert image.shape[0] == 2

							lowerCamelCase      =   torch.Generator(device=_a					).manual_seed(0					)
							lowerCamelCase      =   sd_pipe(
							    [prompt]						,					image=_a						,					generator=_a						,					num_images_per_prompt=2						,					guidance_scale=6.0						,					noise_level=20						,					num_inference_steps=2						,					output_type="""np"""						,					)
							lowerCamelCase      =   output.images
							assert image.shape[0] == 2





				@unittest.skipIf(torch_device != """cuda"""						,					"""This test requires a GPU"""					)
				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   self.dummy_cond_unet_upscale
							lowerCamelCase      =   DDPMScheduler()
							lowerCamelCase      =   DDIMScheduler(prediction_type="""v_prediction"""					)
							lowerCamelCase      =   self.dummy_vae
							lowerCamelCase      =   self.dummy_text_encoder
							lowerCamelCase      =   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

							lowerCamelCase      =   self.dummy_image.cpu().permute(0						,					2						,					3						,					1					)[0]
							lowerCamelCase      =   Image.fromarray(np.uinta(_a					)					).convert("""RGB"""					).resize((64, 64)					)

							# put models in fp16, except vae as it overflows in fp16
							lowerCamelCase      =   unet.half()
							lowerCamelCase      =   text_encoder.half()

							# make sure here that pndm scheduler skips prk
							lowerCamelCase      =   StableDiffusionUpscalePipeline(
							    unet=_a						,					low_res_scheduler=_a						,					scheduler=_a						,					vae=_a						,					text_encoder=_a						,					tokenizer=_a						,					max_noise_level=350						,					)
							lowerCamelCase      =   sd_pipe.to(_a					)
							sd_pipe.set_progress_bar_config(disable=_a					)

							lowerCamelCase      =   """A painting of a squirrel eating a burger"""
							lowerCamelCase      =   torch.manual_seed(0					)
							lowerCamelCase      =   sd_pipe(
							    [prompt]						,					image=_a						,					generator=_a						,					num_inference_steps=2						,					output_type="""np"""						,					).images

							lowerCamelCase      =   low_res_image.size[0] * 4
							assert image.shape == (1, expected_height_width, expected_height_width, 3)






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






				'''simple docstring'''





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
							    """/sd2-upscale/low_res_cat.png"""					)
							lowerCamelCase      =   load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"""
							    """/upsampled_cat.npy"""					)

							lowerCamelCase      =   """stabilityai/stable-diffusion-x4-upscaler"""
							lowerCamelCase      =   StableDiffusionUpscalePipeline.from_pretrained(_a					)
							pipe.to(_a					)
							pipe.set_progress_bar_config(disable=_a					)
							pipe.enable_attention_slicing()

							lowerCamelCase      =   """a cat sitting on a park bench"""

							lowerCamelCase      =   torch.manual_seed(0					)
							lowerCamelCase      =   pipe(
							    prompt=_a						,					image=_a						,					generator=_a						,					output_type="""np"""						,					)
							lowerCamelCase      =   output.images[0]

							assert image.shape == (512, 512, 3)
							assert np.abs(expected_image - image					).max() < 1e-3





				def   _lowerCAmelCase							(			self					):





							"""simple docstring"""
							lowerCamelCase      =   load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
							    """/sd2-upscale/low_res_cat.png"""					)
							lowerCamelCase      =   load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"""
							    """/upsampled_cat_fp16.npy"""					)

							lowerCamelCase      =   """stabilityai/stable-diffusion-x4-upscaler"""
							lowerCamelCase      =   StableDiffusionUpscalePipeline.from_pretrained(
							    _a						,					torch_dtype=torch.floataa						,					)
							pipe.to(_a					)
							pipe.set_progress_bar_config(disable=_a					)
							pipe.enable_attention_slicing()

							lowerCamelCase      =   """a cat sitting on a park bench"""

							lowerCamelCase      =   torch.manual_seed(0					)
							lowerCamelCase      =   pipe(
							    prompt=_a						,					image=_a						,					generator=_a						,					output_type="""np"""						,					)
							lowerCamelCase      =   output.images[0]

							assert image.shape == (512, 512, 3)
							assert np.abs(expected_image - image					).max() < 5e-1





				def   _lowerCAmelCase							(			self					):





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

							lowerCamelCase      =   load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
							    """/sd2-upscale/low_res_cat.png"""					)

							lowerCamelCase      =   """stabilityai/stable-diffusion-x4-upscaler"""
							lowerCamelCase      =   StableDiffusionUpscalePipeline.from_pretrained(
							    _a						,					torch_dtype=torch.floataa						,					)
							pipe.to(_a					)
							pipe.set_progress_bar_config(disable=_a					)
							pipe.enable_attention_slicing(1					)
							pipe.enable_sequential_cpu_offload()

							lowerCamelCase      =   """a cat sitting on a park bench"""

							lowerCamelCase      =   torch.manual_seed(0					)
							lowerCamelCase      =   pipe(
							    prompt=_a						,					image=_a						,					generator=_a						,					num_inference_steps=5						,					output_type="""np"""						,					)

							lowerCamelCase      =   torch.cuda.max_memory_allocated()
							# make sure that less than 2.9 GB is allocated
							assert mem_bytes < 2.9 * 10**9









"""simple docstring"""




import random



def        a__					(							snake_case__			,					snake_case__			,					snake_case__ = False							)		->   dict:
			lowerCamelCase      =   {i: [] for i in range(snake_case__							)}

			# if probability is greater or equal than 1, then generate a complete graph
			if probability >= 1:
						return complete_graph(snake_case__							)
			# if probability is lower or equal than 0, then return a graph without edges
			if probability <= 0:
						return graph

			# for each couple of nodes, add an edge from u to v
			# if the number randomly generated is greater than probability probability
			for i in range(snake_case__							):
						for j in range(i + 1			,					snake_case__							):
									if random.random() < probability:
												graph[i].append(snake_case__							)
												if not directed:
															# if the graph is undirected, add an edge in from j to i, either
															graph[j].append(snake_case__							)
			return graph



def        a__					(							snake_case__							)		->   dict:
			return {
			    i: [j for j in range(snake_case__							) if i != j] for i in range(snake_case__							)
			}


if __name__ == "__main__":
					import doctest

					doctest.testmod()



