2237 lines
104 KiB
Python
2237 lines
104 KiB
Python
|
# coding=utf-8
|
||
|
|
# Copyright 2022 Google LLC., LongT5 Authors and HuggingFace Inc. team.
|
||
|
|
#
|
||
|
|
# 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 LongT5 model."""
|
||
|
|
|
||
|
|
|
||
|
|
import copy
|
||
|
|
import math
|
||
|
|
import warnings
|
||
|
|
from typing import Any, List, Optional, Tuple, Union
|
||
|
|
|
||
|
|
import torch
|
||
|
|
from torch import nn
|
||
|
|
from torch.nn import CrossEntropyLoss
|
||
|
|
|
||
|
|
from ...activations import ACT2FN
|
||
|
|
from ...modeling_outputs import (
|
||
|
|
BaseModelOutput,
|
||
|
|
BaseModelOutputWithPastAndCrossAttentions,
|
||
|
|
Seq2SeqLMOutput,
|
||
|
|
Seq2SeqModelOutput,
|
||
|
|
)
|
||
|
|
from ...modeling_utils import PreTrainedModel
|
||
|
|
from ...pytorch_utils import ALL_LAYERNORM_LAYERS, find_pruneable_heads_and_indices, prune_linear_layer
|
||
|
|
from ...utils import (
|
||
|
|
DUMMY_INPUTS,
|
||
|
|
DUMMY_MASK,
|
||
|
|
add_start_docstrings,
|
||
|
|
add_start_docstrings_to_model_forward,
|
||
|
|
is_torch_fx_proxy,
|
||
|
|
logging,
|
||
|
|
replace_return_docstrings,
|
||
|
|
)
|
||
|
|
from .configuration_longt5 import LongT5Config
|
||
|
|
|
||
|
|
|
||
|
|
logger = logging.get_logger(__name__)
|
||
|
|
|
||
|
|
_CONFIG_FOR_DOC = "LongT5Config"
|
||
|
|
_CHECKPOINT_FOR_DOC = "google/long-t5-local-base"
|
||
|
|
|
||
|
|
# TODO: Update before the merge
|
||
|
|
|
||
|
|
from ..deprecated._archive_maps import LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST # noqa: F401, E402
|
||
|
|
|
||
|
|
|
||
|
|
def _pad_to_multiple(x: torch.Tensor, block_len: int, dim: int, pad_value: int = 0) -> torch.Tensor:
|
||
|
|
"""Pad a tensor so that a sequence length will be a multiple of `block_len`"""
|
||
|
|
pad_len = -x.shape[dim] % block_len
|
||
|
|
# Handle cases when an empty input sequence is given
|
||
|
|
if not all(x.shape):
|
||
|
|
new_shape = list(x.shape)
|
||
|
|
new_shape[dim] += pad_len
|
||
|
|
return torch.zeros(new_shape, dtype=x.dtype)
|
||
|
|
|
||
|
|
pad = [(0, 0)] * x.ndim
|
||
|
|
pad[dim] = (0, pad_len)
|
||
|
|
pad = sum(pad[::-1], ())
|
||
|
|
x = nn.functional.pad(x, pad=pad, mode="constant", value=pad_value)
|
||
|
|
return x
|
||
|
|
|
||
|
|
|
||
|
|
def _split_into_blocks(x: torch.Tensor, block_len: int, dim: int) -> torch.Tensor:
|
||
|
|
"""Split an input tensor into blocks of a given `block_len` along the given `dim`. If the dimension length
|
||
|
|
is not a multiple of `block_len`, it will be padded first with selected `pad_value`.
|
||
|
|
"""
|
||
|
|
# pad tensor to multiple of block_len
|
||
|
|
if x.shape[dim] % block_len != 0:
|
||
|
|
x = _pad_to_multiple(x, block_len, dim, pad_value=0)
|
||
|
|
num_blocks = x.shape[dim] // block_len
|
||
|
|
output_shape = x.shape[:dim] + (num_blocks, block_len) + x.shape[(dim + 1) :]
|
||
|
|
# If 0 is in output_shape, we cannot apply reshape because of incompatibility with ONNX conversion
|
||
|
|
if 0 in output_shape:
|
||
|
|
return torch.empty(output_shape, dtype=x.dtype, device=x.device)
|
||
|
|
return x.reshape(output_shape)
|
||
|
|
|
||
|
|
|
||
|
|
def _concatenate_3_blocks(x: torch.Tensor, block_dim: int, sequence_dim: int, pad_value: int = 0) -> torch.Tensor:
|
||
|
|
"""Concatenate three consecutive blocks for each input block for local attentiont.
|
||
|
|
|
||
|
|
For more information, see: https://arxiv.org/pdf/2112.07916.pdf.
|
||
|
|
"""
|
||
|
|
num_blocks = x.shape[block_dim]
|
||
|
|
|
||
|
|
pad = [(0, 0)] * x.ndim
|
||
|
|
pad[block_dim] = (1, 1)
|
||
|
|
pad = sum(pad[::-1], ())
|
||
|
|
# [batch_size, num_blocks, block_len] -> [batch_size, num_blocks + 2, block_len]
|
||
|
|
x = nn.functional.pad(x, pad=pad, mode="constant", value=pad_value)
|
||
|
|
|
||
|
|
blocks_list: List[torch.Tensor] = []
|
||
|
|
for i in range(3):
|
||
|
|
# We use indexing approach here:
|
||
|
|
# https://numpy.org/doc/stable/user/basics.indexing.html#dealing-with-variable-numbers-of-indices-within-programs
|
||
|
|
indices = [slice(0, None)] * x.ndim
|
||
|
|
indices[block_dim] = slice(i, i + num_blocks)
|
||
|
|
indices = tuple(indices)
|
||
|
|
blocks_list.append(x[indices])
|
||
|
|
# [batch_size, num_blocks, 3 * block_len, ...]
|
||
|
|
return torch.cat(blocks_list, dim=sequence_dim)
|
||
|
|
|
||
|
|
|
||
|
|
def _make_3block_relative_position_ids(block_len: int) -> torch.Tensor:
|
||
|
|
"""Makes 3-blocked relative position ids for local attention."""
|
||
|
|
position_ids = torch.arange(3 * block_len, dtype=torch.int32)
|
||
|
|
center_position_ids = position_ids[block_len:-block_len]
|
||
|
|
# [block_len, 3 * block_len]
|
||
|
|
relative_position_ids = position_ids.unsqueeze(0) - center_position_ids.unsqueeze(1)
|
||
|
|
return relative_position_ids
|
||
|
|
|
||
|
|
|
||
|
|
def _mask_local_attention_mask(local_attention_mask: torch.Tensor, block_len: int) -> torch.Tensor:
|
||
|
|
"""Mask local attention mask to enforce that tokens are not allowed to attend tokens farther than ``local_radius."""
|
||
|
|
relative_position_ids = _make_3block_relative_position_ids(block_len)
|
||
|
|
locality_mask = torch.abs(relative_position_ids) < block_len
|
||
|
|
locality_mask = locality_mask[None, None, :, :]
|
||
|
|
locality_mask = locality_mask.to(local_attention_mask.device)
|
||
|
|
return torch.logical_and(local_attention_mask, locality_mask)
|
||
|
|
|
||
|
|
|
||
|
|
def _get_local_attention_mask(attention_mask: torch.Tensor, block_len: int, device: torch.device) -> torch.Tensor:
|
||
|
|
"""Prepare attention mask to be applied for a local attention."""
|
||
|
|
# [batch_size, num_blocks, block_len]
|
||
|
|
_blocked_attention_mask = _split_into_blocks(attention_mask, block_len, dim=1)
|
||
|
|
# [batch_size, num_block, 3 * block_len]
|
||
|
|
_3blocked_attention_mask = _concatenate_3_blocks(_blocked_attention_mask, block_dim=1, sequence_dim=2)
|
||
|
|
|
||
|
|
_blocked_attention_mask = _blocked_attention_mask.unsqueeze(-1)
|
||
|
|
_3blocked_attention_mask = _3blocked_attention_mask.unsqueeze(-2)
|
||
|
|
# [batch_size, num_block, block_len, 3 * block_len]
|
||
|
|
local_attention_mask = torch.logical_and(_blocked_attention_mask, _3blocked_attention_mask)
|
||
|
|
local_attention_mask = _mask_local_attention_mask(local_attention_mask, block_len)
|
||
|
|
# [batch_size, 1, num_block, block_len, 3 * block_len]
|
||
|
|
return local_attention_mask.unsqueeze(1).to(device)
|
||
|
|
|
||
|
|
|
||
|
|
def _make_global_fixed_block_ids(
|
||
|
|
attention_mask: torch.Tensor, global_block_size: int
|
||
|
|
) -> Tuple[torch.Tensor, torch.Tensor]:
|
||
|
|
"""Obtain the "fixed block" global id corresponding to each input token.
|
||
|
|
|
||
|
|
This implementation is a simlified version of the original Flaxformr implementation adopted from:
|
||
|
|
https://github.com/google/flaxformer/blob/main/flaxformer/architectures/longt5/long_attention.py.
|
||
|
|
|
||
|
|
In our scenario, as we use this strategy only for a decoder, orphan tokens, i.e. those tokens which do not make for
|
||
|
|
the whole fixed block, are assigned to the preceding block.
|
||
|
|
|
||
|
|
Padding tokens from the original sequence are represented by -1.
|
||
|
|
"""
|
||
|
|
batch_size, seq_len = attention_mask.shape[:2]
|
||
|
|
|
||
|
|
def handle_orphan_tokens(block_ids: torch.Tensor) -> torch.Tensor:
|
||
|
|
block_ends = (torch.arange(seq_len) % global_block_size) == global_block_size - 1
|
||
|
|
block_ends = block_ends.to(block_ids.device)
|
||
|
|
true_block_ends = torch.logical_and(block_ends, block_ids >= 0)
|
||
|
|
full_blocks = true_block_ends.sum(-1).unsqueeze(-1).type(block_ids.dtype) - 1
|
||
|
|
block_ids = torch.where(block_ids < full_blocks, block_ids, full_blocks)
|
||
|
|
return block_ids
|
||
|
|
|
||
|
|
fixed_block_mask = torch.ones_like(attention_mask, device=attention_mask.device) / global_block_size
|
||
|
|
fixed_block_mask = torch.cumsum(fixed_block_mask, axis=1) - fixed_block_mask
|
||
|
|
mask = torch.where(attention_mask != 0.0, 1.0, -1000.0).type(attention_mask.dtype)
|
||
|
|
global_block_ids = torch.floor(mask + fixed_block_mask - 1.0).type(attention_mask.dtype)
|
||
|
|
_global_block_ids_lower_bound = torch.tensor(-1, dtype=global_block_ids.dtype, device=global_block_ids.device)
|
||
|
|
global_block_ids = torch.where(
|
||
|
|
global_block_ids > _global_block_ids_lower_bound, global_block_ids, _global_block_ids_lower_bound
|
||
|
|
)
|
||
|
|
# set padding tokens to -1
|
||
|
|
global_block_ids = (global_block_ids * attention_mask) + (attention_mask - 1)
|
||
|
|
# [batch_size, seq_len]
|
||
|
|
global_block_ids = handle_orphan_tokens(global_block_ids)
|
||
|
|
num_globals = seq_len // global_block_size
|
||
|
|
# [batch_size, seq_len // global_block_size]
|
||
|
|
if num_globals > 0:
|
||
|
|
_sequence_block_ids_max = torch.max(global_block_ids, dim=-1).values.repeat(num_globals, 1).transpose(0, 1)
|
||
|
|
else:
|
||
|
|
_sequence_block_ids_max = torch.zeros(
|
||
|
|
batch_size, 0, dtype=global_block_ids.dtype, device=global_block_ids.device
|
||
|
|
)
|
||
|
|
global_segment_ids = torch.cumsum(torch.ones(batch_size, num_globals), dim=-1) - 1
|
||
|
|
global_segment_ids = global_segment_ids.to(attention_mask.device)
|
||
|
|
global_segment_ids = torch.where(global_segment_ids <= _sequence_block_ids_max, 1, 0)
|
||
|
|
return global_block_ids.type(torch.int), global_segment_ids.type(torch.int)
|
||
|
|
|
||
|
|
|
||
|
|
def _make_side_relative_position_ids(attention_mask: torch.Tensor, global_block_size: int) -> torch.Tensor:
|
||
|
|
"""Create the relative position tensor for local -> global attention."""
|
||
|
|
block_ids, global_segment_ids = _make_global_fixed_block_ids(attention_mask, global_block_size)
|
||
|
|
global_seq_len = global_segment_ids.shape[-1]
|
||
|
|
global_positions = torch.arange(global_seq_len, device=block_ids.device)
|
||
|
|
side_relative_position = global_positions - block_ids[..., None]
|
||
|
|
return side_relative_position.type(torch.int64)
|
||
|
|
|
||
|
|
|
||
|
|
def _create_global_aggregates(
|
||
|
|
hidden_states: torch.Tensor, block_ids: torch.Tensor, global_seq_len: int
|
||
|
|
) -> torch.Tensor:
|
||
|
|
"""Compute individual block aggregates by summing over individual blocks."""
|
||
|
|
# (batch..., seq_len, global_seq_len))
|
||
|
|
block_ids = block_ids.where(
|
||
|
|
block_ids >= 0, torch.tensor(global_seq_len, dtype=block_ids.dtype, device=block_ids.device)
|
||
|
|
)
|
||
|
|
one_hot_block_ids = nn.functional.one_hot(block_ids.type(torch.int64), global_seq_len + 1)[:, :, :-1]
|
||
|
|
return torch.einsum("...nd,...ng->...gd", hidden_states, one_hot_block_ids.type(hidden_states.dtype))
|
||
|
|
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5LayerNorm with T5->LongT5
|
||
|
|
class LongT5LayerNorm(nn.Module):
|
||
|
|
def __init__(self, hidden_size, eps=1e-6):
|
||
|
|
"""
|
||
|
|
Construct a layernorm module in the LongT5 style. No bias and no subtraction of mean.
|
||
|
|
"""
|
||
|
|
super().__init__()
|
||
|
|
self.weight = nn.Parameter(torch.ones(hidden_size))
|
||
|
|
self.variance_epsilon = eps
|
||
|
|
|
||
|
|
def forward(self, hidden_states):
|
||
|
|
# LongT5 uses a layer_norm which only scales and doesn't shift, which is also known as Root Mean
|
||
|
|
# Square Layer Normalization https://arxiv.org/abs/1910.07467 thus varience is calculated
|
||
|
|
# w/o mean and there is no bias. Additionally we want to make sure that the accumulation for
|
||
|
|
# half-precision inputs is done in fp32
|
||
|
|
|
||
|
|
variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
|
||
|
|
hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
|
||
|
|
|
||
|
|
# convert into half-precision if necessary
|
||
|
|
if self.weight.dtype in [torch.float16, torch.bfloat16]:
|
||
|
|
hidden_states = hidden_states.to(self.weight.dtype)
|
||
|
|
|
||
|
|
return self.weight * hidden_states
|
||
|
|
|
||
|
|
|
||
|
|
try:
|
||
|
|
from apex.normalization import FusedRMSNorm
|
||
|
|
|
||
|
|
LongT5LayerNorm = FusedRMSNorm # noqa
|
||
|
|
|
||
|
|
logger.info("Discovered apex.normalization.FusedRMSNorm - will use it instead of LongT5LayerNorm")
|
||
|
|
except ImportError:
|
||
|
|
# using the normal LongT5LayerNorm
|
||
|
|
pass
|
||
|
|
except Exception:
|
||
|
|
logger.warning("discovered apex but it failed to load, falling back to LongT5LayerNorm")
|
||
|
|
pass
|
||
|
|
|
||
|
|
ALL_LAYERNORM_LAYERS.append(LongT5LayerNorm)
|
||
|
|
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5DenseActDense with T5->LongT5
|
||
|
|
class LongT5DenseActDense(nn.Module):
|
||
|
|
def __init__(self, config: LongT5Config):
|
||
|
|
super().__init__()
|
||
|
|
self.wi = nn.Linear(config.d_model, config.d_ff, bias=False)
|
||
|
|
self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
|
||
|
|
self.dropout = nn.Dropout(config.dropout_rate)
|
||
|
|
self.act = ACT2FN[config.dense_act_fn]
|
||
|
|
|
||
|
|
def forward(self, hidden_states):
|
||
|
|
hidden_states = self.wi(hidden_states)
|
||
|
|
hidden_states = self.act(hidden_states)
|
||
|
|
hidden_states = self.dropout(hidden_states)
|
||
|
|
if (
|
||
|
|
isinstance(self.wo.weight, torch.Tensor)
|
||
|
|
and hidden_states.dtype != self.wo.weight.dtype
|
||
|
|
and self.wo.weight.dtype != torch.int8
|
||
|
|
):
|
||
|
|
hidden_states = hidden_states.to(self.wo.weight.dtype)
|
||
|
|
hidden_states = self.wo(hidden_states)
|
||
|
|
return hidden_states
|
||
|
|
|
||
|
|
|
||
|
|
class LongT5DenseGatedActDense(nn.Module):
|
||
|
|
def __init__(self, config: LongT5Config):
|
||
|
|
super().__init__()
|
||
|
|
self.wi_0 = nn.Linear(config.d_model, config.d_ff, bias=False)
|
||
|
|
self.wi_1 = nn.Linear(config.d_model, config.d_ff, bias=False)
|
||
|
|
self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
|
||
|
|
self.dropout = nn.Dropout(config.dropout_rate)
|
||
|
|
self.act = ACT2FN[config.dense_act_fn]
|
||
|
|
|
||
|
|
def forward(self, hidden_states):
|
||
|
|
hidden_gelu = self.act(self.wi_0(hidden_states))
|
||
|
|
hidden_linear = self.wi_1(hidden_states)
|
||
|
|
hidden_states = hidden_gelu * hidden_linear
|
||
|
|
hidden_states = self.dropout(hidden_states)
|
||
|
|
hidden_states = self.wo(hidden_states)
|
||
|
|
return hidden_states
|
||
|
|
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5LayerFF with T5->LongT5
|
||
|
|
class LongT5LayerFF(nn.Module):
|
||
|
|
def __init__(self, config: LongT5Config):
|
||
|
|
super().__init__()
|
||
|
|
if config.is_gated_act:
|
||
|
|
self.DenseReluDense = LongT5DenseGatedActDense(config)
|
||
|
|
else:
|
||
|
|
self.DenseReluDense = LongT5DenseActDense(config)
|
||
|
|
|
||
|
|
self.layer_norm = LongT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
|
||
|
|
self.dropout = nn.Dropout(config.dropout_rate)
|
||
|
|
|
||
|
|
def forward(self, hidden_states):
|
||
|
|
forwarded_states = self.layer_norm(hidden_states)
|
||
|
|
forwarded_states = self.DenseReluDense(forwarded_states)
|
||
|
|
hidden_states = hidden_states + self.dropout(forwarded_states)
|
||
|
|
return hidden_states
|
||
|
|
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5Attention with T5->LongT5
|
||
|
|
class LongT5Attention(nn.Module):
|
||
|
|
def __init__(self, config: LongT5Config, has_relative_attention_bias=False):
|
||
|
|
super().__init__()
|
||
|
|
self.is_decoder = config.is_decoder
|
||
|
|
self.has_relative_attention_bias = has_relative_attention_bias
|
||
|
|
self.relative_attention_num_buckets = config.relative_attention_num_buckets
|
||
|
|
self.relative_attention_max_distance = config.relative_attention_max_distance
|
||
|
|
self.d_model = config.d_model
|
||
|
|
self.key_value_proj_dim = config.d_kv
|
||
|
|
self.n_heads = config.num_heads
|
||
|
|
self.dropout = config.dropout_rate
|
||
|
|
self.inner_dim = self.n_heads * self.key_value_proj_dim
|
||
|
|
|
||
|
|
# Mesh TensorFlow initialization to avoid scaling before softmax
|
||
|
|
self.q = nn.Linear(self.d_model, self.inner_dim, bias=False)
|
||
|
|
self.k = nn.Linear(self.d_model, self.inner_dim, bias=False)
|
||
|
|
self.v = nn.Linear(self.d_model, self.inner_dim, bias=False)
|
||
|
|
self.o = nn.Linear(self.inner_dim, self.d_model, bias=False)
|
||
|
|
|
||
|
|
if self.has_relative_attention_bias:
|
||
|
|
self.relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets, self.n_heads)
|
||
|
|
self.pruned_heads = set()
|
||
|
|
self.gradient_checkpointing = False
|
||
|
|
|
||
|
|
def prune_heads(self, heads):
|
||
|
|
if len(heads) == 0:
|
||
|
|
return
|
||
|
|
heads, index = find_pruneable_heads_and_indices(
|
||
|
|
heads, self.n_heads, self.key_value_proj_dim, self.pruned_heads
|
||
|
|
)
|
||
|
|
# Prune linear layers
|
||
|
|
self.q = prune_linear_layer(self.q, index)
|
||
|
|
self.k = prune_linear_layer(self.k, index)
|
||
|
|
self.v = prune_linear_layer(self.v, index)
|
||
|
|
self.o = prune_linear_layer(self.o, index, dim=1)
|
||
|
|
# Update hyper params
|
||
|
|
self.n_heads = self.n_heads - len(heads)
|
||
|
|
self.inner_dim = self.key_value_proj_dim * self.n_heads
|
||
|
|
self.pruned_heads = self.pruned_heads.union(heads)
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _relative_position_bucket(relative_position, bidirectional=True, num_buckets=32, max_distance=128):
|
||
|
|
"""
|
||
|
|
Adapted from Mesh Tensorflow:
|
||
|
|
https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593
|
||
|
|
|
||
|
|
Translate relative position to a bucket number for relative attention. The relative position is defined as
|
||
|
|
memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to
|
||
|
|
position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for
|
||
|
|
small absolute relative_position and larger buckets for larger absolute relative_positions. All relative
|
||
|
|
positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket.
|
||
|
|
This should allow for more graceful generalization to longer sequences than the model has been trained on
|
||
|
|
|
||
|
|
Args:
|
||
|
|
relative_position: an int32 Tensor
|
||
|
|
bidirectional: a boolean - whether the attention is bidirectional
|
||
|
|
num_buckets: an integer
|
||
|
|
max_distance: an integer
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets)
|
||
|
|
"""
|
||
|
|
relative_buckets = 0
|
||
|
|
if bidirectional:
|
||
|
|
num_buckets //= 2
|
||
|
|
relative_buckets += (relative_position > 0).to(torch.long) * num_buckets
|
||
|
|
relative_position = torch.abs(relative_position)
|
||
|
|
else:
|
||
|
|
relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
|
||
|
|
# now relative_position is in the range [0, inf)
|
||
|
|
|
||
|
|
# half of the buckets are for exact increments in positions
|
||
|
|
max_exact = num_buckets // 2
|
||
|
|
is_small = relative_position < max_exact
|
||
|
|
|
||
|
|
# The other half of the buckets are for logarithmically bigger bins in positions up to max_distance
|
||
|
|
relative_position_if_large = max_exact + (
|
||
|
|
torch.log(relative_position.float() / max_exact)
|
||
|
|
/ math.log(max_distance / max_exact)
|
||
|
|
* (num_buckets - max_exact)
|
||
|
|
).to(torch.long)
|
||
|
|
relative_position_if_large = torch.min(
|
||
|
|
relative_position_if_large, torch.full_like(relative_position_if_large, num_buckets - 1)
|
||
|
|
)
|
||
|
|
|
||
|
|
relative_buckets += torch.where(is_small, relative_position, relative_position_if_large)
|
||
|
|
return relative_buckets
|
||
|
|
|
||
|
|
def compute_bias(self, query_length, key_length, device=None):
|
||
|
|
"""Compute binned relative position bias"""
|
||
|
|
if device is None:
|
||
|
|
device = self.relative_attention_bias.weight.device
|
||
|
|
context_position = torch.arange(query_length, dtype=torch.long, device=device)[:, None]
|
||
|
|
memory_position = torch.arange(key_length, dtype=torch.long, device=device)[None, :]
|
||
|
|
relative_position = memory_position - context_position # shape (query_length, key_length)
|
||
|
|
relative_position_bucket = self._relative_position_bucket(
|
||
|
|
relative_position, # shape (query_length, key_length)
|
||
|
|
bidirectional=(not self.is_decoder),
|
||
|
|
num_buckets=self.relative_attention_num_buckets,
|
||
|
|
max_distance=self.relative_attention_max_distance,
|
||
|
|
)
|
||
|
|
values = self.relative_attention_bias(relative_position_bucket) # shape (query_length, key_length, num_heads)
|
||
|
|
values = values.permute([2, 0, 1]).unsqueeze(0) # shape (1, num_heads, query_length, key_length)
|
||
|
|
return values
|
||
|
|
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
hidden_states,
|
||
|
|
mask=None,
|
||
|
|
key_value_states=None,
|
||
|
|
position_bias=None,
|
||
|
|
past_key_value=None,
|
||
|
|
layer_head_mask=None,
|
||
|
|
query_length=None,
|
||
|
|
use_cache=False,
|
||
|
|
output_attentions=False,
|
||
|
|
):
|
||
|
|
"""
|
||
|
|
Self-attention (if key_value_states is None) or attention over source sentence (provided by key_value_states).
|
||
|
|
"""
|
||
|
|
# Input is (batch_size, seq_length, dim)
|
||
|
|
# Mask is (batch_size, key_length) (non-causal) or (batch_size, key_length, key_length)
|
||
|
|
# past_key_value[0] is (batch_size, n_heads, q_len - 1, dim_per_head)
|
||
|
|
batch_size, seq_length = hidden_states.shape[:2]
|
||
|
|
|
||
|
|
real_seq_length = seq_length
|
||
|
|
|
||
|
|
if past_key_value is not None:
|
||
|
|
if len(past_key_value) != 2:
|
||
|
|
raise ValueError(
|
||
|
|
f"past_key_value should have 2 past states: keys and values. Got { len(past_key_value)} past states"
|
||
|
|
)
|
||
|
|
real_seq_length += past_key_value[0].shape[2] if query_length is None else query_length
|
||
|
|
|
||
|
|
key_length = real_seq_length if key_value_states is None else key_value_states.shape[1]
|
||
|
|
|
||
|
|
def shape(states):
|
||
|
|
"""projection"""
|
||
|
|
return states.view(batch_size, -1, self.n_heads, self.key_value_proj_dim).transpose(1, 2)
|
||
|
|
|
||
|
|
def unshape(states):
|
||
|
|
"""reshape"""
|
||
|
|
return states.transpose(1, 2).contiguous().view(batch_size, -1, self.inner_dim)
|
||
|
|
|
||
|
|
def project(hidden_states, proj_layer, key_value_states, past_key_value):
|
||
|
|
"""projects hidden states correctly to key/query states"""
|
||
|
|
if key_value_states is None:
|
||
|
|
# self-attn
|
||
|
|
# (batch_size, n_heads, seq_length, dim_per_head)
|
||
|
|
hidden_states = shape(proj_layer(hidden_states))
|
||
|
|
elif past_key_value is None:
|
||
|
|
# cross-attn
|
||
|
|
# (batch_size, n_heads, seq_length, dim_per_head)
|
||
|
|
hidden_states = shape(proj_layer(key_value_states))
|
||
|
|
|
||
|
|
if past_key_value is not None:
|
||
|
|
if key_value_states is None:
|
||
|
|
# self-attn
|
||
|
|
# (batch_size, n_heads, key_length, dim_per_head)
|
||
|
|
hidden_states = torch.cat([past_key_value, hidden_states], dim=2)
|
||
|
|
elif past_key_value.shape[2] != key_value_states.shape[1]:
|
||
|
|
# checking that the `sequence_length` of the `past_key_value` is the same as
|
||
|
|
# the provided `key_value_states` to support prefix tuning
|
||
|
|
# cross-attn
|
||
|
|
# (batch_size, n_heads, seq_length, dim_per_head)
|
||
|
|
hidden_states = shape(proj_layer(key_value_states))
|
||
|
|
else:
|
||
|
|
# cross-attn
|
||
|
|
hidden_states = past_key_value
|
||
|
|
return hidden_states
|
||
|
|
|
||
|
|
# get query states
|
||
|
|
query_states = shape(self.q(hidden_states)) # (batch_size, n_heads, seq_length, dim_per_head)
|
||
|
|
|
||
|
|
# get key/value states
|
||
|
|
key_states = project(
|
||
|
|
hidden_states, self.k, key_value_states, past_key_value[0] if past_key_value is not None else None
|
||
|
|
)
|
||
|
|
value_states = project(
|
||
|
|
hidden_states, self.v, key_value_states, past_key_value[1] if past_key_value is not None else None
|
||
|
|
)
|
||
|
|
|
||
|
|
# compute scores
|
||
|
|
scores = torch.matmul(
|
||
|
|
query_states, key_states.transpose(3, 2)
|
||
|
|
) # equivalent of torch.einsum("bnqd,bnkd->bnqk", query_states, key_states), compatible with onnx op>9
|
||
|
|
|
||
|
|
if position_bias is None:
|
||
|
|
if not self.has_relative_attention_bias:
|
||
|
|
position_bias = torch.zeros(
|
||
|
|
(1, self.n_heads, real_seq_length, key_length), device=scores.device, dtype=scores.dtype
|
||
|
|
)
|
||
|
|
if self.gradient_checkpointing and self.training:
|
||
|
|
position_bias.requires_grad = True
|
||
|
|
else:
|
||
|
|
position_bias = self.compute_bias(real_seq_length, key_length, device=scores.device)
|
||
|
|
|
||
|
|
# if key and values are already calculated
|
||
|
|
# we want only the last query position bias
|
||
|
|
if past_key_value is not None:
|
||
|
|
position_bias = position_bias[:, :, -hidden_states.size(1) :, :]
|
||
|
|
|
||
|
|
if mask is not None:
|
||
|
|
position_bias = position_bias + mask # (batch_size, n_heads, seq_length, key_length)
|
||
|
|
|
||
|
|
if self.pruned_heads:
|
||
|
|
mask = torch.ones(position_bias.shape[1])
|
||
|
|
mask[list(self.pruned_heads)] = 0
|
||
|
|
position_bias_masked = position_bias[:, mask.bool()]
|
||
|
|
else:
|
||
|
|
position_bias_masked = position_bias
|
||
|
|
|
||
|
|
scores += position_bias_masked
|
||
|
|
attn_weights = nn.functional.softmax(scores.float(), dim=-1).type_as(
|
||
|
|
scores
|
||
|
|
) # (batch_size, n_heads, seq_length, key_length)
|
||
|
|
attn_weights = nn.functional.dropout(
|
||
|
|
attn_weights, p=self.dropout, training=self.training
|
||
|
|
) # (batch_size, n_heads, seq_length, key_length)
|
||
|
|
|
||
|
|
# Mask heads if we want to
|
||
|
|
if layer_head_mask is not None:
|
||
|
|
attn_weights = attn_weights * layer_head_mask
|
||
|
|
|
||
|
|
attn_output = unshape(torch.matmul(attn_weights, value_states)) # (batch_size, seq_length, dim)
|
||
|
|
attn_output = self.o(attn_output)
|
||
|
|
|
||
|
|
present_key_value_state = (key_states, value_states) if (self.is_decoder and use_cache) else None
|
||
|
|
outputs = (attn_output,) + (present_key_value_state,) + (position_bias,)
|
||
|
|
|
||
|
|
if output_attentions:
|
||
|
|
outputs = outputs + (attn_weights,)
|
||
|
|
return outputs
|
||
|
|
|
||
|
|
|
||
|
|
class LongT5LocalAttention(nn.Module):
|
||
|
|
def __init__(self, config: LongT5Config, has_relative_attention_bias: bool = False) -> None:
|
||
|
|
super().__init__()
|
||
|
|
self.is_decoder = config.is_decoder
|
||
|
|
self.has_relative_attention_bias = has_relative_attention_bias
|
||
|
|
self.relative_attention_num_buckets = config.relative_attention_num_buckets
|
||
|
|
self.relative_attention_max_distance = config.relative_attention_max_distance
|
||
|
|
self.d_model = config.d_model
|
||
|
|
self.key_value_proj_dim = config.d_kv
|
||
|
|
self.n_heads = config.num_heads
|
||
|
|
self.local_radius = config.local_radius
|
||
|
|
self.block_len = self.local_radius + 1
|
||
|
|
self.dropout = config.dropout_rate
|
||
|
|
self.inner_dim = self.n_heads * self.key_value_proj_dim
|
||
|
|
|
||
|
|
# Mesh TensorFlow initialization to avoid scaling before softmax
|
||
|
|
self.q = nn.Linear(self.d_model, self.inner_dim, bias=False)
|
||
|
|
self.k = nn.Linear(self.d_model, self.inner_dim, bias=False)
|
||
|
|
self.v = nn.Linear(self.d_model, self.inner_dim, bias=False)
|
||
|
|
self.o = nn.Linear(self.inner_dim, self.d_model, bias=False)
|
||
|
|
|
||
|
|
if self.has_relative_attention_bias:
|
||
|
|
self.relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets, self.n_heads)
|
||
|
|
self.pruned_heads = set()
|
||
|
|
self.gradient_checkpointing = False
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5Attention.prune_heads
|
||
|
|
def prune_heads(self, heads):
|
||
|
|
if len(heads) == 0:
|
||
|
|
return
|
||
|
|
heads, index = find_pruneable_heads_and_indices(
|
||
|
|
heads, self.n_heads, self.key_value_proj_dim, self.pruned_heads
|
||
|
|
)
|
||
|
|
# Prune linear layers
|
||
|
|
self.q = prune_linear_layer(self.q, index)
|
||
|
|
self.k = prune_linear_layer(self.k, index)
|
||
|
|
self.v = prune_linear_layer(self.v, index)
|
||
|
|
self.o = prune_linear_layer(self.o, index, dim=1)
|
||
|
|
# Update hyper params
|
||
|
|
self.n_heads = self.n_heads - len(heads)
|
||
|
|
self.inner_dim = self.key_value_proj_dim * self.n_heads
|
||
|
|
self.pruned_heads = self.pruned_heads.union(heads)
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5Attention._relative_position_bucket
|
||
|
|
def _relative_position_bucket(relative_position, bidirectional=True, num_buckets=32, max_distance=128):
|
||
|
|
"""
|
||
|
|
Adapted from Mesh Tensorflow:
|
||
|
|
https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593
|
||
|
|
|
||
|
|
Translate relative position to a bucket number for relative attention. The relative position is defined as
|
||
|
|
memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to
|
||
|
|
position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for
|
||
|
|
small absolute relative_position and larger buckets for larger absolute relative_positions. All relative
|
||
|
|
positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket.
|
||
|
|
This should allow for more graceful generalization to longer sequences than the model has been trained on
|
||
|
|
|
||
|
|
Args:
|
||
|
|
relative_position: an int32 Tensor
|
||
|
|
bidirectional: a boolean - whether the attention is bidirectional
|
||
|
|
num_buckets: an integer
|
||
|
|
max_distance: an integer
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets)
|
||
|
|
"""
|
||
|
|
relative_buckets = 0
|
||
|
|
if bidirectional:
|
||
|
|
num_buckets //= 2
|
||
|
|
relative_buckets += (relative_position > 0).to(torch.long) * num_buckets
|
||
|
|
relative_position = torch.abs(relative_position)
|
||
|
|
else:
|
||
|
|
relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
|
||
|
|
# now relative_position is in the range [0, inf)
|
||
|
|
|
||
|
|
# half of the buckets are for exact increments in positions
|
||
|
|
max_exact = num_buckets // 2
|
||
|
|
is_small = relative_position < max_exact
|
||
|
|
|
||
|
|
# The other half of the buckets are for logarithmically bigger bins in positions up to max_distance
|
||
|
|
relative_position_if_large = max_exact + (
|
||
|
|
torch.log(relative_position.float() / max_exact)
|
||
|
|
/ math.log(max_distance / max_exact)
|
||
|
|
* (num_buckets - max_exact)
|
||
|
|
).to(torch.long)
|
||
|
|
relative_position_if_large = torch.min(
|
||
|
|
relative_position_if_large, torch.full_like(relative_position_if_large, num_buckets - 1)
|
||
|
|
)
|
||
|
|
|
||
|
|
relative_buckets += torch.where(is_small, relative_position, relative_position_if_large)
|
||
|
|
return relative_buckets
|
||
|
|
|
||
|
|
def compute_bias(self, block_length: int):
|
||
|
|
"""Compute binned relative position bias"""
|
||
|
|
target_device = (
|
||
|
|
self.relative_attention_bias.weight.device
|
||
|
|
if self.relative_attention_bias.weight.device.type != "meta"
|
||
|
|
else None
|
||
|
|
)
|
||
|
|
memory_position = torch.arange(3 * block_length, dtype=torch.long, device=target_device)
|
||
|
|
context_position = memory_position[block_length:-block_length]
|
||
|
|
|
||
|
|
# (block_length, 3 * block_length)
|
||
|
|
relative_position = memory_position[None, :] - context_position[:, None]
|
||
|
|
relative_position_bucket = self._relative_position_bucket(
|
||
|
|
relative_position, # (block_length, 3 * block_length)
|
||
|
|
bidirectional=(not self.is_decoder),
|
||
|
|
num_buckets=self.relative_attention_num_buckets,
|
||
|
|
max_distance=self.relative_attention_max_distance,
|
||
|
|
)
|
||
|
|
# (block_length, 3 * block_length, num_heads)
|
||
|
|
values = self.relative_attention_bias(relative_position_bucket)
|
||
|
|
# (1, 1, num_heads, block_length, 3 * block_length)
|
||
|
|
values = values.permute([2, 0, 1]).unsqueeze(0).unsqueeze(0)
|
||
|
|
return values
|
||
|
|
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
hidden_states,
|
||
|
|
mask=None,
|
||
|
|
position_bias=None,
|
||
|
|
layer_head_mask=None,
|
||
|
|
output_attentions=False,
|
||
|
|
):
|
||
|
|
batch_size, seq_length = hidden_states.shape[:2]
|
||
|
|
|
||
|
|
def shape(states):
|
||
|
|
"""projection"""
|
||
|
|
return states.view(batch_size, -1, self.n_heads, self.key_value_proj_dim)
|
||
|
|
|
||
|
|
def unshape(states):
|
||
|
|
"""reshape"""
|
||
|
|
return states.contiguous().view(batch_size, -1, self.inner_dim)
|
||
|
|
|
||
|
|
# get query/key/value states -> (batch_size, seq_length, n_heads, dim_per_head)
|
||
|
|
query_states = shape(self.q(hidden_states))
|
||
|
|
key_states = shape(self.k(hidden_states))
|
||
|
|
value_states = shape(self.v(hidden_states))
|
||
|
|
|
||
|
|
# Split into blocks -> (batch_size, num_blocks, block_len, n_heads, dim_per_head)
|
||
|
|
query_states = _split_into_blocks(query_states, self.block_len, dim=1)
|
||
|
|
key_states = _split_into_blocks(key_states, self.block_len, dim=1)
|
||
|
|
value_states = _split_into_blocks(value_states, self.block_len, dim=1)
|
||
|
|
|
||
|
|
# Concatenate 3 blocks for keys and values -> (batch_size, num_blocks, 3 * block_len, n_heads, dim_per_head)
|
||
|
|
key_states = _concatenate_3_blocks(key_states, block_dim=1, sequence_dim=2)
|
||
|
|
value_states = _concatenate_3_blocks(value_states, block_dim=1, sequence_dim=2)
|
||
|
|
|
||
|
|
# Compute scores
|
||
|
|
scores = torch.einsum(
|
||
|
|
"...qhd,...khd->...hqk", query_states, key_states
|
||
|
|
) # (batch_size, num_block, n_heads, block_len, 3 * block_len)
|
||
|
|
|
||
|
|
if position_bias is None:
|
||
|
|
# position_bias shape: # (1, 1, n_heads, block_len, 3 * block_len)
|
||
|
|
if not self.has_relative_attention_bias:
|
||
|
|
position_bias = torch.zeros(
|
||
|
|
(1, 1, self.n_heads, self.block_len, 3 * self.block_len), device=scores.device, dtype=scores.dtype
|
||
|
|
)
|
||
|
|
if self.gradient_checkpointing and self.training:
|
||
|
|
position_bias.requires_grad = True
|
||
|
|
else:
|
||
|
|
position_bias = self.compute_bias(self.block_len)
|
||
|
|
|
||
|
|
if mask is not None:
|
||
|
|
# Replace masked positions with -1e10 (according to the original implementation)
|
||
|
|
mask = torch.where(mask > 0, 0.0, -1e10)
|
||
|
|
# We need to adjust position bias shape to be sum with mask
|
||
|
|
position_bias = position_bias + mask.transpose(1, 2)
|
||
|
|
|
||
|
|
scores += position_bias
|
||
|
|
# (batch_size, num_blocks, n_heads, block_len, 3 * block_len)
|
||
|
|
attn_weights = nn.functional.softmax(scores.float(), dim=-1).type_as(scores)
|
||
|
|
# (batch_size, num_blocks, n_heads, block_len, 3 * block_len)
|
||
|
|
attn_weights = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
|
||
|
|
|
||
|
|
# Mask heads if we want to
|
||
|
|
if layer_head_mask is not None:
|
||
|
|
attn_weights = attn_weights * layer_head_mask
|
||
|
|
attn_weights = attn_weights.type(value_states.dtype)
|
||
|
|
attn_output = unshape(torch.einsum("...hqk,...khd->...qhd", attn_weights, value_states))
|
||
|
|
attn_output = attn_output[:, :seq_length, :]
|
||
|
|
attn_output = self.o(attn_output)
|
||
|
|
|
||
|
|
present_key_value_state = None
|
||
|
|
outputs = (attn_output,) + (present_key_value_state,) + (position_bias,)
|
||
|
|
|
||
|
|
if output_attentions:
|
||
|
|
outputs = outputs + (attn_weights,)
|
||
|
|
return outputs
|
||
|
|
|
||
|
|
|
||
|
|
class LongT5TransientGlobalAttention(nn.Module):
|
||
|
|
def __init__(self, config: LongT5Config, has_relative_attention_bias: bool = False) -> None:
|
||
|
|
super().__init__()
|
||
|
|
self.is_decoder = config.is_decoder
|
||
|
|
self.has_relative_attention_bias = has_relative_attention_bias
|
||
|
|
self.relative_attention_num_buckets = config.relative_attention_num_buckets
|
||
|
|
self.relative_attention_max_distance = config.relative_attention_max_distance
|
||
|
|
self.d_model = config.d_model
|
||
|
|
self.key_value_proj_dim = config.d_kv
|
||
|
|
self.n_heads = config.num_heads
|
||
|
|
self.local_radius = config.local_radius
|
||
|
|
self.block_len = self.local_radius + 1
|
||
|
|
self.global_block_size = config.global_block_size
|
||
|
|
self.dropout = config.dropout_rate
|
||
|
|
self.inner_dim = self.n_heads * self.key_value_proj_dim
|
||
|
|
|
||
|
|
# Mesh TensorFlow initialization to avoid scaling before softmax
|
||
|
|
self.q = nn.Linear(self.d_model, self.inner_dim, bias=False)
|
||
|
|
self.k = nn.Linear(self.d_model, self.inner_dim, bias=False)
|
||
|
|
self.v = nn.Linear(self.d_model, self.inner_dim, bias=False)
|
||
|
|
self.o = nn.Linear(self.inner_dim, self.d_model, bias=False)
|
||
|
|
|
||
|
|
if self.has_relative_attention_bias:
|
||
|
|
self.relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets, self.n_heads)
|
||
|
|
self.pruned_heads = set()
|
||
|
|
|
||
|
|
# Relativen attention bias & Layer norm for global attention
|
||
|
|
if self.has_relative_attention_bias:
|
||
|
|
self.global_relative_attention_bias = nn.Embedding(self.relative_attention_num_buckets, self.n_heads)
|
||
|
|
self.global_input_layer_norm = LongT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5Attention.prune_heads
|
||
|
|
def prune_heads(self, heads):
|
||
|
|
if len(heads) == 0:
|
||
|
|
return
|
||
|
|
heads, index = find_pruneable_heads_and_indices(
|
||
|
|
heads, self.n_heads, self.key_value_proj_dim, self.pruned_heads
|
||
|
|
)
|
||
|
|
# Prune linear layers
|
||
|
|
self.q = prune_linear_layer(self.q, index)
|
||
|
|
self.k = prune_linear_layer(self.k, index)
|
||
|
|
self.v = prune_linear_layer(self.v, index)
|
||
|
|
self.o = prune_linear_layer(self.o, index, dim=1)
|
||
|
|
# Update hyper params
|
||
|
|
self.n_heads = self.n_heads - len(heads)
|
||
|
|
self.inner_dim = self.key_value_proj_dim * self.n_heads
|
||
|
|
self.pruned_heads = self.pruned_heads.union(heads)
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5Attention._relative_position_bucket
|
||
|
|
def _relative_position_bucket(relative_position, bidirectional=True, num_buckets=32, max_distance=128):
|
||
|
|
"""
|
||
|
|
Adapted from Mesh Tensorflow:
|
||
|
|
https://github.com/tensorflow/mesh/blob/0cb87fe07da627bf0b7e60475d59f95ed6b5be3d/mesh_tensorflow/transformer/transformer_layers.py#L593
|
||
|
|
|
||
|
|
Translate relative position to a bucket number for relative attention. The relative position is defined as
|
||
|
|
memory_position - query_position, i.e. the distance in tokens from the attending position to the attended-to
|
||
|
|
position. If bidirectional=False, then positive relative positions are invalid. We use smaller buckets for
|
||
|
|
small absolute relative_position and larger buckets for larger absolute relative_positions. All relative
|
||
|
|
positions >=max_distance map to the same bucket. All relative positions <=-max_distance map to the same bucket.
|
||
|
|
This should allow for more graceful generalization to longer sequences than the model has been trained on
|
||
|
|
|
||
|
|
Args:
|
||
|
|
relative_position: an int32 Tensor
|
||
|
|
bidirectional: a boolean - whether the attention is bidirectional
|
||
|
|
num_buckets: an integer
|
||
|
|
max_distance: an integer
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
a Tensor with the same shape as relative_position, containing int32 values in the range [0, num_buckets)
|
||
|
|
"""
|
||
|
|
relative_buckets = 0
|
||
|
|
if bidirectional:
|
||
|
|
num_buckets //= 2
|
||
|
|
relative_buckets += (relative_position > 0).to(torch.long) * num_buckets
|
||
|
|
relative_position = torch.abs(relative_position)
|
||
|
|
else:
|
||
|
|
relative_position = -torch.min(relative_position, torch.zeros_like(relative_position))
|
||
|
|
# now relative_position is in the range [0, inf)
|
||
|
|
|
||
|
|
# half of the buckets are for exact increments in positions
|
||
|
|
max_exact = num_buckets // 2
|
||
|
|
is_small = relative_position < max_exact
|
||
|
|
|
||
|
|
# The other half of the buckets are for logarithmically bigger bins in positions up to max_distance
|
||
|
|
relative_position_if_large = max_exact + (
|
||
|
|
torch.log(relative_position.float() / max_exact)
|
||
|
|
/ math.log(max_distance / max_exact)
|
||
|
|
* (num_buckets - max_exact)
|
||
|
|
).to(torch.long)
|
||
|
|
relative_position_if_large = torch.min(
|
||
|
|
relative_position_if_large, torch.full_like(relative_position_if_large, num_buckets - 1)
|
||
|
|
)
|
||
|
|
|
||
|
|
relative_buckets += torch.where(is_small, relative_position, relative_position_if_large)
|
||
|
|
return relative_buckets
|
||
|
|
|
||
|
|
def compute_bias(self, block_length: int):
|
||
|
|
"""Compute binned relative position bias"""
|
||
|
|
target_device = (
|
||
|
|
self.relative_attention_bias.weight.device
|
||
|
|
if self.relative_attention_bias.weight.device.type != "meta"
|
||
|
|
else None
|
||
|
|
)
|
||
|
|
memory_position = torch.arange(3 * block_length, dtype=torch.long, device=target_device)
|
||
|
|
context_position = memory_position[block_length:-block_length]
|
||
|
|
|
||
|
|
# (block_length, 3 * block_length)
|
||
|
|
relative_position = memory_position[None, :] - context_position[:, None]
|
||
|
|
relative_position_bucket = self._relative_position_bucket(
|
||
|
|
relative_position, # (block_length, 3 * block_length)
|
||
|
|
bidirectional=(not self.is_decoder),
|
||
|
|
num_buckets=self.relative_attention_num_buckets,
|
||
|
|
max_distance=self.relative_attention_max_distance,
|
||
|
|
)
|
||
|
|
# (block_length, 3 * block_length, num_heads)
|
||
|
|
values = self.relative_attention_bias(relative_position_bucket)
|
||
|
|
# (1, 1, num_heads, block_length, 3 * block_length)
|
||
|
|
values = values.permute([2, 0, 1]).unsqueeze(0).unsqueeze(0)
|
||
|
|
return values
|
||
|
|
|
||
|
|
def compute_side_bias(self, mask: torch.Tensor, global_segment_ids: torch.Tensor) -> torch.Tensor:
|
||
|
|
# (batch_size, 1, seq_len, global_seq_len)
|
||
|
|
side_attention_mask = torch.eq(mask[..., None], global_segment_ids[:, None, :])[:, None, ...]
|
||
|
|
attention_side_bias = torch.where(side_attention_mask > 0, 0.0, -1e10)
|
||
|
|
# (batch_size, seq_len, global_seq_len)
|
||
|
|
side_relative_position = _make_side_relative_position_ids(mask, self.global_block_size)
|
||
|
|
side_relative_position_bucket = self._relative_position_bucket(
|
||
|
|
side_relative_position,
|
||
|
|
bidirectional=(not self.is_decoder),
|
||
|
|
num_buckets=self.relative_attention_num_buckets,
|
||
|
|
max_distance=self.relative_attention_max_distance,
|
||
|
|
)
|
||
|
|
# (batch_size, seq_len, global_seq_len, num_heads)
|
||
|
|
side_bias = self.global_relative_attention_bias(side_relative_position_bucket)
|
||
|
|
|
||
|
|
# (batch_size, num_heads, seq_len, global_seq_len)
|
||
|
|
side_bias = side_bias.permute([0, 3, 1, 2])
|
||
|
|
# (batch_size, num_heads, seq_len, global_seq_len)
|
||
|
|
attention_side_bias = attention_side_bias + side_bias
|
||
|
|
return attention_side_bias
|
||
|
|
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
hidden_states,
|
||
|
|
mask=None,
|
||
|
|
position_bias=None,
|
||
|
|
layer_head_mask=None,
|
||
|
|
output_attentions=False,
|
||
|
|
):
|
||
|
|
batch_size, seq_length = hidden_states.shape[:2]
|
||
|
|
|
||
|
|
def shape(states):
|
||
|
|
"""projection"""
|
||
|
|
return states.view(batch_size, -1, self.n_heads, self.key_value_proj_dim)
|
||
|
|
|
||
|
|
def unshape(states):
|
||
|
|
"""reshape"""
|
||
|
|
return states.contiguous().view(batch_size, -1, self.inner_dim)
|
||
|
|
|
||
|
|
# Prepare components for transient-global attention
|
||
|
|
# Obtain block_ids and global_segment_ids
|
||
|
|
# global_seq_len := seq_len // self.global_block_size
|
||
|
|
# shapes: (batch_size, seq_len) & (batch_size, global_seq_len)
|
||
|
|
block_ids, global_segment_ids = _make_global_fixed_block_ids(
|
||
|
|
mask if mask is not None else torch.ones(hidden_states.shape[:-1]),
|
||
|
|
self.global_block_size,
|
||
|
|
)
|
||
|
|
# Create global inputs
|
||
|
|
_global_seq_len = global_segment_ids.shape[-1]
|
||
|
|
global_inputs = _create_global_aggregates(hidden_states, block_ids, _global_seq_len)
|
||
|
|
global_inputs = self.global_input_layer_norm(global_inputs)
|
||
|
|
|
||
|
|
# get query states -> (batch_size, seq_length, n_heads, dim_per_head)
|
||
|
|
query_states = shape(self.q(hidden_states))
|
||
|
|
key_states = shape(self.k(hidden_states))
|
||
|
|
value_states = shape(self.v(hidden_states))
|
||
|
|
# Get global/side key/value states shape: (batch_size, global_seq_len, n_heads, dim_per_head)
|
||
|
|
side_key_states = shape(self.k(global_inputs))
|
||
|
|
side_value_states = shape(self.v(global_inputs))
|
||
|
|
|
||
|
|
# Split into blocks -> (batch_size, num_blocks, block_len, n_heads, dim_per_head)
|
||
|
|
query_states = _split_into_blocks(query_states, self.block_len, dim=1)
|
||
|
|
key_states = _split_into_blocks(key_states, self.block_len, dim=1)
|
||
|
|
value_states = _split_into_blocks(value_states, self.block_len, dim=1)
|
||
|
|
|
||
|
|
# Concatenate 3 blocks for keys and values -> (batch_size, num_blocks, 3 * block_len, n_heads, dim_per_head)
|
||
|
|
key_states = _concatenate_3_blocks(key_states, block_dim=1, sequence_dim=2)
|
||
|
|
value_states = _concatenate_3_blocks(value_states, block_dim=1, sequence_dim=2)
|
||
|
|
|
||
|
|
# Tile side inputs across local key/value blocks
|
||
|
|
# New shape: (batch_size, num_blocks, global_seq_len, n_heads, dim_per_head)
|
||
|
|
reps = [1] * (side_key_states.ndim + 1)
|
||
|
|
reps[1] = key_states.shape[1]
|
||
|
|
side_key_states = side_key_states.unsqueeze(1).repeat(reps)
|
||
|
|
side_value_states = side_value_states.unsqueeze(1).repeat(reps)
|
||
|
|
|
||
|
|
# Concatenate "local" and "side"/"global" key/value states to allow each token to attend global aggregated ones
|
||
|
|
# New shape: (batch_size, num_blocks, 3 * block_len + global_seq_len, n_heads, dim_per_head)
|
||
|
|
key_states = torch.cat([key_states, side_key_states], dim=2)
|
||
|
|
value_states = torch.cat([value_states, side_value_states], dim=2)
|
||
|
|
|
||
|
|
# Compute scores -> (batch_size, num_block, n_heads, block_len, 3 * block_len + global_seq_len)
|
||
|
|
scores = torch.einsum("...qhd,...khd->...hqk", query_states, key_states)
|
||
|
|
|
||
|
|
if mask is not None:
|
||
|
|
# We need to adjust position bias shape to be sum with mask
|
||
|
|
local_attention_mask = _get_local_attention_mask(mask, self.block_len, hidden_states.device)
|
||
|
|
# Replace masked positions with -10_000 (according to the original implementation)
|
||
|
|
local_attention_mask = torch.where(local_attention_mask > 0, 0.0, -1e10)
|
||
|
|
else:
|
||
|
|
local_attention_mask = None
|
||
|
|
|
||
|
|
if position_bias is None:
|
||
|
|
# position_bias shape: # (1, 1, n_heads, block_len, 3 * block_len)
|
||
|
|
if not self.has_relative_attention_bias:
|
||
|
|
position_bias = torch.zeros(
|
||
|
|
(1, 1, self.n_heads, self.block_len, 3 * self.block_len),
|
||
|
|
device=scores.device,
|
||
|
|
dtype=scores.dtype,
|
||
|
|
)
|
||
|
|
if self.gradient_checkpointing and self.training:
|
||
|
|
position_bias.requires_grad = True
|
||
|
|
else:
|
||
|
|
position_bias = self.compute_bias(self.block_len)
|
||
|
|
|
||
|
|
if local_attention_mask is not None:
|
||
|
|
# (batch_size, 1, n_heads, block_len, 3 * block_len)
|
||
|
|
position_bias = position_bias + local_attention_mask.transpose(1, 2)
|
||
|
|
position_bias = position_bias.type(scores.dtype)
|
||
|
|
|
||
|
|
# Calculate global/side bias - shape: # (batch_size, num_heads, seq_len, global_seq_len)
|
||
|
|
if mask is None:
|
||
|
|
mask = torch.ones(batch_size, seq_length)
|
||
|
|
# (batch_size, num_heads, seq_len, global_seq_len)
|
||
|
|
side_position_bias = self.compute_side_bias(mask, global_segment_ids)
|
||
|
|
# (batch_size, num_blocks, num_heads, block_len, global_seq_len)
|
||
|
|
side_position_bias = _split_into_blocks(side_position_bias, self.block_len, dim=-2).transpose(1, 2)
|
||
|
|
side_position_bias = side_position_bias.type(scores.dtype).to(scores.device)
|
||
|
|
# (batch_size, num_blocks, num_heads, block_len, 3 * block_len + global_seq_len)
|
||
|
|
position_bias = torch.cat([position_bias, side_position_bias], dim=-1)
|
||
|
|
|
||
|
|
scores += position_bias
|
||
|
|
# (batch_size, num_blocks, n_heads, block_len, 3 * block_len + global_seq_len)
|
||
|
|
attn_weights = nn.functional.softmax(scores.float(), dim=-1).type_as(scores)
|
||
|
|
attn_weights = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
|
||
|
|
|
||
|
|
# Mask heads if we want to
|
||
|
|
if layer_head_mask is not None:
|
||
|
|
attn_weights = attn_weights * layer_head_mask
|
||
|
|
attn_weights = attn_weights.type(value_states.dtype)
|
||
|
|
attn_output = unshape(torch.einsum("...hqk,...khd->...qhd", attn_weights, value_states))
|
||
|
|
attn_output = attn_output[:, :seq_length, :]
|
||
|
|
attn_output = self.o(attn_output)
|
||
|
|
|
||
|
|
present_key_value_state = None
|
||
|
|
outputs = (attn_output,) + (present_key_value_state,) + (position_bias,)
|
||
|
|
|
||
|
|
if output_attentions:
|
||
|
|
outputs = outputs + (attn_weights,)
|
||
|
|
return outputs
|
||
|
|
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5LayerSelfAttention with T5->LongT5
|
||
|
|
class LongT5LayerSelfAttention(nn.Module):
|
||
|
|
def __init__(self, config, has_relative_attention_bias=False):
|
||
|
|
super().__init__()
|
||
|
|
self.SelfAttention = LongT5Attention(config, has_relative_attention_bias=has_relative_attention_bias)
|
||
|
|
self.layer_norm = LongT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
|
||
|
|
self.dropout = nn.Dropout(config.dropout_rate)
|
||
|
|
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
hidden_states,
|
||
|
|
attention_mask=None,
|
||
|
|
position_bias=None,
|
||
|
|
layer_head_mask=None,
|
||
|
|
past_key_value=None,
|
||
|
|
use_cache=False,
|
||
|
|
output_attentions=False,
|
||
|
|
):
|
||
|
|
normed_hidden_states = self.layer_norm(hidden_states)
|
||
|
|
attention_output = self.SelfAttention(
|
||
|
|
normed_hidden_states,
|
||
|
|
mask=attention_mask,
|
||
|
|
position_bias=position_bias,
|
||
|
|
layer_head_mask=layer_head_mask,
|
||
|
|
past_key_value=past_key_value,
|
||
|
|
use_cache=use_cache,
|
||
|
|
output_attentions=output_attentions,
|
||
|
|
)
|
||
|
|
hidden_states = hidden_states + self.dropout(attention_output[0])
|
||
|
|
outputs = (hidden_states,) + attention_output[1:] # add attentions if we output them
|
||
|
|
return outputs
|
||
|
|
|
||
|
|
|
||
|
|
class LongT5LayerLocalSelfAttention(nn.Module):
|
||
|
|
"""Local self attention used in encoder"""
|
||
|
|
|
||
|
|
def __init__(self, config, has_relative_attention_bias=False):
|
||
|
|
super().__init__()
|
||
|
|
self.LocalSelfAttention = LongT5LocalAttention(config, has_relative_attention_bias=has_relative_attention_bias)
|
||
|
|
self.layer_norm = LongT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
|
||
|
|
self.dropout = nn.Dropout(config.dropout_rate)
|
||
|
|
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
hidden_states,
|
||
|
|
attention_mask=None,
|
||
|
|
position_bias=None,
|
||
|
|
layer_head_mask=None,
|
||
|
|
output_attentions=False,
|
||
|
|
**kwargs: Any, # to accept past_key_value and use_cache kwargs
|
||
|
|
):
|
||
|
|
normed_hidden_states = self.layer_norm(hidden_states)
|
||
|
|
attention_output = self.LocalSelfAttention(
|
||
|
|
normed_hidden_states,
|
||
|
|
mask=attention_mask,
|
||
|
|
position_bias=position_bias,
|
||
|
|
layer_head_mask=layer_head_mask,
|
||
|
|
output_attentions=output_attentions,
|
||
|
|
)
|
||
|
|
hidden_states = hidden_states + self.dropout(attention_output[0])
|
||
|
|
outputs = (hidden_states,) + attention_output[1:] # add attentions if we output them
|
||
|
|
return outputs
|
||
|
|
|
||
|
|
|
||
|
|
class LongT5LayerTransientGlobalSelfAttention(nn.Module):
|
||
|
|
"""Transient-Global self attention used in encoder"""
|
||
|
|
|
||
|
|
def __init__(self, config, has_relative_attention_bias=False):
|
||
|
|
super().__init__()
|
||
|
|
self.TransientGlobalSelfAttention = LongT5TransientGlobalAttention(
|
||
|
|
config, has_relative_attention_bias=has_relative_attention_bias
|
||
|
|
)
|
||
|
|
self.layer_norm = LongT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
|
||
|
|
self.dropout = nn.Dropout(config.dropout_rate)
|
||
|
|
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
hidden_states,
|
||
|
|
attention_mask=None,
|
||
|
|
position_bias=None,
|
||
|
|
layer_head_mask=None,
|
||
|
|
output_attentions=False,
|
||
|
|
**kwargs: Any, # to accept past_key_value and use_cache kwargs
|
||
|
|
):
|
||
|
|
normed_hidden_states = self.layer_norm(hidden_states)
|
||
|
|
attention_output = self.TransientGlobalSelfAttention(
|
||
|
|
normed_hidden_states,
|
||
|
|
mask=attention_mask,
|
||
|
|
position_bias=position_bias,
|
||
|
|
layer_head_mask=layer_head_mask,
|
||
|
|
output_attentions=output_attentions,
|
||
|
|
)
|
||
|
|
hidden_states = hidden_states + self.dropout(attention_output[0])
|
||
|
|
outputs = (hidden_states,) + attention_output[1:] # add attentions if we output them
|
||
|
|
return outputs
|
||
|
|
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5LayerCrossAttention with T5->LongT5
|
||
|
|
class LongT5LayerCrossAttention(nn.Module):
|
||
|
|
def __init__(self, config):
|
||
|
|
super().__init__()
|
||
|
|
self.EncDecAttention = LongT5Attention(config, has_relative_attention_bias=False)
|
||
|
|
self.layer_norm = LongT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
|
||
|
|
self.dropout = nn.Dropout(config.dropout_rate)
|
||
|
|
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
hidden_states,
|
||
|
|
key_value_states,
|
||
|
|
attention_mask=None,
|
||
|
|
position_bias=None,
|
||
|
|
layer_head_mask=None,
|
||
|
|
past_key_value=None,
|
||
|
|
use_cache=False,
|
||
|
|
query_length=None,
|
||
|
|
output_attentions=False,
|
||
|
|
):
|
||
|
|
normed_hidden_states = self.layer_norm(hidden_states)
|
||
|
|
attention_output = self.EncDecAttention(
|
||
|
|
normed_hidden_states,
|
||
|
|
mask=attention_mask,
|
||
|
|
key_value_states=key_value_states,
|
||
|
|
position_bias=position_bias,
|
||
|
|
layer_head_mask=layer_head_mask,
|
||
|
|
past_key_value=past_key_value,
|
||
|
|
use_cache=use_cache,
|
||
|
|
query_length=query_length,
|
||
|
|
output_attentions=output_attentions,
|
||
|
|
)
|
||
|
|
layer_output = hidden_states + self.dropout(attention_output[0])
|
||
|
|
outputs = (layer_output,) + attention_output[1:] # add attentions if we output them
|
||
|
|
return outputs
|
||
|
|
|
||
|
|
|
||
|
|
class LongT5Block(nn.Module):
|
||
|
|
def __init__(self, config, has_relative_attention_bias=False):
|
||
|
|
super().__init__()
|
||
|
|
self.is_decoder = config.is_decoder
|
||
|
|
if config.is_decoder:
|
||
|
|
attention_layer = LongT5LayerSelfAttention
|
||
|
|
elif config.encoder_attention_type == "local":
|
||
|
|
attention_layer = LongT5LayerLocalSelfAttention
|
||
|
|
elif config.encoder_attention_type == "transient-global":
|
||
|
|
attention_layer = LongT5LayerTransientGlobalSelfAttention
|
||
|
|
else:
|
||
|
|
raise ValueError(
|
||
|
|
"For encoder attention mechanism, either `local` or `transient-global` attention type is expected, "
|
||
|
|
f"but got {config.encoder_attention_type}."
|
||
|
|
)
|
||
|
|
self.layer = nn.ModuleList()
|
||
|
|
self.layer.append(attention_layer(config, has_relative_attention_bias=has_relative_attention_bias))
|
||
|
|
if self.is_decoder:
|
||
|
|
self.layer.append(LongT5LayerCrossAttention(config))
|
||
|
|
|
||
|
|
self.layer.append(LongT5LayerFF(config))
|
||
|
|
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
hidden_states,
|
||
|
|
attention_mask=None,
|
||
|
|
position_bias=None,
|
||
|
|
encoder_hidden_states=None,
|
||
|
|
encoder_attention_mask=None,
|
||
|
|
encoder_decoder_position_bias=None,
|
||
|
|
layer_head_mask=None,
|
||
|
|
cross_attn_layer_head_mask=None,
|
||
|
|
past_key_value=None,
|
||
|
|
use_cache=False,
|
||
|
|
output_attentions=False,
|
||
|
|
return_dict=True,
|
||
|
|
):
|
||
|
|
if past_key_value is not None:
|
||
|
|
if not self.is_decoder:
|
||
|
|
logger.warning("`past_key_values` is passed to the encoder. Please make sure this is intended.")
|
||
|
|
expected_num_past_key_values = 2 if encoder_hidden_states is None else 4
|
||
|
|
|
||
|
|
if len(past_key_value) != expected_num_past_key_values:
|
||
|
|
raise ValueError(
|
||
|
|
f"There should be {expected_num_past_key_values} past states. "
|
||
|
|
f"{'2 (past / key) for cross attention. ' if expected_num_past_key_values == 4 else ''}"
|
||
|
|
f"Got {len(past_key_value)} past key / value states"
|
||
|
|
)
|
||
|
|
|
||
|
|
self_attn_past_key_value = past_key_value[:2]
|
||
|
|
cross_attn_past_key_value = past_key_value[2:]
|
||
|
|
else:
|
||
|
|
self_attn_past_key_value, cross_attn_past_key_value = None, None
|
||
|
|
|
||
|
|
self_attention_outputs = self.layer[0](
|
||
|
|
hidden_states,
|
||
|
|
attention_mask=attention_mask,
|
||
|
|
position_bias=position_bias,
|
||
|
|
layer_head_mask=layer_head_mask,
|
||
|
|
past_key_value=self_attn_past_key_value,
|
||
|
|
use_cache=use_cache,
|
||
|
|
output_attentions=output_attentions,
|
||
|
|
)
|
||
|
|
hidden_states, present_key_value_state = self_attention_outputs[:2]
|
||
|
|
attention_outputs = self_attention_outputs[2:] # Keep self-attention outputs and relative position weights
|
||
|
|
|
||
|
|
# clamp inf values to enable fp16 inference - check https://github.com/huggingface/transformers/pull/19229/
|
||
|
|
if hidden_states.dtype == torch.float16 and torch.isinf(hidden_states).any():
|
||
|
|
clamp_value = torch.finfo(hidden_states.dtype).max - 1000
|
||
|
|
hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
|
||
|
|
|
||
|
|
do_cross_attention = self.is_decoder and encoder_hidden_states is not None
|
||
|
|
if do_cross_attention:
|
||
|
|
# the actual query length is unknown for cross attention
|
||
|
|
# if using past key value states. Need to inject it here
|
||
|
|
if present_key_value_state is not None:
|
||
|
|
query_length = present_key_value_state[0].shape[2]
|
||
|
|
else:
|
||
|
|
query_length = None
|
||
|
|
|
||
|
|
cross_attention_outputs = self.layer[1](
|
||
|
|
hidden_states,
|
||
|
|
key_value_states=encoder_hidden_states,
|
||
|
|
attention_mask=encoder_attention_mask,
|
||
|
|
position_bias=encoder_decoder_position_bias,
|
||
|
|
layer_head_mask=cross_attn_layer_head_mask,
|
||
|
|
past_key_value=cross_attn_past_key_value,
|
||
|
|
query_length=query_length,
|
||
|
|
use_cache=use_cache,
|
||
|
|
output_attentions=output_attentions,
|
||
|
|
)
|
||
|
|
hidden_states = cross_attention_outputs[0]
|
||
|
|
|
||
|
|
# clamp inf values to enable fp16 inference - check https://github.com/huggingface/transformers/pull/19229/
|
||
|
|
if hidden_states.dtype == torch.float16 and torch.isinf(hidden_states).any():
|
||
|
|
clamp_value = torch.finfo(hidden_states.dtype).max - 1000
|
||
|
|
hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
|
||
|
|
|
||
|
|
# Combine self attn and cross attn key value states
|
||
|
|
if present_key_value_state is not None:
|
||
|
|
present_key_value_state = present_key_value_state + cross_attention_outputs[1]
|
||
|
|
|
||
|
|
# Keep cross-attention outputs and relative position weights
|
||
|
|
attention_outputs = attention_outputs + cross_attention_outputs[2:]
|
||
|
|
|
||
|
|
# Apply Feed Forward layer
|
||
|
|
hidden_states = self.layer[-1](hidden_states)
|
||
|
|
|
||
|
|
# clamp inf values to enable fp16 inference - check https://github.com/huggingface/transformers/pull/19229/
|
||
|
|
if hidden_states.dtype == torch.float16 and torch.isinf(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 use_cache:
|
||
|
|
outputs = outputs + (present_key_value_state,) + attention_outputs
|
||
|
|
else:
|
||
|
|
outputs = outputs + attention_outputs
|
||
|
|
|
||
|
|
return outputs # hidden-states, present_key_value_states, (self-attention position bias), (self-attention weights), (cross-attention position bias), (cross-attention weights)
|
||
|
|
|
||
|
|
|
||
|
|
class LongT5PreTrainedModel(PreTrainedModel):
|
||
|
|
"""
|
||
|
|
An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
|
||
|
|
models.
|
||
|
|
"""
|
||
|
|
|
||
|
|
config_class = LongT5Config
|
||
|
|
base_model_prefix = "transformer"
|
||
|
|
supports_gradient_checkpointing = True
|
||
|
|
_no_split_modules = ["LongT5Block"]
|
||
|
|
|
||
|
|
@property
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5PreTrainedModel.dummy_inputs
|
||
|
|
def dummy_inputs(self):
|
||
|
|
input_ids = torch.tensor(DUMMY_INPUTS)
|
||
|
|
input_mask = torch.tensor(DUMMY_MASK)
|
||
|
|
dummy_inputs = {
|
||
|
|
"decoder_input_ids": input_ids,
|
||
|
|
"input_ids": input_ids,
|
||
|
|
"decoder_attention_mask": input_mask,
|
||
|
|
}
|
||
|
|
return dummy_inputs
|
||
|
|
|
||
|
|
def _init_weights(self, module):
|
||
|
|
"""Initialize the weights"""
|
||
|
|
factor = self.config.initializer_factor # Used for testing weights initialization
|
||
|
|
if isinstance(module, LongT5LayerNorm):
|
||
|
|
module.weight.data.fill_(factor * 1.0)
|
||
|
|
elif isinstance(module, (LongT5Model, LongT5ForConditionalGeneration, LongT5EncoderModel)):
|
||
|
|
# Mesh TensorFlow embeddings initialization
|
||
|
|
# See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L1624
|
||
|
|
module.shared.weight.data.normal_(mean=0.0, std=factor * 1.0)
|
||
|
|
if hasattr(module, "lm_head") and not self.config.tie_word_embeddings:
|
||
|
|
module.lm_head.weight.data.normal_(mean=0.0, std=factor * 1.0)
|
||
|
|
elif isinstance(module, LongT5DenseActDense):
|
||
|
|
# Mesh TensorFlow FF initialization
|
||
|
|
# See https://github.com/tensorflow/mesh/blob/master/mesh_tensorflow/transformer/transformer_layers.py#L56
|
||
|
|
# and https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L89
|
||
|
|
module.wi.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
|
||
|
|
if hasattr(module.wi, "bias") and module.wi.bias is not None:
|
||
|
|
module.wi.bias.data.zero_()
|
||
|
|
module.wo.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
|
||
|
|
if hasattr(module.wo, "bias") and module.wo.bias is not None:
|
||
|
|
module.wo.bias.data.zero_()
|
||
|
|
elif isinstance(module, LongT5DenseGatedActDense):
|
||
|
|
module.wi_0.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
|
||
|
|
if hasattr(module.wi_0, "bias") and module.wi_0.bias is not None:
|
||
|
|
module.wi_0.bias.data.zero_()
|
||
|
|
module.wi_1.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_model) ** -0.5))
|
||
|
|
if hasattr(module.wi_1, "bias") and module.wi_1.bias is not None:
|
||
|
|
module.wi_1.bias.data.zero_()
|
||
|
|
module.wo.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_ff) ** -0.5))
|
||
|
|
if hasattr(module.wo, "bias") and module.wo.bias is not None:
|
||
|
|
module.wo.bias.data.zero_()
|
||
|
|
elif isinstance(module, (LongT5Attention, LongT5LocalAttention, LongT5TransientGlobalAttention)):
|
||
|
|
# Mesh TensorFlow attention initialization to avoid scaling before softmax
|
||
|
|
# See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/attention.py#L136
|
||
|
|
d_model = self.config.d_model
|
||
|
|
key_value_proj_dim = self.config.d_kv
|
||
|
|
n_heads = self.config.num_heads
|
||
|
|
module.q.weight.data.normal_(mean=0.0, std=factor * ((d_model * key_value_proj_dim) ** -0.5))
|
||
|
|
module.k.weight.data.normal_(mean=0.0, std=factor * (d_model**-0.5))
|
||
|
|
module.v.weight.data.normal_(mean=0.0, std=factor * (d_model**-0.5))
|
||
|
|
module.o.weight.data.normal_(mean=0.0, std=factor * ((n_heads * key_value_proj_dim) ** -0.5))
|
||
|
|
if module.has_relative_attention_bias:
|
||
|
|
module.relative_attention_bias.weight.data.normal_(mean=0.0, std=factor * ((d_model) ** -0.5))
|
||
|
|
if isinstance(module, LongT5TransientGlobalAttention):
|
||
|
|
module.global_relative_attention_bias.weight.data.normal_(
|
||
|
|
mean=0.0, std=factor * ((d_model) ** -0.5)
|
||
|
|
)
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5PreTrainedModel._shift_right with T5->LongT5
|
||
|
|
def _shift_right(self, input_ids):
|
||
|
|
decoder_start_token_id = self.config.decoder_start_token_id
|
||
|
|
pad_token_id = self.config.pad_token_id
|
||
|
|
|
||
|
|
if decoder_start_token_id is None:
|
||
|
|
raise ValueError(
|
||
|
|
"self.model.config.decoder_start_token_id has to be defined. In LongT5 it is usually set to the pad_token_id. "
|
||
|
|
"See LongT5 docs for more information."
|
||
|
|
)
|
||
|
|
|
||
|
|
# shift inputs to the right
|
||
|
|
if is_torch_fx_proxy(input_ids):
|
||
|
|
# Item assignment is not supported natively for proxies.
|
||
|
|
shifted_input_ids = torch.full(input_ids.shape[:-1] + (1,), decoder_start_token_id)
|
||
|
|
shifted_input_ids = torch.cat([shifted_input_ids, input_ids[..., :-1]], dim=-1)
|
||
|
|
else:
|
||
|
|
shifted_input_ids = input_ids.new_zeros(input_ids.shape)
|
||
|
|
shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
|
||
|
|
shifted_input_ids[..., 0] = decoder_start_token_id
|
||
|
|
|
||
|
|
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`
|
||
|
|
shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
|
||
|
|
|
||
|
|
return shifted_input_ids
|
||
|
|
|
||
|
|
|
||
|
|
class LongT5Stack(LongT5PreTrainedModel):
|
||
|
|
def __init__(self, config, embed_tokens=None):
|
||
|
|
super().__init__(config)
|
||
|
|
|
||
|
|
self.embed_tokens = nn.Embedding(config.vocab_size, config.d_model)
|
||
|
|
if embed_tokens is not None:
|
||
|
|
self.embed_tokens.weight = embed_tokens.weight
|
||
|
|
self.is_decoder = config.is_decoder
|
||
|
|
|
||
|
|
self.local_radius = config.local_radius
|
||
|
|
self.block_len = self.local_radius + 1
|
||
|
|
|
||
|
|
self.block = nn.ModuleList(
|
||
|
|
[LongT5Block(config, has_relative_attention_bias=bool(i == 0)) for i in range(config.num_layers)]
|
||
|
|
)
|
||
|
|
self.final_layer_norm = LongT5LayerNorm(config.d_model, eps=config.layer_norm_epsilon)
|
||
|
|
self.dropout = nn.Dropout(config.dropout_rate)
|
||
|
|
|
||
|
|
self.gradient_checkpointing = False
|
||
|
|
|
||
|
|
# Initialize weights and apply final processing
|
||
|
|
self.post_init()
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5Stack.get_input_embeddings
|
||
|
|
def get_input_embeddings(self):
|
||
|
|
return self.embed_tokens
|
||
|
|
|
||
|
|
# Copied from transformers.models.t5.modeling_t5.T5Stack.set_input_embeddings
|
||
|
|
def set_input_embeddings(self, new_embeddings):
|
||
|
|
self.embed_tokens = new_embeddings
|
||
|
|
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
input_ids=None,
|
||
|
|
attention_mask=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,
|
||
|
|
):
|
||
|
|
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:
|
||
|
|
assert self.embed_tokens is not None, "You have to initialize the model with valid token embeddings"
|
||
|
|
inputs_embeds = self.embed_tokens(input_ids)
|
||
|
|
|
||
|
|
batch_size, seq_length = input_shape
|
||
|
|
|
||
|
|
# required mask seq length can be calculated via length of past
|
||
|
|
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:
|
||
|
|
assert self.is_decoder, f"`use_cache` can only be set to `True` if {self} is used as a decoder"
|
||
|
|
|
||
|
|
if attention_mask is None:
|
||
|
|
attention_mask = torch.ones(batch_size, mask_seq_length, device=inputs_embeds.device)
|
||
|
|
|
||
|
|
# initialize past_key_values with `None` if past does not exist
|
||
|
|
if past_key_values is None:
|
||
|
|
past_key_values = [None] * len(self.block)
|
||
|
|
|
||
|
|
# We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
|
||
|
|
# ourselves in which case we just need to make it broadcastable to all heads.
|
||
|
|
# We use local attention in encoder self-attention, otherwise standard self & cross attentions are used
|
||
|
|
if self.is_decoder:
|
||
|
|
extended_attention_mask = self.get_extended_attention_mask(
|
||
|
|
attention_mask, input_shape, inputs_embeds.device
|
||
|
|
)
|
||
|
|
elif self.config.encoder_attention_type == "local":
|
||
|
|
extended_attention_mask = _get_local_attention_mask(attention_mask, self.block_len, inputs_embeds.device)
|
||
|
|
else: # we need to use both local attention mask and standard extended mask for transient-global attention
|
||
|
|
extended_attention_mask = attention_mask
|
||
|
|
|
||
|
|
# If a 2D or 3D attention mask is provided for the cross-attention
|
||
|
|
# we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
|
||
|
|
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)
|
||
|
|
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:
|
||
|
|
logger.warning_once(
|
||
|
|
"`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
|
||
|
|
)
|
||
|
|
use_cache = False
|
||
|
|
|
||
|
|
# Prepare head mask if needed
|
||
|
|
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 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, # past_key_value is always None with gradient checkpointing
|
||
|
|
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,
|
||
|
|
)
|
||
|
|
|
||
|
|
# layer_outputs is a tuple with:
|
||
|
|
# hidden-states, key-value-states, (self-attention position bias), (self-attention weights), (cross-attention position bias), (cross-attention weights)
|
||
|
|
if use_cache is False:
|
||
|
|
layer_outputs = layer_outputs[:1] + (None,) + layer_outputs[1:]
|
||
|
|
|
||
|
|
hidden_states, present_key_value_state = layer_outputs[:2]
|
||
|
|
|
||
|
|
# We share the position biases between the layers - the first layer store them
|
||
|
|
# layer_outputs = hidden-states, key-value-states (self-attention position bias), (self-attention weights),
|
||
|
|
# (cross-attention position bias), (cross-attention weights)
|
||
|
|
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]
|
||
|
|
# append next layer key value states
|
||
|
|
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],)
|
||
|
|
|
||
|
|
hidden_states = self.final_layer_norm(hidden_states)
|
||
|
|
hidden_states = self.dropout(hidden_states)
|
||
|
|
|
||
|
|
# Add last layer
|
||
|
|
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 BaseModelOutputWithPastAndCrossAttentions(
|
||
|
|
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,
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
LONGT5_START_DOCSTRING = r"""
|
||
|
|
|
||
|
|
The LongT5 model was proposed in [LongT5: Efficient Text-To-Text Transformer for Long
|
||
|
|
Sequences](https://arxiv.org/abs/2112.07916) by Mandy Guo, Joshua Ainslie, David Uthus, Santiago Ontanon, Jianmo
|
||
|
|
Ni, Yun-Hsuan Sung and Yinfei Yang. It's an encoder-decoder transformer pre-trained in a text-to-text denoising
|
||
|
|
generative setting. LongT5 model is an extension of T5 model, and it enables using one of the two different
|
||
|
|
efficient attention mechanisms - (1) Local attention, or (2) Transient-Global attention.
|
||
|
|
|
||
|
|
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 ([`LongT5Config`]): 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.
|
||
|
|
"""
|
||
|
|
|
||
|
|
LONGT5_INPUTS_DOCSTRING = r"""
|
||
|
|
Args:
|
||
|
|
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
|
||
|
|
Indices of input sequence tokens in the vocabulary. LongT5 is a model with relative position embeddings so
|
||
|
|
you should be able to pad the inputs on both the right and the left.
|
||
|
|
|
||
|
|
Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
|
||
|
|
[`PreTrainedTokenizer.__call__`] for detail.
|
||
|
|
|
||
|
|
[What are input IDs?](../glossary#input-ids)
|
||
|
|
|
||
|
|
To know more on how to prepare `input_ids` for pretraining take a look a [LONGT5
|
||
|
|
Training](./longt5#training).
|
||
|
|
attention_mask (`torch.FloatTensor` 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)
|
||
|
|
|
||
|
|
LONGT5 uses the `pad_token_id` as the starting token for `decoder_input_ids` generation. If
|
||
|
|
`past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
|
||
|
|
`past_key_values`).
|
||
|
|
|
||
|
|
To know more on how to prepare `decoder_input_ids` for pretraining take a look at [LONGT5
|
||
|
|
Training](./longt5#training).
|
||
|
|
decoder_attention_mask (`torch.BoolTensor` 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.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
|
||
|
|
Mask to nullify selected heads of the self-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.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
|
||
|
|
Mask to nullify selected heads of the self-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 `(num_heads,)` or `(num_layers, num_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)` 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))` of length `config.n_layers` with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
|
||
|
|
Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up 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.
|
||
|
|
"""
|
||
|
|
|
||
|
|
LONGT5_ENCODER_INPUTS_DOCSTRING = r"""
|
||
|
|
Args:
|
||
|
|
input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
|
||
|
|
Indices of input sequence tokens in the vocabulary. LongT5 is a model with relative position embeddings so
|
||
|
|
you should be able to pad the inputs on both the right and the left.
|
||
|
|
|
||
|
|
Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
|
||
|
|
[`PreTrainedTokenizer.__call__`] for detail.
|
||
|
|
|
||
|
|
To know more on how to prepare `input_ids` for pretraining take a look a [LONGT5
|
||
|
|
Training](./longt5#training).
|
||
|
|
attention_mask (`torch.FloatTensor` 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.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
|
||
|
|
Mask to nullify selected heads of the self-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.
|
||
|
|
"""
|
||
|
|
|
||
|
|
# Warning message for FutureWarning: head_mask was separated into two input args - head_mask, decoder_head_mask
|
||
|
|
__HEAD_MASK_WARNING_MSG = """
|
||
|
|
The input argument `head_mask` was split into two arguments `head_mask` and `decoder_head_mask`. Currently,
|
||
|
|
`decoder_head_mask` is set to copy `head_mask`, but this feature is deprecated and will be removed in future versions.
|
||
|
|
If you do not want to use any `decoder_head_mask` now, please set `decoder_head_mask = torch.ones(num_layers,
|
||
|
|
num_heads)`.
|
||
|
|
"""
|
||
|
|
|
||
|
|
|
||
|
|
@add_start_docstrings(
|
||
|
|
"The bare LONGT5 Model transformer outputting raw hidden-states without any specific head on top.",
|
||
|
|
LONGT5_START_DOCSTRING,
|
||
|
|
)
|
||
|
|
class LongT5Model(LongT5PreTrainedModel):
|
||
|
|
_keys_to_ignore_on_load_unexpected = [
|
||
|
|
r"decoder.block.0.layer.1.EncDecAttention.relative_attention_bias.weight",
|
||
|
|
]
|
||
|
|
_tied_weights_keys = ["encoder.embed_tokens.weight", "decoder.embed_tokens.weight"]
|
||
|
|
|
||
|
|
def __init__(self, config: LongT5Config):
|
||
|
|
super().__init__(config)
|
||
|
|
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 = LongT5Stack(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 = LongT5Stack(decoder_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, new_embeddings):
|
||
|
|
self.shared = new_embeddings
|
||
|
|
self.encoder.set_input_embeddings(new_embeddings)
|
||
|
|
self.decoder.set_input_embeddings(new_embeddings)
|
||
|
|
|
||
|
|
def _tie_weights(self):
|
||
|
|
if self.config.tie_word_embeddings:
|
||
|
|
self._tie_or_clone_weights(self.encoder.embed_tokens, self.shared)
|
||
|
|
self._tie_or_clone_weights(self.decoder.embed_tokens, self.shared)
|
||
|
|
|
||
|
|
def get_encoder(self):
|
||
|
|
return self.encoder
|
||
|
|
|
||
|
|
def get_decoder(self):
|
||
|
|
return self.decoder
|
||
|
|
|
||
|
|
def _prune_heads(self, heads_to_prune):
|
||
|
|
"""
|
||
|
|
Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
|
||
|
|
class PreTrainedModel
|
||
|
|
"""
|
||
|
|
for layer, heads in heads_to_prune.items():
|
||
|
|
self.encoder.layer[layer].attention.prune_heads(heads)
|
||
|
|
|
||
|
|
@add_start_docstrings_to_model_forward(LONGT5_INPUTS_DOCSTRING)
|
||
|
|
@replace_return_docstrings(output_type=Seq2SeqModelOutput, config_class=_CONFIG_FOR_DOC)
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
input_ids: Optional[torch.LongTensor] = None,
|
||
|
|
attention_mask: Optional[torch.FloatTensor] = 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.FloatTensor]]] = None,
|
||
|
|
past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
|
||
|
|
inputs_embeds: Optional[torch.Tensor] = None,
|
||
|
|
decoder_inputs_embeds: Optional[torch.Tensor] = None,
|
||
|
|
use_cache: Optional[bool] = None,
|
||
|
|
output_attentions: Optional[bool] = None,
|
||
|
|
output_hidden_states: Optional[bool] = None,
|
||
|
|
return_dict: Optional[bool] = None,
|
||
|
|
) -> Union[Tuple[torch.FloatTensor], Seq2SeqModelOutput]:
|
||
|
|
r"""
|
||
|
|
Returns:
|
||
|
|
|
||
|
|
Example:
|
||
|
|
|
||
|
|
```python
|
||
|
|
>>> from transformers import AutoTokenizer, LongT5Model
|
||
|
|
|
||
|
|
>>> tokenizer = AutoTokenizer.from_pretrained("google/long-t5-local-base")
|
||
|
|
>>> model = LongT5Model.from_pretrained("google/long-t5-local-base")
|
||
|
|
|
||
|
|
>>> # Let's try a very long encoder input.
|
||
|
|
>>> input_ids = tokenizer(
|
||
|
|
... 100 * "Studies have been shown that owning a dog is good for you", return_tensors="pt"
|
||
|
|
... ).input_ids # Batch size 1
|
||
|
|
|
||
|
|
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1
|
||
|
|
|
||
|
|
>>> # forward pass
|
||
|
|
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
|
||
|
|
>>> last_hidden_states = outputs.last_hidden_state
|
||
|
|
```"""
|
||
|
|
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
|
||
|
|
|
||
|
|
# FutureWarning: head_mask was separated into two input args - head_mask, decoder_head_mask
|
||
|
|
if head_mask is not None and decoder_head_mask is None:
|
||
|
|
if self.config.num_layers == self.config.num_decoder_layers:
|
||
|
|
warnings.warn(__HEAD_MASK_WARNING_MSG, FutureWarning)
|
||
|
|
decoder_head_mask = head_mask
|
||
|
|
|
||
|
|
# Encode if needed (training, first prediction pass)
|
||
|
|
if encoder_outputs is None:
|
||
|
|
encoder_outputs = self.encoder(
|
||
|
|
input_ids=input_ids,
|
||
|
|
attention_mask=attention_mask,
|
||
|
|
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]
|
||
|
|
|
||
|
|
# Decode
|
||
|
|
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,
|
||
|
|
)
|
||
|
|
|
||
|
|
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("""LONGT5 Model with a `language modeling` head on top.""", LONGT5_START_DOCSTRING)
|
||
|
|
class LongT5ForConditionalGeneration(LongT5PreTrainedModel):
|
||
|
|
_keys_to_ignore_on_load_unexpected = [
|
||
|
|
r"decoder.block.0.layer.1.EncDecAttention.relative_attention_bias.weight",
|
||
|
|
]
|
||
|
|
_tied_weights_keys = ["encoder.embed_tokens.weight", "decoder.embed_tokens.weight", "lm_head.weight"]
|
||
|
|
|
||
|
|
def __init__(self, config: LongT5Config):
|
||
|
|
super().__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 = LongT5Stack(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 = LongT5Stack(decoder_config, self.shared)
|
||
|
|
|
||
|
|
self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
|
||
|
|
|
||
|
|
# Initialize weights and apply final processing
|
||
|
|
self.post_init()
|
||
|
|
|
||
|
|
def get_input_embeddings(self):
|
||
|
|
return self.shared
|
||
|
|
|
||
|
|
def set_input_embeddings(self, new_embeddings):
|
||
|
|
self.shared = new_embeddings
|
||
|
|
self.encoder.set_input_embeddings(new_embeddings)
|
||
|
|
self.decoder.set_input_embeddings(new_embeddings)
|
||
|
|
|
||
|
|
def _tie_weights(self):
|
||
|
|
if self.config.tie_word_embeddings:
|
||
|
|
self._tie_or_clone_weights(self.encoder.embed_tokens, self.shared)
|
||
|
|
self._tie_or_clone_weights(self.decoder.embed_tokens, self.shared)
|
||
|
|
|
||
|
|
def set_output_embeddings(self, new_embeddings):
|
||
|
|
self.lm_head = new_embeddings
|
||
|
|
|
||
|
|
def get_output_embeddings(self):
|
||
|
|
return self.lm_head
|
||
|
|
|
||
|
|
def get_encoder(self):
|
||
|
|
return self.encoder
|
||
|
|
|
||
|
|
def get_decoder(self):
|
||
|
|
return self.decoder
|
||
|
|
|
||
|
|
@add_start_docstrings_to_model_forward(LONGT5_INPUTS_DOCSTRING)
|
||
|
|
@replace_return_docstrings(output_type=Seq2SeqLMOutput, config_class=_CONFIG_FOR_DOC)
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
input_ids: Optional[torch.LongTensor] = None,
|
||
|
|
attention_mask: Optional[torch.FloatTensor] = 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,
|
||
|
|
past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = 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[torch.FloatTensor], Seq2SeqLMOutput]:
|
||
|
|
r"""
|
||
|
|
labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
|
||
|
|
Labels for computing the sequence classification/regression loss. Indices should be in `[-100, 0, ...,
|
||
|
|
config.vocab_size - 1]`. All labels set to `-100` are ignored (masked), the loss is only computed for
|
||
|
|
labels in `[0, ..., config.vocab_size]`
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
|
||
|
|
Examples:
|
||
|
|
|
||
|
|
```python
|
||
|
|
>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration
|
||
|
|
|
||
|
|
>>> tokenizer = AutoTokenizer.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps")
|
||
|
|
>>> model = LongT5ForConditionalGeneration.from_pretrained(
|
||
|
|
... "Stancld/longt5-tglobal-large-16384-pubmed-3k_steps"
|
||
|
|
... )
|
||
|
|
|
||
|
|
>>> # Let's try a very long input.
|
||
|
|
>>> inputs = tokenizer(100 * "studies have shown that owning a dog is good for you ", return_tensors="pt")
|
||
|
|
>>> input_ids = inputs.input_ids
|
||
|
|
|
||
|
|
>>> outputs = model.generate(input_ids)
|
||
|
|
>>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
|
||
|
|
abstractthe aim of this article is to provide an overview of the literature on the role of dog
|
||
|
|
```"""
|
||
|
|
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
|
||
|
|
|
||
|
|
# FutureWarning: head_mask was separated into two input args - head_mask, decoder_head_mask
|
||
|
|
if head_mask is not None and decoder_head_mask is None:
|
||
|
|
if self.config.num_layers == self.config.num_decoder_layers:
|
||
|
|
warnings.warn(__HEAD_MASK_WARNING_MSG, FutureWarning)
|
||
|
|
decoder_head_mask = head_mask
|
||
|
|
|
||
|
|
# Encode if needed (training, first prediction pass)
|
||
|
|
if encoder_outputs is None:
|
||
|
|
# Convert encoder inputs in embeddings if needed
|
||
|
|
encoder_outputs = self.encoder(
|
||
|
|
input_ids=input_ids,
|
||
|
|
attention_mask=attention_mask,
|
||
|
|
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 labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
|
||
|
|
# get decoder inputs from shifting lm labels to the right
|
||
|
|
decoder_input_ids = self._shift_right(labels)
|
||
|
|
|
||
|
|
# Decode
|
||
|
|
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.config.tie_word_embeddings:
|
||
|
|
# Rescale output before projecting on vocab
|
||
|
|
# See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/transformer.py#L586
|
||
|
|
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))
|
||
|
|
# TODO(thom): Add z_loss https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L666
|
||
|
|
|
||
|
|
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,
|
||
|
|
cross_attn_head_mask=None,
|
||
|
|
use_cache=None,
|
||
|
|
encoder_outputs=None,
|
||
|
|
**kwargs,
|
||
|
|
):
|
||
|
|
# cut decoder_input_ids if past_key_values 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 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:]
|
||
|
|
|
||
|
|
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,
|
||
|
|
"cross_attn_head_mask": cross_attn_head_mask,
|
||
|
|
"use_cache": use_cache,
|
||
|
|
}
|
||
|
|
|
||
|
|
def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
|
||
|
|
return self._shift_right(labels)
|
||
|
|
|
||
|
|
def _reorder_cache(self, past_key_values, beam_idx):
|
||
|
|
# if decoder past is not included in output
|
||
|
|
# speedy decoding is disabled and no need to reorder
|
||
|
|
if past_key_values is None:
|
||
|
|
logger.warning("You might want to consider setting `use_cache=True` to speed up decoding")
|
||
|
|
return past_key_values
|
||
|
|
|
||
|
|
reordered_decoder_past = ()
|
||
|
|
for layer_past_states in past_key_values:
|
||
|
|
# get the correct batch idx from layer past batch dim
|
||
|
|
# batch dim of `past` is at 2nd position
|
||
|
|
reordered_layer_past_states = ()
|
||
|
|
for layer_past_state in layer_past_states:
|
||
|
|
# need to set correct `past` for each of the four key / value states
|
||
|
|
reordered_layer_past_states = reordered_layer_past_states + (
|
||
|
|
layer_past_state.index_select(0, beam_idx.to(layer_past_state.device)),
|
||
|
|
)
|
||
|
|
|
||
|
|
assert reordered_layer_past_states[0].shape == layer_past_states[0].shape
|
||
|
|
assert len(reordered_layer_past_states) == len(layer_past_states)
|
||
|
|
|
||
|
|
reordered_decoder_past = reordered_decoder_past + (reordered_layer_past_states,)
|
||
|
|
return reordered_decoder_past
|
||
|
|
|
||
|
|
|
||
|
|
@add_start_docstrings(
|
||
|
|
"The bare LONGT5 Model transformer outputting encoder's raw hidden-states without any specific head on top.",
|
||
|
|
LONGT5_START_DOCSTRING,
|
||
|
|
)
|
||
|
|
class LongT5EncoderModel(LongT5PreTrainedModel):
|
||
|
|
_tied_weights_keys = ["encoder.embed_tokens.weight"]
|
||
|
|
_keys_to_ignore_on_load_unexpected = [r"decoder"]
|
||
|
|
|
||
|
|
def __init__(self, config: LongT5Config):
|
||
|
|
super().__init__(config)
|
||
|
|
self.shared = nn.Embedding(config.vocab_size, config.d_model)
|
||
|
|
|
||
|
|
encoder_config = copy.deepcopy(config)
|
||
|
|
encoder_config.use_cache = False
|
||
|
|
encoder_config.is_encoder_decoder = False
|
||
|
|
self.encoder = LongT5Stack(encoder_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, new_embeddings):
|
||
|
|
self.shared = new_embeddings
|
||
|
|
self.encoder.set_input_embeddings(new_embeddings)
|
||
|
|
|
||
|
|
def _tie_weights(self):
|
||
|
|
if self.config.tie_word_embeddings:
|
||
|
|
self._tie_or_clone_weights(self.encoder.embed_tokens, self.shared)
|
||
|
|
|
||
|
|
def get_encoder(self):
|
||
|
|
return self.encoder
|
||
|
|
|
||
|
|
def _prune_heads(self, heads_to_prune):
|
||
|
|
"""
|
||
|
|
Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
|
||
|
|
class PreTrainedModel
|
||
|
|
"""
|
||
|
|
for layer, heads in heads_to_prune.items():
|
||
|
|
self.encoder.layer[layer].attention.prune_heads(heads)
|
||
|
|
|
||
|
|
@add_start_docstrings_to_model_forward(LONGT5_ENCODER_INPUTS_DOCSTRING)
|
||
|
|
@replace_return_docstrings(output_type=BaseModelOutput, config_class=_CONFIG_FOR_DOC)
|
||
|
|
def forward(
|
||
|
|
self,
|
||
|
|
input_ids: Optional[torch.LongTensor] = None,
|
||
|
|
attention_mask: Optional[torch.FloatTensor] = None,
|
||
|
|
head_mask: Optional[torch.FloatTensor] = 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[torch.FloatTensor], BaseModelOutput]:
|
||
|
|
r"""
|
||
|
|
Returns:
|
||
|
|
|
||
|
|
Example:
|
||
|
|
|
||
|
|
```python
|
||
|
|
>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration
|
||
|
|
|
||
|
|
>>> tokenizer = AutoTokenizer.from_pretrained("google/long-t5-local-base")
|
||
|
|
>>> model = LongT5EncoderModel.from_pretrained("google/long-t5-local-base")
|
||
|
|
>>> input_ids = tokenizer(
|
||
|
|
... 100 * "Studies have been shown that owning a dog is good for you ", return_tensors="pt"
|
||
|
|
... ).input_ids # Batch size 1
|
||
|
|
>>> outputs = model(input_ids=input_ids)
|
||
|
|
>>> last_hidden_states = outputs.last_hidden_state
|
||
|
|
```"""
|
||
|
|
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
|
||
|
|
|
||
|
|
encoder_outputs = self.encoder(
|
||
|
|
input_ids=input_ids,
|
||
|
|
attention_mask=attention_mask,
|
||
|
|
inputs_embeds=inputs_embeds,
|
||
|
|
head_mask=head_mask,
|
||
|
|
output_attentions=output_attentions,
|
||
|
|
output_hidden_states=output_hidden_states,
|
||
|
|
return_dict=return_dict,
|
||
|
|
)
|
||
|
|
|
||
|
|
return encoder_outputs
|