import torch from torch import nn from DilatedTransformerLayer import DilatedTransformerLayer class DilatedTransformerModel(nn.Module): def __init__(self, attn_len=5, ntoken=2, dmodel=128, nhead=2, d_hid=512, nlayers=9, norm_first=True, dropout=.1): super(DilatedTransformerModel, self).__init__() self.nhead = nhead self.nlayers = nlayers self.attn_len = attn_len self.head_dim = dmodel // nhead assert self.head_dim * nhead == dmodel, "embed_dim must be divisible by num_heads" #self.Er = nn.Parameter(torch.randn(nlayers, nhead, self.head_dim, attn_len)) self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(5, 3), stride=1, padding=(2, 0))#126 #self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(3, 3), stride=1, padding=(1, 0))#79 self.maxpool1 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#26 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.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(1, 12), stride=1, padding=(0, 0))#15 self.maxpool2 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#5 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.conv3 = nn.Conv2d(in_channels=64, out_channels=dmodel, kernel_size=(3, 3), stride=1, padding=(1, 0))#3 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'Transformer_layer_{idx}'] = DilatedTransformerLayer(dmodel, nhead, d_hid, dropout, Er_provided=False, attn_len=attn_len, 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, time, dmodel), FloatTensor x = x.unsqueeze(1) #(batch, channel, time, dmodel) 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, channel, time, 1) x = x.transpose(1, 3).squeeze(1).contiguous() #(batch, time, channel=dmodel) batch, time, dmodel = x.shape t = [] for layer in range(self.nlayers): x, skip = self.Transformer_layers[f'Transformer_layer_{layer}'](x, layer=layer) t.append(skip) x = torch.relu(x) 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, time, dmodel), FloatTensor x = x.unsqueeze(1) #(batch, channel, time, dmodel) 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, channel, time, 1) x = x.transpose(1, 3).squeeze(1).contiguous() #(batch, time, channel=dmodel) batch, time, dmodel = x.shape 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'Transformer_layer_{layer}'].inference(x, layer=layer) t.append(skip) attn.append(torch.matmul(attn[-1], layer_attn.transpose(-2, -1))) x = torch.relu(x) 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 non_demix_spectrogram_dataset import audioDataset from torch.utils.data import DataLoader from tqdm import tqdm import numpy as np import madmom from utils import AverageMeter SAMPLE_SIZE = int(44100 / 1024 * 180) INSTR =5 FPS = 44100 / 1024 NUM_FOLDS = 8 #model NORM_FIRST=True ATTN_LEN=5 NTOKEN=2 DMODEL=256 NHEAD=8 DHID=512 NLAYER=9 DROPOUT=.1 DEVICE=f'cuda:{0}' TRAIN_BATCH_SIZE = 1 DATASET_PATH = './data/demix_spectrogram_data.npz' ANNOTATION_PATH = './data/full_beat_annotation.npz' DATA_TO_LOAD = ['gtzan'] TEST_ONLY = ['gtzan'] model = DilatedTransformerModel(attn_len=ATTN_LEN, ntoken=NTOKEN, dmodel=DMODEL, nhead=NHEAD, d_hid=DHID, nlayers=NLAYER, norm_first=NORM_FIRST, dropout=DROPOUT ) model.load_state_dict(torch.load("/mnt/c/Users/zhaoj/Desktop/trf_param_018.pt", map_location=torch.device(DEVICE))) model.to(DEVICE) dataset = audioDataset(data_to_load=DATA_TO_LOAD, test_only_data = TEST_ONLY, data_path = DATASET_PATH, annotation_path = ANNOTATION_PATH, fps = FPS, sample_size = SAMPLE_SIZE, num_folds = 1) _, _, test_set = dataset.get_fold(fold=0) #loader = DataLoader(val_set, batch_size=1, shuffle=False) loader = DataLoader(test_set, batch_size=1, shuffle=False) beat_DBN_meter = AverageMeter() downbeat_DBN_meter = AverageMeter() beat_tracker = madmom.features.beats.DBNBeatTrackingProcessor(min_bpm=55.0, max_bpm=215.0, fps=FPS, transition_lambda=100, observation_lambda=6, num_tempi=None, threshold=0.2) downbeat_tracker = madmom.features.downbeats.DBNDownBeatTrackingProcessor(beats_per_bar=[3, 4], min_bpm=55.0, max_bpm=215.0, fps=FPS, transition_lambda=100, observation_lambda=6, num_tempi=None, threshold=0.2) activations = {} beat_gt = {} downbeat_gt = {} count = 0 with torch.no_grad(): for idx, (dataset_key, data, beat, downbeat, tempo, root) in tqdm(enumerate(loader), total=len(loader)): #data data = data.float().to(DEVICE) print(data.shape) pred, _ = model(data) beat_pred = torch.sigmoid(pred[0, :, 0]).detach().cpu().numpy() downbeat_pred = torch.sigmoid(pred[0, :, 1]).detach().cpu().numpy() beat = torch.nonzero(beat[0]>.5)[:, 0].detach().numpy() / (FPS) downbeat = torch.nonzero(downbeat[0]>.5)[:, 0].detach().numpy() / (FPS) dataset_key = dataset_key[0] root = root[0] if not dataset_key in activations: activations[dataset_key] = [] beat_gt[dataset_key] = [] downbeat_gt[dataset_key] = [] activations[dataset_key].append(np.stack((beat_pred, downbeat_pred), axis=0)) beat_gt[dataset_key].append(beat) downbeat_gt[dataset_key].append(downbeat) #count += 1 #if count == 50: # break for dataset_key in activations: print(f'inferencing on {dataset_key} ...') beat_error = 0 downbeat_error = 0 for i in tqdm(range(len(activations[dataset_key]))): pred = activations[dataset_key][i] #print(pred.shape) beat = beat_gt[dataset_key][i] downbeat = downbeat_gt[dataset_key][i] try: dbn_beat_pred = beat_tracker(pred[0]) beat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_beat_pred, beat) beat_DBN_meter.update(f'{dataset_key}-fmeasure', beat_score_DBN.fmeasure) beat_DBN_meter.update(f'{dataset_key}-cmlt', beat_score_DBN.cmlt) beat_DBN_meter.update(f'{dataset_key}-amlt', beat_score_DBN.amlt) except Exception as e: #print(f'beat inference encounter exception {e}') beat_error += 1 try: combined_act = np.concatenate((np.maximum(pred[0] - pred[1], np.zeros(pred[0].shape))[:, np.newaxis], pred[1][:, np.newaxis]), axis=-1) #(T, 2) #print(combined_act.shape) dbn_downbeat_pred = downbeat_tracker(combined_act) dbn_downbeat_pred = dbn_downbeat_pred[dbn_downbeat_pred[:, 1]==1][:, 0] downbeat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_downbeat_pred, downbeat) downbeat_DBN_meter.update(f'{dataset_key}-fmeasure', downbeat_score_DBN.fmeasure) downbeat_DBN_meter.update(f'{dataset_key}-cmlt', downbeat_score_DBN.cmlt) downbeat_DBN_meter.update(f'{dataset_key}-amlt', downbeat_score_DBN.amlt) except Exception as e: #print(f'downbeat inference encounter exception {e}') downbeat_error += 1 print(f'beat error: {beat_error}; downbeat error: {downbeat_error}') print('DBN beat detection') for key in beat_DBN_meter.avg.keys(): print('\t', key, beat_DBN_meter.avg[key]) print('DBN downbeat detection') for key in downbeat_DBN_meter.avg.keys(): print('\t', key, downbeat_DBN_meter.avg[key])