





"""simple docstring"""
import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







class       a							(   a__   , a__   , a__   , unittest.TestCase  ):
 snake_case__             =       AltDiffusionPipeline
 snake_case__             =       TEXT_TO_IMAGE_PARAMS
 snake_case__             =       TEXT_TO_IMAGE_BATCH_PARAMS
 snake_case__             =       TEXT_TO_IMAGE_IMAGE_PARAMS
 snake_case__             =       TEXT_TO_IMAGE_IMAGE_PARAMS



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  torch.manual_seed(0     )
  lowerCAmelCase    				= 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				,       )
  lowerCAmelCase    				= DDIMScheduler(
      beta_start=0.00_085				,       beta_end=0.012				,       beta_schedule='scaled_linear'				,       clip_sample=_snake_case				,       set_alpha_to_one=_snake_case				,       )
  torch.manual_seed(0     )
  lowerCAmelCase    				= 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				,       )

  # TODO: address the non-deterministic text encoder (fails for save-load tests)
  # torch.manual_seed(0)
  # text_encoder_config = RobertaSeriesConfig(
  #     hidden_size=32,
  #     project_dim=32,
  #     intermediate_size=37,
  #     layer_norm_eps=1e-05,
  #     num_attention_heads=4,
  #     num_hidden_layers=5,
  #     vocab_size=5002,
  # )
  # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

  torch.manual_seed(0     )
  lowerCAmelCase    				= CLIPTextConfig(
      bos_token_id=0				,       eos_token_id=2				,       hidden_size=32				,       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=50_02				,       )
  lowerCAmelCase    				= CLIPTextModel(_snake_case     )

  lowerCAmelCase    				= XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta'     )
  lowerCAmelCase    				= 77

  lowerCAmelCase    				= {
      'unet': unet,
      'scheduler': scheduler,
      'vae': vae,
      'text_encoder': text_encoder,
      'tokenizer': tokenizer,
      'safety_checker': None,
      'feature_extractor': None,
  }
  return components



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case=0     ):







  """simple docstring"""






  if str(_snake_case     ).startswith('mps'     ):
   lowerCAmelCase    				= torch.manual_seed(_snake_case     )
  else:
   lowerCAmelCase    				= torch.Generator(device=_snake_case     ).manual_seed(_snake_case     )
  lowerCAmelCase    				= {
      'prompt': 'A painting of a squirrel eating a burger',
      'generator': generator,
      'num_inference_steps': 2,
      'guidance_scale': 6.0,
      'output_type': 'numpy',
  }
  return inputs



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  super().test_attention_slicing_forward_pass(expected_max_diff=3E-3     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  super().test_inference_batch_single_identical(expected_max_diff=3E-3     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= 'cpu'  # ensure determinism for the device-dependent torch.Generator

  lowerCAmelCase    				= self.get_dummy_components()
  torch.manual_seed(0     )
  lowerCAmelCase    				= RobertaSeriesConfig(
      hidden_size=32				,       project_dim=32				,       intermediate_size=37				,       layer_norm_eps=1E-05				,       num_attention_heads=4				,       num_hidden_layers=5				,       vocab_size=50_02				,       )
  # TODO: remove after fixing the non-deterministic text encoder
  lowerCAmelCase    				= RobertaSeriesModelWithTransformation(_snake_case     )
  lowerCAmelCase    				= text_encoder

  lowerCAmelCase    				= AltDiffusionPipeline(**_snake_case     )
  lowerCAmelCase    				= alt_pipe.to(_snake_case     )
  alt_pipe.set_progress_bar_config(disable=_snake_case     )

  lowerCAmelCase    				= self.get_dummy_inputs(_snake_case     )
  lowerCAmelCase    				= 'A photo of an astronaut'
  lowerCAmelCase    				= alt_pipe(**_snake_case     )
  lowerCAmelCase    				= output.images
  lowerCAmelCase    				= image[0, -3:, -3:, -1]

  assert image.shape == (1, 64, 64, 3)
  lowerCAmelCase    				= np.array(
      [0.5_748_162, 0.60_447_145, 0.48_821_217, 0.50_100_636, 0.5_431_185, 0.45_763_683, 0.49_657_696, 0.48_132_733, 0.47_573_093]     )

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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= 'cpu'  # ensure determinism for the device-dependent torch.Generator

  lowerCAmelCase    				= self.get_dummy_components()
  lowerCAmelCase    				= PNDMScheduler(skip_prk_steps=_snake_case     )
  torch.manual_seed(0     )
  lowerCAmelCase    				= RobertaSeriesConfig(
      hidden_size=32				,       project_dim=32				,       intermediate_size=37				,       layer_norm_eps=1E-05				,       num_attention_heads=4				,       num_hidden_layers=5				,       vocab_size=50_02				,       )
  # TODO: remove after fixing the non-deterministic text encoder
  lowerCAmelCase    				= RobertaSeriesModelWithTransformation(_snake_case     )
  lowerCAmelCase    				= text_encoder
  lowerCAmelCase    				= AltDiffusionPipeline(**_snake_case     )
  lowerCAmelCase    				= alt_pipe.to(_snake_case     )
  alt_pipe.set_progress_bar_config(disable=_snake_case     )

  lowerCAmelCase    				= self.get_dummy_inputs(_snake_case     )
  lowerCAmelCase    				= alt_pipe(**_snake_case     )
  lowerCAmelCase    				= output.images
  lowerCAmelCase    				= image[0, -3:, -3:, -1]

  assert image.shape == (1, 64, 64, 3)
  lowerCAmelCase    				= np.array(
      [0.51_605_093, 0.5_707_241, 0.47_365_507, 0.50_578_886, 0.5_633_877, 0.4_642_503, 0.5_182_081, 0.48_763_484, 0.49_084_237]     )

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







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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'				,       safety_checker=_snake_case     )
  lowerCAmelCase    				= alt_pipe.to(_snake_case     )
  alt_pipe.set_progress_bar_config(disable=_snake_case     )

  lowerCAmelCase    				= 'A painting of a squirrel eating a burger'
  lowerCAmelCase    				= torch.manual_seed(0     )
  lowerCAmelCase    				= alt_pipe([prompt]				,       generator=_snake_case				,       guidance_scale=6.0				,       num_inference_steps=20				,       output_type='np'     )

  lowerCAmelCase    				= output.images

  lowerCAmelCase    				= image[0, -3:, -3:, -1]

  assert image.shape == (1, 5_12, 5_12, 3)
  lowerCAmelCase    				= np.array([0.1_010, 0.0_800, 0.0_794, 0.0_885, 0.0_843, 0.0_762, 0.0_769, 0.0_729, 0.0_586]     )

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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= DDIMScheduler.from_pretrained('BAAI/AltDiffusion'				,       subfolder='scheduler'     )

  lowerCAmelCase    				= AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'				,       scheduler=_snake_case				,       safety_checker=_snake_case     )
  lowerCAmelCase    				= alt_pipe.to(_snake_case     )
  alt_pipe.set_progress_bar_config(disable=_snake_case     )

  lowerCAmelCase    				= 'A painting of a squirrel eating a burger'
  lowerCAmelCase    				= torch.manual_seed(0     )

  lowerCAmelCase    				= alt_pipe([prompt]				,       generator=_snake_case				,       num_inference_steps=2				,       output_type='numpy'     )
  lowerCAmelCase    				= output.images

  lowerCAmelCase    				= image[0, -3:, -3:, -1]

  assert image.shape == (1, 5_12, 5_12, 3)
  lowerCAmelCase    				= np.array([0.4_019, 0.4_052, 0.3_810, 0.4_119, 0.3_916, 0.3_982, 0.4_651, 0.4_195, 0.5_323]     )

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







'''simple docstring'''



from itertools import product


def A (__lowerCamelCase :int					,      __lowerCamelCase :int						):
						_lowerCAmelCase    		=					sides_number
						_lowerCAmelCase    		=					max_face_number * dice_number
						_lowerCAmelCase    		=					[0] * (max_total + 1)

						_lowerCAmelCase    		=					1
						_lowerCAmelCase    		=					range(__lowerCamelCase					,      max_face_number + 1						)
						for dice_numbers in product(__lowerCamelCase					,      repeat=__lowerCamelCase						):
												_lowerCAmelCase    		=					sum(__lowerCamelCase						)
												totals_frequencies[total] += 1

						return totals_frequencies


def A ():
						_lowerCAmelCase    		=					total_frequency_distribution(
						    sides_number=4					,      dice_number=9						)
						_lowerCAmelCase    		=					total_frequency_distribution(
						    sides_number=6					,      dice_number=6						)

						_lowerCAmelCase    		=					0
						_lowerCAmelCase    		=					9
						_lowerCAmelCase    		=					4 * 9
						_lowerCAmelCase    		=					6
						for peter_total in range(__lowerCamelCase					,      max_peter_total + 1						):
												peter_wins_count += peter_totals_frequencies[peter_total] * sum(
												    colin_totals_frequencies[min_colin_total:peter_total]						)

						_lowerCAmelCase    		=					(4**9) * (6**6)
						_lowerCAmelCase    		=					peter_wins_count / total_games_number

						_lowerCAmelCase    		=					round(__lowerCamelCase					,      ndigits=7						)

						return rounded_peter_win_probability


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