






"""simple docstring"""
import unittest

import numpy as np

from transformers import ElectraConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
			from transformers.models.electra.modeling_flax_electra import (
			    FlaxElectraForCausalLM,
			    FlaxElectraForMaskedLM,
			    FlaxElectraForMultipleChoice,
			    FlaxElectraForPreTraining,
			    FlaxElectraForQuestionAnswering,
			    FlaxElectraForSequenceClassification,
			    FlaxElectraForTokenClassification,
			    FlaxElectraModel,
			)


class _lowerCAmelCase	(						unittest.TestCase					):







						def __init__(						self      ,							lowerCAmelCase_      ,							lowerCAmelCase_=1_3      ,							lowerCAmelCase_=7      ,							lowerCAmelCase_=True      ,							lowerCAmelCase_=True      ,							lowerCAmelCase_=True      ,							lowerCAmelCase_=True      ,							lowerCAmelCase_=9_9      ,							lowerCAmelCase_=2_4      ,							lowerCAmelCase_=3_2      ,							lowerCAmelCase_=5      ,							lowerCAmelCase_=4      ,							lowerCAmelCase_=3_7      ,							lowerCAmelCase_="gelu"      ,							lowerCAmelCase_=0.1      ,							lowerCAmelCase_=0.1      ,							lowerCAmelCase_=5_1_2      ,							lowerCAmelCase_=1_6      ,							lowerCAmelCase_=2      ,							lowerCAmelCase_=0.02      ,							lowerCAmelCase_=4      ,							)		->       Union[str, Any]:
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						parent
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						batch_size
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						seq_length
										_SCREAMING_SNAKE_CASE      :		Tuple							=						is_training
										_SCREAMING_SNAKE_CASE      :		Tuple							=						use_attention_mask
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						use_token_type_ids
										_SCREAMING_SNAKE_CASE      :		Dict							=						use_labels
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						vocab_size
										_SCREAMING_SNAKE_CASE      :		int							=						hidden_size
										_SCREAMING_SNAKE_CASE      :		str							=						embedding_size
										_SCREAMING_SNAKE_CASE      :		Any							=						num_hidden_layers
										_SCREAMING_SNAKE_CASE      :		List[str]							=						num_attention_heads
										_SCREAMING_SNAKE_CASE      :		str							=						intermediate_size
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						hidden_act
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						hidden_dropout_prob
										_SCREAMING_SNAKE_CASE      :		List[str]							=						attention_probs_dropout_prob
										_SCREAMING_SNAKE_CASE      :		Tuple							=						max_position_embeddings
										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						type_vocab_size
										_SCREAMING_SNAKE_CASE      :		int							=						type_sequence_label_size
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						initializer_range
										_SCREAMING_SNAKE_CASE      :		Tuple							=						num_choices







						def  A			(						self       )		->       List[Any]:
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						ids_tensor([self.batch_size, self.seq_length]      ,							self.vocab_size       )

										_SCREAMING_SNAKE_CASE      :		str							=						None
										if self.use_attention_mask:
														_SCREAMING_SNAKE_CASE      :		int							=						random_attention_mask([self.batch_size, self.seq_length]       )

										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						None
										if self.use_token_type_ids:
														_SCREAMING_SNAKE_CASE      :		Tuple							=						ids_tensor([self.batch_size, self.seq_length]      ,							self.type_vocab_size       )

										_SCREAMING_SNAKE_CASE      :		List[str]							=						ElectraConfig(
										    vocab_size=self.vocab_size      ,							hidden_size=self.hidden_size      ,							embedding_size=self.embedding_size      ,							num_hidden_layers=self.num_hidden_layers      ,							num_attention_heads=self.num_attention_heads      ,							intermediate_size=self.intermediate_size      ,							hidden_act=self.hidden_act      ,							hidden_dropout_prob=self.hidden_dropout_prob      ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,							max_position_embeddings=self.max_position_embeddings      ,							type_vocab_size=self.type_vocab_size      ,							initializer_range=self.initializer_range      ,							)

										return config, input_ids, token_type_ids, attention_mask







						def  A			(						self       )		->       str:
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						self.prepare_config_and_inputs()
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						config_and_inputs
										_SCREAMING_SNAKE_CASE      :		Dict							=						{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask}
										return config, inputs_dict







