


'''simple docstring'''



import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()


class 						_snake_case   (       a__    ,				a__    ,				a__    ,				unittest.TestCase		):
					lowerCAmelCase :Union[str, Any]						=   StableUnCLIPPipeline
					lowerCAmelCase :int						=   TEXT_TO_IMAGE_PARAMS
					lowerCAmelCase :List[Any]						=   TEXT_TO_IMAGE_BATCH_PARAMS
					lowerCAmelCase :Optional[int]						=   TEXT_TO_IMAGE_IMAGE_PARAMS
					lowerCAmelCase :str						=   TEXT_TO_IMAGE_IMAGE_PARAMS

					# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
					lowerCAmelCase :str						=   False




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   List[str]       				=       32
								UpperCAmelCase__					:   Any       				=       embedder_hidden_size

								# prior components

								torch.manual_seed(0)
								UpperCAmelCase__					:   str       				=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

								torch.manual_seed(0)
								UpperCAmelCase__					:   Any       				=       CLIPTextModelWithProjection(
								    CLIPTextConfig(
								        bos_token_id=0							,							eos_token_id=2							,							hidden_size=_lowerCamelCase							,							projection_dim=_lowerCamelCase							,							intermediate_size=37							,							layer_norm_eps=1e-0_5							,							num_attention_heads=4							,							num_hidden_layers=5							,							pad_token_id=1							,							vocab_size=1000							,							))

								torch.manual_seed(0)
								UpperCAmelCase__					:   Optional[Any]       				=       PriorTransformer(
								    num_attention_heads=2							,							attention_head_dim=12							,							embedding_dim=_lowerCamelCase							,							num_layers=1							,							)

								torch.manual_seed(0)
								UpperCAmelCase__					:   Tuple       				=       DDPMScheduler(
								    variance_type="""fixed_small_log"""							,							prediction_type="""sample"""							,							num_train_timesteps=1000							,							clip_sample=_lowerCamelCase							,							clip_sample_range=5.0							,							beta_schedule="""squaredcos_cap_v2"""							,							)

								# regular denoising components

								torch.manual_seed(0)
								UpperCAmelCase__					:   Optional[Any]       				=       StableUnCLIPImageNormalizer(embedding_dim=_lowerCamelCase)
								UpperCAmelCase__					:   Any       				=       DDPMScheduler(beta_schedule="""squaredcos_cap_v2""")

								torch.manual_seed(0)
								UpperCAmelCase__					:   Tuple       				=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

								torch.manual_seed(0)
								UpperCAmelCase__					:   Dict       				=       CLIPTextModel(
								    CLIPTextConfig(
								        bos_token_id=0							,							eos_token_id=2							,							hidden_size=_lowerCamelCase							,							projection_dim=32							,							intermediate_size=37							,							layer_norm_eps=1e-0_5							,							num_attention_heads=4							,							num_hidden_layers=5							,							pad_token_id=1							,							vocab_size=1000							,							))

								torch.manual_seed(0)
								UpperCAmelCase__					:   Optional[Any]       				=       UNetaDConditionModel(
								    sample_size=32							,							in_channels=4							,							out_channels=4							,							down_block_types=("""CrossAttnDownBlock2D""", """DownBlock2D""")							,							up_block_types=("""UpBlock2D""", """CrossAttnUpBlock2D""")							,							block_out_channels=(32, 64)							,							attention_head_dim=(2, 4)							,							class_embed_type="""projection"""							,							projection_class_embeddings_input_dim=embedder_projection_dim * 2							,							cross_attention_dim=_lowerCamelCase							,							layers_per_block=1							,							upcast_attention=_lowerCamelCase							,							use_linear_projection=_lowerCamelCase							,							)

								torch.manual_seed(0)
								UpperCAmelCase__					:   List[Any]       				=       DDIMScheduler(
								    beta_schedule="""scaled_linear"""							,							beta_start=0.00085							,							beta_end=0.012							,							prediction_type="""v_prediction"""							,							set_alpha_to_one=_lowerCamelCase							,							steps_offset=1							,							)

								torch.manual_seed(0)
								UpperCAmelCase__					:   str       				=       AutoencoderKL()

								UpperCAmelCase__					:   List[str]       				=       {
								    # prior components
								    """prior_tokenizer""": prior_tokenizer,
								    """prior_text_encoder""": prior_text_encoder,
								    """prior""": prior,
								    """prior_scheduler""": prior_scheduler,
								    # image noising components
								    """image_normalizer""": image_normalizer,
								    """image_noising_scheduler""": image_noising_scheduler,
								    # regular denoising components
								    """tokenizer""": tokenizer,
								    """text_encoder""": text_encoder,
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """vae""": vae,
								}

								return components




					def 			snake_case__  ( self							,							_lowerCamelCase							,							_lowerCamelCase=0):
								if str(_lowerCamelCase).startswith("""mps"""):
											UpperCAmelCase__					:   Tuple       				=       torch.manual_seed(_lowerCamelCase)
								else:
											UpperCAmelCase__					:   str       				=       torch.Generator(device=_lowerCamelCase).manual_seed(_lowerCamelCase)
								UpperCAmelCase__					:   Optional[int]       				=       {
								    """prompt""": """A painting of a squirrel eating a burger""",
								    """generator""": generator,
								    """num_inference_steps""": 2,
								    """prior_num_inference_steps""": 2,
								    """output_type""": """numpy""",
								}
								return inputs




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   Dict       				=       torch_device == """cpu"""

								self._test_attention_slicing_forward_pass(test_max_difference=_lowerCamelCase)




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   List[Any]       				=       torch_device in ["""cpu""", """mps"""]

								self._test_inference_batch_single_identical(test_max_difference=_lowerCamelCase)


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




					def 			snake_case__  ( self):
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()




					def 			snake_case__  ( self):
								UpperCAmelCase__					:   List[Any]       				=       load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy""")

								UpperCAmelCase__					:   Union[str, Any]       				=       StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""							,							torch_dtype=torch.floataa)
								pipe.to(_lowerCamelCase)
								pipe.set_progress_bar_config(disable=_lowerCamelCase)
								# stable unclip will oom when integration tests are run on a V100,
								# so turn on memory savings
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								UpperCAmelCase__					:   Optional[int]       				=       torch.Generator(device="""cpu""").manual_seed(0)
								UpperCAmelCase__					:   Union[str, Any]       				=       pipe("""anime turle"""							,							generator=_lowerCamelCase							,							output_type="""np""")

								UpperCAmelCase__					:   List[str]       				=       output.images[0]

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

								assert_mean_pixel_difference(_lowerCamelCase							,							_lowerCamelCase)




					def 			snake_case__  ( self):
								torch.cuda.empty_cache()
								torch.cuda.reset_max_memory_allocated()
								torch.cuda.reset_peak_memory_stats()

								UpperCAmelCase__					:   List[str]       				=       StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""							,							torch_dtype=torch.floataa)
								UpperCAmelCase__					:   Optional[int]       				=       pipe.to(_lowerCamelCase)
								pipe.set_progress_bar_config(disable=_lowerCamelCase)
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								UpperCAmelCase__					:   List[str]       				=       pipe(
								    """anime turtle"""							,							prior_num_inference_steps=2							,							num_inference_steps=2							,							output_type="""np"""							,							)

								UpperCAmelCase__					:   Optional[Any]       				=       torch.cuda.max_memory_allocated()
								# make sure that less than 7 GB is allocated
								assert mem_bytes < 7 * 10**9



'''simple docstring'''



def       _UpperCamelCase (						UpperCamelCase__   ):
			UpperCAmelCase__					:   List[str]       				=       len(UpperCamelCase__   )
			UpperCAmelCase__					:   List[Any]       				=       sum(UpperCamelCase__   )

			UpperCAmelCase__					:   List[str]       				=       [[False for x in range(s + 1   )] for y in range(n + 1   )]

			for i in range(1	, n + 1   ):
						UpperCAmelCase__					:   int       				=       True

			for i in range(1	, s + 1   ):
						UpperCAmelCase__					:   Dict       				=       False

			for i in range(1	, n + 1   ):
						for j in range(1	, s + 1   ):
									UpperCAmelCase__					:   int       				=       dp[i][j - 1]

									if arr[i - 1] <= j:
												UpperCAmelCase__					:   str       				=       dp[i][j] or dp[i - 1][j - arr[i - 1]]

			for j in range(int(s / 2   )	, -1	, -1   ):
						if dp[n][j] is True:
									UpperCAmelCase__					:   int       				=       s - 2 * j
									break

			return diff