






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 							lowercase__  (	self		:       Union[str, Any]    ):

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




				@property
				def 							lowercase__  (	self		:       Tuple    ):

								'''simple docstring'''
								lowercase__  					=     1
								lowercase__  					=     3
								lowercase__  					=     (32, 32)

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




				@property
				def 							lowercase__  (	self		:       Tuple    ):

								'''simple docstring'''
								torch.manual_seed(0    )
								lowercase__  					=     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=lowerCamelCase,    only_cross_attention=(True, True, False),    num_class_embeds=100,    )
								return model




				@property
				def 							lowercase__  (	self		:       Tuple    ):

								'''simple docstring'''
								torch.manual_seed(0    )
								lowercase__  					=     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 							lowercase__  (	self		:       Union[str, Any]    ):

								'''simple docstring'''
								torch.manual_seed(0    )
								lowercase__  					=     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=1_000,    hidden_act='''gelu''',    projection_dim=512,    )
								return CLIPTextModel(lowerCamelCase    )




				def 							lowercase__  (	self		:       List[str]    ):

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

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

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

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

								lowercase__  					=     output.images

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

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

								lowercase__  					=     low_res_image.size[0] * 4
								assert image.shape == (1, expected_height_width, expected_height_width, 3)
								lowercase__  					=     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 							lowercase__  (	self		:       Any    ):

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

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

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

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

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




				@unittest.skipIf(torch_device != '''cuda''',    '''This test requires a GPU'''    )
				def 							lowercase__  (	self		:       Optional[Any]    ):

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

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

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

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

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

								lowercase__  					=     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 							lowercase__  (	self		:       List[str]    ):

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




				def 							lowercase__  (	self		:       int    ):

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

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

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

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

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




				def 							lowercase__  (	self		:       int    ):

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

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

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

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

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




				def 							lowercase__  (	self		:       List[str]    ):

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

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

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

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

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

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












def     a     (		lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				lowercase__  					=     len(lowerCamelCase_							)
				lowercase__  					=     [[False] * (required_sum + 1) for _ in range(arr_len + 1							)]

				# for each arr value, a sum of zero(0) can be formed by not taking any element
				# hence True/1
				for i in range(arr_len + 1							):
								lowercase__  					=     True

				# sum is not zero and set is empty then false
				for i in range(1						,  required_sum + 1							):
								lowercase__  					=     False

				for i in range(1						,  arr_len + 1							):
								for j in range(1						,  required_sum + 1							):
												if arr[i - 1] > j:
																lowercase__  					=     subset[i - 1][j]
												if arr[i - 1] <= j:
																lowercase__  					=     subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

				return subset[arr_len][required_sum]


if __name__ == "__main__":
							import doctest

							doctest.testmod()




