



'''simple docstring'''



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()








'''simple docstring'''



import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, XLMRobertaTokenizer

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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


enable_full_determinism()





class _UpperCamelCase		(     A      ,       A      ,       A      ,       unittest.TestCase		):





				'''simple docstring'''





				lowerCAmelCase__					    =    AltDiffusionPipeline
				lowerCAmelCase__					    =    TEXT_TO_IMAGE_PARAMS
				lowerCAmelCase__					    =    TEXT_TO_IMAGE_BATCH_PARAMS
				lowerCAmelCase__					    =    TEXT_TO_IMAGE_IMAGE_PARAMS
				lowerCAmelCase__					    =    TEXT_TO_IMAGE_IMAGE_PARAMS

				def 				__lowerCamelCase     (							self  :  Union[str, Any]):







											'''simple docstring'''

											torch.manual_seed(0)
											__lowercase       	=UNetaDConditionModel(
											    block_out_channels=(3_2, 6_4)  ,       layers_per_block=2  ,       sample_size=3_2  ,       in_channels=4  ,       out_channels=4  ,       down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')  ,       up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')  ,       cross_attention_dim=3_2  ,       )
											__lowercase       	=DDIMScheduler(
											    beta_start=0.0_0085  ,       beta_end=0.012  ,       beta_schedule='scaled_linear'  ,       clip_sample=_lowerCAmelCase  ,       set_alpha_to_one=_lowerCAmelCase  ,       )
											torch.manual_seed(0)
											__lowercase       	=AutoencoderKL(
											    block_out_channels=[3_2, 6_4]  ,       in_channels=3  ,       out_channels=3  ,       down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']  ,       up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']  ,       latent_channels=4  ,       )

											# TODO: address the non-deterministic text encoder (fails for save-load tests)
											# torch.manual_seed(0)
											# text_encoder_config = RobertaSeriesConfig(
											#     hidden_size=32,
											#     project_dim=32,
											#     intermediate_size=37,
											#     layer_norm_eps=1e-05,
											#     num_attention_heads=4,
											#     num_hidden_layers=5,
											#     vocab_size=5002,
											# )
											# text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

											torch.manual_seed(0)
											__lowercase       	=CLIPTextConfig(
											    bos_token_id=0  ,       eos_token_id=2  ,       hidden_size=3_2  ,       projection_dim=3_2  ,       intermediate_size=3_7  ,       layer_norm_eps=1e-05  ,       num_attention_heads=4  ,       num_hidden_layers=5  ,       pad_token_id=1  ,       vocab_size=5_0_0_2  ,       )
											__lowercase       	=CLIPTextModel(_lowerCAmelCase)

											__lowercase       	=XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta')
											__lowercase       	=7_7

											__lowercase       	={
											    'unet': unet,
											    'scheduler': scheduler,
											    'vae': vae,
											    'text_encoder': text_encoder,
											    'tokenizer': tokenizer,
											    'safety_checker': None,
											    'feature_extractor': None,
											}
											return components

				def 				__lowerCamelCase     (							self  :  List[Any]  ,       _lowerCAmelCase  :  Union[str, Any]  ,       _lowerCAmelCase  :  Dict=0):







											'''simple docstring'''

											if str(_lowerCAmelCase).startswith('mps'):
																		__lowercase       	=torch.manual_seed(_lowerCAmelCase)
											else:
																		__lowercase       	=torch.Generator(device=_lowerCAmelCase).manual_seed(_lowerCAmelCase)
											__lowercase       	={
											    'prompt': 'A painting of a squirrel eating a burger',
											    'generator': generator,
											    'num_inference_steps': 2,
											    'guidance_scale': 6.0,
											    'output_type': 'numpy',
											}
											return inputs

				def 				__lowerCamelCase     (							self  :  List[str]):







											'''simple docstring'''

											super().test_attention_slicing_forward_pass(expected_max_diff=3e-3)

				def 				__lowerCamelCase     (							self  :  Optional[int]):







											'''simple docstring'''

											super().test_inference_batch_single_identical(expected_max_diff=3e-3)

				def 				__lowerCamelCase     (							self  :  Optional[Any]):







											'''simple docstring'''

											__lowercase       	='cpu'  # ensure determinism for the device-dependent torch.Generator

											__lowercase       	=self.get_dummy_components()
											torch.manual_seed(0)
											__lowercase       	=RobertaSeriesConfig(
											    hidden_size=3_2  ,       project_dim=3_2  ,       intermediate_size=3_7  ,       layer_norm_eps=1e-05  ,       num_attention_heads=4  ,       num_hidden_layers=5  ,       vocab_size=5_0_0_2  ,       )
											# TODO: remove after fixing the non-deterministic text encoder
											__lowercase       	=RobertaSeriesModelWithTransformation(_lowerCAmelCase)
											__lowercase       	=text_encoder

											__lowercase       	=AltDiffusionPipeline(**_lowerCAmelCase)
											__lowercase       	=alt_pipe.to(_lowerCAmelCase)
											alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase)

											__lowercase       	=self.get_dummy_inputs(_lowerCAmelCase)
											__lowercase       	='A photo of an astronaut'
											__lowercase       	=alt_pipe(**_lowerCAmelCase)
											__lowercase       	=output.images
											__lowercase       	=image[0, -3:, -3:, -1]

											assert image.shape == (1, 6_4, 6_4, 3)
											__lowercase       	=np.array(
											    [0.574_8162, 0.6044_7145, 0.4882_1217, 0.5010_0636, 0.543_1185, 0.4576_3683, 0.4965_7696, 0.4813_2733, 0.4757_3093])

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

				def 				__lowerCamelCase     (							self  :  str):







											'''simple docstring'''

											__lowercase       	='cpu'  # ensure determinism for the device-dependent torch.Generator

											__lowercase       	=self.get_dummy_components()
											__lowercase       	=PNDMScheduler(skip_prk_steps=_lowerCAmelCase)
											torch.manual_seed(0)
											__lowercase       	=RobertaSeriesConfig(
											    hidden_size=3_2  ,       project_dim=3_2  ,       intermediate_size=3_7  ,       layer_norm_eps=1e-05  ,       num_attention_heads=4  ,       num_hidden_layers=5  ,       vocab_size=5_0_0_2  ,       )
											# TODO: remove after fixing the non-deterministic text encoder
											__lowercase       	=RobertaSeriesModelWithTransformation(_lowerCAmelCase)
											__lowercase       	=text_encoder
											__lowercase       	=AltDiffusionPipeline(**_lowerCAmelCase)
											__lowercase       	=alt_pipe.to(_lowerCAmelCase)
											alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase)

											__lowercase       	=self.get_dummy_inputs(_lowerCAmelCase)
											__lowercase       	=alt_pipe(**_lowerCAmelCase)
											__lowercase       	=output.images
											__lowercase       	=image[0, -3:, -3:, -1]

											assert image.shape == (1, 6_4, 6_4, 3)
											__lowercase       	=np.array(
											    [0.5160_5093, 0.570_7241, 0.4736_5507, 0.5057_8886, 0.563_3877, 0.464_2503, 0.518_2081, 0.4876_3484, 0.4908_4237])

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





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





				'''simple docstring'''





				def 				__lowerCamelCase     (							self  :  str):







											'''simple docstring'''

											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()

				def 				__lowerCamelCase     (							self  :  Union[str, Any]):







											'''simple docstring'''

											__lowercase       	=AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'  ,       safety_checker=_lowerCAmelCase)
											__lowercase       	=alt_pipe.to(_lowerCAmelCase)
											alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase)

											__lowercase       	='A painting of a squirrel eating a burger'
											__lowercase       	=torch.manual_seed(0)
											__lowercase       	=alt_pipe([prompt]  ,       generator=_lowerCAmelCase  ,       guidance_scale=6.0  ,       num_inference_steps=2_0  ,       output_type='np')

											__lowercase       	=output.images

											__lowercase       	=image[0, -3:, -3:, -1]

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__lowercase       	=np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586])

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

				def 				__lowerCamelCase     (							self  :  Dict):







											'''simple docstring'''

											__lowercase       	=DDIMScheduler.from_pretrained('BAAI/AltDiffusion'  ,       subfolder='scheduler')

											__lowercase       	=AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'  ,       scheduler=_lowerCAmelCase  ,       safety_checker=_lowerCAmelCase)
											__lowercase       	=alt_pipe.to(_lowerCAmelCase)
											alt_pipe.set_progress_bar_config(disable=_lowerCAmelCase)

											__lowercase       	='A painting of a squirrel eating a burger'
											__lowercase       	=torch.manual_seed(0)

											__lowercase       	=alt_pipe([prompt]  ,       generator=_lowerCAmelCase  ,       num_inference_steps=2  ,       output_type='numpy')
											__lowercase       	=output.images

											__lowercase       	=image[0, -3:, -3:, -1]

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__lowercase       	=np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323])

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



