


'''simple docstring'''







import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

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


A				:					Optional[int]    						=			1e-4

if is_torch_available():
   import torch

   from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
   from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder


@require_torch
class 			__lowerCamelCase			:
    """simple docstring"""


    def __init__(  self      :							List[str]				,							SCREAMING_SNAKE_CASE      :							int				,							SCREAMING_SNAKE_CASE      :							Dict=16				,							SCREAMING_SNAKE_CASE      :							Union[str, Any]=13				,							SCREAMING_SNAKE_CASE      :							List[str]=7				,							SCREAMING_SNAKE_CASE      :							Optional[int]=14				,							SCREAMING_SNAKE_CASE      :							List[str]=10				,							SCREAMING_SNAKE_CASE      :							Dict=19				,							SCREAMING_SNAKE_CASE      :							List[str]=5				,							SCREAMING_SNAKE_CASE      :							str=4				,							SCREAMING_SNAKE_CASE      :							Tuple=True				,							SCREAMING_SNAKE_CASE      :							List[str]=16				,							SCREAMING_SNAKE_CASE      :							Optional[int]=2				,							SCREAMING_SNAKE_CASE      :							int=4				,							SCREAMING_SNAKE_CASE      :							List[str]=4				,							SCREAMING_SNAKE_CASE      :							List[Any]="gelu"				,							SCREAMING_SNAKE_CASE      :							Optional[Any]=0.1				,							SCREAMING_SNAKE_CASE      :							Optional[Any]=0.1				,							SCREAMING_SNAKE_CASE      :							Union[str, Any]=[1, 2, 3, 4, 5]				,							SCREAMING_SNAKE_CASE      :							Tuple=25				,							SCREAMING_SNAKE_CASE      :							Tuple=5				,							):
           _A					:     Tuple     = d_model
           _A					:     Dict     = parent
           _A					:     Optional[Any]     = batch_size
           _A					:     Tuple     = prediction_length
           _A					:     List[str]     = context_length
           _A					:     Dict     = cardinality
           _A					:     List[Any]     = num_time_features
           _A					:     Optional[int]     = lags_sequence
           _A					:     int     = embedding_dimension
           _A					:     Optional[int]     = is_training
           _A					:     Tuple     = hidden_size
           _A					:     Any     = num_hidden_layers
           _A					:     Dict     = num_attention_heads
           _A					:     List[str]     = intermediate_size
           _A					:     Tuple     = hidden_act
           _A					:     List[Any]     = hidden_dropout_prob
           _A					:     List[str]     = attention_probs_dropout_prob

           _A					:     List[Any]     = context_length
           _A					:     int     = prediction_length + label_length
           _A					:     Tuple     = label_length

           _A					:     Optional[int]     = moving_average
           _A					:     Optional[int]     = autocorrelation_factor


    def        A   (  self      :							Dict):
           return AutoformerConfig(
               d_model=self.d_model				,							encoder_layers=self.num_hidden_layers				,							decoder_layers=self.num_hidden_layers				,							encoder_attention_heads=self.num_attention_heads				,							decoder_attention_heads=self.num_attention_heads				,							encoder_ffn_dim=self.intermediate_size				,							decoder_ffn_dim=self.intermediate_size				,							dropout=self.hidden_dropout_prob				,							attention_dropout=self.attention_probs_dropout_prob				,							prediction_length=self.prediction_length				,							context_length=self.context_length				,							label_length=self.label_length				,							lags_sequence=self.lags_sequence				,							num_time_features=self.num_time_features				,							num_static_categorical_features=1				,							cardinality=[self.cardinality]				,							embedding_dimension=[self.embedding_dimension]				,							moving_average=self.moving_average				,							)


    def        A   (  self      :							Any				,							SCREAMING_SNAKE_CASE      :							Union[str, Any]):
           _A					:     Any     = config.context_length + max(config.lags_sequence)

           _A					:     Any     = ids_tensor([self.batch_size, 1]				,							config.cardinality[0])
           _A					:     List[str]     = floats_tensor([self.batch_size, _past_length, config.num_time_features])
           _A					:     Optional[int]     = floats_tensor([self.batch_size, _past_length])
           _A					:     Tuple     = floats_tensor([self.batch_size, _past_length]) > 0.5

           # decoder inputs
           _A					:     Dict     = floats_tensor([self.batch_size, config.prediction_length, config.num_time_features])
           _A					:     Union[str, Any]     = floats_tensor([self.batch_size, config.prediction_length])

           _A					:     int     = {
               'past_values': past_values,
               'static_categorical_features': static_categorical_features,
               'past_time_features': past_time_features,
               'past_observed_mask': past_observed_mask,
               'future_time_features': future_time_features,
               'future_values': future_values,
           }
           return inputs_dict


    def        A   (  self      :							str):
           _A					:     List[str]     = self.get_config()
           _A					:     Dict     = self.prepare_autoformer_inputs_dict(SCREAMING_SNAKE_CASE)
           return config, inputs_dict


    def        A   (  self      :							List[str]):
           _A					:     Optional[int]     = self.prepare_config_and_inputs()
           return config, inputs_dict


    def        A   (  self      :							int				,							SCREAMING_SNAKE_CASE      :							Optional[int]				,							SCREAMING_SNAKE_CASE      :							List[Any]):
           _A					:     Dict     = AutoformerModel(config=SCREAMING_SNAKE_CASE).to(SCREAMING_SNAKE_CASE).eval()
           _A					:     Any     = model(**SCREAMING_SNAKE_CASE)

           _A					:     Optional[Any]     = outputs.encoder_last_hidden_state
           _A					:     List[Any]     = outputs.last_hidden_state

           with tempfile.TemporaryDirectory() as tmpdirname:
                  _A					:     Any     = model.get_encoder()
                  encoder.save_pretrained(SCREAMING_SNAKE_CASE)
                  _A					:     Optional[int]     = AutoformerEncoder.from_pretrained(SCREAMING_SNAKE_CASE).to(SCREAMING_SNAKE_CASE)

           _A					:     List[Any]     = model.create_network_inputs(**SCREAMING_SNAKE_CASE)
           _A					:     Optional[Any]     = model.decomposition_layer(transformer_inputs[:, : config.context_length, ...])

           _A					:     List[Any]     = torch.cat(
               (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])				,							dim=-1				,							)
           _A					:     List[Any]     = encoder(inputs_embeds=SCREAMING_SNAKE_CASE)[0]
           self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3)

           _A					:     List[str]     = (
               torch.mean(transformer_inputs[:, : config.context_length, ...]				,							dim=1)
               .unsqueeze(1)
               .repeat(1				,							config.prediction_length				,							1)
           )
           _A					:     str     = torch.zeros(
               [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]				,							device=enc_input.device				,							)

           _A					:     List[Any]     = torch.cat(
               (
                   torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)				,							dim=1),
                   feature[:, config.context_length - config.label_length :, ...],
               )				,							dim=-1				,							)
           _A					:     Tuple     = torch.cat(
               (
                   torch.cat((trend_input[:, -config.label_length :, ...], mean)				,							dim=1),
                   feature[:, config.context_length - config.label_length :, ...],
               )				,							dim=-1				,							)

           with tempfile.TemporaryDirectory() as tmpdirname:
                  _A					:     Optional[int]     = model.get_decoder()
                  decoder.save_pretrained(SCREAMING_SNAKE_CASE)
                  _A					:     Any     = AutoformerDecoder.from_pretrained(SCREAMING_SNAKE_CASE).to(SCREAMING_SNAKE_CASE)

           _A					:     int     = decoder(
               trend=SCREAMING_SNAKE_CASE				,							inputs_embeds=SCREAMING_SNAKE_CASE				,							encoder_hidden_states=SCREAMING_SNAKE_CASE				,							)[0]

           self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3)




