



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   ):
	return 1 if input_a == input_a else 0



def    snake_case_				(    ):
	assert xnor_gate(0  ,	0   ) == 1
	assert xnor_gate(0  ,	1   ) == 0
	assert xnor_gate(1  ,	0   ) == 0
	assert xnor_gate(1  ,	1   ) == 1


if __name__ == "__main__":
	print(xnor_gate(0, 0))
	print(xnor_gate(0, 1))
	print(xnor_gate(1, 0))
	print(xnor_gate(1, 1))








import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()

class   _A   ( _lowercase  ,						_lowercase  ,						_lowercase  ,						unittest.TestCase	):


						'''simple docstring'''





						_snake_case			:     Dict      							=      StableUnCLIPImgaImgPipeline
						_snake_case			:     List[Any]      							=      TEXT_GUIDED_IMAGE_VARIATION_PARAMS
						_snake_case			:     Optional[Any]      							=      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
						_snake_case			:     int      							=      frozenset(
						    []	)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
						_snake_case			:     int      							=      frozenset([]	)



						def     _snake_case	(	self	:							Tuple	):






							'''simple docstring'''



							__lowercase		       =			32
							__lowercase		       =			embedder_hidden_size

							# image encoding components

							__lowercase		       =			CLIPImageProcessor(crop_size=32							,      size=32	)

							torch.manual_seed(0	)
							__lowercase		       =			CLIPVisionModelWithProjection(
							    CLIPVisionConfig(
							        hidden_size=lowerCamelCase							,      projection_dim=lowerCamelCase							,      num_hidden_layers=5							,      num_attention_heads=4							,      image_size=32							,      intermediate_size=37							,      patch_size=1							,      )	)

							# regular denoising components

							torch.manual_seed(0	)
							__lowercase		       =			StableUnCLIPImageNormalizer(embedding_dim=lowerCamelCase	)
							__lowercase		       =			DDPMScheduler(beta_schedule="squaredcos_cap_v2"	)

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

							torch.manual_seed(0	)
							__lowercase		       =			CLIPTextModel(
							    CLIPTextConfig(
							        bos_token_id=0							,      eos_token_id=2							,      hidden_size=lowerCamelCase							,      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=1_000							,      )	)

							torch.manual_seed(0	)
							__lowercase		       =			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	)
							__lowercase		       =			DDIMScheduler(
							    beta_schedule="scaled_linear"							,      beta_start=0.0_0085							,      beta_end=0.012							,      prediction_type="v_prediction"							,      set_alpha_to_one=lowerCamelCase							,      steps_offset=1							,      )

							torch.manual_seed(0	)
							__lowercase		       =			AutoencoderKL()

							__lowercase		       =			{
							    # image encoding components
							    "feature_extractor": feature_extractor,
							    "image_encoder": image_encoder.eval(),
							    # image noising components
							    "image_normalizer": image_normalizer.eval(),
							    "image_noising_scheduler": image_noising_scheduler,
							    # regular denoising components
							    "tokenizer": tokenizer,
							    "text_encoder": text_encoder.eval(),
							    "unet": unet.eval(),
							    "scheduler": scheduler,
							    "vae": vae.eval(),
							}

							return components



						def     _snake_case	(	self	:							List[Any]							,      lowerCamelCase	:							str							,      lowerCamelCase	:							Any=0							,      lowerCamelCase	:							Union[str, Any]=True	):






							'''simple docstring'''



							if str(lowerCamelCase	).startswith("mps"	):
								__lowercase		       =			torch.manual_seed(lowerCamelCase	)
							else:
								__lowercase		       =			torch.Generator(device=lowerCamelCase	).manual_seed(lowerCamelCase	)

							__lowercase		       =			floats_tensor((1, 3, 32, 32)							,      rng=random.Random(lowerCamelCase	)	).to(lowerCamelCase	)

							if pil_image:
								__lowercase		       =			input_image * 0.5 + 0.5
								__lowercase		       =			input_image.clamp(0							,      1	)
								__lowercase		       =			input_image.cpu().permute(0							,      2							,      3							,      1	).float().numpy()
								__lowercase		       =			DiffusionPipeline.numpy_to_pil(lowerCamelCase	)[0]

							return {
							    "prompt": "An anime racoon running a marathon",
							    "image": input_image,
							    "generator": generator,
							    "num_inference_steps": 2,
							    "output_type": "np",
							}



						@skip_mps
						def     _snake_case	(	self	:							Optional[Any]	):






							'''simple docstring'''



							__lowercase		       =			"cpu"  # ensure determinism for the device-dependent torch.Generator
							__lowercase		       =			self.get_dummy_components()
							__lowercase		       =			StableUnCLIPImgaImgPipeline(**lowerCamelCase	)
							__lowercase		       =			sd_pipe.to(lowerCamelCase	)
							sd_pipe.set_progress_bar_config(disable=lowerCamelCase	)

							__lowercase		       =			self.get_dummy_inputs(lowerCamelCase	)
							inputs.update({"image_embeds": None}	)
							__lowercase		       =			sd_pipe(**lowerCamelCase	).images
							__lowercase		       =			image[0, -3:, -3:, -1]

							assert image.shape == (1, 32, 32, 3)
							__lowercase		       =			np.array([0.3872, 0.7224, 0.5601, 0.4741, 0.6872, 0.5814, 0.4636, 0.3867, 0.5078]	)

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



						def     _snake_case	(	self	:							Dict	):






							'''simple docstring'''



							__lowercase		       =			torch_device in ["cpu", "mps"]

							self._test_attention_slicing_forward_pass(test_max_difference=lowerCamelCase	)



						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							__lowercase		       =			torch_device in ["cpu", "mps"]

							self._test_inference_batch_single_identical(test_max_difference=lowerCamelCase	)



						@unittest.skipIf(
						    torch_device != "cuda" or not is_xformers_available()							,      reason="XFormers attention is only available with CUDA and `xformers` installed"							,      )
						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							self._test_xformers_attention_forwardGenerator_pass(test_max_difference=lowerCamelCase	)

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


						'''simple docstring'''





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






							'''simple docstring'''



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



						def     _snake_case	(	self	:							Any	):






							'''simple docstring'''



							__lowercase		       =			load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"	)

							__lowercase		       =			load_numpy(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy"	)

							__lowercase		       =			StableUnCLIPImgaImgPipeline.from_pretrained(
							    "fusing/stable-unclip-2-1-l-img2img"							,      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()

							__lowercase		       =			torch.Generator(device="cpu"	).manual_seed(0	)
							__lowercase		       =			pipe(lowerCamelCase							,      "anime turle"							,      generator=lowerCamelCase							,      output_type="np"	)

							__lowercase		       =			output.images[0]

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

							assert_mean_pixel_difference(lowerCamelCase							,      lowerCamelCase	)



						def     _snake_case	(	self	:							Optional[Any]	):






							'''simple docstring'''



							__lowercase		       =			load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"	)

							__lowercase		       =			load_numpy(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy"	)

							__lowercase		       =			StableUnCLIPImgaImgPipeline.from_pretrained(
							    "fusing/stable-unclip-2-1-h-img2img"							,      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()

							__lowercase		       =			torch.Generator(device="cpu"	).manual_seed(0	)
							__lowercase		       =			pipe(lowerCamelCase							,      "anime turle"							,      generator=lowerCamelCase							,      output_type="np"	)

							__lowercase		       =			output.images[0]

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

							assert_mean_pixel_difference(lowerCamelCase							,      lowerCamelCase	)



						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							__lowercase		       =			load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"	)

							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()
							torch.cuda.reset_peak_memory_stats()

							__lowercase		       =			StableUnCLIPImgaImgPipeline.from_pretrained(
							    "fusing/stable-unclip-2-1-h-img2img"							,      torch_dtype=torch.floataa	)
							__lowercase		       =			pipe.to(lowerCamelCase	)
							pipe.set_progress_bar_config(disable=lowerCamelCase	)
							pipe.enable_attention_slicing()
							pipe.enable_sequential_cpu_offload()

							__lowercase		       =			pipe(
							    lowerCamelCase							,      "anime turtle"							,      num_inference_steps=2							,      output_type="np"							,      )

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



