




import gc
import random
import tempfile
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()






class       A      (		unittest.TestCase		):
     """simple docstring"""

     def 			__snake_case (     self	: List[Any]      )					->							Optional[int]:
           # clean up the VRAM after each test
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()




     @property
     def 			__snake_case (     self	: Dict      )					->							int:
           lowerCamelCase__   	=					1
           lowerCamelCase__   	=					3
           lowerCamelCase__   	=					(3_2, 3_2)

           lowerCamelCase__   	=					floats_tensor((batch_size, num_channels) + sizes						,	rng=random.Random(0      )      ).to(UpperCAmelCase_      )
           return image




     @property
     def 			__snake_case (     self	: Any      )					->							Union[str, Any]:
           torch.manual_seed(0      )
           lowerCamelCase__   	=					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						,	)
           return model




     @property
     def 			__snake_case (     self	: Union[str, Any]      )					->							List[Any]:
           torch.manual_seed(0      )
           lowerCamelCase__   	=					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						,	)
           return model




     @property
     def 			__snake_case (     self	: str      )					->							Union[str, Any]:
           torch.manual_seed(0      )
           lowerCamelCase__   	=					CLIPTextConfig(
               bos_token_id=0						,	eos_token_id=2						,	hidden_size=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						,	)
           return CLIPTextModel(UpperCAmelCase_      )




     @property
     def 			__snake_case (     self	: Dict      )					->							Optional[Any]:
           def extract(*A__	: int						,	**A__	: int      ):






                 class       A      :
                      """simple docstring"""

                      def __init__(     self	: int      )					->							Any:
                            lowerCamelCase__   	=					torch.ones([0]      )




                      def 			__snake_case (     self	: List[Any]						,	A__	: Optional[int]      )					->							str:
                            self.pixel_values.to(UpperCAmelCase_      )
                            return self
                 return Out()

           return extract




     def 			__snake_case (     self	: Optional[int]      )					->							Union[str, Any]:
           lowerCamelCase__   	=					"""cpu"""  # ensure determinism for the device-dependent torch.Generator
           lowerCamelCase__   	=					self.dummy_cond_unet
           lowerCamelCase__   	=					DDIMScheduler(
               beta_start=0.00085						,	beta_end=0.012						,	beta_schedule='scaled_linear'						,	clip_sample=UpperCAmelCase_						,	set_alpha_to_one=UpperCAmelCase_						,	)

           lowerCamelCase__   	=					self.dummy_vae
           lowerCamelCase__   	=					self.dummy_text_encoder
           lowerCamelCase__   	=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

           # make sure here that pndm scheduler skips prk
           lowerCamelCase__   	=					StableDiffusionPipeline(
               unet=UpperCAmelCase_						,	scheduler=UpperCAmelCase_						,	vae=UpperCAmelCase_						,	text_encoder=UpperCAmelCase_						,	tokenizer=UpperCAmelCase_						,	safety_checker=UpperCAmelCase_						,	feature_extractor=self.dummy_extractor						,	)
           lowerCamelCase__   	=					sd_pipe.to(UpperCAmelCase_      )
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

           lowerCamelCase__   	=					"""A painting of a squirrel eating a burger"""

           lowerCamelCase__   	=					torch.Generator(device=UpperCAmelCase_      ).manual_seed(0      )
           lowerCamelCase__   	=					sd_pipe([prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=6.0						,	num_inference_steps=2						,	output_type='np'      )
           lowerCamelCase__   	=					output.images

           lowerCamelCase__   	=					torch.Generator(device=UpperCAmelCase_      ).manual_seed(0      )
           lowerCamelCase__   	=					sd_pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=6.0						,	num_inference_steps=2						,	output_type='np'						,	return_dict=UpperCAmelCase_						,	)[0]

           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					image_from_tuple[0, -3:, -3:, -1]

           assert image.shape == (1, 6_4, 6_4, 3)
           lowerCamelCase__   	=					np.array([0.5753, 0.6114, 0.5001, 0.5034, 0.5470, 0.4729, 0.4971, 0.4867, 0.4867]      )

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




     def 			__snake_case (     self	: List[Any]      )					->							Any:
           lowerCamelCase__   	=					"""cpu"""  # ensure determinism for the device-dependent torch.Generator
           lowerCamelCase__   	=					self.dummy_cond_unet
           lowerCamelCase__   	=					PNDMScheduler(skip_prk_steps=UpperCAmelCase_      )
           lowerCamelCase__   	=					self.dummy_vae
           lowerCamelCase__   	=					self.dummy_text_encoder
           lowerCamelCase__   	=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

           # make sure here that pndm scheduler skips prk
           lowerCamelCase__   	=					StableDiffusionPipeline(
               unet=UpperCAmelCase_						,	scheduler=UpperCAmelCase_						,	vae=UpperCAmelCase_						,	text_encoder=UpperCAmelCase_						,	tokenizer=UpperCAmelCase_						,	safety_checker=UpperCAmelCase_						,	feature_extractor=self.dummy_extractor						,	)
           lowerCamelCase__   	=					sd_pipe.to(UpperCAmelCase_      )
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

           lowerCamelCase__   	=					"""A painting of a squirrel eating a burger"""
           lowerCamelCase__   	=					torch.Generator(device=UpperCAmelCase_      ).manual_seed(0      )
           lowerCamelCase__   	=					sd_pipe([prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=6.0						,	num_inference_steps=2						,	output_type='np'      )

           lowerCamelCase__   	=					output.images

           lowerCamelCase__   	=					torch.Generator(device=UpperCAmelCase_      ).manual_seed(0      )
           lowerCamelCase__   	=					sd_pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=6.0						,	num_inference_steps=2						,	output_type='np'						,	return_dict=UpperCAmelCase_						,	)[0]

           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					image_from_tuple[0, -3:, -3:, -1]

           assert image.shape == (1, 6_4, 6_4, 3)
           lowerCamelCase__   	=					np.array([0.5122, 0.5712, 0.4825, 0.5053, 0.5646, 0.4769, 0.5179, 0.4894, 0.4994]      )

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




     def 			__snake_case (     self	: List[Any]      )					->							Optional[Any]:
           lowerCamelCase__   	=					StableDiffusionPipeline.from_pretrained(
               'hf-internal-testing/tiny-stable-diffusion-lms-pipe'						,	safety_checker=UpperCAmelCase_      )
           assert isinstance(UpperCAmelCase_						,	UpperCAmelCase_      )
           assert isinstance(pipe.scheduler						,	UpperCAmelCase_      )
           assert pipe.safety_checker is None

           lowerCamelCase__   	=					pipe('example prompt'						,	num_inference_steps=2      ).images[0]
           assert image is not None

           # check that there's no error when saving a pipeline with one of the models being None
           with tempfile.TemporaryDirectory() as tmpdirname:
                 pipe.save_pretrained(UpperCAmelCase_      )
                 lowerCamelCase__   	=					StableDiffusionPipeline.from_pretrained(UpperCAmelCase_      )

           # sanity check that the pipeline still works
           assert pipe.safety_checker is None
           lowerCamelCase__   	=					pipe('example prompt'						,	num_inference_steps=2      ).images[0]
           assert image is not None




     @unittest.skipIf(torch_device != 'cuda'						,	'This test requires a GPU'      )
     def 			__snake_case (     self	: Optional[int]      )					->							Any:
           lowerCamelCase__   	=					self.dummy_cond_unet
           lowerCamelCase__   	=					PNDMScheduler(skip_prk_steps=UpperCAmelCase_      )
           lowerCamelCase__   	=					self.dummy_vae
           lowerCamelCase__   	=					self.dummy_text_encoder
           lowerCamelCase__   	=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

           # put models in fp16
           lowerCamelCase__   	=					unet.half()
           lowerCamelCase__   	=					vae.half()
           lowerCamelCase__   	=					bert.half()

           # make sure here that pndm scheduler skips prk
           lowerCamelCase__   	=					StableDiffusionPipeline(
               unet=UpperCAmelCase_						,	scheduler=UpperCAmelCase_						,	vae=UpperCAmelCase_						,	text_encoder=UpperCAmelCase_						,	tokenizer=UpperCAmelCase_						,	safety_checker=UpperCAmelCase_						,	feature_extractor=self.dummy_extractor						,	)
           lowerCamelCase__   	=					sd_pipe.to(UpperCAmelCase_      )
           sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

           lowerCamelCase__   	=					"""A painting of a squirrel eating a burger"""
           lowerCamelCase__   	=					sd_pipe([prompt]						,	num_inference_steps=2						,	output_type='np'      ).images

           assert image.shape == (1, 6_4, 6_4, 3)






