import torch from torch import nn from DilatedTransformerLayer import DilatedTransformerLayer from torch.nn import TransformerEncoderLayer as torchTransformerEncoderLayer class Demixed_DilatedTransformerModel(nn.Module): def __init__(self, attn_len=5, instr=5, ntoken=2, dmodel=128, nhead=2, d_hid=512, nlayers=9, norm_first=True, dropout=.1): super(Demixed_DilatedTransformerModel, self).__init__() self.nhead = nhead self.nlayers = nlayers self.attn_len = attn_len self.head_dim = dmodel // nhead self.dmodel = dmodel assert self.head_dim * nhead == dmodel, "embed_dim must be divisible by num_heads" self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(5, 3), stride=1, padding=(2, 0))#126 self.maxpool1 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#42 self.dropout1 = nn.Dropout(p=dropout) self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(1, 12), stride=1, padding=(0, 0))#31 self.maxpool2 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#10 self.dropout2 = nn.Dropout(p=dropout) self.conv3 = nn.Conv2d(in_channels=64, out_channels=dmodel, kernel_size=(3, 6), stride=1, padding=(1, 0))#5 self.maxpool3 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#1 self.dropout3 = nn.Dropout(p=dropout) self.Transformer_layers = nn.ModuleDict({}) for idx in range(nlayers): self.Transformer_layers[f'time_attention_{idx}'] = DilatedTransformerLayer(dmodel, nhead, d_hid, dropout, Er_provided=False, attn_len=attn_len, norm_first=norm_first) if (idx >= 3) and (idx <= 5): self.Transformer_layers[f'instr_attention_{idx}'] = torchTransformerEncoderLayer(dmodel, nhead, d_hid, dropout, batch_first=True, norm_first=norm_first) self.out_linear = nn.Linear(dmodel, ntoken) self.dropout_t = nn.Dropout(p=.5) self.out_linear_t = nn.Linear(dmodel, 300) def forward(self, x): #x: (batch, instr, time, dmodel), FloatTensor batch, instr, time, melbin = x.shape x = x.reshape(-1, 1, time, melbin) x = self.conv1(x) x = self.maxpool1(x) x = torch.relu(x) x = self.dropout1(x) x = self.conv2(x) x = self.maxpool2(x) x = torch.relu(x) x = self.dropout2(x) x = self.conv3(x) x = self.maxpool3(x) x = torch.relu(x) x = self.dropout3(x) #(batch*instr, channel, time, 1) x = x.reshape(-1, self.dmodel, time).transpose(1, 2) #(batch*instr, time, channel=dmodel) t = [] for layer in range(self.nlayers): x, skip = self.Transformer_layers[f'time_attention_{layer}'](x, layer=layer) skip = skip.reshape(batch, instr, time, self.dmodel) t.append(skip.mean(1)) if (layer >= 3) and (layer <= 5): x = x.reshape(batch, instr, time, self.dmodel) x = x.permute(0, 2, 1, 3) x = x.reshape(-1, instr, self.dmodel) x = self.Transformer_layers[f'instr_attention_{layer}'](x) x = x.reshape(batch, time, instr, self.dmodel) x = x.permute(0, 2, 1, 3) x = x.reshape(-1, time, self.dmodel) x = torch.relu(x) x = x.reshape(batch, instr, time, self.dmodel) x = x.mean(1) x = self.out_linear(x) t = torch.stack(t, axis=-1).sum(dim=-1) t = torch.relu(t) t = self.dropout_t(t) t = t.mean(dim=1) #(batch, dmodel) t = self.out_linear_t(t) return x, t def inference(self, x): #x: (batch, instr, time, dmodel), FloatTensor #This inference method also outputs the cumulative attention matrix batch, instr, time, melbin = x.shape x = x.reshape(-1, 1, time, melbin) x = self.conv1(x) x = self.maxpool1(x) x = torch.relu(x) x = self.dropout1(x) x = self.conv2(x) x = self.maxpool2(x) x = torch.relu(x) x = self.dropout2(x) x = self.conv3(x) x = self.maxpool3(x) x = torch.relu(x) x = self.dropout3(x) #(batch*instr, channel, time, 1) x = x.reshape(-1, self.dmodel, time).transpose(1, 2) #(batch*instr, time, channel=dmodel) t = [] attn = [torch.eye(time, device=x.device).repeat(batch, self.nhead, 1, 1)] for layer in range(self.nlayers): x, skip, layer_attn = self.Transformer_layers[f'time_attention_{layer}'].inference(x, layer=layer) skip = skip.reshape(batch, instr, time, self.dmodel) t.append(skip.mean(1)) attn.append(torch.matmul(attn[-1], layer_attn.transpose(-2, -1))) if (layer >= 3) and (layer <= 5): x = x.reshape(batch, instr, time, self.dmodel) x = x.permute(0, 2, 1, 3) x = x.reshape(-1, instr, self.dmodel) x = self.Transformer_layers[f'instr_attention_{layer}'](x) x = x.reshape(batch, time, instr, self.dmodel) x = x.permute(0, 2, 1, 3) x = x.reshape(-1, time, self.dmodel) x = torch.relu(x) x = x.reshape(batch, instr, time, self.dmodel) x = x.mean(1) x = self.out_linear(x) t = torch.stack(t, axis=-1).sum(dim=-1) t = torch.relu(t) t = self.dropout_t(t) t = t.mean(dim=1) #(batch, dmodel) t = self.out_linear_t(t) return x, t, attn if __name__ == '__main__': from spectrogram_dataset import audioDataset from torch.utils.data import DataLoader DEVICE = 'cuda:0' model = Demixed_DilatedTransformerModel(attn_len=5, instr=5, ntoken=2, dmodel=256, nhead=8, d_hid=1024, nlayers=9, norm_first=True, dropout=.1) model.to(DEVICE) model.eval() for name, param in model.state_dict().items(): print(name, param.shape) # name: str # param: Tensor total = sum([param.nelement() for param in model.parameters()]) print(total) #print("Number of parameter: %.2fM" % (total/1e6))