@require_torch
class 			__lowerCamelCase			(	a_    , a_    , unittest.TestCase	):
    """simple docstring"""
    a													=   (AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
    a													=   (AutoformerForPrediction,) if is_torch_available() else ()
    a													=   {"feature-extraction": AutoformerModel} if is_torch_available() else {}
    a													=   False
    a													=   False
    a													=   False
    a													=   False
    a													=   False
    a													=   False


    def        A   (  self      :							List[str]):
           _A					:     Optional[int]     = AutoformerModelTester(self)
           _A					:     Union[str, Any]     = ConfigTester(self				,							config_class=SCREAMING_SNAKE_CASE				,							has_text_modality=SCREAMING_SNAKE_CASE)


    def        A   (  self      :							List[Any]):
           self.config_tester.run_common_tests()


    def        A   (  self      :							Union[str, Any]):
           _A					:     List[str]     = self.model_tester.prepare_config_and_inputs()
           for model_class in self.all_model_classes:
                  _A					:     Any     = model_class(SCREAMING_SNAKE_CASE)

                  with tempfile.TemporaryDirectory() as tmpdirname:
                         model.save_pretrained(SCREAMING_SNAKE_CASE)
                         _A					:     str     = model_class.from_pretrained(SCREAMING_SNAKE_CASE				,							output_loading_info=SCREAMING_SNAKE_CASE)
                  self.assertEqual(info['missing_keys']				,							[])


    def        A   (  self      :							int):
           _A					:     Dict     = self.model_tester.prepare_config_and_inputs_for_common()
           self.model_tester.check_encoder_decoder_model_standalone(*SCREAMING_SNAKE_CASE)


    @unittest.skip(reason='Model has no tokens embeddings')
    def        A   (  self      :							Any):
           pass


    def        A   (  self      :							List[str]):
           _A					:     Dict     = inspect.signature(getattr(SCREAMING_SNAKE_CASE				,							'forward'))
           # The main input is the name of the argument after `self`
           _A					:     str     = list(model_signature.parameters.keys())[1]
           self.assertEqual(AutoformerModel.main_input_name				,							SCREAMING_SNAKE_CASE)


    def        A   (  self      :							Optional[int]):
           _A					:     int     = self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                  _A					:     List[str]     = model_class(SCREAMING_SNAKE_CASE)
                  _A					:     Union[str, Any]     = inspect.signature(model.forward)
                  # signature.parameters is an OrderedDict => so arg_names order is deterministic
                  _A					:     Any     = [*signature.parameters.keys()]

                  _A					:     str     = [
                      'past_values',
                      'past_time_features',
                      'past_observed_mask',
                      'static_categorical_features',
                      'static_real_features',
                      'future_values',
                      'future_time_features',
                  ]

                  if model.__class__.__name__ in ["AutoformerForPrediction"]:
                         expected_arg_names.append('future_observed_mask')

                  expected_arg_names.extend(
                      [
                          'decoder_attention_mask',
                          'head_mask',
                          'decoder_head_mask',
                          'cross_attn_head_mask',
                          'encoder_outputs',
                          'past_key_values',
                          'output_hidden_states',
                          'output_attentions',
                          'use_cache',
                          'return_dict',
                      ])

                  self.assertListEqual(arg_names[: len(SCREAMING_SNAKE_CASE)]				,							SCREAMING_SNAKE_CASE)


    def        A   (  self      :							Union[str, Any]):
           _A					:     List[str]     = self.model_tester.prepare_config_and_inputs_for_common()
           _A					:     int     = True

           _A					:     Optional[int]     = getattr(self.model_tester				,							'seq_length'				,							SCREAMING_SNAKE_CASE)
           _A					:     Dict     = getattr(self.model_tester				,							'decoder_seq_length'				,							SCREAMING_SNAKE_CASE)
           _A					:     Any     = getattr(self.model_tester				,							'encoder_seq_length'				,							SCREAMING_SNAKE_CASE)
           _A					:     Optional[Any]     = getattr(self.model_tester				,							'd_model'				,							SCREAMING_SNAKE_CASE)
           _A					:     Tuple     = getattr(self.model_tester				,							'num_attention_heads'				,							SCREAMING_SNAKE_CASE)
           _A					:     int     = d_model // num_attention_heads

           for model_class in self.all_model_classes:
                  _A					:     str     = True
                  _A					:     int     = False
                  _A					:     Tuple     = True
                  _A					:     str     = model_class(SCREAMING_SNAKE_CASE)
                  model.to(SCREAMING_SNAKE_CASE)
                  model.eval()
                  with torch.no_grad():
                         _A					:     Tuple     = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE))
                  _A					:     Any     = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
                  self.assertEqual(len(SCREAMING_SNAKE_CASE)				,							self.model_tester.num_hidden_layers)

                  # check that output_attentions also work using config
                  del inputs_dict["output_attentions"]
                  _A					:     List[str]     = True
                  _A					:     List[Any]     = model_class(SCREAMING_SNAKE_CASE)
                  model.to(SCREAMING_SNAKE_CASE)
                  model.eval()
                  with torch.no_grad():
                         _A					:     Any     = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE))
                  _A					:     Optional[int]     = outputs.encoder_attentions
                  self.assertEqual(len(SCREAMING_SNAKE_CASE)				,							self.model_tester.num_hidden_layers)

                  self.assertListEqual(
                      list(attentions[0].shape[-3:])				,							[self.model_tester.num_attention_heads, encoder_seq_length, dim]				,							)
                  _A					:     Union[str, Any]     = len(SCREAMING_SNAKE_CASE)

                  _A					:     Tuple     = 7

                  if "last_hidden_state" in outputs:
                         correct_outlen += 1

                  if "trend" in outputs:
                         correct_outlen += 1

                  if "past_key_values" in outputs:
                         correct_outlen += 1  # past_key_values have been returned

                  if "loss" in outputs:
                         correct_outlen += 1

                  if "params" in outputs:
                         correct_outlen += 1

                  self.assertEqual(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)

                  # decoder attentions
                  _A					:     List[Any]     = outputs.decoder_attentions
                  self.assertIsInstance(SCREAMING_SNAKE_CASE				,							(list, tuple))
                  self.assertEqual(len(SCREAMING_SNAKE_CASE)				,							self.model_tester.num_hidden_layers)
                  self.assertListEqual(
                      list(decoder_attentions[0].shape[-3:])				,							[self.model_tester.num_attention_heads, decoder_seq_length, dim]				,							)

                  # cross attentions
                  _A					:     Optional[int]     = outputs.cross_attentions
                  self.assertIsInstance(SCREAMING_SNAKE_CASE				,							(list, tuple))
                  self.assertEqual(len(SCREAMING_SNAKE_CASE)				,							self.model_tester.num_hidden_layers)
                  self.assertListEqual(
                      list(cross_attentions[0].shape[-3:])				,							[self.model_tester.num_attention_heads, decoder_seq_length, dim]				,							)

           # Check attention is always last and order is fine
           _A					:     Tuple     = True
           _A					:     List[Any]     = True
           _A					:     int     = model_class(SCREAMING_SNAKE_CASE)
           model.to(SCREAMING_SNAKE_CASE)
           model.eval()
           with torch.no_grad():
                  _A					:     Tuple     = model(**self._prepare_for_class(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE))

           self.assertEqual(out_len + 2				,							len(SCREAMING_SNAKE_CASE))

           _A					:     int     = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

           self.assertEqual(len(SCREAMING_SNAKE_CASE)				,							self.model_tester.num_hidden_layers)
           self.assertListEqual(
               list(self_attentions[0].shape[-3:])				,							[self.model_tester.num_attention_heads, encoder_seq_length, dim]				,							)


    @is_flaky()
    def        A   (  self      :							int):
           super().test_retain_grad_hidden_states_attentions()




