U &co@sdddlZddlZddlmZddlmZmZddlm Z m Z m Z ddl m Z mZddlmZeeZdd d d d d dZGdddejjjZGdddejjjZGdddejjjZGddde ZGdddeZdZdZedeGdddeZedeGdd d eZ Gd!d"d"ejjjZ!ed#eGd$d%d%eZ"ed&eGd'd(d(eZ#dS))N) ElectraConfig)add_start_docstrings add_start_docstrings_to_callable)ACT2FN TFBertEncoderTFBertPreTrainedModel)get_initializer shape_list) BatchEncodingzEhttps://cdn.huggingface.co/google/electra-small-generator/tf_model.h5zDhttps://cdn.huggingface.co/google/electra-base-generator/tf_model.h5zEhttps://cdn.huggingface.co/google/electra-large-generator/tf_model.h5zIhttps://cdn.huggingface.co/google/electra-small-discriminator/tf_model.h5zHhttps://cdn.huggingface.co/google/electra-base-discriminator/tf_model.h5zIhttps://cdn.huggingface.co/google/electra-large-discriminator/tf_model.h5)zgoogle/electra-small-generatorzgoogle/electra-base-generatorzgoogle/electra-large-generatorz"google/electra-small-discriminatorz!google/electra-base-discriminatorz"google/electra-large-discriminatorcsHeZdZdZfddZfddZddd Zdd d Zd d ZZ S)TFElectraEmbeddingszLConstruct the embeddings from word, position and token_type embeddings. c stjf||j|_|j|_|j|_tjjj|j |jt |jdd|_ tjjj|j |jt |jdd|_ tjjj|jdd|_tjj|j|_dS)Nposition_embeddings)Zembeddings_initializernametoken_type_embeddings LayerNormepsilonr)super__init__ vocab_sizeembedding_sizeinitializer_rangetfkeraslayersZ EmbeddingZmax_position_embeddingsr r Ztype_vocab_sizerLayerNormalizationlayer_norm_epsrDropouthidden_dropout_probdropoutselfconfigkwargs __class__D/tmp/pip-unpacked-wheel-ymerj3tt/transformers/modeling_tf_electra.pyrs$ zTFElectraEmbeddings.__init__c sFtd&|jd|j|jgt|jd|_W5QRXt |dS)z"Build shared word embedding layer word_embeddingsZweight)shape initializerN) rZ name_scope add_weightrrr rr(rbuildr! input_shaper$r&r'r,6s  zTFElectraEmbeddings.build embeddingFcCs:|dkr|j||dS|dkr(||Std|dS)a Get token embeddings of inputs. Args: inputs: list of three int64 tensors with shape [batch_size, length]: (input_ids, position_ids, token_type_ids) mode: string, a valid value is one of "embedding" and "linear". Returns: outputs: (1) If mode == "embedding", output embedding tensor, float32 with shape [batch_size, length, embedding_size]; (2) mode == "linear", output linear tensor, float32 with shape [batch_size, length, vocab_size]. Raises: ValueError: if mode is not valid. Shared weights logic adapted from https://github.com/tensorflow/models/blob/a009f4fb9d2fc4949e32192a944688925ef78659/official/transformer/v2/embedding_layer.py#L24 r/traininglinearzmode {} is not valid.N) _embedding_linear ValueErrorformat)r!inputsmoder1r&r&r'callBs  zTFElectraEmbeddings.callc Cs|\}}}}|dk rt|}nt|dd}|d}|dkr\tj|tjdtjddf}|dkrpt|d}|dkrt|j|}||} | |} || | } | | } |j | |d} | S)z)Applies embedding based on inputs tensor.Nr)Zdtyperr0) r rrangeZint32newaxisfillZgatherr(r rrr) r!r7r1 input_ids position_idstoken_type_ids inputs_embedsr.Z seq_lengthr r embeddingsr&r&r'r3Xs"       zTFElectraEmbeddings._embeddingcCsPt|d}t|d}t|d|jg}tj||jdd}t||||jgS)a Computes logits by running inputs through a linear layer. Args: inputs: A float32 tensor with shape [batch_size, length, hidden_size] Returns: float32 tensor with shape [batch_size, length, vocab_size]. rrr:T)Z transpose_b)r rZreshapermatmulr(r)r!r7Z batch_sizelengthxlogitsr&r&r'r4qs   zTFElectraEmbeddings._linear)r/F)F) __name__ __module__ __qualname____doc__rr,r9r3r4 __classcell__r&r&r$r'r s    r cs&eZdZfddZdddZZS)!TFElectraDiscriminatorPredictionsc sBtjf|tjjj|jdd|_tjjjddd|_||_ dS)Ndenserrdense_prediction) rrrrrDense hidden_sizerMrOr"r r$r&r'rsz*TFElectraDiscriminatorPredictions.__init__FcCs.||}t|jj|}t||}|SN)rMrr" hidden_actrZsqueezerO)r!discriminator_hidden_statesr1 hidden_statesrFr&r&r'r9s z&TFElectraDiscriminatorPredictions.call)FrGrHrIrr9rKr&r&r$r'rLs rLcs&eZdZfddZdddZZS)TFElectraGeneratorPredictionsc s>tjf|tjjj|jdd|_tjjj|j dd|_ dS)NrrrMrN) rrrrrrrrrPrrMr r$r&r'rsz&TFElectraGeneratorPredictions.__init__FcCs$||}td|}||}|S)NZgelu)rMrr)r!generator_hidden_statesr1rUr&r&r'r9s   z"TFElectraGeneratorPredictions.call)FrVr&r&r$r'rWs rWc@s(eZdZeZeZdZddZddZ dS)TFElectraPreTrainedModelelectracCsN|dkrt|d}|ddtjtjddf}t|tj}d|d}|S)Nrg?g)rr=r<castZfloat32)r!attention_maskr.extended_attention_maskr&r&r'get_extended_attention_masks   z4TFElectraPreTrainedModel.get_extended_attention_maskcCs |dk rtndg|jj}|SrR)NotImplementedErrorr"Znum_hidden_layers)r! head_maskr&r&r' get_head_masksz&TFElectraPreTrainedModel.get_head_maskN) rGrHrIr config_class'TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_MAPZpretrained_model_archive_mapZbase_model_prefixr^rar&r&r&r'rYs rYcsBeZdZeZfddZddZddZddZd d d Z Z S)TFElectraMainLayerc sXtj|f|t|dd|_|j|jkr@tjjj |jdd|_ t |dd|_ ||_ dS)NrBrNembeddings_projectencoder)rrr rBrrQrrrrPrerrfr"r r$r&r'rs  zTFElectraMainLayer.__init__cCs|jSrR)rBr!r&r&r'get_input_embeddingssz'TFElectraMainLayer.get_input_embeddingscCstdSrRr_)r!Znew_num_tokensr&r&r'_resize_token_embeddingssz+TFElectraMainLayer._resize_token_embeddingscCstdS)z Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base class PreTrainedModel Nri)r!Zheads_to_pruner&r&r' _prune_headsszTFElectraMainLayer._prune_headsNFc Cst|ttfr|d}t|dkr*|dn|}t|dkrB|dn|}t|dkrZ|dn|}t|dkrr|dn|}t|dkr|dn|}t|dkstdnrt|ttfr|d }|d |}|d |}|d |}|d |}|d|}t|dkstdn|}|dk r4|dk r4tdn8|dk rHt |} n$|dk rdt |dd} ntd|dkrt | d}|dkrt | d}| || } | |}|j||||g|d} t|dr|j| |d} |j| | |g|d} | S)NrrzToo many inputs.r>r\r@r?r`rAzDYou cannot specify both input_ids and inputs_embeds at the same timer:z5You have to specify either input_ids or inputs_embedsr0re) isinstancetuplelistlenAssertionErrordictr getr5r rr=r^rarBhasattrrerf) r!r7r\r@r?r`rAr1r>r.r]rUr&r&r'r9sF                  zTFElectraMainLayer.call)NNNNNF) rGrHrIrrbrrhrjrkr9rKr&r&r$r'rds  rda This model is a `tf.keras.Model `__ sub-class. Use it as a regular TF 2.0 Keras Model and refer to the TF 2.0 documentation for all matter related to general usage and behavior. .. note:: TF 2.0 models accepts two formats as inputs: - having all inputs as keyword arguments (like PyTorch models), or - having all inputs as a list, tuple or dict in the first positional arguments. This second option is useful when using :obj:`tf.keras.Model.fit()` method which currently requires having all the tensors in the first argument of the model call function: :obj:`model(inputs)`. If you choose this second option, there are three possibilities you can use to gather all the input Tensors in the first positional argument : - a single Tensor with input_ids only and nothing else: :obj:`model(inputs_ids)` - a list of varying length with one or several input Tensors IN THE ORDER given in the docstring: :obj:`model([input_ids, attention_mask])` or :obj:`model([input_ids, attention_mask, token_type_ids])` - a dictionary with one or several input Tensors associated to the input names given in the docstring: :obj:`model({'input_ids': input_ids, 'token_type_ids': token_type_ids})` 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. a Args: input_ids (:obj:`Numpy array` or :obj:`tf.Tensor` 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.encode_plus` for details. `What are input IDs? <../glossary.html#input-ids>`__ attention_mask (:obj:`Numpy array` or :obj:`tf.Tensor` 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>`__ head_mask (:obj:`Numpy array` or :obj:`tf.Tensor` 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:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, embedding_dim)`, `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. training (:obj:`boolean`, `optional`, defaults to :obj:`False`): Whether to activate dropout modules (if set to :obj:`True`) during training or to de-activate them (if set to :obj:`False`) for evaluation. a\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.cs4eZdZfddZddZeeddZZS)TFElectraModelcs&tj|f||t|dd|_dS)NrZrN)rrrdrZ)r!r"r7r#r$r&r'r]szTFElectraModel.__init__cCs|jjSrRrZrBrgr&r&r'rhasz#TFElectraModel.get_input_embeddingscKs|j|f|}|S)a Returns: :obj:`tuple(tf.Tensor)` comprising various elements depending on the configuration (:class:`~transformers.ElectraConfig`) and inputs: last_hidden_state (:obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`): Sequence of hidden-states at the output of the last layer of the model. hidden_states (:obj:`tuple(tf.Tensor)`, `optional`, returned when :obj:`config.output_hidden_states=True`): tuple of :obj:`tf.Tensor` (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(tf.Tensor)`, `optional`, returned when ``config.output_attentions=True``): tuple of :obj:`tf.Tensor` (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. Examples:: import tensorflow as tf from transformers import ElectraTokenizer, TFElectraModel tokenizer = ElectraTokenizer.from_pretrained('google/electra-small-discriminator') model = TFElectraModel.from_pretrained('google/electra-small-discriminator') input_ids = tf.constant(tokenizer.encode("Hello, my dog is cute"))[None, :] # Batch size 1 outputs = model(input_ids) last_hidden_states = outputs[0] # The last hidden-state is the first element of the output tuple )rZ)r!r7r#outputsr&r&r'r9dszTFElectraModel.call rGrHrIrrhrELECTRA_INPUTS_DOCSTRINGr9rKr&r&r$r'ryTs rya8 Electra model with a binary classification head on top as used during pre-training for identifying generated tokens. Even though both the discriminator and generator may be loaded into this model, the discriminator is the only model of the two to have the correct classification head to be used for this model.cs6eZdZfddZddZeed ddZZS) TFElectraForPreTrainingc s0tj|f|t|dd|_t|dd|_dS)NrZrNdiscriminator_predictions)rrrdrZrLrr r$r&r'rsz TFElectraForPreTraining.__init__cCs|jjSrRrzrgr&r&r'rhsz,TFElectraForPreTraining.get_input_embeddingsNFc CsD|j|||||||d}|d} || } | f} | |dd7} | S)aY Returns: :obj:`tuple(tf.Tensor)` comprising various elements depending on the configuration (:class:`~transformers.ElectraConfig`) and inputs: scores (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, config.num_labels)`): Prediction scores of the head (scores for each token before SoftMax). hidden_states (:obj:`tuple(tf.Tensor)`, `optional`, returned when :obj:`config.output_hidden_states=True`): tuple of :obj:`tf.Tensor` (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(tf.Tensor)`, `optional`, returned when ``config.output_attentions=True``): tuple of :obj:`tf.Tensor` (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. Examples:: import tensorflow as tf from transformers import ElectraTokenizer, TFElectraForPreTraining tokenizer = ElectraTokenizer.from_pretrained('google/electra-small-discriminator') model = TFElectraForPreTraining.from_pretrained('google/electra-small-discriminator') input_ids = tf.constant(tokenizer.encode("Hello, my dog is cute"))[None, :] # Batch size 1 outputs = model(input_ids) scores = outputs[0] r0rrN)rZr r!r>r\r@r?r`rAr1rTZdiscriminator_sequence_outputrFoutputr&r&r'r9s' zTFElectraForPreTraining.call)NNNNNNFr|r&r&r$r'r~s r~cs2eZdZfddZfddZdddZZS) TFElectraMaskedLMHeadc s tjf||j|_||_dSrR)rrrinput_embeddings)r!r"rr#r$r&r'rszTFElectraMaskedLMHead.__init__cs(|j|jfdddd|_t|dS)NzerosTbias)r)r*Z trainabler)r+rrrr,r-r$r&r'r,szTFElectraMaskedLMHead.buildFcCs|j|dd}||j}|S)Nr2)r8)rr)r!rUr1r&r&r'r9s zTFElectraMaskedLMHead.call)F)rGrHrIrr,r9rKr&r&r$r'rs  rz 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.cs>eZdZfddZddZddZeed d d ZZ S) TFElectraForMaskedLMc sntj|f||j|_t|dd|_t|dd|_t|jt rNt |j|_ n|j|_ t ||jj dd|_dS)NrZrNgenerator_predictionsgenerator_lm_head)rrrrdrZrWrrqrSstrrZ activationrrBrr r$r&r'rs zTFElectraForMaskedLM.__init__cCs|jjSrRrzrgr&r&r'rhsz)TFElectraForMaskedLM.get_input_embeddingscCs|jSrR)rrgr&r&r'get_output_embeddingssz*TFElectraForMaskedLM.get_output_embeddingsNFc CsV|j|||||||d}|d} |j| |d} |j| |d} | f} | |dd7} | S)a Returns: :obj:`tuple(tf.Tensor)` comprising various elements depending on the configuration (:class:`~transformers.ElectraConfig`) and inputs: prediction_scores (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, config.vocab_size)`): Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax). hidden_states (:obj:`tuple(tf.Tensor)`, `optional`, returned when :obj:`config.output_hidden_states=True`): tuple of :obj:`tf.Tensor` (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(tf.Tensor)`, `optional`, returned when ``config.output_attentions=True``): tuple of :obj:`tf.Tensor` (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. Examples:: import tensorflow as tf from transformers import ElectraTokenizer, TFElectraForMaskedLM tokenizer = ElectraTokenizer.from_pretrained('google/electra-small-generator') model = TFElectraForMaskedLM.from_pretrained('google/electra-small-generator') input_ids = tf.constant(tokenizer.encode("Hello, my dog is cute"))[None, :] # Batch size 1 outputs = model(input_ids) prediction_scores = outputs[0] r0rrN)rZrr) r!r>r\r@r?r`rAr1rXZgenerator_sequence_outputZprediction_scoresrr&r&r'r9s(zTFElectraForMaskedLM.call)NNNNNNF) rGrHrIrrhrrr}r9rKr&r&r$r'rs rz| Electra model with a token classification head on top. Both the discriminator and generator may be loaded into this model.cs.eZdZfddZeedddZZS)TFElectraForTokenClassificationc sJtj|f|t|dd|_tjj|j|_ tjjj |j dd|_ dS)NrZrN classifier) rrrdrZrrrrrrrPZ num_labelsrr r$r&r'r1sz(TFElectraForTokenClassification.__init__NFc CsN|j|||||||d}|d} || } || } | f} | |dd7} | S)aK Returns: :obj:`tuple(tf.Tensor)` comprising various elements depending on the configuration (:class:`~transformers.ElectraConfig`) and inputs: scores (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, config.num_labels)`): Classification scores (before SoftMax). hidden_states (:obj:`tuple(tf.Tensor)`, `optional`, returned when :obj:`config.output_hidden_states=True`): tuple of :obj:`tf.Tensor` (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(tf.Tensor)`, `optional`, returned when ``config.output_attentions=True``): tuple of :obj:`tf.Tensor` (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. Examples:: import tensorflow as tf from transformers import ElectraTokenizer, TFElectraForTokenClassification tokenizer = ElectraTokenizer.from_pretrained('google/electra-small-discriminator') model = TFElectraForTokenClassification.from_pretrained('google/electra-small-discriminator') input_ids = tf.constant(tokenizer.encode("Hello, my dog is cute"))[None, :] # Batch size 1 outputs = model(input_ids) scores = outputs[0] r0rrN)rZrrrr&r&r'r98s'  z$TFElectraForTokenClassification.call)NNNNNNF)rGrHrIrrr}r9rKr&r&r$r'r)s r)$loggingZ tensorflowrZ transformersrZ file_utilsrrZmodeling_tf_bertrrrZmodeling_tf_utilsr r Ztokenization_utilsr getLoggerrGloggerrcrrZLayerr rLrWrYrdZELECTRA_START_DOCSTRINGr}ryr~rrrr&r&r&r'sT    g%R) <G