U &cP @sdZddlZddlZddlZddlZddlmZddlmZmZddl m Z m Z m Z ddl mZddlmZmZdd lmZmZeeZd d d d ddddddddddddddddddd Zd!d"Zd#d$Ze ejjje e ed%ZejjZGd&d'd'ej Z!Gd(d)d)ej Z"Gd*d+d+ej Z#Gd,d-d-ej Z$Gd.d/d/ej Z%Gd0d1d1ej Z&Gd2d3d3ej Z'Gd4d5d5ej Z(Gd6d7d7ej Z)Gd8d9d9ej Z*Gd:d;d;ej Z+Gdd?d?ej Z-Gd@dAdAej Z.GdBdCdCeZ/dDZ0dEZ1edFe0GdGdHdHe/Z2edIe0GdJdKdKe/Z3edLe0GdMdNdNe/Z4edOe0GdPdQdQe/Z5edRe0GdSdTdTe/Z6edUe0GdVdWdWe/Z7edXe0GdYdZdZe/Z8ed[e0Gd\d]d]e/Z9dS)^zPyTorch BERT model. N)nn)CrossEntropyLossMSELoss)gelugelu_newswish) BertConfig)add_start_docstrings add_start_docstrings_to_callable)PreTrainedModelprune_linear_layerz>https://cdn.huggingface.co/bert-base-uncased-pytorch_model.binz?https://cdn.huggingface.co/bert-large-uncased-pytorch_model.binzhttps://cdn.huggingface.co/bert-base-chinese-pytorch_model.binzChttps://cdn.huggingface.co/bert-base-german-cased-pytorch_model.binzRhttps://cdn.huggingface.co/bert-large-uncased-whole-word-masking-pytorch_model.binzPhttps://cdn.huggingface.co/bert-large-cased-whole-word-masking-pytorch_model.binzbhttps://cdn.huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad-pytorch_model.binz`https://cdn.huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad-pytorch_model.binzKhttps://cdn.huggingface.co/bert-base-cased-finetuned-mrpc-pytorch_model.binzIhttps://cdn.huggingface.co/bert-base-german-dbmdz-cased-pytorch_model.binzKhttps://cdn.huggingface.co/bert-base-german-dbmdz-uncased-pytorch_model.binzIhttps://cdn.huggingface.co/cl-tohoku/bert-base-japanese/pytorch_model.binz\https://cdn.huggingface.co/cl-tohoku/bert-base-japanese-whole-word-masking/pytorch_model.binzNhttps://cdn.huggingface.co/cl-tohoku/bert-base-japanese-char/pytorch_model.binzahttps://cdn.huggingface.co/cl-tohoku/bert-base-japanese-char-whole-word-masking/pytorch_model.binzPhttps://cdn.huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/pytorch_model.binzRhttps://cdn.huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/pytorch_model.binzKhttps://cdn.huggingface.co/wietsedv/bert-base-dutch-cased/pytorch_model.bin)zbert-base-uncasedzbert-large-uncasedzbert-base-casedzbert-large-casedzbert-base-multilingual-uncasedzbert-base-multilingual-casedzbert-base-chinesezbert-base-german-casedz%bert-large-uncased-whole-word-maskingz#bert-large-cased-whole-word-maskingz5bert-large-uncased-whole-word-masking-finetuned-squadz3bert-large-cased-whole-word-masking-finetuned-squadzbert-base-cased-finetuned-mrpczbert-base-german-dbmdz-casedzbert-base-german-dbmdz-uncasedzbert-base-japanesez%bert-base-japanese-whole-word-maskingzbert-base-japanese-charz*bert-base-japanese-char-whole-word-maskingzbert-base-finnish-cased-v1zbert-base-finnish-uncased-v1zbert-base-dutch-casedc Cszddl}ddl}ddl}Wn tk r<tdYnXtj|}t d ||j |}g}g} |D]<\} } t d | | |j || } || | | qrt|| D]\} } | d} tdd| Drt d d| q|} | D]}|d |r"|d |}n|g}|dd ksD|dd krPt| d} n|ddksl|ddkrxt| d} nz|ddkrt| d} n`|ddkrt| d} nFzt| |d} Wn2tk rt d d| YqYnXt|dkrt|d}| |} q|dddkr6t| d} n|d krJ|| } z| j| jks^tWn<tk r}z|j| j| jf7_W5d}~XYnXt d | t| | _q|S)z- Load tf checkpoints in a pytorch model. rNzLoading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.z(Converting TensorFlow checkpoint from {}z"Loading TF weight {} with shape {}/css|]}|dkVqdS))Zadam_vZadam_mZAdamWeightDecayOptimizerZAdamWeightDecayOptimizer_1Z global_stepN).0nrr>/tmp/pip-unpacked-wheel-ymerj3tt/transformers/modeling_bert.py Zsz*load_tf_weights_in_bert..z Skipping {}z [A-Za-z]+_\d+z_(\d+)kernelgammaweightZ output_biasbetabiasZoutput_weightsZsquad classifierriZ _embeddingszInitialize PyTorch weight {})reZnumpyZ tensorflow ImportErrorloggererrorospathabspathinfoformatZtrainZlist_variablesZ load_variableappendzipsplitanyjoin fullmatchgetattrAttributeErrorlenint transposeshapeAssertionErrorargstorchZ from_numpydata)modelconfigZtf_checkpoint_pathrnptfZtf_pathZ init_varsnamesZarraysnamer/arraypointerZm_nameZ scope_namesnumerrrload_tf_weights_in_bert=sv                  r>cCs|ttj|SN)r2tanhr functionalZsoftplus)xrrrmishsrC)rrelurrrCcs*eZdZdZfddZdddZZS)BertEmbeddingszLConstruct the embeddings from word, position and token_type embeddings. csjttj|j|j|jd|_t|j|j|_ t|j |j|_ t |j|j d|_t|j|_dS)N)Z padding_idxZeps)super__init__r Embedding vocab_size hidden_size pad_token_idword_embeddingsZmax_position_embeddingsposition_embeddingsZtype_vocab_sizetoken_type_embeddings BertLayerNormlayer_norm_eps LayerNormDropouthidden_dropout_probdropoutselfr5 __class__rrrHs  zBertEmbeddings.__init__Nc Cs|dk r|}n|dd}|d}|dk r8|jn|j}|dkrhtj|tj|d}|d|}|dkrtj|tj|d}|dkr||}| |}| |} ||| } | | } | | } | S)NrZdtypedevicer) sizer\r2arangelongZ unsqueezeexpandzerosrMrNrOrRrU) rW input_idstoken_type_ids position_ids inputs_embeds input_shapeZ seq_lengthr\rNrO embeddingsrrrforwards$       zBertEmbeddings.forward)NNNN)__name__ __module__ __qualname____doc__rHrh __classcell__rrrXrrEs rEcs.eZdZfddZddZdddZZS) BertSelfAttentioncst|j|jdkr8t|ds8td|j|jf|j|_|j|_t|j|j|_|j|j|_ t |j|j |_ t |j|j |_ t |j|j |_t |j|_dS)NrZembedding_sizezLThe hidden size (%d) is not a multiple of the number of attention heads (%d))rGrHrKnum_attention_headshasattr ValueErroroutput_attentionsr-attention_head_size all_head_sizerLinearquerykeyvaluerSZattention_probs_dropout_probrUrVrXrrrHs  zBertSelfAttention.__init__cCs6|dd|j|jf}|j|}|ddddS)NrZrrr)r]rorsviewpermute)rWrBZ new_x_shaperrrtranspose_for_scoress z&BertSelfAttention.transpose_for_scoresNcCs||}|dk r,||}||}|}n||}||}||} ||} ||} t| | dd} | t|j } |dk r| |} t j dd| } | | } |dk r| |} t| | }| dddd}|dd|jf}|j|}|jr|| fn|f}|S)NrZZdimrrrry)rvrwrxr|r2matmulr.mathsqrtrsrZSoftmaxrUr{ contiguousr]rtrzrr)rW hidden_statesattention_mask head_maskencoder_hidden_statesencoder_attention_maskZmixed_query_layerZmixed_key_layerZmixed_value_layerZ query_layerZ key_layerZ value_layerZattention_scoresZattention_probsZ context_layerZnew_context_layer_shapeoutputsrrrrhs0           zBertSelfAttention.forward)NNNN)rirjrkrHr|rhrmrrrXrrns rncs$eZdZfddZddZZS)BertSelfOutputcs@tt|j|j|_t|j|jd|_t |j |_ dSNrF) rGrHrrurKdenserPrQrRrSrTrUrVrXrrrHs zBertSelfOutput.__init__cCs&||}||}|||}|Sr?rrUrRrWrZ input_tensorrrrrh s  zBertSelfOutput.forwardrirjrkrHrhrmrrrXrrs rcs.eZdZfddZddZdddZZS) BertAttentioncs*tt||_t||_t|_dSr?)rGrHrnrWroutputset pruned_headsrVrXrrrHs   zBertAttention.__init__cst|dkrdSt|jj|jj}t||j}|D](tfdd|jDd|<q6| d d}t t|| }t|jj||j_t|jj||j_t|jj||j_t|jj|dd|j_|jjt||j_|jj|jj|j_|j||_dS)Nrc3s|]}|krdndVqdS)rrNr)rhheadrrr!sz,BertAttention.prune_heads..rZrr~)r,r2onesrWrorsrrsumrzreqr^r_r rvrwrxrrrtunion)rWheadsmaskindexrrr prune_headss   zBertAttention.prune_headsNc Cs8||||||}||d|}|f|dd}|SNrr)rWr) rWrrrrrZ self_outputsattention_outputrrrrrh1szBertAttention.forward)NNNN)rirjrkrHrrhrmrrrXrrs rcs$eZdZfddZddZZS)BertIntermediatecsBtt|j|j|_t|jt r6t |j|_ n|j|_ dSr?) rGrHrrurKintermediate_sizer isinstance hidden_actstrACT2FNintermediate_act_fnrVrXrrrHBs   zBertIntermediate.__init__cCs||}||}|Sr?)rrrWrrrrrhJs  zBertIntermediate.forwardrrrrXrrAs rcs$eZdZfddZddZZS) BertOutputcs@tt|j|j|_t|j|jd|_ t |j |_ dSr) rGrHrrurrKrrPrQrRrSrTrUrVrXrrrHQs zBertOutput.__init__cCs&||}||}|||}|Sr?rrrrrrhWs  zBertOutput.forwardrrrrXrrPs rcs&eZdZfddZdddZZS) BertLayercsDtt||_|j|_|jr,t||_t||_t||_ dSr?) rGrHr attention is_decodercrossattentionr intermediaterrrVrXrrrH_s    zBertLayer.__init__Nc Cs~||||}|d}|dd}|jrZ|dk rZ||||||} | d}|| dd}||} || |} | f|}|Sr)rrrrr) rWrrrrrZself_attention_outputsrrZcross_attention_outputsZintermediate_outputZ layer_outputrrrrhhs"    zBertLayer.forward)NNNNrrrrXrr^s  rcs&eZdZfddZdddZZS) BertEncodercs>tj|_j|_tfddtjD|_dS)Ncsg|] }tqSr)r)r_r5rr sz(BertEncoder.__init__..) rGrHrroutput_hidden_statesrZ ModuleListrangenum_hidden_layerslayerrVrXrrrHs zBertEncoder.__init__Nc Csd}d}t|jD]H\}} |jr*||f}| ||||||} | d}|jr|| df}q|jrl||f}|f} |jr| |f} |jr| |f} | S)Nrrr) enumeraterrrr) rWrrrrrZall_hidden_statesZall_attentionsiZ layer_moduleZ layer_outputsrrrrrhs.    zBertEncoder.forward)NNNNrrrrXrrs  rcs$eZdZfddZddZZS) BertPoolercs*tt|j|j|_t|_dSr?)rGrHrrurKrZTanh activationrVrXrrrHs zBertPooler.__init__cCs(|dddf}||}||}|S)Nr)rr)rWrZfirst_token_tensor pooled_outputrrrrhs  zBertPooler.forwardrrrrXrrs rcs$eZdZfddZddZZS)BertPredictionHeadTransformcsTtt|j|j|_t|jtr6t |j|_ n|j|_ t |j|j d|_ dSr)rGrHrrurKrrrrrtransform_act_fnrPrQrRrVrXrrrHs   z$BertPredictionHeadTransform.__init__cCs"||}||}||}|Sr?)rrrRrrrrrhs   z#BertPredictionHeadTransform.forwardrrrrXrrs rcs$eZdZfddZddZZS)BertLMPredictionHeadcsLtt||_tj|j|jdd|_t t |j|_ |j |j_ dS)NF)r) rGrHr transformrrurKrJdecoder Parameterr2rarrVrXrrrHs   zBertLMPredictionHead.__init__cCs||}||}|Sr?)rrrrrrrhs  zBertLMPredictionHead.forwardrrrrXrrs rcs$eZdZfddZddZZS)BertOnlyMLMHeadcstt||_dSr?)rGrHr predictionsrVrXrrrHs zBertOnlyMLMHead.__init__cCs||}|Sr?)r)rWsequence_outputprediction_scoresrrrrhs zBertOnlyMLMHead.forwardrrrrXrrs rcs$eZdZfddZddZZS)BertOnlyNSPHeadcstt|jd|_dSNr)rGrHrrurKseq_relationshiprVrXrrrHs zBertOnlyNSPHead.__init__cCs||}|Sr?)r)rWrseq_relationship_scorerrrrhs zBertOnlyNSPHead.forwardrrrrXrrs rcs$eZdZfddZddZZS)BertPreTrainingHeadscs(tt||_t|jd|_dSr)rGrHrrrrurKrrVrXrrrHs  zBertPreTrainingHeads.__init__cCs||}||}||fSr?)rr)rWrrrrrrrrhs  zBertPreTrainingHeads.forwardrrrrXrrs rc@s(eZdZdZeZeZeZ dZ ddZ dS)BertPreTrainedModelz An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models. bertcCstt|tjtjfr*|jjjd|jjdn$t|t rN|j j |jj dt|tjrp|j dk rp|j j dS)z Initialize the weights g)ZmeanZstdg?N) rrrurIrr3Znormal_r5Zinitializer_rangerPrZzero_Zfill_)rWmodulerrr _init_weightss  z!BertPreTrainedModel._init_weightsN) rirjrkrlr Z config_class!BERT_PRETRAINED_MODEL_ARCHIVE_MAPZpretrained_model_archive_mapr>Zload_tf_weightsZbase_model_prefixrrrrrrs ram This model is a PyTorch `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.BertConfig`): 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:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. Indices can be obtained using :class:`transformers.BertTokenizer`. See :func:`transformers.PreTrainedTokenizer.encode` and :func:`transformers.PreTrainedTokenizer.encode_plus` 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. z^The bare Bert Model transformer outputting raw hidden-states without any specific head on top.c sJeZdZdZfddZddZddZdd Zee d d d Z Z S) BertModela The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of cross-attention is added between the self-attention layers, following the architecture described in `Attention is all you need`_ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin. To behave as an decoder the model needs to be initialized with the :obj:`is_decoder` argument of the configuration set to :obj:`True`; an :obj:`encoder_hidden_states` is expected as an input to the forward pass. .. _`Attention is all you need`: https://arxiv.org/abs/1706.03762 cs<t|||_t||_t||_t||_| dSr?) rGrHr5rErgrencoderrpooler init_weightsrVrXrrrHcs     zBertModel.__init__cCs|jjSr?rgrMrWrrrget_input_embeddingsmszBertModel.get_input_embeddingscCs ||j_dSr?r)rWrxrrrset_input_embeddingspszBertModel.set_input_embeddingscCs*|D]\}}|jj|j|qdS)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 N)itemsrrrr)rWZheads_to_prunerrrrr _prune_headssszBertModel._prune_headsNc CsN|dk r|dk rtdn4|dk r,|} n"|dk rF|dd} ntd|dk r\|jn|j} |dkrxtj| | d}|dkrtj| tj| d}||| |j} |jj r|dk r|\} } }| | f}|dkrtj|| d}| |}nd}| ||jj }|j ||||d}|j|| |||d}|d }||}||f|d d}|S) a Return: :obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.BertConfig`) and inputs: last_hidden_state (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`): Sequence of hidden-states at the output of the last layer of the model. pooler_output (:obj:`torch.FloatTensor`: of shape :obj:`(batch_size, hidden_size)`): Last layer hidden-state of the first token of the sequence (classification token) further processed by a Linear layer and a Tanh activation function. The Linear layer weights are trained from the next sentence prediction (classification) objective during pre-training. This output is usually *not* a good summary of the semantic content of the input, you're often better with averaging or pooling the sequence of hidden-states for the whole input sequence. hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned 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 ``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. Examples:: from transformers import BertModel, BertTokenizer import torch tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertModel.from_pretrained('bert-base-uncased') input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1 outputs = model(input_ids) last_hidden_states = outputs[0] # The last hidden-state is the first element of the output tuple NzDYou cannot specify both input_ids and inputs_embeds at the same timerZz5You have to specify either input_ids or inputs_embeds)r\r[)rbrdrcre)rrrrrr)rqr]r\r2rrar_Zget_extended_attention_maskr5rZinvert_attention_maskZ get_head_maskrrgrr)rWrbrrcrdrrerrrfr\Zextended_attention_maskZencoder_batch_sizeZencoder_sequence_lengthrZencoder_hidden_shapeZencoder_extended_attention_maskZembedding_outputZencoder_outputsrrrrrrrh{sX5     zBertModel.forward)NNNNNNNN) rirjrkrlrHrrrr BERT_INPUTS_DOCSTRINGrhrmrrrXrrNs rzBert Model with two heads on top as done during the pre-training: a `masked language modeling` head and a `next sentence prediction (classification)` head. c s6eZdZfddZddZeedddZZS) BertForPreTrainingcs,t|t||_t||_|dSr?)rGrHrrrclsrrVrXrrrHs   zBertForPreTraining.__init__cCs |jjjSr?rrrrrrrget_output_embeddingssz(BertForPreTraining.get_output_embeddingsNc Cs|j||||||d} | dd\} } || | \} } | | f| dd} |dk r|dk rt}|| d|jj|d}|| dd|d}||}|f| } | S)a masked_lm_labels (``torch.LongTensor`` of shape ``(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]`` next_sentence_label (``torch.LongTensor`` of shape ``(batch_size,)``, `optional`, defaults to :obj:`None`): Labels for computing the next sequence prediction (classification) loss. Input should be a sequence pair (see :obj:`input_ids` docstring) Indices should be in ``[0, 1]``. ``0`` indicates sequence B is a continuation of sequence A, ``1`` indicates sequence B is a random sequence. Returns: :obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.BertConfig`) and inputs: loss (`optional`, returned when ``masked_lm_labels`` is provided) ``torch.FloatTensor`` of shape ``(1,)``: Total loss as the sum of the masked language modeling loss and the next sequence prediction (classification) loss. prediction_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, config.vocab_size)`) Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax). seq_relationship_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, 2)`): Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation before SoftMax). hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when :obj:`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 ``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. Examples:: from transformers import BertTokenizer, BertForPreTraining import torch tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForPreTraining.from_pretrained('bert-base-uncased') input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1 outputs = model(input_ids) prediction_scores, seq_relationship_scores = outputs[:2] rrcrdrreNrrZ)rrrrzr5rJ)rWrbrrcrdrremasked_lm_labelsnext_sentence_labelrrrrrloss_fctmasked_lm_lossnext_sentence_loss total_lossrrrrhs(=   zBertForPreTraining.forward)NNNNNNNN) rirjrkrHrr rrhrmrrrXrrs rz3Bert Model with a `language modeling` head on top. c s@eZdZfddZddZeed ddZd dd ZZ S) BertForMaskedLMcs,t|t||_t||_|dSr?)rGrHrrrrrrVrXrrrHUs   zBertForMaskedLM.__init__cCs |jjjSr?rrrrrr]sz%BertForMaskedLM.get_output_embeddingsNc  Cs|j|||||||| d} | d} || } | f| dd} |dk rrt}|| d|jj|d}|f| } | dk r| ddddddf} | ddddf} t}|| d|jj| d}|f| } | S)a masked_lm_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]`` lm_labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`): Labels for computing the left-to-right language modeling loss (next word prediction). 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]`` Returns: :obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.BertConfig`) and inputs: masked_lm_loss (`optional`, returned when ``masked_lm_labels`` is provided) ``torch.FloatTensor`` of shape ``(1,)``: Masked language modeling loss. ltr_lm_loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when :obj:`lm_labels` is provided): Next token prediction loss. prediction_scores (:obj:`torch.FloatTensor` 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(torch.FloatTensor)`, `optional`, returned 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 ``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. Examples:: from transformers import BertTokenizer, BertForMaskedLM import torch tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForMaskedLM.from_pretrained('bert-base-uncased') input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1 outputs = model(input_ids, masked_lm_labels=input_ids) loss, prediction_scores = outputs[:2] )rrcrdrrerrrrNrZr)rrrrzr5rJr)rWrbrrcrdrrerrrZ lm_labelsrrrrrZ ltr_lm_lossrrrrh`s0=    zBertForMaskedLM.forwardcKs|j}|d}|dkr ||}|jjdkr|jjdk s@tdtj|||jddfgdd}tj |df|jjtj |j d}tj||gdd}||dS) NrFz.The PAD token should be defined for generationrrZr~r[)rbr) r/Znew_onesr5rrLr0r2catZ new_zerosfullr_r\)rWrbrZ model_kwargsrfZeffective_batch_sizeZ dummy_tokenrrrprepare_inputs_for_generations$  z-BertForMaskedLM.prepare_inputs_for_generation) NNNNNNNNNN)N) rirjrkrHrr rrhrrmrrrXrrSs  arzKBert Model with a `next sentence prediction (classification)` head on top. cs.eZdZfddZeedddZZS)BertForNextSentencePredictioncs,t|t||_t||_|dSr?)rGrHrrrrrrVrXrrrHs   z&BertForNextSentencePrediction.__init__Nc Csn|j||||||d}|d} || } | f|dd}|dk rjt} | | dd|d} | f|}|S)a& next_sentence_label (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`): Labels for computing the next sequence prediction (classification) loss. Input should be a sequence pair (see ``input_ids`` docstring) Indices should be in ``[0, 1]``. ``0`` indicates sequence B is a continuation of sequence A, ``1`` indicates sequence B is a random sequence. Returns: :obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.BertConfig`) and inputs: loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when :obj:`next_sentence_label` is provided): Next sequence prediction (classification) loss. seq_relationship_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, 2)`): Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation before SoftMax). hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned 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 ``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. Examples:: from transformers import BertTokenizer, BertForNextSentencePrediction import torch tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForNextSentencePrediction.from_pretrained('bert-base-uncased') input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1 outputs = model(input_ids) seq_relationship_scores = outputs[0] rrrNrZ)rrrrz) rWrbrrcrdrrerrrrrrrrrrhs 3   z%BertForNextSentencePrediction.forward)NNNNNNNrirjrkrHr rrhrmrrrXrrs rzBert Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled output) e.g. for GLUE tasks. cs.eZdZfddZeedddZZS)BertForSequenceClassificationcsJt||j|_t||_t|j|_t |j |j|_ | dSr? rGrH num_labelsrrrrSrTrUrurKrrrVrXrrrH4s   z&BertForSequenceClassification.__init__Nc Cs|j||||||d}|d} || } || } | f|dd}|dk r|jdkrtt} | | d|d} n t} | | d|j|d} | f|}|S)a@ 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). Returns: :obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.BertConfig`) and inputs: loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when :obj:`label` is provided): Classification (or regression if config.num_labels==1) loss. logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, config.num_labels)`): Classification (or regression if config.num_labels==1) scores (before SoftMax). hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned 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 ``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. Examples:: from transformers import BertTokenizer, BertForSequenceClassification import torch tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForSequenceClassification.from_pretrained('bert-base-uncased') input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1 labels = torch.tensor([1]).unsqueeze(0) # Batch size 1 outputs = model(input_ids, labels=labels) loss, logits = outputs[:2] rrrNrZ)rrUrrrrzr) rWrbrrcrdrrelabelsrrlogitsrlossrrrrh>s(4     z%BertForSequenceClassification.forward)NNNNNNNrrrrXrr.s rzBert 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. cs.eZdZfddZeedddZZS)BertForMultipleChoicecs@t|t||_t|j|_t|j d|_ | dS)Nr) rGrHrrrrSrTrUrurKrrrVrXrrrHs   zBertForMultipleChoice.__init__NcCs|jd}|d|d}|dk r6|d|dnd}|dk rT|d|dnd}|dk rr|d|dnd}|j||||||d} | d} || } || } | d|} | f| dd} |dk rt} | | |}|f| } | S)aF 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]`` where `num_choices` is the size of the second dimension of the input tensors. (see `input_ids` above) Returns: :obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.BertConfig`) and inputs: loss (:obj:`torch.FloatTensor` of shape `(1,)`, `optional`, returned when :obj:`labels` is provided): Classification loss. classification_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, num_choices)`): `num_choices` is the second dimension of the input tensors. (see `input_ids` above). Classification scores (before SoftMax). hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned 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 ``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. Examples:: from transformers import BertTokenizer, BertForMultipleChoice import torch tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForMultipleChoice.from_pretrained('bert-base-uncased') choices = ["Hello, my dog is cute", "Hello, my cat is amazing"] input_ids = torch.tensor([tokenizer.encode(s, add_special_tokens=True) for s in choices]).unsqueeze(0) # Batch size 1, 2 choices labels = torch.tensor(1).unsqueeze(0) # Batch size 1 outputs = model(input_ids, labels=labels) loss, classification_scores = outputs[:2] rrZNrr)r/rzr]rrUrr)rWrbrrcrdrrerZ num_choicesrrrZreshaped_logitsrrrrrrhs.5       zBertForMultipleChoice.forward)NNNNNNNrrrrXrrs rzBert Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for Named-Entity-Recognition (NER) tasks. cs.eZdZfddZeedddZZS)BertForTokenClassificationcsJt||j|_t||_t|j|_t |j |j|_ | dSr?rrVrXrrrHs   z#BertForTokenClassification.__init__NcCs|j||||||d}|d} || } || } | f|dd}|dk rt} |dk r|ddk} | d|j} t| |dt| j  |}| | |}n| | d|j|d}|f|}|S)aN 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]``. Returns: :obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.BertConfig`) and inputs: loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when ``labels`` is provided) : Classification loss. scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, config.num_labels)`) Classification scores (before SoftMax). hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned 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 ``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. Examples:: from transformers import BertTokenizer, BertForTokenClassification import torch tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForTokenClassification.from_pretrained('bert-base-uncased') input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1 labels = torch.tensor([1] * input_ids.size(1)).unsqueeze(0) # Batch size 1 outputs = model(input_ids, labels=labels) loss, scores = outputs[:2] rrrNrZr) rrUrrrzrr2whereZtensor ignore_indexZtype_as)rWrbrrcrdrrerrrrrZ active_lossZ active_logitsZ active_labelsrrrrrhs42     z"BertForTokenClassification.forward)NNNNNNNrrrrXrrs rzBert 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`). c s.eZdZfddZeedddZZS)BertForQuestionAnsweringcs<t||j|_t||_t|j|j|_| dSr?) rGrHrrrrrurK qa_outputsrrVrXrrrH[s   z!BertForQuestionAnswering.__init__Nc Cs|j||||||d} | d} || } | jddd\} } | d} | d} | | f| dd} |dk r|dk rt|dkr|d}t|dkr|d}| d}|d||d|t|d}|| |}|| |}||d}|f| } | S) a^ 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. Returns: :obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.BertConfig`) and inputs: loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when :obj:`labels` is provided): Total span extraction loss is the sum of a Cross-Entropy for the start and end positions. start_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length,)`): Span-start scores (before SoftMax). end_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length,)`): Span-end scores (before SoftMax). hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned 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 ``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. Examples:: from transformers import BertTokenizer, BertForQuestionAnswering import torch tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertForQuestionAnswering.from_pretrained('bert-large-uncased-whole-word-masking-finetuned-squad') question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet" encoding = tokenizer.encode_plus(question, text) input_ids, token_type_ids = encoding["input_ids"], encoding["token_type_ids"] start_scores, end_scores = model(torch.tensor([input_ids]), token_type_ids=torch.tensor([token_type_ids])) all_tokens = tokenizer.convert_ids_to_tokens(input_ids) answer = ' '.join(all_tokens[torch.argmax(start_scores) : torch.argmax(end_scores)+1]) assert answer == "a nice puppet" rrrrZr~rN)r)rrr&Zsqueezer,r]Zclamp_r)rWrbrrcrdrreZstart_positionsZ end_positionsrrrZ start_logitsZ end_logitsZ ignored_indexrZ start_lossZend_lossrrrrrhds8>              z BertForQuestionAnswering.forward)NNNNNNNNrrrrXrrUs r):rlloggingrrr2rZtorch.nnrrZ activationsrrrZconfiguration_bertr Z file_utilsr r Zmodeling_utilsr r getLoggerrirrr>rCrArDrrRrPModulerErnrrrrrrrrrrrrrZBERT_START_DOCSTRINGrrrrrrrrrrrrrs   H(N.#)    .cR\_]