def 				lowerCAmelCase__	(    lowerCamelCase					:      Union[str, Any]="train-batch.pt"       ):
       _A					:     Any     = hf_hub_download(repo_id='hf-internal-testing/tourism-monthly-batch'  ,filename=lowerCamelCase  ,repo_type='dataset'       )
       _A					:     Optional[Any]     = torch.load(lowerCamelCase  ,map_location=lowerCamelCase       )
       return batch


@require_torch
@slow
class 			__lowerCamelCase			(	unittest.TestCase	):
    """simple docstring"""


    def        A   (  self      :							int):
           _A					:     Any     = AutoformerModel.from_pretrained('huggingface/autoformer-tourism-monthly').to(SCREAMING_SNAKE_CASE)
           _A					:     int     = prepare_batch()

           with torch.no_grad():
                  _A					:     Dict     = model(
                      past_values=batch['past_values']				,							past_time_features=batch['past_time_features']				,							past_observed_mask=batch['past_observed_mask']				,							static_categorical_features=batch['static_categorical_features']				,							future_values=batch['future_values']				,							future_time_features=batch['future_time_features']				,							)[0]

           _A					:     Any     = torch.Size(
               (64, model.config.prediction_length + model.config.label_length, model.config.feature_size))
           self.assertEqual(output.shape				,							SCREAMING_SNAKE_CASE)

           _A					:     Union[str, Any]     = torch.tensor(
               [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]]				,							device=SCREAMING_SNAKE_CASE)
           self.assertTrue(torch.allclose(output[0, :3, :3]				,							SCREAMING_SNAKE_CASE				,							atol=SCREAMING_SNAKE_CASE))


    def        A   (  self      :							Dict):
           _A					:     Optional[int]     = AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly').to(SCREAMING_SNAKE_CASE)
           _A					:     Any     = prepare_batch('val-batch.pt')
           with torch.no_grad():
                  _A					:     Tuple     = model(
                      past_values=batch['past_values']				,							past_time_features=batch['past_time_features']				,							past_observed_mask=batch['past_observed_mask']				,							static_categorical_features=batch['static_categorical_features']				,							).encoder_last_hidden_state
           _A					:     Optional[int]     = torch.Size((64, model.config.context_length, model.config.d_model))
           self.assertEqual(output.shape				,							SCREAMING_SNAKE_CASE)

           _A					:     List[Any]     = torch.tensor(
               [[-0.0734, -0.9036, 0.8358], [4.7186, 2.4113, 1.9581], [1.7953, 2.3558, 1.2970]]				,							device=SCREAMING_SNAKE_CASE)
           self.assertTrue(torch.allclose(output[0, :3, :3]				,							SCREAMING_SNAKE_CASE				,							atol=SCREAMING_SNAKE_CASE))


    def        A   (  self      :							str):
           _A					:     int     = AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly').to(SCREAMING_SNAKE_CASE)
           _A					:     int     = prepare_batch('val-batch.pt')
           with torch.no_grad():
                  _A					:     str     = model.generate(
                      static_categorical_features=batch['static_categorical_features']				,							past_time_features=batch['past_time_features']				,							past_values=batch['past_values']				,							future_time_features=batch['future_time_features']				,							past_observed_mask=batch['past_observed_mask']				,							)
           _A					:     int     = torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length))
           self.assertEqual(outputs.sequences.shape				,							SCREAMING_SNAKE_CASE)

           _A					:     Union[str, Any]     = torch.tensor([3130.6763, 4056.5293, 7053.0786]				,							device=SCREAMING_SNAKE_CASE)
           _A					:     List[Any]     = outputs.sequences.mean(dim=1)
           self.assertTrue(torch.allclose(mean_prediction[0, -3:]				,							SCREAMING_SNAKE_CASE				,							rtol=1e-1))










'''simple docstring'''







from typing import TYPE_CHECKING

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


A				:					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:
   A				:					int    						=			['''ElectraTokenizerFast''']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A				:					List[str]    						=			[
       '''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:
   A				:					Dict    						=			[
       '''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:
   A				:					List[Any]    						=			[
       '''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

   A				:					Tuple    						=			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