@nightly
@require_torch_gpu
class       A      (		unittest.TestCase		):
     """simple docstring"""

     def 			__snake_case (     self	: Optional[Any]      )					->							Union[str, Any]:
           # clean up the VRAM after each test
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()




     def 			__snake_case (     self	: int      )					->							List[str]:
           lowerCamelCase__   	=					"""cuda"""
           lowerCamelCase__   	=					StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'      )
           lowerCamelCase__   	=					pipe.to(UpperCAmelCase_      )
           pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

           lowerCamelCase__   	=					"""a photo of a cat"""
           lowerCamelCase__   	=					{
               """editing_prompt""": ["""sunglasses"""],
               """reverse_editing_direction""": [False],
               """edit_warmup_steps""": 1_0,
               """edit_guidance_scale""": 6,
               """edit_threshold""": 0.95,
               """edit_momentum_scale""": 0.5,
               """edit_mom_beta""": 0.6,
           }

           lowerCamelCase__   	=					3
           lowerCamelCase__   	=					7

           # no sega enabled
           lowerCamelCase__   	=					torch.Generator(UpperCAmelCase_      )
           generator.manual_seed(UpperCAmelCase_      )
           lowerCamelCase__   	=					pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=UpperCAmelCase_						,	num_inference_steps=5_0						,	output_type='np'						,	width=5_1_2						,	height=5_1_2						,	)

           lowerCamelCase__   	=					output.images
           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					[
               0.34673113,
               0.38492733,
               0.37597352,
               0.34086335,
               0.35650748,
               0.35579205,
               0.3384763,
               0.34340236,
               0.3573271,
           ]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

           # with sega enabled
           # generator = torch.manual_seed(seed)
           generator.manual_seed(UpperCAmelCase_      )
           lowerCamelCase__   	=					pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=UpperCAmelCase_						,	num_inference_steps=5_0						,	output_type='np'						,	width=5_1_2						,	height=5_1_2						,	**UpperCAmelCase_						,	)

           lowerCamelCase__   	=					output.images
           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					[
               0.41887826,
               0.37728766,
               0.30138272,
               0.41416335,
               0.41664985,
               0.36283392,
               0.36191246,
               0.43364465,
               0.43001732,
           ]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

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




     def 			__snake_case (     self	: List[str]      )					->							str:
           lowerCamelCase__   	=					"""cuda"""
           lowerCamelCase__   	=					StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'      )
           lowerCamelCase__   	=					pipe.to(UpperCAmelCase_      )
           pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

           lowerCamelCase__   	=					"""an image of a crowded boulevard, realistic, 4k"""
           lowerCamelCase__   	=					{
               """editing_prompt""": """crowd, crowded, people""",
               """reverse_editing_direction""": True,
               """edit_warmup_steps""": 1_0,
               """edit_guidance_scale""": 8.3,
               """edit_threshold""": 0.9,
               """edit_momentum_scale""": 0.5,
               """edit_mom_beta""": 0.6,
           }

           lowerCamelCase__   	=					9
           lowerCamelCase__   	=					7

           # no sega enabled
           lowerCamelCase__   	=					torch.Generator(UpperCAmelCase_      )
           generator.manual_seed(UpperCAmelCase_      )
           lowerCamelCase__   	=					pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=UpperCAmelCase_						,	num_inference_steps=5_0						,	output_type='np'						,	width=5_1_2						,	height=5_1_2						,	)

           lowerCamelCase__   	=					output.images
           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					[
               0.43497998,
               0.91814065,
               0.7540739,
               0.55580205,
               0.8467265,
               0.5389691,
               0.62574506,
               0.58897763,
               0.50926757,
           ]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

           # with sega enabled
           # generator = torch.manual_seed(seed)
           generator.manual_seed(UpperCAmelCase_      )
           lowerCamelCase__   	=					pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=UpperCAmelCase_						,	num_inference_steps=5_0						,	output_type='np'						,	width=5_1_2						,	height=5_1_2						,	**UpperCAmelCase_						,	)

           lowerCamelCase__   	=					output.images
           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					[
               0.3089719,
               0.30500144,
               0.29016042,
               0.30630964,
               0.325687,
               0.29419225,
               0.2908091,
               0.28723598,
               0.27696294,
           ]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

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




     def 			__snake_case (     self	: Tuple      )					->							int:
           lowerCamelCase__   	=					"""cuda"""
           lowerCamelCase__   	=					StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'      )
           lowerCamelCase__   	=					pipe.to(UpperCAmelCase_      )
           pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

           lowerCamelCase__   	=					"""a castle next to a river"""
           lowerCamelCase__   	=					{
               """editing_prompt""": ["""boat on a river, boat""", """monet, impression, sunrise"""],
               """reverse_editing_direction""": False,
               """edit_warmup_steps""": [1_5, 1_8],
               """edit_guidance_scale""": 6,
               """edit_threshold""": [0.9, 0.8],
               """edit_momentum_scale""": 0.5,
               """edit_mom_beta""": 0.6,
           }

           lowerCamelCase__   	=					4_8
           lowerCamelCase__   	=					7

           # no sega enabled
           lowerCamelCase__   	=					torch.Generator(UpperCAmelCase_      )
           generator.manual_seed(UpperCAmelCase_      )
           lowerCamelCase__   	=					pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=UpperCAmelCase_						,	num_inference_steps=5_0						,	output_type='np'						,	width=5_1_2						,	height=5_1_2						,	)

           lowerCamelCase__   	=					output.images
           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					[
               0.75163555,
               0.76037145,
               0.61785,
               0.9189673,
               0.8627701,
               0.85189694,
               0.8512813,
               0.87012076,
               0.8312857,
           ]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

           # with sega enabled
           # generator = torch.manual_seed(seed)
           generator.manual_seed(UpperCAmelCase_      )
           lowerCamelCase__   	=					pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=UpperCAmelCase_						,	num_inference_steps=5_0						,	output_type='np'						,	width=5_1_2						,	height=5_1_2						,	**UpperCAmelCase_						,	)

           lowerCamelCase__   	=					output.images
           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					[
               0.73553365,
               0.7537271,
               0.74341905,
               0.66480356,
               0.6472925,
               0.63039416,
               0.64812905,
               0.6749717,
               0.6517102,
           ]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

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




     def 			__snake_case (     self	: Union[str, Any]      )					->							Any:
           lowerCamelCase__   	=					"""cuda"""
           lowerCamelCase__   	=					StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'						,	torch_dtype=torch.floataa      )
           lowerCamelCase__   	=					pipe.to(UpperCAmelCase_      )
           pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

           lowerCamelCase__   	=					"""a photo of a cat"""
           lowerCamelCase__   	=					{
               """editing_prompt""": ["""sunglasses"""],
               """reverse_editing_direction""": [False],
               """edit_warmup_steps""": 1_0,
               """edit_guidance_scale""": 6,
               """edit_threshold""": 0.95,
               """edit_momentum_scale""": 0.5,
               """edit_mom_beta""": 0.6,
           }

           lowerCamelCase__   	=					3
           lowerCamelCase__   	=					7

           # no sega enabled
           lowerCamelCase__   	=					torch.Generator(UpperCAmelCase_      )
           generator.manual_seed(UpperCAmelCase_      )
           lowerCamelCase__   	=					pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=UpperCAmelCase_						,	num_inference_steps=5_0						,	output_type='np'						,	width=5_1_2						,	height=5_1_2						,	)

           lowerCamelCase__   	=					output.images
           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					[
               0.34887695,
               0.3876953,
               0.375,
               0.34423828,
               0.3581543,
               0.35717773,
               0.3383789,
               0.34570312,
               0.359375,
           ]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

           # with sega enabled
           # generator = torch.manual_seed(seed)
           generator.manual_seed(UpperCAmelCase_      )
           lowerCamelCase__   	=					pipe(
               [prompt]						,	generator=UpperCAmelCase_						,	guidance_scale=UpperCAmelCase_						,	num_inference_steps=5_0						,	output_type='np'						,	width=5_1_2						,	height=5_1_2						,	**UpperCAmelCase_						,	)

           lowerCamelCase__   	=					output.images
           lowerCamelCase__   	=					image[0, -3:, -3:, -1]
           lowerCamelCase__   	=					[
               0.42285156,
               0.36914062,
               0.29077148,
               0.42041016,
               0.41918945,
               0.35498047,
               0.3618164,
               0.4423828,
               0.43115234,
           ]

           assert image.shape == (1, 5_1_2, 5_1_2, 3)

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




"""simple docstring"""







from math import factorial


def  __SCREAMING_SNAKE_CASE (  __UpperCAmelCase   ,				__UpperCAmelCase      ):
		return factorial(__UpperCAmelCase      ) / (factorial(__UpperCAmelCase      ) * factorial(n - r      ))


def  __SCREAMING_SNAKE_CASE (  ):
		_lowercase				: Optional[Any]     =   0

		for i in range(1   ,				101      ):
				for j in range(1   ,				i + 1      ):
						if combinations(__UpperCAmelCase   ,				__UpperCAmelCase      ) > 1E6:
								total += 1
		return total


if __name__ == "__main__":
		print(solution())



