






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,
    DDIMInverseScheduler,
    DDIMScheduler,
    DPMSolverMultistepInverseScheduler,
    DPMSolverMultistepScheduler,
    StableDiffusionDiffEditPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_image, slow
from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class  lowerCAmelCase_       (				snake_case__     ,    snake_case__     ,    unittest.TestCase					):
							UpperCamelCase_		:List[Any]		      =    StableDiffusionDiffEditPipeline
							UpperCamelCase_		:List[Any]		      =    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'height', 'width', 'image'} | {'image_latents'}
							UpperCamelCase_		:List[str]		      =    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {'image'} | {'image_latents'}
							UpperCamelCase_		:List[str]		      =    frozenset(
							    []					)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
							UpperCamelCase_		:List[str]		      =    frozenset([]					)




							def 						__snake_case					(   self     :   str	):
											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 ,							attention_head_dim=(2, 4) ,							use_linear_projection=SCREAMING_SNAKE_CASE_ ,							)
											lowerCAmelCase__      			=						DDIMScheduler(
											    beta_start=0.00_085 ,							beta_end=0.012 ,							beta_schedule='''scaled_linear''' ,							clip_sample=SCREAMING_SNAKE_CASE_ ,							set_alpha_to_one=SCREAMING_SNAKE_CASE_ ,							)
											lowerCAmelCase__      			=						DDIMInverseScheduler(
											    beta_start=0.00_085 ,							beta_end=0.012 ,							beta_schedule='''scaled_linear''' ,							clip_sample=SCREAMING_SNAKE_CASE_ ,							set_alpha_to_zero=SCREAMING_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 ,							sample_size=128 ,							)
											torch.manual_seed(0	)
											lowerCAmelCase__      			=						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 ,							hidden_act='''gelu''' ,							projection_dim=512 ,							)
											lowerCAmelCase__      			=						CLIPTextModel(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)

											lowerCAmelCase__      			=						{
											    '''unet''': unet,
											    '''scheduler''': scheduler,
											    '''inverse_scheduler''': inverse_scheduler,
											    '''vae''': vae,
											    '''text_encoder''': text_encoder,
											    '''tokenizer''': tokenizer,
											    '''safety_checker''': None,
											    '''feature_extractor''': None,
											}

											return components




							def 						__snake_case					(   self     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   Optional[Any] ,							SCREAMING_SNAKE_CASE_     :   str=0	):
											lowerCAmelCase__      			=						floats_tensor((1, 16, 16) ,							rng=random.Random(SCREAMING_SNAKE_CASE_	)	).to(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						floats_tensor((1, 2, 4, 16, 16) ,							rng=random.Random(SCREAMING_SNAKE_CASE_	)	).to(SCREAMING_SNAKE_CASE_	)
											if str(SCREAMING_SNAKE_CASE_	).startswith('''mps'''	):
															lowerCAmelCase__      			=						torch.manual_seed(SCREAMING_SNAKE_CASE_	)
											else:
															lowerCAmelCase__      			=						torch.Generator(device=SCREAMING_SNAKE_CASE_	).manual_seed(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						{
											    '''prompt''': '''a dog and a newt''',
											    '''mask_image''': mask,
											    '''image_latents''': latents,
											    '''generator''': generator,
											    '''num_inference_steps''': 2,
											    '''inpaint_strength''': 1.0,
											    '''guidance_scale''': 6.0,
											    '''output_type''': '''numpy''',
											}

											return inputs




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   List[Any]=0	):
											lowerCAmelCase__      			=						floats_tensor((1, 3, 32, 32) ,							rng=random.Random(SCREAMING_SNAKE_CASE_	)	).to(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						image.cpu().permute(0 ,							2 ,							3 ,							1	)[0]
											lowerCAmelCase__      			=						Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE_	)	).convert('''RGB'''	)
											if str(SCREAMING_SNAKE_CASE_	).startswith('''mps'''	):
															lowerCAmelCase__      			=						torch.manual_seed(SCREAMING_SNAKE_CASE_	)
											else:
															lowerCAmelCase__      			=						torch.Generator(device=SCREAMING_SNAKE_CASE_	).manual_seed(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						{
											    '''image''': image,
											    '''source_prompt''': '''a cat and a frog''',
											    '''target_prompt''': '''a dog and a newt''',
											    '''generator''': generator,
											    '''num_inference_steps''': 2,
											    '''num_maps_per_mask''': 2,
											    '''mask_encode_strength''': 1.0,
											    '''guidance_scale''': 6.0,
											    '''output_type''': '''numpy''',
											}

											return inputs




							def 						__snake_case					(   self     :   str ,							SCREAMING_SNAKE_CASE_     :   int ,							SCREAMING_SNAKE_CASE_     :   str=0	):
											lowerCAmelCase__      			=						floats_tensor((1, 3, 32, 32) ,							rng=random.Random(SCREAMING_SNAKE_CASE_	)	).to(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						image.cpu().permute(0 ,							2 ,							3 ,							1	)[0]
											lowerCAmelCase__      			=						Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE_	)	).convert('''RGB'''	)
											if str(SCREAMING_SNAKE_CASE_	).startswith('''mps'''	):
															lowerCAmelCase__      			=						torch.manual_seed(SCREAMING_SNAKE_CASE_	)
											else:
															lowerCAmelCase__      			=						torch.Generator(device=SCREAMING_SNAKE_CASE_	).manual_seed(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						{
											    '''image''': image,
											    '''prompt''': '''a cat and a frog''',
											    '''generator''': generator,
											    '''num_inference_steps''': 2,
											    '''inpaint_strength''': 1.0,
											    '''guidance_scale''': 6.0,
											    '''decode_latents''': True,
											    '''output_type''': '''numpy''',
											}
											return inputs




							def 						__snake_case					(   self     :   int	):
											if not hasattr(self.pipeline_class ,							'''_optional_components'''	):
															return

											lowerCAmelCase__      			=						self.get_dummy_components()
											lowerCAmelCase__      			=						self.pipeline_class(**SCREAMING_SNAKE_CASE_	)
											pipe.to(SCREAMING_SNAKE_CASE_	)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

											# set all optional components to None and update pipeline config accordingly
											for optional_component in pipe._optional_components:
															setattr(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)
											pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components}	)

											lowerCAmelCase__      			=						self.get_dummy_inputs(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						pipe(**SCREAMING_SNAKE_CASE_	)[0]

											with tempfile.TemporaryDirectory() as tmpdir:
															pipe.save_pretrained(SCREAMING_SNAKE_CASE_	)
															lowerCAmelCase__      			=						self.pipeline_class.from_pretrained(SCREAMING_SNAKE_CASE_	)
															pipe_loaded.to(SCREAMING_SNAKE_CASE_	)
															pipe_loaded.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

											for optional_component in pipe._optional_components:
															self.assertTrue(
															    getattr(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	) is None ,							f'`{optional_component}` did not stay set to None after loading.' ,							)

											lowerCAmelCase__      			=						self.get_dummy_inputs(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						pipe_loaded(**SCREAMING_SNAKE_CASE_	)[0]

											lowerCAmelCase__      			=						np.abs(output - output_loaded	).max()
											self.assertLess(SCREAMING_SNAKE_CASE_ ,							1e-4	)




							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__      			=						'''cpu'''

											lowerCAmelCase__      			=						self.get_dummy_components()
											lowerCAmelCase__      			=						self.pipeline_class(**SCREAMING_SNAKE_CASE_	)
											pipe.to(SCREAMING_SNAKE_CASE_	)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						self.get_dummy_mask_inputs(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						pipe.generate_mask(**SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						mask[0, -3:, -3:]

											self.assertEqual(mask.shape ,							(1, 16, 16)	)
											lowerCAmelCase__      			=						np.array([0] * 9	)
											lowerCAmelCase__      			=						np.abs(mask_slice.flatten() - expected_slice	).max()
											self.assertLessEqual(SCREAMING_SNAKE_CASE_ ,							1e-3	)
											self.assertEqual(mask[0, -3, -4] ,							0	)




							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__      			=						'''cpu'''

											lowerCAmelCase__      			=						self.get_dummy_components()
											lowerCAmelCase__      			=						self.pipeline_class(**SCREAMING_SNAKE_CASE_	)
											pipe.to(SCREAMING_SNAKE_CASE_	)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						self.get_dummy_inversion_inputs(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						pipe.invert(**SCREAMING_SNAKE_CASE_	).images
											lowerCAmelCase__      			=						image[0, -1, -3:, -3:]

											self.assertEqual(image.shape ,							(2, 32, 32, 3)	)
											lowerCAmelCase__      			=						np.array(
											    [0.5_150, 0.5_134, 0.5_043, 0.5_376, 0.4_694, 0.51_050, 0.5_015, 0.4_407, 0.4_799] ,							)
											lowerCAmelCase__      			=						np.abs(image_slice.flatten() - expected_slice	).max()
											self.assertLessEqual(SCREAMING_SNAKE_CASE_ ,							1e-3	)




							def 						__snake_case					(   self     :   Union[str, Any]	):
											super().test_inference_batch_single_identical(expected_max_diff=5e-3	)




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						'''cpu'''

											lowerCAmelCase__      			=						self.get_dummy_components()

											lowerCAmelCase__      			=						{'''beta_start''': 0.00_085, '''beta_end''': 0.012, '''beta_schedule''': '''scaled_linear'''}
											lowerCAmelCase__      			=						DPMSolverMultistepScheduler(**SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						DPMSolverMultistepInverseScheduler(**SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						self.pipeline_class(**SCREAMING_SNAKE_CASE_	)
											pipe.to(SCREAMING_SNAKE_CASE_	)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						self.get_dummy_inversion_inputs(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						pipe.invert(**SCREAMING_SNAKE_CASE_	).images
											lowerCAmelCase__      			=						image[0, -1, -3:, -3:]

											self.assertEqual(image.shape ,							(2, 32, 32, 3)	)
											lowerCAmelCase__      			=						np.array(
											    [0.5_150, 0.5_134, 0.5_043, 0.5_376, 0.4_694, 0.51_050, 0.5_015, 0.4_407, 0.4_799] ,							)
											lowerCAmelCase__      			=						np.abs(image_slice.flatten() - expected_slice	).max()
											self.assertLessEqual(SCREAMING_SNAKE_CASE_ ,							1e-3	)



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




							def 						__snake_case					(   self     :   Optional[Any]	):
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()




							@classmethod
							def 						__snake_case					(   cls     :   int	):
											lowerCAmelCase__      			=						load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png'''	)

											lowerCAmelCase__      			=						raw_image.convert('''RGB'''	).resize((768, 768)	)

											lowerCAmelCase__      			=						raw_image




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						torch.manual_seed(0	)

											lowerCAmelCase__      			=						StableDiffusionDiffEditPipeline.from_pretrained(
											    '''stabilityai/stable-diffusion-2-1''' ,							safety_checker=SCREAMING_SNAKE_CASE_ ,							torch_dtype=torch.floataa	)
											lowerCAmelCase__      			=						DDIMScheduler.from_config(pipe.scheduler.config	)
											lowerCAmelCase__      			=						DDIMInverseScheduler.from_config(pipe.scheduler.config	)
											pipe.enable_model_cpu_offload()
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						'''a bowl of fruit'''
											lowerCAmelCase__      			=						'''a bowl of pears'''

											lowerCAmelCase__      			=						pipe.generate_mask(
											    image=self.raw_image ,							source_prompt=SCREAMING_SNAKE_CASE_ ,							target_prompt=SCREAMING_SNAKE_CASE_ ,							generator=SCREAMING_SNAKE_CASE_ ,							)

											lowerCAmelCase__      			=						pipe.invert(
											    prompt=SCREAMING_SNAKE_CASE_ ,							image=self.raw_image ,							inpaint_strength=0.7 ,							generator=SCREAMING_SNAKE_CASE_	).latents

											lowerCAmelCase__      			=						pipe(
											    prompt=SCREAMING_SNAKE_CASE_ ,							mask_image=SCREAMING_SNAKE_CASE_ ,							image_latents=SCREAMING_SNAKE_CASE_ ,							generator=SCREAMING_SNAKE_CASE_ ,							negative_prompt=SCREAMING_SNAKE_CASE_ ,							inpaint_strength=0.7 ,							output_type='''numpy''' ,							).images[0]

											lowerCAmelCase__      			=						(
											    np.array(
											        load_image(
											            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											            '''/diffedit/pears.png'''	).resize((768, 768)	)	)
											    / 255
											)
											assert np.abs((expected_image - image).max()	) < 5e-1




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						torch.manual_seed(0	)

											lowerCAmelCase__      			=						StableDiffusionDiffEditPipeline.from_pretrained(
											    '''stabilityai/stable-diffusion-2-1''' ,							safety_checker=SCREAMING_SNAKE_CASE_ ,							torch_dtype=torch.floataa	)
											lowerCAmelCase__      			=						DPMSolverMultistepScheduler.from_config(pipe.scheduler.config	)
											lowerCAmelCase__      			=						DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config	)
											pipe.enable_model_cpu_offload()
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						'''a bowl of fruit'''
											lowerCAmelCase__      			=						'''a bowl of pears'''

											lowerCAmelCase__      			=						pipe.generate_mask(
											    image=self.raw_image ,							source_prompt=SCREAMING_SNAKE_CASE_ ,							target_prompt=SCREAMING_SNAKE_CASE_ ,							generator=SCREAMING_SNAKE_CASE_ ,							)

											lowerCAmelCase__      			=						pipe.invert(
											    prompt=SCREAMING_SNAKE_CASE_ ,							image=self.raw_image ,							inpaint_strength=0.7 ,							generator=SCREAMING_SNAKE_CASE_ ,							num_inference_steps=25 ,							).latents

											lowerCAmelCase__      			=						pipe(
											    prompt=SCREAMING_SNAKE_CASE_ ,							mask_image=SCREAMING_SNAKE_CASE_ ,							image_latents=SCREAMING_SNAKE_CASE_ ,							generator=SCREAMING_SNAKE_CASE_ ,							negative_prompt=SCREAMING_SNAKE_CASE_ ,							inpaint_strength=0.7 ,							num_inference_steps=25 ,							output_type='''numpy''' ,							).images[0]

											lowerCAmelCase__      			=						(
											    np.array(
											        load_image(
											            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											            '''/diffedit/pears.png'''	).resize((768, 768)	)	)
											    / 255
											)
											assert np.abs((expected_image - image).max()	) < 5e-1













from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_UpperCAmelCase			:		List[str]   				=    {
    "configuration_electra": ["ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP", "ElectraConfig", "ElectraOnnxConfig"],
    "tokenization_electra": ["ElectraTokenizer"],
}

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_UpperCAmelCase			:		Dict   				=    ["ElectraTokenizerFast"]

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_UpperCAmelCase			:		Optional[Any]   				=    [
			    "ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "ElectraForCausalLM",
			    "ElectraForMaskedLM",
			    "ElectraForMultipleChoice",
			    "ElectraForPreTraining",
			    "ElectraForQuestionAnswering",
			    "ElectraForSequenceClassification",
			    "ElectraForTokenClassification",
			    "ElectraModel",
			    "ElectraPreTrainedModel",
			    "load_tf_weights_in_electra",
			]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_UpperCAmelCase			:		Union[str, Any]   				=    [
			    "TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "TFElectraForMaskedLM",
			    "TFElectraForMultipleChoice",
			    "TFElectraForPreTraining",
			    "TFElectraForQuestionAnswering",
			    "TFElectraForSequenceClassification",
			    "TFElectraForTokenClassification",
			    "TFElectraModel",
			    "TFElectraPreTrainedModel",
			]

try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_UpperCAmelCase			:		Optional[int]   				=    [
			    "FlaxElectraForCausalLM",
			    "FlaxElectraForMaskedLM",
			    "FlaxElectraForMultipleChoice",
			    "FlaxElectraForPreTraining",
			    "FlaxElectraForQuestionAnswering",
			    "FlaxElectraForSequenceClassification",
			    "FlaxElectraForTokenClassification",
			    "FlaxElectraModel",
			    "FlaxElectraPreTrainedModel",
			]


if TYPE_CHECKING:
			from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
			from .tokenization_electra import ElectraTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_electra_fast import ElectraTokenizerFast

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_electra import (
						    ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
						    ElectraForCausalLM,
						    ElectraForMaskedLM,
						    ElectraForMultipleChoice,
						    ElectraForPreTraining,
						    ElectraForQuestionAnswering,
						    ElectraForSequenceClassification,
						    ElectraForTokenClassification,
						    ElectraModel,
						    ElectraPreTrainedModel,
						    load_tf_weights_in_electra,
						)

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_electra import (
						    TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFElectraForMaskedLM,
						    TFElectraForMultipleChoice,
						    TFElectraForPreTraining,
						    TFElectraForQuestionAnswering,
						    TFElectraForSequenceClassification,
						    TFElectraForTokenClassification,
						    TFElectraModel,
						    TFElectraPreTrainedModel,
						)

			try:
						if not is_flax_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_flax_electra import (
						    FlaxElectraForCausalLM,
						    FlaxElectraForMaskedLM,
						    FlaxElectraForMultipleChoice,
						    FlaxElectraForPreTraining,
						    FlaxElectraForQuestionAnswering,
						    FlaxElectraForSequenceClassification,
						    FlaxElectraForTokenClassification,
						    FlaxElectraModel,
						    FlaxElectraPreTrainedModel,
						)

else:
			import sys

			_UpperCAmelCase			:		Any   				=    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





