'''simple docstring'''




import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import 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


_lowercase						: Tuple						=						False





@skip_mps
class     __magic_name__						(    _UpperCAmelCase,     _UpperCAmelCase,     _UpperCAmelCase,     unittest.TestCase):
			UpperCamelCase__				=       StableDiffusionAttendAndExcitePipeline
			UpperCamelCase__				=       False
			UpperCamelCase__				=       TEXT_TO_IMAGE_PARAMS
			UpperCamelCase__				=       TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''})
			UpperCamelCase__				=       TEXT_TO_IMAGE_IMAGE_PARAMS
			UpperCamelCase__				=       TEXT_TO_IMAGE_IMAGE_PARAMS







			@classmethod
			def 	SCREAMING_SNAKE_CASE_     (	cls				:  Tuple    ):
										super().setUpClass()
										torch.use_deterministic_algorithms(lowercase_    )







			@classmethod
			def 	SCREAMING_SNAKE_CASE_     (	cls				:  int    ):
										super().tearDownClass()
										torch.use_deterministic_algorithms(lowercase_    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Dict    ):
										torch.manual_seed(0    )
										lowercase_					:			Any										=       UNetaDConditionModel(
										    block_out_channels=(32, 64)				,			layers_per_block=1				,			sample_size=32				,			in_channels=4				,			out_channels=4				,			down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")				,			up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")				,			cross_attention_dim=32				,			attention_head_dim=(2, 4)				,			use_linear_projection=lowercase_				,			)
										lowercase_					:			Optional[Any]										=       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_					:			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				,			sample_size=128				,			)
										torch.manual_seed(0    )
										lowercase_					:			str										=       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				,			hidden_act="""gelu"""				,			projection_dim=512				,			)
										lowercase_					:			Any										=       CLIPTextModel(lowercase_    )
										lowercase_					:			List[Any]										=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )

										lowercase_					:			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				:  List[str]				,			lowercase_				:  List[str]				,			lowercase_				:  Dict=0    ):
										if str(lowercase_    ).startswith("""mps"""    ):
																	lowercase_					:			Optional[Any]										=       torch.manual_seed(lowercase_    )
										else:
																	lowercase_					:			int										=       torch.Generator(device=lowercase_    ).manual_seed(lowercase_    )
										lowercase_					:			Optional[int]										=       {
										    """prompt""": """a cat and a frog""",
										    """token_indices""": [2, 5],
										    """generator""": generator,
										    """num_inference_steps""": 1,
										    """guidance_scale""": 6.0,
										    """output_type""": """numpy""",
										    """max_iter_to_alter""": 2,
										    """thresholds""": {0: 0.7},
										}
										return inputs







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Union[str, Any]    ):
										lowercase_					:			Optional[int]										=       """cpu"""

										lowercase_					:			Union[str, Any]										=       self.get_dummy_components()
										lowercase_					:			Optional[int]										=       self.pipeline_class(**lowercase_    )
										pipe.to(lowercase_    )
										pipe.set_progress_bar_config(disable=lowercase_    )

										lowercase_					:			Optional[int]										=       self.get_dummy_inputs(lowercase_    )
										lowercase_					:			List[Any]										=       pipe(**lowercase_    ).images
										lowercase_					:			Optional[int]										=       image[0, -3:, -3:, -1]

										self.assertEqual(image.shape				,			(1, 64, 64, 3)    )
										lowercase_					:			int										=       np.array(
										    [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96]    )
										lowercase_					:			str										=       np.abs(image_slice.flatten() - expected_slice    ).max()
										self.assertLessEqual(lowercase_				,			1E-3    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[Any]    ):
										super().test_cpu_offload_forward_pass(expected_max_diff=5E-4    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Union[str, Any]    ):
										# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
										self._test_inference_batch_consistent(batch_sizes=[1, 2]    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  str    ):
										self._test_inference_batch_single_identical(batch_size=2				,			expected_max_diff=7E-4    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Any    ):
										super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Union[str, Any]    ):
										super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[Any]    ):
										super().test_save_load_local(expected_max_difference=5E-4    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[int]    ):
										super().test_save_load_optional_components(expected_max_difference=4E-4    )





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







			@classmethod
			def 	SCREAMING_SNAKE_CASE_     (	cls				:  Dict    ):
										super().setUpClass()
										torch.use_deterministic_algorithms(lowercase_    )







			@classmethod
			def 	SCREAMING_SNAKE_CASE_     (	cls				:  Union[str, Any]    ):
										super().tearDownClass()
										torch.use_deterministic_algorithms(lowercase_    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Union[str, Any]    ):
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[Any]    ):
										lowercase_					:			Union[str, Any]										=       torch.manual_seed(51    )

										lowercase_					:			Optional[Any]										=       StableDiffusionAttendAndExcitePipeline.from_pretrained(
										    """CompVis/stable-diffusion-v1-4"""				,			safety_checker=lowercase_				,			torch_dtype=torch.floataa    )
										pipe.to("""cuda"""    )

										lowercase_					:			str										=       """a painting of an elephant with glasses"""
										lowercase_					:			Optional[int]										=       [5, 7]

										lowercase_					:			Dict										=       pipe(
										    prompt=lowercase_				,			token_indices=lowercase_				,			guidance_scale=7.5				,			generator=lowercase_				,			num_inference_steps=5				,			max_iter_to_alter=5				,			output_type="""numpy"""				,			).images[0]

										lowercase_					:			Tuple										=       load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy"""    )
										assert np.abs((expected_image - image).max()    ) < 5E-1






'''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() = }""")





