


'''simple docstring'''
def       a				(      __a			, __a       )  ->     str:



					'''simple docstring'''






					if a < 0 or b < 0:
										raise ValueError('''the value of both inputs must be positive'''       )

					UpperCamelCase__       :List[str]							 =			str(bin(__a       )       )[2:]  # remove the leading "0b"
					UpperCamelCase__       :Optional[int]							 =			str(bin(__a       )       )[2:]  # remove the leading "0b"

					UpperCamelCase__       :List[Any]							 =			max(len(__a       )			, len(__a       )       )

					return "0b" + "".join(
					    str(int(char_a != char_b       )       )
					    for char_a, char_b in zip(a_binary.zfill(__a       )			, b_binary.zfill(__a       )       )       )


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        lowercase     (							A__     ,		A__     ,		A__     ,		unittest.TestCase ):

		"""simple docstring"""

		_a   			=    AltDiffusionPipeline
		_a   			=    TEXT_TO_IMAGE_PARAMS
		_a   			=    TEXT_TO_IMAGE_BATCH_PARAMS
		_a   			=    TEXT_TO_IMAGE_IMAGE_PARAMS
		_a   			=    TEXT_TO_IMAGE_IMAGE_PARAMS




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							torch.manual_seed(0							)
							UpperCamelCase__       :List[str]							 =			UNetaDConditionModel(
							    block_out_channels=(32, 64)   ,       layers_per_block=2   ,       sample_size=32   ,       in_channels=4   ,       out_channels=4   ,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')   ,       up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')   ,       cross_attention_dim=32   ,       )
							UpperCamelCase__       :int							 =			DDIMScheduler(
							    beta_start=0.00085   ,       beta_end=0.012   ,       beta_schedule='''scaled_linear'''   ,       clip_sample=UpperCamelCase_   ,       set_alpha_to_one=UpperCamelCase_   ,       )
							torch.manual_seed(0							)
							UpperCamelCase__       :List[str]							 =			AutoencoderKL(
							    block_out_channels=[32, 64]   ,       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							)
							UpperCamelCase__       :Union[str, Any]							 =			CLIPTextConfig(
							    bos_token_id=0   ,       eos_token_id=2   ,       hidden_size=32   ,       projection_dim=32   ,       intermediate_size=37   ,       layer_norm_eps=1e-05   ,       num_attention_heads=4   ,       num_hidden_layers=5   ,       pad_token_id=1   ,       vocab_size=5002   ,       )
							UpperCamelCase__       :Optional[Any]							 =			CLIPTextModel(UpperCamelCase_							)

							UpperCamelCase__       :int							 =			XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''							)
							UpperCamelCase__       :Dict							 =			77

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




		def    lowerCAmelCase__    (		self   ,       UpperCamelCase_   ,       UpperCamelCase_=0							):

							'''simple docstring'''


							if str(UpperCamelCase_							).startswith('''mps'''							):
												UpperCamelCase__       :Dict							 =			torch.manual_seed(UpperCamelCase_							)
							else:
												UpperCamelCase__       :List[str]							 =			torch.Generator(device=UpperCamelCase_							).manual_seed(UpperCamelCase_							)
							UpperCamelCase__       :Optional[int]							 =			{
							    '''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							):

							'''simple docstring'''


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




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


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




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							UpperCamelCase__       :str							 =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator

							UpperCamelCase__       :Tuple							 =			self.get_dummy_components()
							torch.manual_seed(0							)
							UpperCamelCase__       :Dict							 =			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   ,       )
							# TODO: remove after fixing the non-deterministic text encoder
							UpperCamelCase__       :Union[str, Any]							 =			RobertaSeriesModelWithTransformation(UpperCamelCase_							)
							UpperCamelCase__       :Union[str, Any]							 =			text_encoder

							UpperCamelCase__       :Any							 =			AltDiffusionPipeline(**UpperCamelCase_							)
							UpperCamelCase__       :List[Any]							 =			alt_pipe.to(UpperCamelCase_							)
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__       :int							 =			self.get_dummy_inputs(UpperCamelCase_							)
							UpperCamelCase__       :Dict							 =			'''A photo of an astronaut'''
							UpperCamelCase__       :Union[str, Any]							 =			alt_pipe(**UpperCamelCase_							)
							UpperCamelCase__       :Any							 =			output.images
							UpperCamelCase__       :List[Any]							 =			image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							UpperCamelCase__       :List[Any]							 =			np.array(
							    [0.5748162, 0.60447145, 0.48821217, 0.50100636, 0.5431185, 0.45763683, 0.49657696, 0.48132733, 0.47573093]							)

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




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							UpperCamelCase__       :str							 =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator

							UpperCamelCase__       :int							 =			self.get_dummy_components()
							UpperCamelCase__       :Union[str, Any]							 =			PNDMScheduler(skip_prk_steps=UpperCamelCase_							)
							torch.manual_seed(0							)
							UpperCamelCase__       :Dict							 =			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   ,       )
							# TODO: remove after fixing the non-deterministic text encoder
							UpperCamelCase__       :str							 =			RobertaSeriesModelWithTransformation(UpperCamelCase_							)
							UpperCamelCase__       :Union[str, Any]							 =			text_encoder
							UpperCamelCase__       :Union[str, Any]							 =			AltDiffusionPipeline(**UpperCamelCase_							)
							UpperCamelCase__       :Optional[int]							 =			alt_pipe.to(UpperCamelCase_							)
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__       :List[str]							 =			self.get_dummy_inputs(UpperCamelCase_							)
							UpperCamelCase__       :Optional[Any]							 =			alt_pipe(**UpperCamelCase_							)
							UpperCamelCase__       :str							 =			output.images
							UpperCamelCase__       :int							 =			image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							UpperCamelCase__       :List[Any]							 =			np.array(
							    [0.51605093, 0.5707241, 0.47365507, 0.50578886, 0.5633877, 0.4642503, 0.5182081, 0.48763484, 0.49084237]							)

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



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

		"""simple docstring"""

		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


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




		def    lowerCAmelCase__    (		self							):

							'''simple docstring'''


							UpperCamelCase__       :Optional[Any]							 =			AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''   ,       safety_checker=UpperCamelCase_							)
							UpperCamelCase__       :str							 =			alt_pipe.to(UpperCamelCase_							)
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__       :int							 =			'''A painting of a squirrel eating a burger'''
							UpperCamelCase__       :int							 =			torch.manual_seed(0							)
							UpperCamelCase__       :Optional[Any]							 =			alt_pipe([prompt]   ,       generator=UpperCamelCase_   ,       guidance_scale=6.0   ,       num_inference_steps=20   ,       output_type='''np'''							)

							UpperCamelCase__       :Union[str, Any]							 =			output.images

							UpperCamelCase__       :Optional[Any]							 =			image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							UpperCamelCase__       :Union[str, Any]							 =			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							):

							'''simple docstring'''


							UpperCamelCase__       :Any							 =			DDIMScheduler.from_pretrained('''BAAI/AltDiffusion'''   ,       subfolder='''scheduler'''							)

							UpperCamelCase__       :List[str]							 =			AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''   ,       scheduler=UpperCamelCase_   ,       safety_checker=UpperCamelCase_							)
							UpperCamelCase__       :Dict							 =			alt_pipe.to(UpperCamelCase_							)
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__       :List[Any]							 =			'''A painting of a squirrel eating a burger'''
							UpperCamelCase__       :str							 =			torch.manual_seed(0							)

							UpperCamelCase__       :Optional[int]							 =			alt_pipe([prompt]   ,       generator=UpperCamelCase_   ,       num_inference_steps=2   ,       output_type='''numpy'''							)
							UpperCamelCase__       :Any							 =			output.images

							UpperCamelCase__       :int							 =			image[0, -3:, -3:, -1]

							assert image.shape == (1, 512, 512, 3)
							UpperCamelCase__       :int							 =			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