Beat-Transformer/code/ablation_models/music_transformer.py

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])