






'''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 		UpperCamelCase__    (unittest.TestCase			):




		'''simple docstring'''





		def 			UpperCamelCase_					(      self       ):
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






		@property
		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  1
								lowerCamelCase__         =  3
								lowerCamelCase__         =  (32, 32)

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






		@property
		def 			UpperCamelCase_					(      self       ):
								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=lowercase__   ,only_cross_attention=(True, True, False)   ,num_class_embeds=1_00   ,)
								return model






		@property
		def 			UpperCamelCase_					(      self       ):
								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 			UpperCamelCase_					(      self       ):
								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   ,)
								return CLIPTextModel(lowercase__       )






		def 			UpperCamelCase_					(      self       ):
								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(lowercase__       )       ).convert("""RGB"""       ).resize((64, 64)       )

								# make sure here that pndm scheduler skips prk
								lowerCamelCase__         =  StableDiffusionUpscalePipeline(
								    unet=lowercase__   ,low_res_scheduler=lowercase__   ,scheduler=lowercase__   ,vae=lowercase__   ,text_encoder=lowercase__   ,tokenizer=lowercase__   ,max_noise_level=3_50   ,)
								lowerCamelCase__         =  sd_pipe.to(lowercase__       )
								sd_pipe.set_progress_bar_config(disable=lowercase__       )

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

								lowerCamelCase__         =  output.images

								lowerCamelCase__         =  torch.Generator(device=lowercase__       ).manual_seed(0       )
								lowerCamelCase__         =  sd_pipe(
								    [prompt]   ,image=lowercase__   ,generator=lowercase__   ,guidance_scale=6.0   ,noise_level=20   ,num_inference_steps=2   ,output_type="""np"""   ,return_dict=lowercase__   ,)[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.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661]       )

								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 			UpperCamelCase_					(      self       ):
								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(lowercase__       )       ).convert("""RGB"""       ).resize((64, 64)       )

								# make sure here that pndm scheduler skips prk
								lowerCamelCase__         =  StableDiffusionUpscalePipeline(
								    unet=lowercase__   ,low_res_scheduler=lowercase__   ,scheduler=lowercase__   ,vae=lowercase__   ,text_encoder=lowercase__   ,tokenizer=lowercase__   ,max_noise_level=3_50   ,)
								lowerCamelCase__         =  sd_pipe.to(lowercase__       )
								sd_pipe.set_progress_bar_config(disable=lowercase__       )

								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=lowercase__       ).manual_seed(0       )
								lowerCamelCase__         =  sd_pipe(
								    [prompt]   ,image=lowercase__   ,generator=lowercase__   ,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 			UpperCamelCase_					(      self       ):
								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(lowercase__       )       ).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=lowercase__   ,low_res_scheduler=lowercase__   ,scheduler=lowercase__   ,vae=lowercase__   ,text_encoder=lowercase__   ,tokenizer=lowercase__   ,max_noise_level=3_50   ,)
								lowerCamelCase__         =  sd_pipe.to(lowercase__       )
								sd_pipe.set_progress_bar_config(disable=lowercase__       )

								lowerCamelCase__         =  '''A painting of a squirrel eating a burger'''
								lowerCamelCase__         =  torch.manual_seed(0       )
								lowerCamelCase__         =  sd_pipe(
								    [prompt]   ,image=lowercase__   ,generator=lowercase__   ,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 		UpperCamelCase__    (unittest.TestCase			):




		'''simple docstring'''





		def 			UpperCamelCase_					(      self       ):
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






		def 			UpperCamelCase_					(      self       ):
								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(lowercase__       )
								pipe.to(lowercase__       )
								pipe.set_progress_bar_config(disable=lowercase__       )
								pipe.enable_attention_slicing()

								lowerCamelCase__         =  '''a cat sitting on a park bench'''

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

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






		def 			UpperCamelCase_					(      self       ):
								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(
								    lowercase__   ,torch_dtype=torch.floataa   ,)
								pipe.to(lowercase__       )
								pipe.set_progress_bar_config(disable=lowercase__       )
								pipe.enable_attention_slicing()

								lowerCamelCase__         =  '''a cat sitting on a park bench'''

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

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






		def 			UpperCamelCase_					(      self       ):
								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(
								    lowercase__   ,torch_dtype=torch.floataa   ,)
								pipe.to(lowercase__       )
								pipe.set_progress_bar_config(disable=lowercase__       )
								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=lowercase__   ,image=lowercase__   ,generator=lowercase__   ,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'''







def 						A__			(				):
						return [
						    a * b * (1000 - a - b)
						    for a in range(1   ,    999						)
						    for b in range(__lowerCAmelCase   ,    999						)
						    if (a * a + b * b == (1000 - a - b) ** 2)
						][0]


if __name__ == "__main__":
							print(F'{solution() = }')

