"""simple docstring"""



import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    MODEL_FOR_PRETRAINING_MAPPING,
				    ElectraForCausalLM,
				    ElectraForMaskedLM,
				    ElectraForMultipleChoice,
				    ElectraForPreTraining,
				    ElectraForQuestionAnswering,
				    ElectraForSequenceClassification,
				    ElectraForTokenClassification,
				    ElectraModel,
				)
				from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST
class 	__UpperCAmelCase						:







			'''simple docstring'''





			def __init__( self      ,			snake_case_      ,			snake_case_=13      ,			snake_case_=7      ,			snake_case_=True      ,			snake_case_=True      ,			snake_case_=True      ,			snake_case_=True      ,			snake_case_=99      ,			snake_case_=32      ,			snake_case_=5      ,			snake_case_=4      ,			snake_case_=37      ,			snake_case_="gelu"      ,			snake_case_=0.1      ,			snake_case_=0.1      ,			snake_case_=512      ,			snake_case_=16      ,			snake_case_=2      ,			snake_case_=0.02      ,			snake_case_=3      ,			snake_case_=4      ,			snake_case_=None      ,			):







										'''simple docstring'''


										A__					:    int														= parent
										A__					:    Any														= batch_size
										A__					:    Any														= seq_length
										A__					:    List[Any]														= is_training
										A__					:    Any														= use_input_mask
										A__					:    str														= use_token_type_ids
										A__					:    Optional[Any]														= use_labels
										A__					:    List[str]														= vocab_size
										A__					:    Tuple														= hidden_size
										A__					:    str														= num_hidden_layers
										A__					:    int														= num_attention_heads
										A__					:    Optional[int]														= intermediate_size
										A__					:    Tuple														= hidden_act
										A__					:    Tuple														= hidden_dropout_prob
										A__					:    int														= attention_probs_dropout_prob
										A__					:    List[Any]														= max_position_embeddings
										A__					:    Optional[Any]														= type_vocab_size
										A__					:    Union[str, Any]														= type_sequence_label_size
										A__					:    List[Any]														= initializer_range
										A__					:    List[Any]														= num_labels
										A__					:    Union[str, Any]														= num_choices
										A__					:    int														= scope





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Optional[int]														= ids_tensor([self.batch_size, self.seq_length]      ,			self.vocab_size       )

										A__					:    Any														= None
										if self.use_input_mask:
																	A__					:    Union[str, Any]														= random_attention_mask([self.batch_size, self.seq_length]       )

										A__					:    str														= None
										if self.use_token_type_ids:
																	A__					:    int														= ids_tensor([self.batch_size, self.seq_length]      ,			self.type_vocab_size       )

										A__					:    Optional[Any]														= None
										A__					:    Optional[int]														= None
										A__					:    List[str]														= None
										if self.use_labels:
																	A__					:    List[str]														= ids_tensor([self.batch_size]      ,			self.type_sequence_label_size       )
																	A__					:    Union[str, Any]														= ids_tensor([self.batch_size, self.seq_length]      ,			self.num_labels       )
																	A__					:    Optional[Any]														= ids_tensor([self.batch_size]      ,			self.num_choices       )
																	A__					:    Any														= ids_tensor([self.batch_size, self.seq_length]      ,			1       )

										A__					:    str														= self.get_config()

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										    fake_token_labels,
										)





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										return ElectraConfig(
										    vocab_size=self.vocab_size      ,			hidden_size=self.hidden_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      ,			is_decoder=snake_case_      ,			initializer_range=self.initializer_range      ,			)





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										(
										    (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       
										)					:    Union[str, Any]														= self.prepare_config_and_inputs()

										A__					:    Optional[int]														= True
										A__					:    Optional[Any]														= floats_tensor([self.batch_size, self.seq_length, self.hidden_size]       )
										A__					:    Optional[Any]														= ids_tensor([self.batch_size, self.seq_length]      ,			vocab_size=2       )

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										    encoder_hidden_states,
										    encoder_attention_mask,
										)





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			):







										'''simple docstring'''


										A__					:    Optional[int]														= ElectraModel(config=snake_case_       )
										model.to(snake_case_       )
										model.eval()
										A__					:    Optional[int]														= model(snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_       )
										A__					:    List[Any]														= model(snake_case_      ,			token_type_ids=snake_case_       )
										A__					:    Union[str, Any]														= model(snake_case_       )
										self.parent.assertEqual(result.last_hidden_state.shape      ,			(self.batch_size, self.seq_length, self.hidden_size)       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			):







										'''simple docstring'''


										A__					:    Optional[Any]														= True
										A__					:    Tuple														= ElectraModel(snake_case_       )
										model.to(snake_case_       )
										model.eval()
										A__					:    str														= model(
										    snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_      ,			encoder_hidden_states=snake_case_      ,			encoder_attention_mask=snake_case_      ,			)
										A__					:    Optional[int]														= model(
										    snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_      ,			encoder_hidden_states=snake_case_      ,			)
										A__					:    Dict														= model(snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_       )
										self.parent.assertEqual(result.last_hidden_state.shape      ,			(self.batch_size, self.seq_length, self.hidden_size)       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			):







										'''simple docstring'''


										A__					:    Any														= ElectraForMaskedLM(config=snake_case_       )
										model.to(snake_case_       )
										model.eval()
										A__					:    str														= model(snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_      ,			labels=snake_case_       )
										self.parent.assertEqual(result.logits.shape      ,			(self.batch_size, self.seq_length, self.vocab_size)       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			):







										'''simple docstring'''


										A__					:    List[Any]														= ElectraForCausalLM(config=snake_case_       )
										model.to(snake_case_       )
										model.eval()
										A__					:    int														= model(snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_      ,			labels=snake_case_       )
										self.parent.assertEqual(result.logits.shape      ,			(self.batch_size, self.seq_length, self.vocab_size)       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			):







										'''simple docstring'''


										A__					:    str														= self.num_labels
										A__					:    List[Any]														= ElectraForTokenClassification(config=snake_case_       )
										model.to(snake_case_       )
										model.eval()
										A__					:    List[str]														= model(snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_      ,			labels=snake_case_       )
										self.parent.assertEqual(result.logits.shape      ,			(self.batch_size, self.seq_length, self.num_labels)       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			):







										'''simple docstring'''


										A__					:    Optional[Any]														= self.num_labels
										A__					:    Union[str, Any]														= ElectraForPreTraining(config=snake_case_       )
										model.to(snake_case_       )
										model.eval()
										A__					:    Any														= model(snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_      ,			labels=snake_case_       )
										self.parent.assertEqual(result.logits.shape      ,			(self.batch_size, self.seq_length)       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			):







										'''simple docstring'''


										A__					:    List[str]														= self.num_labels
										A__					:    Dict														= ElectraForSequenceClassification(snake_case_       )
										model.to(snake_case_       )
										model.eval()
										A__					:    Optional[Any]														= model(snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_      ,			labels=snake_case_       )
										self.parent.assertEqual(result.logits.shape      ,			(self.batch_size, self.num_labels)       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			):







										'''simple docstring'''


										A__					:    Union[str, Any]														= ElectraForQuestionAnswering(config=snake_case_       )
										model.to(snake_case_       )
										model.eval()
										A__					:    List[Any]														= model(
										    snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_      ,			start_positions=snake_case_      ,			end_positions=snake_case_      ,			)
										self.parent.assertEqual(result.start_logits.shape      ,			(self.batch_size, self.seq_length)       )
										self.parent.assertEqual(result.end_logits.shape      ,			(self.batch_size, self.seq_length)       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			snake_case_      ,			):







										'''simple docstring'''


										A__					:    Optional[Any]														= self.num_choices
										A__					:    Tuple														= ElectraForMultipleChoice(config=snake_case_       )
										model.to(snake_case_       )
										model.eval()
										A__					:    List[str]														= input_ids.unsqueeze(1       ).expand(-1      ,			self.num_choices      ,			-1       ).contiguous()
										A__					:    List[Any]														= token_type_ids.unsqueeze(1       ).expand(-1      ,			self.num_choices      ,			-1       ).contiguous()
										A__					:    List[Any]														= input_mask.unsqueeze(1       ).expand(-1      ,			self.num_choices      ,			-1       ).contiguous()
										A__					:    Optional[int]														= model(
										    snake_case_      ,			attention_mask=snake_case_      ,			token_type_ids=snake_case_      ,			labels=snake_case_      ,			)
										self.parent.assertEqual(result.logits.shape      ,			(self.batch_size, self.num_choices)       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Dict														= self.prepare_config_and_inputs()
										(
										    (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       (
										    A__
										)							,       
										)					:    List[str]														= config_and_inputs
										A__					:    int														= {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
										return config, inputs_dict





@require_torch
class 	__UpperCAmelCase						(__A       ,      __A       ,      unittest.TestCase    ):







			'''simple docstring'''
			_UpperCamelCase     :	Union[str, Any]				    =							(
			    (
			        ElectraModel,
			        ElectraForPreTraining,
			        ElectraForMaskedLM,
			        ElectraForCausalLM,
			        ElectraForMultipleChoice,
			        ElectraForTokenClassification,
			        ElectraForSequenceClassification,
			        ElectraForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			_UpperCamelCase     :	List[str]				    =							(
			    {
			        'feature-extraction': ElectraModel,
			        'fill-mask': ElectraForMaskedLM,
			        'question-answering': ElectraForQuestionAnswering,
			        'text-classification': ElectraForSequenceClassification,
			        'text-generation': ElectraForCausalLM,
			        'token-classification': ElectraForTokenClassification,
			        'zero-shot': ElectraForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			_UpperCamelCase     :	Dict				    =							True





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_      ,			snake_case_=False       ):







										'''simple docstring'''


										A__					:    List[Any]														= super()._prepare_for_class(snake_case_      ,			snake_case_      ,			return_labels=snake_case_       )

										if return_labels:
																	if model_class in get_values(snake_case_       ):
																								A__					:    Optional[int]														= torch.zeros(
																								    (self.model_tester.batch_size, self.model_tester.seq_length)      ,			dtype=torch.long      ,			device=snake_case_       )
										return inputs_dict





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    int														= ElectraModelTester(self       )
										A__					:    int														= ConfigTester(self      ,			config_class=snake_case_      ,			hidden_size=37       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										self.config_tester.run_common_tests()





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Optional[Any]														= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_model(*snake_case_       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Tuple														= self.model_tester.prepare_config_and_inputs_for_decoder()
										self.model_tester.create_and_check_electra_model_as_decoder(*snake_case_       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    int														= self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
																	A__					:    Any														= type
																	self.model_tester.create_and_check_electra_model(*snake_case_       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    int														= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_masked_lm(*snake_case_       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    str														= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_token_classification(*snake_case_       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Any														= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_pretraining(*snake_case_       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Optional[Any]														= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_sequence_classification(*snake_case_       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Union[str, Any]														= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_question_answering(*snake_case_       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Any														= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_multiple_choice(*snake_case_       )





			@slow
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	A__					:    str														= ElectraModel.from_pretrained(snake_case_       )
																	self.assertIsNotNone(snake_case_       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Tuple														= self.model_tester.prepare_config_and_inputs_for_decoder()
										self.model_tester.create_and_check_electra_for_causal_lm(*snake_case_       )





@require_torch
class 	__UpperCAmelCase						(unittest.TestCase    ):







			'''simple docstring'''





			@slow
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    str														= ElectraModel.from_pretrained("""google/electra-small-discriminator"""       )
										A__					:    Optional[int]														= torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]       )
										A__					:    int														= torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]       )
										A__					:    str														= model(snake_case_      ,			attention_mask=snake_case_       )[0]
										A__					:    Tuple														= torch.Size((1, 11, 256)       )
										self.assertEqual(output.shape      ,			snake_case_       )
										A__					:    List[Any]														= torch.tensor(
										    [[[0.44_71, 0.68_21, -0.32_65], [0.46_27, 0.52_55, -0.36_68], [0.45_32, 0.33_13, -0.43_44]]]       )

										self.assertTrue(torch.allclose(output[:, 1:4, 1:4]      ,			snake_case_      ,			atol=1E-4       )       )






"""simple docstring"""



# This model implementation is heavily based on:

import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetInpaintPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()
class 	__UpperCAmelCase						(__A       ,      __A       ,      __A       ,      unittest.TestCase    ):







			'''simple docstring'''
			_UpperCamelCase     :	List[str]				    =							StableDiffusionControlNetInpaintPipeline
			_UpperCamelCase     :	List[Any]				    =							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			_UpperCamelCase     :	Dict				    =							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			_UpperCamelCase     :	Dict				    =							frozenset({'control_image'}    )  # skip `image` and `mask` for now, only test for control_image
			_UpperCamelCase     :	Dict				    =							TEXT_TO_IMAGE_IMAGE_PARAMS





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										torch.manual_seed(0       )
										A__					:    Optional[int]														= UNetaDConditionModel(
										    block_out_channels=(32, 64)      ,			layers_per_block=2      ,			sample_size=32      ,			in_channels=9      ,			out_channels=4      ,			down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,			up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")      ,			cross_attention_dim=32      ,			)
										torch.manual_seed(0       )
										A__					:    Any														= ControlNetModel(
										    block_out_channels=(32, 64)      ,			layers_per_block=2      ,			in_channels=4      ,			down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,			cross_attention_dim=32      ,			conditioning_embedding_out_channels=(16, 32)      ,			)
										torch.manual_seed(0       )
										A__					:    List[str]														= DDIMScheduler(
										    beta_start=0.0_00_85      ,			beta_end=0.0_12      ,			beta_schedule="""scaled_linear"""      ,			clip_sample=snake_case_      ,			set_alpha_to_one=snake_case_      ,			)
										torch.manual_seed(0       )
										A__					:    List[Any]														= 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       )
										A__					:    List[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=1_000      ,			)
										A__					:    Any														= CLIPTextModel(snake_case_       )
										A__					:    Optional[int]														= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

										A__					:    Union[str, Any]														= {
										    """unet""": unet,
										    """controlnet""": controlnet,
										    """scheduler""": scheduler,
										    """vae""": vae,
										    """text_encoder""": text_encoder,
										    """tokenizer""": tokenizer,
										    """safety_checker""": None,
										    """feature_extractor""": None,
										}
										return components





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_=0       ):







										'''simple docstring'''


										if str(snake_case_       ).startswith("""mps"""       ):
																	A__					:    Tuple														= torch.manual_seed(snake_case_       )
										else:
																	A__					:    Dict														= torch.Generator(device=snake_case_       ).manual_seed(snake_case_       )

										A__					:    Union[str, Any]														= 2
										A__					:    int														= randn_tensor(
										    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)      ,			generator=snake_case_      ,			device=torch.device(snake_case_       )      ,			)
										A__					:    List[Any]														= floats_tensor((1, 3, 32, 32)      ,			rng=random.Random(snake_case_       )       ).to(snake_case_       )
										A__					:    Union[str, Any]														= init_image.cpu().permute(0      ,			2      ,			3      ,			1       )[0]

										A__					:    Dict														= Image.fromarray(np.uinta(snake_case_       )       ).convert("""RGB"""       ).resize((64, 64)       )
										A__					:    Union[str, Any]														= Image.fromarray(np.uinta(init_image + 4       )       ).convert("""RGB"""       ).resize((64, 64)       )

										A__					:    int														= {
										    """prompt""": """A painting of a squirrel eating a burger""",
										    """generator""": generator,
										    """num_inference_steps""": 2,
										    """guidance_scale""": 6.0,
										    """output_type""": """numpy""",
										    """image""": image,
										    """mask_image""": mask_image,
										    """control_image""": control_image,
										}

										return inputs





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3       )





			@unittest.skipIf(
			    torch_device != """cuda""" or not is_xformers_available()      ,			reason="""XFormers attention is only available with CUDA and `xformers` installed"""      ,			)
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										self._test_inference_batch_single_identical(expected_max_diff=2E-3       )





class 	__UpperCAmelCase						(__A    ):







			'''simple docstring'''
			_UpperCamelCase     :	Tuple				    =							StableDiffusionControlNetInpaintPipeline
			_UpperCamelCase     :	List[Any]				    =							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			_UpperCamelCase     :	List[Any]				    =							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
			_UpperCamelCase     :	Tuple				    =							frozenset([]    )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										torch.manual_seed(0       )
										A__					:    List[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      ,			)
										torch.manual_seed(0       )
										A__					:    Any														= ControlNetModel(
										    block_out_channels=(32, 64)      ,			layers_per_block=2      ,			in_channels=4      ,			down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,			cross_attention_dim=32      ,			conditioning_embedding_out_channels=(16, 32)      ,			)
										torch.manual_seed(0       )
										A__					:    Optional[int]														= DDIMScheduler(
										    beta_start=0.0_00_85      ,			beta_end=0.0_12      ,			beta_schedule="""scaled_linear"""      ,			clip_sample=snake_case_      ,			set_alpha_to_one=snake_case_      ,			)
										torch.manual_seed(0       )
										A__					:    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      ,			)
										torch.manual_seed(0       )
										A__					:    Any														= 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=1_000      ,			)
										A__					:    List[Any]														= CLIPTextModel(snake_case_       )
										A__					:    Union[str, Any]														= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

										A__					:    Optional[int]														= {
										    """unet""": unet,
										    """controlnet""": controlnet,
										    """scheduler""": scheduler,
										    """vae""": vae,
										    """text_encoder""": text_encoder,
										    """tokenizer""": tokenizer,
										    """safety_checker""": None,
										    """feature_extractor""": None,
										}
										return components





class 	__UpperCAmelCase						(__A       ,      __A       ,      unittest.TestCase    ):







			'''simple docstring'''
			_UpperCamelCase     :	Dict				    =							StableDiffusionControlNetInpaintPipeline
			_UpperCamelCase     :	int				    =							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
			_UpperCamelCase     :	Optional[int]				    =							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										torch.manual_seed(0       )
										A__					:    List[Any]														= UNetaDConditionModel(
										    block_out_channels=(32, 64)      ,			layers_per_block=2      ,			sample_size=32      ,			in_channels=9      ,			out_channels=4      ,			down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,			up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")      ,			cross_attention_dim=32      ,			)
										torch.manual_seed(0       )

										def init_weights(snake_case_       ):
																	if isinstance(snake_case_      ,			torch.nn.Convad       ):
																								torch.nn.init.normal(m.weight       )
																								m.bias.data.fill_(1.0       )

										A__					:    Dict														= ControlNetModel(
										    block_out_channels=(32, 64)      ,			layers_per_block=2      ,			in_channels=4      ,			down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,			cross_attention_dim=32      ,			conditioning_embedding_out_channels=(16, 32)      ,			)
										controlneta.controlnet_down_blocks.apply(snake_case_       )

										torch.manual_seed(0       )
										A__					:    Union[str, Any]														= ControlNetModel(
										    block_out_channels=(32, 64)      ,			layers_per_block=2      ,			in_channels=4      ,			down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,			cross_attention_dim=32      ,			conditioning_embedding_out_channels=(16, 32)      ,			)
										controlneta.controlnet_down_blocks.apply(snake_case_       )

										torch.manual_seed(0       )
										A__					:    Dict														= DDIMScheduler(
										    beta_start=0.0_00_85      ,			beta_end=0.0_12      ,			beta_schedule="""scaled_linear"""      ,			clip_sample=snake_case_      ,			set_alpha_to_one=snake_case_      ,			)
										torch.manual_seed(0       )
										A__					:    Union[str, Any]														= 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       )
										A__					:    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=1_000      ,			)
										A__					:    List[Any]														= CLIPTextModel(snake_case_       )
										A__					:    int														= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

										A__					:    Optional[Any]														= MultiControlNetModel([controlneta, controlneta]       )

										A__					:    str														= {
										    """unet""": unet,
										    """controlnet""": controlnet,
										    """scheduler""": scheduler,
										    """vae""": vae,
										    """text_encoder""": text_encoder,
										    """tokenizer""": tokenizer,
										    """safety_checker""": None,
										    """feature_extractor""": None,
										}
										return components





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_=0       ):







										'''simple docstring'''


										if str(snake_case_       ).startswith("""mps"""       ):
																	A__					:    Optional[Any]														= torch.manual_seed(snake_case_       )
										else:
																	A__					:    Optional[Any]														= torch.Generator(device=snake_case_       ).manual_seed(snake_case_       )

										A__					:    Any														= 2

										A__					:    List[str]														= [
										    randn_tensor(
										        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)      ,			generator=snake_case_      ,			device=torch.device(snake_case_       )      ,			),
										    randn_tensor(
										        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)      ,			generator=snake_case_      ,			device=torch.device(snake_case_       )      ,			),
										]
										A__					:    Optional[int]														= floats_tensor((1, 3, 32, 32)      ,			rng=random.Random(snake_case_       )       ).to(snake_case_       )
										A__					:    Optional[Any]														= init_image.cpu().permute(0      ,			2      ,			3      ,			1       )[0]

										A__					:    Tuple														= Image.fromarray(np.uinta(snake_case_       )       ).convert("""RGB"""       ).resize((64, 64)       )
										A__					:    Union[str, Any]														= Image.fromarray(np.uinta(init_image + 4       )       ).convert("""RGB"""       ).resize((64, 64)       )

										A__					:    Any														= {
										    """prompt""": """A painting of a squirrel eating a burger""",
										    """generator""": generator,
										    """num_inference_steps""": 2,
										    """guidance_scale""": 6.0,
										    """output_type""": """numpy""",
										    """image""": image,
										    """mask_image""": mask_image,
										    """control_image""": control_image,
										}

										return inputs





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    int														= self.get_dummy_components()
										A__					:    str														= self.pipeline_class(**snake_case_       )
										pipe.to(snake_case_       )

										A__					:    Union[str, Any]														= 10.0
										A__					:    Union[str, Any]														= 4

										A__					:    List[Any]														= self.get_dummy_inputs(snake_case_       )
										A__					:    Optional[int]														= steps
										A__					:    List[Any]														= scale
										A__					:    List[Any]														= pipe(**snake_case_       )[0]

										A__					:    Union[str, Any]														= self.get_dummy_inputs(snake_case_       )
										A__					:    Dict														= steps
										A__					:    List[str]														= scale
										A__					:    str														= pipe(**snake_case_      ,			control_guidance_start=0.1      ,			control_guidance_end=0.2       )[0]

										A__					:    Union[str, Any]														= self.get_dummy_inputs(snake_case_       )
										A__					:    Union[str, Any]														= steps
										A__					:    Tuple														= scale
										A__					:    int														= pipe(**snake_case_      ,			control_guidance_start=[0.1, 0.3]      ,			control_guidance_end=[0.2, 0.7]       )[0]

										A__					:    Any														= self.get_dummy_inputs(snake_case_       )
										A__					:    Union[str, Any]														= steps
										A__					:    str														= scale
										A__					:    Optional[Any]														= pipe(**snake_case_      ,			control_guidance_start=0.4      ,			control_guidance_end=[0.5, 0.8]       )[0]

										# make sure that all outputs are different
										assert np.sum(np.abs(output_a - output_a       )       ) > 1E-3
										assert np.sum(np.abs(output_a - output_a       )       ) > 1E-3
										assert np.sum(np.abs(output_a - output_a       )       ) > 1E-3





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3       )





			@unittest.skipIf(
			    torch_device != """cuda""" or not is_xformers_available()      ,			reason="""XFormers attention is only available with CUDA and `xformers` installed"""      ,			)
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										self._test_inference_batch_single_identical(expected_max_diff=2E-3       )





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Any														= self.get_dummy_components()
										A__					:    int														= self.pipeline_class(**snake_case_       )
										pipe.to(snake_case_       )
										pipe.set_progress_bar_config(disable=snake_case_       )
										with tempfile.TemporaryDirectory() as tmpdir:
																	try:
																								# save_pretrained is not implemented for Multi-ControlNet
																								pipe.save_pretrained(snake_case_       )
																	except NotImplementedError:
																								pass





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







			'''simple docstring'''





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


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





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Union[str, Any]														= ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""       )

										A__					:    Optional[int]														= StableDiffusionControlNetInpaintPipeline.from_pretrained(
										    """runwayml/stable-diffusion-inpainting"""      ,			safety_checker=snake_case_      ,			controlnet=snake_case_       )
										pipe.enable_model_cpu_offload()
										pipe.set_progress_bar_config(disable=snake_case_       )

										A__					:    List[str]														= torch.Generator(device="""cpu"""       ).manual_seed(0       )
										A__					:    int														= load_image(
										    """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"""       ).resize((512, 512)       )

										A__					:    str														= load_image(
										    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
										    """/stable_diffusion_inpaint/input_bench_mask.png"""       ).resize((512, 512)       )

										A__					:    Optional[int]														= """pitch black hole"""

										A__					:    Optional[int]														= load_image(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"""       ).resize((512, 512)       )

										A__					:    str														= pipe(
										    snake_case_      ,			image=snake_case_      ,			mask_image=snake_case_      ,			control_image=snake_case_      ,			generator=snake_case_      ,			output_type="""np"""      ,			num_inference_steps=3      ,			)

										A__					:    List[Any]														= output.images[0]

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

										A__					:    List[str]														= load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy"""       )

										assert np.abs(expected_image - image       ).max() < 9E-2





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Optional[int]														= ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""       )

										A__					:    List[str]														= StableDiffusionControlNetInpaintPipeline.from_pretrained(
										    """runwayml/stable-diffusion-v1-5"""      ,			safety_checker=snake_case_      ,			controlnet=snake_case_       )
										A__					:    str														= DDIMScheduler.from_config(pipe.scheduler.config       )
										pipe.enable_model_cpu_offload()
										pipe.set_progress_bar_config(disable=snake_case_       )

										A__					:    List[Any]														= torch.Generator(device="""cpu"""       ).manual_seed(33       )

										A__					:    Any														= load_image(
										    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"""       )
										A__					:    Tuple														= init_image.resize((512, 512)       )

										A__					:    Union[str, Any]														= load_image(
										    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"""       )
										A__					:    int														= mask_image.resize((512, 512)       )

										A__					:    int														= """a handsome man with ray-ban sunglasses"""

										def make_inpaint_condition(snake_case_      ,			snake_case_       ):
																	A__					:    str														= np.array(image.convert("""RGB"""       )       ).astype(np.floataa       ) / 2_55.0
																	A__					:    str														= np.array(image_mask.convert("""L"""       )       ).astype(np.floataa       ) / 2_55.0

																	assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
																	A__					:    Tuple														= -1.0  # set as masked pixel
																	A__					:    Any														= np.expand_dims(snake_case_      ,			0       ).transpose(0      ,			3      ,			1      ,			2       )
																	A__					:    Tuple														= torch.from_numpy(snake_case_       )
																	return image

										A__					:    int														= make_inpaint_condition(snake_case_      ,			snake_case_       )

										A__					:    Optional[Any]														= pipe(
										    snake_case_      ,			image=snake_case_      ,			mask_image=snake_case_      ,			control_image=snake_case_      ,			guidance_scale=9.0      ,			eta=1.0      ,			generator=snake_case_      ,			num_inference_steps=20      ,			output_type="""np"""      ,			)
										A__					:    Tuple														= output.images[0]

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

										A__					:    Optional[int]														= load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy"""       )

										assert np.abs(expected_image - image       ).max() < 9E-2





