
'''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 	__lowercase				(  _lowercase      ,     _lowercase      ,     _lowercase      ,     unittest.TestCase    ):
			lowerCamelCase			:		int	      =			StableUnCLIPPipeline
			lowerCamelCase			:		Optional[Any]	      =			TEXT_TO_IMAGE_PARAMS
			lowerCamelCase			:		Union[str, Any]	      =			TEXT_TO_IMAGE_BATCH_PARAMS
			lowerCamelCase			:		str	      =			TEXT_TO_IMAGE_IMAGE_PARAMS
			lowerCamelCase			:		List[Any]	      =			TEXT_TO_IMAGE_IMAGE_PARAMS

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

			def        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      List[Any]     =		3_2
								lowerCamelCase_					:      int     =		embedder_hidden_size

								# prior components

								torch.manual_seed(0      )
								lowerCamelCase_					:      Any     =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

								torch.manual_seed(0      )
								lowerCamelCase_					:      List[str]     =		CLIPTextModelWithProjection(
								    CLIPTextConfig(
								        bos_token_id=0			,   eos_token_id=2			,   hidden_size=A			,   projection_dim=A			,   intermediate_size=3_7			,   layer_norm_eps=1E-05			,   num_attention_heads=4			,   num_hidden_layers=5			,   pad_token_id=1			,   vocab_size=1_0_0_0			,   )      )

								torch.manual_seed(0      )
								lowerCamelCase_					:      Any     =		PriorTransformer(
								    num_attention_heads=2			,   attention_head_dim=1_2			,   embedding_dim=A			,   num_layers=1			,   )

								torch.manual_seed(0      )
								lowerCamelCase_					:      Optional[Any]     =		DDPMScheduler(
								    variance_type='''fixed_small_log'''			,   prediction_type='''sample'''			,   num_train_timesteps=1_0_0_0			,   clip_sample=A			,   clip_sample_range=5.0			,   beta_schedule='''squaredcos_cap_v2'''			,   )

								# regular denoising components

								torch.manual_seed(0      )
								lowerCamelCase_					:      Optional[Any]     =		StableUnCLIPImageNormalizer(embedding_dim=A      )
								lowerCamelCase_					:      str     =		DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''      )

								torch.manual_seed(0      )
								lowerCamelCase_					:      List[Any]     =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

								torch.manual_seed(0      )
								lowerCamelCase_					:      List[Any]     =		CLIPTextModel(
								    CLIPTextConfig(
								        bos_token_id=0			,   eos_token_id=2			,   hidden_size=A			,   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=1_0_0_0			,   )      )

								torch.manual_seed(0      )
								lowerCamelCase_					:      List[Any]     =		UNetaDConditionModel(
								    sample_size=3_2			,   in_channels=4			,   out_channels=4			,   down_block_types=('''CrossAttnDownBlock2D''', '''DownBlock2D''')			,   up_block_types=('''UpBlock2D''', '''CrossAttnUpBlock2D''')			,   block_out_channels=(3_2, 6_4)			,   attention_head_dim=(2, 4)			,   class_embed_type='''projection'''			,   projection_class_embeddings_input_dim=embedder_projection_dim * 2			,   cross_attention_dim=A			,   layers_per_block=1			,   upcast_attention=A			,   use_linear_projection=A			,   )

								torch.manual_seed(0      )
								lowerCamelCase_					:      Dict     =		DDIMScheduler(
								    beta_schedule='''scaled_linear'''			,   beta_start=0.0_00_85			,   beta_end=0.0_12			,   prediction_type='''v_prediction'''			,   set_alpha_to_one=A			,   steps_offset=1			,   )

								torch.manual_seed(0      )
								lowerCamelCase_					:      Optional[int]     =		AutoencoderKL()

								lowerCamelCase_					:      List[Any]     =		{
								    # 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        UpperCAmelCase__ (self			,   A			,   A=0      ):
								if str(A      ).startswith('''mps'''      ):
													lowerCamelCase_					:      List[str]     =		torch.manual_seed(A      )
								else:
													lowerCamelCase_					:      Optional[Any]     =		torch.Generator(device=A      ).manual_seed(A      )
								lowerCamelCase_					:      Union[str, Any]     =		{
								    '''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        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      Optional[int]     =		torch_device == '''cpu'''

								self._test_attention_slicing_forward_pass(test_max_difference=A      )






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

								self._test_inference_batch_single_identical(test_max_difference=A      )

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

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

			def        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      Dict     =		load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'''      )

								lowerCamelCase_					:      Optional[int]     =		StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''			,   torch_dtype=torch.floataa      )
								pipe.to(A      )
								pipe.set_progress_bar_config(disable=A      )
								# 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()

								lowerCamelCase_					:      List[Any]     =		torch.Generator(device='''cpu'''      ).manual_seed(0      )
								lowerCamelCase_					:      Any     =		pipe('''anime turle'''			,   generator=A			,   output_type='''np'''      )

								lowerCamelCase_					:      Any     =		output.images[0]

								assert image.shape == (7_6_8, 7_6_8, 3)

								assert_mean_pixel_difference(A			,   A      )






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

								lowerCamelCase_					:      Optional[int]     =		StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''			,   torch_dtype=torch.floataa      )
								lowerCamelCase_					:      Dict     =		pipe.to(A      )
								pipe.set_progress_bar_config(disable=A      )
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								lowerCamelCase_					:      Tuple     =		pipe(
								    '''anime turtle'''			,   prior_num_inference_steps=2			,   num_inference_steps=2			,   output_type='''np'''			,   )

								lowerCamelCase_					:      List[Any]     =		torch.cuda.max_memory_allocated()
								# make sure that less than 7 GB is allocated
								assert mem_bytes < 7 * 1_0**9




'''simple docstring'''


def lowercase_	(   _lowercase			,       _lowercase				)     ->							Dict:
					'''simple docstring'''

					lowerCamelCase_					:      List[Any]     =		0
					while b > 0:
										if b & 1:
															res += a

										a += a
										b >>= 1

					return res




def lowercase_	(   _lowercase			,       _lowercase			,       _lowercase				)     ->							Optional[Any]:
					'''simple docstring'''

					lowerCamelCase_					:      str     =		0
					while b > 0:
										if b & 1:
															lowerCamelCase_					:      Optional[int]     =		((res % c) + (a % c)) % c

										a += a
										b >>= 1

					return res