@require_flax
class _lowerCAmelCase	(						__UpperCAmelCase      ,     unittest.TestCase					):
						_lowerCAmelCase:				int   				=							True

						_lowerCAmelCase:				Dict   				=							(
						    (
						        FlaxElectraModel,
						        FlaxElectraForCausalLM,
						        FlaxElectraForMaskedLM,
						        FlaxElectraForPreTraining,
						        FlaxElectraForTokenClassification,
						        FlaxElectraForQuestionAnswering,
						        FlaxElectraForMultipleChoice,
						        FlaxElectraForSequenceClassification,
						    )
						    if is_flax_available()
						    else ()
						)







						def  A			(						self       )		->       List[Any]:
										_SCREAMING_SNAKE_CASE      :		Tuple							=						FlaxElectraModelTester(self       )







						@slow
						def  A			(						self       )		->       str:
										for model_class_name in self.all_model_classes:
														if model_class_name == FlaxElectraForMaskedLM:
																		_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						model_class_name.from_pretrained('google/electra-small-generator'       )
														else:
																		_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						model_class_name.from_pretrained('google/electra-small-discriminator'       )
														_SCREAMING_SNAKE_CASE      :		Optional[int]							=						model(np.ones((1, 1)       )       )
														self.assertIsNotNone(lowerCAmelCase_       )









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

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    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 _lowerCAmelCase	(						__UpperCAmelCase      ,     __UpperCAmelCase      ,     unittest.TestCase					):
						SCREAMING_SNAKE_CASE_:				int   				=							StableDiffusionParadigmsPipeline
						SCREAMING_SNAKE_CASE_:				str   				=							TEXT_TO_IMAGE_PARAMS
						SCREAMING_SNAKE_CASE_:				Any   				=							TEXT_TO_IMAGE_BATCH_PARAMS
						SCREAMING_SNAKE_CASE_:				str   				=							TEXT_TO_IMAGE_IMAGE_PARAMS
						SCREAMING_SNAKE_CASE_:				List[Any]   				=							TEXT_TO_IMAGE_IMAGE_PARAMS







						def  A			(						self       )		->       int:
										torch.manual_seed(0       )
										_SCREAMING_SNAKE_CASE      :		Dict							=						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      ,							attention_head_dim=(2, 4)      ,							use_linear_projection=lowerCAmelCase_      ,							)
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						DDIMParallelScheduler(
										    beta_start=0.00_085      ,							beta_end=0.012      ,							beta_schedule='scaled_linear'      ,							clip_sample=lowerCAmelCase_      ,							set_alpha_to_one=lowerCAmelCase_      ,							)
										torch.manual_seed(0       )
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						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      ,							sample_size=1_2_8      ,							)
										torch.manual_seed(0       )
										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						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      ,							hidden_act='gelu'      ,							projection_dim=5_1_2      ,							)
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						CLIPTextModel(lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'       )

										_SCREAMING_SNAKE_CASE      :		List[Any]							=						{
										    'unet': unet,
										    'scheduler': scheduler,
										    'vae': vae,
										    'text_encoder': text_encoder,
										    'tokenizer': tokenizer,
										    'safety_checker': None,
										    'feature_extractor': None,
										}
										return components







						def  A			(						self      ,							lowerCAmelCase_      ,							lowerCAmelCase_=0       )		->       Tuple:
										if str(lowerCAmelCase_       ).startswith('mps'       ):
														_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						torch.manual_seed(lowerCAmelCase_       )
										else:
														_SCREAMING_SNAKE_CASE      :		int							=						torch.Generator(device=lowerCAmelCase_       ).manual_seed(lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		str							=						{
										    'prompt': 'a photograph of an astronaut riding a horse',
										    'generator': generator,
										    'num_inference_steps': 1_0,
										    'guidance_scale': 6.0,
										    'output_type': 'numpy',
										    'parallel': 3,
										    'debug': True,
										}
										return inputs







						def  A			(						self       )		->       int:
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						'cpu'  # ensure determinism for the device-dependent torch.Generator
										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						self.get_dummy_components()
										_SCREAMING_SNAKE_CASE      :		Any							=						StableDiffusionParadigmsPipeline(**lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						sd_pipe.to(lowerCAmelCase_       )
										sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_       )

										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						self.get_dummy_inputs(lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		Dict							=						sd_pipe(**lowerCAmelCase_       ).images
										_SCREAMING_SNAKE_CASE      :		Dict							=						image[0, -3:, -3:, -1]
										assert image.shape == (1, 6_4, 6_4, 3)

										_SCREAMING_SNAKE_CASE      :		int							=						np.array([0.4_773, 0.5_417, 0.4_723, 0.4_925, 0.5_631, 0.4_752, 0.5_240, 0.4_935, 0.5_023]       )

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







						def  A			(						self       )		->       Tuple:
										_SCREAMING_SNAKE_CASE      :		Tuple							=						'cpu'  # ensure determinism for the device-dependent torch.Generator
										_SCREAMING_SNAKE_CASE      :		str							=						self.get_dummy_components()
										torch.manual_seed(0       )
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						DDPMParallelScheduler()
										torch.manual_seed(0       )
										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						StableDiffusionParadigmsPipeline(**lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		int							=						sd_pipe.to(lowerCAmelCase_       )
										sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_       )

										_SCREAMING_SNAKE_CASE      :		Tuple							=						self.get_dummy_inputs(lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						sd_pipe(**lowerCAmelCase_       ).images
										_SCREAMING_SNAKE_CASE      :		Dict							=						image[0, -3:, -3:, -1]
										assert image.shape == (1, 6_4, 6_4, 3)

										_SCREAMING_SNAKE_CASE      :		Dict							=						np.array([0.3_573, 0.4_420, 0.4_960, 0.4_799, 0.3_796, 0.3_879, 0.4_819, 0.4_365, 0.4_468]       )

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







						def  A			(						self       )		->       Optional[Any]:
										super().test_inference_batch_consistent(batch_sizes=[1, 2]       )







						def  A			(						self       )		->       Tuple:
										super().test_inference_batch_single_identical(batch_size=2      ,							expected_max_diff=3e-3       )







						def  A			(						self       )		->       List[str]:
										_SCREAMING_SNAKE_CASE      :		List[Any]							=						'cpu'  # ensure determinism for the device-dependent torch.Generator
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						self.get_dummy_components()
										_SCREAMING_SNAKE_CASE      :		Union[str, Any]							=						StableDiffusionParadigmsPipeline(**lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		List[str]							=						sd_pipe.to(lowerCAmelCase_       )
										sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_       )

										_SCREAMING_SNAKE_CASE      :		int							=						self.get_dummy_inputs(lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		Tuple							=						'french fries'
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						sd_pipe(**lowerCAmelCase_      ,							negative_prompt=lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		Optional[Any]							=						output.images
										_SCREAMING_SNAKE_CASE      :		Dict							=						image[0, -3:, -3:, -1]

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

										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						np.array([0.4_771, 0.5_420, 0.4_683, 0.4_918, 0.5_636, 0.4_725, 0.5_230, 0.4_923, 0.5_015]       )

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







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







						def  A			(						self       )		->       Tuple:
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()







						def  A			(						self      ,							lowerCAmelCase_=0       )		->       int:
										_SCREAMING_SNAKE_CASE      :		str							=						torch.Generator(device=lowerCAmelCase_       ).manual_seed(lowerCAmelCase_       )
										_SCREAMING_SNAKE_CASE      :		List[str]							=						{
										    'prompt': 'a photograph of an astronaut riding a horse',
										    'generator': generator,
										    'num_inference_steps': 1_0,
										    'guidance_scale': 7.5,
										    'output_type': 'numpy',
										    'parallel': 3,
										    'debug': True,
										}
										return inputs







						def  A			(						self       )		->       List[str]:
										_SCREAMING_SNAKE_CASE      :		Any							=						'stabilityai/stable-diffusion-2-base'
										_SCREAMING_SNAKE_CASE      :		Dict							=						DDIMParallelScheduler.from_pretrained(lowerCAmelCase_      ,							subfolder='scheduler'       )
										_SCREAMING_SNAKE_CASE      :		List[str]							=						StableDiffusionParadigmsPipeline.from_pretrained(lowerCAmelCase_      ,							scheduler=lowerCAmelCase_      ,							safety_checker=lowerCAmelCase_       )
										pipe.to(lowerCAmelCase_       )
										pipe.set_progress_bar_config(disable=lowerCAmelCase_       )
										pipe.enable_attention_slicing()

										_SCREAMING_SNAKE_CASE      :		Optional[int]							=						self.get_inputs()
										_SCREAMING_SNAKE_CASE      :		str							=						pipe(**lowerCAmelCase_       ).images
										_SCREAMING_SNAKE_CASE      :		Dict							=						image[0, -3:, -3:, -1].flatten()

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

										_SCREAMING_SNAKE_CASE      :		Any							=						np.array([0.9_622, 0.9_602, 0.9_748, 0.9_591, 0.9_630, 0.9_691, 0.9_661, 0.9_631, 0.9_741]       )

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

