|
from typing import List, Optional, Tuple, Union
|
|
from dataclasses import dataclass
|
|
import copy, os
|
|
import torch
|
|
import torch.nn as nn
|
|
from torch.nn import CrossEntropyLoss
|
|
from transformers import AutoConfig, AutoModelForSeq2SeqLM, \
|
|
T5Config, T5Model, T5ForConditionalGeneration
|
|
|
|
from transformers.models.t5.modeling_t5 import T5Stack
|
|
from transformers.modeling_outputs import CausalLMOutputWithPast, Seq2SeqLMOutput, BaseModelOutput, BaseModelOutputWithPastAndCrossAttentions
|
|
from transformers.utils import ModelOutput
|
|
from transformers import DonutSwinModel, DonutImageProcessor, DonutSwinConfig
|
|
from abc import ABC, abstractmethod
|
|
import re
|
|
|
|
from transformers import T5PreTrainedModel
|
|
from transformers.models.t5.modeling_t5 import T5Block, T5LayerNorm
|
|
|
|
|
|
@dataclass
|
|
class BaseModelOutputWithPastAndCrossAttentionsWithAttentionMask(ModelOutput):
|
|
"""
|
|
Base class for model's outputs that may also contain a past key/values (to speed up sequential decoding).
|
|
|
|
Args:
|
|
last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
|
|
Sequence of hidden-states at the output of the last layer of the model.
|
|
|
|
If `past_key_values` is used only the last hidden-state of the sequences of shape `(batch_size, 1,
|
|
hidden_size)` is output.
|
|
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 optionally if
|
|
`config.is_encoder_decoder=True` 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 optionally if
|
|
`config.is_encoder_decoder=True` in the cross-attention blocks) that can be used (see `past_key_values`
|
|
input) to speed up sequential decoding.
|
|
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` and `config.add_cross_attention=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 of the decoder's cross-attention layer, after the attention softmax, used to compute the
|
|
weighted average in the cross-attention heads.
|
|
"""
|
|
|
|
last_hidden_state: torch.FloatTensor = None
|
|
past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None
|
|
hidden_states: Optional[Tuple[torch.FloatTensor]] = None
|
|
attentions: Optional[Tuple[torch.FloatTensor]] = None
|
|
cross_attentions: Optional[Tuple[torch.FloatTensor]] = None
|
|
attention_mask: Optional[torch.LongTensor] = None
|
|
|
|
class LlavaT5Config(T5Config):
|
|
model_type = "llava_t5"
|
|
|
|
|
|
|
|
class LlavaT5Stack(T5PreTrainedModel):
|
|
config_class = LlavaT5Config
|
|
|
|
def __init__(self, config, embed_tokens=None):
|
|
super().__init__(config)
|
|
|
|
self.embed_tokens = embed_tokens
|
|
self.is_decoder = config.is_decoder
|
|
|
|
self.block = nn.ModuleList(
|
|
[T5Block(config, has_relative_attention_bias=bool(i == 0)) for i in range(config.num_layers)]
|
|
)
|
|
self.final_layer_norm = T5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
|
|
self.dropout = nn.Dropout(config.dropout_rate)
|
|
|
|
|
|
self.vision_tower = DonutSwinModel(config=config.vision_config)
|
|
self.mm_projector = nn.Linear(config.mm_hidden_size, config.hidden_size)
|
|
self.pad_token_id = 0
|
|
self.image_token_index = 32100
|
|
|
|
|
|
|
|
self.post_init()
|
|
|
|
self.model_parallel = False
|
|
self.device_map = None
|
|
self.gradient_checkpointing = False
|
|
|
|
def _merge_input_ids_with_image_features(self, image_features, inputs_embeds, input_ids, attention_mask):
|
|
num_images, num_image_patches, embed_dim = image_features.shape
|
|
batch_size, sequence_length = input_ids.shape
|
|
left_padding = not torch.sum(input_ids[:, -1] == torch.tensor(self.pad_token_id))
|
|
|
|
special_image_token_mask = input_ids == self.image_token_index
|
|
num_special_image_tokens = torch.sum(special_image_token_mask, dim=-1)
|
|
|
|
max_embed_dim = (num_special_image_tokens.max() * (num_image_patches - 1)) + sequence_length
|
|
batch_indices, non_image_indices = torch.where(input_ids != self.image_token_index)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
new_token_positions = torch.cumsum((special_image_token_mask * (num_image_patches - 1) + 1), -1) - 1
|
|
nb_image_pad = max_embed_dim - 1 - new_token_positions[:, -1]
|
|
if left_padding:
|
|
new_token_positions += nb_image_pad[:, None]
|
|
text_to_overwrite = new_token_positions[batch_indices, non_image_indices]
|
|
|
|
|
|
final_embedding = torch.zeros(
|
|
batch_size, max_embed_dim, embed_dim, dtype=inputs_embeds.dtype, device=inputs_embeds.device
|
|
)
|
|
final_attention_mask = torch.zeros(
|
|
batch_size, max_embed_dim, dtype=attention_mask.dtype, device=inputs_embeds.device
|
|
)
|
|
|
|
|
|
|
|
target_device = inputs_embeds.device
|
|
batch_indices, non_image_indices, text_to_overwrite = (
|
|
batch_indices.to(target_device),
|
|
non_image_indices.to(target_device),
|
|
text_to_overwrite.to(target_device),
|
|
)
|
|
attention_mask = attention_mask.to(target_device)
|
|
|
|
|
|
|
|
final_embedding[batch_indices, text_to_overwrite] = inputs_embeds[batch_indices, non_image_indices]
|
|
final_attention_mask[batch_indices, text_to_overwrite] = attention_mask[batch_indices, non_image_indices]
|
|
|
|
|
|
image_to_overwrite = torch.full(
|
|
(batch_size, max_embed_dim), True, dtype=torch.bool, device=inputs_embeds.device
|
|
)
|
|
image_to_overwrite[batch_indices, text_to_overwrite] = False
|
|
image_to_overwrite &= image_to_overwrite.cumsum(-1) - 1 >= nb_image_pad[:, None].to(target_device)
|
|
|
|
if image_to_overwrite.sum() != image_features.shape[:-1].numel():
|
|
raise ValueError(
|
|
f"The input provided to the model are wrong. The number of image tokens is {torch.sum(special_image_token_mask)} while"
|
|
f" the number of image given to the model is {num_images}. This prevents correct indexing and breaks batch generation."
|
|
)
|
|
|
|
final_embedding[image_to_overwrite] = image_features.contiguous().reshape(-1, embed_dim).to(target_device)
|
|
final_attention_mask |= image_to_overwrite
|
|
|
|
|
|
batch_indices, pad_indices = torch.where(input_ids == self.pad_token_id)
|
|
indices_to_mask = new_token_positions[batch_indices, pad_indices]
|
|
|
|
final_embedding[batch_indices, indices_to_mask] = 0
|
|
|
|
return final_embedding, final_attention_mask
|
|
|
|
def forward(
|
|
self,
|
|
input_ids=None,
|
|
attention_mask=None,
|
|
pixel_values=None,
|
|
encoder_hidden_states=None,
|
|
encoder_attention_mask=None,
|
|
inputs_embeds=None,
|
|
head_mask=None,
|
|
cross_attn_head_mask=None,
|
|
past_key_values=None,
|
|
use_cache=None,
|
|
output_attentions=None,
|
|
output_hidden_states=None,
|
|
return_dict=None,
|
|
):
|
|
|
|
if self.model_parallel:
|
|
torch.cuda.set_device(self.first_device)
|
|
self.embed_tokens = self.embed_tokens.to(self.first_device)
|
|
use_cache = use_cache if use_cache is not None else self.config.use_cache
|
|
output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
|
|
output_hidden_states = (
|
|
output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
|
|
)
|
|
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
|
|
|
|
if input_ids is not None and inputs_embeds is not None:
|
|
err_msg_prefix = "decoder_" if self.is_decoder else ""
|
|
raise ValueError(
|
|
f"You cannot specify both {err_msg_prefix}input_ids and {err_msg_prefix}inputs_embeds at the same time"
|
|
)
|
|
elif input_ids is not None:
|
|
input_shape = input_ids.size()
|
|
input_ids = input_ids.view(-1, input_shape[-1])
|
|
elif inputs_embeds is not None:
|
|
input_shape = inputs_embeds.size()[:-1]
|
|
else:
|
|
err_msg_prefix = "decoder_" if self.is_decoder else ""
|
|
raise ValueError(f"You have to specify either {err_msg_prefix}input_ids or {err_msg_prefix}inputs_embeds")
|
|
|
|
if inputs_embeds is None:
|
|
if self.embed_tokens is None:
|
|
raise ValueError("You have to initialize the model with valid token embeddings")
|
|
inputs_embeds = self.embed_tokens(input_ids)
|
|
|
|
|
|
vision_feature_layer = -1
|
|
vision_feature_select_strategy = "default"
|
|
image_outputs = self.vision_tower(pixel_values, output_hidden_states=True)
|
|
|
|
selected_image_feature = image_outputs.hidden_states[vision_feature_layer]
|
|
|
|
if vision_feature_select_strategy == "default":
|
|
selected_image_feature = selected_image_feature[:, 1:]
|
|
elif vision_feature_select_strategy == "full":
|
|
selected_image_feature = selected_image_feature
|
|
else:
|
|
raise ValueError(
|
|
f"Unexpected select feature strategy: {self.config.vision_feature_select_strategy}"
|
|
)
|
|
|
|
image_features = self.mm_projector(selected_image_feature)
|
|
inputs_embeds = inputs_embeds.to(image_features.dtype)
|
|
inputs_embeds, attention_mask = self._merge_input_ids_with_image_features(
|
|
image_features, inputs_embeds, input_ids, attention_mask
|
|
)
|
|
input_shape = inputs_embeds.size()[:-1]
|
|
|
|
|
|
batch_size, seq_length = input_shape
|
|
|
|
|
|
mask_seq_length = past_key_values[0][0].shape[2] + seq_length if past_key_values is not None else seq_length
|
|
|
|
if use_cache is True:
|
|
if not self.is_decoder:
|
|
raise ValueError(f"`use_cache` can only be set to `True` if {self} is used as a decoder")
|
|
|
|
|
|
if past_key_values is None:
|
|
past_key_values = [None] * len(self.block)
|
|
|
|
if attention_mask is None:
|
|
attention_mask = torch.ones(batch_size, mask_seq_length, device=inputs_embeds.device)
|
|
|
|
|
|
|
|
extended_attention_mask = self.get_extended_attention_mask(attention_mask, input_shape)
|
|
|
|
|
|
|
|
if self.is_decoder and encoder_hidden_states is not None:
|
|
encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
|
|
encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
|
|
if encoder_attention_mask is None:
|
|
encoder_attention_mask = torch.ones(
|
|
encoder_hidden_shape, device=inputs_embeds.device, dtype=torch.long
|
|
)
|
|
encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
|
|
else:
|
|
encoder_extended_attention_mask = None
|
|
|
|
if self.gradient_checkpointing and self.training:
|
|
if use_cache:
|
|
|
|
|
|
|
|
use_cache = False
|
|
|
|
|
|
head_mask = self.get_head_mask(head_mask, self.config.num_layers)
|
|
cross_attn_head_mask = self.get_head_mask(cross_attn_head_mask, self.config.num_layers)
|
|
present_key_value_states = () if use_cache else None
|
|
all_hidden_states = () if output_hidden_states else None
|
|
all_attentions = () if output_attentions else None
|
|
all_cross_attentions = () if (output_attentions and self.is_decoder) else None
|
|
position_bias = None
|
|
encoder_decoder_position_bias = None
|
|
|
|
hidden_states = self.dropout(inputs_embeds)
|
|
|
|
for i, (layer_module, past_key_value) in enumerate(zip(self.block, past_key_values)):
|
|
layer_head_mask = head_mask[i]
|
|
cross_attn_layer_head_mask = cross_attn_head_mask[i]
|
|
|
|
if self.model_parallel:
|
|
torch.cuda.set_device(hidden_states.device)
|
|
|
|
if attention_mask is not None:
|
|
attention_mask = attention_mask.to(hidden_states.device)
|
|
if position_bias is not None:
|
|
position_bias = position_bias.to(hidden_states.device)
|
|
if encoder_hidden_states is not None:
|
|
encoder_hidden_states = encoder_hidden_states.to(hidden_states.device)
|
|
if encoder_extended_attention_mask is not None:
|
|
encoder_extended_attention_mask = encoder_extended_attention_mask.to(hidden_states.device)
|
|
if encoder_decoder_position_bias is not None:
|
|
encoder_decoder_position_bias = encoder_decoder_position_bias.to(hidden_states.device)
|
|
if layer_head_mask is not None:
|
|
layer_head_mask = layer_head_mask.to(hidden_states.device)
|
|
if cross_attn_layer_head_mask is not None:
|
|
cross_attn_layer_head_mask = cross_attn_layer_head_mask.to(hidden_states.device)
|
|
if output_hidden_states:
|
|
all_hidden_states = all_hidden_states + (hidden_states,)
|
|
|
|
if self.gradient_checkpointing and self.training:
|
|
layer_outputs = self._gradient_checkpointing_func(
|
|
layer_module.forward,
|
|
hidden_states,
|
|
extended_attention_mask,
|
|
position_bias,
|
|
encoder_hidden_states,
|
|
encoder_extended_attention_mask,
|
|
encoder_decoder_position_bias,
|
|
layer_head_mask,
|
|
cross_attn_layer_head_mask,
|
|
None,
|
|
use_cache,
|
|
output_attentions,
|
|
)
|
|
else:
|
|
layer_outputs = layer_module(
|
|
hidden_states,
|
|
attention_mask=extended_attention_mask,
|
|
position_bias=position_bias,
|
|
encoder_hidden_states=encoder_hidden_states,
|
|
encoder_attention_mask=encoder_extended_attention_mask,
|
|
encoder_decoder_position_bias=encoder_decoder_position_bias,
|
|
layer_head_mask=layer_head_mask,
|
|
cross_attn_layer_head_mask=cross_attn_layer_head_mask,
|
|
past_key_value=past_key_value,
|
|
use_cache=use_cache,
|
|
output_attentions=output_attentions,
|
|
)
|
|
|
|
|
|
|
|
if use_cache is False:
|
|
layer_outputs = layer_outputs[:1] + (None,) + layer_outputs[1:]
|
|
|
|
hidden_states, present_key_value_state = layer_outputs[:2]
|
|
|
|
|
|
|
|
|
|
position_bias = layer_outputs[2]
|
|
if self.is_decoder and encoder_hidden_states is not None:
|
|
encoder_decoder_position_bias = layer_outputs[4 if output_attentions else 3]
|
|
|
|
if use_cache:
|
|
present_key_value_states = present_key_value_states + (present_key_value_state,)
|
|
|
|
if output_attentions:
|
|
all_attentions = all_attentions + (layer_outputs[3],)
|
|
if self.is_decoder:
|
|
all_cross_attentions = all_cross_attentions + (layer_outputs[5],)
|
|
|
|
|
|
if self.model_parallel:
|
|
for k, v in self.device_map.items():
|
|
if i == v[-1] and "cuda:" + str(k) != self.last_device:
|
|
hidden_states = hidden_states.to("cuda:" + str(k + 1))
|
|
|
|
hidden_states = self.final_layer_norm(hidden_states)
|
|
hidden_states = self.dropout(hidden_states)
|
|
|
|
|
|
if output_hidden_states:
|
|
all_hidden_states = all_hidden_states + (hidden_states,)
|
|
|
|
if not return_dict:
|
|
return tuple(
|
|
v
|
|
for v in [
|
|
hidden_states,
|
|
present_key_value_states,
|
|
all_hidden_states,
|
|
all_attentions,
|
|
all_cross_attentions,
|
|
]
|
|
if v is not None
|
|
)
|
|
return BaseModelOutputWithPastAndCrossAttentionsWithAttentionMask(
|
|
last_hidden_state=hidden_states,
|
|
past_key_values=present_key_value_states,
|
|
hidden_states=all_hidden_states,
|
|
attentions=all_attentions,
|
|
cross_attentions=all_cross_attentions,
|
|
attention_mask=attention_mask,
|
|
)
|
|
|
|
|
|
class LlavaT5ForConditionalGeneration(T5ForConditionalGeneration):
|
|
config_class = LlavaT5Config
|
|
|
|
def __init__(self, config):
|
|
super(T5ForConditionalGeneration, self).__init__(config)
|
|
|
|
self.model_dim = config.d_model
|
|
|
|
self.shared = nn.Embedding(config.vocab_size, config.d_model)
|
|
|
|
encoder_config = copy.deepcopy(config)
|
|
encoder_config.is_decoder = False
|
|
encoder_config.use_cache = False
|
|
encoder_config.is_encoder_decoder = False
|
|
self.encoder = LlavaT5Stack(encoder_config, self.shared)
|
|
|
|
decoder_config = copy.deepcopy(config)
|
|
decoder_config.is_decoder = True
|
|
decoder_config.is_encoder_decoder = False
|
|
decoder_config.num_layers = config.num_decoder_layers
|
|
self.decoder = T5Stack(decoder_config, self.shared)
|
|
|
|
self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
|
|
|
|
|
|
self.post_init()
|
|
|
|
|
|
self.model_parallel = False
|
|
self.device_map = None
|
|
|
|
def get_model(self):
|
|
return self.encoder
|
|
def get_encoder(self):
|
|
return self.encoder
|
|
def get_decoder(self):
|
|
return self.decoder
|
|
|
|
def forward(
|
|
self,
|
|
input_ids: torch.LongTensor = None,
|
|
attention_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,
|
|
pixel_values: Optional[torch.FloatTensor] = None,
|
|
return_dict: Optional[bool] = None,
|
|
|
|
decoder_input_ids: Optional[torch.LongTensor] = None,
|
|
decoder_attention_mask: Optional[torch.BoolTensor] = None,
|
|
head_mask: Optional[torch.FloatTensor] = None,
|
|
decoder_head_mask: Optional[torch.FloatTensor] = None,
|
|
cross_attn_head_mask: Optional[torch.Tensor] = None,
|
|
encoder_outputs: Optional[Tuple[Tuple[torch.Tensor]]] = None,
|
|
decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
|
|
|
|
) -> Union[Tuple, Seq2SeqLMOutput]:
|
|
|
|
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
|
|
|
|
|
|
|
|
if head_mask is not None and decoder_head_mask is None:
|
|
if self.config.num_layers == self.config.num_decoder_layers:
|
|
|
|
decoder_head_mask = head_mask
|
|
|
|
if encoder_outputs is not None:
|
|
attention_mask = encoder_outputs.attention_mask
|
|
|
|
|
|
if encoder_outputs is None:
|
|
|
|
encoder_outputs = self.encoder(
|
|
input_ids=input_ids,
|
|
attention_mask=attention_mask,
|
|
pixel_values=pixel_values,
|
|
inputs_embeds=inputs_embeds,
|
|
head_mask=head_mask,
|
|
output_attentions=output_attentions,
|
|
output_hidden_states=output_hidden_states,
|
|
return_dict=return_dict,
|
|
)
|
|
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,
|
|
)
|
|
|
|
|
|
hidden_states = encoder_outputs[0]
|
|
|
|
if self.model_parallel:
|
|
torch.cuda.set_device(self.decoder.first_device)
|
|
|
|
if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
|
|
|
|
decoder_input_ids = self._shift_right(labels)
|
|
|
|
|
|
if self.model_parallel:
|
|
torch.cuda.set_device(self.decoder.first_device)
|
|
hidden_states = hidden_states.to(self.decoder.first_device)
|
|
if decoder_input_ids is not None:
|
|
decoder_input_ids = decoder_input_ids.to(self.decoder.first_device)
|
|
if attention_mask is not None:
|
|
attention_mask = attention_mask.to(self.decoder.first_device)
|
|
if decoder_attention_mask is not None:
|
|
decoder_attention_mask = decoder_attention_mask.to(self.decoder.first_device)
|
|
|
|
|
|
decoder_outputs = self.decoder(
|
|
input_ids=decoder_input_ids,
|
|
attention_mask=decoder_attention_mask,
|
|
inputs_embeds=decoder_inputs_embeds,
|
|
past_key_values=past_key_values,
|
|
encoder_hidden_states=hidden_states,
|
|
encoder_attention_mask=attention_mask,
|
|
head_mask=decoder_head_mask,
|
|
cross_attn_head_mask=cross_attn_head_mask,
|
|
use_cache=use_cache,
|
|
output_attentions=output_attentions,
|
|
output_hidden_states=output_hidden_states,
|
|
return_dict=return_dict,
|
|
)
|
|
sequence_output = decoder_outputs[0]
|
|
|
|
|
|
if self.model_parallel:
|
|
torch.cuda.set_device(self.encoder.first_device)
|
|
self.lm_head = self.lm_head.to(self.encoder.first_device)
|
|
sequence_output = sequence_output.to(self.lm_head.weight.device)
|
|
|
|
if self.config.tie_word_embeddings:
|
|
|
|
|
|
sequence_output = sequence_output * (self.model_dim**-0.5)
|
|
|
|
lm_logits = self.lm_head(sequence_output)
|
|
|
|
loss = None
|
|
if labels is not None:
|
|
loss_fct = CrossEntropyLoss(ignore_index=-100)
|
|
|
|
labels = labels.to(lm_logits.device)
|
|
loss = loss_fct(lm_logits.view(-1, lm_logits.size(-1)), labels.view(-1))
|
|
|
|
|
|
if not return_dict:
|
|
output = (lm_logits,) + decoder_outputs[1:] + encoder_outputs
|
|
return ((loss,) + output) if loss is not None else output
|
|
|
|
return Seq2SeqLMOutput(
|
|
loss=loss,
|
|
logits=lm_logits,
|
|
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,
|
|
)
|
|
|
|
def prepare_inputs_for_generation(
|
|
self,
|
|
input_ids,
|
|
past_key_values=None,
|
|
attention_mask=None,
|
|
head_mask=None,
|
|
decoder_head_mask=None,
|
|
decoder_attention_mask=None,
|
|
cross_attn_head_mask=None,
|
|
use_cache=None,
|
|
encoder_outputs=None,
|
|
**kwargs,
|
|
):
|
|
|
|
if past_key_values is not None:
|
|
past_length = past_key_values[0][0].shape[2]
|
|
|
|
|
|
if input_ids.shape[1] > past_length:
|
|
remove_prefix_length = past_length
|
|
else:
|
|
|
|
remove_prefix_length = input_ids.shape[1] - 1
|
|
|
|
input_ids = input_ids[:, remove_prefix_length:]
|
|
|
|
return {
|
|
"decoder_input_ids": input_ids,
|
|
"past_key_values": past_key_values,
|
|
"encoder_outputs": encoder_outputs,
|
|
"attention_mask": attention_mask,
|
|
"head_mask": head_mask,
|
|
"decoder_head_mask": decoder_head_mask,
|
|
"decoder_attention_mask": decoder_attention_mask,
|
|
"cross_attn_head_mask": cross_attn_head_mask,
|
|
"use_cache": use_cache,
|
|
"pixel_values": kwargs.get("pixel_values", None),
|
|
}
|
|
|