'''simple docstring'''




import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
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 PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





class     __magic_name__						(    _UpperCAmelCase,     _UpperCAmelCase,     unittest.TestCase):
			UpperCamelCase__				=       StableDiffusionSAGPipeline
			UpperCamelCase__				=       TEXT_TO_IMAGE_PARAMS
			UpperCamelCase__				=       TEXT_TO_IMAGE_BATCH_PARAMS
			UpperCamelCase__				=       TEXT_TO_IMAGE_IMAGE_PARAMS
			UpperCamelCase__				=       TEXT_TO_IMAGE_IMAGE_PARAMS
			UpperCamelCase__				=       False







			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[Any]    ):
										torch.manual_seed(0    )
										lowercase_					:			Any										=       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				,			)
										lowercase_					:			Optional[int]										=       DDIMScheduler(
										    beta_start=0.0_00_85				,			beta_end=0.0_12				,			beta_schedule="""scaled_linear"""				,			clip_sample=lowercase_				,			set_alpha_to_one=lowercase_				,			)
										torch.manual_seed(0    )
										lowercase_					:			Tuple										=       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				,			)
										torch.manual_seed(0    )
										lowercase_					:			Optional[int]										=       CLIPTextConfig(
										    bos_token_id=0				,			eos_token_id=2				,			hidden_size=32				,			intermediate_size=37				,			layer_norm_eps=1E-05				,			num_attention_heads=4				,			num_hidden_layers=5				,			pad_token_id=1				,			vocab_size=1000				,			)
										lowercase_					:			Any										=       CLIPTextModel(lowercase_    )
										lowercase_					:			Any										=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )

										lowercase_					:			List[str]										=       {
										    """unet""": unet,
										    """scheduler""": scheduler,
										    """vae""": vae,
										    """text_encoder""": text_encoder,
										    """tokenizer""": tokenizer,
										    """safety_checker""": None,
										    """feature_extractor""": None,
										}
										return components







			def 	SCREAMING_SNAKE_CASE_     (	self				:  int				,			lowercase_				:  Union[str, Any]				,			lowercase_				:  List[Any]=0    ):
										if str(lowercase_    ).startswith("""mps"""    ):
																	lowercase_					:			int										=       torch.manual_seed(lowercase_    )
										else:
																	lowercase_					:			List[str]										=       torch.Generator(device=lowercase_    ).manual_seed(lowercase_    )
										lowercase_					:			Tuple										=       {
										    """prompt""": """.""",
										    """generator""": generator,
										    """num_inference_steps""": 2,
										    """guidance_scale""": 1.0,
										    """sag_scale""": 1.0,
										    """output_type""": """numpy""",
										}
										return inputs







			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[Any]    ):
										super().test_inference_batch_single_identical(expected_max_diff=3E-3    )





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







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







			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[str]    ):
										lowercase_					:			Optional[Any]										=       StableDiffusionSAGPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4"""    )
										lowercase_					:			Union[str, Any]										=       sag_pipe.to(lowercase_    )
										sag_pipe.set_progress_bar_config(disable=lowercase_    )

										lowercase_					:			List[str]										=       """."""
										lowercase_					:			Tuple										=       torch.manual_seed(0    )
										lowercase_					:			Any										=       sag_pipe(
										    [prompt]				,			generator=lowercase_				,			guidance_scale=7.5				,			sag_scale=1.0				,			num_inference_steps=20				,			output_type="""np"""    )

										lowercase_					:			Tuple										=       output.images

										lowercase_					:			Optional[int]										=       image[0, -3:, -3:, -1]

										assert image.shape == (1, 512, 512, 3)
										lowercase_					:			Any										=       np.array([0.15_68, 0.17_38, 0.16_95, 0.16_93, 0.15_07, 0.17_05, 0.15_47, 0.17_51, 0.19_49]    )

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







			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										lowercase_					:			Optional[int]										=       StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""    )
										lowercase_					:			List[Any]										=       sag_pipe.to(lowercase_    )
										sag_pipe.set_progress_bar_config(disable=lowercase_    )

										lowercase_					:			List[str]										=       """."""
										lowercase_					:			Optional[Any]										=       torch.manual_seed(0    )
										lowercase_					:			Any										=       sag_pipe(
										    [prompt]				,			generator=lowercase_				,			guidance_scale=7.5				,			sag_scale=1.0				,			num_inference_steps=20				,			output_type="""np"""    )

										lowercase_					:			Optional[Any]										=       output.images

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

										assert image.shape == (1, 512, 512, 3)
										lowercase_					:			List[Any]										=       np.array([0.34_59, 0.28_76, 0.25_37, 0.30_02, 0.26_71, 0.21_60, 0.30_26, 0.22_62, 0.23_71]    )

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







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[int]    ):
										lowercase_					:			int										=       StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""    )
										lowercase_					:			Tuple										=       sag_pipe.to(lowercase_    )
										sag_pipe.set_progress_bar_config(disable=lowercase_    )

										lowercase_					:			Dict										=       """."""
										lowercase_					:			Tuple										=       torch.manual_seed(0    )
										lowercase_					:			Optional[Any]										=       sag_pipe(
										    [prompt]				,			width=768				,			height=512				,			generator=lowercase_				,			guidance_scale=7.5				,			sag_scale=1.0				,			num_inference_steps=20				,			output_type="""np"""				,			)

										lowercase_					:			str										=       output.images

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






'''simple docstring'''




from itertools import product




def 							lowerCamelCase	(      UpperCAmelCase__       :					int      ,      UpperCAmelCase__       :					int )			->      list[int]:
							lowercase_					:			List[Any]										=       sides_number
							lowercase_					:			Dict										=       max_face_number * dice_number
							lowercase_					:			List[str]										=       [0] * (max_total + 1)

							lowercase_					:			Union[str, Any]										=       1
							lowercase_					:			Dict										=       range(UpperCAmelCase__      ,      max_face_number + 1 )
							for dice_numbers in product(UpperCAmelCase__      ,      repeat=UpperCAmelCase__ ):
														lowercase_					:			Any										=       sum(UpperCAmelCase__ )
														totals_frequencies[total] += 1

							return totals_frequencies




def 							lowerCamelCase	(      )			->      float:
							lowercase_					:			Optional[Any]										=       total_frequency_distribution(
							    sides_number=4      ,      dice_number=9 )
							lowercase_					:			List[str]										=       total_frequency_distribution(
							    sides_number=6      ,      dice_number=6 )

							lowercase_					:			Union[str, Any]										=       0
							lowercase_					:			Tuple										=       9
							lowercase_					:			Optional[int]										=       4 * 9
							lowercase_					:			List[Any]										=       6
							for peter_total in range(UpperCAmelCase__      ,      max_peter_total + 1 ):
														peter_wins_count += peter_totals_frequencies[peter_total] * sum(
														    colin_totals_frequencies[min_colin_total:peter_total] )

							lowercase_					:			str										=       (4**9) * (6**6)
							lowercase_					:			List[Any]										=       peter_wins_count / total_games_number

							lowercase_					:			Dict										=       round(UpperCAmelCase__      ,      ndigits=7 )

							return rounded_peter_win_probability


if __name__ == "__main__":
						print(f"""{solution() = }""")





