text: import logging
  import os
  import warnings
  from dataclasses import dataclass
  from typing import Optional, Tuple
  
  import torch
  import torch.nn as nn
  from torch.nn import CrossEntropyLoss, MSELoss
  
  from .activations import get_activation
  from .configuration_electra import ElectraConfig
  from .file_utils import (
      ModelOutput,
      add_code_sample_docstrings,
      add_start_docstrings,
      add_start_docstrings_to_callable,
      replace_return_docstrings,
  )
  from .modeling_bert import BertEmbeddings, BertEncoder, BertLayerNorm, BertPreTrainedModel
  from .modeling_outputs import (
      BaseModelOutput,
      MaskedLMOutput,
      MultipleChoiceModelOutput,
      QuestionAnsweringModelOutput,
      SequenceClassifierOutput,
      TokenClassifierOutput,
  )
  from .modeling_utils import SequenceSummary
  
  
  logger = logging.getLogger(__name__)
  
  _CONFIG_FOR_DOC = "ElectraConfig"
  _TOKENIZER_FOR_DOC = "ElectraTokenizer"
  
  ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST = [
      "google/electra-small-generator",
      "google/electra-base-generator",
      "google/electra-large-generator",
      "google/electra-small-discriminator",
      "google/electra-base-discriminator",
      "google/electra-large-discriminator",
      # See all ELECTRA models at https://huggingface.co/models?filter=electra
  ]
  
  
  def load_tf_weights_in_electra(model, config, tf_checkpoint_path, discriminator_or_generator="discriminator"):
      """ Load tf checkpoints in a pytorch model.
      """
      try:
          import re
  
          import numpy as np
          import tensorflow as tf
      except ImportError:
          logger.error(
              "Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see "
              "https://www.tensorflow.org/install/ for installation instructions."
          )
          raise
      tf_path = os.path.abspath(tf_checkpoint_path)
      logger.info("Converting TensorFlow checkpoint from {}".format(tf_path))
      # Load weights from TF model
      init_vars = tf.train.list_variables(tf_path)
      names = []
      arrays = []
      for name, shape in init_vars:
          logger.info("Loading TF weight {} with shape {}".format(name, shape))
          array = tf.train.load_variable(tf_path, name)
          names.append(name)
          arrays.append(array)
      for name, array in zip(names, arrays):
          original_name: str = name
  
          try:
              if isinstance(model, ElectraForMaskedLM):
                  name = name.replace("electra/embeddings/", "generator/embeddings/")
  
              if discriminator_or_generator == "generator":
                  name = name.replace("electra/", "discriminator/")
                  name = name.replace("generator/", "electra/")
  
              name = name.replace("dense_1", "dense_prediction")
              name = name.replace("generator_predictions/output_bias", "generator_lm_head/bias")
  
              name = name.split("/")
              # print(original_name, name)
              # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v
              # which are not required for using pretrained model
              if any(n in ["global_step", "temperature"] for n in name):
                  logger.info("Skipping {}".format(original_name))
                  continue
              pointer = model
              for m_name in name:
                  if re.fullmatch(r"[A-Za-z]+_\d+", m_name):
                      scope_names = re.split(r"_(\d+)", m_name)
                  else:
                      scope_names = [m_name]
                  if scope_names[0] == "kernel" or scope_names[0] == "gamma":
                      pointer = getattr(pointer, "weight")
                  elif scope_names[0] == "output_bias" or scope_names[0] == "beta":
                      pointer = getattr(pointer, "bias")
                  elif scope_names[0] == "output_weights":
                      pointer = getattr(pointer, "weight")
                  elif scope_names[0] == "squad":
                      pointer = getattr(pointer, "classifier")
                  else:
                      pointer = getattr(pointer, scope_names[0])
                  if len(scope_names) >= 2:
                      num = int(scope_names[1])
                      pointer = pointer[num]
              if m_name.endswith("_embeddings"):
                  pointer = getattr(pointer, "weight")
              elif m_name == "kernel":
                  array = np.transpose(array)
              try:
                  assert (
                      pointer.shape == array.shape
                  ), f"Pointer shape {pointer.shape} and array shape {array.shape} mismatched"
              except AssertionError as e:
                  e.args += (pointer.shape, array.shape)
                  raise
              print("Initialize PyTorch weight {}".format(name), original_name)
              pointer.data = torch.from_numpy(array)
          except AttributeError as e:
              print("Skipping {}".format(original_name), name, e)
              continue
      return model
  
  
  class ElectraEmbeddings(BertEmbeddings):
      """Construct the embeddings from word, position and token_type embeddings."""
  
      def __init__(self, config):
          super().__init__(config)
          self.word_embeddings = nn.Embedding(config.vocab_size, config.embedding_size, padding_idx=config.pad_token_id)
          self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.embedding_size)
          self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.embedding_size)
  
          # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
          # any TensorFlow checkpoint file
          self.LayerNorm = BertLayerNorm(config.embedding_size, eps=config.layer_norm_eps)
  
  
  class ElectraDiscriminatorPredictions(nn.Module):
      """Prediction module for the discriminator, made up of two dense layers."""
  
      def __init__(self, config):
          super().__init__()
  
          self.dense = nn.Linear(config.hidden_size, config.hidden_size)
          self.dense_prediction = nn.Linear(config.hidden_size, 1)
          self.config = config
  
      def forward(self, discriminator_hidden_states):
          hidden_states = self.dense(discriminator_hidden_states)
          hidden_states = get_activation(self.config.hidden_act)(hidden_states)
          logits = self.dense_prediction(hidden_states).squeeze()
  
          return logits
  
  
  class ElectraGeneratorPredictions(nn.Module):
      """Prediction module for the generator, made up of two dense layers."""
  
      def __init__(self, config):
          super().__init__()
  
          self.LayerNorm = BertLayerNorm(config.embedding_size)
          self.dense = nn.Linear(config.hidden_size, config.embedding_size)
  
      def forward(self, generator_hidden_states):
          hidden_states = self.dense(generator_hidden_states)
          hidden_states = get_activation("gelu")(hidden_states)
          hidden_states = self.LayerNorm(hidden_states)
  
          return hidden_states
  
  
  class ElectraPreTrainedModel(BertPreTrainedModel):
      """ An abstract class to handle weights initialization and
          a simple interface for downloading and loading pretrained models.
      """
  
      config_class = ElectraConfig
      load_tf_weights = load_tf_weights_in_electra
      base_model_prefix = "electra"
  
  
  @dataclass
  class ElectraForPreTrainingOutput(ModelOutput):
      """
      Output type of :class:`~transformers.ElectraForPreTrainingModel`.
  
      Args:
          loss (`optional`, returned when ``labels`` is provided, ``torch.FloatTensor`` of shape :obj:`(1,)`):
              Total loss of the ELECTRA objective.
          logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`):
              Prediction scores of the head (scores for each token before SoftMax).
          hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``):
              Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
              of shape :obj:`(batch_size, sequence_length, hidden_size)`.
  
              Hidden-states of the model at the output of each layer plus the initial embedding outputs.
          attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``):
              Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape
              :obj:`(batch_size, num_heads, sequence_length, sequence_length)`.
  
              Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
              heads.
      """
  
      loss: Optional[torch.FloatTensor] = None
      logits: torch.FloatTensor = None
      hidden_states: Optional[Tuple[torch.FloatTensor]] = None
      attentions: Optional[Tuple[torch.FloatTensor]] = None
  
  
  ELECTRA_START_DOCSTRING = r"""
      This model is a PyTorch `torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>`_ sub-class.
      Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general
      usage and behavior.
  
      Parameters:
          config (:class:`~transformers.ElectraConfig`): Model configuration class with all the parameters of the model.
              Initializing with a config file does not load the weights associated with the model, only the configuration.
              Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model weights.
  """
  
  ELECTRA_INPUTS_DOCSTRING = r"""
      Args:
          input_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`):
              Indices of input sequence tokens in the vocabulary.
  
              Indices can be obtained using :class:`transformers.ElectraTokenizer`.
              See :func:`transformers.PreTrainedTokenizer.encode` and
              :func:`transformers.PreTrainedTokenizer.__call__` for details.
  
              `What are input IDs? <../glossary.html#input-ids>`__
          attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
              Mask to avoid performing attention on padding token indices.
              Mask values selected in ``[0, 1]``:
              ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
  
              `What are attention masks? <../glossary.html#attention-mask>`__
          token_type_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
              Segment token indices to indicate first and second portions of the inputs.
              Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1``
              corresponds to a `sentence B` token
  
              `What are token type IDs? <../glossary.html#token-type-ids>`_
          position_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
              Indices of positions of each input sequence tokens in the position embeddings.
              Selected in the range ``[0, config.max_position_embeddings - 1]``.
  
              `What are position IDs? <../glossary.html#position-ids>`_
          head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`, defaults to :obj:`None`):
              Mask to nullify selected heads of the self-attention modules.
              Mask values selected in ``[0, 1]``:
              :obj:`1` indicates the head is **not masked**, :obj:`0` indicates the head is **masked**.
          inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
              Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.
              This is useful if you want more control over how to convert `input_ids` indices into associated vectors
              than the model's internal embedding lookup matrix.
          encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
              Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
              if the model is configured as a decoder.
          encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
              Mask to avoid performing attention on the padding token indices of the encoder input. This mask
              is used in the cross-attention if the model is configured as a decoder.
              Mask values selected in ``[0, 1]``:
              ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
          output_attentions (:obj:`bool`, `optional`, defaults to :obj:`None`):
              If set to ``True``, the attentions tensors of all attention layers are returned. See ``attentions`` under returned tensors for more detail.
          output_hidden_states (:obj:`bool`, `optional`, defaults to :obj:`None`):
              If set to ``True``, the hidden states of all layers are returned. See ``hidden_states`` under returned tensors for more detail.
          return_dict (:obj:`bool`, `optional`, defaults to :obj:`None`):
              If set to ``True``, the model will return a :class:`~transformers.file_utils.ModelOutput` instead of a
              plain tuple.
  """
  
  
  @add_start_docstrings(
      "The bare Electra Model transformer outputting raw hidden-states without any specific head on top. Identical to "
      "the BERT model except that it uses an additional linear layer between the embedding layer and the encoder if the "
      "hidden size and embedding size are different."
      ""
      "Both the generator and discriminator checkpoints may be loaded into this model.",
      ELECTRA_START_DOCSTRING,
  )
  class ElectraModel(ElectraPreTrainedModel):
  
      config_class = ElectraConfig
  
      def __init__(self, config):
          super().__init__(config)
          self.embeddings = ElectraEmbeddings(config)
  
          if config.embedding_size != config.hidden_size:
              self.embeddings_project = nn.Linear(config.embedding_size, config.hidden_size)
  
          self.encoder = BertEncoder(config)
          self.config = config
          self.init_weights()
  
      def get_input_embeddings(self):
          return self.embeddings.word_embeddings
  
      def set_input_embeddings(self, value):
          self.embeddings.word_embeddings = value
  
      def _prune_heads(self, heads_to_prune):
          """ Prunes heads of the model.
              heads_to_prune: dict of {layer_num: list of heads to prune in this layer}
              See base class PreTrainedModel
          """
          for layer, heads in heads_to_prune.items():
              self.encoder.layer[layer].attention.prune_heads(heads)
  
      @add_start_docstrings_to_callable(ELECTRA_INPUTS_DOCSTRING)
      @add_code_sample_docstrings(
          tokenizer_class=_TOKENIZER_FOR_DOC,
          checkpoint="google/electra-small-discriminator",
          output_type=BaseModelOutput,
          config_class=_CONFIG_FOR_DOC,
      )
      def forward(
          self,
          input_ids=None,
          attention_mask=None,
          token_type_ids=None,
          position_ids=None,
          head_mask=None,
          inputs_embeds=None,
          output_attentions=None,
          output_hidden_states=None,
          return_dict=None,
      ):
          output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
          output_hidden_states = (
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          return_dict = return_dict if return_dict is not None else self.config.use_return_dict
  
          if input_ids is not None and inputs_embeds is not None:
              raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
          elif input_ids is not None:
              input_shape = input_ids.size()
          elif inputs_embeds is not None:
              input_shape = inputs_embeds.size()[:-1]
          else:
              raise ValueError("You have to specify either input_ids or inputs_embeds")
  
          device = input_ids.device if input_ids is not None else inputs_embeds.device
  
          if attention_mask is None:
              attention_mask = torch.ones(input_shape, device=device)
          if token_type_ids is None:
              token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
  
          extended_attention_mask = self.get_extended_attention_mask(attention_mask, input_shape, device)
          head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
  
          hidden_states = self.embeddings(
              input_ids=input_ids, position_ids=position_ids, token_type_ids=token_type_ids, inputs_embeds=inputs_embeds
          )
  
          if hasattr(self, "embeddings_project"):
              hidden_states = self.embeddings_project(hidden_states)
  
          hidden_states = self.encoder(
              hidden_states,
              attention_mask=extended_attention_mask,
              head_mask=head_mask,
              output_attentions=output_attentions,
              output_hidden_states=output_hidden_states,
              return_dict=return_dict,
          )
  
          return hidden_states
  
  
  class ElectraClassificationHead(nn.Module):
      """Head for sentence-level classification tasks."""
  
      def __init__(self, config):
          super().__init__()
          self.dense = nn.Linear(config.hidden_size, config.hidden_size)
          self.dropout = nn.Dropout(config.hidden_dropout_prob)
          self.out_proj = nn.Linear(config.hidden_size, config.num_labels)
  
      def forward(self, features, **kwargs):
          x = features[:, 0, :]  # take <s> token (equiv. to [CLS])
          x = self.dropout(x)
          x = self.dense(x)
          x = get_activation("gelu")(x)  # although BERT uses tanh here, it seems Electra authors used gelu here
          x = self.dropout(x)
          x = self.out_proj(x)
          return x
  
  
  @add_start_docstrings(
      """ELECTRA Model transformer with a sequence classification/regression head on top (a linear layer on top of
      the pooled output) e.g. for GLUE tasks. """,
      ELECTRA_START_DOCSTRING,
  )
  class ElectraForSequenceClassification(ElectraPreTrainedModel):
      def __init__(self, config):
          super().__init__(config)
          self.num_labels = config.num_labels
          self.electra = ElectraModel(config)
          self.classifier = ElectraClassificationHead(config)
  
          self.init_weights()
  
      @add_start_docstrings_to_callable(ELECTRA_INPUTS_DOCSTRING)
      @add_code_sample_docstrings(
          tokenizer_class=_TOKENIZER_FOR_DOC,
          checkpoint="google/electra-small-discriminator",
          output_type=SequenceClassifierOutput,
          config_class=_CONFIG_FOR_DOC,
      )
      def forward(
          self,
          input_ids=None,
          attention_mask=None,
          token_type_ids=None,
          position_ids=None,
          head_mask=None,
          inputs_embeds=None,
          labels=None,
          output_attentions=None,
          output_hidden_states=None,
          return_dict=None,
      ):
          r"""
          labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
              Labels for computing the sequence classification/regression loss.
              Indices should be in :obj:`[0, ..., config.num_labels - 1]`.
              If :obj:`config.num_labels == 1` a regression loss is computed (Mean-Square loss),
              If :obj:`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
          """
          return_dict = return_dict if return_dict is not None else self.config.use_return_dict
  
          discriminator_hidden_states = self.electra(
              input_ids,
              attention_mask,
              token_type_ids,
              position_ids,
              head_mask,
              inputs_embeds,
              output_attentions,
              output_hidden_states,
              return_dict,
          )
  
          sequence_output = discriminator_hidden_states[0]
          logits = self.classifier(sequence_output)
  
          loss = None
          if labels is not None:
              if self.num_labels == 1:
                  #  We are doing regression
                  loss_fct = MSELoss()
                  loss = loss_fct(logits.view(-1), labels.view(-1))
              else:
                  loss_fct = CrossEntropyLoss()
                  loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
  
          if not return_dict:
              output = (logits,) + discriminator_hidden_states[1:]
              return ((loss,) + output) if loss is not None else output
  
          return SequenceClassifierOutput(
              loss=loss,
              logits=logits,
              hidden_states=discriminator_hidden_states.hidden_states,
              attentions=discriminator_hidden_states.attentions,
          )
  
  
  @add_start_docstrings(
      """
      Electra model with a binary classification head on top as used during pre-training for identifying generated
      tokens.
  
      It is recommended to load the discriminator checkpoint into that model.""",
      ELECTRA_START_DOCSTRING,
  )
  class ElectraForPreTraining(ElectraPreTrainedModel):
      def __init__(self, config):
          super().__init__(config)
  
          self.electra = ElectraModel(config)
          self.discriminator_predictions = ElectraDiscriminatorPredictions(config)
          self.init_weights()
  
      @add_start_docstrings_to_callable(ELECTRA_INPUTS_DOCSTRING)
      @replace_return_docstrings(output_type=ElectraForPreTrainingOutput, config_class=_CONFIG_FOR_DOC)
      def forward(
          self,
          input_ids=None,
          attention_mask=None,
          token_type_ids=None,
          position_ids=None,
          head_mask=None,
          inputs_embeds=None,
          labels=None,
          output_attentions=None,
          output_hidden_states=None,
          return_dict=None,
      ):
          r"""
          labels (``torch.LongTensor`` of shape ``(batch_size, sequence_length)``, `optional`, defaults to :obj:`None`):
              Labels for computing the ELECTRA loss. Input should be a sequence of tokens (see :obj:`input_ids` docstring)
              Indices should be in ``[0, 1]``.
              ``0`` indicates the token is an original token,
              ``1`` indicates the token was replaced.
  
      Returns:
  
      Examples::
  
          >>> from transformers import ElectraTokenizer, ElectraForPreTraining
          >>> import torch
  
          >>> tokenizer = ElectraTokenizer.from_pretrained('google/electra-small-discriminator')
          >>> model = ElectraForPreTraining.from_pretrained('google/electra-small-discriminator')
  
          >>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0)  # Batch size 1
          >>> logits = model(input_ids).logits
          """
          return_dict = return_dict if return_dict is not None else self.config.use_return_dict
  
          discriminator_hidden_states = self.electra(
              input_ids,
              attention_mask,
              token_type_ids,
              position_ids,
              head_mask,
              inputs_embeds,
              output_attentions,
              output_hidden_states,
              return_dict,
          )
          discriminator_sequence_output = discriminator_hidden_states[0]
  
          logits = self.discriminator_predictions(discriminator_sequence_output)
  
          loss = None
          if labels is not None:
              loss_fct = nn.BCEWithLogitsLoss()
              if attention_mask is not None:
                  active_loss = attention_mask.view(-1, discriminator_sequence_output.shape[1]) == 1
                  active_logits = logits.view(-1, discriminator_sequence_output.shape[1])[active_loss]
                  active_labels = labels[active_loss]
                  loss = loss_fct(active_logits, active_labels.float())
              else:
                  loss = loss_fct(logits.view(-1, discriminator_sequence_output.shape[1]), labels.float())
  
          if not return_dict:
              output = (logits,) + discriminator_hidden_states[1:]
              return ((loss,) + output) if loss is not None else output
  
          return ElectraForPreTrainingOutput(
              loss=loss,
              logits=logits,
              hidden_states=discriminator_hidden_states.hidden_states,
              attentions=discriminator_hidden_states.attentions,
          )
  
  
  @add_start_docstrings(
      """
      Electra model with a language modeling head on top.
  
      Even though both the discriminator and generator may be loaded into this model, the generator is
      the only model of the two to have been trained for the masked language modeling task.""",
      ELECTRA_START_DOCSTRING,
  )
  class ElectraForMaskedLM(ElectraPreTrainedModel):
      def __init__(self, config):
          super().__init__(config)
  
          self.electra = ElectraModel(config)
          self.generator_predictions = ElectraGeneratorPredictions(config)
  
          self.generator_lm_head = nn.Linear(config.embedding_size, config.vocab_size)
          self.init_weights()
  
      def get_output_embeddings(self):
          return self.generator_lm_head
  
      @add_start_docstrings_to_callable(ELECTRA_INPUTS_DOCSTRING)
      @add_code_sample_docstrings(
          tokenizer_class=_TOKENIZER_FOR_DOC,
          checkpoint="google/electra-small-discriminator",
          output_type=MaskedLMOutput,
          config_class=_CONFIG_FOR_DOC,
      )
      def forward(
          self,
          input_ids=None,
          attention_mask=None,
          token_type_ids=None,
          position_ids=None,
          head_mask=None,
          inputs_embeds=None,
          labels=None,
          output_attentions=None,
          output_hidden_states=None,
          return_dict=None,
          **kwargs
      ):
          r"""
          labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
              Labels for computing the masked language modeling loss.
              Indices should be in ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring)
              Tokens with indices set to ``-100`` are ignored (masked), the loss is only computed for the tokens with labels
              in ``[0, ..., config.vocab_size]``
          kwargs (:obj:`Dict[str, any]`, optional, defaults to `{}`):
              Used to hide legacy arguments that have been deprecated.
          """
          if "masked_lm_labels" in kwargs:
              warnings.warn(
                  "The `masked_lm_labels` argument is deprecated and will be removed in a future version, use `labels` instead.",
                  FutureWarning,
              )
              labels = kwargs.pop("masked_lm_labels")
          assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
          return_dict = return_dict if return_dict is not None else self.config.use_return_dict
  
          generator_hidden_states = self.electra(
              input_ids,
              attention_mask,
              token_type_ids,
              position_ids,
              head_mask,
              inputs_embeds,
              output_attentions,
              output_hidden_states,
              return_dict,
          )
          generator_sequence_output = generator_hidden_states[0]
  
          prediction_scores = self.generator_predictions(generator_sequence_output)
          prediction_scores = self.generator_lm_head(prediction_scores)
  
          loss = None
          # Masked language modeling softmax layer
          if labels is not None:
              loss_fct = nn.CrossEntropyLoss()  # -100 index = padding token
              loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
  
          if not return_dict:
              output = (prediction_scores,) + generator_hidden_states[1:]
              return ((loss,) + output) if loss is not None else output
  
          return MaskedLMOutput(
              loss=loss,
              logits=prediction_scores,
              hidden_states=generator_hidden_states.hidden_states,
              attentions=generator_hidden_states.attentions,
          )
  
  
  @add_start_docstrings(
      """
      Electra model with a token classification head on top.
  
      Both the discriminator and generator may be loaded into this model.""",
      ELECTRA_START_DOCSTRING,
  )
  class ElectraForTokenClassification(ElectraPreTrainedModel):
      def __init__(self, config):
          super().__init__(config)
  
          self.electra = ElectraModel(config)
          self.dropout = nn.Dropout(config.hidden_dropout_prob)
          self.classifier = nn.Linear(config.hidden_size, config.num_labels)
          self.init_weights()
  
      @add_start_docstrings_to_callable(ELECTRA_INPUTS_DOCSTRING)
      @add_code_sample_docstrings(
          tokenizer_class=_TOKENIZER_FOR_DOC,
          checkpoint="google/electra-small-discriminator",
          output_type=TokenClassifierOutput,
          config_class=_CONFIG_FOR_DOC,
      )
      def forward(
          self,
          input_ids=None,
          attention_mask=None,
          token_type_ids=None,
          position_ids=None,
          head_mask=None,
          inputs_embeds=None,
          labels=None,
          output_attentions=None,
          output_hidden_states=None,
          return_dict=None,
      ):
          r"""
          labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
              Labels for computing the token classification loss.
              Indices should be in ``[0, ..., config.num_labels - 1]``.
          """
          return_dict = return_dict if return_dict is not None else self.config.use_return_dict
  
          discriminator_hidden_states = self.electra(
              input_ids,
              attention_mask,
              token_type_ids,
              position_ids,
              head_mask,
              inputs_embeds,
              output_attentions,
              output_hidden_states,
              return_dict,
          )
          discriminator_sequence_output = discriminator_hidden_states[0]
  
          discriminator_sequence_output = self.dropout(discriminator_sequence_output)
          logits = self.classifier(discriminator_sequence_output)
  
          loss = None
          if labels is not None:
              loss_fct = nn.CrossEntropyLoss()
              # Only keep active parts of the loss
              if attention_mask is not None:
                  active_loss = attention_mask.view(-1) == 1
                  active_logits = logits.view(-1, self.config.num_labels)[active_loss]
                  active_labels = labels.view(-1)[active_loss]
                  loss = loss_fct(active_logits, active_labels)
              else:
                  loss = loss_fct(logits.view(-1, self.config.num_labels), labels.view(-1))
  
          if not return_dict:
              output = (logits,) + discriminator_hidden_states[1:]
              return ((loss,) + output) if loss is not None else output
  
          return TokenClassifierOutput(
              loss=loss,
              logits=logits,
              hidden_states=discriminator_hidden_states.hidden_states,
              attentions=discriminator_hidden_states.attentions,
          )
  
  
  @add_start_docstrings(
      """
      ELECTRA Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
      layers on top of the hidden-states output to compute `span start logits` and `span end logits`).""",
      ELECTRA_START_DOCSTRING,
  )
  class ElectraForQuestionAnswering(ElectraPreTrainedModel):
      config_class = ElectraConfig
      base_model_prefix = "electra"
  
      def __init__(self, config):
          super().__init__(config)
          self.num_labels = config.num_labels
  
          self.electra = ElectraModel(config)
          self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
  
          self.init_weights()
  
      @add_start_docstrings_to_callable(ELECTRA_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
      @add_code_sample_docstrings(
          tokenizer_class=_TOKENIZER_FOR_DOC,
          checkpoint="google/electra-small-discriminator",
          output_type=QuestionAnsweringModelOutput,
          config_class=_CONFIG_FOR_DOC,
      )
      def forward(
          self,
          input_ids=None,
          attention_mask=None,
          token_type_ids=None,
          position_ids=None,
          head_mask=None,
          inputs_embeds=None,
          start_positions=None,
          end_positions=None,
          output_attentions=None,
          output_hidden_states=None,
          return_dict=None,
      ):
          r"""
          start_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
              Labels for position (index) of the start of the labelled span for computing the token classification loss.
              Positions are clamped to the length of the sequence (`sequence_length`).
              Position outside of the sequence are not taken into account for computing the loss.
          end_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
              Labels for position (index) of the end of the labelled span for computing the token classification loss.
              Positions are clamped to the length of the sequence (`sequence_length`).
              Position outside of the sequence are not taken into account for computing the loss.
          """
          return_dict = return_dict if return_dict is not None else self.config.use_return_dict
  
          discriminator_hidden_states = self.electra(
              input_ids,
              attention_mask=attention_mask,
              token_type_ids=token_type_ids,
              position_ids=position_ids,
              head_mask=head_mask,
              inputs_embeds=inputs_embeds,
              output_attentions=output_attentions,
              output_hidden_states=output_hidden_states,
          )
  
          sequence_output = discriminator_hidden_states[0]
  
          logits = self.qa_outputs(sequence_output)
          start_logits, end_logits = logits.split(1, dim=-1)
          start_logits = start_logits.squeeze(-1)
          end_logits = end_logits.squeeze(-1)
  
          total_loss = None
          if start_positions is not None and end_positions is not None:
              # If we are on multi-GPU, split add a dimension
              if len(start_positions.size()) > 1:
                  start_positions = start_positions.squeeze(-1)
              if len(end_positions.size()) > 1:
                  end_positions = end_positions.squeeze(-1)
              # sometimes the start/end positions are outside our model inputs, we ignore these terms
              ignored_index = start_logits.size(1)
              start_positions.clamp_(0, ignored_index)
              end_positions.clamp_(0, ignored_index)
  
              loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
              start_loss = loss_fct(start_logits, start_positions)
              end_loss = loss_fct(end_logits, end_positions)
              total_loss = (start_loss + end_loss) / 2
  
          if not return_dict:
              output = (start_logits, end_logits,) + discriminator_hidden_states[1:]
              return ((total_loss,) + output) if total_loss is not None else output
  
          return QuestionAnsweringModelOutput(
              loss=total_loss,
              start_logits=start_logits,
              end_logits=end_logits,
              hidden_states=discriminator_hidden_states.hidden_states,
              attentions=discriminator_hidden_states.attentions,
          )
  
  
  @add_start_docstrings(
      """ELECTRA Model with a multiple choice classification head on top (a linear layer on top of
      the pooled output and a softmax) e.g. for RocStories/SWAG tasks. """,
      ELECTRA_START_DOCSTRING,
  )
  class ElectraForMultipleChoice(ElectraPreTrainedModel):
      def __init__(self, config):
          super().__init__(config)
  
          self.electra = ElectraModel(config)
          self.sequence_summary = SequenceSummary(config)
          self.classifier = nn.Linear(config.hidden_size, 1)
  
          self.init_weights()
  
      @add_start_docstrings_to_callable(ELECTRA_INPUTS_DOCSTRING.format("(batch_size, num_choices, sequence_length)"))
      @add_code_sample_docstrings(
          tokenizer_class=_TOKENIZER_FOR_DOC,
          checkpoint="google/electra-small-discriminator",
          output_type=MultipleChoiceModelOutput,
          config_class=_CONFIG_FOR_DOC,
      )
      def forward(
          self,
          input_ids=None,
          attention_mask=None,
          token_type_ids=None,
          position_ids=None,
          head_mask=None,
          inputs_embeds=None,
          labels=None,
          output_attentions=None,
          output_hidden_states=None,
          return_dict=None,
      ):
          r"""
          labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
              Labels for computing the multiple choice classification loss.
              Indices should be in ``[0, ..., num_choices-1]`` where `num_choices` is the size of the second dimension
              of the input tensors. (see `input_ids` above)
          """
          return_dict = return_dict if return_dict is not None else self.config.use_return_dict
          num_choices = input_ids.shape[1] if input_ids is not None else inputs_embeds.shape[1]
  
          input_ids = input_ids.view(-1, input_ids.size(-1)) if input_ids is not None else None
          attention_mask = attention_mask.view(-1, attention_mask.size(-1)) if attention_mask is not None else None
          token_type_ids = token_type_ids.view(-1, token_type_ids.size(-1)) if token_type_ids is not None else None
          position_ids = position_ids.view(-1, position_ids.size(-1)) if position_ids is not None else None
          inputs_embeds = (
              inputs_embeds.view(-1, inputs_embeds.size(-2), inputs_embeds.size(-1))
              if inputs_embeds is not None
              else None
          )
  
          discriminator_hidden_states = self.electra(
              input_ids,
              attention_mask=attention_mask,
              token_type_ids=token_type_ids,
              position_ids=position_ids,
              head_mask=head_mask,
              inputs_embeds=inputs_embeds,
              output_attentions=output_attentions,
              output_hidden_states=output_hidden_states,
              return_dict=return_dict,
          )
  
          sequence_output = discriminator_hidden_states[0]
  
          pooled_output = self.sequence_summary(sequence_output)
          logits = self.classifier(pooled_output)
          reshaped_logits = logits.view(-1, num_choices)
  
          loss = None
          if labels is not None:
              loss_fct = CrossEntropyLoss()
              loss = loss_fct(reshaped_logits, labels)
  
          if not return_dict:
              output = (reshaped_logits,) + discriminator_hidden_states[1:]
              return ((loss,) + output) if loss is not None else output
  
          return MultipleChoiceModelOutput(
              loss=loss,
              logits=reshaped_logits,
              hidden_states=discriminator_hidden_states.hidden_states,
              attentions=discriminator_hidden_states.attentions,
          )
  