|
|
@@ -0,0 +1,2351 @@
|
|
|
+# coding=utf-8
|
|
|
+# Copyright 2021, The Facebook AI Research Team and The HuggingFace Inc. team. All rights reserved.
|
|
|
+#
|
|
|
+# Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
+# you may not use this file except in compliance with the License.
|
|
|
+# You may obtain a copy of the License at
|
|
|
+#
|
|
|
+# http://www.apache.org/licenses/LICENSE-2.0
|
|
|
+#
|
|
|
+# Unless required by applicable law or agreed to in writing, software
|
|
|
+# distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
+# See the License for the specific language governing permissions and
|
|
|
+# limitations under the License.
|
|
|
+"""PyTorch UnimerMBART model."""
|
|
|
+
|
|
|
+import copy
|
|
|
+import math
|
|
|
+from dataclasses import dataclass
|
|
|
+from typing import List, Optional, Tuple, Union
|
|
|
+
|
|
|
+import torch
|
|
|
+import torch.nn.functional as F
|
|
|
+import torch.utils.checkpoint
|
|
|
+from torch import nn
|
|
|
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
|
|
|
+
|
|
|
+from transformers.activations import ACT2FN
|
|
|
+from transformers.modeling_attn_mask_utils import (
|
|
|
+ _prepare_4d_attention_mask,
|
|
|
+ _prepare_4d_attention_mask_for_sdpa,
|
|
|
+ _prepare_4d_causal_attention_mask,
|
|
|
+ _prepare_4d_causal_attention_mask_for_sdpa,
|
|
|
+)
|
|
|
+from transformers.modeling_outputs import (
|
|
|
+ BaseModelOutput,
|
|
|
+ BaseModelOutputWithPastAndCrossAttentions,
|
|
|
+ CausalLMOutputWithCrossAttentions,
|
|
|
+ Seq2SeqLMOutput,
|
|
|
+ Seq2SeqModelOutput,
|
|
|
+ Seq2SeqQuestionAnsweringModelOutput,
|
|
|
+ Seq2SeqSequenceClassifierOutput,
|
|
|
+)
|
|
|
+from transformers import GenerationMixin, PreTrainedModel
|
|
|
+from transformers.utils import (
|
|
|
+ add_code_sample_docstrings,
|
|
|
+ add_end_docstrings,
|
|
|
+ add_start_docstrings,
|
|
|
+ add_start_docstrings_to_model_forward,
|
|
|
+ is_flash_attn_2_available,
|
|
|
+ is_flash_attn_greater_or_equal_2_10,
|
|
|
+ logging,
|
|
|
+ replace_return_docstrings,
|
|
|
+)
|
|
|
+from .configuration_unimer_mbart import UnimerMBartConfig
|
|
|
+
|
|
|
+
|
|
|
+if is_flash_attn_2_available():
|
|
|
+ from flash_attn import flash_attn_func, flash_attn_varlen_func
|
|
|
+ from flash_attn.bert_padding import index_first_axis, pad_input, unpad_input # noqa
|
|
|
+
|
|
|
+
|
|
|
+logger = logging.get_logger(__name__)
|
|
|
+
|
|
|
+_CHECKPOINT_FOR_DOC = "facebook/mbart-large-cc25"
|
|
|
+_CONFIG_FOR_DOC = "MBartConfig"
|
|
|
+
|
|
|
+# Base model docstring
|
|
|
+_EXPECTED_OUTPUT_SHAPE = [1, 8, 1024]
|
|
|
+
|
|
|
+
|
|
|
+# Copied from transformers.models.llama.modeling_llama._get_unpad_data
|
|
|
+def _get_unpad_data(attention_mask):
|
|
|
+ seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32)
|
|
|
+ indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
|
|
|
+ max_seqlen_in_batch = seqlens_in_batch.max().item()
|
|
|
+ cu_seqlens = F.pad(torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.int32), (1, 0))
|
|
|
+ return (
|
|
|
+ indices,
|
|
|
+ cu_seqlens,
|
|
|
+ max_seqlen_in_batch,
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+def shift_tokens_right(input_ids: torch.Tensor, pad_token_id: int):
|
|
|
+ """
|
|
|
+ Shift input ids one token to the right, and wrap the last non pad token (the <LID> token) Note that MBart does not
|
|
|
+ have a single `decoder_start_token_id` in contrast to other Bart-like models.
|
|
|
+ """
|
|
|
+ prev_output_tokens = input_ids.clone()
|
|
|
+
|
|
|
+ if pad_token_id is None:
|
|
|
+ raise ValueError("self.model.config.pad_token_id has to be defined.")
|
|
|
+ # replace possible -100 values in labels by `pad_token_id`
|
|
|
+ prev_output_tokens.masked_fill_(prev_output_tokens == -100, pad_token_id)
|
|
|
+
|
|
|
+ index_of_eos = (prev_output_tokens.ne(pad_token_id).sum(dim=1) - 1).unsqueeze(-1)
|
|
|
+ decoder_start_tokens = prev_output_tokens.gather(1, index_of_eos).squeeze()
|
|
|
+ prev_output_tokens[:, 1:] = prev_output_tokens[:, :-1].clone()
|
|
|
+ prev_output_tokens[:, 0] = decoder_start_tokens
|
|
|
+
|
|
|
+ return prev_output_tokens
|
|
|
+
|
|
|
+@dataclass
|
|
|
+class CausalLMOutputWithCrossAttentionsAndCounting(CausalLMOutputWithCrossAttentions):
|
|
|
+ """
|
|
|
+ Base class for causal language model (or autoregressive) outputs.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
|
|
|
+ Language modeling loss (for next-token prediction).
|
|
|
+ logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
|
|
|
+ Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
|
|
|
+ hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
|
|
|
+ Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
|
|
|
+ one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.
|
|
|
+
|
|
|
+ Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.
|
|
|
+ attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
|
|
|
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(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.
|
|
|
+ cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
|
|
|
+ Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
|
|
|
+ sequence_length)`.
|
|
|
+
|
|
|
+ Cross attentions weights after the attention softmax, used to compute the weighted average in the
|
|
|
+ cross-attention heads.
|
|
|
+ past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
|
|
|
+ Tuple of `torch.FloatTensor` tuples of length `config.n_layers`, with each tuple containing the cached key,
|
|
|
+ value states of the self-attention and the cross-attention layers if model is used in encoder-decoder
|
|
|
+ setting. Only relevant if `config.is_decoder = True`.
|
|
|
+
|
|
|
+ Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
|
|
|
+ `past_key_values` input) to speed up sequential decoding.
|
|
|
+ counting:
|
|
|
+ Counting
|
|
|
+ """
|
|
|
+ counting: Optional[torch.FloatTensor] = None
|
|
|
+
|
|
|
+# Copied from transformers.models.bart.modeling_bart.BartLearnedPositionalEmbedding with Bart->MBart
|
|
|
+class UnimerMBartLearnedPositionalEmbedding(nn.Embedding):
|
|
|
+ """
|
|
|
+ This module learns positional embeddings up to a fixed maximum size.
|
|
|
+ """
|
|
|
+
|
|
|
+ def __init__(self, num_embeddings: int, embedding_dim: int):
|
|
|
+ # MBart is set up so that if padding_idx is specified then offset the embedding ids by 2
|
|
|
+ # and adjust num_embeddings appropriately. Other models don't have this hack
|
|
|
+ self.offset = 2
|
|
|
+ super().__init__(num_embeddings + self.offset, embedding_dim)
|
|
|
+
|
|
|
+ def forward(self, input_ids: torch.Tensor, past_key_values_length: int = 0):
|
|
|
+ """`input_ids' shape is expected to be [bsz x seqlen]."""
|
|
|
+
|
|
|
+ bsz, seq_len = input_ids.shape[:2]
|
|
|
+ positions = torch.arange(
|
|
|
+ past_key_values_length, past_key_values_length + seq_len, dtype=torch.long, device=self.weight.device
|
|
|
+ ).expand(bsz, -1)
|
|
|
+
|
|
|
+ return super().forward(positions + self.offset)
|
|
|
+
|
|
|
+
|
|
|
+# Copied from transformers.models.bart.modeling_bart.BartScaledWordEmbedding with Bart->MBart
|
|
|
+class UnimerMBartScaledWordEmbedding(nn.Embedding):
|
|
|
+ """
|
|
|
+ This module overrides nn.Embeddings' forward by multiplying with embeddings scale.
|
|
|
+ """
|
|
|
+
|
|
|
+ def __init__(self, num_embeddings: int, embedding_dim: int, padding_idx: int, embed_scale: Optional[float] = 1.0):
|
|
|
+ super().__init__(num_embeddings, embedding_dim, padding_idx)
|
|
|
+ self.embed_scale = embed_scale
|
|
|
+
|
|
|
+ def forward(self, input_ids: torch.Tensor):
|
|
|
+ return super().forward(input_ids) * self.embed_scale
|
|
|
+
|
|
|
+
|
|
|
+# Copied from transformers.models.bart.modeling_bart.BartAttention with Bart->MBart
|
|
|
+class UnimerMBartAttention(nn.Module):
|
|
|
+ """Multi-headed attention from 'Attention Is All You Need' paper, with qk_squeeze"""
|
|
|
+
|
|
|
+ def __init__(
|
|
|
+ self,
|
|
|
+ embed_dim: int,
|
|
|
+ num_heads: int,
|
|
|
+ dropout: float = 0.0,
|
|
|
+ is_decoder: bool = False,
|
|
|
+ bias: bool = True,
|
|
|
+ is_causal: bool = False,
|
|
|
+ *,
|
|
|
+ config: UnimerMBartConfig,
|
|
|
+ ):
|
|
|
+ super().__init__()
|
|
|
+ self.embed_dim = embed_dim
|
|
|
+ self.num_heads = num_heads
|
|
|
+ self.dropout = dropout
|
|
|
+ self.head_dim = embed_dim // num_heads
|
|
|
+ self.config = config
|
|
|
+
|
|
|
+ if (self.head_dim * num_heads) != self.embed_dim:
|
|
|
+ raise ValueError(
|
|
|
+ f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}"
|
|
|
+ f" and `num_heads`: {num_heads})."
|
|
|
+ )
|
|
|
+
|
|
|
+ self.squeeze_dim = embed_dim // config.qk_squeeze
|
|
|
+ self.squeeze_head_dim = self.squeeze_dim // num_heads
|
|
|
+ self.scaling = self.squeeze_head_dim**-0.5
|
|
|
+ self.is_decoder = is_decoder
|
|
|
+ self.is_causal = is_causal
|
|
|
+
|
|
|
+ self.q_proj = nn.Linear(embed_dim, self.squeeze_dim, bias=bias)
|
|
|
+ self.k_proj = nn.Linear(embed_dim, self.squeeze_dim, bias=bias)
|
|
|
+ self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
|
|
|
+ self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
|
|
|
+
|
|
|
+ def _shape_qk(self, tensor: torch.Tensor, seq_len: int, bsz: int):
|
|
|
+ return tensor.view(bsz, seq_len, self.num_heads, self.squeeze_head_dim).transpose(1, 2).contiguous()
|
|
|
+
|
|
|
+ def _shape_v(self, tensor: torch.Tensor, seq_len: int, bsz: int):
|
|
|
+ return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
|
|
|
+
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ hidden_states: torch.Tensor,
|
|
|
+ key_value_states: Optional[torch.Tensor] = None,
|
|
|
+ past_key_value: Optional[Tuple[torch.Tensor]] = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ layer_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ output_attentions: bool = False,
|
|
|
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
|
|
|
+ """Input shape: Batch x Time x Channel"""
|
|
|
+
|
|
|
+ # if key_value_states are provided this layer is used as a cross-attention layer
|
|
|
+ # for the decoder
|
|
|
+ is_cross_attention = key_value_states is not None
|
|
|
+
|
|
|
+ bsz, tgt_len, _ = hidden_states.size()
|
|
|
+
|
|
|
+ # get query proj
|
|
|
+ query_states = self.q_proj(hidden_states) * self.scaling
|
|
|
+ # get key, value proj
|
|
|
+ # `past_key_value[0].shape[2] == key_value_states.shape[1]`
|
|
|
+ # is checking that the `sequence_length` of the `past_key_value` is the same as
|
|
|
+ # the provided `key_value_states` to support prefix tuning
|
|
|
+ if (
|
|
|
+ is_cross_attention
|
|
|
+ and past_key_value is not None
|
|
|
+ and past_key_value[0].shape[2] == key_value_states.shape[1]
|
|
|
+ ):
|
|
|
+ # reuse k,v, cross_attentions
|
|
|
+ key_states = past_key_value[0]
|
|
|
+ value_states = past_key_value[1]
|
|
|
+ elif is_cross_attention:
|
|
|
+ # cross_attentions
|
|
|
+ key_states = self._shape_qk(self.k_proj(key_value_states), -1, bsz)
|
|
|
+ value_states = self._shape_v(self.v_proj(key_value_states), -1, bsz)
|
|
|
+ elif past_key_value is not None:
|
|
|
+ # reuse k, v, self_attention
|
|
|
+ key_states = self._shape_qk(self.k_proj(hidden_states), -1, bsz)
|
|
|
+ value_states = self._shape_v(self.v_proj(hidden_states), -1, bsz)
|
|
|
+ key_states = torch.cat([past_key_value[0], key_states], dim=2)
|
|
|
+ value_states = torch.cat([past_key_value[1], value_states], dim=2)
|
|
|
+ else:
|
|
|
+ # self_attention
|
|
|
+ key_states = self._shape_qk(self.k_proj(hidden_states), -1, bsz)
|
|
|
+ value_states = self._shape_v(self.v_proj(hidden_states), -1, bsz)
|
|
|
+
|
|
|
+ if self.is_decoder:
|
|
|
+ # if cross_attention save Tuple(torch.Tensor, torch.Tensor) of all cross attention key/value_states.
|
|
|
+ # Further calls to cross_attention layer can then reuse all cross-attention
|
|
|
+ # key/value_states (first "if" case)
|
|
|
+ # if uni-directional self-attention (decoder) save Tuple(torch.Tensor, torch.Tensor) of
|
|
|
+ # all previous decoder key/value_states. Further calls to uni-directional self-attention
|
|
|
+ # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
|
|
|
+ # if encoder bi-directional self-attention `past_key_value` is always `None`
|
|
|
+ past_key_value = (key_states, value_states)
|
|
|
+
|
|
|
+ proj_shape = (bsz * self.num_heads, -1, self.squeeze_head_dim)
|
|
|
+ value_shape = (bsz * self.num_heads, -1, self.head_dim)
|
|
|
+ query_states = self._shape_qk(query_states, tgt_len, bsz).view(*proj_shape)
|
|
|
+ key_states = key_states.reshape(*proj_shape)
|
|
|
+ value_states = value_states.reshape(*value_shape)
|
|
|
+
|
|
|
+ src_len = key_states.size(1)
|
|
|
+ attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))
|
|
|
+
|
|
|
+ if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len):
|
|
|
+ raise ValueError(
|
|
|
+ f"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is"
|
|
|
+ f" {attn_weights.size()}"
|
|
|
+ )
|
|
|
+
|
|
|
+ if attention_mask is not None:
|
|
|
+ if attention_mask.size() != (bsz, 1, tgt_len, src_len):
|
|
|
+ raise ValueError(
|
|
|
+ f"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {attention_mask.size()}"
|
|
|
+ )
|
|
|
+ attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len) + attention_mask
|
|
|
+ attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
|
|
|
+
|
|
|
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1)
|
|
|
+
|
|
|
+ if layer_head_mask is not None:
|
|
|
+ if layer_head_mask.size() != (self.num_heads,):
|
|
|
+ raise ValueError(
|
|
|
+ f"Head mask for a single layer should be of size {(self.num_heads,)}, but is"
|
|
|
+ f" {layer_head_mask.size()}"
|
|
|
+ )
|
|
|
+ attn_weights = layer_head_mask.view(1, -1, 1, 1) * attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
|
|
|
+ attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
|
|
|
+
|
|
|
+ if output_attentions:
|
|
|
+ # this operation is a bit awkward, but it's required to
|
|
|
+ # make sure that attn_weights keeps its gradient.
|
|
|
+ # In order to do so, attn_weights have to be reshaped
|
|
|
+ # twice and have to be reused in the following
|
|
|
+ attn_weights_reshaped = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
|
|
|
+ attn_weights = attn_weights_reshaped.view(bsz * self.num_heads, tgt_len, src_len)
|
|
|
+ else:
|
|
|
+ attn_weights_reshaped = None
|
|
|
+
|
|
|
+ attn_probs = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
|
|
|
+ attn_output = torch.bmm(attn_probs, value_states)
|
|
|
+
|
|
|
+ if attn_output.size() != (bsz * self.num_heads, tgt_len, self.head_dim):
|
|
|
+ raise ValueError(
|
|
|
+ f"`attn_output` should be of size {(bsz * self.num_heads, tgt_len, self.head_dim)}, but is"
|
|
|
+ f" {attn_output.size()}"
|
|
|
+ )
|
|
|
+
|
|
|
+ attn_output = attn_output.view(bsz, self.num_heads, tgt_len, self.head_dim)
|
|
|
+ attn_output = attn_output.transpose(1, 2)
|
|
|
+
|
|
|
+ # Use the `embed_dim` from the config (stored in the class) rather than `hidden_state` because `attn_output` can be
|
|
|
+ # partitioned across GPUs when using tensor-parallelism.
|
|
|
+ attn_output = attn_output.reshape(bsz, tgt_len, self.embed_dim)
|
|
|
+
|
|
|
+ attn_output = self.out_proj(attn_output)
|
|
|
+
|
|
|
+ return attn_output, attn_weights_reshaped, past_key_value
|
|
|
+
|
|
|
+
|
|
|
+# Copied from transformers.models.bart.modeling_bart.BartFlashAttention2 with Bart->MBart
|
|
|
+class UnimerMBartFlashAttention2(UnimerMBartAttention):
|
|
|
+ """
|
|
|
+ MBart flash attention module. This module inherits from `MBartSqueezeAttention` as the weights of the module stays
|
|
|
+ untouched. The only required change would be on the forward pass where it needs to correctly call the public API of
|
|
|
+ flash attention and deal with padding tokens in case the input contains any of them.
|
|
|
+ """
|
|
|
+
|
|
|
+ # Copied from transformers.models.llama.modeling_llama.LlamaFlashAttention2.__init__
|
|
|
+ def __init__(self, *args, **kwargs):
|
|
|
+ super().__init__(*args, **kwargs)
|
|
|
+
|
|
|
+ # TODO: Should be removed once Flash Attention for RoCm is bumped to 2.1.
|
|
|
+ # flash_attn<2.1 generates top-left aligned causal mask, while what is needed here is bottom-right alignement, that was made default for flash_attn>=2.1. This attribute is used to handle this difference. Reference: https://github.com/Dao-AILab/flash-attention/releases/tag/v2.1.0.
|
|
|
+ # Beware that with flash_attn<2.1, using q_seqlen != k_seqlen (except for the case q_seqlen == 1) produces a wrong mask (top-left).
|
|
|
+ self._flash_attn_uses_top_left_mask = not is_flash_attn_greater_or_equal_2_10()
|
|
|
+
|
|
|
+ # def _reshape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
|
|
|
+ # return tensor.view(bsz, seq_len, self.num_heads, self.head_dim)
|
|
|
+
|
|
|
+ def _shape_qk(self, tensor: torch.Tensor, seq_len: int, bsz: int):
|
|
|
+ return tensor.view(bsz, seq_len, self.num_heads, self.squeeze_head_dim)
|
|
|
+
|
|
|
+ def _shape_v(self, tensor: torch.Tensor, seq_len: int, bsz: int):
|
|
|
+ return tensor.view(bsz, seq_len, self.num_heads, self.head_dim)
|
|
|
+
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ hidden_states: torch.Tensor,
|
|
|
+ key_value_states: Optional[torch.Tensor] = None,
|
|
|
+ past_key_value: Optional[Tuple[torch.Tensor]] = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ layer_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ output_attentions: bool = False,
|
|
|
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
|
|
|
+ # MBartFlashAttention2 attention does not support output_attentions
|
|
|
+ if output_attentions:
|
|
|
+ raise ValueError("MBartFlashAttention2 attention does not support output_attentions")
|
|
|
+
|
|
|
+ # if key_value_states are provided this layer is used as a cross-attention layer
|
|
|
+ # for the decoder
|
|
|
+ is_cross_attention = key_value_states is not None
|
|
|
+
|
|
|
+ bsz, q_len, _ = hidden_states.size()
|
|
|
+
|
|
|
+ # get query proj
|
|
|
+ query_states = self._shape_qk(self.q_proj(hidden_states), -1, bsz)
|
|
|
+
|
|
|
+ # get key, value proj
|
|
|
+ # `past_key_value[0].shape[2] == key_value_states.shape[1]`
|
|
|
+ # is checking that the `sequence_length` of the `past_key_value` is the same as
|
|
|
+ # the provided `key_value_states` to support prefix tuning
|
|
|
+ if (
|
|
|
+ is_cross_attention
|
|
|
+ and past_key_value is not None
|
|
|
+ and past_key_value[0].shape[2] == key_value_states.shape[1]
|
|
|
+ ):
|
|
|
+ # reuse k,v, cross_attentions
|
|
|
+ key_states = past_key_value[0].transpose(1, 2)
|
|
|
+ value_states = past_key_value[1].transpose(1, 2)
|
|
|
+ elif is_cross_attention:
|
|
|
+ # cross_attentions
|
|
|
+ key_states = self._shape_qk(self.k_proj(key_value_states), -1, bsz)
|
|
|
+ value_states = self._shape_v(self.v_proj(key_value_states), -1, bsz)
|
|
|
+ elif past_key_value is not None:
|
|
|
+ # reuse k, v, self_attention
|
|
|
+ key_states = self._shape_qk(self.k_proj(hidden_states), -1, bsz)
|
|
|
+ value_states = self._shape_v(self.v_proj(hidden_states), -1, bsz)
|
|
|
+ key_states = torch.cat([past_key_value[0].transpose(1, 2), key_states], dim=1)
|
|
|
+ value_states = torch.cat([past_key_value[1].transpose(1, 2), value_states], dim=1)
|
|
|
+ else:
|
|
|
+ # self_attention
|
|
|
+ key_states = self._shape_qk(self.k_proj(hidden_states), -1, bsz)
|
|
|
+ value_states = self._shape_v(self.v_proj(hidden_states), -1, bsz)
|
|
|
+
|
|
|
+ if self.is_decoder:
|
|
|
+ # if cross_attention save Tuple(torch.Tensor, torch.Tensor) of all cross attention key/value_states.
|
|
|
+ # Further calls to cross_attention layer can then reuse all cross-attention
|
|
|
+ # key/value_states (first "if" case)
|
|
|
+ # if uni-directional self-attention (decoder) save Tuple(torch.Tensor, torch.Tensor) of
|
|
|
+ # all previous decoder key/value_states. Further calls to uni-directional self-attention
|
|
|
+ # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
|
|
|
+ # if encoder bi-directional self-attention `past_key_value` is always `None`
|
|
|
+ past_key_value = (key_states.transpose(1, 2), value_states.transpose(1, 2))
|
|
|
+
|
|
|
+ kv_seq_len = key_states.shape[-2]
|
|
|
+ if past_key_value is not None:
|
|
|
+ kv_seq_len += past_key_value[0].shape[-2]
|
|
|
+
|
|
|
+ # In PEFT, usually we cast the layer norms in float32 for training stability reasons
|
|
|
+ # therefore the input hidden states gets silently casted in float32. Hence, we need
|
|
|
+ # cast them back in the correct dtype just to be sure everything works as expected.
|
|
|
+ # This might slowdown training & inference so it is recommended to not cast the LayerNorms
|
|
|
+ # in fp32. (LlamaRMSNorm handles it correctly)
|
|
|
+
|
|
|
+ input_dtype = query_states.dtype
|
|
|
+ if input_dtype == torch.float32:
|
|
|
+ if torch.is_autocast_enabled():
|
|
|
+ target_dtype = torch.get_autocast_gpu_dtype()
|
|
|
+ # Handle the case where the model is quantized
|
|
|
+ elif hasattr(self.config, "_pre_quantization_dtype"):
|
|
|
+ target_dtype = self.config._pre_quantization_dtype
|
|
|
+ else:
|
|
|
+ target_dtype = self.q_proj.weight.dtype
|
|
|
+
|
|
|
+ logger.warning_once(
|
|
|
+ f"The input hidden states seems to be silently casted in float32, this might be related to"
|
|
|
+ f" the fact you have upcasted embedding or layer norm layers in float32. We will cast back the input in"
|
|
|
+ f" {target_dtype}."
|
|
|
+ )
|
|
|
+
|
|
|
+ query_states = query_states.to(target_dtype)
|
|
|
+ key_states = key_states.to(target_dtype)
|
|
|
+ value_states = value_states.to(target_dtype)
|
|
|
+
|
|
|
+ attn_output = self._flash_attention_forward(
|
|
|
+ query_states, key_states, value_states, attention_mask, q_len, dropout=self.dropout
|
|
|
+ )
|
|
|
+
|
|
|
+ attn_output = attn_output.reshape(bsz, q_len, -1)
|
|
|
+ attn_output = self.out_proj(attn_output)
|
|
|
+
|
|
|
+ if not output_attentions:
|
|
|
+ attn_weights = None
|
|
|
+
|
|
|
+ return attn_output, attn_weights, past_key_value
|
|
|
+
|
|
|
+ # Copied from transformers.models.llama.modeling_llama.LlamaFlashAttention2._flash_attention_forward
|
|
|
+ def _flash_attention_forward(
|
|
|
+ self, query_states, key_states, value_states, attention_mask, query_length, dropout=0.0, softmax_scale=None
|
|
|
+ ):
|
|
|
+ """
|
|
|
+ Calls the forward method of Flash Attention - if the input hidden states contain at least one padding token
|
|
|
+ first unpad the input, then computes the attention scores and pad the final attention scores.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ query_states (`torch.Tensor`):
|
|
|
+ Input query states to be passed to Flash Attention API
|
|
|
+ key_states (`torch.Tensor`):
|
|
|
+ Input key states to be passed to Flash Attention API
|
|
|
+ value_states (`torch.Tensor`):
|
|
|
+ Input value states to be passed to Flash Attention API
|
|
|
+ attention_mask (`torch.Tensor`):
|
|
|
+ The padding mask - corresponds to a tensor of size `(batch_size, seq_len)` where 0 stands for the
|
|
|
+ position of padding tokens and 1 for the position of non-padding tokens.
|
|
|
+ dropout (`float`):
|
|
|
+ Attention dropout
|
|
|
+ softmax_scale (`float`, *optional*):
|
|
|
+ The scaling of QK^T before applying softmax. Default to 1 / sqrt(head_dim)
|
|
|
+ """
|
|
|
+ if not self._flash_attn_uses_top_left_mask:
|
|
|
+ causal = self.is_causal
|
|
|
+ else:
|
|
|
+ # TODO: Remove the `query_length != 1` check once Flash Attention for RoCm is bumped to 2.1. For details, please see the comment in LlamaFlashAttention2 __init__.
|
|
|
+ causal = self.is_causal and query_length != 1
|
|
|
+
|
|
|
+ # Contains at least one padding token in the sequence
|
|
|
+ if attention_mask is not None:
|
|
|
+ batch_size = query_states.shape[0]
|
|
|
+
|
|
|
+ query_states, key_states, value_states, indices_q, cu_seq_lens, max_seq_lens = self._upad_input(
|
|
|
+ query_states, key_states, value_states, attention_mask, query_length
|
|
|
+ )
|
|
|
+
|
|
|
+ cu_seqlens_q, cu_seqlens_k = cu_seq_lens
|
|
|
+ max_seqlen_in_batch_q, max_seqlen_in_batch_k = max_seq_lens
|
|
|
+
|
|
|
+ attn_output_unpad = flash_attn_varlen_func(
|
|
|
+ query_states,
|
|
|
+ key_states,
|
|
|
+ value_states,
|
|
|
+ cu_seqlens_q=cu_seqlens_q,
|
|
|
+ cu_seqlens_k=cu_seqlens_k,
|
|
|
+ max_seqlen_q=max_seqlen_in_batch_q,
|
|
|
+ max_seqlen_k=max_seqlen_in_batch_k,
|
|
|
+ dropout_p=dropout,
|
|
|
+ softmax_scale=softmax_scale,
|
|
|
+ causal=causal,
|
|
|
+ )
|
|
|
+
|
|
|
+ attn_output = pad_input(attn_output_unpad, indices_q, batch_size, query_length)
|
|
|
+ else:
|
|
|
+ attn_output = flash_attn_func(
|
|
|
+ query_states, key_states, value_states, dropout, softmax_scale=softmax_scale, causal=causal
|
|
|
+ )
|
|
|
+
|
|
|
+ return attn_output
|
|
|
+
|
|
|
+ # Copied from transformers.models.llama.modeling_llama.LlamaFlashAttention2._upad_input
|
|
|
+ def _upad_input(self, query_layer, key_layer, value_layer, attention_mask, query_length):
|
|
|
+ indices_k, cu_seqlens_k, max_seqlen_in_batch_k = _get_unpad_data(attention_mask)
|
|
|
+ batch_size, kv_seq_len, num_key_value_heads, head_dim = key_layer.shape
|
|
|
+
|
|
|
+ key_layer = index_first_axis(
|
|
|
+ key_layer.reshape(batch_size * kv_seq_len, num_key_value_heads, head_dim), indices_k
|
|
|
+ )
|
|
|
+ value_layer = index_first_axis(
|
|
|
+ value_layer.reshape(batch_size * kv_seq_len, num_key_value_heads, head_dim), indices_k
|
|
|
+ )
|
|
|
+ if query_length == kv_seq_len:
|
|
|
+ query_layer = index_first_axis(
|
|
|
+ query_layer.reshape(batch_size * kv_seq_len, self.num_heads, head_dim), indices_k
|
|
|
+ )
|
|
|
+ cu_seqlens_q = cu_seqlens_k
|
|
|
+ max_seqlen_in_batch_q = max_seqlen_in_batch_k
|
|
|
+ indices_q = indices_k
|
|
|
+ elif query_length == 1:
|
|
|
+ max_seqlen_in_batch_q = 1
|
|
|
+ cu_seqlens_q = torch.arange(
|
|
|
+ batch_size + 1, dtype=torch.int32, device=query_layer.device
|
|
|
+ ) # There is a memcpy here, that is very bad.
|
|
|
+ indices_q = cu_seqlens_q[:-1]
|
|
|
+ query_layer = query_layer.squeeze(1)
|
|
|
+ else:
|
|
|
+ # The -q_len: slice assumes left padding.
|
|
|
+ attention_mask = attention_mask[:, -query_length:]
|
|
|
+ query_layer, indices_q, cu_seqlens_q, max_seqlen_in_batch_q = unpad_input(query_layer, attention_mask)
|
|
|
+
|
|
|
+ return (
|
|
|
+ query_layer,
|
|
|
+ key_layer,
|
|
|
+ value_layer,
|
|
|
+ indices_q,
|
|
|
+ (cu_seqlens_q, cu_seqlens_k),
|
|
|
+ (max_seqlen_in_batch_q, max_seqlen_in_batch_k),
|
|
|
+ )
|
|
|
+
|
|
|
+class UnimerMBartSdpaAttention(UnimerMBartAttention):
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ hidden_states: torch.Tensor,
|
|
|
+ key_value_states: Optional[torch.Tensor] = None,
|
|
|
+ past_key_value: Optional[Tuple[torch.Tensor]] = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ layer_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ output_attentions: bool = False,
|
|
|
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
|
|
|
+ """Input shape: Batch x Time x Channel"""
|
|
|
+ if output_attentions or layer_head_mask is not None:
|
|
|
+ # TODO: Improve this warning with e.g. `model.config._attn_implementation = "manual"` once this is implemented.
|
|
|
+ logger.warning(
|
|
|
+ "BartModel is using BartSdpaAttention, but `torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True` or `layer_head_mask` not None. Falling back to the manual attention"
|
|
|
+ ' implementation, but specifying the manual implementation will be required from Transformers version v5.0.0 onwards. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.'
|
|
|
+ )
|
|
|
+ return super().forward(
|
|
|
+ hidden_states,
|
|
|
+ key_value_states=key_value_states,
|
|
|
+ past_key_value=past_key_value,
|
|
|
+ attention_mask=attention_mask,
|
|
|
+ layer_head_mask=layer_head_mask,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ )
|
|
|
+
|
|
|
+ # if key_value_states are provided this layer is used as a cross-attention layer
|
|
|
+ # for the decoder
|
|
|
+ is_cross_attention = key_value_states is not None
|
|
|
+
|
|
|
+ bsz, tgt_len, _ = hidden_states.size()
|
|
|
+
|
|
|
+ # get query proj
|
|
|
+ query_states = self.q_proj(hidden_states)
|
|
|
+ # get key, value proj
|
|
|
+ # `past_key_value[0].shape[2] == key_value_states.shape[1]`
|
|
|
+ # is checking that the `sequence_length` of the `past_key_value` is the same as
|
|
|
+ # the provided `key_value_states` to support prefix tuning
|
|
|
+ if (
|
|
|
+ is_cross_attention
|
|
|
+ and past_key_value is not None
|
|
|
+ and past_key_value[0].shape[2] == key_value_states.shape[1]
|
|
|
+ ):
|
|
|
+ # reuse k,v, cross_attentions
|
|
|
+ key_states = past_key_value[0]
|
|
|
+ value_states = past_key_value[1]
|
|
|
+ elif is_cross_attention:
|
|
|
+ # cross_attentions
|
|
|
+ key_states = self._shape_qk(self.k_proj(key_value_states), -1, bsz)
|
|
|
+ value_states = self._shape_v(self.v_proj(key_value_states), -1, bsz)
|
|
|
+ elif past_key_value is not None:
|
|
|
+ # reuse k, v, self_attention
|
|
|
+ key_states = self._shape_qk(self.k_proj(hidden_states), -1, bsz)
|
|
|
+ value_states = self._shape_v(self.v_proj(hidden_states), -1, bsz)
|
|
|
+ key_states = torch.cat([past_key_value[0], key_states], dim=2)
|
|
|
+ value_states = torch.cat([past_key_value[1], value_states], dim=2)
|
|
|
+ else:
|
|
|
+ # self_attention
|
|
|
+ key_states = self._shape_qk(self.k_proj(hidden_states), -1, bsz)
|
|
|
+ value_states = self._shape_v(self.v_proj(hidden_states), -1, bsz)
|
|
|
+
|
|
|
+ if self.is_decoder:
|
|
|
+ # if cross_attention save Tuple(torch.Tensor, torch.Tensor) of all cross attention key/value_states.
|
|
|
+ # Further calls to cross_attention layer can then reuse all cross-attention
|
|
|
+ # key/value_states (first "if" case)
|
|
|
+ # if uni-directional self-attention (decoder) save Tuple(torch.Tensor, torch.Tensor) of
|
|
|
+ # all previous decoder key/value_states. Further calls to uni-directional self-attention
|
|
|
+ # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
|
|
|
+ # if encoder bi-directional self-attention `past_key_value` is always `None`
|
|
|
+ past_key_value = (key_states, value_states)
|
|
|
+
|
|
|
+ query_states = self._shape_qk(query_states, tgt_len, bsz)
|
|
|
+
|
|
|
+ # We dispatch to SDPA's Flash Attention or Efficient kernels via this `is_causal` if statement instead of an inline conditional assignment
|
|
|
+ # in SDPA to support both torch.compile's dynamic shapes and full graph options. An inline conditional prevents dynamic shapes from compiling.
|
|
|
+ # The tgt_len > 1 is necessary to match with AttentionMaskConverter.to_causal_4d that does not create a causal mask in case tgt_len == 1.
|
|
|
+ is_causal = True if self.is_causal and attention_mask is None and tgt_len > 1 else False
|
|
|
+
|
|
|
+ # NOTE: SDPA with memory-efficient backend is currently (torch==2.1.2) bugged when using non-contiguous inputs and a custom attn_mask,
|
|
|
+ # but we are fine here as `_shape` do call `.contiguous()`. Reference: https://github.com/pytorch/pytorch/issues/112577
|
|
|
+ attn_output = torch.nn.functional.scaled_dot_product_attention(
|
|
|
+ query_states,
|
|
|
+ key_states,
|
|
|
+ value_states,
|
|
|
+ attn_mask=attention_mask,
|
|
|
+ dropout_p=self.dropout if self.training else 0.0,
|
|
|
+ is_causal=is_causal,
|
|
|
+ )
|
|
|
+
|
|
|
+ if attn_output.size() != (bsz, self.num_heads, tgt_len, self.head_dim):
|
|
|
+ raise ValueError(
|
|
|
+ f"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is"
|
|
|
+ f" {attn_output.size()}"
|
|
|
+ )
|
|
|
+
|
|
|
+ attn_output = attn_output.transpose(1, 2)
|
|
|
+
|
|
|
+ # Use the `embed_dim` from the config (stored in the class) rather than `hidden_state` because `attn_output` can be
|
|
|
+ # partitioned across GPUs when using tensor-parallelism.
|
|
|
+ attn_output = attn_output.reshape(bsz, tgt_len, self.embed_dim)
|
|
|
+
|
|
|
+ attn_output = self.out_proj(attn_output)
|
|
|
+
|
|
|
+ return attn_output, None, past_key_value
|
|
|
+
|
|
|
+UNIMER_MBART_ATTENTION_CLASSES = {
|
|
|
+ "eager": UnimerMBartAttention,
|
|
|
+ "flash_attention_2": UnimerMBartFlashAttention2,
|
|
|
+ "sdpa": UnimerMBartSdpaAttention,
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+class UnimerMBartEncoderLayer(nn.Module):
|
|
|
+ def __init__(self, config: UnimerMBartConfig):
|
|
|
+ super().__init__()
|
|
|
+ self.embed_dim = config.d_model
|
|
|
+
|
|
|
+ self.self_attn = UNIMER_MBART_ATTENTION_CLASSES[config._attn_implementation](
|
|
|
+ embed_dim=self.embed_dim,
|
|
|
+ num_heads=config.encoder_attention_heads,
|
|
|
+ dropout=config.attention_dropout,
|
|
|
+ config=config,
|
|
|
+ )
|
|
|
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
|
|
|
+ self.dropout = config.dropout
|
|
|
+ self.activation_fn = ACT2FN[config.activation_function]
|
|
|
+ self.activation_dropout = config.activation_dropout
|
|
|
+ self.fc1 = nn.Linear(self.embed_dim, config.encoder_ffn_dim)
|
|
|
+ self.fc2 = nn.Linear(config.encoder_ffn_dim, self.embed_dim)
|
|
|
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
|
|
|
+
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ hidden_states: torch.Tensor,
|
|
|
+ attention_mask: torch.Tensor,
|
|
|
+ layer_head_mask: torch.Tensor,
|
|
|
+ output_attentions: bool = False,
|
|
|
+ ) -> torch.Tensor:
|
|
|
+ """
|
|
|
+ Args:
|
|
|
+ hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
|
|
|
+ attention_mask (`torch.FloatTensor`): attention mask of size
|
|
|
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
|
|
|
+ layer_head_mask (`torch.FloatTensor`): mask for attention heads in a given layer of size
|
|
|
+ `(encoder_attention_heads,)`.
|
|
|
+ output_attentions (`bool`, *optional*):
|
|
|
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
|
|
|
+ returned tensors for more detail.
|
|
|
+ """
|
|
|
+ residual = hidden_states
|
|
|
+ hidden_states = self.self_attn_layer_norm(hidden_states)
|
|
|
+ hidden_states, attn_weights, _ = self.self_attn(
|
|
|
+ hidden_states=hidden_states,
|
|
|
+ attention_mask=attention_mask,
|
|
|
+ layer_head_mask=layer_head_mask,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ )
|
|
|
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
|
|
|
+ hidden_states = residual + hidden_states
|
|
|
+
|
|
|
+ residual = hidden_states
|
|
|
+ hidden_states = self.final_layer_norm(hidden_states)
|
|
|
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
|
|
|
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
|
|
|
+ hidden_states = self.fc2(hidden_states)
|
|
|
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
|
|
|
+ hidden_states = residual + hidden_states
|
|
|
+
|
|
|
+ if hidden_states.dtype == torch.float16 and (
|
|
|
+ torch.isinf(hidden_states).any() or torch.isnan(hidden_states).any()
|
|
|
+ ):
|
|
|
+ clamp_value = torch.finfo(hidden_states.dtype).max - 1000
|
|
|
+ hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
|
|
|
+
|
|
|
+ outputs = (hidden_states,)
|
|
|
+
|
|
|
+ if output_attentions:
|
|
|
+ outputs += (attn_weights,)
|
|
|
+
|
|
|
+ return outputs
|
|
|
+
|
|
|
+
|
|
|
+class UnimerMBartDecoderLayer(nn.Module):
|
|
|
+ def __init__(self, config: UnimerMBartConfig):
|
|
|
+ super().__init__()
|
|
|
+ self.embed_dim = config.d_model
|
|
|
+
|
|
|
+ self.self_attn = UNIMER_MBART_ATTENTION_CLASSES[config._attn_implementation](
|
|
|
+ embed_dim=self.embed_dim,
|
|
|
+ num_heads=config.decoder_attention_heads,
|
|
|
+ dropout=config.attention_dropout,
|
|
|
+ is_decoder=True,
|
|
|
+ is_causal=True,
|
|
|
+ config=config,
|
|
|
+ )
|
|
|
+ self.dropout = config.dropout
|
|
|
+ self.activation_fn = ACT2FN[config.activation_function]
|
|
|
+ self.activation_dropout = config.activation_dropout
|
|
|
+
|
|
|
+ self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
|
|
|
+ self.encoder_attn = UNIMER_MBART_ATTENTION_CLASSES[config._attn_implementation](
|
|
|
+ self.embed_dim,
|
|
|
+ config.decoder_attention_heads,
|
|
|
+ dropout=config.attention_dropout,
|
|
|
+ is_decoder=True,
|
|
|
+ config=config,
|
|
|
+ )
|
|
|
+ self.encoder_attn_layer_norm = nn.LayerNorm(self.embed_dim)
|
|
|
+ self.fc1 = nn.Linear(self.embed_dim, config.decoder_ffn_dim)
|
|
|
+ self.fc2 = nn.Linear(config.decoder_ffn_dim, self.embed_dim)
|
|
|
+ self.final_layer_norm = nn.LayerNorm(self.embed_dim)
|
|
|
+
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ hidden_states: torch.Tensor,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ encoder_hidden_states: Optional[torch.Tensor] = None,
|
|
|
+ encoder_attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ layer_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ cross_attn_layer_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ past_key_value: Optional[Tuple[torch.Tensor]] = None,
|
|
|
+ output_attentions: Optional[bool] = False,
|
|
|
+ use_cache: Optional[bool] = True,
|
|
|
+ ) -> torch.Tensor:
|
|
|
+ """
|
|
|
+ Args:
|
|
|
+ hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
|
|
|
+ attention_mask (`torch.FloatTensor`): attention mask of size
|
|
|
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
|
|
|
+ encoder_hidden_states (`torch.FloatTensor`):
|
|
|
+ cross attention input to the layer of shape `(batch, seq_len, embed_dim)`
|
|
|
+ encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size
|
|
|
+ `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
|
|
|
+ layer_head_mask (`torch.FloatTensor`): mask for attention heads in a given layer of size
|
|
|
+ `(encoder_attention_heads,)`.
|
|
|
+ cross_attn_layer_head_mask (`torch.FloatTensor`): mask for cross-attention heads in a given layer of
|
|
|
+ size `(decoder_attention_heads,)`.
|
|
|
+ past_key_value (`Tuple(torch.FloatTensor)`): cached past key and value projection states
|
|
|
+ output_attentions (`bool`, *optional*):
|
|
|
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
|
|
|
+ returned tensors for more detail.
|
|
|
+ """
|
|
|
+ residual = hidden_states
|
|
|
+ hidden_states = self.self_attn_layer_norm(hidden_states)
|
|
|
+
|
|
|
+ # Self Attention
|
|
|
+ # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
|
|
|
+ self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
|
|
|
+ # add present self-attn cache to positions 1,2 of present_key_value tuple
|
|
|
+ hidden_states, self_attn_weights, present_key_value = self.self_attn(
|
|
|
+ hidden_states=hidden_states,
|
|
|
+ past_key_value=self_attn_past_key_value,
|
|
|
+ attention_mask=attention_mask,
|
|
|
+ layer_head_mask=layer_head_mask,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ )
|
|
|
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
|
|
|
+ hidden_states = residual + hidden_states
|
|
|
+
|
|
|
+ # Cross-Attention Block
|
|
|
+ cross_attn_present_key_value = None
|
|
|
+ cross_attn_weights = None
|
|
|
+ if encoder_hidden_states is not None:
|
|
|
+ residual = hidden_states
|
|
|
+ hidden_states = self.encoder_attn_layer_norm(hidden_states)
|
|
|
+
|
|
|
+ # cross_attn cached key/values tuple is at positions 3,4 of present_key_value tuple
|
|
|
+ cross_attn_past_key_value = past_key_value[-2:] if past_key_value is not None else None
|
|
|
+ hidden_states, cross_attn_weights, cross_attn_present_key_value = self.encoder_attn(
|
|
|
+ hidden_states=hidden_states,
|
|
|
+ key_value_states=encoder_hidden_states,
|
|
|
+ attention_mask=encoder_attention_mask,
|
|
|
+ layer_head_mask=cross_attn_layer_head_mask,
|
|
|
+ past_key_value=cross_attn_past_key_value,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ )
|
|
|
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
|
|
|
+ hidden_states = residual + hidden_states
|
|
|
+
|
|
|
+ # add cross-attn to positions 3,4 of present_key_value tuple
|
|
|
+ present_key_value = present_key_value + cross_attn_present_key_value
|
|
|
+
|
|
|
+ # Fully Connected
|
|
|
+ residual = hidden_states
|
|
|
+ hidden_states = self.final_layer_norm(hidden_states)
|
|
|
+ hidden_states = self.activation_fn(self.fc1(hidden_states))
|
|
|
+ hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
|
|
|
+ hidden_states = self.fc2(hidden_states)
|
|
|
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
|
|
|
+ hidden_states = residual + hidden_states
|
|
|
+
|
|
|
+ outputs = (hidden_states,)
|
|
|
+
|
|
|
+ if output_attentions:
|
|
|
+ outputs += (self_attn_weights, cross_attn_weights)
|
|
|
+
|
|
|
+ if use_cache:
|
|
|
+ outputs += (present_key_value,)
|
|
|
+
|
|
|
+ return outputs
|
|
|
+
|
|
|
+
|
|
|
+# Copied from transformers.models.bart.modeling_bart.BartClassificationHead with Bart->MBart
|
|
|
+class UnimerMBartClassificationHead(nn.Module):
|
|
|
+ """Head for sentence-level classification tasks."""
|
|
|
+
|
|
|
+ def __init__(
|
|
|
+ self,
|
|
|
+ input_dim: int,
|
|
|
+ inner_dim: int,
|
|
|
+ num_classes: int,
|
|
|
+ pooler_dropout: float,
|
|
|
+ ):
|
|
|
+ super().__init__()
|
|
|
+ self.dense = nn.Linear(input_dim, inner_dim)
|
|
|
+ self.dropout = nn.Dropout(p=pooler_dropout)
|
|
|
+ self.out_proj = nn.Linear(inner_dim, num_classes)
|
|
|
+
|
|
|
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
|
|
|
+ hidden_states = self.dropout(hidden_states)
|
|
|
+ hidden_states = self.dense(hidden_states)
|
|
|
+ hidden_states = torch.tanh(hidden_states)
|
|
|
+ hidden_states = self.dropout(hidden_states)
|
|
|
+ hidden_states = self.out_proj(hidden_states)
|
|
|
+ return hidden_states
|
|
|
+
|
|
|
+
|
|
|
+class UnimerMBartPreTrainedModel(PreTrainedModel):
|
|
|
+ config_class = UnimerMBartConfig
|
|
|
+ base_model_prefix = "model"
|
|
|
+ supports_gradient_checkpointing = True
|
|
|
+ _no_split_modules = ["MBartDecoderLayer", "MBartSqueezeAttention"]
|
|
|
+ _supports_flash_attn_2 = True
|
|
|
+ _supports_sdpa = True
|
|
|
+
|
|
|
+ def _init_weights(self, module):
|
|
|
+ std = self.config.init_std
|
|
|
+ if isinstance(module, nn.Linear):
|
|
|
+ module.weight.data.normal_(mean=0.0, std=std)
|
|
|
+ if module.bias is not None:
|
|
|
+ module.bias.data.zero_()
|
|
|
+ elif isinstance(module, nn.Embedding):
|
|
|
+ module.weight.data.normal_(mean=0.0, std=std)
|
|
|
+ if module.padding_idx is not None:
|
|
|
+ module.weight.data[module.padding_idx].zero_()
|
|
|
+
|
|
|
+ @property
|
|
|
+ def dummy_inputs(self):
|
|
|
+ pad_token = self.config.pad_token_id
|
|
|
+ input_ids = torch.tensor([[0, 6, 10, 4, 2], [0, 8, 12, 2, pad_token]], device=self.device)
|
|
|
+ dummy_inputs = {
|
|
|
+ "attention_mask": input_ids.ne(pad_token),
|
|
|
+ "input_ids": input_ids,
|
|
|
+ }
|
|
|
+ return dummy_inputs
|
|
|
+
|
|
|
+
|
|
|
+MBART_START_DOCSTRING = r"""
|
|
|
+ This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
|
|
|
+ library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
|
|
|
+ etc.)
|
|
|
+
|
|
|
+ This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
|
|
|
+ Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
|
|
|
+ and behavior.
|
|
|
+
|
|
|
+ Parameters:
|
|
|
+ config ([`MBartConfig`]):
|
|
|
+ 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
|
|
|
+ [`~PreTrainedModel.from_pretrained`] method to load the model weights.
|
|
|
+"""
|
|
|
+
|
|
|
+MBART_GENERATION_EXAMPLE = r"""
|
|
|
+ Translation example:
|
|
|
+
|
|
|
+ ```python
|
|
|
+ >>> from transformers import AutoTokenizer, MBartForConditionalGeneration
|
|
|
+
|
|
|
+ >>> model = MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-en-ro")
|
|
|
+ >>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-en-ro")
|
|
|
+
|
|
|
+ >>> example_english_phrase = "42 is the answer"
|
|
|
+ >>> inputs = tokenizer(example_english_phrase, return_tensors="pt")
|
|
|
+
|
|
|
+ >>> # Translate
|
|
|
+ >>> generated_ids = model.generate(**inputs, num_beams=4, max_length=5)
|
|
|
+ >>> tokenizer.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
|
|
|
+ '42 este răspuns'
|
|
|
+ ```
|
|
|
+
|
|
|
+ Mask filling example:
|
|
|
+
|
|
|
+ ```python
|
|
|
+ >>> from transformers import AutoTokenizer, MBartForConditionalGeneration
|
|
|
+
|
|
|
+ >>> model = MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-cc25")
|
|
|
+ >>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
|
|
|
+
|
|
|
+ >>> # de_DE is the language symbol id <LID> for German
|
|
|
+ >>> TXT = "</s> Meine Freunde sind <mask> nett aber sie essen zu viel Kuchen. </s> de_DE"
|
|
|
+
|
|
|
+ >>> input_ids = tokenizer([TXT], add_special_tokens=False, return_tensors="pt")["input_ids"]
|
|
|
+ >>> logits = model(input_ids).logits
|
|
|
+
|
|
|
+ >>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
|
|
|
+ >>> probs = logits[0, masked_index].softmax(dim=0)
|
|
|
+ >>> values, predictions = probs.topk(5)
|
|
|
+
|
|
|
+ >>> tokenizer.decode(predictions).split()
|
|
|
+ ['nett', 'sehr', 'ganz', 'nicht', 'so']
|
|
|
+ ```
|
|
|
+"""
|
|
|
+
|
|
|
+MBART_INPUTS_DOCSTRING = r"""
|
|
|
+ Args:
|
|
|
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
|
|
|
+ Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
|
|
|
+ it.
|
|
|
+
|
|
|
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
|
|
|
+ [`PreTrainedTokenizer.__call__`] for details.
|
|
|
+
|
|
|
+ [What are input IDs?](../glossary#input-ids)
|
|
|
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
|
|
|
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 for tokens that are **not masked**,
|
|
|
+ - 0 for tokens that are **masked**.
|
|
|
+
|
|
|
+ [What are attention masks?](../glossary#attention-mask)
|
|
|
+ decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
|
|
|
+ Indices of decoder input sequence tokens in the vocabulary.
|
|
|
+
|
|
|
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
|
|
|
+ [`PreTrainedTokenizer.__call__`] for details.
|
|
|
+
|
|
|
+ [What are decoder input IDs?](../glossary#decoder-input-ids)
|
|
|
+
|
|
|
+ MBart uses a specific language id token as the starting token for `decoder_input_ids` generation that
|
|
|
+ varies according to source and target language, *e.g.* 25004 for *en_XX*, and 25003 for *de_DE*. If
|
|
|
+ `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
|
|
|
+ `past_key_values`).
|
|
|
+
|
|
|
+ For translation and summarization training, `decoder_input_ids` should be provided. If no
|
|
|
+ `decoder_input_ids` is provided, the model will create this tensor by shifting the `input_ids` to the right
|
|
|
+ for denoising pre-training following the paper.
|
|
|
+ decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
|
|
|
+ Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
|
|
|
+ be used by default.
|
|
|
+ head_mask (`torch.Tensor` of shape `(encoder_layers, encoder_attention_heads)`, *optional*):
|
|
|
+ Mask to nullify selected heads of the attention modules in the encoder. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 indicates the head is **not masked**,
|
|
|
+ - 0 indicates the head is **masked**.
|
|
|
+
|
|
|
+ decoder_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
|
|
|
+ Mask to nullify selected heads of the attention modules in the decoder. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 indicates the head is **not masked**,
|
|
|
+ - 0 indicates the head is **masked**.
|
|
|
+
|
|
|
+ cross_attn_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
|
|
|
+ Mask to nullify selected heads of the cross-attention modules in the decoder. Mask values selected in `[0,
|
|
|
+ 1]`:
|
|
|
+
|
|
|
+ - 1 indicates the head is **not masked**,
|
|
|
+ - 0 indicates the head is **masked**.
|
|
|
+
|
|
|
+ encoder_outputs (`tuple(tuple(torch.FloatTensor)`, *optional*):
|
|
|
+ Tuple consists of (`last_hidden_state`, *optional*: `hidden_states`, *optional*: `attentions`)
|
|
|
+ `last_hidden_state` of shape `(batch_size, sequence_length, hidden_size)`, *optional*) is a sequence of
|
|
|
+ hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.
|
|
|
+ past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
|
|
|
+ Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
|
|
|
+ `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape
|
|
|
+ `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`.
|
|
|
+
|
|
|
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
|
|
|
+ blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
|
|
|
+
|
|
|
+ If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
|
|
|
+ don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
|
|
|
+ `decoder_input_ids` of shape `(batch_size, sequence_length)`.
|
|
|
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
|
|
|
+ Optionally, instead of passing `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.
|
|
|
+ decoder_inputs_embeds (`torch.FloatTensor` of shape `(batch_size, target_sequence_length, hidden_size)`, *optional*):
|
|
|
+ Optionally, instead of passing `decoder_input_ids` you can choose to directly pass an embedded
|
|
|
+ representation. If `past_key_values` is used, optionally only the last `decoder_inputs_embeds` have to be
|
|
|
+ input (see `past_key_values`). This is useful if you want more control over how to convert
|
|
|
+ `decoder_input_ids` indices into associated vectors than the model's internal embedding lookup matrix.
|
|
|
+
|
|
|
+ If `decoder_input_ids` and `decoder_inputs_embeds` are both unset, `decoder_inputs_embeds` takes the value
|
|
|
+ of `inputs_embeds`.
|
|
|
+ use_cache (`bool`, *optional*):
|
|
|
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
|
|
|
+ `past_key_values`).
|
|
|
+ output_attentions (`bool`, *optional*):
|
|
|
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
|
|
|
+ tensors for more detail.
|
|
|
+ output_hidden_states (`bool`, *optional*):
|
|
|
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
|
|
|
+ more detail.
|
|
|
+ return_dict (`bool`, *optional*):
|
|
|
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
|
|
|
+"""
|
|
|
+
|
|
|
+
|
|
|
+class UnimerMBartEncoder(UnimerMBartPreTrainedModel):
|
|
|
+ """
|
|
|
+ Transformer encoder consisting of *config.encoder_layers* self attention layers. Each layer is a
|
|
|
+ [`MBartEncoderLayer`].
|
|
|
+
|
|
|
+ Args:
|
|
|
+ config: MBartConfig
|
|
|
+ embed_tokens (nn.Embedding): output embedding
|
|
|
+ """
|
|
|
+
|
|
|
+ def __init__(self, config: UnimerMBartConfig, embed_tokens: Optional[nn.Embedding] = None):
|
|
|
+ super().__init__(config)
|
|
|
+
|
|
|
+ self.dropout = config.dropout
|
|
|
+ self.layerdrop = config.encoder_layerdrop
|
|
|
+
|
|
|
+ embed_dim = config.d_model
|
|
|
+ self.padding_idx = config.pad_token_id
|
|
|
+ self.max_source_positions = config.max_position_embeddings
|
|
|
+ embed_scale = math.sqrt(embed_dim) if config.scale_embedding else 1.0
|
|
|
+
|
|
|
+ self.embed_tokens = UnimerMBartScaledWordEmbedding(
|
|
|
+ config.vocab_size, embed_dim, self.padding_idx, embed_scale=embed_scale
|
|
|
+ )
|
|
|
+
|
|
|
+ if embed_tokens is not None:
|
|
|
+ self.embed_tokens.weight = embed_tokens.weight
|
|
|
+
|
|
|
+ self.embed_positions = UnimerMBartLearnedPositionalEmbedding(
|
|
|
+ config.max_position_embeddings,
|
|
|
+ embed_dim,
|
|
|
+ )
|
|
|
+ self.layers = nn.ModuleList([UnimerMBartEncoderLayer(config) for _ in range(config.encoder_layers)])
|
|
|
+ self._use_flash_attention_2 = config._attn_implementation == "flash_attention_2"
|
|
|
+ self._use_sdpa = config._attn_implementation == "sdpa"
|
|
|
+ self.layernorm_embedding = nn.LayerNorm(embed_dim)
|
|
|
+ self.layer_norm = nn.LayerNorm(config.d_model)
|
|
|
+
|
|
|
+ self.gradient_checkpointing = False
|
|
|
+ # Initialize weights and apply final processing
|
|
|
+ self.post_init()
|
|
|
+
|
|
|
+ def _backward_compatibility_gradient_checkpointing(self):
|
|
|
+ # Override to not delete the attribute from the config
|
|
|
+ if self.supports_gradient_checkpointing and getattr(self.config, "gradient_checkpointing", False):
|
|
|
+ self.gradient_checkpointing_enable()
|
|
|
+
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ input_ids: torch.LongTensor = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ head_mask: Optional[torch.Tensor] = None,
|
|
|
+ inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ output_attentions: Optional[bool] = None,
|
|
|
+ output_hidden_states: Optional[bool] = None,
|
|
|
+ return_dict: Optional[bool] = None,
|
|
|
+ ) -> Union[Tuple, BaseModelOutput]:
|
|
|
+ r"""
|
|
|
+ Args:
|
|
|
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
|
|
|
+ Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you
|
|
|
+ provide it.
|
|
|
+
|
|
|
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
|
|
|
+ [`PreTrainedTokenizer.__call__`] for details.
|
|
|
+
|
|
|
+ [What are input IDs?](../glossary#input-ids)
|
|
|
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
|
|
|
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 for tokens that are **not masked**,
|
|
|
+ - 0 for tokens that are **masked**.
|
|
|
+
|
|
|
+ [What are attention masks?](../glossary#attention-mask)
|
|
|
+ head_mask (`torch.Tensor` of shape `(encoder_layers, encoder_attention_heads)`, *optional*):
|
|
|
+ Mask to nullify selected heads of the attention modules. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 indicates the head is **not masked**,
|
|
|
+ - 0 indicates the head is **masked**.
|
|
|
+
|
|
|
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
|
|
|
+ Optionally, instead of passing `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.
|
|
|
+ output_attentions (`bool`, *optional*):
|
|
|
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
|
|
|
+ returned tensors for more detail.
|
|
|
+ output_hidden_states (`bool`, *optional*):
|
|
|
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
|
|
|
+ for more detail.
|
|
|
+ return_dict (`bool`, *optional*):
|
|
|
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
|
|
|
+ """
|
|
|
+ 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
|
|
|
+
|
|
|
+ # retrieve input_ids and inputs_embeds
|
|
|
+ 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 = input_ids
|
|
|
+ input_shape = input.shape
|
|
|
+ input_ids = input_ids.view(-1, input_shape[-1])
|
|
|
+ elif inputs_embeds is not None:
|
|
|
+ input = inputs_embeds[:, :, -1]
|
|
|
+ else:
|
|
|
+ raise ValueError("You have to specify either input_ids or inputs_embeds")
|
|
|
+
|
|
|
+ if inputs_embeds is None:
|
|
|
+ inputs_embeds = self.embed_tokens(input_ids)
|
|
|
+
|
|
|
+ embed_pos = self.embed_positions(input)
|
|
|
+
|
|
|
+ hidden_states = inputs_embeds + embed_pos.to(inputs_embeds.device)
|
|
|
+ hidden_states = self.layernorm_embedding(hidden_states)
|
|
|
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
|
|
|
+
|
|
|
+ # expand attention_mask
|
|
|
+ if attention_mask is not None:
|
|
|
+ # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
|
|
|
+ if self._use_flash_attention_2:
|
|
|
+ attention_mask = attention_mask if 0 in attention_mask else None
|
|
|
+ elif self._use_sdpa and head_mask is None and not output_attentions:
|
|
|
+ # output_attentions=True & head_mask can not be supported when using SDPA, fall back to
|
|
|
+ # the manual implementation that requires a 4D causal mask in all cases.
|
|
|
+ # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
|
|
|
+ attention_mask = _prepare_4d_attention_mask_for_sdpa(attention_mask, inputs_embeds.dtype)
|
|
|
+ else:
|
|
|
+ # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
|
|
|
+ attention_mask = _prepare_4d_attention_mask(attention_mask, inputs_embeds.dtype)
|
|
|
+
|
|
|
+ encoder_states = () if output_hidden_states else None
|
|
|
+ all_attentions = () if output_attentions else None
|
|
|
+
|
|
|
+ # check if head_mask has a correct number of layers specified if desired
|
|
|
+ if head_mask is not None:
|
|
|
+ if head_mask.size()[0] != len(self.layers):
|
|
|
+ raise ValueError(
|
|
|
+ f"The head_mask should be specified for {len(self.layers)} layers, but it is for"
|
|
|
+ f" {head_mask.size()[0]}."
|
|
|
+ )
|
|
|
+ for idx, encoder_layer in enumerate(self.layers):
|
|
|
+ if output_hidden_states:
|
|
|
+ encoder_states = encoder_states + (hidden_states,)
|
|
|
+ # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description)
|
|
|
+ to_drop = False
|
|
|
+ if self.training:
|
|
|
+ dropout_probability = torch.rand([])
|
|
|
+ if dropout_probability < self.layerdrop: # skip the layer
|
|
|
+ to_drop = True
|
|
|
+
|
|
|
+ if to_drop:
|
|
|
+ layer_outputs = (None, None)
|
|
|
+ else:
|
|
|
+ if self.gradient_checkpointing and self.training:
|
|
|
+ layer_outputs = self._gradient_checkpointing_func(
|
|
|
+ encoder_layer.__call__,
|
|
|
+ hidden_states,
|
|
|
+ attention_mask,
|
|
|
+ (head_mask[idx] if head_mask is not None else None),
|
|
|
+ output_attentions,
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ layer_outputs = encoder_layer(
|
|
|
+ hidden_states,
|
|
|
+ attention_mask,
|
|
|
+ layer_head_mask=(head_mask[idx] if head_mask is not None else None),
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ )
|
|
|
+
|
|
|
+ hidden_states = layer_outputs[0]
|
|
|
+
|
|
|
+ if output_attentions:
|
|
|
+ all_attentions = all_attentions + (layer_outputs[1],)
|
|
|
+
|
|
|
+ hidden_states = self.layer_norm(hidden_states)
|
|
|
+
|
|
|
+ if output_hidden_states:
|
|
|
+ encoder_states = encoder_states + (hidden_states,)
|
|
|
+
|
|
|
+ if not return_dict:
|
|
|
+ return tuple(v for v in [hidden_states, encoder_states, all_attentions] if v is not None)
|
|
|
+ return BaseModelOutput(
|
|
|
+ last_hidden_state=hidden_states, hidden_states=encoder_states, attentions=all_attentions
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+class UnimerMBartDecoder(UnimerMBartPreTrainedModel):
|
|
|
+ """
|
|
|
+ Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`MBartDecoderLayer`]
|
|
|
+
|
|
|
+ Args:
|
|
|
+ config: MBartConfig
|
|
|
+ embed_tokens (nn.Embedding): output embedding
|
|
|
+ """
|
|
|
+
|
|
|
+ def __init__(self, config: UnimerMBartConfig, embed_tokens: Optional[nn.Embedding] = None):
|
|
|
+ super().__init__(config)
|
|
|
+ self.dropout = config.dropout
|
|
|
+ self.layerdrop = config.decoder_layerdrop
|
|
|
+ self.padding_idx = config.pad_token_id
|
|
|
+ self.max_target_positions = config.max_position_embeddings
|
|
|
+ embed_scale = math.sqrt(config.d_model) if config.scale_embedding else 1.0
|
|
|
+
|
|
|
+ self.embed_tokens = UnimerMBartScaledWordEmbedding(
|
|
|
+ config.vocab_size, config.d_model, self.padding_idx, embed_scale=embed_scale
|
|
|
+ )
|
|
|
+
|
|
|
+ if embed_tokens is not None:
|
|
|
+ self.embed_tokens.weight = embed_tokens.weight
|
|
|
+
|
|
|
+ self.embed_positions = UnimerMBartLearnedPositionalEmbedding(
|
|
|
+ config.max_position_embeddings,
|
|
|
+ config.d_model,
|
|
|
+ )
|
|
|
+ self.layers = nn.ModuleList([UnimerMBartDecoderLayer(config) for _ in range(config.decoder_layers)])
|
|
|
+ self._use_flash_attention_2 = config._attn_implementation == "flash_attention_2"
|
|
|
+ self._use_sdpa = config._attn_implementation == "sdpa"
|
|
|
+ self.layernorm_embedding = nn.LayerNorm(config.d_model)
|
|
|
+ self.layer_norm = nn.LayerNorm(config.d_model)
|
|
|
+
|
|
|
+ self.gradient_checkpointing = False
|
|
|
+ # Initialize weights and apply final processing
|
|
|
+ self.post_init()
|
|
|
+
|
|
|
+ def get_input_embeddings(self):
|
|
|
+ return self.embed_tokens
|
|
|
+
|
|
|
+ def set_input_embeddings(self, value):
|
|
|
+ self.embed_tokens = value
|
|
|
+
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ input_ids: torch.LongTensor = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ count_pred: Optional[torch.FloatTensor] = None,
|
|
|
+ encoder_hidden_states: Optional[torch.FloatTensor] = None,
|
|
|
+ encoder_attention_mask: Optional[torch.LongTensor] = None,
|
|
|
+ head_mask: Optional[torch.Tensor] = None,
|
|
|
+ cross_attn_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
|
|
|
+ inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ use_cache: Optional[bool] = None,
|
|
|
+ output_attentions: Optional[bool] = None,
|
|
|
+ output_hidden_states: Optional[bool] = None,
|
|
|
+ return_dict: Optional[bool] = None,
|
|
|
+ ) -> Union[Tuple, BaseModelOutputWithPastAndCrossAttentions]:
|
|
|
+ r"""
|
|
|
+ Args:
|
|
|
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
|
|
|
+ Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you
|
|
|
+ provide it.
|
|
|
+
|
|
|
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
|
|
|
+ [`PreTrainedTokenizer.__call__`] for details.
|
|
|
+
|
|
|
+ [What are input IDs?](../glossary#input-ids)
|
|
|
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
|
|
|
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 for tokens that are **not masked**,
|
|
|
+ - 0 for tokens that are **masked**.
|
|
|
+
|
|
|
+ [What are attention masks?](../glossary#attention-mask)
|
|
|
+ encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*):
|
|
|
+ Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
|
|
|
+ of the decoder.
|
|
|
+ encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, encoder_sequence_length)`, *optional*):
|
|
|
+ Mask to avoid performing cross-attention on padding tokens indices of encoder input_ids. Mask values
|
|
|
+ selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 for tokens that are **not masked**,
|
|
|
+ - 0 for tokens that are **masked**.
|
|
|
+
|
|
|
+ [What are attention masks?](../glossary#attention-mask)
|
|
|
+ head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
|
|
|
+ Mask to nullify selected heads of the attention modules. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 indicates the head is **not masked**,
|
|
|
+ - 0 indicates the head is **masked**.
|
|
|
+
|
|
|
+ cross_attn_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
|
|
|
+ Mask to nullify selected heads of the cross-attention modules in the decoder to avoid performing
|
|
|
+ cross-attention on hidden heads. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 indicates the head is **not masked**,
|
|
|
+ - 0 indicates the head is **masked**.
|
|
|
+
|
|
|
+ past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
|
|
|
+ Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of
|
|
|
+ shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of
|
|
|
+ shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`.
|
|
|
+
|
|
|
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and in the
|
|
|
+ cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
|
|
|
+
|
|
|
+ If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those
|
|
|
+ that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of
|
|
|
+ all `decoder_input_ids` of shape `(batch_size, sequence_length)`.
|
|
|
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
|
|
|
+ Optionally, instead of passing `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.
|
|
|
+ output_attentions (`bool`, *optional*):
|
|
|
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
|
|
|
+ returned tensors for more detail.
|
|
|
+ output_hidden_states (`bool`, *optional*):
|
|
|
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
|
|
|
+ for more detail.
|
|
|
+ return_dict (`bool`, *optional*):
|
|
|
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
|
|
|
+ """
|
|
|
+ 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
|
|
|
+ )
|
|
|
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
|
|
|
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
|
|
|
+
|
|
|
+ # retrieve input_ids and inputs_embeds
|
|
|
+ if input_ids is not None and inputs_embeds is not None:
|
|
|
+ raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
|
|
|
+ elif input_ids is not None:
|
|
|
+ input = input_ids
|
|
|
+ input_shape = input.size()
|
|
|
+ input_ids = input_ids.view(-1, input_shape[-1])
|
|
|
+ elif inputs_embeds is not None:
|
|
|
+ input_shape = inputs_embeds.size()[:-1]
|
|
|
+ input = inputs_embeds[:, :, -1]
|
|
|
+ else:
|
|
|
+ raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds")
|
|
|
+
|
|
|
+ # past_key_values_length
|
|
|
+ past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
|
|
|
+
|
|
|
+ if inputs_embeds is None:
|
|
|
+ inputs_embeds = self.embed_tokens(input_ids)
|
|
|
+
|
|
|
+ if self._use_flash_attention_2:
|
|
|
+ # 2d mask is passed through the layers
|
|
|
+ attention_mask = attention_mask if (attention_mask is not None and 0 in attention_mask) else None
|
|
|
+ elif self._use_sdpa and not output_attentions and cross_attn_head_mask is None:
|
|
|
+ # output_attentions=True & cross_attn_head_mask can not be supported when using SDPA, and we fall back on
|
|
|
+ # the manual implementation that requires a 4D causal mask in all cases.
|
|
|
+ attention_mask = _prepare_4d_causal_attention_mask_for_sdpa(
|
|
|
+ attention_mask,
|
|
|
+ input_shape,
|
|
|
+ inputs_embeds,
|
|
|
+ past_key_values_length,
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ # 4d mask is passed through the layers
|
|
|
+ attention_mask = _prepare_4d_causal_attention_mask(
|
|
|
+ attention_mask, input_shape, inputs_embeds, past_key_values_length
|
|
|
+ )
|
|
|
+
|
|
|
+ # expand encoder attention mask
|
|
|
+ if encoder_hidden_states is not None and encoder_attention_mask is not None:
|
|
|
+ if self._use_flash_attention_2:
|
|
|
+ encoder_attention_mask = encoder_attention_mask if 0 in encoder_attention_mask else None
|
|
|
+ elif self._use_sdpa and cross_attn_head_mask is None and not output_attentions:
|
|
|
+ # output_attentions=True & cross_attn_head_mask can not be supported when using SDPA, and we fall back on
|
|
|
+ # the manual implementation that requires a 4D causal mask in all cases.
|
|
|
+ # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
|
|
|
+ encoder_attention_mask = _prepare_4d_attention_mask_for_sdpa(
|
|
|
+ encoder_attention_mask,
|
|
|
+ inputs_embeds.dtype,
|
|
|
+ tgt_len=input_shape[-1],
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
|
|
|
+ encoder_attention_mask = _prepare_4d_attention_mask(
|
|
|
+ encoder_attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]
|
|
|
+ )
|
|
|
+
|
|
|
+ # embed positions
|
|
|
+ positions = self.embed_positions(input, past_key_values_length)
|
|
|
+
|
|
|
+ hidden_states = inputs_embeds + positions.to(inputs_embeds.device)
|
|
|
+
|
|
|
+ # TODO: add counting context weight to hidden_states
|
|
|
+ if count_pred is not None:
|
|
|
+ count_context_weight = self.counting_context_weight(count_pred)
|
|
|
+ hidden_states = hidden_states + 0.5 * count_context_weight.unsqueeze(1)
|
|
|
+
|
|
|
+ hidden_states = self.layernorm_embedding(hidden_states)
|
|
|
+ hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
|
|
|
+
|
|
|
+ if self.gradient_checkpointing and self.training:
|
|
|
+ if use_cache:
|
|
|
+ logger.warning_once(
|
|
|
+ "`use_cache=True` is incompatible with gradient checkpointing`. Setting `use_cache=False`..."
|
|
|
+ )
|
|
|
+ use_cache = False
|
|
|
+
|
|
|
+ # decoder layers
|
|
|
+ all_hidden_states = () if output_hidden_states else None
|
|
|
+ all_self_attns = () if output_attentions else None
|
|
|
+ all_cross_attentions = () if (output_attentions and encoder_hidden_states is not None) else None
|
|
|
+ next_decoder_cache = () if use_cache else None
|
|
|
+
|
|
|
+ # check if head_mask/cross_attn_head_mask has a correct number of layers specified if desired
|
|
|
+ for attn_mask, mask_name in zip([head_mask, cross_attn_head_mask], ["head_mask", "cross_attn_head_mask"]):
|
|
|
+ if attn_mask is not None:
|
|
|
+ if attn_mask.size()[0] != len(self.layers):
|
|
|
+ raise ValueError(
|
|
|
+ f"The `{mask_name}` should be specified for {len(self.layers)} layers, but it is for"
|
|
|
+ f" {attn_mask.size()[0]}."
|
|
|
+ )
|
|
|
+ for idx, decoder_layer in enumerate(self.layers):
|
|
|
+ # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description)
|
|
|
+ if output_hidden_states:
|
|
|
+ all_hidden_states += (hidden_states,)
|
|
|
+ if self.training:
|
|
|
+ dropout_probability = torch.rand([])
|
|
|
+ if dropout_probability < self.layerdrop:
|
|
|
+ continue
|
|
|
+
|
|
|
+ past_key_value = past_key_values[idx] if past_key_values is not None else None
|
|
|
+
|
|
|
+ if self.gradient_checkpointing and self.training:
|
|
|
+ layer_outputs = self._gradient_checkpointing_func(
|
|
|
+ decoder_layer.__call__,
|
|
|
+ hidden_states,
|
|
|
+ attention_mask,
|
|
|
+ encoder_hidden_states,
|
|
|
+ encoder_attention_mask,
|
|
|
+ head_mask[idx] if head_mask is not None else None,
|
|
|
+ cross_attn_head_mask[idx] if cross_attn_head_mask is not None else None,
|
|
|
+ None,
|
|
|
+ output_attentions,
|
|
|
+ use_cache,
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ layer_outputs = decoder_layer(
|
|
|
+ hidden_states,
|
|
|
+ attention_mask=attention_mask,
|
|
|
+ encoder_hidden_states=encoder_hidden_states,
|
|
|
+ encoder_attention_mask=encoder_attention_mask,
|
|
|
+ layer_head_mask=(head_mask[idx] if head_mask is not None else None),
|
|
|
+ cross_attn_layer_head_mask=(
|
|
|
+ cross_attn_head_mask[idx] if cross_attn_head_mask is not None else None
|
|
|
+ ),
|
|
|
+ past_key_value=past_key_value,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ use_cache=use_cache,
|
|
|
+ )
|
|
|
+ hidden_states = layer_outputs[0]
|
|
|
+
|
|
|
+ if use_cache:
|
|
|
+ next_decoder_cache += (layer_outputs[3 if output_attentions else 1],)
|
|
|
+
|
|
|
+ if output_attentions:
|
|
|
+ all_self_attns += (layer_outputs[1],)
|
|
|
+
|
|
|
+ if encoder_hidden_states is not None:
|
|
|
+ all_cross_attentions += (layer_outputs[2],)
|
|
|
+
|
|
|
+ hidden_states = self.layer_norm(hidden_states)
|
|
|
+
|
|
|
+ # add hidden states from the last decoder layer
|
|
|
+ if output_hidden_states:
|
|
|
+ all_hidden_states += (hidden_states,)
|
|
|
+
|
|
|
+ next_cache = next_decoder_cache if use_cache else None
|
|
|
+ if not return_dict:
|
|
|
+ return tuple(
|
|
|
+ v
|
|
|
+ for v in [hidden_states, next_cache, all_hidden_states, all_self_attns, all_cross_attentions]
|
|
|
+ if v is not None
|
|
|
+ )
|
|
|
+ return BaseModelOutputWithPastAndCrossAttentions(
|
|
|
+ last_hidden_state=hidden_states,
|
|
|
+ past_key_values=next_cache,
|
|
|
+ hidden_states=all_hidden_states,
|
|
|
+ attentions=all_self_attns,
|
|
|
+ cross_attentions=all_cross_attentions,
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@add_start_docstrings(
|
|
|
+ "The bare MBART Model outputting raw hidden-states without any specific head on top.",
|
|
|
+ MBART_START_DOCSTRING,
|
|
|
+)
|
|
|
+class UnimerMBartModel(UnimerMBartPreTrainedModel):
|
|
|
+ _tied_weights_keys = ["encoder.embed_tokens.weight", "decoder.embed_tokens.weight"]
|
|
|
+
|
|
|
+ def __init__(self, config: UnimerMBartConfig):
|
|
|
+ super().__init__(config)
|
|
|
+
|
|
|
+ padding_idx, vocab_size = config.pad_token_id, config.vocab_size
|
|
|
+ self.shared = nn.Embedding(vocab_size, config.d_model, padding_idx)
|
|
|
+
|
|
|
+ self.encoder = UnimerMBartEncoder(config, self.shared)
|
|
|
+ self.decoder = UnimerMBartDecoder(config, self.shared)
|
|
|
+
|
|
|
+ # Initialize weights and apply final processing
|
|
|
+ self.post_init()
|
|
|
+
|
|
|
+ def get_input_embeddings(self):
|
|
|
+ return self.shared
|
|
|
+
|
|
|
+ def set_input_embeddings(self, value):
|
|
|
+ self.shared = value
|
|
|
+ self.encoder.embed_tokens = self.shared
|
|
|
+ self.decoder.embed_tokens = self.shared
|
|
|
+
|
|
|
+ def get_encoder(self):
|
|
|
+ return self.encoder
|
|
|
+
|
|
|
+ def get_decoder(self):
|
|
|
+ return self.decoder
|
|
|
+
|
|
|
+ def _tie_weights(self):
|
|
|
+ if self.config.tie_word_embeddings:
|
|
|
+ self._tie_or_clone_weights(self.encoder.embed_tokens, self.get_input_embeddings())
|
|
|
+ self._tie_or_clone_weights(self.decoder.embed_tokens, self.get_input_embeddings())
|
|
|
+
|
|
|
+ @add_start_docstrings_to_model_forward(MBART_INPUTS_DOCSTRING)
|
|
|
+ @add_code_sample_docstrings(
|
|
|
+ checkpoint=_CHECKPOINT_FOR_DOC,
|
|
|
+ output_type=Seq2SeqModelOutput,
|
|
|
+ config_class=_CONFIG_FOR_DOC,
|
|
|
+ expected_output=_EXPECTED_OUTPUT_SHAPE,
|
|
|
+ )
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ input_ids: torch.LongTensor = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ decoder_input_ids: Optional[torch.LongTensor] = None,
|
|
|
+ decoder_attention_mask: Optional[torch.LongTensor] = None,
|
|
|
+ head_mask: Optional[torch.Tensor] = None,
|
|
|
+ decoder_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ cross_attn_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ encoder_outputs: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
|
|
|
+ past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
|
|
|
+ inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ use_cache: Optional[bool] = None,
|
|
|
+ output_attentions: Optional[bool] = None,
|
|
|
+ output_hidden_states: Optional[bool] = None,
|
|
|
+ return_dict: Optional[bool] = None,
|
|
|
+ ) -> Union[Seq2SeqModelOutput, Tuple[torch.FloatTensor]]:
|
|
|
+ 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
|
|
|
+ )
|
|
|
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
|
|
|
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
|
|
|
+
|
|
|
+ # different to other models, MBart automatically creates decoder_input_ids from
|
|
|
+ # input_ids if no decoder_input_ids are provided
|
|
|
+ if decoder_input_ids is None and decoder_inputs_embeds is None:
|
|
|
+ decoder_input_ids = shift_tokens_right(input_ids, self.config.pad_token_id)
|
|
|
+
|
|
|
+ if encoder_outputs is None:
|
|
|
+ encoder_outputs = self.encoder(
|
|
|
+ input_ids=input_ids,
|
|
|
+ attention_mask=attention_mask,
|
|
|
+ head_mask=head_mask,
|
|
|
+ inputs_embeds=inputs_embeds,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ output_hidden_states=output_hidden_states,
|
|
|
+ return_dict=return_dict,
|
|
|
+ )
|
|
|
+ # If the user passed a tuple for encoder_outputs, we wrap it in a BaseModelOutput when return_dict=True
|
|
|
+ elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
|
|
|
+ encoder_outputs = BaseModelOutput(
|
|
|
+ last_hidden_state=encoder_outputs[0],
|
|
|
+ hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
|
|
|
+ attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
|
|
|
+ )
|
|
|
+
|
|
|
+ # decoder outputs consists of (dec_features, past_key_value, dec_hidden, dec_attn)
|
|
|
+ decoder_outputs = self.decoder(
|
|
|
+ input_ids=decoder_input_ids,
|
|
|
+ attention_mask=decoder_attention_mask,
|
|
|
+ encoder_hidden_states=encoder_outputs[0],
|
|
|
+ encoder_attention_mask=attention_mask,
|
|
|
+ head_mask=decoder_head_mask,
|
|
|
+ cross_attn_head_mask=cross_attn_head_mask,
|
|
|
+ past_key_values=past_key_values,
|
|
|
+ inputs_embeds=decoder_inputs_embeds,
|
|
|
+ use_cache=use_cache,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ output_hidden_states=output_hidden_states,
|
|
|
+ return_dict=return_dict,
|
|
|
+ )
|
|
|
+
|
|
|
+ if not return_dict:
|
|
|
+ return decoder_outputs + encoder_outputs
|
|
|
+
|
|
|
+ return Seq2SeqModelOutput(
|
|
|
+ last_hidden_state=decoder_outputs.last_hidden_state,
|
|
|
+ past_key_values=decoder_outputs.past_key_values,
|
|
|
+ decoder_hidden_states=decoder_outputs.hidden_states,
|
|
|
+ decoder_attentions=decoder_outputs.attentions,
|
|
|
+ cross_attentions=decoder_outputs.cross_attentions,
|
|
|
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
|
|
|
+ encoder_hidden_states=encoder_outputs.hidden_states,
|
|
|
+ encoder_attentions=encoder_outputs.attentions,
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@add_start_docstrings(
|
|
|
+ "The MBART Model with a language modeling head. Can be used for summarization, after fine-tuning the pretrained models.",
|
|
|
+ MBART_START_DOCSTRING,
|
|
|
+)
|
|
|
+class UnimerMBartForConditionalGeneration(UnimerMBartPreTrainedModel, GenerationMixin):
|
|
|
+ base_model_prefix = "model"
|
|
|
+ _keys_to_ignore_on_load_missing = ["final_logits_bias"]
|
|
|
+ _tied_weights_keys = ["model.encoder.embed_tokens.weight", "model.decoder.embed_tokens.weight", "lm_head.weight"]
|
|
|
+
|
|
|
+ def __init__(self, config: UnimerMBartConfig):
|
|
|
+ super().__init__(config)
|
|
|
+ self.model = UnimerMBartModel(config)
|
|
|
+ self.register_buffer("final_logits_bias", torch.zeros((1, self.model.shared.num_embeddings)))
|
|
|
+ self.lm_head = nn.Linear(config.d_model, self.model.shared.num_embeddings, bias=False)
|
|
|
+
|
|
|
+ # Initialize weights and apply final processing
|
|
|
+ self.post_init()
|
|
|
+
|
|
|
+ def get_encoder(self):
|
|
|
+ return self.model.get_encoder()
|
|
|
+
|
|
|
+ def get_decoder(self):
|
|
|
+ return self.model.get_decoder()
|
|
|
+
|
|
|
+ def resize_token_embeddings(self, new_num_tokens: int, pad_to_multiple_of: Optional[int] = None) -> nn.Embedding:
|
|
|
+ new_embeddings = super().resize_token_embeddings(new_num_tokens, pad_to_multiple_of)
|
|
|
+ self._resize_final_logits_bias(new_embeddings.weight.shape[0])
|
|
|
+ return new_embeddings
|
|
|
+
|
|
|
+ def _resize_final_logits_bias(self, new_num_tokens: int) -> None:
|
|
|
+ old_num_tokens = self.final_logits_bias.shape[-1]
|
|
|
+ if new_num_tokens <= old_num_tokens:
|
|
|
+ new_bias = self.final_logits_bias[:, :new_num_tokens]
|
|
|
+ else:
|
|
|
+ extra_bias = torch.zeros((1, new_num_tokens - old_num_tokens), device=self.final_logits_bias.device)
|
|
|
+ new_bias = torch.cat([self.final_logits_bias, extra_bias], dim=1)
|
|
|
+ self.register_buffer("final_logits_bias", new_bias)
|
|
|
+
|
|
|
+ def get_output_embeddings(self):
|
|
|
+ return self.lm_head
|
|
|
+
|
|
|
+ def set_output_embeddings(self, new_embeddings):
|
|
|
+ self.lm_head = new_embeddings
|
|
|
+
|
|
|
+ @add_start_docstrings_to_model_forward(MBART_INPUTS_DOCSTRING)
|
|
|
+ @replace_return_docstrings(output_type=Seq2SeqLMOutput, config_class=_CONFIG_FOR_DOC)
|
|
|
+ @add_end_docstrings(MBART_GENERATION_EXAMPLE)
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ input_ids: torch.LongTensor = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ decoder_input_ids: Optional[torch.LongTensor] = None,
|
|
|
+ decoder_attention_mask: Optional[torch.LongTensor] = None,
|
|
|
+ head_mask: Optional[torch.Tensor] = None,
|
|
|
+ decoder_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ cross_attn_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ encoder_outputs: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
|
|
|
+ past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
|
|
|
+ inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ labels: Optional[torch.LongTensor] = None,
|
|
|
+ use_cache: Optional[bool] = None,
|
|
|
+ output_attentions: Optional[bool] = None,
|
|
|
+ output_hidden_states: Optional[bool] = None,
|
|
|
+ return_dict: Optional[bool] = None,
|
|
|
+ ) -> Union[Seq2SeqLMOutput, Tuple[torch.FloatTensor]]:
|
|
|
+ r"""
|
|
|
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
|
|
|
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
|
|
|
+ config.vocab_size]` or -100 (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:
|
|
|
+
|
|
|
+ """
|
|
|
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
|
|
|
+
|
|
|
+ if labels is not None:
|
|
|
+ if use_cache:
|
|
|
+ logger.warning("The `use_cache` argument is changed to `False` since `labels` is provided.")
|
|
|
+ use_cache = False
|
|
|
+ if decoder_input_ids is None and decoder_inputs_embeds is None:
|
|
|
+ decoder_input_ids = shift_tokens_right(labels, self.config.pad_token_id)
|
|
|
+
|
|
|
+ outputs = self.model(
|
|
|
+ input_ids,
|
|
|
+ attention_mask=attention_mask,
|
|
|
+ decoder_input_ids=decoder_input_ids,
|
|
|
+ encoder_outputs=encoder_outputs,
|
|
|
+ decoder_attention_mask=decoder_attention_mask,
|
|
|
+ head_mask=head_mask,
|
|
|
+ decoder_head_mask=decoder_head_mask,
|
|
|
+ cross_attn_head_mask=cross_attn_head_mask,
|
|
|
+ past_key_values=past_key_values,
|
|
|
+ inputs_embeds=inputs_embeds,
|
|
|
+ decoder_inputs_embeds=decoder_inputs_embeds,
|
|
|
+ use_cache=use_cache,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ output_hidden_states=output_hidden_states,
|
|
|
+ return_dict=return_dict,
|
|
|
+ )
|
|
|
+ lm_logits = self.lm_head(outputs[0]) + self.final_logits_bias
|
|
|
+
|
|
|
+ masked_lm_loss = None
|
|
|
+ if labels is not None:
|
|
|
+ loss_fct = CrossEntropyLoss()
|
|
|
+ masked_lm_loss = loss_fct(lm_logits.view(-1, self.config.vocab_size), labels.view(-1))
|
|
|
+
|
|
|
+ if not return_dict:
|
|
|
+ output = (lm_logits,) + outputs[1:]
|
|
|
+ return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
|
|
|
+
|
|
|
+ return Seq2SeqLMOutput(
|
|
|
+ loss=masked_lm_loss,
|
|
|
+ logits=lm_logits,
|
|
|
+ past_key_values=outputs.past_key_values,
|
|
|
+ decoder_hidden_states=outputs.decoder_hidden_states,
|
|
|
+ decoder_attentions=outputs.decoder_attentions,
|
|
|
+ cross_attentions=outputs.cross_attentions,
|
|
|
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
|
|
|
+ encoder_hidden_states=outputs.encoder_hidden_states,
|
|
|
+ encoder_attentions=outputs.encoder_attentions,
|
|
|
+ )
|
|
|
+
|
|
|
+ def prepare_inputs_for_generation(
|
|
|
+ self,
|
|
|
+ decoder_input_ids,
|
|
|
+ past_key_values=None,
|
|
|
+ attention_mask=None,
|
|
|
+ head_mask=None,
|
|
|
+ decoder_head_mask=None,
|
|
|
+ cross_attn_head_mask=None,
|
|
|
+ use_cache=None,
|
|
|
+ encoder_outputs=None,
|
|
|
+ **kwargs,
|
|
|
+ ):
|
|
|
+ # cut decoder_input_ids if past is used
|
|
|
+ if past_key_values is not None:
|
|
|
+ past_length = past_key_values[0][0].shape[2]
|
|
|
+
|
|
|
+ # Some generation methods already pass only the last input ID
|
|
|
+ if decoder_input_ids.shape[1] > past_length:
|
|
|
+ remove_prefix_length = past_length
|
|
|
+ else:
|
|
|
+ # Default to old behavior: keep only final ID
|
|
|
+ remove_prefix_length = decoder_input_ids.shape[1] - 1
|
|
|
+
|
|
|
+ decoder_input_ids = decoder_input_ids[:, remove_prefix_length:]
|
|
|
+
|
|
|
+ return {
|
|
|
+ "input_ids": None, # encoder_outputs is defined. input_ids not needed
|
|
|
+ "encoder_outputs": encoder_outputs,
|
|
|
+ "past_key_values": past_key_values,
|
|
|
+ "decoder_input_ids": decoder_input_ids,
|
|
|
+ "attention_mask": attention_mask,
|
|
|
+ "head_mask": head_mask,
|
|
|
+ "decoder_head_mask": decoder_head_mask,
|
|
|
+ "cross_attn_head_mask": cross_attn_head_mask,
|
|
|
+ "use_cache": use_cache, # change this to avoid caching (presumably for debugging)
|
|
|
+ }
|
|
|
+
|
|
|
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
|
|
|
+ return shift_tokens_right(labels, self.config.pad_token_id)
|
|
|
+
|
|
|
+ @staticmethod
|
|
|
+ def _reorder_cache(past_key_values, beam_idx):
|
|
|
+ reordered_past = ()
|
|
|
+ for layer_past in past_key_values:
|
|
|
+ # cached cross_attention states don't have to be reordered -> they are always the same
|
|
|
+ reordered_past += (
|
|
|
+ tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past[:2])
|
|
|
+ + layer_past[2:],
|
|
|
+ )
|
|
|
+ return reordered_past
|
|
|
+
|
|
|
+
|
|
|
+@add_start_docstrings(
|
|
|
+ """
|
|
|
+ MBart model with a sequence classification/head on top (a linear layer on top of the pooled output) e.g. for GLUE
|
|
|
+ tasks.
|
|
|
+ """,
|
|
|
+ MBART_START_DOCSTRING,
|
|
|
+)
|
|
|
+class UnimerMBartForSequenceClassification(UnimerMBartPreTrainedModel):
|
|
|
+ _tied_weights_keys = ["model.encoder.embed_tokens.weight", "model.decoder.embed_tokens.weight"]
|
|
|
+
|
|
|
+ def __init__(self, config: UnimerMBartConfig, **kwargs):
|
|
|
+ super().__init__(config, **kwargs)
|
|
|
+ self.model = UnimerMBartModel(config)
|
|
|
+ self.classification_head = UnimerMBartClassificationHead(
|
|
|
+ config.d_model,
|
|
|
+ config.d_model,
|
|
|
+ config.num_labels,
|
|
|
+ config.classifier_dropout,
|
|
|
+ )
|
|
|
+
|
|
|
+ # Initialize weights and apply final processing
|
|
|
+ self.post_init()
|
|
|
+
|
|
|
+ @add_start_docstrings_to_model_forward(MBART_INPUTS_DOCSTRING)
|
|
|
+ @add_code_sample_docstrings(
|
|
|
+ checkpoint=_CHECKPOINT_FOR_DOC,
|
|
|
+ output_type=Seq2SeqSequenceClassifierOutput,
|
|
|
+ config_class=_CONFIG_FOR_DOC,
|
|
|
+ )
|
|
|
+ # Copied from transformers.models.bart.modeling_bart.BartForSequenceClassification.forward
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ input_ids: torch.LongTensor = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ decoder_input_ids: Optional[torch.LongTensor] = None,
|
|
|
+ decoder_attention_mask: Optional[torch.LongTensor] = None,
|
|
|
+ head_mask: Optional[torch.Tensor] = None,
|
|
|
+ decoder_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ cross_attn_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ encoder_outputs: Optional[List[torch.FloatTensor]] = None,
|
|
|
+ inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ labels: Optional[torch.LongTensor] = None,
|
|
|
+ use_cache: Optional[bool] = None,
|
|
|
+ output_attentions: Optional[bool] = None,
|
|
|
+ output_hidden_states: Optional[bool] = None,
|
|
|
+ return_dict: Optional[bool] = None,
|
|
|
+ ) -> Union[Tuple, Seq2SeqSequenceClassifierOutput]:
|
|
|
+ r"""
|
|
|
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
|
|
|
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
|
|
|
+ config.num_labels - 1]`. If `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
|
|
|
+ if labels is not None:
|
|
|
+ use_cache = False
|
|
|
+
|
|
|
+ if input_ids is None and inputs_embeds is not None:
|
|
|
+ raise NotImplementedError(
|
|
|
+ f"Passing input embeddings is currently not supported for {self.__class__.__name__}"
|
|
|
+ )
|
|
|
+
|
|
|
+ outputs = self.model(
|
|
|
+ input_ids,
|
|
|
+ attention_mask=attention_mask,
|
|
|
+ decoder_input_ids=decoder_input_ids,
|
|
|
+ decoder_attention_mask=decoder_attention_mask,
|
|
|
+ head_mask=head_mask,
|
|
|
+ decoder_head_mask=decoder_head_mask,
|
|
|
+ cross_attn_head_mask=cross_attn_head_mask,
|
|
|
+ encoder_outputs=encoder_outputs,
|
|
|
+ inputs_embeds=inputs_embeds,
|
|
|
+ decoder_inputs_embeds=decoder_inputs_embeds,
|
|
|
+ use_cache=use_cache,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ output_hidden_states=output_hidden_states,
|
|
|
+ return_dict=return_dict,
|
|
|
+ )
|
|
|
+ hidden_states = outputs[0] # last hidden state
|
|
|
+
|
|
|
+ eos_mask = input_ids.eq(self.config.eos_token_id).to(hidden_states.device)
|
|
|
+
|
|
|
+ if len(torch.unique_consecutive(eos_mask.sum(1))) > 1:
|
|
|
+ raise ValueError("All examples must have the same number of <eos> tokens.")
|
|
|
+ sentence_representation = hidden_states[eos_mask, :].view(hidden_states.size(0), -1, hidden_states.size(-1))[
|
|
|
+ :, -1, :
|
|
|
+ ]
|
|
|
+ logits = self.classification_head(sentence_representation)
|
|
|
+
|
|
|
+ loss = None
|
|
|
+ if labels is not None:
|
|
|
+ labels = labels.to(logits.device)
|
|
|
+ if self.config.problem_type is None:
|
|
|
+ if self.config.num_labels == 1:
|
|
|
+ self.config.problem_type = "regression"
|
|
|
+ elif self.config.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
|
|
|
+ self.config.problem_type = "single_label_classification"
|
|
|
+ else:
|
|
|
+ self.config.problem_type = "multi_label_classification"
|
|
|
+
|
|
|
+ if self.config.problem_type == "regression":
|
|
|
+ loss_fct = MSELoss()
|
|
|
+ if self.config.num_labels == 1:
|
|
|
+ loss = loss_fct(logits.squeeze(), labels.squeeze())
|
|
|
+ else:
|
|
|
+ loss = loss_fct(logits, labels)
|
|
|
+ elif self.config.problem_type == "single_label_classification":
|
|
|
+ loss_fct = CrossEntropyLoss()
|
|
|
+ loss = loss_fct(logits.view(-1, self.config.num_labels), labels.view(-1))
|
|
|
+ elif self.config.problem_type == "multi_label_classification":
|
|
|
+ loss_fct = BCEWithLogitsLoss()
|
|
|
+ loss = loss_fct(logits, labels)
|
|
|
+ if not return_dict:
|
|
|
+ output = (logits,) + outputs[1:]
|
|
|
+ return ((loss,) + output) if loss is not None else output
|
|
|
+
|
|
|
+ return Seq2SeqSequenceClassifierOutput(
|
|
|
+ loss=loss,
|
|
|
+ logits=logits,
|
|
|
+ past_key_values=outputs.past_key_values,
|
|
|
+ decoder_hidden_states=outputs.decoder_hidden_states,
|
|
|
+ decoder_attentions=outputs.decoder_attentions,
|
|
|
+ cross_attentions=outputs.cross_attentions,
|
|
|
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
|
|
|
+ encoder_hidden_states=outputs.encoder_hidden_states,
|
|
|
+ encoder_attentions=outputs.encoder_attentions,
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@add_start_docstrings(
|
|
|
+ """
|
|
|
+ MBART Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear
|
|
|
+ layer on top of the hidden-states output to compute `span start logits` and `span end logits`).
|
|
|
+ """,
|
|
|
+ MBART_START_DOCSTRING,
|
|
|
+)
|
|
|
+class UnimerMBartForQuestionAnswering(UnimerMBartPreTrainedModel):
|
|
|
+ _tied_weights_keys = ["model.encoder.embed_tokens.weight", "model.decoder.embed_tokens.weight"]
|
|
|
+
|
|
|
+ def __init__(self, config):
|
|
|
+ super().__init__(config)
|
|
|
+
|
|
|
+ config.num_labels = 2
|
|
|
+ self.num_labels = config.num_labels
|
|
|
+
|
|
|
+ self.model = UnimerMBartModel(config)
|
|
|
+ self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
|
|
|
+
|
|
|
+ # Initialize weights and apply final processing
|
|
|
+ self.post_init()
|
|
|
+
|
|
|
+ @add_start_docstrings_to_model_forward(MBART_INPUTS_DOCSTRING)
|
|
|
+ @add_code_sample_docstrings(
|
|
|
+ checkpoint=_CHECKPOINT_FOR_DOC,
|
|
|
+ output_type=Seq2SeqQuestionAnsweringModelOutput,
|
|
|
+ config_class=_CONFIG_FOR_DOC,
|
|
|
+ )
|
|
|
+ # Copied from transformers.models.bart.modeling_bart.BartForQuestionAnswering.forward
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ input_ids: torch.Tensor = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ decoder_input_ids: Optional[torch.LongTensor] = None,
|
|
|
+ decoder_attention_mask: Optional[torch.LongTensor] = None,
|
|
|
+ head_mask: Optional[torch.Tensor] = None,
|
|
|
+ decoder_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ cross_attn_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ encoder_outputs: Optional[List[torch.FloatTensor]] = None,
|
|
|
+ start_positions: Optional[torch.LongTensor] = None,
|
|
|
+ end_positions: Optional[torch.LongTensor] = None,
|
|
|
+ inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ use_cache: Optional[bool] = None,
|
|
|
+ output_attentions: Optional[bool] = None,
|
|
|
+ output_hidden_states: Optional[bool] = None,
|
|
|
+ return_dict: Optional[bool] = None,
|
|
|
+ ) -> Union[Tuple, Seq2SeqQuestionAnsweringModelOutput]:
|
|
|
+ r"""
|
|
|
+ start_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
|
|
|
+ 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 (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
|
|
|
+ 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
|
|
|
+ if start_positions is not None and end_positions is not None:
|
|
|
+ use_cache = False
|
|
|
+
|
|
|
+ outputs = self.model(
|
|
|
+ input_ids,
|
|
|
+ attention_mask=attention_mask,
|
|
|
+ decoder_input_ids=decoder_input_ids,
|
|
|
+ decoder_attention_mask=decoder_attention_mask,
|
|
|
+ head_mask=head_mask,
|
|
|
+ decoder_head_mask=decoder_head_mask,
|
|
|
+ cross_attn_head_mask=cross_attn_head_mask,
|
|
|
+ encoder_outputs=encoder_outputs,
|
|
|
+ inputs_embeds=inputs_embeds,
|
|
|
+ decoder_inputs_embeds=decoder_inputs_embeds,
|
|
|
+ use_cache=use_cache,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ output_hidden_states=output_hidden_states,
|
|
|
+ return_dict=return_dict,
|
|
|
+ )
|
|
|
+
|
|
|
+ sequence_output = outputs[0]
|
|
|
+
|
|
|
+ logits = self.qa_outputs(sequence_output)
|
|
|
+ start_logits, end_logits = logits.split(1, dim=-1)
|
|
|
+ start_logits = start_logits.squeeze(-1).contiguous()
|
|
|
+ end_logits = end_logits.squeeze(-1).contiguous()
|
|
|
+
|
|
|
+ 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 = start_positions.clamp(0, ignored_index)
|
|
|
+ end_positions = 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,
|
|
|
+ ) + outputs[1:]
|
|
|
+ return ((total_loss,) + output) if total_loss is not None else output
|
|
|
+
|
|
|
+ return Seq2SeqQuestionAnsweringModelOutput(
|
|
|
+ loss=total_loss,
|
|
|
+ start_logits=start_logits,
|
|
|
+ end_logits=end_logits,
|
|
|
+ past_key_values=outputs.past_key_values,
|
|
|
+ decoder_hidden_states=outputs.decoder_hidden_states,
|
|
|
+ decoder_attentions=outputs.decoder_attentions,
|
|
|
+ cross_attentions=outputs.cross_attentions,
|
|
|
+ encoder_last_hidden_state=outputs.encoder_last_hidden_state,
|
|
|
+ encoder_hidden_states=outputs.encoder_hidden_states,
|
|
|
+ encoder_attentions=outputs.encoder_attentions,
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+# Copied from transformers.models.bart.modeling_bart.BartDecoderWrapper with Bart->MBart
|
|
|
+class UnimerMBartDecoderWrapper(UnimerMBartPreTrainedModel):
|
|
|
+ """
|
|
|
+ This wrapper class is a helper class to correctly load pretrained checkpoints when the causal language model is
|
|
|
+ used in combination with the [`EncoderDecoderModel`] framework.
|
|
|
+ """
|
|
|
+
|
|
|
+ def __init__(self, config):
|
|
|
+ super().__init__(config)
|
|
|
+ self.decoder = UnimerMBartDecoder(config)
|
|
|
+
|
|
|
+ def forward(self, *args, **kwargs):
|
|
|
+ return self.decoder(*args, **kwargs)
|
|
|
+
|
|
|
+
|
|
|
+# Copied from transformers.models.bart.modeling_bart.BartForCausalLM with Bart->MBart, facebook/bart-base->facebook/mbart-large-cc25
|
|
|
+class UnimerMBartForCausalLM(UnimerMBartPreTrainedModel, GenerationMixin):
|
|
|
+ _tied_weights_keys = ["lm_head.weight"]
|
|
|
+
|
|
|
+ def __init__(self, config):
|
|
|
+ config = copy.deepcopy(config)
|
|
|
+ config.is_decoder = True
|
|
|
+ config.is_encoder_decoder = False
|
|
|
+ super().__init__(config)
|
|
|
+ self.model = UnimerMBartDecoderWrapper(config)
|
|
|
+
|
|
|
+ self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
|
|
|
+
|
|
|
+ # Initialize weights and apply final processing
|
|
|
+ self.post_init()
|
|
|
+
|
|
|
+ def get_input_embeddings(self):
|
|
|
+ return self.model.decoder.embed_tokens
|
|
|
+
|
|
|
+ def set_input_embeddings(self, value):
|
|
|
+ self.model.decoder.embed_tokens = value
|
|
|
+
|
|
|
+ def get_output_embeddings(self):
|
|
|
+ return self.lm_head
|
|
|
+
|
|
|
+ def set_output_embeddings(self, new_embeddings):
|
|
|
+ self.lm_head = new_embeddings
|
|
|
+
|
|
|
+ def set_decoder(self, decoder):
|
|
|
+ self.model.decoder = decoder
|
|
|
+
|
|
|
+ def get_decoder(self):
|
|
|
+ return self.model.decoder
|
|
|
+
|
|
|
+ @replace_return_docstrings(output_type=CausalLMOutputWithCrossAttentionsAndCounting, config_class=_CONFIG_FOR_DOC)
|
|
|
+ def forward(
|
|
|
+ self,
|
|
|
+ input_ids: torch.LongTensor = None,
|
|
|
+ attention_mask: Optional[torch.Tensor] = None,
|
|
|
+ encoder_hidden_states: Optional[torch.FloatTensor] = None,
|
|
|
+ encoder_attention_mask: Optional[torch.FloatTensor] = None,
|
|
|
+ head_mask: Optional[torch.Tensor] = None,
|
|
|
+ cross_attn_head_mask: Optional[torch.Tensor] = None,
|
|
|
+ past_key_values: Optional[List[torch.FloatTensor]] = None,
|
|
|
+ inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
+ labels: Optional[torch.LongTensor] = None,
|
|
|
+ use_cache: Optional[bool] = None,
|
|
|
+ output_attentions: Optional[bool] = None,
|
|
|
+ output_hidden_states: Optional[bool] = None,
|
|
|
+ return_dict: Optional[bool] = None,
|
|
|
+ count_gt: Optional[torch.LongTensor] = None,
|
|
|
+ ) -> Union[Tuple, CausalLMOutputWithCrossAttentions]:
|
|
|
+ r"""
|
|
|
+ Args:
|
|
|
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
|
|
|
+ Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you
|
|
|
+ provide it.
|
|
|
+
|
|
|
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
|
|
|
+ [`PreTrainedTokenizer.__call__`] for details.
|
|
|
+
|
|
|
+ [What are input IDs?](../glossary#input-ids)
|
|
|
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
|
|
|
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 for tokens that are **not masked**,
|
|
|
+ - 0 for tokens that are **masked**.
|
|
|
+
|
|
|
+ [What are attention masks?](../glossary#attention-mask)
|
|
|
+ encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
|
|
|
+ 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 (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, *optional*):
|
|
|
+ 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]`:
|
|
|
+ head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
|
|
|
+ Mask to nullify selected heads of the attention modules. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 indicates the head is **not masked**,
|
|
|
+ - 0 indicates the head is **masked**.
|
|
|
+
|
|
|
+ cross_attn_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*):
|
|
|
+ Mask to nullify selected heads of the cross-attention modules. Mask values selected in `[0, 1]`:
|
|
|
+
|
|
|
+ - 1 indicates the head is **not masked**,
|
|
|
+ - 0 indicates the head is **masked**.
|
|
|
+
|
|
|
+ past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
|
|
|
+ Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of
|
|
|
+ shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of
|
|
|
+ shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`. The two additional
|
|
|
+ tensors are only required when the model is used as a decoder in a Sequence to Sequence model.
|
|
|
+
|
|
|
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and in the
|
|
|
+ cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
|
|
|
+
|
|
|
+ If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those
|
|
|
+ that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of
|
|
|
+ all `decoder_input_ids` of shape `(batch_size, sequence_length)`.
|
|
|
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
|
|
|
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
|
|
|
+ config.vocab_size]` or -100 (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]`.
|
|
|
+ use_cache (`bool`, *optional*):
|
|
|
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
|
|
|
+ (see `past_key_values`).
|
|
|
+
|
|
|
+ - 1 for tokens that are **not masked**,
|
|
|
+ - 0 for tokens that are **masked**.
|
|
|
+ output_attentions (`bool`, *optional*):
|
|
|
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
|
|
|
+ returned tensors for more detail.
|
|
|
+ output_hidden_states (`bool`, *optional*):
|
|
|
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
|
|
|
+ for more detail.
|
|
|
+ return_dict (`bool`, *optional*):
|
|
|
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
|
|
|
+
|
|
|
+ Returns:
|
|
|
+
|
|
|
+ Example:
|
|
|
+
|
|
|
+ ```python
|
|
|
+ >>> from transformers import AutoTokenizer, MBartForCausalLM
|
|
|
+
|
|
|
+ >>> tokenizer = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25")
|
|
|
+ >>> model = MBartForCausalLM.from_pretrained("facebook/mbart-large-cc25", add_cross_attention=False)
|
|
|
+ >>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
|
|
|
+ >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
|
|
|
+ >>> outputs = model(**inputs)
|
|
|
+
|
|
|
+ >>> logits = outputs.logits
|
|
|
+ >>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size]
|
|
|
+ >>> list(logits.shape) == expected_shape
|
|
|
+ True
|
|
|
+ ```"""
|
|
|
+
|
|
|
+ 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
|
|
|
+
|
|
|
+ count_pred = None
|
|
|
+
|
|
|
+ # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
|
|
|
+ outputs = self.model.decoder(
|
|
|
+ input_ids=input_ids,
|
|
|
+ attention_mask=attention_mask,
|
|
|
+ count_pred=count_pred,
|
|
|
+ encoder_hidden_states=encoder_hidden_states,
|
|
|
+ encoder_attention_mask=encoder_attention_mask,
|
|
|
+ head_mask=head_mask,
|
|
|
+ cross_attn_head_mask=cross_attn_head_mask,
|
|
|
+ past_key_values=past_key_values,
|
|
|
+ inputs_embeds=inputs_embeds,
|
|
|
+ use_cache=use_cache,
|
|
|
+ output_attentions=output_attentions,
|
|
|
+ output_hidden_states=output_hidden_states,
|
|
|
+ return_dict=return_dict,
|
|
|
+ )
|
|
|
+
|
|
|
+ logits = self.lm_head(outputs[0])
|
|
|
+
|
|
|
+ loss = None
|
|
|
+ if labels is not None:
|
|
|
+ labels = labels.to(logits.device)
|
|
|
+ loss_fct = CrossEntropyLoss()
|
|
|
+ loss = loss_fct(logits.view(-1, self.config.vocab_size), labels.view(-1))
|
|
|
+
|
|
|
+ if not return_dict:
|
|
|
+ output = (logits,) + outputs[1:]
|
|
|
+ return (loss,) + output if loss is not None else output
|
|
|
+
|
|
|
+ return CausalLMOutputWithCrossAttentionsAndCounting(
|
|
|
+ loss=loss,
|
|
|
+ logits=logits,
|
|
|
+ past_key_values=outputs.past_key_values,
|
|
|
+ hidden_states=outputs.hidden_states,
|
|
|
+ attentions=outputs.attentions,
|
|
|
+ cross_attentions=outputs.cross_attentions,
|
|
|
+ counting=count_pred,
|
|
|
+ )
|
|
|
+
|
|
|
+ def prepare_inputs_for_generation(
|
|
|
+ self, input_ids, past_key_values=None, attention_mask=None, use_cache=None, **kwargs
|
|
|
+ ):
|
|
|
+ # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
|
|
|
+ if attention_mask is None:
|
|
|
+ attention_mask = input_ids.new_ones(input_ids.shape)
|
|
|
+
|
|
|
+ if past_key_values:
|
|
|
+ past_length = past_key_values[0][0].shape[2]
|
|
|
+
|
|
|
+ # Some generation methods already pass only the last input ID
|
|
|
+ if input_ids.shape[1] > past_length:
|
|
|
+ remove_prefix_length = past_length
|
|
|
+ else:
|
|
|
+ # Default to old behavior: keep only final ID
|
|
|
+ remove_prefix_length = input_ids.shape[1] - 1
|
|
|
+
|
|
|
+ input_ids = input_ids[:, remove_prefix_length:]
|
|
|
+ # first step, decoder_cached_states are empty
|
|
|
+ return {
|
|
|
+ "input_ids": input_ids, # encoder_outputs is defined. input_ids not needed
|
|
|
+ "attention_mask": attention_mask,
|
|
|
+ "past_key_values": past_key_values,
|
|
|
+ "use_cache": use_cache,
|
|
|
+ }
|
|
|
+
|
|
|
+ @staticmethod
|
|
|
+ def _reorder_cache(past_key_values, beam_idx):
|
|
|
+ reordered_past = ()
|
|
|
+ for layer_past in past_key_values:
|
|
|
+ reordered_past += (
|
|
|
+ tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past),
|
|
|
+ )
|
|
|
+ return reordered_past
|
myhloli