import math
from numpy import transpose
import torch
import torch.nn.functional as F
from torch import nn
from torch.nn.modules.normalization import LayerNorm
from torch.nn import Transformer
import copy
class MultiheadAttentionwithRelativePositionalEmbedding(nn.Module):
def __init__(self, dmodel, num_heads, dropout=0, Er_provided=False, max_len=3):
super(MultiheadAttentionwithRelativePositionalEmbedding, self).__init__()
self.L = 2 * max_len - 1
self.num_heads = num_heads
self.max_len = max_len
self.head_dim = dmodel // num_heads
assert self.head_dim * num_heads == dmodel, "embed_dim must be divisible by num_heads"
self.key = nn.Linear(dmodel, dmodel)
self.value = nn.Linear(dmodel, dmodel)
self.query = nn.Linear(dmodel, dmodel)
self.dropout = nn.Dropout(dropout)
self.Er_provided = Er_provided
self.num_heads = num_heads
if not Er_provided:
self.Er = nn.Parameter(torch.randn(num_heads, self.L, self.head_dim))
def forward(self, query, key, value, Er=None, layer=0, attn_mask=None):
#x: (batch, len, dmodel)
#Srel: (num_head, tgt_len, src_len)
#attn_mask: (batch, num_head, tgt_len, src_len): float tensor
bs, tgt_len, d_model = query.shape
_, src_len, _ = key.shape
q = self.query(query).reshape(bs, tgt_len, self.num_heads, self.head_dim).transpose(1, 2) #(batch, num_head, tgt_len, head_dim)
k = self.key(key).reshape(bs, src_len, self.num_heads, self.head_dim).permute(0, 2, 3, 1) #(batch, num_head, head_dim, src_len)
v = self.value(value).reshape(bs, src_len, self.num_heads, self.head_dim).transpose(1, 2) #(batch, num_head, src_len, head_dim)
Er_t = torch.zeros(self.num_heads, 2*src_len-1, self.head_dim, device=query.device)
dilation_len = min(1 + (src_len-1)//(2**layer), self.max_len)
if not self.Er_provided:
Er_t[:, [src_len-1 + i*(2**layer) for i in range(-dilation_len+1, dilation_len)], :] = self.Er[:, self.max_len-dilation_len: self.max_len+dilation_len-1, :]
else:
Er_t[:, [src_len-1 + i*(2**layer) for i in range(-dilation_len+1, dilation_len)], :] = Er[:, self.max_len-dilation_len: self.max_len+dilation_len-1, :]
Er_t = Er_t.transpose(-2, -1) #(num_head, head_dim, src_L)
QEr = torch.matmul(q, Er_t) #(num_head, num_head, tgt_len, src_L)
#print(QEr[0, 0])
Srel = self.skew(QEr, src_len) #(num_head, num_head, tgt_len, src_len)
#print('Srel', Srel[1, 1])
attn = (torch.matmul(q, k) + Srel) / math.sqrt(self.head_dim) #(batch, num_head, tgt_len, src_len)
if attn_mask is not None:
#print(attn.shape, attn_mask.shape)
attn += attn_mask
#for i in range(attn.shape[0]):
# print(attn_mask[i, 0])
attn = F.softmax(attn, dim=-1)
out = torch.matmul(attn, v) #(batch, num_head, tgt_len, head_dim)
out = out.transpose(1, 2).reshape(bs, tgt_len, d_model) #(batch, tgt_len, d_model)
return self.dropout(out), attn
def skew(self, QEr, src_len):
#QEr: (batch, num_heads, tgt_len, src_L)
bs, num_heads, tgt_len, src_L = QEr.shape
QEr = F.pad(QEr, (0, 1)) #(batch, num_heads, tgt_len, src_L+1)
QEr = QEr.reshape(bs, num_heads, -1) #(batch, num_heads, tgt_len*(src_L+1))
QEr = F.pad(QEr, (0, src_L-tgt_len)) #(batch, num_heads, (tgt_len+1)*src_L)
QEr = QEr.reshape(bs, num_heads, tgt_len+1, src_L)
QEr = QEr[:, :, :tgt_len, -src_len:] #(batch, num_heads, tgt_len, src_len)
return QEr
class TransformerEncoderLayer(nn.Module):
def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, Er_provided=False, max_len=3, layer_norm_eps=1e-5, norm_first=False):
super(TransformerEncoderLayer, self).__init__()
self.self_attn = MultiheadAttentionwithRelativePositionalEmbedding(d_model, nhead, dropout, Er_provided, max_len)
# Implementation of Feedforward model
self.linear1 = nn.Linear(d_model, dim_feedforward)
self.dropout = nn.Dropout(dropout)
self.linear2 = nn.Linear(dim_feedforward, d_model)
self.norm_first = norm_first
self.norm1 = LayerNorm(d_model, eps=layer_norm_eps)
self.norm2 = LayerNorm(d_model, eps=layer_norm_eps)
self.dropout1 = nn.Dropout(dropout)
self.dropout2 = nn.Dropout(dropout)
self.activation = F.gelu
def forward(self, x, Er=None, layer=0, src_mask=None):
#x: (batch, len, dmodel)
#Er: (num_head, tgt_len, src_len)
#key_padding_mask: (batch, num_head, tgt_len, src_len), bool tensor
#attn_mask: (batch, num_head, tgt_len, src_len): float tensor
if self.norm_first:
x = x + self._sa_block(self.norm1(x), Er, layer, src_mask)
x = x + self._ff_block(self.norm2(x))
else:
x = self.norm1(x + self._sa_block(x, Er, layer, src_mask))
x = self.norm2(x + self._ff_block(x))
return x
# self-attention block
def _sa_block(self, x, Er=None, layer=0, attn_mask=None):
x = self.self_attn(x, x, x, Er, layer, attn_mask=attn_mask)[0]
return self.dropout1(x)
# feed forward block
def _ff_block(self, x):
x = self.linear2(self.dropout(self.activation(self.linear1(x))))
return self.dropout2(x)
def generate_dilation_self_attention_mask(batch, num_head, seq_len, max_len, layer):
attn_mask = torch.eye(seq_len).repeat(batch, num_head, 1, 1)
mask_temp = torch.eye(seq_len).repeat(batch, num_head, 1, 1)
for i in range(1, max_len):
attn_mask[:, :, : -i*(2**layer), i*(2**layer):] += mask_temp[:, :, i*(2**layer):, i*(2**layer):]
attn_mask[:, :, i*(2**layer):, : -i*(2**layer)] += mask_temp[:, :, i*(2**layer):, i*(2**layer):]
attn_mask = (1-attn_mask).masked_fill((attn_mask == 0), -float('inf'))
return attn_mask
if __name__ == '__main__':
MAX_LEN=3
LAYER=0
model = MultiheadAttentionwithRelativePositionalEmbedding(dmodel=12, num_heads=6, max_len=MAX_LEN)
x = torch.ones(3, 8, 12)
attn_mask = generate_dilation_self_attention_mask(3, 6, 8, MAX_LEN, LAYER)
#print(attn_mask[1, 1, :, :].numpy())
output, attn = model(x, x, x, attn_mask=attn_mask, layer=LAYER)
#print(attn[1, 1])